Whose VSCode Fork is it anyway?

TL;DR

The AI IDE landscape looks chaotic, but underneath it all, the one thing that matters is how AI-powered development tools may actually improve your workflow — not hype, branding, or which VSCode fork it came from.

Let's dive in and learn how to choose an AI coding environment based on leverage, privacy, and long-term control.

• Why so many AI IDEs are appearing at once
• How VS Code’s open-source/product split drives fragmentation
• The real technical criteria that differentiate AI editors
• How to avoid getting locked into a proprietary coding workflow
• Why agents, not editors, will shape the future of software development

1. The explosion of AI-powered editors

Dear reader, I am a guy who likes to use numbers to understand the world around me. Maybe you are partial to numbers as well. Here is a number for you: 7. That is how many – somewhat – successful AI-driven VSCode forks are out there. Cursor, Antigravity, Kiro, Qoder, Trae just to name a few.

While that is exceptional and speaks to the great work the Microsoft team did when they built this Electron-based IDE and open-sourced it, it is becoming a real pain. The ecosystem is divided, there is no clear winner, and it seems like everyone is on it just to cash in on the AI trend.

It is worth noting that there are well over 12 Copilot-like extensions for VSCode, as well as more than 8 CLI options you can use to run your AI agents as well. More on this last one later.

In just two years, Anysphere – Cursor's parent company – has released two major Cursor versions and raised $2.3 billion USD in capital for a total valuation of $29.3 billion.

2. Marketplace lock-in and fragmentation

VSCode is a very nifty piece of software. It is good, extensible, and free. It does not get any better than that.

Make no mistake: this is a race to the top. And Microsoft wants VSCode to remain top of mind. At the moment this article is published, VSCode remains the most popular IDE among professional developers.

The VSCode extensions marketplace is run by Microsoft. Since Cursor's rise in popularity, Microsoft has introduced hidden APIs to VSCode only enabled for Copilot. Some people have pointed out that the GitHub Copilot add-on for Visual Studio Code appears to break the rules that others must follow.

This year, Cursor reached 100,000 daily users.

Hitting 100,000 daily users in 18 months sets a record. VS Code took three-plus years to reach this scale. Cursor charges $20 monthly when free alternatives exist. That pricing works because the quality gap justifies cost. At roughly 40% paid conversion, Cursor generates $8 million annual recurring revenue. Developers pay $240 yearly for an editor when VS Code costs zero. That only happens when productivity gains are obvious.

Microsoft’s restrictions seem to be forcing every fork to re-implement or reinvent their own ecosystem. This leads to fragmentation, inconsistent behavior, and duplicated efforts across tools. While this seems to be transparent to developers installing extensions, it is harder on those who actually maintain them.

Open VSX Registry

The Open VSX Registry is a vendor-neutral, open-source alternative to the proprietary Microsoft Visual Studio Marketplace. It was created in 2019 as a response to Microsoft's Marketplace Terms of Use, which explicitly forbid non-Microsoft builds of VS Code from accessing the official marketplace.

Extension developers have to deal with both registries. This duplicated effort across tools may lead to inconsistent behavior or unforeseen security vulnerabilities.

3. What actually differentiates these AI IDEs

Let's talk about the features we should pay attention to when we’re evaluating which IDE to choose.

Project-wide Context

How well the tool understands your entire codebase at once. Strong context means the AI can reference, reason about, and update multiple parts of the project consistently.

Multi-File Edits / Refactoring

The tool’s ability to make coordinated changes across several files. Good support means reliable, architecture-aware edits rather than isolated line changes.

Agent Quality

How effectively the AI can plan, break down tasks, execute steps, and iterate with minimal hand-holding. High-quality agents reduce manual supervision.

Extensibility and Ecosystem

How well the tool integrates with existing extensions, workflows, and development setups. A strong ecosystem reduces friction and preserves your current tooling.

Maturity

How stable, battle-tested, and production-ready the tool is. Mature tools have fewer surprises and better long-term reliability.

VSCode + Copilot

Ideal Use Case: Developers who want strong AI assistance without leaving VSCode. Great for incremental edits, comprehension, and moderate refactors.

Cursor

Ideal Use Case: Fast iteration, AI-first development, and complex multi-file modifications with reliable automation.

Windsurf

Ideal Use Case: Medium-to-large projects needing strong context awareness and AI help without switching fully to Cursor.

AWS Kiro

Ideal Use Case: Enterprise teams on AWS needing AI-assisted workflows tied to specs, infrastructure, and large codebases.

Google Antigravity

Ideal Use Case: Agent-first development, automated feature generation, and highly autonomous workflows.

4. The hidden cost: Who controls your development workflow

Developers tend to compare AI IDEs on features: context windows, agents, latency, and so on. But underneath all of this, there’s a quieter variable that matters just as much: control — specifically, who controls the workflow you spend eight hours a day inside of?

AI IDEs are not neutral tools. They all come with trade-offs around data handling, embeddings, telemetry, cloud dependence, and how much autonomy you hand over to a single vendor. These choices compound over time, and once your workflow leans heavily on an AI layer, switching becomes progressively harder.

There are four main areas where control shows up:

1. Codebase ownership

Once your editor starts embedding your entire repo, the vendor effectively owns the “map” of your code.

That includes:

• Structural relationships
• Symbol graphs
• Vector embeddings of key logic
• The model’s internal state about your architecture

This isn’t bad on its own, but it does centralize power. If the vendor changes pricing, capabilities, or data policies, you feel it immediately.

2. Agents affect your decision-making

The more agent-driven your workflow becomes, the more your coding style adapts to the design philosophy of the tool.

Agents decide:

• How to break down tasks
• Which files to modify
• Which tests to run
• How to structure a refactor

The higher truth here is that over time, your approach starts to shift to follow the AI agent’s behavior.

This introduces subtle lock-in: you’re not just using a tool — you’re adopting its way of thinking.

3. Cloud dependencies limit your autonomy and efficiency

Most AI IDEs rely on cloud inference, cloud embeddings, and vendor-specific backends.

This means:

• No offline work
• No local-first control over your context
• Limited transparency into data retention
• Dependence on the vendor’s uptime and privacy guarantees

If the vendor goes down, gets restricted by a corporate firewall, or raises prices, you will feel it.

4. Intellectual property risks

LLM vendors like OpenAI, Anthropic, and Google invest heavily in security. They run dedicated red teams, SOC2-compliant infrastructure, strict isolation layers, and continuous audits. All of that is true. And still — not one of those defenses is a guarantee.

Once your code leaves your machine, you accept a level of exposure.

Two real risks emerge:

• Infrastructure breaches: Every cloud provider is a target. A single misconfiguration, overlooked permission, or unpatched dependency can expose private embeddings or model logs.
• Human error: Most data leaks aren’t Bond-movie attacks. They come from one engineer fat-fingering an S3 bucket policy, a logging flag left on in production, or a misrouted support request.

Even if the vendor never uses your data to train models, the simple act of transmitting code off your local environment introduces a non-zero risk.

This doesn’t mean you should avoid these tools.
It means you should understand the trade-off: convenience and speed in exchange for more points of failure between your machine and the outside world.

Your AI IDE should be able to make your job easier. Think about how well JetBrains IDEs index code and allow you to go to definitions with high precision. In this same way, your AI agents should be able to present actionable information. Code still drives the conversation, but in large codebases owned by different teams, keeping track of changes and staying up to date is complicated.

5. Implementing AI into your development workflow like a grown-up

Thanks for bearing with me this far. This article is way larger than I anticipated, and I promise you I did cut it by more than half.

You now know a good deal more about the AI-driven IDEs that can help you increase your productivity, and some of the features you should ponder when choosing an agent. Now let's bring it home with the actual things that bring value to your development workflow.

1. Prioritize tools that reduce cognitive load

The real value of AI lies in reducing the number of decisions you need to make. Choose tools that help you navigate the codebase faster, understand unfamiliar files with less friction, and offload repetitive edits or boilerplate.

The AI should help you feel more focused. Otherwise, it is not doing its job. If you feel like you’re babysitting it, you picked the wrong tool.

2. Avoid deep vendor lock-in

Every AI IDE wants to center your workflow around its ecosystem. The risk appears when switching becomes painful.

Avoid tools that store your project state only in their cloud, rely on proprietary formats, or build features that only work inside their editor.

Prioritize setups where you maintain control of your data, your prompts, and your workflow design.

3. Own your embeddings if possible

When a tool indexes your codebase, it generates embeddings — vector representations that effectively become the model’s memory of your system. If those embeddings live locally or in infrastructure you control, you retain ownership. If they live exclusively in a vendor’s cloud, you depend on their policies, pricing, and uptime.

Understand where your embeddings are created and who controls them.

4. Do Not Repeat Yourself — choose tools that integrate with your existing workflows

The biggest gains come from removing friction, not adding new environments. AI should complement your current setup, not replace it.

That means respecting your Git workflow, your test runners, your CI/CD, and your project layout. If the vendor forces you to maintain parallel workflows or reconfigure half your environment, it’s slowing you down.

Good AI integrates; bad AI demands you adapt to it. Same goes for developers.

Quick Checklist Before Choosing an AI IDE

• Does this tool lower my cognitive load, or add another layer to manage?
• Can I leave this vendor tomorrow without losing my workflow?
• Who owns my embeddings and project context?
• Does it integrate with my existing Git, tests, CI/CD, and repo structure?
• How transparent is the vendor about telemetry and data retention?
• Will this tool still make sense once agent-driven development becomes the norm?

6. How to prepare for the future

Agents are the future — not IDEs.

Satya Nadella recently shared his thoughts on the AI agent future. He envisions a future where AI agents become the primary interface for all computing, largely replacing traditional software applications and their user interfaces.

Some of the key points he made:

• Agents as the core, apps as tools: The traditional SaaS model will change dramatically. Instead of humans navigating apps, AI agents will orchestrate business logic and interact directly with systems.
• Natural language interfaces: Instead of clicking through menus, users will simply tell agents what they need.
• Humans as “agent managers”: The role of knowledge workers will evolve into supervising agents, defining goals, and handling exceptions.
• Unified interaction layer: The agent becomes the primary interface; applications become background utilities.

While today's conversation is about how cool all these new IDEs are, the endgame is entirely different. If Satya Nadella is right, our future will be managing agents. If we imagine this for a minute, we can think of orchestrating agents that work alongside integration agents, testing agents, QA agents, and so on.

You will remain the problem solver, but a significant portion of the code will be written by AI.

Final Thoughts

AI-driven IDEs are evolving fast, while the general landscape is getting more fragmented, the real advantage comes from understanding how these tools shape your workflow, not just what features they advertise.

Choose tools that

• Reduce friction
• Preserve your autonomy and
• Help you think more clearly.

The IDE may change, but your judgment should remain the constant.

Thank you for reading. I would love to hear your thoughts — follow me on LinkedIn: Page Carbajal.