Last of three setup guides, after VS Code, the default, and Sublime Text, the survivor. This one is the newcomer, although "newcomer" undersells the lineage: Zed was started by Nathan Sobo, one of the creators of Atom, and it reads like an act of atonement. Atom taught the world that editors built on web technology feel heavy. Zed is what happens when the same people rebuild the idea in Rust, rendering on the GPU, with performance as the founding principle.
The short version of why Zed matters in 2026: it hit 1.0 in April after five years of development, it's free and open source, it runs on macOS, Linux and Windows, and it's the first mainstream editor where AI assistance is part of the architecture rather than an extension wearing a lanyard. Startup is near-instant, keystroke latency is imperceptible, and memory usage is a fraction of an Electron editor's. If VS Code's honesty section (the bit where it's slow) bothered you, this is the article you skipped ahead to.
Install and first run #
Download from zed.dev or install via your platform's package manager. First run offers to import your VS Code settings and keybindings, and you should accept: the migration is decent and it removes the main friction of switching. Platform note worth knowing before committing: maturity runs macOS first, Linux close behind, Windows last, with Windows support the newest of the three. It's stable, but the roughest edges live there.
Sign-in is optional. The editor is fully functional without an account; you only need one for the hosted AI features, and you can skip those entirely by bringing your own API keys or running local models. More on that below, because it's the part of the setup with actual decisions in it.
The bit where there's no extensions section #
Here's the structural difference from the VS Code article: the extensions list is nearly empty, on purpose. Language servers for TypeScript, JavaScript, CSS, JSON and friends are built in or auto-installed when you open a relevant file. Prettier-style formatting: built in, on by default via the language servers. Git: a native panel with staging, committing, blame and history. Terminal: built in. Vim mode: built in, and one of the better implementations outside Vim itself. The inline-error display you install Error Lens for in VS Code: built in.
Zed does have an extension system, mostly themes and additional language support, and the catalogue is roughly 800 strong against VS Code's tens of thousands. For standard web work you may install nothing at all beyond a theme. That's not a poverty; it's the design. Everything in the hot path is native code, which is where the speed comes from and why the correct instinct here is the opposite of VS Code's: don't look for an extension until you've confirmed the feature isn't already there.
The gap is real at the edges, though. Niche language tooling, database explorers, that one internal extension your company built for VS Code: if your workflow depends on the long tail, check it exists before you move in. This remains the honest reason most developers haven't switched yet.
Settings worth changing #
Configuration is JSON (zed: open settings
from the command palette), with a settings UI arriving for the common cases. A sensible web-development baseline:
{
"buffer_font_family": "JetBrains Mono",
"buffer_font_size": 14,
"format_on_save": "on",
"autosave": "on_focus_change",
"vim_mode": false,
"inlay_hints": { "enabled": true },
"git": { "inline_blame": { "enabled": true } }
}
Inlay hints put inferred TypeScript types inline where they're useful; switch them off if you find them noisy. Inline blame is GitLens's headline feature, here as a config flag. Set vim_mode
true if that's your religion, and note that Zed also speaks Sublime-style multiple cursors fluently, so the muscle memory from either of this series' other editors transfers.
The AI decisions #
This is where Zed's 2026 setup genuinely differs from the other two articles. AI here isn't one assistant; it's a set of choices. Edit Predictions gives Cursor-style inline next-edit suggestions, with a monthly allowance on the free plan and unlimited on the paid tier, which at $10 a month undercuts most rivals. The Agent Panel runs conversational and autonomous coding agents against your codebase, and since 1.0 can run several in parallel. And the part that matters strategically: Zed supports the Agent Client Protocol, an open standard for plugging external agents in, plus bring-your-own-key for the major model providers and local models via Ollama. You are not locked into anyone's model, including Zed's.
The recommended setup, then, is deliberate rather than maximal: switch on Edit Predictions and see whether the suggestions earn their keep in your codebase; wire the Agent Panel to whichever provider your team already pays for; and if you want none of it, there's a single toggle to disable all AI features, which Zed added because enough people asked. An editor that makes abstaining a first-class setting is an editor being unusually honest about the moment we're in.
Where Zed loses #
The ecosystem gap, covered above, is the big one. Debugging shipped with 1.0 but is younger than its rivals' offerings. The Windows build trails the other platforms. And the project moves fast, which cuts both ways: fixes land weekly, and occasionally so do regressions.
So the recommendation splits cleanly across this series. Deep extension dependencies or maximum stability: stay with the VS Code article. Pure editing speed with no AI in the building: the Sublime Text one. But if you want the modern feature set, native performance, and AI treated as architecture with an off switch, Zed is the first new editor in a decade that's earned the word ultimate. Atom's creators finally shipped the editor Atom was trying to be. It just took a different language, a different decade, and, apparently, the death of the first attempt.