DEV Community

Parsa
Parsa

Posted on Originally published at youtube.com AI-assisted

Senior engineers aren't slow at code review. They're outnumbered.

Agents multiplied pull requests and review hours stayed flat. Another AI reviewer reads the same diff, and the failure that pages you usually sits outside it.

Every team with coding agents ends up with the same chart. Pull requests per week goes up and to the right. The hours senior engineers have for reading them is a flat line. The gap between those two lines is where review quality goes.

Nobody on the team got slower. There are just more PRs than careful reads, and the person who clicks merge still owns what breaks at 2am.

The usual fix reads the same diff

The first instinct is to add an AI reviewer, and they're good at what they do. They catch the missing null check, the unused variable, the function that should have been split. But a second AI reviewer reads exactly the same lines the first one did, so you get more comments on what was already visible, and the PR looks more checked than it is.

The failures that page people mostly aren't in those lines.

Where the incident actually lives

A few shapes that come up again and again:

A caller expecting the old response shape. An agent renames a field or changes a return type. The diff is clean and the tests for that function pass. A service in another repo, or a file the PR never opened, still reads the old field and starts failing in production.

A queue consumer with different assumptions. A producer starts sending a new event type, or sends the same event twice on retry. The consumer was written for the old behaviour. Nothing in the producer's PR shows the consumer at all.

A shared database. A migration adds an index or tightens a constraint on a table three services use. It runs in a second on the dev database and locks writes on the busy production one.

All three read fine as diffs. You only see the problem once you look at what the change touches around it.

Change what the bar is based on

Lowering the bar for merging isn't an option, since the person merging still owns the result. What can change is what the decision is based on.

Instead of giving every PR the same read, judge each one against the system around it first. What depends on the code it changed? Does it touch shared infrastructure? Has this area caused problems before? Then spend the slow, careful review on the PRs where that says it's needed, and let the rest go through the normal path.

You can start this by hand. CODEOWNERS on the files that change most and break most, and a short checklist for PRs that touch shared clients, queues or migrations, gets you part of the way.

Where Tomosu fits

That routing step is what Tomosu does. It checks what a pull request needs to hold up in production, using context beyond the diff, like dependencies and infrastructure, plus runtime signals where they're connected. It scores the change with a Production Reliability Index (PRI) and gives a Ready or Not Ready verdict before merge.

The verdict isn't there to push the PR back to its author. It's there to show what the change needs before it goes to production, so the reviewer knows where to look and the fix happens before the merge rather than after the page.

It runs alongside the review tools you already have. Line-level review still catches line-level mistakes, and Tomosu covers what the change does to everything else.

Don't lower the bar for merging. Change what it's based on.


You can run a free scan on a repo at tomosu.ai/start. Repos under 50 files scan in the browser, and larger ones go through the free IDE plugins.

Top comments (0)