The End of Programming? The Controversy Behind AI Rewriting a Million Lines of Code

AI Rewrites a Million Lines of Code in 11 Days

Debate over "the end of programming" has been intensifying lately: Is human code review on the verge of becoming obsolete? This idea keeps resurfacing across developer communities.

At the center of this wave of discussion is something raised by Paul Dix — CEO of InfluxData and creator of InfluxDB — who mentioned that an AI wrote 1 million lines of code, then continued refining them over the following months. Specifically, this refers to a project that rewrote Bun (a JavaScript runtime) from Zig to Rust.

The numbers are striking: the entire rewrite was completed in just 11 days, at a total cost of roughly $165,000 in API calls. The result is reliable software that now runs on the machines of millions of developers.

Bun is a high-performance JavaScript/TypeScript runtime created by Jarred Sumner, positioned as a competitive alternative to Node.js. Its original version was written in Zig — a systems programming language known for fine-grained performance control and excellent C interoperability, though it has a relatively niche ecosystem. Rust, on the other hand, has rapidly risen to prominence in systems programming, celebrated for its memory safety guarantees (without garbage collection) and robust toolchain ecosystem, and has been widely adopted by Mozilla, Microsoft, the Linux kernel, and others. Migrating Bun from Zig to Rust means re-implementing the entire runtime using completely different language semantics and memory models while preserving all existing functional behavior — this goes far beyond syntactic translation, touching on concurrency models, error handling mechanisms, and deep architectural decisions around low-level system calls.

Just How Impressive Is This Achievement?

From an engineering standpoint, this is a result that deserves to be taken seriously. Some might push back and say it's no big deal — after all, they had an "Oracle" (a reference standard) to compare against, since translating from one language to another inherently comes with a clear correct answer to validate against.

But that view actually undersells what happened here. A language migration may seem "straightforward," but it still involves handling complex logic at the million-line scale. The key insight is this: if you can build a verification system and provide the right decision-making context, AI can produce highly complex, highly precise software.

In other words, the value of this case isn't that "AI can translate code" — it's that it demonstrates how, when a verifiable correctness standard exists, AI can complete large-scale engineering tasks in a fraction of the time that would traditionally require enormous human effort.

The Verification System Is the Real Key

The real crux of this debate isn't "can AI write code" — it's "how do we verify that the code AI writes is correct."

The Zig-to-Rust rewrite succeeded precisely because it had a natural "ground truth" to compare against — the existing Bun functionality served as the verification baseline. Every piece of Rust code generated by AI could be confirmed correct by comparing it against the original behavior. This also explains why the argument that "human review is nearing its end" has begun to emerge: when verification can be automated and scaled, line-by-line human review becomes increasingly secondary.

Underlying all of this is a deeper judgment: the ceiling of AI's programming capabilities depends largely on whether we can design clear verification mechanisms for a given task. For tasks with well-defined correctness standards — such as code migration, test-driven development, and refactoring with explicit specifications — AI may significantly exceed expectations. For vague requirements that lack objective validation criteria, human judgment remains irreplaceable.

The Oracle concept mentioned here comes from the field of software testing. A "Test Oracle" refers to a mechanism or reference point that can determine whether a program's output is correct. In code migration scenarios, the original implementation naturally serves as the Oracle — for the same input, the new implementation's output must match the original's, providing a solid foundation for automated verification. This concept is closely related to Differential Testing: by feeding the same test cases into two implementations simultaneously and comparing their outputs to detect discrepancies, a technique already widely used by Google, Apple, and others for testing compilers and interpreters. When AI generates code, having such a comparable Oracle means the verification process can be fully automated and massively parallelized — a critical engineering prerequisite that enabled this million-line migration to be completed in just 11 days.

Is Programming Really "Over"?

"The end of programming" is a headline-grabbing claim, but a more accurate framing might be: the shape of programming is changing. The developer's role may shift from "writing code line by line" to "designing verification systems, defining correctness standards, and making critical decisions."

The lesson from the Bun rewrite is clear — AI is already capable of independently handling complex engineering work at the million-line scale, provided the task itself is verifiable. This is both a stunning technical milestone and a question worth sitting with across the entire industry: in scenarios without an "Oracle," how do we establish trust?

This article is based on analysis from a single YouTube source. The figures cited (1 million lines of code, 11 days, $165,000) come from Paul Dix's public statements; readers are encouraged to independently verify the project details.