Hey guys, it's your boy Zach.
Um, I am hanging out by a river again.
As you can see, I had to wait for a
freight train to pass. There's a train
that passes on the other side there a
lot.
Um, but you'll still hear construction
noises and the geese probably cuz
they're hanging out down there.
Um,
so, uh, yeah, Bun merged their big
rewrite today from Zigg to Rust. And I
realized this is a bigger story than I
thought it was. This is, I think, the
first
really public example we have of a large
scale software project completely
transitioning
to agentic coding.
you know the the the initially they
wrote it in Zigg and and of course in
the early days it was handwritten they
started using Claude extensively
uh the last couple years and now with
this rewrite to Rust it's completely
written by Claude and I realized this is
actually a big risk because if this
fails and and the the project becomes
too complex for Claude to continue to
maintain
This could be a PR disaster not just for
Anthropic but even for
all frontier AI companies. Remember they
all pretty much pivoted to focus on on
coding the last year or two because they
collectively realized this is where the
money is, right? The money is not
getting normies to pay 10 bucks a month.
The money is in getting highly paid
programmers to pay $200 a month, getting
software companies to pay per seat, and
of course paying even more for API
usage.
And so what happens if a big project
like this cuz because with bun this is
like best case scenario for
agentic coding, right? They have an
unlimited token budget because they of
course work for Anthropic and they have
an unlimited human budget because they
they they can hire the best programmers
that money can buy. Um they're paying
Silicon Valley salaries, right? They
they're hiring people who can probably
run circles around me.
And and so if they get to a point where
this codebase becomes unmaintainable
even for Claude,
that would be a pretty big disaster. A
lot of people would suddenly be like,
uh, okay, maybe we still need to think
about simplicity.
But if they prove that they can still
maintain it,
um, then maybe people like me need to
re-evaluate.
Again, you saw in my last video, I'm not
against AI. I'm I'm in favor of using
it. Um, but I keep it on a short leash.
I review the code and I constantly steer
it when I see it doing making a solution
that's too complex.
They I don't think they're using AI that
way at Bun.
There's no way they are if they're if
they're doing a rewrite like this in a
week and a half.
We'll see. I mean, I'm actually really
interested. I want to see um if what I
said in that last video proves true.
Will complexity ever
grow so fast that it outstrips the
model's ability to deal with it? Okay,
doing the initial conversion is the easy
part. We know these models are good at
language to language conversions.
What we don't know is what happens next.
Will they be able to maintain and add
features and fix bugs without
introducing new bugs?
Um, we're going to have to find out.
There's there's already one bad sign
though. If you look at that PR, the new
Rust code base is just over 1 million
lines of code.
Now, the original Zig code base was
already quite large. It was 640,000
lines.
So, this rewrite
by Claude
increased the size of the the codebase
by like more than 60%.
Think about how crazy that is. Rust is
actually a more concise language than
Zigg. If you compare
uh equivalent code, the Zig code is
usually longer because Zigg requires you
to do more things explicitly. It
doesn't, for example, it doesn't have
destructors. So, the cleanup code is
always explicitly there.
Zig is a more verbose language and
somehow the rewrite
exploded the line count from Zigg to
Rust. How crazy is that?
But but there's even more. Just to put
this in perspective, there's something
even more crazy here.
I don't know if you're familiar with
Bun.
Bun is not a JavaScript compiler, just
to be clear. Um, Bun uses a JavaScript
compiler, right? Um, Bun uses JavaScript
core, which uh comes from the WebKit
project.
and then they just wrap it and implement
the node API as well as their own
additional standard library. That's all
bun is doing.
I think you can agree with me that the
JIT compiler for JavaScript is the more
complex part of this,
not the wrapper around it that adds
um implements the node API.
Well, I looked it up. JavaScript Core
the uh the compiler that they're using
is about 590,000 lines of C++.
It's just under 600,000 lines.
So even the original Zigg codebase of
bun was already larger
in line count
than the JIT compiler,
the JavaScript compiler that they're
wrapping.
And now with this Rust rewrite, it's
nearly double the line count of
JavaScript core. How [ __ ] insane is
that?
Like what the hell is it even doing?
What is it actually doing? and and and
explain how that requires double the
line count of a
very advanced featureful
JavaScript JIT compiler. Explain that to
me.
It's going to be very interesting to see
uh what the limits are.
And I one thing I can predict is that
the line count is not going to stay at 1
million. Guys,
as I said in my last video, complexity
compounds when you allow a a complex
solution to get into your codebase.
Every change after that has to be more
complex, too.
I think they're going to be adding an
insane amount of code to this project in
the future just to maintain it.
That's my prediction.
you know um
people just don't really appreciate this
this entire topic of complexity and
simplicity.
I think it's the most important
topic in our industry and almost nobody
can even talk about it correctly.
There's a lot that we can learn by
looking at other domains.
I'm from a military family. Both of my
parents were in the Navy. My dad
uh was in for almost four decades. He
primarily was on aircraft carriers.
He was an ordinance.
So, as a kid, of course, I was kind of a
war buff. me and my buddies, we would we
would always uh you know uh like read
World War II books and uh and even even
dress in military fatigues and stuff as
kids
and um I loved reading about like
nuclear submarines and planes like the
F-22.
One plane I did not appreciate enough
because it's not nearly as sexy is the
B-52 Stratofortress.
Um, which arguably is one of the most
successful projects in US military
history.
Uh, we are still using it today uh in
Iran.
It first flew in 1952.
Think about that. It first flew during
the Korean War and we're still using it
nearly 75 years later.
There's a lot that we can learn about
how a project of that complexity
was able to continue working as long as
it has.
Last year, I came across a random
comment on Hacker News from someone who
worked on the B-52,
and he said something that really stuck
with me. He said that the thing he
learned most is that simplicity is king.
Complexity is the enemy. That's what he
said.
I imagine anyone who works on a really
complicated project will say the exact
same thing. Someone who worked on the
Apollo program, someone who worked on uh
on a nuclear submarine or whatever. I
bet they all would say something
similar.
In the software world, we just don't
appreciate this subject enough. It's so
much easier to talk about concrete
things like memory safety. You can point
to that. You can point to memory safety
or performance.
Um, you can point to a CVE that was
caused by a memory bug. What you can't
easily point to is complexity. So,
people just don't talk about it. They
don't appreciate it. They can only talk
about the benefits of a very complex
language like Rust or C++. They can only
point because it's much easier to talk
about those concrete things. Almost
nobody can talk about
whether those languages lead to greater
complexity and whether that complexity
is harmful in the long run. It's so much
harder to talk about that. It's so
abstract.
And yet I maintain it's the most
important topic in our field, arguably
in any field.
But our field, I think, has less
appreciation for it.
I think Rich Hickey probably
did the most to improve our ability to
talk about it.
Um, which is why I got into closure back
then. But here we are 15 years later and
um, almost nobody in our field can talk
about it.
So, we're about to find out how
important this subject is.
A million [ __ ] lines. Are you kidding
me?
I think the Rust compiler itself is 2
million lines. And that's a Rust
compiler.
Bun is a [ __ ] wrapper around
JavaScript 4 and it's already half the
size of the Rust compiler.
Am I going insane here? Is this not like
completely absurd?
I'm fascinated, guys. Look, um like I
said, um the the initial rewrite is the
easy part. The interesting question is
what happens next? Can this actually be
maintained or not?
you know,
um I I I' I've already stated my
position
in the last video. Um
I think complexity compounds and a
codebase like that will get harder and
harder to maintain over over time, even
by frontier AI models.
But that's all theory.
I have to hand it to them because the
bun team is um
is is fearlessly marching forward here
and we're all going to benefit from this
as a
test case, you know. So, I got to give
him props for that. Um I I'm going to
pay attention. I want to see what
happens.
Um,
if anything,
I just want people to talk about
simplicity and complexity a lot more.
And maybe this will trigger that kind of
discussion a lot more because people
just don't talk about it enough in our
field. They they barely understand what
it even means. Um, but we're we're
rapidly reaching a point where um you
you have to talk about it
a million [ __ ] lines. Are you kidding
me?
Yeah.
Well, um
we'll see if I turn out to be right.
If not, then screw me.