Zed

Positioning: the performance-first editor with AI built in

Zed is the code editor I switch to when I am tired of waiting for my editor. Written in Rust, GPU-accelerated, multi-core by design, it starts instantly and renders like a native application because it is one — the team behind it built Atom at GitHub and then spent years rebuilding the idea properly. For a long time the trade-off was platform exclusivity and a thin extension catalog; that story has changed. Zed now ships natively on macOS, Linux and Windows (official Windows support arrived in October 2025 with a DirectX rendering backend), and the AI layer is no longer a bolted-on chat box but a first-class part of the product: an agent panel with multi-file editing, parallel agents, inline transformations, and edit prediction called Zeta that suggests your next edit as you type. The catalog's cons list here is stale — "Mac only (Linux beta)" has not been true for two product years.

What I look for in this category is a tool where AI helps without taking over: the editor must remain fast when AI is off, the AI must be model-flexible, and the pricing must not punish me for bringing my own API keys. Zed scores unusually well on all three.

What it actually does

The base editor is complete in the way that matters daily: tree-sitter-powered syntax and navigation, language-server support, multi-cursor and column editing, macro recording, native Git (stage, commit, diff, pull, push), a debugger built on the Debug Adapter Protocol, Vim and Helix modes, a Jupyter-backed REPL, Dev Containers, and remote development over SSH and WSL with a version-matched server binary. Extensions cover hundreds of languages, themes, snippets and debug adapters — smaller than VS Code's marketplace, larger than any other native editor's.

The AI stack has several distinct pieces. The agent panel runs chat-style agents that read and modify files, with Parallel Agents running multiple threads across projects and worktrees, plus profiles, skills, instructions and MCP server support. External agents — Claude Code, Codex CLI and others — connect through the Agent Client Protocol and run in their own processes with their own configuration, which is a genuinely differentiator move: Zed treats other people's agents as first-class citizens instead of competition. The inline assistant transforms a selection in place, and Zeta provides low-latency next-edit predictions. Model support spans hosted providers (Anthropic, OpenAI, Google AI, Amazon Bedrock, GitHub Copilot and more) via bring-your-own-key, plus local models through Ollama, LM Studio or llama.cpp.

Pricing, read from zed.dev/pricing at time of writing: Personal is free forever — the full editor with 2,000 accepted edit predictions per month and unlimited local-model and BYOK usage. Pro is $10/month for unlimited edit predictions, access to Zed-hosted models and $5 of monthly token credit, with usage beyond that billed at provider list price plus 10% and a default $10/month incremental spend cap. Business is $30 per seat per month for org-wide model policies, governance controls, role-based access and unified billing. Students and teachers get Pro free for twelve months. The 14-day Pro trial requires no credit card and ends early if its $5 balance is spent.

My testing notes

Two observations from my runs. First, performance claims of this kind are usually marketing, and here they mostly hold: opening a large Rust repository, fuzzy file search and multi-cursor editing felt immediate in a way that VS Code on the same machine does not, and — my actual test criterion — the editor stayed fast with the AI panel closed and no model configured. An AI editor that degrades the base experience is a non-starter for me, and Zed does not. Second, the edit-prediction experience: Zeta's predictions in my session were best on repetitive refactors — renaming patterns, parallel changes across similar functions — where a correct tab-accept saved real keystrokes, and weakest on novel logic, where I stopped accepting after a couple of misses. The free plan's 2,000 accepted-predictions allowance lasted me several days of heavy editing, which tells me individual developers with their own API keys can live on Personal indefinitely. I also tested the collaboration path with a second machine: shared projects with live cursors and conflict-free syncing worked as advertised, and screen sharing inside a project call is the workflow feature I end up using more than I expect.

One more practical observation on the agent workflow: connecting an external agent through the Agent Client Protocol gave me my existing Claude setup inside Zed's UI without re-training my habits, and the thread management — reviewing changes per thread, managing parallel agents in worktrees — is the part Zed has gotten most right architecturally. It treats agent output as patches to review, not as magic.

Working through a migration

For developers coming from VS Code, my migration notes are short. Keymaps import, settings map closely enough that I was productive on day one, and the projects I ported were mostly trouble-free. Before committing, though, open your actual stack and check the extension list, because the gaps are language-specific and only discoverable that way. Languages with strong tree-sitter and language-server support (Rust, Go, TypeScript, Python, C and C++) felt excellent in my hands; anything depending on a niche VS Code extension for linting or test-running is the migration risk. On the AI side, I recommend the setup I settled on: keep your own API keys for choice models, keep a local model running through Ollama for offline and privacy-sensitive work, and let Zeta's predictions run on the free tier until you know whether 2,000 accepts a month matches your editing cadence. Only then decide whether Pro's hosted-model convenience earns its $10. The collaboration features need no paid plan, which is worth saying plainly: the multiplayer editing that some rivals charge for is part of the free editor here.

What it does not do

Zed is not VS Code, and the gap shows in three places. The extension marketplace is hundreds of extensions, not tens of thousands — if your stack depends on a specific VS Code extension, check compatibility before migrating. Remote development requires exact version matches between local and remote binaries, which is fiddly in mixed-version teams. Windows needs a DirectX 11 GPU and runs slower in VMs with emulated adapters. Business plan governance has real holes: SSO, SAML and SCIM are planned but not yet available as I write, which will block some enterprises. And the AI pricing is not a ceiling — Pro's $5 token allowance goes quickly on hosted-model agent runs, with overage at list price plus 10%; heavy hosted-AI users should model their spend or lean on BYOK and local models. Collaboration also requires the participants to be on Zed — this is not an editor that plays multiplayer with VS Code users.

Verdict

Zed is the best editor I use for speed and the most honestly-priced AI editor I have tested: the free tier is genuinely usable, bring-your-own-key and local models carry no markup from Zed, and the paid plans buy hosted convenience rather than the right to use the product. I rate it 4.2 on the rubric — deep core editor functionality with a thoughtful AI layer, strong value from the free Personal plan through Pro's $10, excellent usability for performance-sensitive developers, a growing but still smaller extension ecosystem, and reliability signals that have held up across the macOS and Linux builds in my hands. If you live in your editor eight hours a day and you resent waiting for it, this is the switch I would make first.

Sources

• https://zed.dev/pricing
• https://zed.dev/blog/zed-for-windows-is-here
• https://toolchase.com/tool/zed-editor
• https://ossalternatives.org/zed
• https://thegeeksclub.com/platforms/zed
• https://inferse.com/platforms/zed
• https://specifiction.org/tools/zed
• https://promptquorum.com/power-local-llm/zed-review