Zerolang: Vercel's Agent-First Language and Your Review Cost

Vercel Labs released an experimental language this summer in which an AI agent edits the compiler’s graph rather than source text. Most buyers will read that as an adoption question and set it aside. The more useful reading is what it reveals about a line item engineering budgets carry without measuring: code review.

The project is serious work. It has drawn more than five thousand GitHub stars since its introduction in May, by InfoQ’s count, and it is Apache licensed and openly labelled experimental. What makes it worth a buyer’s attention is the cost the design is aimed at.

Hold the adoption question anyway and look at the mechanism. In a conventional agent loop the model writes text into a file, runs a build, reads the failure, and edits again. Every control most teams have added sits downstream of that write: a pull request, a reviewer, a gate. They exist because free text can express an unbounded number of wrong things, and somebody has to sort them.

The Bottleneck Moved and the Budget Did Not

The arithmetic is not hard and almost nobody runs it. Take your own inputs: agent-authored changes per week, senior minutes spent approving each, your loaded day rate. At thirty changes and forty minutes each, approval alone eats half a senior engineer’s week, and it sits in no budget line.

Throughput at the keyboard rises sharply once agents are in production. Throughput at the point of approval does not, because it is bounded by the number of people qualified to say yes.

So the queue relocates. It used to sit in front of writing code. Now it sits in front of accepting code. Reviewing machine-written diffs is also worse work than reviewing a colleague’s: more volume, less context, no shared intent to lean on.

Most organisations have not repriced any of this. The agent was booked as a productivity gain and review stayed a background activity that nobody owns a number for.

What a Checked Patch Actually Removes

The graph-first design attacks the problem at the source. The agent does not hand over text and wait to be told what the text meant. It asks the compiler for the structure, then submits a patch aimed at a named node, carrying a hash of the state it read. If the structure moved underneath it, the patch fails before anything is written.

Whole categories of error stop being reviewable events because they stop being expressible. A lost closing brace. A patch written against a stale copy of a file. An edit that landed on a similarly named function. None of these reach a human.

That is a different kind of control from the ones most teams have built. A gate judges output. A sandbox limits blast radius. Both run after the agent has already written whatever it wanted, and both add a checkpoint you keep paying for. A narrower write surface retires the checkpoint instead.

Your Agents Already Have a Write Surface

The language itself is a poor bet: one vendor’s experiment, its authoring surface reworked three times since spring. The transferable part is the question it forces. How much can your agent express, and what does sorting that cost you?

That question applies to tooling already in the estate. An agent restricted to a typed migration command cannot invent a schema change. An agent that emits a config diff validated against a schema cannot produce a config that parses and still means the wrong thing. An agent handed shell access can do anything, and each of those anythings is somebody’s afternoon.

The Figure Nobody Can Produce

Before the next agent lands in your stack, get one figure: senior review hours consumed per agent-authored change, and where that trend goes as agents are added. Most teams cannot produce it. That inability is the finding.

Zerolang will probably never appear in your estate. The thing it demonstrates will. The cheapest review is the one the write surface made unnecessary. Narrow what an agent can say, and you buy that cost down permanently, without hiring a single reviewer.