“Human beings are too slow when dealing with code. So if we’re going to move at the speed of the agents, we’re all going to have to back off a little bit and maintain the high-level supervision, but at the level of code, that’s probably out of our domain now.”
That’s Robert “Uncle Bob” Martin, who wrote Clean Code almost 20 years ago, and a whole generation of engineers learned from it that code is written for other humans to read. When I had him on The Hangar DX podcast, he told me he never sees 95% of the code his agents write.
I didn’t expect to hear that from him. I also don’t think he’s wrong about the speed. Agents open pull requests faster than anyone can read them, and most teams stopped reading line by line a while ago.
Next, he said, “I try to get as much intelligence about what it has done as I can without forcing myself to go all the way to code.”
“Even the person who just declared code out of scope for humans is still reading something.”
Even the person who just declared code out of scope for humans is still reading something.
He showed me what that something is. Partway through our conversation, he shared his screen and walked me through the tool he reviews with now.
An agent breaks his project down into something close to UML, and he can expand, collapse, and drill into any part.
Problems show up in red:
- Functions with a CRAP score that’s too high. CRAP, short for Change Risk Anti-Patterns, is a 2007 metric that combines cyclomatic complexity with test coverage and spikes when code is both complex and poorly tested.
- A mutation-testing score that’s too low.
- Arrows marking dependencies that point the wrong way.
The agent is attached to the diagram, so he can run what-if scenarios, ask it to move components into different layers, and review the proposed structure before any of it becomes source code. He can still drill down to a module, but usually he doesn’t.
He’s checking the partitioning, the direction of the dependencies, and whether the parts that change often are decoupled from the parts that don’t.
“This was the old dream of UML,” he told me, “but UML was conceived back when it was a static thing that you did before you wrote the code. This is now a dynamic thing that you do after the code is produced.”
That works for one engineer and one agent. On a team, where other people need to understand the change too, what should the reviewer be looking at when they approve it?
Nobody reads anything
Ray Myers has spent a good part of this year arguing against the idea that we should stop reading code. When he came on the podcast, he summed up the people on the other side better than they do themselves: “Most of the people who are telling you don’t read code are actually doing some lowercase form of actually reading the code.”
Lowercase reading takes a few forms. Some engineers skip the code on throwaway, low-stakes tasks and read carefully everywhere else. Some lean on automated verification, so a passing test suite, a harness, or a dashboard becomes the thing they read. Some read selectively, skip the bug hunt, and look only at design and maintainability. Some read at the very end. None of them read nothing.
What to read when you stop reading the code
I’ve argued before that code review was doing two jobs at once, alignment and standards checking, and that AI broke each of them differently. The review I’d build today hands the reviewer three things to read.
Intent
What the change is for, what’s in scope, and what’s deliberately left out. Intent gets captured where decisions actually happen, in the prompts and the back-and-forth with the agent.
Acceptance criteria
These come in two layers. The first is the criteria for this specific change; the second is the invariants from the team’s AI slop registry, the patterns your senior engineers keep correcting, which apply to every matching change automatically. A verifying agent with no context from the agent that wrote the code checks each criterion and returns a verdict and evidence. This is how we built Verify at Aviator. The reviewer reads the criteria and the evidence with one question in mind: are we solving the right problem with the right constraints?
Decisions
The architectural, behavioral, and technical calls made along the way. Which library, which data model, what happens when the downstream service times out, what we chose not to build. Most of what an agent writes is boilerplate.
The decisions are what a human actually contributed, so another human should look at them. When two engineers disagree about one of them, the team needs a place to argue it out, and that deserves its own article.
Uncle Bob described the new human job as taking responsibility “just above the code level.” Intent, criteria, and decisions live there.
Keeping the mental model
Knowledge sharing and building mental models of the codebase were never side effects of code review; they were part of the job. Mitchell Hashimoto calls his version of this the whiteboard defense. Anyone who ships a customer-facing system should be able to explain how it works and defend the decisions behind it. He doesn’t expect them to remember function names. He does expect a confident answer when he asks, “Why did you do X instead of Y?” or “Where does this fail?”
Reading intent, acceptance criteria, and decisions keeps the mental model alive even if engineers can’t realistically read every line of AI-generated code. You still know why the system works the way it does and how its parts fit together, even if you haven’t looked at every function. And the team no longer depends on the one senior engineer who remembers how everything works.
Not reading the code is a sliding scale
Few people are closer to what code review looks like across the industry than David Poll, who leads GitHub’s pull request and code review team. When we talked, he told me that asking whether to read the code or not is the wrong question.
“The question is not whether I read or not read the code; it’s whether my attention gets directed to where it’s actually useful. Can I be pointed at the parts that are meaningful for me to go and look at and apply my judgment and expertise, and the things that can be with high confidence removed from my attention set, can fall away more and more over time.”
He’s right. Most teams already read some parts of their codebase closely and barely look at others. What lets you move along it safely is the quality of what you read in place of the code. Clear intent, criteria backed by real evidence, and decisions recorded where they were made let more of the code fall out of your attention set with confidence.
Someone still owns it
“The agents are not responsible for anything. They’re entirely irresponsible. Only humans can be responsible.”
That’s Uncle Bob again, and it’s the one part of this debate nobody can automate away. When I laid out the new shape of code review, I split it into five layers: argue, capture, codify, debate, and own. Own is the layer he’s talking about that no tool takes off your plate. The engineer who merges a change owns it, whether they read every line or none.
“The agents are not responsible for anything. They’re entirely irresponsible. Only humans can be responsible.”
You can stop reading the code. You can’t stop owning it.
The post If we stop reading the code, what do we read? appeared first on The New Stack.

