Whole-branch review without re-trusting the branch's own self-assessment

Dispatch reviewers that never saw the build session, since a session that built something is the worst judge of it.

Also usessuperpowersclaude-plugins-official

The failure mode is structural, not moral: a session that built something is the worst available judge of it, because it reviews the intent it remembers rather than the diff it produced. Every skill here is chosen for its blindness properties.

Start here

One prompt to start

Review this whole branch without letting the session that built it grade its own work -- dispatch a fresh reviewer with the base and head SHAs who never saw the build session, run the diff-shaped toolkit reviewers in parallel for correctness, silent failures, and test coverage, check for contract drift, and if two verdicts disagree, run the tribunal to decide it per criterion rather than deferring to whichever session sounds more confident.

Needssuperpowers, pr-review-toolkit, confab, andon

Beats

Run these in order. Each prompt is copy-pasteable straight into Claude Code.

superpowers:requesting-code-review
Dispatches a `general-purpose` subagent filling `code-reviewer.md` with BASE_SHA / HEAD_SHA — a reviewer that never saw the build session.
Run this beat on its own
prompt
```
request a code review of this branch against main — a fresh reviewer, not you, and give it the base and head SHAs
```
pr-review-toolkit:code-reviewer
All six toolkit agents (including silent-failure-hunter and pr-test-analyzer) are diff-shaped and none fetches a PR itself; the caller passes scope, so they parallelize cleanly.
Run this beat on its own
prompt
```
review this diff four ways in parallel — general correctness, silent failures, test coverage, type design. Most capable model for the whole-branch pass.
```
pr-review-toolkit:silent-failure-hunteralso in 2 other recipes
- Investigate a job that reports success but changed nothing
- Fix misleading error or diagnostic output
All six toolkit agents are diff-shaped and none fetches a PR itself; the caller passes scope, so they parallelize cleanly.
pr-review-toolkit:pr-test-analyzeralso in 1 other recipe
- Investigate tests that pass while the code is broken
All six toolkit agents are diff-shaped and none fetches a PR itself; the caller passes scope, so they parallelize cleanly.
confab:confab-contract-driftalso in 3 other recipes
Drops into a review gate with zero setup, and catches what a prose review reads past.
andon:andon-verifyalso in 13 other recipes
Its tribunal is explicitly "never authored or influenced by the session that proposed or built the fix under review."
Run this beat on its own
prompt
```
two reviewers disagree about whether this actually satisfies the requirement. Run the tribunal and decide it per criterion.
```

Worked example

Grounded in — why this beat order is trustworthy

a branch touching all five plugin-local copies of `build_symbol_index.py` plus `tools/symbol-indexer/` — a diff whose risk is entirely in what it left out, which is precisely what a self-assessment cannot see.

Do / Don't

Dispatch a fresh reviewer with the base and head SHAs -- one that never saw the build session that produced the diff.
Run the diff-shaped toolkit reviewers in parallel -- none of them fetches a PR itself, so the caller's scope lets them parallelize cleanly.
Check for contract drift as a zero-setup addition to the review gate.
Run the tribunal when two reviewers disagree, and decide it per criterion rather than by whichever session sounds more confident.

Don't let the session that built something judge its own work -- it reviews the intent it remembers, not the diff it actually produced.
Don't trust a self-assessment to catch what a branch left out -- that's exactly what self-assessment structurally can't see.
Don't resolve a disagreement between reviewers by picking one over the other without running the tribunal to decide it per criterion.