The Writer/Reviewer Pattern: Why One Claude Session Can't Check Its Own Work

TL;DR: A Claude session that implements and then self-reviews has a bias problem — it saw the reasoning that produced the code. A fresh Reviewer session or adversarial subagent doesn't.

A Claude Code session that builds something and then reviews it is primed to rationalize what it just built. It knows why each decision was made and unconsciously defends it. A reviewer running in a separate context with zero knowledge of the implementation history evaluates the result on its own terms.

The Writer/Reviewer split (two sessions)

Run Session A to implement and Session B to review — they can run in parallel in separate worktrees:

# Session A (Writer)
Implement a rate limiter for our API endpoints — write tests and get them passing.

# Session B (Reviewer) — after Session A finishes
Review the rate limiter in @src/middleware/rateLimiter.ts.
Look for edge cases, race conditions, and consistency with our existing middleware patterns.
Report gaps — not style preferences.

Session B never read the implementation context, has no sunk-cost attachment to the approach, and will flag things Session A reasoned away. Feed Session A the findings: "here's the review. Address these issues."

The adversarial subagent (for autonomous runs)

For longer unattended sessions, delegate review to a subagent — it gets its own fresh context window inside the same session:

Use a subagent to review the rate limiter diff against PLAN.md.
Check that every requirement is implemented, listed edge cases have tests,
and nothing outside the task scope changed.
Report gaps only — not style preferences.

The subagent reports findings directly back to the implementing session, which can fix and re-review without you copying between windows.

One calibration: A reviewer told to find gaps will always find some, even when the work is sound. Prompt it to flag only gaps that affect correctness or stated requirements — not hypothetical future scenarios. Over-chasing findings produces defensive abstraction layers for cases that can't happen.

Quick version: /code-review. The built-in skill launches a subagent in a fresh context, reviews the current diff, and surfaces findings in your session — the adversarial step with zero setup.

Sources: Claude Code best practices, Sub-agents — Claude Code Docs