Your team has used AI for about a year now, and output went up. More people open pull requests than ever. But every change still lands on the same engineer's desk before it can ship, and on some teams it's two engineers.

You probably know the names. They review most of the pull requests, they get pulled into every design call, and when production breaks at 4:40 on a Friday, they're the ones who open the logs. AI was supposed to spread that work out, but for them it mostly stacked more of it on.

Most of what your best engineer writes in a review is a rule nobody wrote down. Once you sort those comments into two piles, only one of the piles actually needs your best engineer.

More Code, Same Reviewers

A year ago your team had five people who could ship a feature, and now nearly everyone can. Product managers open pull requests, and junior developers finish tickets in an afternoon that used to take them a week.

But the number of people who can tell whether that code belongs in your system didn't change. It's still the same two seniors. So the pull request queue grew, the review comments grew with it, and the seniors spent less time on the work only they can do, because they were busy writing the same comment again.

I've been on that side of it for a good part of my 29 years in software, including as CTO at multiple companies, and I've been the name on the review queue since before anyone called it a pull request. You end up losing your best architect to a job that is mostly proofreading. Fortunately, you don't have to skip review to fix that. You just have to look at what the senior writes in those reviews and sort it.

One Pull Request, Four Comments

Here's a pull request, and every comment on it is one I've written myself, more than once.

A mid-level developer used an AI tool to add an endpoint that lets a customer approve an invoice. It's a clean diff, about 300 lines, and the tests pass. The senior opens it and leaves four comments.

Comment 1. "This endpoint returns a raw string on failure. Use OperationResult like every other endpoint in the API."

Comment 2. "The service catches the exception, logs it, and returns null. The caller cannot tell it failed. Let it fail or return a failure result."

Comment 3. "No integration test on the new endpoint. Every endpoint gets one."

Comment 4. "This puts the approval rule inside the payment service. Approval and payment change for different reasons, and finance already asked for approvals that do not trigger a payment. Split them now, while it is 300 lines and not 3,000."

Read those four again, because three of them have something in common and one of them doesn't.

Two Piles

Comments 1, 2, and 3 are Repeat Review. A Repeat Review comment is one your best engineer has left before, on a different pull request, for the same reason. The senior didn't need to be senior to write it. They just needed to remember the rule. If you search that repo's review history for "OperationResult" or "integration test," chances are you'll find the same comment with different dates on it.

Comment 4 is Judgment Review. It depends on things the senior knows that no file holds yet: what finance asked for last month, how the payment service grew, and what it cost the last time two concerns shared one class. Nobody else on the team could have written that comment, and the AI that wrote the code couldn't have either, because it has never heard of finance.

Comment 4 is what you pay the senior for, and comments 1 through 3 are why they stay late. On that one pull request, three of the four comments went to rules the team had already agreed on.

Want to see that count for your own repo? One prompt reads 30 days of pull requests and hands you a short report with links to the evidence.

Move the Repeat Pile Out of the Comment Box

A Repeat Review comment is a rule that never got written down where it counts. The team knows the rule, and so does the senior. But the AI tool that wrote the code doesn't, because the rule lives in the senior's head and in a pile of closed pull requests. So the AI guesses, it guesses wrong the same way it did last time, and the senior types the fix into a comment again.

That rule needs to live in two places.

Write the rule where the AI reads it

Your AI tool loads instructions from a file in the repo, so put the three rules there as three lines: endpoints return OperationResult, services don't swallow exceptions, and every endpoint gets an integration test. The next pull request from that same developer, using that same tool, shouldn't need comments 1, 2, and 3, because the tool finally knows the rules.

I see this every day building DevNitro, where I'm the reviewer and the AI is the author. Early on I accepted its first try about a third of the time. Then I wrote three sentences in the file the agent reads first, and first-try acceptance went to most of the time.

Back the rule with a check that runs

A written rule still depends on the AI reading it, and on someone noticing when it didn't. So put a check behind each rule. An analyzer can catch the raw string return, and a test that walks every controller can catch a missing integration test. Then the build fails, nobody has to type a word, and the senior doesn't see the pull request until it passes. This post won't get into which analyzer or test framework to use, because that depends on your stack.

Some folks think an AI reviewer can take the senior's place here, and AI review does help. But a review only covers what you show it, whether a person or an AI does the reviewing. In September of last year I had Copilot review a pull request on my framework, and its comments looked fine, so I merged it. Then I pulled main and built it, and the NuGet packages came out versioned -main-date-time instead of 1.0.1. The version script that caused it was outside the diff. Copilot answered the question I asked, but I still needed the build to answer the rest.

Once the repeat pile is out, look at what's left in the queue. It's comment 4, the judgment call, which is the work your senior is there for. Review didn't go away. It got smaller and it got harder, and that's what senior review should be.

The Repeat Review Test

Here's the test, and you can run it on your next review without asking anyone. Before you post a comment, ask one question:

Have I written this before, on a different pull request, for the same reason?

If the answer is no, post it. That's your judgment, and the team needs it.

If the answer is yes, don't post it as a comment. Post it as a rule instead. Put the line in the file your AI tool reads, open a ticket for the check that will enforce it, and then post the comment one last time with a link to the rule.

Do that one comment at a time, and the repeat pile drains. A few months in, your best engineer reviews fewer pull requests, and the ones that reach them actually need them.

Find the Repeat Work in Your Repo

You can do this from memory, or you can let your AI tool read the review history and do the counting.

I wrote a prompt for that. Run it against one repo, and it reads the last 30 days of pull requests and review threads, looking for three things: work waiting on review, the same correction made in separate changes, and fixes for defects an earlier change caused. You get a short report with up to three findings, a link to the evidence behind each one, what each one may mean (with the other explanation that would change your mind), and one next step or one question for your team this week.

It also tells you what it could and couldn't check. When the records don't support a finding, it says it found no strong signal and stops. It doesn't rank developers, it doesn't make up hours saved, and there's no sales pitch at the end. The form is at the bottom of this post.

Where This Fits in Intelligent Engineering

Intelligent Engineering is the operating model for engineering organizations in the AI era. It is what comes after vibe coding.

Repeat Review is the smallest version of it: one rule, written once, read by every tool and every session, and held by a check that runs. Your best engineer stops being the check and goes back to being the judgment.

All That to Simply Say This

When every change waits on one person, it's easy to think that person is the problem, so you hire another senior or split the queue. But most of what that person does all day is Repeat Review. The rules already exist. Nobody wrote them where the AI and the build could read them, so a human reads them out loud, one pull request at a time.

You've seen the four comments, the two piles, and the two places a rule has to live. Write the rules down, add the checks, and give your best engineer back the work only they can do.

If you want the prompt that finds where reviews and rework hold up your team, the form is below. And if you run it and the report raises more questions than it answers, that's worth a conversation. The Intelligent Engineering Assessment is free, and it's two calls. The first is a diagnosis of how your team builds today and where the review load is piling up. The second is a prescription: the best path forward I can see, and whether I have a role in it. Sometimes I don't, and I'll tell you so.


Chad Carter is the creator of DevNitro, the Intelligent Engineering platform. He's spent 29 years building software, served as CTO at multiple companies, and was a Microsoft MVP from 2009-2019.