Dear Microsoft,
I don’t want to have a love-hate relationship with Visual Studio Code, but you’re making it really hard. Once upon a time, Visual Studio Code was just an editor. You configured it with add-ons to make it do whatever job you needed. And that was great! I gravitated towards using VS Code for multiple jobs in various languages. I could set up a Python workflow with extensions to add database-wrangling functionality. I could put together an environment for digital book publishing. I could even set up a project for screenwriting! Now, it’s not like all this went away yesterday. I can still do all of the above. But literally every new feature in VS Code these days is all about agents, AI, and LLMs. It makes me wonder if there’s anyone left in the building who is working on the actual editor anymore.
In the release notes for VS Code 1.127, literally every single new feature save one was about agents and AI. Ditto the version before that. The version before that was a little better, but the trend has been clear for some time now: Visual Studio Code is fast becoming an agent front end first, and everything else is a distant second. One argument I’ve heard is that VS Code is now a mature project. Because there just isn’t much left to be done to improve the core, you have directed your attention towards other features that will attract new users. And because agent-and-AI mania is still burning through the enterprise (and everyone’s budgets), agent-and-AI features are the order of the day.
But do these features really need to be IDE-level features? Instead of drastically retooling VS Code to support agents, and making AI features native elements of the IDE, shouldn’t the real mission be to support VS Code’s native extensibility? After all, VS Code was built to be extended, and thousands of AI add-ons — including GitHub Copilot and dozens of your own extensions — already take advantage of that. Is all this really about what AI features VS Code can support natively, or is it more about making VS Code a default first point of contact for agents and AI — specifically GitHub Copilot? Is this less about developer convenience, and more about guaranteeing — however obnoxiously — that agents and AI tools always have a central place in VS Code?
Whatever the goal is, if you think every VS Code user wants an “agentic development environment” instead of an IDE, I think you’re dead wrong. No doubt AI tools are here to stay. But I do think they will experience a reckoning. Frontier models that do everything and six more things on top of that are becoming of real use only to the big vendors who stick API tollbooths in front of them and construct wetland-devouring data centers the size of the Vegas strip to power them. The future looks more like smaller, locally-hosted models that handle highly specialized tasks and require far fewer resources to train, deploy, and serve. (Even you seem to be moving in that direction, with the Aion on-device models.)
The deeper we go into that reckoning, the less it makes sense to have cart-before-the-horse arrangements like VS Code’s native AI features. How long before these features get hoisted back out of VS Code and moved to an add-on (albeit one we get nagged to install every time we fire up our IDE)? Sooner rather than later, I’d bet. Still, until that fine day comes, I’m resigning myself to the idea that my current favorite editor will be stuffed with more and more AI features, whether or not they even make sense in my use case, for a long, wearying time to come. At least I can turn all that stuff off. For now.
As I was writing this (in VS Code, no less), I got an update to VS Code 1.128. There’s one nice feature in there I could see myself using quite widely: the ability to register OS-level keyboard shortcuts. But the rest? All AI, all agents, all the time.
The Evolution of VS Code: From Editor to AI Hub
Visual Studio Code first launched in 2015 as a lightweight, cross-platform code editor built on Electron. Its rapid rise in popularity was driven by a powerful extension marketplace and a philosophy of being a "hackable" tool that developers could tailor to almost any workflow. Over the years, the core team added built-in Git integration, a debugger, IntelliSense, and a terminal. These features were welcome because they enhanced the editing experience without forcing users into a particular paradigm. Extensions handled everything from language support to theming to complex toolchains. The editor itself remained a neutral canvas.
Now, with the integration of GitHub Copilot and a growing suite of AI-powered tools like chat assistants, agent-based code generation, and context-aware completions, the line between editor and platform has blurred. Microsoft has positioned VS Code as the centerpiece of its AI developer strategy. Entire conferences and developer events revolve around AI features in VS Code. The message is clear: to get the most out of AI coding assistance, you should use the official Microsoft environment. This creates a natural monopoly for Copilot and other proprietary AI services, undermining the openness that made VS Code successful in the first place.
The Extensibility Argument: Why Native AI Misses the Point
Proponents of native AI features argue that deep integration provides better performance and a more seamless user experience. But this ignores the fact that VS Code already has one of the most flexible extension APIs in the industry. Third-party AI tools can register custom commands, provide inline completions, interact with the editor’s language engine, and even spawn webviews for complex interactions. The only thing missing is a first-class AI API that allows extensions to hook into the same underlying models Microsoft uses. Instead of making AI features native, Microsoft could provide a stable, documented API for AI capabilities, then let the ecosystem innovate. This would preserve user choice and avoid the constant churn of mandatory updates that add more AI every quarter.
The same argument applies to agents. An "agentic" development environment implies that the editor takes on responsibilities traditionally held by the developer: suggesting code changes, managing dependencies, even refactoring entire codebases. While these can be useful, they shift the editor’s role from a tool you control to a system that controls you. Developers who prefer to understand every change before applying it find these features intrusive. The ability to disable them is a start, but it adds clutter to settings and fragments the user experience across different versions. Moreover, the agent features are often built on proprietary models that may not align with a developer’s privacy or security requirements.
The Reckoning for AI in Development
The current AI hype in software development echoes past cycles: expert systems in the 1980s, component-based development in the 1990s, and cloud-based IDEs in the 2000s. In each case, early enthusiasm gave way to more pragmatic, specialized tools. The same is likely to happen with AI. Large language models will become commoditized, and the value will shift to small, targeted models that excel at specific tasks — code review, test generation, documentation — rather than trying to be general-purpose coding assistants. These smaller models can run locally, respect data privacy, and integrate smoothly with existing toolchains. When that happens, native AI features in an editor will look like a relic of a bygone era, much like the built-in web browser in some old IDEs.
Microsoft’s investment in on-device models (such as the Aion project) hints that they recognize this trajectory. Yet the current VS Code roadmap continues to prioritize cloud-connected agents. It would be wiser to build a lightweight, modular AI layer that can be swapped out based on the user’s preference — local or cloud, from Microsoft or from a third party. That approach would future-proof the editor and demonstrate genuine respect for developer autonomy.
What VS Code Still Does Best
Despite these frustrations, VS Code remains an excellent editor for many tasks. Its performance, extension ecosystem, and community support are unmatched. Developers can still use it without ever touching an AI feature; the core editing experience is solid. But the constant emphasis on AI in release notes, blog posts, and default configurations makes it harder to ignore. It creates a subtle pressure to adopt these tools, lest you be left behind. For those of us who value minimalism and control, that pressure is unwelcome.
What would be a better path? Microsoft could allocate resources to fixing long-standing issues like the memory consumption of certain extensions, improving the integrated terminal, refining the settings interface, and adding better support for remote development scenarios. These improvements would benefit every user, regardless of whether they use AI. And for AI, keep it as an extension — let the marketplace compete on quality, not integration depth. If Copilot is genuinely useful, developers will install it. They don’t need it baked into the core.
In the end, the message to Microsoft is simple: stop treating VS Code as a vehicle for your AI ambitions. It’s a code editor, not a petri dish for agent experiments. Let the editor be an editor, and let AI be a plugin. Your users will thank you.
Source:InfoWorld News