I used to think a serious developer needed a serious IDE.
Big project? Open PhpStorm. Design work? Open Photoshop. Need every refactor, every inspection, every plugin, every panel, every button? Load the heavy tool and wait for the machine to breathe again.
But something changed. Not overnight, and not because those tools suddenly became bad. They are still powerful. The change is that AI started taking over the parts of the IDE I actually needed most.
Today, I spend more time in VS Code and the terminal than in heavy IDEs. My machine feels lighter. My workflow feels less crowded. And honestly, I do not miss the old setup as much as I thought I would.
For years, big IDEs won because they could see the whole project. They understood symbols, imports, frameworks, database models, refactors, formatting, inspections, and tests. A good IDE felt like a senior assistant sitting beside you, quietly warning you before you made a mess. That was valuable. It still is.
But AI has started to move that intelligence out of the IDE shell. The useful part is no longer tied to one huge application. It can live in your editor, your terminal, your pull request, your CI pipeline, or even in a chat window with access to your codebase.
When AI can read the files, reason about the bug, generate a test, run the test, inspect the failure, and propose a patch, the IDE becomes less like the brain of the workflow and more like one possible place to type.
The phrase "AI coding assistant" already feels too small. Autocomplete was the first version. The newer pattern is closer to an AI developer environment.
You ask it to find the bug. It searches the repo. You ask it to explain a weird error. It follows the stack trace. You ask it to write a benchmark. It can create the benchmark file, run it, compare the result, and tell you what changed. You ask it to add tests. It can inspect the code path and generate cases you probably would have delayed until later.
That changes the value of a heavy IDE. If the IDE's biggest advantage was intelligence, and that intelligence is now available everywhere, then the heavy IDE has to justify its weight in a new way.
For some teams, it still will. Large Java projects, deep framework integrations, enterprise debugging, database tooling, and mature refactor engines are not magically obsolete. But for a lot of web development, app work, scripting, backend APIs, and content-heavy product work, the lighter stack is suddenly enough. This is the part people underestimate: tool weight affects how you think.
A heavy IDE can be comfortable, but it can also make the machine feel occupied. It eats RAM, adds background indexing, opens panels you forgot existed, and turns simple edits into a small cockpit experience.
VS Code and a terminal feel different. Open the files. Run the command. Ask AI to inspect the error. Make the change. Run the test again. There is less ceremony.
I like that. I like seeing the actual commands. I like not waiting for a large application to settle down before I can think. I like that the same terminal workflow works across projects, servers, scripts, and AI agents.
It is not about minimalism for aesthetics. It is about reducing friction.
The strongest reason AI reduces my need for a heavy IDE is not code generation. Code generation is useful, but it is also easy to overtrust.
The stronger shift is AI-assisted verification.
If AI writes code and also writes tests for that code, the workflow becomes more honest. It does not just say, "Here is the fix." It can say, "Here is the failing case I reproduced, here is the patch, and here is the test result after the patch." That is much closer to useful engineering. Benchmarks matter too. A traditional IDE might help you navigate performance code, but AI can generate a benchmark harness, run before-and-after measurements, and point out whether the improvement is real or just vibes.
This is where AI starts replacing the feeling of needing a giant IDE. The confidence no longer comes from a green underline or a smart autocomplete. It comes from generated checks that prove the change works.
I do not think PhpStorm, IntelliJ IDEA, Visual Studio, or Photoshop-style professional tools are going away. That would be a lazy prediction. Experts still need expert tools.
But I do think the default assumption is changing.
Before, the question was: "Why are you not using the full IDE?"
Now the question is: "Do you actually need it for this project?"
That is a big shift. A lighter editor plus terminal plus AI can cover more ground than it could even a few years ago. It can debug, explain, generate, refactor, write tests, create scripts, and help with documentation. It can also jump outside software development into design drafts, copy, image workflows, automation, and deployment tasks.
That is why I also feel less attached to tools like Photoshop for everyday work. For serious design, sure, dedicated tools still win. But for quick graphics, mockups, thumbnails, edits, and experiments, AI tools have eaten a big part of the reason I used to open a heavy design app in the first place.
My current setup is simpler: VS Code, terminal, AI, tests, and scripts.
It sounds smaller. It feels smaller. But it can do more than my older setup did because the intelligence is no longer trapped inside one application.
That is the part I keep coming back to. AI is not just another plugin inside the IDE. AI is becoming the layer around the work. It can sit beside the editor, inside the terminal, inside GitHub, inside CI, inside docs, and inside the browser.
The IDE used to be where development happened. Increasingly, development happens wherever the AI can see the project, run the commands, and verify the result.
For me, that means fewer heavy apps, fewer waiting moments, and more breathing room on my machine. And once you get used to that breathing room, it is hard to go back.
Originally published at https://blog.jenuel.dev/blog/i-stopped-using-heavy-ides-ai-became-my-ide