[0:00]
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 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. they're hanging out down there. Um, so, uh, yeah, Bun merged their big 
[0:31]
rewrite today from Zigg to Rust. And I realized this is a bigger story than I thought it was. This is, I think, the thought it was. This is, I think, the first really public example we have of a large scale software project completely 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 
[1:02]
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 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 
[1:35]
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 of course paying even more for API usage. And so what happens if a big project like this cuz because with bun this is 
[2:06]
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 
[2:38]
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 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. 
[3:10]
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. 
[3:43]
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 
[4:14]
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 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 
[4:44]
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 
[5:15]
this in perspective, there's something even more crazy here. I don't know if you're familiar with 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 core, which uh comes from the WebKit project. and then they just wrap it and implement the node API as well as their own 
[5:47]
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++. 
[6:21]
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 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 JavaScript core. How [ __ ] insane is that? Like what the hell is it even doing? 
[6:52]
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 JavaScript JIT compiler. Explain that to me. It's going to be very interesting to see uh what the limits are. 
[7:22]
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. 
[7:55]
you know um people just don't really appreciate this this entire topic of complexity and 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 
[8:28]
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 dress in military fatigues and stuff as kids and um I loved reading about like 
[9:00]
nuclear submarines and planes like the 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 successful projects in US military history. Uh, we are still using it today uh in 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 
[9:32]
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. 
[10:04]
Complexity is the enemy. That's what he 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 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 
[10:34]
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 
[11:07]
complexity and whether that complexity is harmful in the long run. It's so much harder to talk about that. It's so 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. 
[11:37]
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 A million [ __ ] lines. Are you kidding me? I think the Rust compiler itself is 2 million lines. And that's a Rust million lines. And that's a Rust compiler. 
[12:08]
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 
[12:39]
maintained or not? you know, um I I I' I've already stated my 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 
[13:12]
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 pay attention. I want to see what happens. 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 
[13:44]
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 a million [ __ ] lines. Are you kidding me? Yeah. 
[14:14]
Well, um we'll see if I turn out to be right. If not, then screw me.