← All posts

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, 2026

Merges with no review at all

76.3%

The rise in pull requests merged without any review.

Faros, 2026

As AI output increases, review capacity is not growing at the same rate.

Faros, The AI Speed Trap · Source

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:

Bugs caught by all eight reviewers, by pull request size

Small, up to 100 lines87%
Medium, 101 to 500 lines72%
Large, over 500 lines59%

Each bar is the share of known bugs caught. A critical bug counts more than a minor one.

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:

Cross-file bugs caught

Drape (Deep Review)91.4%
Drape (Review)82.4%
Claude Code (Opus 5.5)77.6%
Cursor74.1%
Mjolnir (Sonnet 5.5)71.8%
Qodo66.3%
Greptile63.5%
Cubic52.9%

A cross-file bug is a change that breaks code in a file the pull request does not touch.

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.

Catch the bug before it merges.

14-day free trial. No credit card required.