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
npx skills add sangrokjung/claude-forge --skill review-loop -a claude-codeWhat 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-code2Manually: put the files in place
~/.claude/skills/review-loop/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/review-loop/
1Skills CLI (Vercel)
npx skills add sangrokjung/claude-forge --skill review-loop -a codex2Manually: put the files in place
.agents/skills/review-loop/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add sangrokjung/claude-forge --skill review-loop -a cursor2Manually: put the files in place
.cursor/skills/review-loop/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install sangrokjung/claude-forge skills/review-loop2Manually: put the files in place
.github/skills/review-loop/SKILL.md1Skills CLI (Vercel)
npx skills add sangrokjung/claude-forge --skill review-loop -a gemini-cli2Platform CLI
gemini skills install https://github.com/sangrokjung/claude-forge --path skills/review-loopManually: put the files in place
.devin/skills/review-loop/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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.