You know, I've always loved programming

languages. I have looked into many and

I've found love in so many different

flavors. And so when today I saw a brand

new one dropping from Vercel, you could

imagine I was a bit curious. I was

piqued, okay? My hams, they were salted.

I was ready. Introducing Zero, the

programming language for agents. Now,

I'm not going to lie to you. I

immediately don't know what that means.

I always thought English was the new

programming language for 2026. AM I

RIGHT, BOYS? I wanted a system language

that was faster, smaller, and easier for

agents to use and repair. Explicit

capabilities, JSON diagnostics, type

safe fixes, made for agents on day zero.

I'm just going to be real with you guys.

I effectively don't know what any of

that means. Now, I've been programming a

long time and it's kind of embarrassing.

I I I I think I can understand what JSON

diagnostics mean, but explicit

capabilities? What doesn't that mean? I

I think a lot of programming languages

have explicit capabilities. Type safe

fixes? There's I assume that means you

have a type safe language. And no, this

is not some sort of April Fools' joke.

It's right here. There's an entire

repository filled with zero examples. I

looked a little bit at the compiler and

I'm not a compiler engineer, but yikes.

I was able to get this bad boy to

compile and I got a hello from zero. So,

we actually just have to talk about this

because honestly, this has to be one of

the times in my life in which I am just

utterly confused. I don't I I truly

don't understand the purpose of this at

all. But first,

the bag, of course. Hey, you. Do you

like getting something better for less

money? Well, let me tell you about

today's sponsor. Blacksmith is the

fastest way to run your GitHub actions.

Two x faster job runs, four x faster on

caches, and 40x faster on Docker builds,

slashing costs up to 75% like that is an

obvious win. Blacksmith is already

trusted by over 3,500 companies

including Ashby, Veed, Clerk, and

Mitrefinch. Check the link in the

description to see how you can save a

boatload of money and have an excellent

action runner. Okay, welcome back. What

Zero is aiming for? Agent-first

learnability. A small regular language

surface that agents can pick up quickly

from examples, docs, and compiler

feedback. Standard library depth. Common

capabilities should live in documented

coherent library APIs instead of

scattered dependency stacks. Okay, I I

like that. That sounds good.

Deterministic tooling. I have never

heard in my lifetime of undeterministic

tooling. I have to say, this is a first

for me. Direct developer experience.

Checking, running, formatting,

inspecting, and repairing code should be

fast, copyable, and scriptable. I

believe that is pretty much programming

in any language but Rust. Regularity

over syntax. Prefer one obvious way to

express most things even when that makes

code more explicit than a human might

choose in another language. You know

what? You know what all these mean,

right? You know you know what he's

saying, right? Call Go. Like bro's

describing Go almost word for word. A,

Go's extremely limited in what you can

do. B, there's pretty much just one way

to do anything. Three, it's extremely

explicit. It is very very simple. You

got an error? You got an if error does

not equal nil handling case. Oh, you

want a complete tool set in which the

standard library effectively covers most

uses of the language itself? Again,

that's Go. Deterministic tools. Bro,

still don't know what that means but Go

Go is just jam-packed with all of it,

okay? Okay, so this is the actual

language that they're doing. Notice that

there's no syntax highlighting. Hey, we

haven't got there yet. GitHub, come on.

Can you get with it? This is a new

language that's been out for days. I

kind of expect you to already have some

syntax highlighters on the server able

to do this. Also, no fallback syntax

highlighting?

You can see right here that it does some

sort of reading from the environment.

When you read from the environment or

you get something from an array, you

have like first.has, that meaning this

thing is not null, and then doing a

standard memory equal first value to

write that means it's doing a memory

compare, a mem compare. This is like

straight out of Zig's playbook. Second,

when you write out to a file for

whatever reason, this writing out to a

file just somehow works, but when you

print out, then you have to do a check.

Like, what I mean, writing to a file

definitely can fail, but writing out to

the CLI, I mean, that can also fail,

too, but I just

What is this language design? Also,

check. I assume this is just effectively

if you get an error, it returns it, and

you can kind of tell that it returns it

because raises must say, "Hey, this

function can raise." And then this must

be the return type, which means you

effectively have some sort of colored

function, meaning that when you call

something that can raise an error, you

yourself probably will end up raising an

error, and then you kind of have this

raises goes everywhere. When I look at

this language, you guys can see all of

this. There's nothing here that's

interesting. There's nothing here that I

see as being agent first. This just

looks like Zig, which seems a lot kind

of almost antithetical to what they're

saying right here. Like, if you want

something that always is more explicit,

then do pray tell why you're just

tossing errors all over the place. This

kind of feels like an if error does not

equal nil situation brewing, but that's

not happening. Like, for me, this is

where I genuinely struggle. I don't get

why this exists. I don't see how we got

anything better here. I was actually

super curious about what does this

language look like? What does it agents

first language look like? I don't really

get that. Maybe it has something to do

with how the language is really small,

so it saves on tokens. Well, that's not

the case.

Maybe there's something that I can't

conceive of because my human brain is

too small and pattern matching in some

higher dimension that I will just never

see because I can't see around corners.

Nope. It's just plain old Zig with a

little bit of extra and some renaming.

Now, one day it may finally actually get

to where it needs to be, which obviously

is Go. That's where it's heading at

least based on its description. But

until then, this is what it looks like.

Also, just as a short nitpick, void not

just being a keyword but instead a type,

I'm triggered. Like honestly, I'm I'm

triggered AF, okay? That is just Okay,

hey, this is a crime against humanity.

But enough about what I think, what do

people think? Language with zero

representation in the current training

data set, bold move. Wow, this might be

in the training data in 2 years. Then it

may be usable. I'm assuming the Arch 64

back end intentionally does nothing, but

what's the point of the project in

general? Is there a design doc available

anywhere to read? Many of the decisions

make absolutely zero sense to me.

Interesting, but how do you even know

it's better for agents? Any backing

results? Better than what? All existing

programming languages? How is it for

humans? How do agents deal with the

relatively tiny code example size for

zero? What about the ecosystem? A brand

new language that no LLM has ever heard

about or knows how to write. Brilliant.

Zero is amazing. I want to try this

programming language for agents. Bro

just called this amazing and then goes I

want to try. Like you can't

You can't call this amazing. Now, as far

as it actually goes and more of like my

opinion on the technical side, I was

pretty alarmed to see this tweet right

here. I don't know, I found it funny

that there's 15 basic identical vector

implementations. He is correct. You can

see right here length, capacity, and

then field type items. It does the same

thing right here with ex- expression.

And then there's a whole bunch of other

ones type args that go on. There's

literally the same code over and over

again handling the push logic, being

able to push into each one of these.

It's so good. Don't get me started on

the back end because they're each having

this nice different way in which it's

handling big endian and different

operations, but they're all

approximately named the same. If you

scroll down, you'll see something like

this one A64 diag in which it checks to

see if this pointer does exist. And then

in the next implementation when you go

down, the elf diag, oh that always

exists. This is truly kind of like an

alarming project for me in my personal

opinion. Now, I don't know what it takes

to build a programming language. I've

built some toy ones. I did, I built a

compiler in college as one of the most

informative times of my life. Uh but

when it comes down to actually building

your own that you're actually going to

support with lots of lots of people in

the really like strong think through

that you have to do on language

ergonomics and design goals, I've never

done that. And this seems well, it seems

very interesting. In fact, when I told

the Teeg about this, he said, "Oh yeah,

I read that earlier. I'm designing my

own language too right now." Which is

just even I

>> [laughter]

>> I didn't even know how to respond to

that. Of course, it was OCaml-based

classic Teeg OCaml. But nonetheless,

like I just don't understand the purpose

of this. The language doesn't offer

anything that at least appears to be

interesting. Is the value all in the

compiler output? If that was the case,

why not just do something for

TypeScript, an extremely well-understood

environment? If you're concerned about

dependencies, you could have like the

TypeScript toolkit in which bootstraps

your project with everything you need to

write a program. And then guess what?

You're at Versel, so it's just

automatically going to work anyways.

Like I just truly don't understand what

the heck is this thing even for? Here's

the thing, I'm not trying to make fun of

Chris Tate or anything. It's just that I

I truly don't get this. Now, let me

explain myself why I keep saying that.

One, there's nothing interesting at

least as far as I can tell from a

language perspective. It just looks like

another C clone with some basic errors

as values and some conveniences around

auto magically returning out like that's

in Odin, that's in Zig. I wish it was in

Go, but Go it's not in you. It's just

that dog ain't in you, Go. The thing

about the language is that as far as I

can tell there's nothing agent first

about it. The examples given are

extremely verbose and so a bunch of

tokens means context windows get

polluted faster. So, that can't be it.

Also, since it's a novel language, the

context again is going to be polluted

faster by giving it the kind of

pre-required information for it to even

generate correct output. So, in other

words, it's doesn't appear to be agent

friendly at all. And the thing is is

like

what makes TypeScript good for agents is

that there's 1 billion examples of

TypeScript. And so generally speaking,

it kind of knows what right looks like

even when it produces horribly ugly

code. Okay, whatever. I

at least it can produce things generally

that work. Lot of heavy lifting in the

word work there. And then there's Rust.

It also has a gazillion examples, but it

also has the borrow checker which tends

to make it so that it has to keep the

LLM even more honest because so much of

it is even more constrained. Like the

amount of programs you can write with

Rust is greatly reduced comparatively to

say something like TypeScript. And so

those both offer something unique. I

don't know what this thing offers. And

even more so, I was genuinely excited to

understand what is a programming

language for agents because hey, I could

be ignorant in some areas. I actually

wanted to see like is there a

fundamentally different take

on what it means to write a program that

is not optimized for say human input or

is there an entire different branch or

family of languages that just seem to be

better? I'm surprised it's not Lisp,

right? I thought Lisp was the greatest

language of all time. The data is the

program. But I instead it's it's just

well, it's pretty much just C that

borrows a lot of stuff from Zig and

raise is kind of looks like throws from

Java. Check is clearly try from uh

what's it called? Zig. The only thing

that I think I guess they're going for

that would be unique is better error

messaging, but I feel like that's

something you could contribute to or

fork off already existing tools to say

in TypeScript or in Rust, but Rust

already has pretty decent tools and

pretty decent output. So that can't be

it. TypeScript has pretty decent errors.

So that can be like I just don't

understand it. And by the way, JSON

isn't some sort of magical unlock to

make LLMs understand stuff better. Like

I can type barely coherent English and

the thing can understand what I'm

saying. It's not like typing it in JSON

somehow makes it that much better. I can

hand it crazy C++ template errors and

it's going to spit out for me where the

template has gone wrong. It's rather

impressive. It operates on languages.

It's not somehow confined to HTML or

JSON despite what you've heard. So I

truly don't get like I I just don't. I'm

so curious and I was so excited. Please,

if you understand, please just explain

to me, okay? I'm old, okay? My fossils

are creaking. I'm clearly not that

smart. I'm not a language enthusiast.

I'm just a language using enthusiast

that has programmed in many, many

languages. I think Ginger Bill said it

best, the creator of Odin of course. I

think people who are designing languages

for LLMs are doing the equivalent of

horoscopes. They have no idea what they

are optimizing for since they don't

actually understand how these models

work. Why would their new language fair

better than any existing language? And

right now I'm completely inclined to

believe him. I There is absolutely no

reason for us to think that somehow

there is a language out there that is

just dramatically better for agents than

what we currently have. And if there was

a language that was dramatically better,

I assume it would be dramatically

different from any language we have

today. Okay, that's it. That's all I had

to say. I know that was There was some

strong app in me. The name is the

Primagen.