Skip to main content

44 Reviews on One Pull Request: The Loop Nobody Owned

An agent reviewer and an agent fixer kept triggering each other on one PR. What was missing was a stop condition, and someone to own it.

Updated 4 min readMarkdown
Part of seriesLoops Nobody Owned
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 (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.

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:

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?

About the author

  • DevOps Engineer | Harness Engineering enthusiast

Deduplicating reviews per head doesn't stop that loop on its own, since every fix pushes a new head, so the count has to follow the change. In my rules a new commit doesn't reset the round count for the same change, or every fix would buy a fresh set of rounds. The cap is written down before round one. When the capped round still returns CHANGES REQUIRED, fixes stop and the merge stays blocked until someone decides what happens next. If you add the counter, what will it count, reviews per head or per pull request?

A hard cap on rounds would set a ceiling on something that has no definition of finished behind it. The reviewer's findings are mostly legitimate on the first pass and the acceptance criteria stay fixed across both rounds, so the second review verifies against a known standard instead of hunting fresh. If the criteria live in the PR description and the fixer is told not to touch them, then round two has something to check against, and anything outside it goes back to the queue as your last section says. Without that, the cap is a stopping rule on a process that still doesn't know what it's aiming at.

A definition of finished comes first in my rules, and the cap sits on top of it. Every change gets a brief before the code, the reviewer answers each line under "Done means" with met, not met or not checkable, and ACCEPT needs every line met. Fixed criteria still don't end the loop when writer and reviewer read one line two ways, because each round repeats the disagreement in a new commit. The cap is what stops that and sends one question to the person who owns the change. In your version, what ends round two when both agents hold the same criterion and read it differently?

Loops Nobody Owned

Part 1 of 1

Agent workflows that keep going because nobody gave them a stop condition.