Bun's Zig-to-Rust Rewrite With Claude Code in 11 Days

Key takeaways

1. Key idea: language rewrites are no longer a one-way decision. Historically, changing the language of a project like Bun (535,496 lines of Zig) = ~1 year for a small team, with a freeze on bugfixes, security, and features — therefore unrealistic, therefore "you never do it." Agentic AI transforms this trade-off: "What if I spend a week testing if Anthropic's new model can rewrite Bun in Rust?" Result: 11 days.
2. The "why Rust" argument is about feedback loops, not taste. The dominant bug class (use-after-free, double-free, missed free calls on error paths) comes from mixing GC memory (JavaScriptCore) × manual memory (Zig) — a case few languages are designed for. In safe Rust, these become compile errors + automatic cleanup (Drop, RAII). "Compiler errors are a better feedback loop than a style guide." Zig favors explicit defer (no hidden control flow); the alternative — homegrown smart pointers — offered "worse ergonomics than Rust, without the guarantees."
3. The constraint that makes the bet feasible: a language-independent test suite. Bun's tests are written in TypeScript → they don't depend on the implementation language. The port aims for minimal behavior change, validated by this suite (60,624 tests, 1.39M expect() calls, 0 tests removed or skipped, verified by hand). This is the safety net that allows merging 1M lines generated by an LLM.
4. Mechanical port > redesign. Explicit choice: preserve the Zig architecture, minimize changes, leave idiomatic Rust for after the v1.4 ship. "Incremental vs all-at-once?" → all at once (as with his original esbuild Go→Zig port, without an LLM). Everything else "is just tactics."
5. The harness: ~50 dynamic workflows in Claude Code, looping for 11 days. Pseudocode as stated: while (task = todo.pop()) { result = task(); feedback = await [review(result), review(result)]; apply(feedback) }. Dedicated workflows: generate the porting guide → mechanically port each .zig file to .rs → fix compile errors per crate → get the subcommands passing (bun test, bun build) → get the whole suite passing → refactors/cleanup.
6. Adversarial review, the core of reliability. A second Claude, in a separate context, that sees ONLY the diff (none of the implementer's reasoning), tasked with "finding why it's wrong." Ratio of 1 implementer / 2+ adversarial reviewers / 1 fixer; the implementer doesn't review, the reviewer doesn't implement (as with humans, the person who writes the code is biased toward merging). Catches bugs that are syntactically identical but semantically different: a Box dropped before an asynchronous uv_close (UAF + double-free); a negative timespec via trunc vs floor; an eager unwrap_or that panics where a lazy unwrap_or_else would not have.
7. "Fix the process that generates the code, not the code by hand.". Guiding principle: when a bug or an anti-pattern appears, the workflow/prompt gets edited, not the file. E.g.: when Claude adds long comments to justify workarounds, a rule is added for reviewers → "If you need a paragraph-long comment to justify why the workaround is OK, the code is wrong — fix the code." One prompt edit, a few hours, the behavior disappears.
8. Preparation (de-risking) before writing a single line. ~3 hours of discussion with Claude → PORTING.md (Zig→Rust pattern/type mapping). Then a workflow analyzing the lifetime of every struct field (reading + control-flow tracing, 2 adversarial reviewers), serialized into LIFETIMES.tsv for the other Claude instances. Then a trial run on 3 files before launching on the 1,448.
9. Parallelism and its false starts. Launching all 1,448 files at once → the Claude instances collide (git stash/stash pop/reset --hard). Fix: ban any git operation that doesn't commit a specific file, no cargo, no slow commands. Then 4 shards / 4 worktrees × 16 Claude = ~64 Claude instances simultaneously. Peak: 1,300 lines/min, 695 commits/h, 58 commits/min. A slow grep froze the disk due to insufficient IOPS on the EC2 instance.
10. ~16,000 compile errors treated as a queue. Split into ~100 crates (faster compilation) → reveals cyclic dependencies (the Zig codebase was a single compilation unit) → classification workflows followed by refactor workflows. cargo check writes errors to a file grouped by crate → distributed across 64 Claude instances. Isolation strengthened via systemd-run (cgroups) for memory-leak/stress tests (10k processes, gigabytes of disk fill, saturated TCP sockets).
11. The road to green (Buildkite CI, 6 platforms). From 972 failing test files to 23 in 2 days; Linux fully green ~1 day before Windows; build #54202 = 6/6 platforms green → merge. Merging ≠ releasing: enough confidence to commit, not yet to ship.
12. Cost, quantified and owned. Pre-merge: 5.9B uncached input tokens + 690M output + 72B cache reads ≈ $165,000 at API pricing. Realistic human alternative: 3 engineers, ~1 year, during which "we wouldn't have improved Node.js compat, fixed bugs/vulnerabilities, or shipped features" — therefore never done. "The realistic alternative was to do nothing and keep fixing the bugs forever."
13. After the merge, the work continues. 11 rounds of Claude Code Security review; 24/7 coverage-guided fuzzing of all parsers (JS/TS/JSX/CSS/JSON5/TOML/YAML/Markdown/INI/Bun Shell/semver/.patch), 100B executions → ~15 PRs (the fuzzer sends the repro to Claude, which submits the PR, followed by human review). ~4% unsafe code (~13,000 unsafe blocks / ~780,000 lines), of which 78% on a single line (a pointer coming from C++ or a C call) — expected to decrease toward idiomatic Rust. 19 known regressions, all fixed (e.g., the debug_assert! macro stripped in release builds → broken HMR).
14. The model and production. A pre-release of Claude Fable 5 ("a Mythos-class model"); Claude Code's dynamic workflows sustained 64 Claude instances for 11 days ("otherwise I would have had to write my own harness"). First release on Bun-in-Rust: Claude Code v2.1.181, +10% faster startup on Linux, minimal user-facing changes → proof of production maturity.
15. Related. agent-based code review / adversarial verification and consensus (Monperrus's "The End of Code Review," Kent Beck-style ADLC series "prosecution not code review" / "tests are the spec"); Loop/Harness Engineering (Lushbinary, Osmani, OpenAI Codex agent-first, the Ralph technique, git worktrees); Claude Code skills & dynamic workflows; Zig already in the corpus (ZML/LLMD, silicon sovereignty); token FinOps / cost per outcome.