![Zed vs VS Code vs JetBrains: $10 Pro, $0 Core [2026]](https://shattered.io/wp-content/uploads/2026/11/zed-vs-vscode-vs-jetbrains-pricing-agents-2026-gen.webp)
Zed vs VS Code stopped being a simple speed contest this fall. Microsoft shipped Visual Studio Code 1.144 on October 28, 2026 with Copilot Fusion multi-model orchestration, AI image generation and experimental desktop computer control. Zed’s stable channel reached 1.26.2 the same day, and JetBrains made Air Governance generally available on October 22. Three editors, three very different ideas about who should run your coding agents.
JetBrains is hedging its bets, too. The company now sells its Java and Kotlin intelligence inside rival editors, and the JetBrains Java and Kotlin extension for VS Code and Cursor has since reached version 1.0. That tells you where the market sits. A decade of picking one IDE and living inside it is giving way to mixed setups, where the editor, the agent and the billing meter come from different vendors.
So the useful question in November 2026 is not which editor wins. It is where your agents run, who pays for the tokens, and how much of your day depends on a deep debugger and refactoring engine. Current versions, current prices and the numbers vendors have actually published answer that below, followed by a migration plan and a verdict.
Don't miss new tech stories on Google
Add Shattered once in the Google app and our stories show up in your news suggestions.
Where Zed, VS Code and JetBrains Stand on November 4, 2026 #
Start with the release state, because it shapes everything else. Zed ships weekly. Its newest stable build is 1.26.2, dated October 28, and a preview build numbered 1.27.0 carries the same date on Zed’s release page. The recent notes read like a working developer’s wish list: syntax highlighting for Go 1.27 generic methods, an option to open README files by default, and AI-written commit messages that follow the style of your repository’s recent commits.
Zed also cut some old hardware loose. Its release notes removed support for macOS Catalina and Big Sur, so the editor now requires macOS 12.0 (Monterey) or later. Windows and Linux builds remain available. If your team still runs a fleet of aging MacBooks, that line item matters more than any benchmark.
Visual Studio Code is on 1.144, released October 28, and the editor is free for private and commercial use. The headline change is less about the editor and more about agents. Microsoft made a new Copilot harness the default for new sessions in the editor and the Agents window, published version 1.0 of the open Agent Host Protocol, and moved a modernized interface (with new Dark 2026 and Light 2026 themes) from preview to the default, with a way back to the classic look during the transition.
VS Code also keeps a few hard edges that matter on older machines. The last stable release to support 32-bit Windows is 1.83, and desktop builds on Linux need a distribution based on glibc 2.28 or later. Neither limit is new, but both explain why some corporate fleets lag behind the current build.
JetBrains is the hardest to summarize because it is not one product. IntelliJ IDEA 2026.2.4 is the latest update on its blog, and posts about the 2026.3 line (sound cues, remote development session management) are already out. On top of the IDEs, JetBrains announced Air in October as a system of products for agentic development. Air Governance, the product formerly called JetBrains Central, became generally available on October 22 and gives organizations control over agents, models, providers and spending.
One more recent item deserves a flag. JetBrains reportedly added GitHub Copilot to Air on November 3 for local and cloud tasks, with Copilot usage billed through the user’s Copilot plan rather than JetBrains AI credits. Cloud use reportedly needs Air Teams and administrator enablement. Treat that as a fresh launch whose details may still shift.
No successor product hangs over any of the three. Zed’s preview channel is the closest thing to a next release, and it is a normal weekly step rather than a new generation. That makes this a clean moment to compare, since nobody is waiting on a major version that would rewrite the answer.
Zed vs VS Code vs JetBrains: Full Specs Table #
The table below lines up twelve attributes using dated vendor material from the last few weeks. JetBrains cells stay general where the company ships many IDEs with different requirements. Where a vendor has not published a figure, the cell says so instead of guessing.
| Spec | Zed | VS Code | JetBrains |
|---|---|---|---|
| Latest stable build | 1.26.2 (Oct 28, 2026) | 1.144 (Oct 28, 2026) | IntelliJ IDEA 2026.2.4 (latest blog update) |
| Base price | Free Personal plan | Free, including commercial use | Paid IDE subscriptions, discounts for students, startups, nonprofits |
| AI add-on price | Pro at $10/month | GitHub Copilot, free and paid plans | JetBrains AI plus Air plans |
| Platform limits | macOS 12.0 or later, Windows, Linux | No 32-bit Windows after 1.83, Linux needs glibc 2.28 or later | System requirements vary by IDE |
| Agent plumbing | External agents with session notices, context compaction | Agent Host Protocol 1.0, persistent sessions | Agent Client Protocol agents: Claude Agent, Codex, Gemini CLI, Junie |
| Model access | BYOK for GPT-6.1 Sol, Bedrock lists GPT-6 Astra, Claude Fable 5.1, Claude Opus 5.5 | Copilot Fusion orchestrates multiple models | Junie, Mellum2.1, third-party agents |
| Agent isolation | OS-enforced sandbox, default since 1.14 | Copilot harness default for new sessions | Air Governance controls access and spend |
| Admin controls | Zed for Business, SSO, SAML and SCIM planned, not shipped | Organizational Copilot licensing | Air Governance, generally available Oct 22 |
| Collaboration | Real-time collaboration built into the editor | Agent sessions continue across VS Code, GitHub apps, Copilot CLI | Air runs agents across IDEs, CLI, browsers, mobile |
| In-house model | Zeta2.1 edit predictions | Copilot inline suggestions model | Mellum2 (12B, open source), Mellum2.1 |
| Recent interface change | Binaries 33% smaller on macOS | Modern UI on by default | 2026.3 adds sound cues, remote session management |
| Student and discount offers | Student plan includes Pro features | Not applicable, editor is free | 40% off former students, 50% off universities |
Read the table by row, not by column. Rows four through eight are where the editors diverge most, and they all concern agents. The base price row looks like a landslide for the free options, but it hides the fact that the price of a coding session now sits in the model tokens, not the editor license.
Row five deserves a second look. Three protocols are competing to become the plug between an editor and an agent: Microsoft’s Agent Host Protocol, which just hit 1.0, JetBrains’ use of the Agent Client Protocol, and Zed’s support for external agents with session notices. If one of them becomes the default, the editor you pick today will matter less than the agent you plug into it. Choosing an editor that speaks an open protocol is the cheapest insurance against that shift.
Speed, Memory and the Numbers Vendors Actually Publish #
Every Zed vs VS Code thread eventually argues about startup time and RAM. The honest answer is that none of the three vendors published a same-machine, same-repository measurement across all three editors this fall. What exists are vendor-reported efficiency figures, each measuring something different. They are worth reading, as long as you do not stack them into a ranking.
| Data point | Value | Reported by | What it measures |
|---|---|---|---|
| Zed binary size, macOS | About 33% smaller | Zed release notes | Download and install footprint |
| Zed binary size, Windows | About 28% smaller | Zed release notes | Download and install footprint |
| Zed binary size, Linux | About 7% smaller (23% on the x86_64 release binary) | Zed release notes | Download and install footprint |
| Zeta2.1 edit predictions | 3x fewer tokens, 50 ms faster | Zed | Inline prediction cost and latency |
| Copilot inline suggestions, configurable eagerness | 29% lower dismissal rate, 28% shorter suggestions vs medium | VS Code team blog | Suggestion quality at a chosen eagerness setting |
| VS Code team focus | 50/50 split between AI and other features | VS Code Wrapped post | Engineering allocation |
| Mellum2 size | 12 billion parameters, open source since June 1 | JetBrains | Model scale for coding workflows |
Three vendors, three kinds of evidence. Zed’s numbers describe the cost of carrying and running the app, plus the cost of its prediction model. Microsoft’s numbers describe how developers react to suggestions. JetBrains’ figure describes the size of its own model. None of them tells you how fast a 400,000-line monorepo opens on your laptop.
The Zeta2.1 figure is the most useful for budgeting. Fewer tokens per prediction should mean lower model spend, and Zed Pro bills overage at API list price plus 10%. If the savings carry over to hosted usage, a model that needs a third of the tokens makes that markup less painful. Microsoft’s eagerness data points a different way. It tells you that suggestion volume is a dial, and that the default setting is not always the best one for your team.
Measure it yourself in 10 minutes. Your repository, your plugins and your OS decide the result, so run the check on your own machine. The script below launches one editor on a repository, waits 45 seconds for indexing and extensions to settle, then sums resident memory across every process whose name matches. Run it once per editor, on a clean login, with the same repository checked out at the same commit.
#!/usr/bin/env bash
set -euo pipefail
LAUNCHER="$1"; PATTERN="$2"; REPO="$3"
start=$(date +%s.%N)
"$LAUNCHER" "$REPO" &
sleep 45
ps -eo rss,comm | awk -v p="$PATTERN" '$2 ~ p { sum += $1 }
END { printf "%s idle RSS: %.0f MB\n", p, sum / 1024 }'
echo "wall clock since launch: $(echo "$(date +%s.%N) - $start" | bc) s"
Repeat three times and take the median. Then run the same four tasks in each editor: open a large file, search the whole repository, trigger a rename across files, and attach a debugger to a failing test. Note which editor you reach for when a build breaks at 5 p.m. That qualitative pass beats any synthetic number, and it is the only one that reflects your stack.
AI Agents: Three Different Bets #
The sharpest difference between these editors is who owns the agent. VS Code bets on Microsoft’s own stack. Zed bets on openness and sandboxing. JetBrains bets on being the control plane for whatever agent you bring. Each choice has a cost, and each is visible in the October releases.
Microsoft’s side is the most integrated. Agent Host, announced August 26, lets sessions persist when you close an editor window or a folder, and it works across local and remote clients. By October 28 the company said you can continue the same agent session across VS Code, the GitHub Copilot app, GitHub Mobile, GitHub.com and Copilot CLI. It also published the Microsoft Copilot harness as the multi-model foundation. Copilot Fusion then bills each model it invokes at that model’s standard rate, with a 30% discount for paid Copilot plans through November 30, 2026.
Connectors are the other new piece. Copilot connectors for Slack, Notion and Microsoft Learn entered preview on October 28, and they supply agent context without making you install or manage an MCP server. That is a real convenience for small teams. It also ties your context pipeline closer to one vendor.
Zed takes the opposite posture. Its Personal plan allows your own API keys or external agents, and recent release notes add bring-your-own-key support for GPT-6.1 Sol with an OpenAI key. The Amazon Bedrock provider now lists GPT-6 Astra, Claude Fable 5.1 and Claude Opus 5.5. A stable release added context compaction and session notices for external agents. For security, Zed enforces sandboxing at the operating-system level for the agent panel’s terminal and fetch tools, and it says sandboxing is on by default for all users starting with release 1.14.
Zed’s September 16 launch of Delta in public beta extends the story beyond the editor. Delta is pitched as a replacement for pull requests, and Zed said it disabled pull requests on Delta’s own repository and now builds Delta inside Delta. Pro trial credit is shared between Zed and Delta, so the two products already share a wallet.
JetBrains positions Air Governance as the layer above all of this. As of October 22 it referenced Claude Agent, Codex, Gemini CLI, Junie and other agents built on the Agent Client Protocol, across IDEs, the command line, browsers and mobile. JetBrains also wrote on October 20 that IDEs remain necessary even as agentic development grows. Given that its customers pay for deep code intelligence, that argument is predictable, but the product work backs it up. Recent IDE releases give agents IDE intelligence, skills for testing, profiling and refactoring, and native GitHub Copilot integration.
Inline completion is the quieter battleground. Zed runs its own edit-prediction model, Zeta2.1. Microsoft shipped a retuned Copilot inline suggestions model this fall and added a configurable eagerness setting so users can decide how readily suggestions appear. JetBrains builds Mellum models, including the open Mellum2 at 12 billion parameters and the newer Mellum2.1 aimed at coding agents and fast sub-agents. The three approaches reflect the three business models: Zed sells credits, Microsoft sells Copilot seats, and JetBrains sells subscriptions plus governance.
For a solo developer who already pays for a Claude or OpenAI plan, Zed and JetBrains Air let you keep that relationship. For a company that standardized on GitHub, VS Code’s integrated path has the least friction. For a regulated shop that needs a ledger of which agent touched what and what it cost, JetBrains has the most mature story right now, with Zed’s Business tier still missing SSO, SAML and SCIM.
Pricing Compared: What You Pay in November 2026 #
Editor pricing is now two bills in one: the license for the tool, and the metered cost of model usage. Zed publishes the clearest numbers, tracked in a pricing history of Zed’s plans and on Zed’s own pricing page. Microsoft keeps the editor free and sells Copilot separately. JetBrains sells subscriptions by product and publishes discount tiers.
| Plan or offer | Price | What you get | Fine print |
|---|---|---|---|
| Zed Personal | Free | 2,000 accepted edit predictions per month, own API keys or external agents | Report dated Nov 3, 2026 |
| Zed Pro | $10/month | Unlimited accepted edit predictions, hosted token credits, real-time collaboration | Pricing FAQ refers to $5 of included credits |
| Zed Pro overage | API list price plus 10% | Extra hosted token usage | Billed at month end or every additional $10, whichever comes first |
| Zed Pro trial | Free for 14 days | $5 of GPT-6 Luna usage, unlimited accepted edit predictions | Ends at $5 spent or 14 days, shared with Delta |
| Zed Student | Free for eligible students | Everything in Zed Pro | Verified university students |
| VS Code editor | Free | Full editor, private and commercial use | Insiders build gets daily updates |
| GitHub Copilot in VS Code | Free and paid plans | Inline suggestions, agents, Fusion | Paid plans get 30% off Fusion through Nov 30, 2026 |
| JetBrains Java and Kotlin extension for VS Code and Cursor | Free 30-day trial | IntelliJ IDEA code intelligence in other editors | Then needs a paid IntelliJ IDEA subscription |
| JetBrains discounts | 25% to 50% off | Former students 40%, universities 50%, startups under 5 years 50% for up to 10 licenses, nonprofits 25% to 50%, competing-tool owners 25% on All Products Pack | Apply to commercial and All Products Pack subscriptions |
| JetBrains AI credits (business) | Credits valid 12 months | Replaces monthly AI licenses for business customers | Not listed |
Two caveats keep this table honest. First, Zed’s own pages disagree with each other on the size of the Pro credit. The pricing FAQ mentions $5 of token credits, while the student-plan description lists $10 per month in credits. Budget on the lower figure and check the live page before you sign anyone up. Second, this comparison quotes no figure for GitHub Copilot plans or JetBrains IDE subscriptions. Those prices change by plan, term and region, so read them off the vendor store on the day you buy.
Simple arithmetic still helps. Ten developers on Zed Pro cost $100 a month before any overage, or $1,200 a year. The meaningful variable is agent usage. Because overage bills at list price plus 10%, a team that runs long agent sessions all day will pay more in tokens than in licenses, whichever editor it uses. In VS Code the same dynamic shows up in Copilot billing, and in Air it shows up in whichever agent plan you route through it.
Three habits keep the bill predictable. Set a monthly token ceiling per developer and review it weekly for the first month. Route routine edits to the cheapest model that passes your tests, and save the frontier models for hard problems. And use the 14-day Zed trial or the Fusion discount window to measure real usage before you commit a team budget.
Extensions, Languages and Ecosystem Depth #
This is where VS Code has historically ended the argument, and the October releases show Microsoft is not letting up. Version 1.144 adds a marketplace-style Browse interface for discovering plugins, skills and other agent tools. The Copilot connectors go a step further by replacing some extension installs with managed context sources. The code lives in the public microsoft/vscode repository on GitHub, and the sheer number of language extensions means it is rare to find a stack VS Code cannot at least open.
Zed’s ecosystem is smaller and more curated, and the weekly notes show where the effort goes. Go 1.27 generic-method highlighting arrived in the October 28 release. JSONL and NDJSON table previews shipped in an earlier preview release. Zed also reportedly added an optional built-in Python language server, Pyrefly, in the latest stable. Outside contributors get named credit in release notes (the Go highlighting change, for example, thanks a community contributor), which suggests a healthy flow of patches even without VS Code’s marketplace scale.
JetBrains plays a different game. Each IDE ships with refactoring, inspections, debuggers and framework support built in, so you install fewer plugins to get the same result. The Plugin Developer Conf on November 10 shows the marketplace still matters, but the real draw is that IntelliJ IDEA, PyCharm, WebStorm and Rider work out of the box. That is why the Java and Kotlin extension for VS Code and Cursor is such a telling move. According to JetBrains, Netflix tested the Java IDE intelligence before it shipped in the extension, and the product now brings that engine to editors JetBrains does not own.
The practical rule: if your work spans many small languages and tools, VS Code’s breadth wins. If you live in one heavy stack (Java, Kotlin, .NET with Rider, or large TypeScript codebases) the JetBrains depth pays back. If you want a fast editor with a clean AI surface and you are fine installing fewer extensions, Zed fits. The quality gap shows up less in features and more in how many of them you have to assemble yourself.
Teams that mix stacks can split the difference. Cursor, Cline and Kilo Code occupy the same VS Code-shaped slot with different agent designs, and the coding and developer tools section tracks how they stack up against the three editors here.
Collaboration, Local Models and Offline Work #
Real-time collaboration is one of Zed’s distinguishing features. Both the Pro plan and the Student plan list it alongside unlimited accepted edit predictions, so pair programming and live code review sit inside the editor rather than in a separate tool. Zed’s Delta beta pushes the same idea further, with collaboration replacing the pull request on Zed’s own repository. For distributed teams that already pair often, this is a concrete reason to pilot Zed.
VS Code collaborates through GitHub rather than the editor. Agent sessions move between VS Code, the Copilot app, GitHub Mobile, GitHub.com and Copilot CLI, which is a different kind of collaboration: you hand work between your own devices and between humans and agents, instead of typing in the same buffer. Microsoft also reported on 1.143 that local AI runs without credits, which matters for developers who want to keep proprietary code off hosted services.
Local models are where JetBrains has been most aggressive. It open-sourced Mellum2, a 12-billion-parameter model, on June 1, and it lists Mellum2.1 as an open model for coding agents and fast sub-agents. JetBrains also reportedly announced an early Junie Local build on August 24 that uses Qwen3.6-27B on a MacBook M5, and says Air supports local models through tools such as Ollama and LM Studio. Treat the Junie Local build as an early direction, not a finished product.
Zed’s route to local and private models goes through bring-your-own-key and external agents. You can point the editor at a provider you trust, including a cloud account you already govern, without sending prompts through a hosted plan. Combined with the operating-system sandbox, that setup suits privacy-minded developers who still want modern agent features.
A practical note on offline work. Editors are only as offline as their model providers. Whichever editor you choose, confirm that your chosen model can run on your own hardware before you rely on it on a plane or inside an air-gapped network. Test one real task, such as a multi-file refactor, with the network disabled.
Security, Sandboxing and Governance #
Agents that run shell commands and fetch URLs are a new attack surface, and the three vendors handle it differently. Zed’s answer is isolation. Its sandbox applies operating-system enforcement to the agent panel’s terminal and fetch tools, and Zed states plainly that the setting is enabled by default for every user from release 1.14. A stable update in late October also refreshed dependencies to address vulnerabilities in the software ecosystem, a reminder that supply chain hygiene counts as much as agent isolation.
Microsoft’s answer is session design and control. The new Copilot harness combines the local VS Code harness with the Copilot CLI harness, and Agent Host Protocol 1.0 gives tools a shared way to talk to agent sessions. Microsoft’s pitch is that developers can hand off more work without handing over the decisions that matter. That is a design philosophy rather than a hard sandbox, so treat it as a layer to combine with your own permission settings.
JetBrains answers at the organization level. Air Governance exists to manage agents, access and spend across a company. If your security team asks which agents are allowed, which models they can reach and how much each team burned last month, that is the product built for the question. The July 7 shift to AI credits valid for 12 months, replacing monthly licenses for business customers, also gives finance a steadier number to plan against.
Zed’s gap here is administrative. Zed for Business reportedly offers centralized billing, role-based access and team management, but SSO, SAML and SCIM are described as planned rather than shipped. If your compliance checklist includes identity provider integration, Zed is not ready for a full rollout. For small teams that only need a solid sandbox and shared billing, it may still be enough.
A short checklist applies to all three. Turn on the strictest agent permission mode before connecting a production repository. Keep secrets out of environment variables an agent can read. Review the diff of any agent-written commit before it merges. And track token spend weekly in the first month, since that is when surprises appear.
What Developers and Founders Say About the IDE’s Future #
Zed’s own blog hosted a conversation about whether the traditional IDE survives the agent era, and it deserves a read with the host’s bias in mind. In that Zed-published discussion, software engineer Steve Yegge, who previously worked at Amazon, Google and Sourcegraph, argued that the plugin model is the weak point. He said: “I think that the IDE monolith architecture is kind of flawed… your AI needs to be able to do everything for you. And that means it can’t sit around waiting for somebody to build a plugin for it.”
The same conversation had Yegge criticizing current tools directly. In his words: “I can tell you a laundry list of things that I do every single day in my outer loop or in my inner loop with the agents that I wish an IDE were helping me with. But VS Code is not helping me, Cursor’s not helping me.” That is a strong claim from a practitioner, though it describes his workflow rather than a measured result, and it comes from a venue run by a VS Code competitor.
Zed co-founder Nathan Sobo, in the same Zed blog conversation, took a more nuanced line: “The IDE is dead. Long live the IDE. Or maybe the IDE needs to be reinvented in some very fundamental ways in order to be useful.” Sobo’s comment is the fairest summary of where all three vendors now stand. None of them is abandoning the editor. All of them are rebuilding the part around it.
JetBrains offered its rebuttal on October 20 with a post arguing that we still need an IDE. Its July 7 announcement on AI for teams and organizations frames the problem as fragmented AI usage and argues for shared context, reusable workflows, governance and cost controls. Microsoft’s own VS Code Wrapped post says AI-powered tools are core to how developers write code, backed by a team split evenly between AI work and other features.
Read together, the positions converge more than the marketing suggests. Everyone agrees agents need deep context, safe execution and cost visibility. They disagree on who should own each of those layers.
Six Real-World Examples From the Last Few Weeks #
Abstract feature lists only go so far. These six cases come from dated vendor material and show how each editor behaves when real teams push it.
- Zed builds Delta inside Delta. After the September 16 public beta, Zed said it turned off pull requests on Delta’s own repository and now collaborates there entirely. It is a bold dogfooding choice, and it tells you Zed thinks of the editor as a front end to a wider collaboration product.
- Netflix tests JetBrains Java intelligence. According to JetBrains, Netflix tried its Java IDE intelligence before it shipped in the Java and Kotlin extension. The signal is that a large Java shop validated the engine outside a JetBrains IDE.
- AWS shops pick Zed with Bedrock. Zed’s Amazon Bedrock provider now lists GPT-6 Astra, Claude Fable 5.1 and Claude Opus 5.5. A team that already buys models through its AWS agreement can use them in Zed without a separate hosted subscription.
- Agent sessions that follow you. With Agent Host, a VS Code user can start a session at the desk, close the folder, and pick it up in GitHub Mobile or Copilot CLI. For on-call engineers who triage from a phone, that continuity is the feature.
- Organizations govern agents through Air. Air Governance, now generally available, gives companies one place to manage which agents run, which models they reach and what they cost. Teams with several agent vendors are the target audience.
- Old Macs lose Zed support. The macOS 12.0 requirement dropped Catalina and Big Sur. A design studio or school lab on aging hardware has to upgrade the OS, or stay on VS Code or a JetBrains IDE.
The pattern across the six is consistent. Zed wins where speed of iteration and model choice matter. VS Code wins where continuity across devices and GitHub matter. JetBrains wins where governance and deep analysis matter. No single editor wins all three jobs.
Which Editor for Which Developer: Six Recommendations #
The best choice depends on your stack, your team and your budget. These six profiles cover most of the questions readers ask.
Solo developer on a modern Mac or Linux box. Pick Zed. The free Personal plan includes 2,000 accepted edit predictions a month and lets you bring your own keys, so you can start at $0 and move to Pro at $10 a month only when you hit the cap. Check that your Mac runs macOS 12.0 or later first.
Student or early-career developer. Zed’s Student plan gives verified university students the Pro features, and JetBrains offers 40% off for former students and 50% off for universities. VS Code is free and has the widest tutorial coverage. Start with whichever your course uses.
GitHub-centered team of 5 to 50. Stay on VS Code. The cross-device agent sessions, Copilot harness and Fusion discount through November 30 all reward a GitHub-first workflow. Use the eagerness setting to tune suggestion noise, since Microsoft reports a 29% lower dismissal rate at its tested setting versus medium.
Java, Kotlin or .NET engineers. Choose JetBrains. IntelliJ IDEA and Rider carry the refactoring and debugging depth, and the Java and Kotlin extension brings that engine to VS Code or Cursor if your team insists on one editor. Budget for a paid IntelliJ IDEA subscription once the 30-day extension trial ends.
Enterprise with a security review. Lean on JetBrains Air Governance or the VS Code and Copilot organizational path. Zed lacks shipped SSO, SAML and SCIM, so it belongs in pilot groups rather than company-wide rollouts for now.
Agent-heavy developer who switches models weekly. Zed or JetBrains. Zed’s BYOK and Bedrock options, plus OS-level sandboxing, suit someone who runs several agents. JetBrains Air suits the same person if they work across IDE, CLI and mobile and want one control layer.
Migration Guide: Moving Between These Editors #
Switching editors costs muscle memory more than data. The plan below keeps the old editor installed for two weeks, so you can fall back on a deadline day without losing time.
From VS Code to Zed
- Confirm your OS. Zed needs macOS 12.0 (Monterey) or later on Mac, and runs on Windows and Linux.
- Install Zed and open your main repository with the command line launcher.
- Set the VS Code keymap so shortcuts match, using the settings snippet below.
- Connect your model. Add your own API key on the free Personal plan, or start the 14-day Pro trial, which includes $5 of GPT-6 Luna usage.
- Turn on the agent panel and check that sandboxing is active (it is the default from release 1.14).
- Rebuild your language support. Check that your language servers and formatters work, and note any VS Code extension you cannot replace.
- Work in Zed for one full sprint, keep VS Code for the gaps, and log every time you switch back.
// Zed settings.json
{
"base_keymap": "VSCode"
}
From VS Code to JetBrains (or adding JetBrains intelligence)
You have two routes. The full move means installing the IDE that matches your language (IntelliJ IDEA, PyCharm, WebStorm or Rider), importing your keymap and letting the IDE index the project. Expect the first index to take a while on a big repository, so start it before lunch. The lighter route keeps VS Code and installs the Java and Kotlin extension, which runs free for 30 days and then needs a paid IntelliJ IDEA subscription. Try the lighter route first if your team is split.
For agents, connect through Air if you want governance. Air supports Claude Agent, Codex, Gemini CLI and Junie, and JetBrains reportedly added GitHub Copilot on November 3. If you already pay for Copilot, that billing stays on your Copilot plan.
Running two editors without chaos
Many developers end up with a hybrid. A common split uses Zed for fast edits and review, and a JetBrains IDE for debugging and refactors, with VS Code for remote and container sessions. If you go hybrid, put formatter and linter config in the repository, not in editor settings, so every editor produces the same diff. Agree on one commit message style as well, since Zed can now write AI commit messages that follow your repository’s recent commits.
Pros and Cons of Each Editor #
| Editor | Strengths | Weaknesses |
|---|---|---|
| Zed | Free tier with BYOK, $10 Pro, OS-level agent sandboxing, weekly releases, real-time collaboration, Bedrock models, 33% smaller macOS binary | macOS 12.0 minimum, SSO, SAML and SCIM not shipped, smaller extension ecosystem, token credit figure inconsistent across pages |
| VS Code | Free for commercial use, widest extension reach, Agent Host Protocol 1.0, sessions follow you across devices, Fusion multi-model with 30% discount through Nov 30 | AI path tied to Copilot billing, Fusion bills every model it calls, computer control still experimental, no public same-machine benchmark |
| JetBrains | Deep refactoring and debugging per IDE, Air Governance generally available, agent-neutral through ACP, discounts for students and startups | Paid subscriptions, several products to choose from, Java and Kotlin extension needs a paid subscription after the trial |
Look at the weaknesses column before the strengths. Each weakness is a procurement question. Zed asks whether you can accept missing identity features. VS Code asks whether you want your agent stack tied to one billing system. JetBrains asks whether the depth justifies the subscription and the product sprawl.
Verdict: Zed vs VS Code vs JetBrains in One Pick Each #
Here is the verdict, by job rather than by trophy. For most individual developers who want a fast editor with a clean agent surface and cost control, Zed is the strongest new option, and the zero-dollar entry makes the trial free. For most teams, VS Code remains the safest default because the editor costs nothing, the extension reach is unmatched and the agent continuity across GitHub surfaces is unique. For organizations that must govern agents and keep deep language tooling, JetBrains is the most complete package, especially now that Air Governance is generally available.
On the data, three points decide it. First, the lowest verified entry cost is $0 for both Zed Personal and VS Code, so price alone should not drive a choice. Second, the only hard efficiency numbers come from vendors and measure different things, so test on your own repository using the script above. Third, the biggest cost driver is agent token usage, which no editor can hide. Zed’s claim of 3x fewer tokens for Zeta2.1 and Microsoft’s 30% Fusion discount through November 30 both target that bill.
If you want one sentence to act on: try Zed on a side project this week, keep VS Code for team work until your colleagues move, and put JetBrains on the machines that carry the heaviest Java, Kotlin or .NET load. A mixed setup costs little and lets your own measurements settle the zed vs vscode debate for your stack.
Four dates will move this verdict. The Fusion discount for paid Copilot plans ends November 30. JetBrains holds its Plugin Developer Conf on November 10. The 2026.3 line of JetBrains IDEs is already being previewed. And Zed’s SSO, SAML and SCIM support, once it ships, would remove the main blocker for company-wide Zed rollouts.
FAQ: Zed vs VS Code vs JetBrains #
Is Zed better than VS Code in 2026? It depends on the job. Zed ships weekly, runs agents inside an OS-enforced sandbox and offers a free Personal plan, which suits individuals who value speed and model choice. VS Code has the broader extension reach, a free editor for commercial use and agent sessions that continue across GitHub surfaces. No neutral benchmark across both editors was published this fall, so test on your own repository.
How much does Zed cost? The Personal plan is free and includes 2,000 accepted edit predictions per month. Zed Pro costs $10 per month with unlimited accepted edit predictions and hosted token credits. Usage beyond the credits bills at API list price plus 10%. Zed’s pages show both a $5 and a $10 credit figure, so confirm on the live pricing page.
Is VS Code still free? Yes. The Visual Studio Code editor is free, including for private and commercial use. GitHub Copilot is a separate product with free and paid plans, and paid plans get a 30% discount on Copilot Fusion usage through November 30, 2026.
Does Zed work on Windows and Linux? Yes. Zed is available on macOS, Windows and Linux. On Mac it now requires macOS 12.0 (Monterey) or later, because the October 28 release dropped Catalina and Big Sur.
Can I use JetBrains features inside VS Code? Yes, for Java and Kotlin. The Java and Kotlin by IntelliJ IDEA extension reached version 1.0 and works in VS Code, Cursor and other supported editors. It is free for a 30-day trial and then requires a paid IntelliJ IDEA subscription.
Which editor is safest for AI agents? Each protects a different layer. Zed sandboxes the agent’s terminal and fetch tools at the operating-system level by default. JetBrains Air Governance controls agent access and spend across an organization. VS Code combines its local harness with the Copilot CLI harness and uses the Agent Host Protocol. Combine the vendor controls with strict permission settings and diff review.
Does Zed support enterprise single sign-on? Not yet. Zed describes SSO, SAML and SCIM as planned rather than shipped. Zed for Business reportedly offers centralized billing, role-based access and team management, so small teams can use it while larger companies wait for identity features.
Which editor should a beginner choose? VS Code is the easiest starting point because it is free and has the most tutorials. Students can also use Zed’s Student plan or JetBrains education discounts. Pick the editor your course or employer uses, and add a second one later.