Dev ToolsArticle An agent ported a production JS runtime from Zig to Rust in six days, and nobody read the million-line diff.
[Priya Nair](https://sourcefeed.dev/u/priya_nair)
For twenty-five years the received wisdom on rewrites came from Joel Spolsky: don't. Throwing away a working codebase to start over is the single worst strategic mistake a software company can make. [Bun](https://bun.com) just did exactly that, ported an entire production JavaScript runtime from [Zig](https://ziglang.org) to [Rust](https://www.rust-lang.org), and the interesting part isn't that they broke the rule. It's *how* they broke it, and what that says about where large-scale engineering is heading.
The headline numbers are the story. 6,755 commits on a branch named claude/phase-a-port
. Over a million lines added. PR opened May 8, merged May 14. Six days. Not a single line written by a human, and per the reviewer list, no human read the whole thing before it merged. The bots approved it (coderabbitai
and claude
), while the one human on the review, alii
, was still marked "Awaiting requested review." Pre-merge, this burned 5.9 billion uncached input tokens and 690 million output tokens, roughly $165,000 at API pricing. Free, conveniently, when your employer is Anthropic, which acquired Bun in December 2025.
My read: this is a genuine milestone, but not the one the triumphant framing suggests. The lesson isn't "Rust beat Zig" or even "agents can rewrite anything now." It's narrower and more useful. A rewrite at this scale was only possible because Bun's test suite was written in TypeScript, which made it language-independent. That suite, with something on the order of a million assertions, became a conformance oracle the agent could grind against. Everything else, the model, the adversarial review loop, the parallel workflows, was downstream of that one architectural accident. Your tests are now your rewrite insurance. That's the takeaway worth carrying into your own codebase.
The conformance suite did the heavy lifting #
Strip away the drama and here's the actual mechanism. Bun's creator, Jarred Sumner, describes starting the port as an experiment with a pre-release Anthropic model (referred to as Mythos/Fable), fully expecting it to fail. A few days in, a high percentage of the suite started passing and the generated Rust visibly mirrored the original Zig. That's the moment the odds flipped from "worth trying" to "I'm going to merge this."
The critical detail is that the tests don't care what language the runtime is written in. They exercise behavior through the JS API surface. So the agent had a tight, automatable feedback loop: translate a chunk, run the suite, fix what regresses, repeat. When something went wrong, Sumner's approach was to fix the process that generated the code rather than hand-patch the output. That's a meaningfully different discipline from vibe-coding a feature and hoping.
This is why the Spolsky rule bends here and won't bend for most teams. The prohibition on rewrites exists because you lose all the accumulated bug fixes encoded in the old code, the thousand tiny corrections nobody documented. A comprehensive behavioral test suite captures a large fraction of exactly that knowledge and hands it to the new implementation as a pass/fail gate. Bun happened to have one. If your "tests" are 40% line coverage and a smoke test, an agent has nothing to converge against, and you get a plausible-looking rewrite that fails silently in production. Most codebases are in that second bucket. Be honest about which one you're in before you get excited.
Was Zig actually the problem? #
The stated reason for the move is memory management, and here Sumner is refreshingly precise. Bun mixes garbage-collected values from JavaScriptCore with manually managed native memory. Zig, like C, makes you write cleanup explicitly at each call site with defer
; it has no destructors, no implicit Drop
. A representative slice of the v1.3.14 bug list makes the pattern obvious: use-after-free in node:zlib
when a re-entrant write races an async one, a leaked SSL_SESSION
(~6.5 KB) per setSession()
call from a missing free, double-frees in the CSS parser. Use-after-free, double-free, and forgot-to-free on error paths. In safe Rust, most of that class is a compile error or handled by RAII-style automatic cleanup.
But several sharp critiques land here, and I think they're right. Sumner himself doesn't blame Zig, and he's careful to say other Zig users don't hit these bugs. The counterargument, made well across the Zig and Lobsters discussions, is that this is a mismatch between Bun and Zig, not a failure of Zig. TigerBeetle builds a database in Zig with famously few memory bugs because its culture prizes rigor over ship speed. Bun's culture is fast iteration on a runtime that constantly crosses the GC boundary, which is an uncommon enough combination that no language really designs for it. "Our team keeps making mistakes with this tool" isn't the same claim as "this tool is inadequate," and treating them as identical is an attribution error. The rewrite is a maturation decision that trades Zig's control for Rust's guardrails, which is a perfectly reasonable business call. It is not evidence that Zig failed.
Worth noting the human friction underneath all this: Zig's founder Andrew Kelley has been openly scathing about Bun's engineering practices and management, and the Zig Software Foundation's $60,000/year donation from Bun quietly stopped after the Anthropic deal. Read that context knowing it's partly a breakup, not a neutral technical review.
The part that should keep you up at night #
Here's where I part ways with the "boring is good" victory lap. The Rust port has shipped inside Claude Code since v2.1.181 (June 17), startup got about 10% faster on Linux, and barely anyone noticed. Great. But "the tests pass and users didn't notice" is not the same as "we understand this code."
A test suite validates known behavior on known paths. It says nothing about error-path handling under stress, boundary conditions, concurrent state, or the global invariants that span functions and live only in the original author's head. An agent translating function by function preserves local semantic equivalence while having no guaranteed grasp of those cross-cutting design constraints. Sumner concedes the point directly: memory issues re-entering across the JS boundary are something the Rust compiler can't catch, and those still depend on human oversight. Except the parts that depend on human oversight are also the parts no human has fully read.
That risk isn't abstract, and it isn't Bun's alone anymore. Before the acquisition, Bun was Jarred betting on himself, self-assumed risk, reasonable startup logic. Now it's the runtime under Claude Code, OpenCode, and 22 million CLI downloads a month, with first-party support on Vercel, Railway, and DigitalOcean. The risk moved from one founder to every engineer running Bun in production. The bill for a black-box codebase doesn't arrive at merge time. It arrives at 3 a.m. during a severe incident six months out, when the crash reproduces only under a specific production load and nobody on the team knows where to start looking.
What to actually do with this #
If you maintain something with a real, behavior-level test suite, this is a legitimately new capability. Agent-driven ports and large refactors just became feasible in a way they weren't eighteen months ago, and the pattern is copyable: a language-independent conformance suite, an adversarial review loop, and fixing the generator instead of the output. That's the workflow to steal. But treat the merge as the start of the review, not the end of it. Budget the human comprehension pass you skipped. Keep the old implementation runnable for differential testing. Assume the invariants that weren't in your tests didn't survive the translation, and go looking for them on the error and concurrency paths, because that's where they'll be missing. And run the numbers: $165,000 in tokens was free for Anthropic and won't be for you.
The rewrite worked. That's real, and it's impressive engineering. Whether it was understood is a different question, and it's the one the whole industry is about to spend the next few years answering the hard way.
Sources & further reading #
My Thoughts on the Bun Rust Rewrite— andrewkelley.me - My Thoughts on Bun's Rust Rewrite | Lobsters— lobste.rs -
[My Thoughts on Bun's Rust Rewrite | Jiacai Liu's personal website](https://en.liujiacai.net/2026/05/16/bun-rust-port/)— en.liujiacai.net -
[Rewriting Bun in Rust | Bun Blog](https://bun.com/blog/bun-in-rust)— bun.com -
[Rewriting Bun in Rust](https://simonwillison.net/2026/Jul/8/rewriting-bun-in-rust/)— simonwillison.net
[Priya Nair](https://sourcefeed.dev/u/priya_nair)· AI & Developer Experience Writer
Priya covers AI frameworks, developer productivity tooling, and the startup ecosystem across South and Southeast Asia, bringing a researcher's rigour and a practitioner's empathy to every story. She is deeply sceptical of benchmarks and asks hard questions so her readers don't have to.
Discussion 0 #
No comments yet
Be the first to weigh in.