Zero - the new programming language for AI - is basically Rust

Vercel just released Zero, a new systems programming language that produces native binaries under 10KB... and a marketing pitch that goes: the programming language built for AI agents

First, what Zero actually is

Zero is basically Rust, but simpler. Same explicit memory management. Same systems-level thinking. A borrow checker… but a weaker one. No LLVM backend, which makes the compiler faster but the output less optimised.
As someone who has written Rust (and C) in the past, the syntax immediately felt familiar to me.

So when Vercel says “AI programming language,” they’re not really saying “AI will write better Zero because, for some reason, it’s a language that AI seems to understand exceptionally well”. It’s not a language written in token IDs or something the models understand natively (even though at one point, reading discussions online, it almost sounded like that was the case).
What they’re actually saying is: we built a language where the toolchain was designed for machines to consume, not bolted on for humans as an afterthought.

That’s a different claim. And it’s actually more interesting.

What’s genuinely real… for real.

Three things. These are real.

One: The compiler speaks JSON natively. When Zero errors, it doesn’t print a message for you to read and interpret. It emits a structured JSON object with a stable error code. NAM003 means “unknown identifier.” Today, tomorrow, next version.
Most of programming languages added JSON output as an afterthought.
Zero made it the primary interface.
Honestly, that’s anyway something I would expect from a modern programming language with or without AI

Two: zero fix --plan --json. This is the one that caught my attention.
Zero tells the agent what to change and where - a machine-readable repair plan.
That’s pretty cool and matches with the previous point, the result is no guessing from an error description. The compiler hands the agent a fix plan.
That’s a genuinely different design decision… nice one!

Three: zero skills - version-matched guidance baked into the CLI. Run it, and you get a workflow guide matched to the exact compiler version you have installed. Meaning: the agent isn’t scraping documentation that might be three versions out of date. The guidance ships with the toolchain. That’s small and smart…

None of these are impossible to approximate elsewhere. Rust’s compiler has --error-format=json. You could build wrappers. But Zero made it structural.
First-class. The whole language is designed around that assumption.

Now, the part Vercel won’t say out loud

This is v0.1.2. No package registry. Limited cross-compilation.
Vercel themselves call it experimental and suggest you don’t use it in production.

And the “AI programming language” framing? That’s doing too much work. The language doesn’t make AI better at writing code. It makes the feedback loop better when AI is writing code.
That’s a very-nice toolchain improvement… but it’s dressed up as a paradigm shift.

I’ve seen Vercel do this before.
Let’s be real… Next.js didn’t invent server-side rendering - it packaged it beautifully and called it the future of the web. v0 didn’t invent AI code generation - it built the slickest interface for it and got the press cycle going.
Zero doesn’t invent structured compiler output. But it builds a whole language around that idea, ships it open-source, and calls it the programming language for agents.

Is that dishonest? Not really. Is it marketing? Abso-effing-lutely.

Here’s the thing: the core ideas in Zero… honestly are worth stealing.
I think they will influence how the next generation of toolchain designers thinks about agent-first developer experience. That’s real. Whether it’s Zero that becomes the standard or whether Rust and others absorb these ideas into their own tooling - that’s the more interesting question.

Should you adopt Zero?

No. Not yet, and Vercel knows it - they say so themselves in the README. If you put this in a production codebase today, that’s a you problem.

But if you’re building agent infrastructure, or you spend any time thinking about why agentic coding loops keep breaking down… honestly spend an afternoon with it. The Apache 2.0 license means no strings. The zero fix --plan --json command alone is worth understanding as a design pattern, even if you never ship a line of Zero. And the zero skills subcommand is a genuinely interesting idea for anyone building tools that agents will use.

The real question Zero is asking isn’t “should you use this language?”
It’s: is this gonna be the standard moving forward?

That’s a good question. I don’t care whether Zero is the answer.