Codex recently coded a browser from scratch. It took a week, but the AI worked solo, with no human in the loop. Could a human parse that code and truly understand it?
The bigger question is: does it matter?
Have you ever audited your binary’s assembly code? You don’t. You trust the compiler. AI-generated code will head in the same direction, though the journey will take time.
We do not yet blindly trust AI-generated code because we lack the necessary checks and balances. Our current ecosystem—languages, tools, workflows—evolved with humans in mind. When that human is replaced by an AI, we hit an impedance mismatch.
Take dynamic languages. They are often less safe than static ones, yet we use them because they are easy for humans to read and prototype. But if an AI crafts the software, who cares about readability? Why not use a statically typed language where unintended errors are mathematically impossible?
But types only prevent invalid code, not wrong code. To ensure the logic holds up, we will have to change our workflows too. Test-First Development will return to vogue. Let the AI generate exhaustive test cases, then write the code to pass them. Follow up with fuzzers for correctness.
Even sacred software engineering practices like code review will evolve. Today, a human reviewer acts as a poor man’s compiler: checking for syntax errors, logic bugs, and variable naming conventions. This is low-leverage work.
If you insist on mandatory line-by-line code reviews for AI-generated code, you merely shift the bottleneck from generation to verification. You are still reading the assembly.
We must shift the burden to reviewing test cases.
When you review a test, you are validating the business logic and the edge cases, not the plumbing. You stop asking “Did they use the right loop structure?” and start asking “Did they handle the null user state?”
This is a higher order of engineering. Let the AI handle the implementation details. If the test suite is exhaustive and the fuzzers are running, the underlying code—like assembly—becomes an implementation detail we can afford to ignore.
We are entering a new era of programming. Don’t be surprised if new programming languages emerge—ones with built-in formal verification, designed not for humans, but for machines.
Abhirama's Blog 