Why the Traditional Code Review Model Is Under Strain
Agentic code generation and agentic code review fundamentally change how quickly code can be produced, the role of code in software development, and how its quality must be established. Generating code is becoming faster than we can realistically read and review it. Yet, AI does not automatically increase the capacity of human developers to understand, review, and assess these rapidly produced artifacts.
As a result, many teams face growing tension within the traditional code review operating model. Emerging evidence suggests that AI adoption can increase reviewer workload through higher change throughput and larger change sets. As teams give agents more substantial tasks and greater autonomy, some changes will naturally become even larger.
Peer Review Becomes a Bottleneck
In these faster development cycles, a peer who was not directly involved in creating the change may become less well positioned to act as the primary reviewer of every implementation detail. This is particularly true when that person is presented with a large and complex change only after it has already been produced. Reconstructing the decisions, assumptions, and iterations behind the change can require significant cognitive effort. This can lead either to superficial approval or to long review cycles, especially for large changes.
Some teams try to enforce small pull requests so that detailed peer review of every code change remains manageable. Yet, as code production becomes faster, the growing volume of small changes can still introduce substantial waiting time, context switching, and coordination overhead. This can reduce some of the speed gained through GenAI-assisted development, and impact the flow-state.
The Role of Code Is Changing
At the same time, GenAI does more than deliver speed improvements; it changes the role of code in programming, and how developers engage with code. As agents take over more of the implementation work and become increasingly capable, especially in low-level implementation tasks, the knowledge developers need begins to shift towards higher-level architectural and design understanding.
These developments do not reduce the need for human understanding, accountability and oversight. GenAI cannot upload a mental model to a developer, and apart from the possibility to introduce defects, it can also produce implementations based on flawed assumptions, introduce architectural or design drift, or mimic system understanding where there is none. Agents can enable developers to produce more work, potentially with higher quality and in less time, but it has also never been easier to produce plausible-looking, low-quality output. Distinguishing between the two can require significant effort, particularly when problems are buried inside a large change.
Code Review Still Matters, but Its Role Must Change
Code review therefore remains important, not because human reviewers can guarantee correctness or find every defect, but because developers still need to understand changes, challenge important decisions and tests, notice obvious problems, share knowledge, and maintain collective ownership of the system. However, its operating model needs to evolve as development becomes more agentic.
We therefore need a code review model that is designed for verification in an agentic development environment, rather than simply applying the traditional peer-review model to increasingly AI-generated code. Such a model should take advantage of automation where it is strong, make the developer who steers the agent responsible for understanding and verifying its work, and preserve independent peer review where human challenge, knowledge sharing, and collective ownership matter.
It should also acknowledge that not every change requires the same level of human attention. The required oversight should depend on what is being changed, how important it is for others to understand it, what could happen if it goes wrong, and how much confidence has already been established through automation and human verification. The goal should not be to remove humans from code review, but to use their limited attention where human judgment provides the most value.
Towards a New Code Review Operating Model
This is the idea behind SCOPE: Staged Code Oversight with Proportional Escalation, a candidate code review operating model I am currently developing for agentic software development.
SCOPE distributes review across three stages: Agent Review, Developer Review, and Peer Review. The steering developer performs the first detailed human review and takes responsibility for understanding and verifying the agent’s work. Peers then provide an independent perspective, challenge important assumptions and decisions, and maintain shared understanding of the system. How deeply each stage is performed is adjusted proportionately to the change’s understanding needs, risk, and the assurance already established.
The underlying principle is simple: automate what can be automated, keep responsibility with the developer directing the work, and use independent human review where understanding and judgment matter most.
