Zed Wants to Fix Code Editors' Two Biggest

I've watched code editors make the same promises since the '90s. This one is faster. This one won't bloat. This one finally gets collaboration right. Usually, what happens is: the fast one gets slow as features pile on, and the collaborative one never quite feels native enough to stick.

So when Better Stack's latest video positions Zed as the editor that solves both lag and the solo-developer problem, my first question is obvious: which parts are genuinely new, and which parts are just good marketing?

The Performance Pitch

Zed is written in Rust with no Electron layer—which means it's not a browser pretending to be an application. This isn't a trivial distinction. Electron editors carry the entire weight of Chromium, which is why they feel fine on small projects and start wheezing once your codebase hits six figures.

Better Stack's video demonstrates this on a 100,000-plus line codebase. The narrator shows smooth scrolling through a massive JSON file and notes: "Where Cursor can start to feel slow as the project grows, Zed didn't seem to care." The basic navigation functions—file search (Cmd+P), symbol search (Cmd+Shift+O), and repo-wide grep (Cmd+Shift+F)—all respond instantly.

This is the part where I should probably note: Cursor isn't slow in absolute terms. It's just carrying VS Code's architectural baggage, and that baggage gets heavy at scale. The question isn't whether Zed is faster on large repos—it probably is—but whether that speed matters enough to overcome switching costs.

For most developers working on most projects? Maybe not. For teams maintaining genuinely large codebases where every lag compounds across dozens of developers? That calculation changes.

AI as an Option, Not an Identity

Here's where Zed's positioning gets interesting. The video emphasizes what the editor doesn't do: constant AI popups, intrusive suggestions, interface clutter. Instead, you highlight code, press Control+Enter, and Claude offers focused suggestions—error handling, refactoring—right where you're working.

The narrator explains: "What I like here is what doesn't happen. No constant popups or extra UI stuff to clutter up my page. So, the point isn't look how much AI it has. The point is it helps and then it gets out of its way."

This is interesting positioning in 2026. Cursor built its identity around being AI-first, and that bet paid off—until it didn't. Turns out developers want AI available, not AI mandatory. They want the option to summon assistance without having their entire interface reorganized around feeding prompts.

Zed integrates Claude through something called Agent Client Protocol (ACP), which sounds impressive but is really just API plumbing. The practical result is that AI feels like a feature you activate when needed, not a philosophy that redesigned the entire editor.

You can still get a sidebar AI panel (Cmd+Shift+A) that looks cursor-familiar if you want it. But the default experience assumes you're writing code, not having a conversation with your editor.

The Collaboration Wildcard

This is where things get genuinely different. Zed has "Channels"—real-time collaborative editing that works more like Google Docs than the screen-sharing hacks most developers cobble together.

The video walks through the experience: "I want you to think like Slack or Discord, but integrated right into the editor. If I open that up with command shift C, I can create my own channel, invite teammates straight from GitHub, and share the project."

You get live cursors, avatars showing where everyone's working, simultaneous edits, and—here's the part that made me pause—integrated voice chat. Like Discord, but you never leave the editor.

I have questions about this.

First: Does this actually solve a problem developers have, or a problem Zed's designers think developers have? Because in my experience, most pair programming happens through VS Code Live Share or just old-fashioned screen sharing, and it works fine. The friction isn't usually the tool—it's coordinating schedules and deciding when synchronous collaboration is actually worth it.

Second: The video positions this as Cursor's fatal weakness—"Cursor, for all its strengths, still assumes you're working alone." But is solo-first really a weakness? Most coding is solo. Even on teams, most actual code production happens in individual flow states, with collaboration happening in reviews, debugging sessions, and architectural discussions.

That said, if Channels works as smoothly as demonstrated, it could lower the activation energy for collaborative debugging just enough to change behavior. Maybe you would pull a teammate into your editor for five minutes if it was literally one keyboard shortcut. Maybe that's genuinely useful.

The Actual Trade-offs

The video frames this as a choice between "an editor built around solo AI workflow" versus "one that balances light AI with real-time multiplayer." That framing assumes those are the axes that matter most.

But here's what the video doesn't address: ecosystem. Cursor benefits from VS Code's enormous extension marketplace. Zed is building from scratch, which means faster core performance but fewer plugins, fewer integrations, fewer accumulated solutions to edge cases.

There's also the question of workflow inertia. Most developers have spent years customizing their editor. Keybindings, snippets, color schemes, muscle memory. The switching cost isn't just "is Zed better?" It's "is Zed enough better to justify rebuilding my entire development environment?"

For teams? Maybe. If you're experiencing real performance problems on large repos, and if built-in collaboration would meaningfully improve your workflow, Zed's value proposition becomes compelling.

For individual developers on reasonably-sized projects? The performance gains probably don't overcome the friction of switching.

What's Actually New Here

I've seen native-compiled editors before—Sublime Text proved that model works. I've seen collaborative editing before—it's been a feature in various editors since the early 2010s. I've seen AI integration before—every editor has added it in the last 18 months.

What Zed is attempting is the combination: native performance, optional AI, and collaboration-first design. Whether that combination is genuinely valuable or just three features that happen to ship together—that's the question.

The thing about code editors is that they're deeply personal tools. What feels fast to one developer feels sluggish to another. What feels clean to one feels sparse to another. The editor you'll actually use is the one that matches how your brain works, not the one with the most technically impressive architecture.

So the real question isn't whether Zed is objectively better. It's whether Zed is better for you, doing your work, with your team. And the only way to answer that is to actually use it.

Which, to be fair, is probably what the Zed team is counting on.

—Mike Sullivan, Technology Correspondent