Bun rewritten in Rust: when tribalism drowns the technical debate

Quite the kerfuffle broke out in the systems-language world. Bun — the JavaScript toolchain that began as a line-by-line port of esbuild’s transpiler — was rewritten from Zig to Rust. As far as I can tell, it was written by a single engineer orchestrating Claude, following Anthropic’s acquisition of Bun. Jarred Sumner lays out the how and the why in a long, well-crafted post: 64 instances of Claude running in parallel over 11 days, adversarial review across separate contexts, more than a million lines, roughly $165,000 in compute, and the same old test suite — written in TypeScript, indifferent to the runtime’s language — as the safety net.

Like every radical change, it stirred discontent. Zig partisans trash Rust; Rust partisans feel vindicated and trash Zig. The usual thing: partisan sentiment dressed up as technology. What struck me as worth commenting on was Andrew Kelley’s response, the creator of Zig.

The argument was there; the noise buried it

I’ll be fair, because it’s the right thing to do: Kelley does bring technical arguments. He holds that the dichotomy Bun’s post sets up — either a style guide, or a language feature — is a false dilemma, and that bugs are eliminated above all by devoting engineering resources to hunting them, the way TigerBeetle does. He points to a real tension: if the test suite wasn’t enough to catch the bugs in the Zig code, why would it be enough to armor a million machine-generated lines with no line-by-line human review? He reminds us that LTO was always available in Zig, that much of the binary-size savings is orthogonal to the change of language, and that the post avoids mentioning compile speed. These are legitimate objections. There’s a debate there.

The problem is everything else. Those arguments come wrapped in — and end up subordinated to — a disqualifying biography: the “beginner energy,” the portrait of a bad manager built from hallway rumors, the diagnosis that Jarred “wrote slop” even before he had LLMs, the “RoboBun” nickname. By the time you finish reading, you don’t remember the point about LTO: you remember the imaginary mug that reads “It Tastes Like It’s Not My Problem Anymore.”

And that is exactly the phenomenon worth naming. The technical discussion drowns under the tribal feud, and it tends to do so precisely when the technical argument, on its own, isn’t enough to close the case. If your objections were decisive, you wouldn’t need the psychological portrait of your adversary. The attack on the person is not a complement to the argument: it’s what gets put in its place when the argument doesn’t suffice. To me the text has the cadence of a leader who, faced with a split, spends more energy explaining why the dissenter was never really one of us than rebutting what he did. It’s a tactic I’ve seen in political and religious organizations facing the risk of a stampede: you armor the flock by discrediting the one who left.

What a good project lead radiates

A technical leader radiates confidence through concrete qualities: level-headedness, composure, a focus on engaging criticism, and a capacity for self-criticism. You don’t have to be milquetoast to have them. The “benevolent dictator” paradigm — I think of Linus Torvalds — proves you can be vehement, even crude, and still be a trustworthy leader. The key isn’t the tone: it’s the origin. Torvalds’s tirades, for all their excess (and yes, there were excesses he later apologized for), almost always start from a verifiable technical claim: this patch breaks that, for this reason. The fury is anchored to a fact, not to the author’s biography.

Kelley’s text inverts that order. It opens with the person’s character and reaches the code almost out of the corner of its eye, and when it gets there, the aggressive emotion doesn’t dissipate: it keeps saturating everything. It isn’t a technical treatment contaminated by a bit of emotion; it’s an emotional score-settling to which a few technical points were added, almost as an alibi.

The telling thing is the contrast with the very post it criticizes. Sumner’s piece — however much it is, as Kelley rightly notes, a marketing artifact polished by a company with a lot at stake — models precisely the virtues you hope for in a leader: it thanks Zig without ambiguity (“Bun would not have been possible without Zig”), it doesn’t blame the language for its own bugs, it documents 19 regressions it introduced and then fixed, and it closes with a motto that ought to be framed: “Boring is good.” It’s hard to accuse someone of arrogance when they’re enumerating their own mistakes. Composure, when it exists, doesn’t need to announce itself.

The AI in the room

There is, moreover, a deeper technical debate that did deserve to be had and that almost no one is having, because they’re too busy picking a side: what does it mean to merge a million lines written by a model? Kelley’s discomfort with “slop contributions” isn’t entirely unfounded as a category — the question of review, accountability, and technical debt for AI-generated code is real and unresolved. But it’s a question you answer by examining the process (the adversarial review across separate contexts, the continuous fuzzing, Miri in CI, the fixing of instrumentable leaks), not by adjudicating who has better taste. The irony is that Bun’s post offers abundant material for that discussion, and the response preferred to discuss the person.

Coda: choose on merit, not on flag

I’ll close with an interested party’s confession. In my projects I use the stack that, in my judgment, meets most of my technical and strategic requirements, and in many cases that stack has turned out to be Rust. I don’t say this to plant another flag. I say it because choosing tools on their merits — memory safety guaranteed by the compiler, Drop instead of defer disciplined by hand, an ecosystem that reduces a whole class of bugs to compile errors — is precisely the opposite of the tribal reflex I’m criticizing here.

Zig is an excellent language and Bun wouldn’t exist without it; Sumner himself says so repeatedly. Rust served one concrete problem better: mixing GC-managed memory with manual memory, a case almost no language designs for explicitly. That’s the whole technical story, and it’s a story without villains. Everything else — the biography, the rumors, the tea mug — is the noise we add when we’d rather win the argument than have it.