Bun 1.4's million-line Zig-to-Rust rewrite was produced by AI agents in 11 days

Bun 1.4 and a rewrite no human wrote line by line

Bun 1.4 shipped last week carrying the JavaScript runtime's full migration from Zig to Rust. According to Paul Dix, whose blog post on the release reached the Hacker News front page, the merge that landed the rewrite added 1,009,257 lines and removed 4,024 — meaning the bulk of the new codebase arrived in one enormous change. Dix acknowledges the language switch itself stirred up real drama in the programming community, but he argues the more important story is how the rewrite was done, and at what scale.

Eleven days, 6,778 commits, roughly $165,000 in tokens

As Dix recounts, the effort was driven by a single developer, Bun creator Jarred Sumner, working with a pre-release build of Anthropic's Fable 5 model and what Dix describes as a seemingly unlimited token budget. Sumner's key contribution was the harness and framework that let multiple agents operate in parallel, translating the existing Zig codebase into Rust. Over 11 days those agents produced 6,778 commits and burned through enough tokens to cost roughly $165,000 at API prices, had it been billed at standard rates.

Dix notes the scale only became apparent in early May, when the merge itself was the first public hint of what had happened, well before the accompanying write-up appeared. He anticipates the obvious objection: a port from one language to another has an oracle, since the Zig implementation already defines correct behavior. His counterargument is that this undersells the accomplishment. Building the verification system and providing the right direction allowed AI to generate highly complex software and keep refining it until it worked, and the result now runs on millions of developer machines.

The broader claim: humans review outcomes, not code

Dix's essay is titled "The End of Programming," and his thesis is that manually writing code and having other humans review it is headed for extinction — or at least will be overwhelmed by a flood of useful, working software produced by agents, where humans inspect only the end result. He expects plenty of low-quality, buggy output alongside well-engineered software that no human has read in fine detail.

As supporting evidence, he points to a graph in GitHub's post about its August 17 outage, which shows a steep, exponential climb in code production since last year. His theory is that most of that volume comes from side projects, internal skunk-works efforts and tools built for individual use — work companies treat as non-critical, and where there is far less organizational resistance to a developer shipping ten or a hundred times more. He also notes that nearly all of that code was generated by models that were frontier only months ago.

Dix adds that Anthropic and OpenAI developers posting on X describe shipping dozens or hundreds of pull requests per week, with their focus shifted up the stack toward systems, prompts and verification tooling rather than close line-by-line review. In his reading, they operate with effectively unlimited access to Fable and Astra, OpenAI's next model — a near-term future everyone else will reach about a year later, once weekly model allotments catch up.

A field report from InfluxDB

Dix pairs the Bun analysis with two of his own experiments, both built in a fork of InfluxDB. The first was an Iceberg integration exposing InfluxDB data via Iceberg REST, external S3 storage and a Glue catalog — an API and CLI, a REST implementation, deep compactor changes and an internal S3 API, amounting to thousands of lines of implementation and tests. After he sketched the architecture and requirements, agent work supervised by him produced a working version in 14 hours, which was then verified end to end against a running cluster using DuckDB and PyIceberg as clients, with a few bugs fixed along the way.

The second was an edge replication system: satellite InfluxDB nodes periodically replicating compressed data to a central cluster, complete with APIs, a CLI, compactor updates, metrics and system tables. After a collaborative design phase, 28 hours of agent work yielded a mostly functioning implementation.

His overall impression is that Fable is qualitatively different from earlier models, much as Opus 4.5 was when it arrived at the end of last November: given requirements and architecture, it can produce a fully functioning first version over multiple working hours with no further interaction.

Why it matters

If Dix's account holds up, Bun 1.4 is a milestone: a widely deployed runtime whose core was largely machine-written, then refined into software running on millions of machines. That reframes the Zig-versus-Rust debate entirely — the constraint is shifting from who can write the code to who can specify, verify and supervise it. For engineering teams, the open questions become review practice, ownership and trust in code no human has read. And since the rewrite depended on an effectively uncapped token budget, it also suggests compute access is becoming a competitive divide between frontier insiders and everyone else. Dix's larger prediction may prove overstated, but the numbers he cites give the argument a concrete data point.