Robert "Uncle Bob" Martin, author of Clean Code, recently shared a striking observation: he never sees 95% of the code his AI agents produce. When asked about this apparent departure from his decades-long advocacy for human-readable code, he explained the reality of working at machine speed: "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."

The shift is undeniable. AI agents open pull requests faster than reviewers can read them, and most teams have already abandoned line-by-line inspection. Yet Martin's approach reveals that stepping back from code doesn't mean stepping back from review entirely. Instead, he focuses on what he calls "high-level supervision," examining architectural structure rather than implementation details. He uses tools that visualize code as diagrams—something close to UML—allowing him to expand, collapse, and drill into specific components without reading the underlying source.

In these visualizations, Martin looks for specific signals: functions with high CRAP scores (Change Risk Anti-Patterns, a metric combining cyclomatic complexity with test coverage), mutation-testing results that fall short, and dependency arrows pointing in the wrong direction. The agent attached to the diagram lets him run scenarios and propose structural changes before code is written. "This was the old dream of UML," he noted, "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."

The myth of not reading anything

Engineer Ray Myers has spent much of the year pushing back against the idea that code review should disappear entirely. His observation cuts to the heart of the debate: "Most of the people who are telling you don't read code are actually doing some lowercase form of actually reading the code." The reality is more nuanced than a binary choice. Some engineers skip review on low-stakes work but read carefully elsewhere. Others rely on automated verification—test suites, dashboards, harnesses—as their primary reading material. Some focus selectively on design and maintainability while skipping implementation details. None of them read nothing.

What reviewers should examine instead

Code review has historically served two purposes simultaneously: ensuring alignment and enforcing standards. AI has disrupted both, requiring a rethinking of what reviewers actually need to examine. A redesigned review process should direct reviewer attention to three specific areas.

Intent

What problem the change solves, what falls within scope, and what was deliberately excluded. Intent emerges from the prompts and conversations with the agent—the actual decision points where direction happens.

Acceptance criteria

These operate on two levels. The first addresses the specific change at hand; the second covers invariants from the team's AI patterns registry—the recurring corrections senior engineers make that should apply automatically to matching changes. A separate verifying agent, working without context from the code-writing agent, checks each criterion and returns a verdict with supporting evidence. The reviewer's job becomes examining whether the right problem is being solved with the right constraints.

Decisions

The architectural, behavioral, and technical choices made during development: which library was selected, what data model was chosen, how downstream timeouts are handled, and what was intentionally not built. Most AI-generated output is boilerplate; the decisions represent genuine human contribution and warrant human review. When engineers disagree about a decision, the team needs a dedicated space to work through it.

Martin characterizes the new human role as taking responsibility "just above the code level." Intent, criteria, and decisions all live in that space.

Preserving institutional knowledge

Code review has always served a secondary but critical function: building and sharing mental models of the codebase. Mitchell Hashimoto calls this the whiteboard defense—any engineer shipping a customer-facing system should be able to explain how it works and justify the decisions behind it. He doesn't expect perfect recall of function names, but he does expect a confident answer to questions like "Why did you do X instead of Y?" or "Where does this fail?"

Reviewing intent, acceptance criteria, and decisions keeps this mental model intact even when engineers cannot realistically read every line of AI-generated code. Teams maintain understanding of why systems work the way they do and how components fit together without requiring someone to examine every function. The organization no longer depends on a single senior engineer who remembers how everything connects.

Reading is not binary

David Poll, who leads GitHub's pull request and code review team, reframes the entire 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."

Most teams already operate this way—reading some parts closely while barely examining others. What makes this approach safe is the quality of what gets read in place of the code itself. Clear intent, criteria backed by real evidence, and decisions recorded where they were made allow progressively more code to fall out of the attention set with confidence.

Responsibility cannot be automated

Martin returns to a point that no tool can address: "The agents are not responsible for anything. They're entirely irresponsible. Only humans can be responsible." Code review can be restructured, attention can be redirected, and reading can be selective—but ownership remains irreducibly human. The engineer who merges a change owns it, whether they examined every line or none.

The conclusion is straightforward: you can stop reading the code. You cannot stop owning it.