Every agent needs a reviewer

Agents are confident. They finish a task, run the tests and tell you it’s done. Most of the time it is. The problem is the rest of the time, because it sounds exactly the same.

So my setup has one rule: the agent that writes the code never gets the last word on it. Every pull request gets a second agent with a fresh context. It reads the requirements, the full diff and the evidence, and nothing else. It doesn’t know how hard the work was or what the first agent meant to do. It only sees what is there.

A real one

In Moss, the room moves with your phone. Tilt it, and a foreground layer slides a few points in front of Pip, like a shoebox diorama. The agent built it, all 39 tests passed, and the pull request came with screenshots and measurements.

The reviewer came back with eight findings. Four of them were should-fix:

• The motion sensor kept running at 30 Hz behind sheets. The scene was paused. The sensor wasn’t.
• Nothing stopped the motion manager when the stage went away, and every stage made its own.
• The Low Power Mode state could go stale while the app was suspended.
• The tilt came from pitch and roll angles, which are unstable when you hold the phone upright.

None of that shows up in a test run. The simulator has no motion sensor. You would only notice it as battery drain, or as a diorama that twitches when you hold your phone like a normal person.

Six findings were fixed, one was accepted as it is, and one got a stronger test. The tilt direction still needs a check on a real device, and the pull request says so.

Why a fresh context works

It isn’t that the reviewer is smarter. For ordinary reviews my setup uses a cheaper model than the one that writes the code. It works because the reviewer has less context, not more. The writer has spent an hour convincing itself the approach is right. The reviewer hasn’t.

That is also why the agent that planned or coordinated the work doesn’t count as the reviewer. Having been there earlier is the opposite of independent.

And when there is no reviewer, the pull request stays a draft and says review is pending. Nothing looks finished when it isn’t.

What the reviewer missed

Here is the honest part. That same parallax change was reviewed, green and merged, and it never reached main. It was stacked on another branch, that branch had already landed, so the merge went somewhere nobody was looking. A second pull request had to carry it over.

It happened on this site too. Two pull requests merged into stack branches, and a third one had to ship them.

The reviewer read the diff. Nobody read where it was going. A reviewer only checks what is in front of it, so the target branch has to be in front of it too. That is the next thing on my list.

Some things a script should catch, not a reviewer. In ambessapower a release guard caught a plugin version I’d forgotten to bump. That is a job for a check that runs every time, not for judgement.

The setup

• One agent writes. It owns the scope and the tests.
• A second agent reviews, read-only, with the requirements, the diff and the evidence.
• Every finding goes into the pull request with an outcome: fixed, accepted or still open.
• Scripts check what scripts can check: tests, versions, formatting.
• No reviewer, no ready pull request.

It costs one more agent per pull request. I would rather pay that than find the motion sensor in a battery report. The setup is part of ambessapower, the agent loop behind everything I build.