The IDE Just Got Demoted
For two decades, the integrated development environment was the center of gravity in software work. Every tool orbited it. Version control got a sidebar. Terminals got a bottom panel. AI assistance, when it arrived, got embedded as autocomplete.
JetBrains' announcement of Air, described as an Agentic Development Environment, together with its Junie CLI, suggests that framing may be inverting.
The inversion
Copilot was the canonical version of AI inside the editor: a model living in your buffer, suggesting the next line while you type. The IDE stayed the workspace. The AI was the feature.
Air points at the opposite arrangement. Based on how JetBrains positions the product, the primary surface in an ADE is an orchestration layer, where a human directs agents that write, test, and refactor code. The editor still exists, but as a subordinate view: a place to inspect and correct agent output rather than the place where most keystrokes happen.
If that positioning holds up in practice, the IDE is being folded into an AI workspace, instead of gaining one more AI feature.
What actually changes
Compare what the developer's screen is optimized for in each model:
- IDE era: one human, one file, one cursor. The tooling maximizes typing throughput: syntax highlighting, autocomplete, jump-to-definition.
- Copilot era: same layout, much better autocomplete. The human still authors most structure and reviews inline.
- ADE era: the primary objects are tasks and agents. The human writes specifications, dispatches work to one or more coding agents, monitors progress, and reviews diffs. The file view becomes a drill-down for verification, opened when something needs inspection rather than kept open all day.
Concretely, a working session in this model looks less like editing and more like triage. You write a brief with acceptance criteria, hand it to an agent, watch a status feed, open the diff when it lands, then send it back with corrections or merge it. Teams experimenting with coding agents already describe something like this rhythm, though how widely it generalizes is an open question. The role shift, to the extent it happens, is from typist toward reviewer and dispatcher: setting acceptance criteria, triaging results, escalating when an agent gets stuck.
Why a CLI ships alongside it
Junie shipping as a CLI fits the orchestration reading. Agents compose through text interfaces far more naturally than through graphical ones. A CLI-first agent can be scripted, chained into pipelines, and invoked by other agents. If coding work moves toward multiple cooperating agents rather than a single assistant, the connections between them need to be automatable, and the terminal remains the most scriptable surface developers have.
That is also a hint about where competition may concentrate. Editor features are mature and widely available; the unsolved problems sit in coordination. How does a human hand a task to an agent unambiguously? How do agents report progress without flooding the human? How does review scale when the volume of generated code exceeds what one person can read line by line?
The caveats
- Product announcements are not adoption. JetBrains launching an ADE shows vendor conviction that the category exists; whether developers actually move remains to be seen. The evidence here is a directional signal from one major tooling vendor, not a measured shift in how most code gets written.
- The editor does not disappear. Debugging agent output, understanding legacy systems, and making surgical fixes still reward direct code manipulation.
- Orchestration has its own failure modes. Managing five agents that each produce plausible but subtly wrong code can be slower than writing the code yourself. The ADE bet only pays off if review and verification tooling improves as fast as generation did.
The takeaway
If you are building developer tools, the strategic question has changed. "How do we put AI in our editor?" is the old one. The current one: "What does the workspace look like when the editor is one panel among many, and the main panel is a queue of agents doing work?"
On current evidence, the IDE survives, on track to become a very good feature inside something larger.