VS Code vs Cursor vs JetBrains vs Zed vs Neovim: The Complete 2026 Code Editor Comparison

As of August 2026, choosing the screen you’ll stare at for eight-plus hours a day is no longer just a matter of taste — it’s a decision that shapes both your productivity and your budget. Now that AI agents write and refactor code directly, this code editor comparison has to be rewritten from scratch, using criteria that look nothing like they did just a few years ago. The question isn’t “whose syntax highlighting looks nicer” anymore; it’s “how deeply — and how cheaply — can you integrate an AI agent,” and that’s what actually decides the winner.

The five editors covered here — VS Code (Microsoft), Cursor (Anysphere), JetBrains (using IntelliJ IDEA as the reference product), Zed (Zed Industries), and Neovim — each stake out opposite ends of the design-philosophy spectrum, and together they carve up the market. VS Code is the generalist heavyweight that wins on its extension ecosystem; Cursor rebuilt the editor itself around AI agents from the ground up; JetBrains bolted AI onto a static-analysis and refactoring engine it’s spent more than 20 years perfecting. Zed ditched Electron and redefined speed with its own GPU renderer, and Neovim still holds the line as the ultimate free, open-source text editor.

This code editor comparison is built on official pricing pages and the latest release notes, not marketing copy. Wherever a figure comes from a source that’s disputed elsewhere or relies on a single source — like Stack Overflow survey share numbers or third-party benchmarks — we’ve flagged it explicitly, and we haven’t made up any number we couldn’t verify. Below, we start with a full five-way comparison table, then move into a feature deep-dive for each product, speed and resource benchmarks, a complete pricing comparison, recommendations by user type, practical tips and common mistakes, and finally an FAQ.

If you’ve already compared the AI coding agents themselves, pairing this with our Cursor vs. GitHub Copilot vs. Cline vs. Windsurf AI coding agent comparison fills in the full picture — which editor to run, and which agent to plug into it.

1. Executive Summary: The Top 5 Code Editors in August 2026 at a Glance

For developers short on time, we’ve compressed the essentials of all five editors as of August 2026 into a single table. Skim this table alone and you’ll already have the big picture of this code editor comparison.

📊 The Complete August 2026 Comparison Table for the Top 5 Code Editors

The single most important line in this table is “AI add-on pricing.” Looking only at the editor’s own price, three of the five (VS Code, Cursor Hobby, Zed Personal, and Neovim) are free — but actually using the AI features usually means paying for a separate subscription billed every month. If you want to read this code editor comparison with your budget in mind, we recommend checking the pricing table in Section 4 first.

2. Deep Dive: Core Features of the Top 5 Code Editors

🟦 1) VS Code — The Dominant #1, Powered by Its Extension Ecosystem

• Still the dominant share leader: The most recent public survey puts VS Code’s usage share at 75.9%, extending a first-place streak that’s now run for several years in a row. That said, secondary sources disagree on exactly which survey year that figure comes from (the 2025 edition, or a fresh 2026 update), so we can’t pin the date down precisely. Either way, its status as “the editor most developers open every single day” isn’t in question.
• AI duty is entirely handed off to the Copilot extension: VS Code itself has no separate AI subscription — everything runs through the GitHub Copilot extension, which extends all the way to agent mode, MCP (Model Context Protocol) support, and Git-worktree-based isolated sessions (letting you run Copilot, Claude, and Codex sessions side by side at the same time). In June–July 2026, the Agents panel UI was redesigned so files and diffs now display next to the chat pane, and dictation was added across chat, the editor, and the terminal.
• The billing model changed completely: As of June 1, 2026, GitHub Copilot scrapped its old “Premium Request” billing and switched to AI credits (token-based). The baseline lineup is Free at $0, Pro at $10/month, Pro+ at $39/month, Business at $19/user/month, and Enterprise at $39/user/month, with a Max plan for extremely heavy agent usage listed at $100/month — though some sources also describe it as “including $200 worth of AI credit,” so the exact list price isn’t entirely settled. Volume discounts kick in at 5% for 10+ seats, 10% for 25+ seats, and 15% for 50+ seats.
• Marketplace size: Microsoft’s officially stated extension count is 100,000+ (36,000 language extensions, 9,400 debuggers, as of May 2025). We couldn’t confirm a precisely updated official figure as of August 2026, but there’s no reason to think the total has shrunk.
• Agentic browser tooling reaches GA: An agentic browser tool that can navigate pages, take screenshots, and verify results has shipped as a general-availability feature, alongside the ability to register your own model providers directly through the Language Models editor.

🟣 2) Cursor — The AI-Native Editor That Redrew the Whole Canvas

• Started as a VS Code (Code-OSS) fork, but it’s now a fundamentally different product: It’s widely known in the industry that Cursor forked the VS Code codebase, but Cursor 2.0, released October 29, 2025, completely redesigned the UI from file-centric to agent-centric. The core of that redesign is a multi-agent architecture that runs up to 8 parallel agents, each in its own independent workspace.
• Its in-house Composer model: Composer, the in-house coding model Cursor introduced with 2.0, is now up to Composer 2.5, and the company claims it’s “4x faster than similarly capable models and finishes most conversational turns in under 30 seconds.” That’s a self-reported figure, though, and hasn’t been re-verified by third-party benchmarks.
• Pricing runs on a credit system: Hobby (free, no card required) gives you 2,000 tab completions a month plus 50 slow premium requests. Pro at $20/month includes unlimited Tab completions and a credit pool worth about $20. Pro+ at $60/month is described inconsistently across sources — either “3x the credits of Pro” or “worth about $70” — but either way, the rough multiplier lands around 3x. The top-tier Ultra at $200/month offers 20x the usage and early access to new features.
• Team and enterprise pricing: Teams Standard runs $40/user/month ($32 when billed annually), and the newly launched (2026) Teams Premium is $120/user/month, offering 5x the usage of Standard. Enterprise is negotiated separately (pooled usage, invoice/PO billing, access controls, and audit logs), annual billing gets you roughly a 20% discount across every plan, and students who verify with a .edu email get a full year of Pro for free.
• The biggest news of July 2026: Automations launched, letting you trigger a coding agent automatically from a code change, a Slack message, or a timer, and a public beta of Cursor for iOS opened up to every paid plan. Back in June, Cursor split the usage pool for Teams seats into a separate pool for its own models (Composer/Auto) versus third-party APIs (Claude/GPT/Gemini).

🟠 3) JetBrains (IntelliJ IDEA) — A Refactoring Engine at Its Peak

• 2026.2 ships: IntelliJ IDEA 2026.2, released in July 2026, supports Java 27 from day one and picks up Kotlin 2.4’s newest language features. Spring development workflows (database migrations, Spring Security insights) got better, log points were added, and navigation from runtime output straight back to source code was strengthened. This release alone closes out more than 1,300 bug fixes and 140 freeze/performance issues.
• AST-based refactoring, polished over 20-plus years: JetBrains’ biggest weapon is its static-analysis and refactoring engine built on the abstract syntax tree (AST). The fact that operations like renaming, extract-method, and change-signature are all handled in a type-safe way within a single-language ecosystem is a strength widely praised across the industry.
• The IDE license and AI Assistant are billed separately: An individual IntelliJ IDEA Ultimate license runs $199/year for year one, and it gets progressively cheaper if you renew — $159 in year two, $119 in year three. An organizational (business) license is $719/user/year. There’s also a monthly billing option, but it works out more expensive overall (for example, $19.90/month annualizes to roughly $239).
• AI Assistant runs on a credit system: AI Free gives you 3 credits every 30 days plus unlimited code completion. AI Pro is $10/month for individuals ($8.33/month billed annually) for 10 credits a month (business seats are $20/month for 20 credits). AI Ultimate is $30/month for individuals ($25/month annually) for 35 credits a month (business seats are $60/month for 70 credits). AI Enterprise is $60/user/month (billed annually), and subscribers to the All Products Pack or dotUltimate get AI Pro bundled in at no extra cost. Each credit is worth roughly $1, though the burn rate varies by model and feature, and you can buy extra credits (valid for 12 months) if you run out.
• Qualitative strengths: Numerous third-party comparison articles credit JetBrains with a real edge in type-safe refactoring within a single-language ecosystem, though we couldn’t confirm any precise numerical benchmark backing that up.

🟢 4) Zed — Native Speed, No Electron Attached

• The 1.0 stable launch is the headline event: On April 29, 2026, Zed dropped the “preview” label and shipped 1.0 stable. Built by a team of former Atom developers over five years, it was rebuilt from scratch on top of GPUI, an in-house, Electron-free GPU rendering framework written in over a million lines of Rust. Some outlets have called this “the end of the Electron era.”
• Its own completion model, Zeta: Zed’s flagship weapon is Zeta (now Zeta2), its in-house, self-hosted autocomplete model. The agent panel supports 15+ LLM providers, including Claude Opus/Sonnet, GPT-5.6, GPT-5.4, Gemini, and local Ollama models, and Terminal Threads, added in May 2026, lets you run Claude Code or Amp as a sidebar agent.
• Three pricing tiers: Personal (free) gives you up to 2,000 Zeta2 edit predictions a month, and AI usage itself is unlimited if you bring your own API key. Pro at $10/month includes unlimited edit predictions plus $5 worth of hosted AI credit each month, with overages billed at API list price plus 10%. Business at $30/seat/month adds org-wide model policies, data governance, role-based access control (RBAC), and unified spend visibility, with no minimum seat count.
• Full feature parity across platforms: The rendering backend is Metal on macOS, DirectX 11 on Windows, and Vulkan on Linux. When Windows switched to the DirectX 11 backend in 2026, it achieved full feature parity with the macOS and Linux versions.
• Speed: qualitative and quantitative claims: One third-party benchmark article reported Zed cold-starting in about 0.12 seconds (under 500ms), input latency around 2ms, UI rendering at 120fps, and roughly 222MB of idle memory. These are self-measured numbers from a single benchmark article, not figures cross-verified by multiple credible sources — a caveat we’ll revisit in Section 3.

⚪ 5) Neovim — Completely Free, Extreme Customization

• The 0.12.0 major release: Released March 29, 2026, 0.12.0 is the first major release in over a year since 0.11. It adds a built-in plugin manager, vim.pack (still labeled experimental but stable enough for everyday use), a :restart command that reloads without quitting, and native insert-mode autocomplete, while removing the old LspInfo/LspRestart/LspLog commands in favor of a unified :lsp command. Synchronized terminal output, scrollback-clear support, and an experimental Zig-toolchain-based build system all landed alongside it. Patches have continued through 0.12.4 since.
• Completely free — there’s no paid tier at all: Neovim is fully free, open-source software under a mixed Vim-license/Apache-2.0 scheme. AI integration isn’t an official first-party feature; it only happens through third-party plugins like avante.nvim, CodeCompanion.nvim, and copilot.vim/copilot.lua. In other words, any “AI subscription fee” isn’t charged by Neovim itself — it’s billed by whatever model or service the plugin connects to (Copilot, the Claude API, and so on).
• Core architecture: The backbone is a built-in LSP (Language Server Protocol) client, integrated Tree-sitter parsing and highlighting, Lua-based configuration and API, and a lightweight architecture that runs equally well in the terminal or a GUI.
• The 1.0 roadmap is still unconfirmed: Around March 2026, the team did mention shipping “Neovim 1.0 within 2026,” but our research couldn’t confirm whether 1.0 has actually shipped or nail down a firm date. Rather than guess, the accurate summary is simply “presumed not yet released.”
• Qualitative strengths: We couldn’t find a current official or third-party figure for exact cold-start time or memory usage, but the qualitative verdict — “very light and very fast” — has been consistent for a long time.

3. Speed and Resource Benchmark Showdown

Performance benchmarks are the part of this code editor comparison that demands the most care. We couldn’t find a credible, unified benchmark that measured all five products under the same conditions, and the numbers below come from a single third-party benchmark article comparing Zed and VS Code. For Cursor, JetBrains, and Neovim, we couldn’t obtain quantitative figures measured on the same basis, so those are marked as qualitative assessments only.

[Perceived speed & lightness ranking — mix of a single benchmark and qualitative review, not an official unified figure]
Zed       : ⭐⭐⭐⭐⭐ Cold start ~0.12s (single benchmark), no Electron
Neovim    : ⭐⭐⭐⭐☆ No quantitative figure, but widely reviewed as "very lightweight"
VS Code   : ⭐⭐☆☆☆ Electron-based; cited cold start of ~1.2s in that same single benchmark
Cursor    : ⭐⭐☆☆☆ Built on a VS Code (Electron) fork, so structurally expected to be similarly heavy (unmeasured); its "4x faster" claim is about AI response latency — a separate axis
JetBrains : ⭐⭐☆☆☆ JVM-based desktop app, generally reported as heavy to launch (unmeasured); refactoring accuracy is a separate strength, not a speed measurement

Judging by the numbers alone, Zed looks overwhelmingly ahead, but you have to keep in mind that every cold-start, input-latency, and memory figure in this table is a self-reported comparison from a single third-party benchmark article — none of it has been cross-checked against Zed’s official blog or an independent, second benchmark. The general direction — that Electron-based editors run relatively heavier — is a fact the industry broadly agrees on, but pinning down “exactly how many times heavier” from this one source alone would be overstating the evidence.

Since Cursor forked VS Code (Code-OSS), the underlying architecture’s weight is presumably not all that different from VS Code’s, but the response speed claimed for its in-house Composer model (“4x faster than similarly capable models”) is a self-reported figure and deserves to be judged with a different level of confidence. JetBrains is generally regarded as launching on the heavier side, given its JVM-based desktop app nature, but the trade-off here is that the weight buys back accuracy in AST-based static analysis and refactoring. And even without a quantitative benchmark, there’s little disagreement that Neovim’s terminal-native architecture itself sits among the lightest of the bunch.

4. Complete Pricing Comparison

[Whether the editor itself is free, ordered by lowest AI add-on price]
Neovim              : Completely free; AI is billed separately by whatever service a third-party plugin connects to
VS Code             : Editor is free; Copilot Free at $0 (limited features)
Zed                 : Personal is free (2,000 Zeta2 predictions/month), Pro at $10/month (includes $5 of credit)
Cursor              : Hobby is free (2,000 tab completions + 50 slow requests), Pro at $20/month
JetBrains (IDE+AI)  : IDE at $199/year + AI Free (3 credits/30 days) — paid AI starts separately at $10/month

💰 Detailed Pricing Comparison Table

There are three things worth flagging from a hidden-cost perspective. First, JetBrains’ IDE license and AI Assistant are entirely separate subscriptions. Add IntelliJ IDEA Ultimate’s $199/year to AI Pro’s $10/month ($120/year), and your total first-year cost reaches $319 — so don’t budget under the assumption that “buying the IDE is the whole cost.” If you’re already subscribed to a higher-tier bundle like the All Products Pack or dotUltimate, AI Pro comes bundled in for free, so it’s worth checking that first if you’re already in the JetBrains product family.

Second, both Cursor and JetBrains require you to think about actual usage in terms of “credits.” Cursor Pro+‘s exact credit multiplier is described inconsistently — sometimes as “3x,” sometimes as “worth about $70” — and JetBrains AI credits burn at different rates depending on the model and feature, so even at the same $10/month, how far your credits actually stretch depends heavily on which model you use and how much. For both products, we’d recommend treating the first month as an observation period to see how fast credits actually deplete.

Third, none of Cursor, Zed, or JetBrains AI publish an official fixed price in Korean won (KRW). For all three services, we couldn’t find evidence of an officially posted KRW price; it appears your card’s exchange rate is simply applied at checkout. If you’re budgeting in a currency other than US dollars, keep in mind that the amount you actually pay can shift with the exchange rate on the day you’re billed.

5. Final Recommendations by User Type

🎯 1) Developers Who Move Between Languages and Want to Max Out an Extension Ecosystem

• Best pick: VS Code
• Why: With over 100,000 marketplace extensions and a still-dominant market share, you can handle whatever language or framework comes your way without a hitch. Just bolt on as much (or as little) AI as you need through the Copilot extension.

🎯 2) Developers and Teams Who Want to Hand Off a Large Share of the Coding to AI Agents

• Best pick: Cursor
• Why: The combination of a multi-agent architecture that runs up to 8 agents in parallel and its in-house Composer model gives Cursor the deepest AI integration of any of the five products. Layer on Automations and you can trigger agents automatically from a Slack message or a code change. If you want to dig deeper into the AI coding agents themselves, we’d also recommend our Cursor vs. GitHub Copilot vs. Cline vs. Windsurf comparison.

🎯 3) Teams Doing Frequent Large-Scale Refactoring in a Specific Ecosystem — Java, Kotlin, Spring

• Best pick: JetBrains (IntelliJ IDEA)
• Why: The accuracy of its AST-based refactoring engine has been refined for over 20 years, and 2026.2 further strengthened Spring tooling and log points. As long as you can stomach having the highest combined total cost between the IDE and AI subscriptions, JetBrains has a clear edge in large-codebase safety.

🎯 4) Developers on Lower-Spec Machines, or Anyone Who Cares About Battery Life

• Best pick: Zed
• Why: Thanks to its own Electron-free GPUI renderer, Zed gets rated as the lightest of the bunch in both perceived speed and resource usage. Factor in its cheap $10/month Pro tier for AI, and it’s a great value pick for individual developers.

🎯 5) Experienced Developers Who Love a Terminal Workflow and Want to Configure Everything Themselves

• Best pick: Neovim
• Why: Being completely free and open-source, plus having a built-in plugin manager like vim.pack, makes extreme customization possible. You do have to wire up AI yourself through plugins like avante.nvim or CodeCompanion.nvim, but that also means total control over exactly which model you use and how.

🎯 6) Solo Developers Who Want to Keep Costs Near Zero While Still Dabbling in AI

• Best pick: VS Code (Copilot Free) or Zed (Personal)
• Why: Both let you sample AI features without registering a card. Copilot Free is limited in features but lets you keep the entire extension ecosystem intact, while Zed Personal gives you 2,000 free Zeta2 predictions a month and effectively unlimited AI once you connect your own API key — pick whichever direction fits your budget and taste.

6. Practical Tips and Common Mistakes

✅ Tip 1: Don’t Miss VS Code Copilot’s Billing Overhaul (June 1, 2026)

As of June 1, 2026, Premium Request billing was scrapped in favor of AI credits (token-based). Any old tutorial or blog post still talking about “so many Premium Requests” no longer matches the real billing structure, so always double-check the current credit-based guidance before you calculate what something will cost you.

✅ Tip 2: Verify Cursor Pro+/Ultra Against Your Actual Usage First

Just as Pro+‘s exact credit multiplier gets described as either “3x” or “worth about $70” depending on the source, the official page’s numbers alone won’t tell you how far the credits actually go in practice. We’d suggest running Pro ($20/month) for a real month, watching how fast the credits burn, and only then deciding whether to upgrade.

✅ Tip 3: Check JetBrains AI Credit Burn Rates by Model Before You Commit

Each credit is worth roughly $1, but the burn rate differs by model and feature. If your workflow leans on heavier models often, AI Pro’s 10 credits a month can disappear fast — treat the first month as an observation period, and bump up to AI Ultimate (35 credits/month) if you need to.

✅ Tip 4: Remember That Zed’s “Speed” Numbers Come From a Single Benchmark

Numbers like a 0.12-second cold start and 2ms input latency are genuinely appealing, but they come from a single third-party benchmark article with no independent cross-verification we could find. Rather than resting your decision on that one number, it’s safer to spend a few days with it yourself and judge by how responsive it actually feels in your own workflow.

✅ Tip 5: With Neovim, Choosing an AI Plugin Is Choosing a Pricing Plan

Neovim itself is completely free, but depending on which plugin you attach for AI — avante.nvim, CodeCompanion.nvim, copilot.vim/copilot.lua, and so on — the entity actually billing you could end up being GitHub Copilot or the Anthropic API. Don’t mistake Neovim for “free AI”; check the pricing plan of whatever service you’re actually connecting to.

✅ Tip 6: Don’t Switch Editors All at Once — Run Both in Parallel for a While

If you switch every keybinding, extension, and setting all at once when moving from Cursor (a VS Code fork) to JetBrains or Zed, your productivity will take a temporary nosedive. It’s much safer to run your old editor and the new one side by side for two to four weeks, migrating shortcuts and workflows gradually.

7. Frequently Asked Questions (FAQ)

Q. What’s the first thing I should check in a code editor comparison?

How deeply you plan to lean on AI agents, and how specialized you need to be within a specific language ecosystem. Nail down those two axes and you’ll already narrow the five candidates down to one or two. Budget comes next — since so many of these products keep the editor’s own price and the AI add-on price completely separate, it’s safest to check the pricing table in Section 4 alongside your decision.

Q. Which is better for AI coding — VS Code or Cursor?

VS Code’s strength is the flexibility of bolting on exactly as much AI as you want through the Copilot extension, while Cursor — having been redesigned around agents from the ground up — offers deeper integration for advanced AI workflows like multi-agent parallel work. If you want to keep your existing VS Code extension ecosystem intact and just beef up the AI, go with VS Code + Copilot; if AI agents themselves are your central workflow, Cursor is the better fit.

Q. Is JetBrains AI Assistant included in the IDE license?

No, it’s a separate subscription. The IntelliJ IDEA Ultimate license (starting at $199/year) and AI Assistant (Free through Enterprise, $10–$60+/month) are entirely separate products. That said, if you’re already subscribed to a higher-tier bundle like the All Products Pack or dotUltimate, AI Pro is included at no extra cost.

Q. Is Zed really faster than VS Code?

A single third-party benchmark article cited Zed’s cold start at about 0.12 seconds versus roughly 1.2 seconds for VS Code, but that’s a self-reported comparison from one source, not a cross-verified figure from multiple credible institutions. The general direction — that Zed’s Electron-free architecture is structurally lighter — is trustworthy, but we’d recommend judging the exact magnitude for yourself rather than taking that multiplier at face value.

Q. Can I use the latest AI agents in Neovim too?

Yes. Third-party plugins like avante.nvim, CodeCompanion.nvim, and copilot.vim/copilot.lua let you connect Claude, the GPT family, GitHub Copilot, and more. Since this isn’t an official first-party feature, though, you have to handle setup and maintenance yourself, and billing comes from whichever API or service you connect to — not from Neovim.

Q. How fast is Cursor 2.0’s multi-agent feature, really?

Anysphere states that its in-house Composer model is “4x faster than similarly capable models and completes most conversational turns in under 30 seconds.” That said, it’s a self-reported figure that hasn’t been re-verified by any third-party benchmark, so the speed you actually experience can vary depending on your project’s size and the kind of task at hand.

Q. What’s the biggest change in IntelliJ IDEA 2026.2?

The biggest change is day-one support for Java 27 alongside Kotlin 2.4’s newest language features. On top of that, Spring development workflows got better, log points were added, and navigation from runtime output straight to source code was strengthened — together with over 1,300 bug fixes and 140 resolved freeze/performance issues in this release.

Q. Is it okay to mix and match all five editors depending on the task?

That’s a perfectly practical strategy. A common combination, for instance, is JetBrains for the main backend team, VS Code or Cursor for frontend and framework experimentation, and Zed or Neovim for personal side projects. Which editor fits best can also depend on which web framework a project uses, so if you haven’t settled on a framework yet, our Next.js vs. React vs. Vue vs. Astro vs. Svelte web framework comparison is worth a look too.

Q. Does this code editor comparison still apply in a container-based development setup?

For the most part, yes. VS Code handles it through the Dev Containers extension, JetBrains through its Docker integration plugin, and Neovim by connecting directly into the container from the terminal to edit. If you want to compare the container and orchestration tools themselves, our Docker vs. Kubernetes container tools comparison can help.

8. Conclusion: The Practical Takeaway From the 2026 Code Editor Comparison

As of August 2026, the conclusion of this code editor comparison is that “how AI gets integrated” is what decides the winner. VS Code answers through the flexible layer of extensions, Cursor through redesigning the editor itself, JetBrains by building on a mature static-analysis engine, Zed through native speed and its own model, and Neovim through complete openness — five different answers to the same question. It’s hard to call any single one absolutely superior; ultimately, your own answers to two questions — “how much judgment am I willing to hand over to an AI agent?” and “how deeply specialized do I need to be in a particular language ecosystem?” — are what determine the right choice.

In practice, a diversified strategy still holds up well. A common split is JetBrains for backend teams doing frequent large-scale refactoring, Cursor for new AI-agent-driven development, VS Code for projects that need a general-purpose extension ecosystem, and Zed or Neovim for low-spec machines or personal projects. That said, given how much has genuinely changed in just the last six months — GitHub Copilot’s switch to credit-based billing (June 1, 2026), Cursor splitting its Teams usage pool, the JetBrains 2026.2 release, Zed’s 1.0 stable, and Neovim’s 0.12 major release — it’s worth building the habit of double-checking the official page one more time before signing a contract or migrating.

[Summary: The final recommendation for your situation]

Generalist developer, maximizing the extension ecosystem
  → VS Code (free editor, Copilot Free to Pro at $10/month)

AI-agent-driven parallel development
  → Cursor (Hobby free to Pro at $20/month, up to 8 agents)

Deep user of a specific ecosystem — Java/Kotlin/Spring
  → JetBrains (IDE at $199/year + AI Pro starting at $10/month)

Low-spec machine, speed above all
  → Zed (Personal free, Pro at $10/month)

Terminal workflow, extreme customization
  → Neovim (completely free, AI via third-party plugin connections)

Settle on your project’s nature and how much you plan to lean on AI first, then layer the current pricing on top of that — and you’ll make a choice that won’t get tripped up when the billing structure changes again a few months down the road.