Vercel's Zero: A Programming Language Built for AI

Somewhere between "genuinely interesting research" and "solution looking for a problem" sits Zero, a new systems programming language from Vercel Labs. It's designed from the ground up for one specific premise: AI agents shouldn't have to parse error messages written for human eyeballs. Everything the compiler touches can output structured JSON. That's the whole bet.

Whether that bet pays off is a more open question than Vercel's landing page suggests.

What Zero Actually Is

Zero lives in the same neighborhood as Rust and Zig—systems-level, compiled, explicit about memory. The syntax won't shock you. You've got enums, structs (called "shapes" here), match expressions, for loops. Error handling uses a check keyword that does roughly what Rust's ? operator does, just spelled out. Files use the .0 extension, which is either minimalist or annoying depending on your mood.

The more interesting design choice is the capabilities system. Want to do any I/O—print to the terminal, read a file, make a network call? Your function needs the world capability declared explicitly. No world capability, no side effects. This isn't just documentation theater; the compiler enforces it. Try to use filesystem access in a function and then target a WebAssembly build, and the compiler rejects it at compile time rather than letting you discover the problem at runtime. That's genuinely useful, and it's a pattern that people have been asking for in systems languages for a while.

Memory management follows the same philosophy of explicitness: owned types, mutable spans for writable views, regular spans for readable views, and a defer keyword for cleanup logic. Nothing groundbreaking if you've spent time with Rust, but it's coherent. The language has a clear point of view.

The Real Pitch: A Toolchain That Talks to Machines

Here's where Zero diverges from "just another systems language" territory. The Better Stack video that's been making the rounds this week put the core argument plainly: "current languages were built for humans. So we read the error messages, the warnings, and the traces, but AI works much better when it has structured data."

So Zero's toolchain isn't just capable of producing JSON output—it's been designed around that capability. Run zero check on broken code with the JSON flag, and instead of a wall of formatted text, you get a structured diagnostic object: severity, error code, exact location, expected vs. actual values, a human-readable message, and a separate field specifically for LLM consumption labeled something like help. There's even a fixed_safety field that can flag whether a fix requires human review before applying.

The zero fix command takes this further. Point it at a broken file, and it returns a structured repair plan—safety levels, applicable edits, self-host repair policy, the full diagnostic, and the canonical fix for that specific error code. The framing is almost philosophical: "What if the language provided its own documentation when it was needed?" Rather than an AI agent having to fetch docs or rely on training data, the toolchain hands over the context inline.

To test this, the Better Stack video creator dropped a broken Zero file into a directory with zero (sorry) context about the language—no docs, no examples, nothing—and asked Claude to fix it. Thirty-one seconds later, Claude had found and patched all three intentionally introduced bugs, using only the output from zero fix as its guide. "This is a brand new language that an LLM can still debug thanks to how the language has been built," the video notes. That part is legitimately impressive.

The Skeptic's Case

But here's the tension that doesn't go away: is this a language feature, or just a good idea that didn't need a new language?

Rust already outputs JSON-formatted errors. You can run cargo build --message-format json and pipe it wherever you want. The ecosystem around compiler diagnostics has been moving toward machine-readable formats for years—Language Server Protocol (LSP) is basically this idea already, and it works across dozens of languages without anyone having to invent new syntax. The video makes exactly this point: "I'm not really sure that we needed a whole language to be built around this idea, and maybe you could have just improved the existing ones if you thought there was a gap in the information."

There's also the training data problem, and it cuts both ways. Zero has zero training representation in any current LLM. For simple, self-contained debugging tasks with rich toolchain output, that might not matter much—as the Claude demo shows. But the moment you're building anything complex, you want a model that has seen thousands of examples of your language, knows its idioms, has absorbed its community wisdom. Rust has that. Zig is getting there. Zero is starting from scratch, and that gap is real.

The counterargument from Zero's camp would probably be: that's the point. We're not trying to replace Rust for complex applications. We're trying to demonstrate a paradigm where the toolchain itself becomes the documentation layer for AI agents, especially for novel or domain-specific languages where training data will never exist. As a proof of concept for that idea, Zero succeeds.

The Harder Question Underneath

What's actually interesting here isn't whether Zero specifically takes off—it probably won't, at least not in its current form. What's interesting is the design question it's surfacing: as AI agents write more code, who are programming languages actually for?

Languages have always been human interfaces. The semantics have to make sense to us; the error messages have to be legible to us; the community and documentation have to be navigable by us. The entire stack was built around the assumption that a human is in the loop at every step. Zero is a small but deliberate challenge to that assumption. If an AI agent is writing, debugging, and iterating on code autonomously, maybe the toolchain should be optimized for that agent's needs—and humans can have the pretty-printed version as a secondary output.

That's not a crazy idea. It's also not necessarily a new-language problem. LSP, structured compiler output, and tools like ast-grep are already making codebases more machine-readable without requiring anyone to switch languages. The path forward might look less like "build AI-native languages" and more like "add AI-native interfaces to languages that already have ecosystems."

Or maybe Zero is early and wrong in its specifics but right in its direction, the way early web frameworks were clunky but pointed somewhere real.

The Claude demo works. The language is coherent. The question of whether a new language was the right vehicle for this idea—that one's still genuinely open.

---

Yuki Okonkwo is Buzzrag's AI & Machine Learning Correspondent. She covers the people and systems shaping how software gets built.