Code Review in the AI Era: Why Writing It Twice Is Actually Faster
TL;DR
AI coding tools make prototyping practical by allowing rapid creation of a disposable first version to validate requirements and solve technical problems. This clears the path for a properly engineered second version, ultimately saving time and improving quality.
Key Takeaways
- •Build two versions: a disposable AI-driven prototype to validate requirements and solve technical challenges, followed by a properly engineered production version.
- •The prototype phase removes constraints—ignore architecture, code quality, security—and focuses solely on making things work quickly.
- •Traditional engineering principles return for the second version: design-first approach, proper code reviews, and consideration of maintainability and security.
- •This approach addresses incomplete requirements understanding early, prevents over-engineering, and reduces psychological resistance to AI-generated code.
- •AI has changed development economics—what was once too expensive (two passes) is now more efficient and leads to better final products.
If you've been coding for a few years, you've probably lived through this nightmare: you finish the first version, finally get it running, and then realize you misunderstood half the requirements, hit three technical dead ends, and the architecture won't survive the next iteration. Want to rewrite from scratch? The deadline says no. So you keep piling on patches, and three years later, that codebase has become the legacy monster no one dares to touch.
This problem has existed for decades. But AI coding tools have accidentally given us a new solution.
My Approach: Two Versions, Two Standards
This idea isn't new. Software engineering textbooks call it "prototyping", build a rough version to validate your ideas, then do the real development. But nobody actually did this, because it was too expensive. Building a working prototype could take half the time of the real implementation. Who has that kind of runway?
Things have changed. AI writes code at a speed that still catches me off guard. A feature that used to take three days might now have a working version in three hours. This shift in velocity turns prototyping from "theoretically nice" into "practically worth it."
Here's how it works: you build two separate versions.
Version One: The Prototype, Let AI Run Wild
The first version has a clear purpose: it's a prototype, not a product. Two goals only: confirm the requirements and solve the hard technical problems.
The principle here is "no constraints", don't think about architecture, don't worry about code quality, ignore security and performance. Focus on one thing: make it work. Merge AI-generated code without review. Let the AI iterate until your product manager nods and says, "Yes, that's what I wanted."
This code is meant to be thrown away, so put it on a separate branch or even in a standalone repo. Its value isn't in the code itself, it's in two things: figuring out what the requirements actually are, and stepping on all the technical landmines first.
No matter how detailed your requirements doc is, you often can't think clearly until you build something. Technical challenges are the same, theory and reality are different beasts. The first version exists to step on every landmine at the lowest possible cost.
Think of it like an architect's sketch. Sketches don't need precise lines or perfect proportions. They help you externalize your thinking quickly, experiment, adjust, confirm direction. Nobody builds from a sketch.
Version Two: Production, Back to Traditional Engineering
Once the first version has cleared the path, you build the second. This is what actually ships.
Now you return to traditional software engineering: design first, then break it into modules, run CI pipelines, do proper code reviews. Keep commits small so humans can actually review them. Consider design, maintainability, security, all the things that matter.
AI still does the heavy lifting in this phase, but humans lead. Design before implementation. Use plan mode to have AI generate code according to your thinking.
The first version's code isn't completely wasted, some modules can be reused, especially algorithm implementations and core business logic.
It's like extracting the valuable parts from a sketch and putting them into proper construction drawings.
Why This Actually Works
Why go through the trouble of two versions?
The core reason: before the first version is done, your understanding of the requirements is almost certainly incomplete.
The problem with traditional development is that it invests too much effort in the first version. You start architecting before the requirements are fully understood. You consider scalability and maintainability before you've figured out the technical challenges. The result? Massive over-engineering for scenarios that "might happen someday" but never will. Time gets spent on edge cases while the real problems get ignored.
The two-version approach lets you clear the path at minimum cost first. After the first version, requirements are confirmed, technical problems are solved, and then you design—knowing exactly what to design and what to skip. Far fewer wrong turns.
There's a hidden benefit too. Many senior developers resist AI coding because they can't accept the quality of AI-generated code. But if you tell them this code is meant to be thrown away, it's just for validating ideas, the psychological resistance drops significantly. It's an out: use AI, but don't be responsible for that code.
Ultimately, AI hasn't just changed how fast we write code, it's changed the economics of the entire development process. Two passes used to be too expensive. Now two passes is actually cheaper. Accepting that the first version is disposable lets you build a much better second version.
