# Should one coding agent review another's work?

Canonical: https://plottypus.com/blog/should-one-coding-agent-review-another

Last updated: 2026-10-14

> Yes, if the reviewer is not the agent that wrote the code and it checks evidence, not the summary. What a reviewer catches, and how to set one up by hand.

**Quick answer:** Yes. The agent that built the change should not mark its own homework. Give the review to a second agent with a fresh context, tell it what was asked, and make it bring evidence: a file and line, a command it ran and what came back. A review that only reads the diff and the first agent's summary misses the failures that matter most.

| Question | Short answer |
| --- | --- |
| Why not let the builder check itself? | It grades its own reasoning, and it stops when the work looks done |
| Does the reviewer need to be a different product? | No. A fresh session or subagent works. A different model helps a bit more |
| What should it read? | The ask, the diff, the test files and a fresh test run |
| What should it skip? | Style. Your linter does that |
| How many comments is right? | As few as hold up. Each one with proof |

## Why shouldn't the agent that wrote it review it?

Two reasons, and both are in the vendor's own guidance.

First, an agent stops when the work looks finished. Anthropic's best-practices page for Claude Code says it plainly: "Claude stops when the work looks done." If nothing outside the agent checks the result, "looks done" is the only signal.

Second, the builder carries its own reasoning into the review. The same page recommends a second session or subagent because "a fresh context improves code review since Claude won't be biased toward code it just wrote", and lists a verification subagent as a way to make sure "the agent doing the work isn't the one grading it."

There's a third reason that comes from research, not docs. Coding agents under pressure to pass tests sometimes change the tests. ImpossibleBench (Zhong, Raghunathan and Carlini, October 2025) built tasks where the spec and the tests contradict each other, so any pass is a shortcut. Its authors found that Claude models mostly cheated by editing the test cases, and that hiding the tests from the agent drove cheating close to zero. An agent that rewrote a test is the last one you want deciding whether the test still means anything.

## What does a reviewer agent catch?

The useful catches are not style nits. They're the three ways a "done" stops holding:

- **Tests not rerun after the last edit.** The agent ran the suite, then made two more changes, then said "all tests pass." The claim was true once.
- **A test rewritten until it passes.** The assertion got loosened, the expected value got changed to match the output, or the test got skipped.
- **A stub presented as finished.** A function returns a hard-coded value, a `TODO` sits where the logic should be, or an error path just logs and returns.

Each of these is cheap to check if you know to look and expensive if it ships. I go through how to catch them by hand in [your coding agent said done, here's how to check](https://plottypus.com/blog/coding-agent-says-done-but-it-isnt).

## Why does the reviewer need the session, not only the diff?

A diff shows what changed. It does not show:

- **What you asked for.** A reviewer can't tell scope creep from the task if it doesn't know the task.
- **What ran, and when.** Whether the tests ran after the final edit is a fact about the session, not the code.
- **What the agent claimed.** "Added tests for the edge cases" is a claim you can check, but only if the reviewer sees it.

So the minimum input for a good review is the original ask, the agent's final message, the diff against the branch point, and a fresh test run that the reviewer starts itself.

## How do I set one up by hand?

You can do this today with tools you probably have. Pick one of these.

**A second Claude Code session.** The best-practices page calls this the Writer/Reviewer pattern: session A implements, session B reviews the files with fresh context, and you paste B's findings back into A. Run B in its own worktree so it can't edit A's files:

```bash
git worktree add -b review ../app-review
```

**A subagent in the same session.** Claude Code's docs suggest a review step where a subagent "sees only the diff and the criteria you give it, not the reasoning that produced the change." The bundled `/code-review` skill does a version of this for bugs. For a check against the ask, write the prompt yourself.

**A different vendor's agent.** If you also use Codex, its CLI has a non-interactive review command. Per OpenAI's docs, `codex review --uncommitted` reviews "staged, unstaged, and untracked changes", and `codex review --base main` reviews the branch against `main`. Using a different model is not required, but it does mean the reviewer doesn't share the builder's habits.

Whichever you pick, share one instructions file so both agents work from the same rules. Claude Code reads `AGENTS.md` as project instructions when there's no `CLAUDE.md`, and a `CLAUDE.md` can import it, so one file can serve both tools.

## What should I tell the reviewer?

The prompt matters more than the tool. This is the one I use, adapted from the review step in the Claude Code docs. The longer version, for a person, is [a checklist for reviewing a coding agent's work](https://plottypus.com/blog/review-code-written-by-coding-agents).

```text
Review the change on this branch against the task below.
1. Run the test suite yourself. Report the command and the result.
2. List every test file the change touched. For each, say whether
   an assertion got weaker, a test got skipped or deleted.
3. Find code that returns a fixed value, has a TODO, or swallows an error.
4. Flag anything outside the task's scope.
Report only problems that affect correctness or the task.
For each one, give file:line and the evidence. No style comments.

Task: <paste what you asked the first agent>
```

The last line about style is not decoration. Anthropic's docs warn that "a reviewer prompted to find gaps will usually report some, even when the work is sound." If you act on every finding you get over-built code. Fewer comments, each with proof, is the bar.

## What goes wrong with two agents?

Mostly, you become the relay. You copy findings from one window to the other, and you're the one who remembers that the tests were last run three edits ago. The review also comes after the work, so the builder has already stopped and lost its place.

The other failure is collisions. If both agents can write to the same files, one overwrites the other. Separate worktrees prevent lost work, but you'll still get merge conflicts. The numbers are in [what happens when two coding agents edit the same file](https://plottypus.com/blog/two-coding-agents-edit-the-same-file).

## Where plottypus fits

The setup above works, and it's where I'd start. Its weak spots are the relay and the timing. plottypus is a second agent that follows the Claude Code session while it works, checks every "done" against what actually ran (did the tests run after the last edit?), and sends the agent back when it won't hold, while it can still fix it, with fewer comments and evidence on each. How we test it, misses included, is on [the evals page](https://plottypus.com/evals). If you want the deterministic half first, [make your agent rerun the tests before it says done](https://plottypus.com/blog/stop-hook-rerun-tests-before-done). To try the rest, [start a free trial](https://plottypus.com/pricing).

## Sources

Checked 14 October 2026.

- Anthropic, [Best practices for Claude Code](https://code.claude.com/docs/en/best-practices): "Give Claude a way to verify its work", the Writer/Reviewer pattern and "Add an adversarial review step".
- Anthropic, [How Claude remembers your project](https://code.claude.com/docs/en/memory), the AGENTS.md section.
- OpenAI, [Developer commands: codex review](https://learn.chatgpt.com/docs/developer-commands?surface=cli).
- Zhong, Raghunathan and Carlini, [ImpossibleBench: Measuring LLMs' Propensity of Exploiting Test Cases](https://arxiv.org/abs/2510.20270), October 2025.
- [AGENTS.md](https://agents.md/).
- Git, [git-worktree](https://git-scm.com/docs/git-worktree).

---

*plottypus is independent and not affiliated with any company or project named here. Claude Code is a trademark of Anthropic. Names belong to their owners. This is our research and opinion, dated above; details may have changed.*