Zed Built Its Own Model. That Should Worry Every AI Coding Startup

An editor company built its own model. Zed shipped Delta, a coding model of its own making, and the developer world took notice. Not because of the benchmarks — because it runs directly against everything the AI coding tool industry has done for the past three years.

One caveat up front: this is early. There isn’t much community reaction to point at yet, and no meaningful discussion threads have surfaced in the last month. So this isn’t a roundup of what developers are saying. It’s an argument about what Zed’s bet means, based on what the company has actually built and what the market around it looks like. Inventing engagement numbers would be worse than admitting they don’t exist yet.

The Wrapper Problem

The standard playbook for AI coding tools was simple. You build the interface. Someone else builds the model. Cursor, Windsurf, GitHub Copilot — structurally, they’re all variations on the same theme. Wire up an OpenAI or Anthropic API, then compete on how good the experience feels on top of it.

That structure has one fatal flaw: you don’t control your own cost basis. The model provider raises prices, your margin evaporates. The model provider ships its own editor, and your supplier is now your competitor. Both of those scenarios have already happened, repeatedly.

Zed’s move is a bet on breaking that dependency. Stop being a layer on top of someone else’s economics and go vertically integrated instead. It’s the same logic Apple used when it dumped Intel for the M-series: if the thing your product lives or dies on belongs to someone else, eventually you build it yourself.

Why Zed Specifically

Not every editor company could attempt this. Zed has a few assets most don’t.

Start with the codebase. Zed isn’t a VS Code fork. It isn’t a web app wearing an Electron costume. It was written in Rust from scratch, GPU-accelerated rendering and all. That means the team controls every layer of the editor internals — and when you’re designing how code context gets fed into a model, that control is the whole ballgame. Wrapper products are stuck with whatever context their host editor exposes.

Then there’s the team’s history. These are the people who built Atom. They shipped an editor, watched GitHub acquire it, and then watched it get shut down after Microsoft bought GitHub and put its weight behind VS Code. That’s not a war story — it’s a lesson about what happens to a tools company that lives inside someone else’s platform. You don’t forget that twice.

And they’ve been deep in real-time collaboration and language server integration for years. The hard question in AI coding isn’t generating tokens. It’s understanding a codebase’s structure well enough to know which tokens matter. Zed has been circling that problem from a different angle the entire time.

The Word That Matters Is Open

The interesting thing about Delta isn’t its benchmark scores. It’s the release model. Shipping it open rather than as a closed API endpoint is a positioning decision, not a technical one.

The reasoning is straightforward. A late entrant going head-to-head with frontier labs on raw capability is going to lose. But you don’t have to be better — you have to be differently good. A model that runs locally means your code never leaves the machine. That unlocks developers who are structurally barred from using cloud AI, no matter how good it is.

This is the part people underrate. Engineers in finance, defense, and healthcare aren’t avoiding AI coding tools because the tools are weak. They’re avoiding them because their code legally cannot leave the building. HIPAA, ITAR, and whatever their compliance team invented last quarter are not negotiable. That market is large, well-funded, and almost entirely unserved by the current generation of cloud-first tools. No benchmark captures the value of being the only option someone is allowed to install.

The Case Against

A one-sided take is a boring take, so here’s the other side.

Training models is expensive, and it isn’t a one-time expense. It’s a treadmill — the frontier moves every few months and you either keep pace or your model quietly becomes irrelevant. Running editor development and model development simultaneously splits both your engineering talent and your capital across two brutally competitive fronts. Whether a startup balance sheet can sustain that for three or four years is genuinely unknown.

The more realistic risk isn’t failure. It’s mediocrity on both fronts. The model trails the frontier by enough to matter, and the editor’s development pace slows because half the team is doing something else. Vertical integration is a moat when it works and a two-front war when it doesn’t.

And developers are ruthlessly unsentimental about tools. Nobody switches editors because a company has an admirable strategy. “We also make our own model” is not a feature. The only question that gets asked is whether it writes better code, and it gets asked within about ten minutes of installation.

The Layer You’re Standing On

Reading Delta as a product launch misses the point. It’s a signal that the industry’s layer structure is coming apart.

Until recently the AI tooling market had a clean stack: model companies at the bottom, application companies on top. That boundary is now collapsing from both directions at once. Model companies ship their own end-user products. Product companies train their own models. The middle is getting squeezed from above and below simultaneously.

If that pattern holds, the most exposed companies are the ones stuck in between — no model of their own, no durable relationship with the user, just a well-designed layer of glue between two things they don’t control. Zed just announced it has no intention of dying there.

An editor company building a frontier-adjacent model would have sounded reckless a few years ago. Now it reads as a survival strategy. Worth asking about whatever tools you’re using right now: which layer are they standing on, and is anyone above or below them already building it themselves?