Why We Still Need an IDE

I've been mulling this over for about a year now. The developer landscape has shifted to the point where you can't scroll past the news without seeing someone declare “I never open my IDE anymore” or “I do everything in the terminal.” And those workflows genuinely work for some people. But not for everyone. I honestly believe IDEs embody why we love what we do. The question then becomes: how do we move forward as the world changes?

The workflow has changed. The environment needs to match it.

Coding agents are no longer an experiment; for many of us, they're already an everyday part of building software. We aren't just tab-completing anymore. We're handing agents substantive tasks that touch multiple files, explore dependencies, and refactor across packages. The day-to-day rhythm of engineering is evolving: it's less about typing line by line and more about steering intent.

Think of this shift like the move from hand-flying to using a modern aircraft's flight computer. The computer can handle complex execution, but it is capable because it is connected to the plane's instruments: navigation, altitude, speed, and engine data. The pilot doesn't need to move every control at every moment, but still needs a cockpit where they can see the whole flight, understand what is happening, and intervene when the route changes.

Agentic software development works the same way. An agent can plan and carry out a substantial change, but it needs a rich environment around it, and so does the engineer directing it. Code analysis, navigation, dependency information, type checking, tests, and access to the systems around the code provide the context that a terminal or isolated session may not expose clearly. An agent may run a compiler or test; the IDE makes the result part of a connected picture of the project, so you can understand not just whether something failed, but what it affects and why.

The pilot also owns the flight, even when the computer is doing much of the work. The engineer owns what ships, even when the agent wrote most of the code. That means reviewing the change in context, understanding its consequences, and being able to explain and defend the result later.