Every bug your AI reviewer misses becomes a pattern your agents copy
Teams trust AI review with more of their code every month. At the same time, they hand it bigger pull requests that span more files, which are the pull requests it reviews worst. The bugs it misses do not stay single bugs. Coding agents learn from the code around them, so they copy what the reviewer let through.
We trust AI review with more every month
Pull requests with AI review
50–80%
At many companies, AI reviews most pull requests.
Faros, 2026Merges with no review at all
76.3%
The rise in pull requests merged without any review.
Faros, 2026As AI output increases, review capacity is not growing at the same rate.
When people cannot keep up, AI review fills the gap. That is a reasonable choice, but it makes the reviewer's misses matter more.
And we hand it bigger pull requests
Faros also found that pull requests are 51% larger, with 28% more bugs in each one. Larger pull requests are where AI reviewers struggle.
crbench is a public benchmark of 127 real pull requests with proven bugs. On its results by size, every reviewer catches fewer bugs on large pull requests than on small ones:
Some reviewers lose more than others:
| Reviewer | Small pull requests | Large pull requests | Change |
|---|---|---|---|
| Drape (Deep Review) | 98% | 81% | 17 points |
| Drape (Review) | 94% | 71% | 23 points |
| Claude Code (Opus 5.5) | 93% | 70% | 23 points |
| Cursor | 86% | 65% | 21 points |
| Cubic | 75% | 57% | 18 points |
| Mjolnir (Sonnet 5.5) | 82% | 54% | 28 points |
| Greptile | 85% | 43% | 42 points |
| Qodo | 81% | 32% | 49 points |
So the trend runs the wrong way. The pull requests get bigger, the reviewer catches less, and fewer people check its work.
Some bugs it barely sees
Some of the hardest bugs to catch are not in the diff at all. A change in one file breaks code in another file that the pull request does not touch. Here is one in an example storefront. A pull request speeds up order lookups with a cache, and drops a filter on the way:
src/storefront/checkout/orders.py
def get_order(account, order_id):
- return Order.objects.get(id=order_id, account=account)
+ return order_cache.get(order_id)
The diff looks like a harmless cache. But the refund endpoint relies on that filter, and it is not in the diff:
# src/storefront/api/refunds.py, not in the diff
@require_login
def create_refund(request, order_id):
order = orders.get_order(request.user.account, order_id)
return refunds.refund(order, request.POST["amount"])
After the change, any signed-in customer can refund someone else's order. A reviewer catches this
only if it reads the code that calls get_order, which is not in the diff. On crbench, reviewers
differ widely on bugs like this one:
Broken windows: one miss becomes a pattern
Say the reviewer misses it, and the pull request merges. The next agent that adds an endpoint looks
at the existing ones and calls get_order the same way, because that is how the codebase seems to
check who owns an order.
1. The reviewer misses one
1
The refund endpoint can now touch any order.
2. Agents copy it
123
New cancel and change-address endpoints trust the same helper.
3. One miss, four holes
1234
A resend-receipt endpoint trusts it too.
Each new endpoint is a small, reasonable-looking pull request, so each one is easy to approve. None
of them changes get_order, so a reviewer that only reads the diff sees nothing wrong with any of
them.
What to do about it
- Know your reviewer's numbers on the pull requests that matter. Overall scores hide the drop on large and cross-file changes. Check a public benchmark such as crbench, or replay your own past bugs through your reviewer and count what it finds.
- Keep pull requests small. Every reviewer on crbench catches more on small pull requests.
- Put people where your reviewer is weak. If it misses cross-file bugs, a person should read the changes that call shared helpers, such as permissions, money and data access.
How Drape does it
Drape leads crbench. Its Deep Review catches 89.4% of the bugs overall, 91.4% of the cross-file bugs, and 81% of the bugs on large pull requests, where the other reviewers average 56%. The leaderboard is public, and every bug on it is proven by running code.
Before your agents copy what your reviewer missed, find out what your reviewer misses.