Pythonium

Python, What else ?

Will AI Kill IDEs?

For years, the IDE has been our main tool as developers. We write code, navigate between files, use autocomplete, debug and run tests. In short, we spend a good part of our days working in it.

But since the arrival of AI agents, our habits have started to change. I can now ask an AI to add a feature, modify several files, fix errors and even run tests without directly interacting with every file.

Ultimately, I wonder whether IDEs still have the same future as before. Will we continue to spend our days in a code editor, or will we gradually start working directly with AI agents?

The IDE, a tool that was once indispensable

I started developing with a simple text editor. When I discovered a "real" IDE, it was a shock. I was amazed. I quickly wondered how I had managed without one before.

An IDE generally brings together several essential tools: code editor, syntax highlighting, autocomplete, file navigation, debugger, integrated terminal, extension management, etc.

Software such as Visual Studio, IntelliJ IDEA and Visual Studio Code (which I use every day, both professionally and personally!) have become references in the field.

The IDE is a bit like the developer's desk. All our tools are there, and we can quickly switch from one task to another without constantly having to change applications.

But this setup is based on a fairly simple idea: the developer writes and manipulates the code directly. And this idea really started to change in 2025.

When AI starts writing code for us

At first, AI assistants were mainly used to complete code, suggest a function or explain an error. We used to copy and paste things from an AI chat. It was quite a manual process.

Today, AI agents go much further. We can ask them to implement an entire feature, modify several files, investigate the cause of a bug or even run tests to check their changes.

The difference is quite significant. I see it every day at work. I don't code the same way anymore. In fact, I sometimes feel like I'm just doing code reviews and removing unnecessary stuff from the code I'm working on.

Before, I could ask an AI how to write a function. Now, I can ask it to create that function directly in my project, integrate it with the rest of the code and check that everything works. Developers no longer necessarily need to manipulate every file themselves to make a change.

Is the IDE becoming just an interface for AI agents?

Tools like Cursor and Windsurf have started integrating AI directly into the development environment. But their ambitions go far beyond simple autocomplete.

The editor is gradually becoming an interface for communicating with agents capable of working on an entire project. We can assign them a task, examine the modified files, check for errors and step in when the result doesn't meet our expectations.

But there's another approach too: working directly from a terminal. With tools like Claude Code, it's possible to ask an agent to explore a project, modify its code and execute commands without going through a traditional IDE.

We can even imagine working with several agents in parallel, each assigned to a different task. In this context, the code editor is no longer necessarily at the center of development. It becomes just another tool for supervising the agents' work.

And ultimately, why would we need a complete (and heavy) IDE if most of the work is done elsewhere?

Why do we still need a code editor?

Despite these changes, I don't think code editors will disappear anytime soon. Even if an AI can modify several files for us, it's still important to be able to examine exactly what it has produced and improve the generated code (even if that means asking the AI to improve it...).

I particularly think that code navigation remains essential. When a project becomes complex enough, we need to understand the relationships between different functions, quickly find a class or follow how a process works.

The same goes for debugging. An AI can identify certain errors, suggest fixes and even run tests. But that doesn't mean it always understands every subtlety of the program.

So I prefer to keep the option of working directly with the code whenever necessary. Well, on the other hand, I'm not sure how long I'll stick to this approach.

The limitations of AI-driven development

We shouldn't idealize this new way of developing either. AI agents can produce unnecessary changes, break existing features or introduce errors that are difficult to detect.

I've also noticed that reviewing and understanding generated code can sometimes be more exhausting than writing it yourself. You can quickly find yourself supervising changes without fully understanding every detail. That's precisely where I see an important limitation.

If we systematically delegate code writing, it's tempting to pay less attention to how the code actually works. Yet we still need to be able to understand what the program does, especially when something goes wrong in production.

An AI agent can considerably speed up development, but it doesn't eliminate the need to understand your project. We also have to take costs, model availability and the potential limitations of the services we use into account. Not everyone necessarily wants to depend on an external service to write or modify code.

So, will IDEs disappear?

Personally, I don't think IDEs will disappear, but their role will probably evolve. The code editor could become secondary, with more emphasis on tools for managing AI agents.

I'm still attached to my editor, though. I like being able to open a file, understand how it works and directly modify a few lines. I wonder whether I'll still be able to stick to this approach, and I keep wondering how our profession as developers will evolve. I'm a little scared :'(...




Popular posts