The End of IDEs and Agentic CLIs? ADEs Have Arrived

Even though my gray hair gives me away, you can probably guess I’ve been developing software for quite a while.

But the truth is, when I started programming back in 2003, IDEs already existed. I’ve always lived with them, and they feel completely natural to me.

Programming in an IDE has made us much more efficient, able to generate more complex code in less time, and above all, it’s allowed us to stop relying on our brainpower to write valid code.

That function you can’t remember how to write, that closing semicolon. Even IDEs like JetBrains’ were pioneers in helping us refactor code, making sure it wouldn’t break.

Programming can’t exist without the IDE.

Or can it?

We might not all agree on how much AI we should use for development, but what’s undeniable is that this is a revolution equal to or even greater than the arrival of IDEs.

And, interestingly, it seems it could also be their end.

AI as an IDE Assistant

When GitHub Copilot appeared, it kind of blew everyone’s mind. An autocomplete so smart that our job basically became hitting TAB on the suggestions it offered.

After wearing out the tab key, we realized maybe that wasn’t the way forward.

If what we wanted was for it to generate our code—or at least part of it—it didn’t make much sense to have to manually accept almost every line. By then, we already had a chat on the side where we could ask questions, and it would take our code as context.

And that’s when the paradigm shift happened: let the AI modify our code. Some people were quick to see the potential here, creating the now-famous agentic IDEs, or AI-powered IDEs.

Every repetitive task a human does can be made more efficient with AI. With Cursor as the biggest example, everyone started moving in that direction.

But this only seemed like a patch for what was coming next.

The Rise of Agentic CLIs

IDEs only sped up our classic workflow. But… what if there was another way?

Claude Code came along to prove there was. If our goal was simply to generate code, we needed tools that were really good at it and leave the review for the final step.

For that, we didn’t need to be constantly in the IDE. We could work from a terminal.

Or, even better, from many terminal instances.

Because if we’re not going to review every step the agent takes, what’s stopping us from having one working on a feature, another fixing a bug, another updating the documentation?

Or even working on several projects at once.

The terminal allows this, but it’s true that it’s not the friendliest tool. Some people, of course, feel very comfortable with it, but some of us ended up there because there was no other option with the same versatility.

Still, in my case, I’d been working with CLIs since July of last year. The first few months with Claude, and since September with Codex CLI.

Until Codex App arrived.

Agent Development Environment

That’s what ADE stands for, in case you’ve been wondering all this time 😄

The first time I seriously tried one, without knowing this name was being coined, was with Codex App.

I’ve been seriously trying out Codex App as a software development tool.

What’s interesting isn’t “that it writes code,” but how it manages state, context, and flow when there are several tasks at once.

The question is: is it better than the CLI, or is it still preferable to use it in the terminal?

See post

And shortly after, I reflected:

I think Codex App is more like an IDE adapted to the new era than the classic alternatives like Cursor, Windsurf, and the rest.

In Codex App, the focus is on agent orchestration, not on the code.

The fact is, we’re going to review less and less code, and especially write less, so taking up most of the workspace with code isn’t practical.

See post

If the new paradigm is managing agents in parallel, then an IDE where code is the center just isn’t enough.

Here we focus on:

• Orchestrating agents: the process isn’t sequential, it’s parallel, so being able to move easily between them is key.
• Letting them work without stepping on each other: for a personal project, having 4 agents working on main might be tolerable for a while. But this doesn’t scale. These tools have the concept of worktrees built in from the start.
• Review is still there: it doesn’t disappear, it’s just relegated to a side section you open when you need it. Code is no longer the center.

A few days later, I read from someone—sorry, I can’t remember who—that they were moving to Cursor to keep working on what they considered the future: ADEs.

And that’s where I first heard the concept. I also realized this wasn’t anything new:

• Cursor has its Agent Mode.
• Antigravity has its Agent Manager.
• And just yesterday, JetBrains introduced Air, which they themselves define as an ADE.

I’m sure I’m missing many others that, either recently or for a while now, offer similar interfaces.

But it seems all the big players are moving in that direction.

We’re Not Ready for This Change

I’m not saying it’s not the future, but it’s definitely not the present. At least not for most developers.

I’m a firm believer in using AI for software development. I’m convinced that if you decide not to use it, you’re shooting yourself in the foot when it comes to your career as a developer.

People who use it wisely and with understanding are much more productive, able to maintain or even surpass the quality of code they used to produce.

But that’s not the vast majority. Many people today don’t even have the knowledge to get a single agent to develop code properly, following their own rules and delivering quality results.

We’ve been sold the idea that AI is magic, and that with a well-written prompt we get perfect results.

And that’s just not true. You need very solid knowledge about how to provide the right ecosystem for them to work:

Context (static and dynamic), guardrails, validations, workflows…

You don’t learn this in two days. This is exactly the kind of work we do in AI Expert, and I’m more convinced than ever that six intensive weeks is barely enough.

And what we’re seeing in many companies is the opposite:

They give people a subscription to the latest AI and tell them they have to be more productive starting the next day.

The damage a single agent can do is huge. Now imagine running 3, 4… 10! agents in parallel.

That’s why I think the industry still needs to mature in its use of AI to really take advantage of this way of working.

Will we get there? My opinion is yes, and there are even people for whom this is already their best tool. I myself use Codex App as my development tool.

But for the average person who isn’t riding the wave all the time, this is light-years away from what they can even consider today.

My Recommendation

If you’re just starting out with AI, the first thing you need to achieve is getting a single agent to do the job exactly how you want.

Start by delegating very small tasks, validating the results line by line, adjusting the context every time it does something that doesn’t match what you wanted.

Little by little, you’ll delegate more tasks. Maybe a bigger feature, later a full commit, later even letting it review a PR—but always when everything before has been validated.

You should get used to the tool, and the tool should do what you expect.

Before coordinating ten agents, make sure you know how to work well with one.

And if you want to speed all this up, we can meet in May at AI Expert 😊