Six months with Zed as my primary editor: an honest retrospective

Last October I switched my primary editor from Cursor to Zed. The trigger was a stretch of work where I was doing a lot of plain-text editing — writing docs, refactoring without much AI, reviewing code in larger chunks — and Cursor’s UI felt heavier than the work needed. Zed advertises itself as fast and minimal; I wanted to test whether that was a real difference or marketing.

Six months later, I still use Zed for most of my work, but I’ve reverted to Cursor for specific cases. The pattern that emerged is interesting and runs counter to the typical “AI editor is the future” framing.

What I expected

Going in, I had two hypotheses:

Zed’s performance would be a small daily win. Faster startup, faster scrolling, faster everything — adding up to maybe 10% better quality-of-life.
The AI feature gap would be a real productivity loss. No Composer, smaller agent capabilities — maybe 15-25% slower on AI-heavy tasks.

Net expectation: roughly even productivity, somewhat better quality of life. Worth trying for the experience even if the productivity numbers came out flat.

What actually happened

Both hypotheses were directionally right and quantitatively off.

The performance difference was bigger than I expected. Not 10% — closer to 30% better quality of life, in ways that are hard to put into a clean number. Zed feels noticeably more responsive in a way that compounds across a full day of editing. By 5pm, I have less editor fatigue than I used to with Cursor.

The AI feature gap was also bigger than I expected. Not 15-25% — closer to 40% slower on AI-heavy tasks. Specifically, anything involving multi-file generation, codebase-wide refactoring, or extended chat-driven work. Zed’s AI is competent for small things and meaningfully worse for large things.

The net for me was: about 70% of my work feels better in Zed (smaller tasks, plain editing, focused coding), and about 30% feels worse (anything where I want a real agent to do significant work). My response to this isn’t to switch back; it’s to use both, with Zed as the default and Cursor for specific work.

What’s better in Zed

After six months of daily use, things I genuinely value:

Startup time. Zed opens in under a second on my projects. Cursor took 4-6 seconds. This matters because I open and close my editor often during the day; the cumulative wait time was real.

Scroll smoothness on large files. I have several files in the 5k-line range. Cursor scrolls these but with occasional jankiness. Zed scrolls them like they’re 100 lines. This isn’t trivial — when I’m reading code, smooth scrolling is the difference between focus and cognitive break.

Memory footprint. Zed sits at about 200MB on my projects. Cursor was 1.5-2GB. On my work laptop with multiple things running, the difference matters for the overall system feel.

Vim mode that actually works. Zed’s Vim emulation is the best non-vim Vim emulation I’ve used. Cursor’s was usable but had quirks.

The collaboration features. Zed has built-in multiplayer (real-time collaboration) that I’ve used a few times for pair-debugging with a remote teammate. Smoother than screen-sharing, lower latency than VSCode Live Share.

Settings as plain JSON. Cursor’s settings UI was fine. Zed’s “open settings.json and edit it” model is faster for me. Probably matters more if you’re settings-curious.

Slash commands for context loading. Zed’s /file path/x.ts to add context is more deliberate than Cursor’s. I’ve come to prefer the explicit-context model — it forces me to think about what the AI needs to see, which produces better prompts.

What’s worse in Zed

The AI feature gap is real and it shows up specifically:

Multi-file generation. Zed’s assistant can produce changes across files, but the UX is patch-based and clunky compared to Cursor’s Composer. For a feature that touches 5+ files, Cursor’s Composer is meaningfully better.

Codebase indexing. Zed has improved here over the six months but is still behind Cursor. “Find me where this pattern is used” or “summarize how the auth system works” produces better results in Cursor.

Background agents. Zed has nothing equivalent. For tasks I’d hand off to Cursor’s agents — write tests for this class, run them, fix issues — I have to switch tools.

Inline edit. Zed’s Cmd+I is functional. Cursor’s Cmd+K feels faster and more reliable for small edits. Maybe 1-2 seconds difference per invocation, but I do this many times a day.

Extension ecosystem. A few extensions I depended on in VSCode/Cursor don’t exist in Zed yet. Mostly minor (a specific git tool, a specific framework helper) but occasionally I notice their absence.

Newer features lag. When Cursor ships a feature (background agents, MCP support, web preview), Zed gets it 3-12 months later, if at all. If you want to be at the leading edge of AI tooling, Zed isn’t where you’ll be.

The work split that emerged

After about three months I noticed I was reaching for Cursor for certain tasks and staying in Zed for others. The pattern that emerged organically:

Stay in Zed for:

Reading and navigating code
Writing prose (docs, commit messages, PR descriptions)
Small targeted edits with Cmd+I
Vim-mode-heavy editing
Pair programming via Zed’s multiplayer
Anything where I want fast scroll and low UI noise

Switch to Cursor for:

Multi-file feature work where Composer earns its keep
Anything involving agent-style background tasks
Codebase exploration on unfamiliar code where indexing helps
Large refactors that span 10+ files
When I want to load a lot of context and reason across it

The split is roughly 70/30 by time. The Cursor work is the more “AI-leveraged” work where the tool’s capabilities matter most. The Zed work is the bulk of editing where the tool’s responsiveness matters more than its AI features.

What this taught me about editor choice

The framing I’d been using before — “the best AI editor wins” — turned out to be too narrow. Editor choice has multiple dimensions:

Editing performance (how the tool feels for plain editing)
AI feature depth (what AI-augmented work the tool supports)
Configuration philosophy (UI vs JSON, opinionated vs flexible)
Ecosystem (extensions, language support, integrations)
Collaboration features (real-time, code review, etc.)

No single tool wins on all dimensions. Cursor wins on AI feature depth. Zed wins on editing performance. JetBrains products win on language-specific tooling. VSCode wins on ecosystem breadth. The right choice depends on which dimensions matter most for your work.

For me, today: editing performance matters more than AI feature depth on most days, and AI feature depth matters more on specific days. The two-tool setup matches the variation.

If you do mostly plain editing: try Zed. The performance is real. You’ll like it.

If you do mostly AI-heavy multi-file work: stay on Cursor. The gap is real and Zed isn’t there yet.

If you do a mix: try both, run them in parallel for a month, see where you naturally reach for which. The two-tool setup isn’t strange; many engineers run multiple editors for different work types.

If you care about specific AI features: check Zed’s current capabilities. They’re improving. Whatever I list here will be partially outdated by the time you read it. Don’t trust six-month-old comparisons (including this one).

If you want one tool, period: Cursor is more flexible across the work spectrum than Zed is. Zed’s specialty is editing; Cursor’s specialty is AI augmentation; “AI augmentation” subsumes “editing” while the reverse isn’t true.

The numbers

Roughly: my measured productivity (tasks-per-week, normalized for difficulty) is essentially flat between full-Cursor and the Zed-primary setup. Maybe 5% lower in Zed-primary, well within noise.

What I subjectively notice:

More energy at end of day (Zed’s smoother performance feels less draining)
Fewer “wait, where was that toolbar option” moments (Zed’s UI is simpler, less to remember)
More structured prompts when I do AI work (the Zed slash-command model rubbed off on my Cursor habits too)

These aren’t measurable in the way “tasks per week” is, but they matter for whether I want to keep doing this work for years.

Six months in, the meta-observation

The interesting thing about this experiment isn’t whether Zed is better or worse than Cursor. It’s that the framing of “best AI editor” misses what makes editors good. AI features matter. So does responsiveness. So does ergonomic fit. So does ecosystem depth. The editor that wins on AI features can lose on the dimensions that matter for the bulk of your work.

For my work mix, the right answer turned out to be both. That answer surprised me — I expected to either stay on Zed forever or revert to Cursor entirely. Living with both for six months has been better than committing to either.

The broader pattern I’d suggest: don’t pick your editor based on the marketed feature set. Pick it based on how it feels on the work you actually do, weighed against the work where you’d want different capabilities. If the work is varied, the answer might be plural. That’s fine.