I read something this week that crystallized something I've been feeling for a while.
The argument: code review as we know it is dead. Not because it was a bad idea, but because AI-generated code has broken the math. Teams with high AI adoption are completing 21% more tasks and merging 98% more PRs. But PR review time is increasing by 91%. More code, bigger diffs, same number of humans to review it.
You can't hire your way out of that. And you can't AI-review your way out of it either - an AI reviewer checking AI-generated code is just two systems agreeing with each other.
The answer is to move the human checkpoint earlier.
The shift is from reviewing code to reviewing specs.
Old model: human writes code, human reviews code.
New model: human writes spec, agent writes code, machines verify against spec.
The code becomes an artifact of the spec - not the thing you review. That's a fundamental reorientation.
Where humans add value now:
- Defining what "correct" actually means (acceptance criteria)
- Setting scope and escalation triggers - what can the agent touch, what requires sign-off
- Reviewing specs, constraints, and plans - not 500-line diffs
BDD was always right. We just didn't have a reason to do it.
With humans writing code, writing a Gherkin spec felt redundant. With agents, the equation flips. The spec is how you control what the agent builds. The spec isn't extra work - it's the input.
I've been thinking about this in the context of how we test at Autonomous. Our QA agent tests against the instructions in the ticket - not against the code. It doesn't know what "correct" looks like by reading the implementation. It knows because you told it what to expect.
The verification stack matters.
No single gate catches everything. Stack imperfect layers: coding guidelines, org-wide invariants, domain contracts, acceptance criteria.
Key rule: verification criteria come from the spec, not the implementation. If you let the agent define what "correct" means for its own code, you've lost.
The senior engineering skill that matters most right now isn't writing code. It's writing specs well enough that an agent can implement them and a verification layer can test them. That's closer to product thinking than implementation thinking.
The engineers who get good at this fast will be extraordinarily leveraged. The ones who stay in the diff-review mindset will be bottlenecks.
Code review was a checkpoint. The checkpoint didn't go away - it moved.
TL;DR
- AI-generated code has broken the math of code review: 98% more PRs, 91% more review time
- The answer isn't better AI reviewers - it's moving the human checkpoint to the spec
- Specs become the primary artifact; code becomes the output of verification against them
- BDD finally makes sense at scale - write the spec, agent implements, framework verifies
- The senior engineering skill that matters: writing specs, not reviewing diffs