When did you last open your IDE?
Genuinely, think about it. The last time I opened VS Code wasn't to review something an agent had written — it was to actually sit down and write code, line by line.
If your answer is "last month," welcome to the ADE era.
ADE stands for Agentic Development Environment. Warp coined the term in mid-2025, but the thing it describes is now happening across the whole industry. Cursor has repositioned from "AI IDE" to agent orchestration platform. Augment Code launched a product called Intent with the keynote title IDE is dead.
The IDE isn't dead. It's been demoted. From the main screen you work in to one of several screens.
Whatever is taking its seat — Cursor Glass, Warp Oz, cmux, Conductor — they're all doing the same thing: turning you from the person writing code into the person directing agents.
What actually changed
The IDE optimises a loop: open file → edit → build → debug → repeat. The entire UI is designed around you editing a file.
The ADE optimises a different loop: state intent → dispatch agents → watch progress → review diffs → merge. The entire UI is designed around you managing a fleet of agents.
The difference is not "a chat panel was added." The difference is who the protagonist is.
In the IDE, you're the protagonist; AI is an assistant. In the ADE, agents are the executors; you're the commander. Your job shifts from write code to define intent + review results.
This transition is a cliff, not a slope. Once you've gotten used to telling an agent what to do and reviewing the result, you don't go back. The same way you don't go back from driving to riding a horse.
This isn't a forecast — it's the current numbers
Claude Code shipped in May 2025. Six months later, ARR crossed $1B. By early 2026, $2.5B. A terminal-native agent — no GUI at all — is monetising faster than ChatGPT did at the same age. Developers are paying for a tool without a window faster than the rest of the world paid for chatbots.
Pragmatic Engineer's 15,000-developer survey: Claude Code 41% usage, overtaking GitHub Copilot's 38%. Satisfaction is even more lopsided — 46% pick Claude Code as their favourite, only 9% pick Copilot.
Cursor ARR crossed $2B, 60% from enterprise. Stack Overflow's 2025 survey: 84% of developers use AI tools, 51% daily. Gartner projects 90% of engineers will use AI assistants by 2028, with the role shifting from implementation to orchestration.
The move from IDE to ADE isn't a future trend. It already happened.
Cursor 1.0 → 3.0: the demotion in three acts
Cursor 1.0 — a VS Code fork with smarter tab completion.
Cursor Composer 2 benchmark: their in-house model catching up to the frontier.
Cursor 3.0 Agents Window: parallel agents, cloud execution, diff-first review.
Cursor's history is the cleanest narrative thread. Over three years, they showed — version by version — how the editor stops being the protagonist.
1.0 (2023). An IDE with a smart plugin. A VS Code fork with better tab completion. The editor is the absolute main character; AI is a small assistant in the sidebar. The positioning is explicit: AI IDE.
2.0 (2025). Editor and agent in a tug of war. Composer for multi-file edits, Agent Mode, Background Agents. Up to 8 agents in parallel. But the editor is still the main surface; agents are stuffed into a sidebar.
3.0 Glass (April 2026). "The IDE? Open it when you actually need it." Full rewrite. The chat panel is gone. In its place: the Agents Window — a dedicated orchestration surface for parallel agents. CEO Michael Truell frames AI coding in three eras: autocomplete → synchronous Copilot → autonomous agent. Glass is the third-era product. Cloud agents run in isolated VMs. Cloud Handoff moves a local task to the cloud seamlessly. Design Mode lets you annotate UI elements in a browser preview and hand them to the agent.
Cursor 1.0 → 3.0 reads as IDE plus AI plugin → IDE plus AI assistant → ADE that happens to contain an editor. The editor went from lead to supporting role.
The terminal is back, and that's the unexpected battleground
Ghostty: Mitchell Hashimoto's (HashiCorp) Zig-written, GPU-accelerated terminal.
cmux: a vertical tab bar showing each agent's git branch, PR status, and working directory.
cmux notification ring: agent done → green, needs attention → blue, error → red.
Warp: Terminal on the left for local agents, Oz on the right for cloud orchestration.
The hottest developer-tool category in 2026 isn't the IDE. It's the terminal emulator. Yes, the black rectangle.
Why? Because agents need a terminal. Humans can patch over a bad tool with aliases, .zshrc edits, and muscle memory. Agents can't. They need the underlying primitives to be there. That's forcing the terminal into the modern era — GPU rendering, embedded browser, programmable APIs, notification systems.
Ghostty. Mitchell Hashimoto's Zig-written, GPU-accelerated terminal. 1.0 shipped late 2024. Already past 45K GitHub stars. Roughly 4× iTerm2 throughput. Hashimoto's own observation is interesting: he did not expect terminal usage to increase, and he really did not expect to be talking to AI coding companies on a regular basis. They are now his biggest users. The core component libghostty is becoming an ecosystem — cmux is built on top of it. As a tell: Jarred Sumner (Anthropic, Claude Code infra) demoed inside Ghostty by rendering the entire bun.sh website inside a single terminal command.
cmux. Manaflow (YC), built on libghostty, native Swift. Crossed 10K stars in two months. The problem it solves is concrete: when you have five Claude Code sessions running, which one needs your attention right now? The notification ring tells you — green for completed, blue for needs-input, red for error. The creator's framing is the philosophy: "cmux is a pattern, not a solution." Different from Cursor Glass or Warp Oz — building blocks, not a finished product. I personally use cmux while running multiple Claude Code instances, and the notification ring is worth more than it sounds.
Warp. Founded in 2020 as the 21st-century terminal, repositioned in the 2.0 launch (2025) as the world's first ADE. Warp coined the term. In 2025 their agent edited 3.2B lines of code across 120K indexed repos. In 2026 they launched Oz, a cloud orchestration platform supporting Full Terminal Use (agents on a real PTY session) and Computer Use (agents in cloud sandboxes operating a GUI). The transition cost them, though — old terminal users felt betrayed, new agent users felt under-served, and forcing a login on a terminal drove power users away. Community split is the sharpest cost of ADE transition.
How the IDE incumbents are responding
VS Code: "I won't be an ADE, but every ADE needs me." MCP support across all models, a free Copilot tier. The strategy is to be the platform, not the product — to make sure every tool sits on top of VS Code. The risk is that as the developer's home screen moves from editor to agent console, the value of editor platform shrinks.
JetBrains: technical edge, pricing misstep. Junie can use the IDE's deep semantic understanding — generate code, run tests, auto-fix on failure. A pure-terminal agent can't do that. But their pricing change went sideways — the annual subscription's quota shrank from three weeks to four hours, with some Marketplace reviewers calling it "near-fraudulent." Smart move on the other side though: they pulled Claude Agent into the IDE and joined the ACP open protocol. "Use whoever's agent you want."
Zed: the fastest editor for the ADE era. Nathan Sobo's (Atom founder) Rust editor, GPU-accelerated, 120 fps. The biggest contribution is co-pushing ACP (Agent Client Protocol) with JetBrains. The goal: decouple agents from any specific editor, the same way LSP decoupled language intelligence. The positioning is clean — in the ADE era, the editor's value is fast, clean, plugs into any agent, not can do everything.
The five patterns that show up everywhere
Tool names will change. These patterns are stable.
- Workspace isolation. Git worktrees or equivalents. Without isolation there is no parallelism.
- Tasks replace file tabs as the top-level nav. Your home screen organises around what's being done, not what's open.
- Async-first. Your attention is too expensive to spend watching progress bars.
- Attention routing. "An agent needs you" is its own event type and needs queueing, prioritisation, and triage.
- Lifecycle integration. The agent participates in the entire issue → PR → CI → merge chain, not just the editor.
These five are the actual difference between an IDE and an ADE. The IDE optimises file editing. The ADE optimises agent management.
The honest problems
The 90%-correct trap. Agent output is often broadly right with subtle wrongness. For high-stakes changes, the traditional IDE is still the best precision tool we have. That's why the IDE doesn't disappear — it gets demoted, not removed.
Review fatigue is real. Twelve agents in parallel means twelve diffs by end-of-day. Sounds productive; collapses in practice. This is exactly why every serious ADE is investing in attention routing and review gating.
Security surface expands. Every tool is adding approval gates, tool logs, permission scoping.
An analogy that lands
Trevin Chow's framing: writing code is starting to look like playing StarCraft. RTS games solved how to manage many parallel units via UI decades ago. The IDE is the soldier's view. The ADE is the commander's view. You're not controlling each soldier any more. You're managing the battlefield.
One last thing
The move from IDE to ADE isn't the IDE died. It's that the developer's home screen changed. The editor got demoted. Agent orchestration is the new main character.
If you're still hand-writing every line, you're not slow. You're using IDE-era methods to do ADE-era work. The ceiling has been redefined: a single person can orchestrate roughly 10× what they can write. Not entering the ADE means using 10× the effort to produce 1× the output.