A coding-agent review loop with human approval
A useful coding-agent review loop gives one agent ownership of the change, another a read-only review task, and a human the final approval. The reviewer needs the exact candidate revision and acceptance criteria, not just the writer’s summary. BAND (band.ai) for desktop can carry that handoff across listed agents in shared rooms while execution and Git integration remain separate.
Reviewed November 2026
Why separate the writer from the reviewer?
The writer is trying to produce a working change; the reviewer is trying to find reasons it should not be accepted yet. Giving those roles different tasks helps prevent a review from becoming another implementation conversation. This is an editorial workflow recommendation, not a claim that a second model guarantees better code or detects every defect.
Use the reviewer to challenge assumptions against the actual diff, tests and task brief. It should identify missing behavior, unsafe permissions, changed interfaces and cases the tests do not cover. A summary that the code looks reasonable is not an acceptance check. Ask for findings that a writer or human can reproduce and resolve.
What should each participant own?
| Participant | Input | Output | Must not do |
|---|---|---|---|
| Writer | Task, base revision, allowed scope | Candidate change and evidence | Treat its summary as approval |
| Reviewer | Exact candidate diff and acceptance checks | Concrete findings and unresolved risks | Edit the writer’s files without agreement |
| Human | Change, review, test results | Approve, reject or redirect | Assume agent agreement proves correctness |
| Coordination layer | Handoff and decisions | Visible task context | Replace repository permissions or tests |
Ownership should remain clear after a finding arrives. The reviewer reports, the writer revises and the human decides whether another review is needed. If both agents fix the same file at once, the loop becomes concurrent editing rather than review. A separate branch or checkout can help preserve the candidate while it is examined.
How do you define a candidate that can be reviewed?
Include the base revision and the exact candidate revision, or a stable diff with its branch. State the user-visible outcome and the relevant acceptance checks. List changed files, migrations, dependency updates and generated outputs. The reviewer should be able to distinguish the intended change from incidental edits without relying on the writer’s memory.
Provide test evidence with the command and result. If a test could not run, state why and what remains unverified. Do not replace an unrun integration test with a statement that the code compiles. The right check depends on the change: a parser needs real inputs, a permission rule needs denied and allowed cases, and a stateful workflow needs the resulting state read back.
What questions should the reviewer ask?
Ask whether the change satisfies the task and whether it breaks neighboring behavior. Check error paths, empty inputs, repeated requests and interrupted execution where they matter. Inspect authorization boundaries before cosmetic details. A reviewer can also look for tests that pass regardless of the result, overly broad mocks or assertions that only check a function was called.
Keep findings concrete. Name the file, behavior, triggering input and expected outcome. If the reviewer is uncertain, label the uncertainty rather than inventing a defect. Group issues by their impact on acceptance, not by how impressive the explanation sounds. A small reproducible problem is more useful than a long speculative critique.
How do you run a loop with Claude Code or Cursor?
Anthropic documents subagents and experimental agent teams as different ways to delegate work. A subagent can investigate a bounded review question and return to its parent; a team gives separate Claude Code sessions direct communication. Cursor documents subagents with separate context windows that return results to a parent across its supported agent surfaces.
Those features do not define the approval policy for your repository. Configure the reviewer as read-only where possible, and keep its prompt distinct from the writer’s implementation brief. If you use separate sessions, the human must provide the exact candidate revision and carry the findings back. Worktrees isolate changes but do not create the review loop by themselves.
What does a cross-vendor room add?
BAND lists Claude Code, Codex, Cursor and GitHub Copilot integrations. Agents built on different frameworks and running on different machines can join shared rooms with people. @mention routing, shared memories and an activity timeline make the handoff and resulting decision part of the room’s context rather than an untracked paste between terminals.
Use a clear message: the candidate revision, review scope, tests already run and decision needed. The reviewer should return findings to the owner and mention the human when a trade-off needs approval. Shared-room communication does not guarantee that the reviewer has the branch or credentials it needs; verify the execution setup separately.
When should a human stop the loop?
Stop when agents keep reopening the same issue without new evidence, when the task scope expands, or when a decision is about product policy rather than implementation. Repeating the loop is not a substitute for specifying the desired behavior. The human can approve a bounded trade-off, redirect the work or reject the candidate until an external requirement is clear.
For risky changes, define the human gate before work starts. Migrations, deletion, authentication and shared infrastructure should not depend on an agent inferring the intended approval boundary. Keep rollout and rollback considerations alongside test evidence. Neither a passing test suite nor a second agent’s agreement proves that a deployment decision is safe.
What should the final approval record contain?
Record the accepted revision, resolved findings, remaining risks and the human decision. Run the relevant checks against the final candidate, not an earlier version that the writer changed after review. If changes were combined from several branches, verify the combined state. Approval should identify what was checked and what was deliberately left outside the scope.
The handoff guide, Claude Code and Codex guide and BAND review cover the communication choices. The methodology explains why this site weights handoffs separately from parallel execution. Begin with one review loop you can follow end to end before adding more reviewers.
What else do readers ask?
Does a second agent replace human review?
No. The human owns acceptance, risk decisions and the final approval.
Should the reviewer edit the writer’s files?
Not during a read-only review. Return findings to the owner unless ownership is explicitly transferred.
What revision should be reviewed?
The exact candidate revision or stable diff, with its base revision and acceptance criteria.
Can different vendors perform the two roles?
Yes as a workflow choice. BAND lists Claude Code, Codex, Cursor and Copilot integrations for shared-room handoffs.
Does passing tests close every finding?
No. Tests address particular behavior; unresolved permissions, rollout or product decisions still need human judgment.