Are IDEs Officially Dead?

The short answer

No. But the question is wrong, and the way it is wrong is the interesting part.

Every few months someone posts "the IDE is dead" and someone else posts "the IDE isn't dead" and both get a few thousand upvotes. In 2026 the posts have titles like "long live the ADE" and "the terminal won". I have read most of them. The honest answer is that the IDE is fine, the editor pane inside it is losing its main job, and the thing that used to make an IDE an IDE is being pulled out and rebuilt somewhere else.

Full disclosure: I build a terminal coding agent, so I have a stake in this. I will try to be fair to the editor anyway.

What actually changed

For about twenty years the IDE owned the inner loop. Open a file, edit, build, run, debug, repeat. Everything else lived around the edges. The terminal, the browser, git: tolerated, docked into a panel, never the main event. The IDE was where code got typed, so it was where everything else had to plug in.

Then the agents arrived, and they did not move into the editor. Claude Code shipped as a terminal program. So did Codex CLI, Gemini CLI, Aider and OpenCode. Even Cursor, the company whose whole pitch was an AI native editor, shipped a CLI in January 2026. There is a boring practical reason for this. An agent needs to run your build, run your tests, read and write across the whole repo, and do all of that in several parallel sessions without stepping on itself. The shell already has every one of those things. The editor had to grow them, one release at a time.

So the loop inverted. In the old loop a human typed and a tool helped. In the new loop a tool types and a human reads. Once that flips, the question of where you type stops mattering, because you mostly are not typing. InfoWorld ran a piece in July arguing that the IDE made sense when a developer did one thing at a time, and that developers now spend their day managing several agents working on several branches at once. Boris Cherny, who runs Claude Code at Anthropic, reportedly said on Lenny's Podcast in February that he had not opened an IDE or written code by hand in months. A founder at Lanes wrote that he told his whole team to drop PyCharm, VS Code and Cursor and just use a terminal agent.

Those are the loud voices. The quieter version, which I think is closer to the truth, is a dev.to post from a platform engineer who now does the first 60 to 70 percent of a task in a terminal agent and then opens the IDE for the rest. That is roughly my own week too.

The IDE vendors did not sit still

Every major editor spent 2026 rebuilding itself around agents. Look at what each one actually shipped, not what their marketing said.

VS Code. The June and July releases (1.123 through 1.127) turned Copilot from a chat sidebar into an agent console: an integrated browser agents can drive to open pages, take screenshots and validate web apps, parallel agent sessions side by side, cost visibility per session, and comments in the gutter on changes an agent made. 1.124 turned Autopilot on by default. And since January you can run Anthropic's Claude agent inside Copilot on your GitHub subscription. Microsoft's editor now hosts a competitor's agent as a feature.

JetBrains. Junie left beta on June 17 and the interesting part was not the agent, it was the architecture. JetBrains rebuilt the IDE integration on the Agent Client Protocol so the same engine runs in the IDE chat, the Junie tool window, and a standalone Junie CLI in your terminal. Its headline feature was agentic debugging: the agent uses the real debugger instead of println. Then there is Air. When Air launched in preview in March, JetBrains told people to use Air for agent work and keep their IDE for everything else. In September it relaunched Air as an open system spanning the IDEs, a web and CLI surface, and a governance layer, with Claude Agent, Codex, Copilot, OpenCode and Junie all supported. Cursor's agent has been able to run inside JetBrains IDEs since March.

Zed. Zed hit 1.0 on April 29 after five years of previews, and the headline feature was not the Rust rendering engine. It was that Claude Code, Codex, Gemini CLI, OpenCode and Cursor's agent all run inside the editor in parallel through the Agent Client Protocol, which Zed created and JetBrains adopted. Zed's framing is explicit: ACP is meant to do to agents what the Language Server Protocol did to language intelligence, which is unbundle them from any one editor.

Cursor. The AI native IDE added long running agents, subagents, skills and a CLI through the first half of the year, and then SpaceX bought it in a deal that closed on August 14. Cursor's own announcement led with making Grok more useful and improving Grok Build, with the editor mentioned further down the list. The most valuable editor company ever built was acquired for its agent and its users, not its text editing.

Notice the pattern. Every one of these companies is turning the editor into a place where agents are hosted, reviewed and governed. Not one of them is betting on the editor as the place where code gets typed.

What the numbers say

Two large surveys landed in the last two months, and together they settle the question better than any hot take.

The JetBrains Developer Ecosystem Survey 2026 polled more than 15,000 professional developers between May and July. 90 percent were using AI coding agents at work at least weekly, 68 percent daily. Here is how workplace adoption moved in just five months:

Tool	Jan 2026	May to Jul 2026
Claude Code	18%	39%
GitHub Copilot	29% (a year earlier)	21%
Codex	3%	16%
Cursor	18%	12%
OpenCode	not tracked	7%
JetBrains AI / Junie	not tracked	9%

The terminal agent doubled. The editor plugin that defined the category in 2023 lost a third of its users. The AI native editor shrank. In the US, 47 percent of developers were using Claude Code at work, and for 31 percent of developers worldwide it was their single most used AI tool.

Then the Stack Overflow Developer Survey 2026 came out on October 6 with more than 30,000 responses. Among people using AI coding tools, 73 percent use them daily and nearly a third use them four or more hours a day. The agents of choice were Claude Code at 66 percent and Copilot at 59 percent. And yet Visual Studio Magazine's summary of the same survey notes Stack Overflow's own line: VS Code is "still the most used IDE despite AI disruptors".

Read those together. Agents are everywhere, the terminal agent is the most used agent by a wide margin, and VS Code is still the most used IDE. All three are true at once. People did not leave the editor. They stopped doing their typing in it.

One number to be careful with. The "JetBrains posted its first loss, the terminal won" story went around last week. The filing behind it is the Czech operating entity's 2025 accounts: a CZK 315 million net loss on CZK 16 billion of revenue, with operating profit still positive at CZK 751 million. The swing came from net financing costs of just over a billion koruna. That is a finance line, not developers fleeing IntelliJ. Do not build a thesis on it.

What the editor still does better

Four things, and every vendor's 2026 roadmap is a tell for each of them.

Review. A terminal diff is a miserable way to review forty files. Multibuffer review, inline comments on the lines an agent changed, jump to definition across the whole change set: this is where the editor wins, and the vendors know it. That is why the June VS Code releases added gutter feedback on agent edits and why Air opens diffs straight from an agent session with line comments the agent can act on. The terminal is where the work happens. The editor is where you find out whether it was any good.

Debugging. Junie's launch pitch was that it uses the debugger rather than println. Breakpoints, watch expressions, stepping through a live process. Terminal agents fake all of this with print statements and log tailing, and they are decent at faking it, but a real debugger attached to a real process is still a different class of tool.

Comprehension. When you do not know a codebase, the IDE's semantic index is still the fastest way to learn it. Addy Osmani's piece on this question makes the point that large refactors across many files in big repositories remain the hardest thing for agents, and that is exactly where the IDE's understanding of types, call graphs and references earns its keep. The dev.to engineer I mentioned earlier watched an agent propose a refactor that looked clean in the diff and broke three downstream services, because it never ran the full test suite in the right environment.

Trust. Stack Overflow found that developers trust AI output when they can verify it, and that 93 percent need source attribution before they will trust context. Among people handling AI generated code, about three quarters ran it locally and nearly two thirds compared it against their codebase. The editor is the verification surface. As long as developers insist on verifying, and they should, the editor keeps a job.

None of those four is going away. What is changing is that they used to be the whole product and now they are the second half of it.

What is actually dying

The editor as the centre of gravity. The IDE was integrated around a human typing. The environment being built now is integrated around agents running, and the human is one of several things that can interrupt them. Three signs that this is real and not a hot take.

The IDE companies are saying it themselves. JetBrains launched Air by telling customers to use it for agent work and keep the IDE for the rest. That sentence would have been unthinkable from JetBrains in 2024. Microsoft put a rival's agent inside Copilot. Zed's 1.0 announcement was about which agents it could host, not about editing.

ACP commoditises the editor's smartest feature. When every editor agrees on one protocol for hosting any agent, the agent becomes the product and the editor becomes the host. That is precisely what the Language Server Protocol did a decade ago: it took the thing that made an IDE smart and made it portable, and the editors competed on everything else. ACP does the same to the agent. Good for developers, who can swap agents without swapping editors. Bad for anyone whose moat was "our editor has the best AI". The JetBrains survey has a nice detail here: 39 percent of Copilot users run it inside JetBrains IDEs. The agent and the editor are already decoupled in practice.

The bottleneck moved. Every one of the ADE posts describes the same failure. Five terminal tabs. One agent waiting on input you did not notice. One that finished ten minutes ago. Two doing overlapping work on the same files. The scarce resource is no longer typing speed, or even autocomplete quality. It is your attention across parallel agents, and the plumbing to keep them from colliding, which in practice means git worktrees. The tool that wins the next few years is the one that manages that, and it will not look like a text editor with a chat panel bolted on the side.

So the honest version of "IDEs are dead" is this. The I in IDE used to mean integrated around the editor. It is going to mean integrated around the agent. Same letters, different product.

Verdict

IDEs are not dead. The editor is not dead. The idea that the editor is where software gets made is dead, and the companies that make editors said so this year, with product launches rather than blog posts.

If you want something practical to do with that:

Keep the IDE open, but stop measuring yourself by time spent in it. Time in the editor is now review time, and review time should be short and sharp.
Pick one terminal agent and learn it properly. Not the chat panel version. The one that runs your tests and opens the pull request. The surveys say most of your peers already did.
Review in the editor, not in the terminal. Agents produce a lot of diff. A terminal is the wrong place to read forty files of it.
Learn git worktrees. Every story about running several agents at once ends up being a story about worktrees, and the tools that automate them are still young.
Watch ACP, not the editor wars. If your editor speaks it, you can change agents next quarter without changing anything else. If it does not, that is the thing to ask your vendor about.
Get good at being the thing that notices. The job is shifting from writing the code to knowing which of five running agents needs you right now, and catching the clean looking refactor that is about to break three services downstream.

The IDE will still be on your dock in 2027. It just will not be the first window you open in the morning.

Are IDEs Officially Dead?

The short answer

What actually changed

The IDE vendors did not sit still

What the numbers say

What the editor still does better

What is actually dying

Verdict

Sources

related notes

The Curious Case A PHP Vulnerability

LLMs Are Plausibility Engines, Not Correctness Engines

Codex Security Is Here - And It's Changing How We Think About DevSecOps

Comments