# 44 Reviews on One Pull Request: The Loop Nobody Owned

How does one pull request end up with 44 reviews?

I work through a ticket queue with Claude Code. One ticket comes in, gets done, goes out, next ticket. The nice thing about a queue is that it has an end. Each item leaves.

A loop doesn't have that property unless someone gives it one, and [openai/codex #42130](https://github.com/openai/codex/issues/42130) (opened September 1, 2026, still open as of mid-November) is a good example of what happens when nobody does. The reporter describes the chain like this:

`review finding → task fixes and pushes → "New commits" review → another finding → repeat`

One agent reviews every new commit on the PR. A separate agent task is told to fix the findings, push, and monitor "until clean". Each part does exactly what it was asked. On one public PR in the reporter's own repo, they counted "44 Codex reviews and 66 review threads; the latest review was again triggered by New commits."

Before anyone screenshots that number, the reporter's caveat matters: "Not every commit or finding was caused by Codex, and some reviews were manually requested." So 44 is the total on a PR where this loop was one of several things going on, rather than 44 rounds of agents arguing with themselves. Their actual claim is narrower and more useful: "The bug is the missing stop condition when these two Codex features are used together." They even list a handful of related issues and explain why each one is different, which I appreciated.

![](https://cdn.hashnode.com/uploads/covers/6a29392edd76b58e2e8790b6/1bfb4c9b-c973-418b-ba4b-2452cdf147b0.png align="center")

## Every fix was probably fine

What bugs me about this one is that each review may well have found something real. Each fix may have been correct. You can't point at a single step and call it the mistake.

It's like a renovation. You call someone to fix a dripping tap, and while they're under the sink they notice the pipe is old, and replacing the pipe means opening the wall, and the wall has a damp patch, and so on. Every finding is legit. Three weeks later you have a different kitchen and nobody ever decided you wanted one.

With agents the bill shows up in a few places. Each fix is a new commit and each new commit is new surface for the next review, so the PR grows. Sixty-six review threads is not a history anyone will read, so when the PR finally merges, the reasons for each change are technically there and practically gone. And "until clean" ends when the reviewer runs out of comments, which isn't the same moment as someone agreeing the change is right.

The reporter's expected behavior reads like a policy you could adopt today, with any vendor or your own scripts:

"After one repair round and one verification review, Codex should pause if findings remain and require owner approval before continuing. It should deduplicate reviews for the same head and warn when repeated rounds materially increase PR scope or usage."

So: a round limit, and a named person who has to say "keep going". The warning about size would be a nice extra.

## What I'd do while waiting for a fix

If the fixer's push triggers the reviewer automatically, you've built a loop, whatever the vendor calls it. At least one link in that chain should need a human or a counter. I'd also write the acceptance criteria into the PR description before the loop starts, so that "clean" means "meets these", and findings outside them go to a new ticket instead of a new commit on this PR. (Back to the queue. New work goes to the back of the line.) And before merging I'd put the final diff next to the first reviewed one. If the PR doubled in size along the way, somebody reads it again from the top, not just the last round.

Counting is cheap, so count:

```bash
gh api repos/OWNER/REPO/pulls/123/reviews --paginate --jq 'length'
```

That counts every review, human ones included, so it's crude. A big number is just where you start reading.

This is one open report about one combination of two features in one product, and I haven't reproduced it. Humans loop on PRs too. The difference is that humans get tired and somebody eventually says "ok, are we done?" Automated steps never get tired.

What's the most review rounds an agent PR in your repo has been through, and who could have called it earlier?
