Don't try to read every agent-written change the way you'd read a colleague's pull request. Decide where human attention goes by blast radius, let automated checks carry the low-risk work, and require evidence tied to the exact commit you're merging. Review gets harder with agents mostly because diffs arrive plausible-looking, large and quick, so the old habit of reading everything stops scaling.
The wider picture supports this. Google's 2025 DORA report announcement frames AI as something that speeds development but exposes weaknesses downstream, and the DORA year-in-review describes throughput gains that often come at the cost of stability when the foundation isn't solid. It's a survey of about 5,000 professionals and shows correlation, not proof of cause. Still, the practical reading is clear: more change volume needs strong automated testing, solid version control and fast feedback, or review becomes the place where problems pile up.
We'd also be careful about claiming the code is simply worse or simply fine. One vendor study of 470 open-source pull requests, from CodeRabbit, reported more findings per AI co-authored change. CodeRabbit sells an AI review product, and "co-authored" isn't the same as agent-written. An empirical study of Claude Code pull requests found agent changes largely acceptable, with no significant difference in merge time, while still benefiting from human oversight. Different measures, different answers. Plan for plausible diffs that sometimes hide real problems.
Sort changes by blast radius
The useful question isn't "is this AI code?" It's "what breaks, and for whom, if this is wrong?" We'd start with three tiers and set the lines from your own system, since only you know which parts of it are dangerous.
Read line by line. Anything touching authentication, permissions, payments, data deletion or migration, secrets, or input that reaches a database or file path. A preprint on agent-written security patches found they often repeat a narrow set of weaknesses such as injection and path traversal, and it argues for separating high-risk flaws from low-impact quality issues. A person should own these changes completely.
Skim, plus checks. Ordinary feature work inside well-understood code. Here the reviewer reads the summary and the tests, then looks for the things agents do characteristically. GitHub's guide to reviewing agent pull requests calls out code reuse blindness: agents replicate patterns and duplicate utilities that already exist. A skim should ask whether this reinvents something we already have, and whether the change stayed inside the scope of the task.
Let automation clear it. Formatting, documentation, dependency bumps with green tests, renamed variables, generated fixtures. If the checks pass and a rollback is cheap, a human reading every line adds delay and little safety.
Write the tiers down and make the tool enforce them, for instance by path rules that route changes in sensitive directories to a named reviewer. Otherwise the policy lives in people's heads, and the most pressed reviewer quietly decides it alone. For context, a University of Victoria study of 100 merged agent-related pull requests in open-source projects reported that 65% were merged without formal human approval, so skipping approval does happen.
What automated checks prove, and what they don't
Passing checks tell you the change didn't break what you already measured. They don't tell you it's right.
Type checks and linters prove the code is consistent with its declared shapes. Existing tests prove old behavior still holds. Those are worth a lot, and they're the cheapest part of review to scale.
The weak spot is tests written by the same agent that wrote the change. If the agent misunderstood the requirement, its tests can encode the same misunderstanding and pass cheerfully. That's why we'd treat agent-written tests as documentation of intent for a human to confirm, not as independent proof. Coverage has the same gap: a high overall number says nothing about whether the changed lines were exercised. Ask for coverage of the diff, not the repository.
The Claude Code study makes a related point: benchmarks focused on functional correctness miss a large part of the work needed to integrate AI code into production. Fit, scope and maintainability still need judgment.
Tie evidence to the exact commit
A green check from ten minutes ago is evidence about a different change if anyone has pushed since. This is where review quietly rots: the agent fixes a comment, force-pushes, and the earlier approval still shows on the pull request.
ForgeLoop, a development-preview delivery system connecting issues, agent tasks, runners and pull requests, is built around this rule: acceptance coverage, gate output and delivery checks are tied to the commit under review, and a changed branch must not inherit verification evidence for an earlier commit. We'd recommend the same rule in any process, with or without our tooling: when the commit changes, the evidence resets.
The second half is keeping the basis of a verdict. Warrant, our private-development CI harness for one-diff reviews, records input digests, tool versions, prompts, responses and cost beside the result a reviewer needs to assess. Its limits matter too: recorded model output is evidence to inspect, not a promise an answer can be regenerated exactly. For your team, the plain version is that a reviewer should be able to see what was checked, against which commit, with what result, rather than trusting a summary.
Comparing the alternatives
Stricter human review of everything. It's the safest-feeling option and the one that creates the bottleneck. Worth it for the top tier only.
A second model as reviewer. Useful as a noisy first pass, especially for simple changes. Some studies cited in recent preprints report that AI reviewers can reduce manual effort but increase comment volume without shortening review time, and that they handle changes needing broad context less well. We'd treat it as a filter ahead of a human, not a replacement, and expect to tune out noise.
Smaller task scoping. Often the cheapest fix. DORA-related findings point toward small batches, and GitHub's guide notes that large pull requests without a structured plan correlate with agents drifting from the goal. A change a reviewer can hold in their head is a change that can be skimmed safely. Scope tasks so each produces a reviewable diff.
Strong checks plus tiers. The combination we'd begin with: small tasks, enforced risk tiers, diff-level coverage, commit-bound evidence, and a model pass for the middle tier.
Where this stays slow
Some review won't speed up. Security-sensitive changes, unfamiliar domains and changes in code nobody on the team understands still need a person with time. If your tests are thin, no review policy fixes that; the first investment is the safety net, not the reviewer. Also, most of the studies above cover open-source projects and one or two tools, so results for a private product team may differ.
Custom review tooling is rarely the first step. Existing branch protection, code owners and CI usually cover tiering and required checks. Build something only when you need evidence bound to commits across several agents and repositories.
This week's decisions
- Name the paths and change types that always get a line-by-line human read.
- Decide what may merge on green checks alone, and what rollback looks like.
- Require coverage of the changed lines, and reset approvals when a commit changes.
- Cap task size so diffs stay reviewable.
- Decide whether a model reviewer is a pre-filter or nothing at all.
If several of these are unclear, or you're unsure whether your tests can carry the load, a short software consulting engagement can settle the policy and what, if anything, to build before you spend on tooling. If you're still setting up how agents run, our piece on running several coding agents at once covers isolation and approvals, and paying a consultant before hiring a studio explains when that advice is worth buying. You can also contact us with a description of your current review flow.
Prepared with AI-assisted research and writing, with automated editorial checks before publication.





