Skip to main content
skill CX Codex

review-loop · sangrokjung — Claude Code skill: what it does, how to install

review-loop runs an adversarial verification loop where a fresh, isolated checker inspects behavioral changes until reaching a strict APPROVE verdict.

MIT ★ 880 updated 2026-09-03

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add sangrokjung/claude-forge --skill review-loop -a claude-code
Open on GitHub

What review-loop does

The skill enforces a maker-checker workflow for any change altering system behavior, including application code, SQL, shell scripts, CI/CD, and runtime prompts. The author cannot grade their own work. After finishing an implementation, the author must run targeted tests, record the command outputs, and hand the diff over to an isolated reviewer agent spawned with a clean context.

The review workflow yields three outcomes: APPROVE, REQUEST_CHANGES, or UNVERIFIED. When changes are requested, the implementer addresses the specific findings and invokes another fresh reviewer. High-risk areas such as auth, access controls, secrets, and irreversible database changes require two distinct reviewer lanes focusing on correctness and domain-specific risks.

If the same defect triggers REQUEST_CHANGES twice consecutively, the loop must escalate to a human developer because repeated failed fixes indicate a flawed underlying diagnosis.

What it helps with

  • enforce an adversarial review loop with a fresh agent context
  • verify sensitive authentication and payment diffs across two review lanes
  • prevent false completion reports before fresh test evidence is collected
  • inspect bug fixes for regression flaws introduced during review

Example prompts for the agent

  • Run the review loop on my latest changes before committing
  • Perform an adversarial review on this branch using a separate checker
  • Put a second pair of eyes on this auth change with maker checker verification

How to install review-loop

1Skills CLI (Vercel)

npx skills add sangrokjung/claude-forge --skill review-loop -a claude-code

2Manually: put the files in place

~/.claude/skills/review-loop/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/review-loop/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about review-loop

How to install review-loop in Claude Code?

Run npx skills add sangrokjung/claude-forge --skill review-loop -a claude-code in your terminal.

What edits are exempt from the review loop?

Prose documentation, typo fixes, marketing copy, and pure formatting changes that do not alter runtime behavior bypass this loop.

Why is a reviewer forbidden from fixing the code directly?

If a checker touches the codebase, it becomes a maker, immediately voiding its independent review verdict.

Source text

SKILL.md · MIT
---
name: review-loop
description: Run the adversarial verification loop — implement, then hand the change to a fresh checker that did not write it, fix what it finds, and re-dispatch until APPROVE. Use before claiming any behavioural change is done, and on requests like "review loop", "adversarial review", "independent review", "get this verified", "is this actually done", "maker checker", "second pair of eyes on this change". Not for prose, docs or typo edits.
---

# review-loop — the independent adversarial loop

> Nobody grades their own exam. The maker implements, a separate fresh checker tries to break the
> claim, and the two alternate until the checker approves the code as it stands right now.

## When this applies

Any change to behaviour: executable code, shell/Python/JS/TS/SQL, CI/CD, hooks, commands, agent
and skill definitions, runtime prompts, and configuration that changes what the system does.

Exempt: prose documentation, marketing copy, typos, and formatting that cannot change behaviour.
When a documentation-only change also touches something a runtime reads, it is behavioural. If you
are unsure which side a change falls on, treat it as behavioural.

File count and diff size are not exemptions. A one-line change to an authorization check is
behavioural; a 900-line documentation reflow is not.

| Risk | Lanes required |
|---|---|
| Ordinary behavioural change | 1 independent checker |
| Auth, authorization, payments, access-control rules, secrets, destructive data changes, irreversible deploys | 2 lanes, run by different checkers: correctness plus the risk-specific angle (runtime security, or rollback) |

## The loop

```text
maker implements → targeted test / real-surface QA → fresh checker
     ↑                                                    │
     └────────── REQUEST_CHANGES ← findings ──────────────┘
                                                          │
                                          APPROVE on current code → done
```

There are exactly three verdicts: `APPROVE`, `REQUEST_CHANGES`, `UNVERIFIED`.

- **APPROVE** is a completion candidate only when it was issued against the revision that is
  checked out now, with evidence produced from that same revision.
- **REQUEST_CHANGES** means the maker fixes the findings surgically, re-runs the tests, and calls
  a fresh checker again. Fixing more than the findings restarts the argument.
- **UNVERIFIED** means no judgement was reached: the checker never ran, returned empty, timed out,
  errored, was rate-limited, returned a malformed envelope, or reviewed a state that has since
  moved. It is not a pass. Retry with a different checker, runtime, or strategy.

If a checker modifies the source, it has joined the maker set and its verdict is void. A past maker
can never be that change's checker.

## Running it

1. **Implement.** Keep the change inside the scope you declared. Unrelated cleanup that arrives in
   the same diff will be reviewed as part of it.

2. **Produce evidence before dispatch.** Run the targeted tests and, when the change has a surface a
   person uses, exercise that surface the way they would. Record the exact commands and their exit
   status. Evidence from before your last edit is stale.

3. **Dispatch a fresh checker.** Use the Task/Agent tool to spawn `adversarial-reviewer` in its own
   context, or a general-purpose agent given that agent's contract. Hand it:
   - the goal and acceptance criteria in one paragraph,
   - the scope (paths, or the diff range),
   - the commands you ran and what they returned,
   - the revision under review (`git rev-parse HEAD`).

   Do not hand it your conclusion. "I verified this works" is the claim under test, not context.

4. **Read the verdict, not the tone.** A checker that praises the change but lists a HIGH finding
   has returned REQUEST_CHANGES. A checker that died mid-run has returned UNVERIFIED, however
   encouraging its last message was.

5. **Fix and re-dispatch.** Every round gets a checker with a fresh context. Reusing the previous
   checker means asking someone to re-read their own conclusion.

6. **Stop when a current APPROVE exists** for the code as it stands, backed by evidence from that
   same revision.

## Re-verification etiquette

When you come back for round N+1, say so plainly:

- state what changed since the last round, in one or two lines, and name the finding each edit
  addresses;
- ask the checker to re-reproduce the original defect, not to take your word that it is gone;
- explicitly invite it to attack the fix itself. Fixes introduce their own defects, and a fix
  written under review pressure is exactly where a second one hides.

Both of the defects worked through in `docs/VERIFICATION-LOOP.md` were found this way: the first
review broke the guard, and the review of the *fix* broke the fix.

## When rounds stop converging

Three rounds on the same strategy is not a reason to stop, and it is not a reason to keep going
unchanged. Switch strategy: a different reproduction, a narrower test, a different checker or
runtime, or a re-plan of the approach. See `references/convergence-detection.md`.

Escalate to the human when the same finding comes back REQUEST_CHANGES twice in a row: two failed
attempts at one defect means the diagnosis is wrong, and a third attempt usually makes it worse.
Report the finding, both attempted fixes, and the reproduction. See `rules/adversarial-review.md`.

## Never report success when

- the reviewed revision is not the revision that is checked out now;
- there is no successful evidence from after the last edit;
- the checker was the maker, or a fork of the maker's context;
- a required lane is missing;
- the checker modified code, returned an empty or malformed verdict, or timed out;
- you are reusing an APPROVE from a different change or a different session.

In every one of those cases the honest report is what is missing, not "done".

© sangrokjung · MIT · sangrokjung/claude-forge

Similar skills

All skills for Code review and refactoring →

review-loop by other authors comes first.

review-loop 2dmurali review-loop — a skill that runs a worker-reviewer loop: a separate critic subagent scores the work 1-10 and hands back notes, and the agent revises until the gate is met. CX Codex +1 114,900installs verification-loop affaan-m The verification-loop skill checks a code change through build, types, lint, tests, security searches, and diff review. Run it after a feature or refactor, or before a PR. CX Codex +1 7,200installs adversarial-review syahiidkamil adversarial-review subjects fresh builds to hostile inspection using isolated reviewer contexts and mandates empirical reproduction on the running system. CX Codex +1 ★ 406repo stars codebase-review-swarm ZaxbyHub codebase-review-swarm executes quote-grounded codebase audits across security, QA, and performance. Suitable for full-repository assessments where no source files may be touched. CX Codex +1 ★ 539repo stars build-loop-claude-code BuilderOS build-loop-claude-code runs every task through build, review, end-to-end test and fix. It keeps going until the plan's checkboxes are all ticked. CX Codex +1 1,700installs ai-qa-review kindlmann ai-qa-review reviews existing test code for smells and checks how testable your application code is. Useful before merging a PR or when a green suite still lets bugs through. CX Codex +1 1,500installs test-evidence-review Donchitos test-evidence-review — a skill for Claude Code, Codex, Cursor and other platforms that goes past test existence and checks assertion coverage. It assigns ADEQUATE, INCOMPLETE, MISSING or NOT ASSESSED to each story. CX Codex +1 632installs

From the same set44

The whole set →
systematic-debugger systematic-debugger turns a reproducible bug into a bounded search: failing test, bisect, falsifiable hypotheses, verified fix. Built for the case where the cause is still a mystery. CX Codex ★ 880repo stars humanize-korean The humanize-korean skill edits awkward, translation-shaped Korean and formulaic AI phrasing while leaving facts, numbers, names, and quotations intact. It works in one pass. CX Codex +1 ★ 880repo stars workflow-classify The workflow-classify command grades a task from S to XL and recommends a workflow. Run it before implementation to get a plan matched to the change’s scope and risk. CX Codex +1 ★ 880repo stars build-error-resolver build-error-resolver turns a failing build green with the smallest possible diff: type errors, compile failures, imports, dependencies. Refactoring and architecture work are ruled out. CX Codex ★ 880repo stars adversarial-review The adversarial-review rule requires an independent check for behavioural changes and defines three outcomes. It helps teams avoid treating a failed review as approval. CX Codex +1 ★ 880repo stars relay relay builds a one-line /compact command and a handoff document with the next task so work survives a context reset. CX Codex +1 ★ 880repo stars adversarial-reviewer The adversarial-reviewer subagent for Claude Code checks behavioural changes before a task is marked complete, reproducing issues and returning a verdict without modifying repository files. CX Codex ★ 880repo stars rca-debugger rca-debugger investigates complex failures when ordinary debugging has stalled, including flaky bugs and differences between CI and local runs. CX Codex ★ 880repo stars

Project sponsors

Companies that keep this analytics open