Code review must move upstream—from pull requests to intent

The pull request-based code review, now roughly two decades old, is showing its age. What began as a practice to catch defects before integration, educate junior developers, and distribute context across teams has increasingly become a compliance theater that slows down modern development—especially as AI tools generate volumes of code traditional review processes cannot handle.

The core insight is straightforward: by the time a large diff lands in a pull request, the critical decisions have already been made and thousands of tokens have already been spent. That's too late to shape the direction of the work.

The bottleneck at the merge gate#

Code review has become a single, fixed checkpoint—right before merging—but teams that practice trunk-based and test-driven development, such as those at Thoughtworks, show that review needn't happen in one ceremonial moment. When developers pair-program and build sufficient test coverage, a passing pipeline becomes a reliable signal. The review happens continuously throughout the work, not weeks later when someone finally reads a 500-line diff.

The real forcing function for change has arrived with agentic AI. When a single agent can generate a full feature in an afternoon, waiting until the implementation is complete means you're already dealing with the consequences of decisions made hours earlier. The gaps worth catching have shifted upstream—to the moment a developer expresses what they're trying to build.

From implementation review to intent review#

Traditional code review asks: Does this code look right? The emerging approach asks a more valuable question: Is this solving the right problem with the right constraints?

This reframing changes what reviewers need to see. Instead of tracing through hundreds of lines of code, they examine the original intent, acceptance criteria, and perhaps a brief summary of the path the agent took. A senior engineer's time is better spent validating that the spec is solving the right problem than performing line-by-line code inspection on AI-generated implementation.

The knowledge-sharing function of review survives and scales through what some teams call an "AI slop register"—a living document of domain-specific patterns, libraries, and conventions that should be followed. When a reviewer spots a recurring mistake across code reviews, they codify it as an invariant. Once encoded, that invariant prevents the same issue from reappearing without requiring human intervention.

When machines verify, humans judge