Self-review
Claude wrote the code, and the same session is asked to check it. It says the code looks right, and subtle bugs ship. The tempting answers make the same reviewer try harder: re-read carefully, turn on extended thinking, add stricter criteria. The exam's answer changes who reviews, and for a big change, how the review is split.
D4 Prompt Engineering & Structured OutputD3 Claude CodeExam guide 4.6 and 3.6About 15 minutes
Start here: proofreading your own essay
Think about checking a piece of writing.
Claude works the same way. A session is one running conversation, with everything said and reasoned in it. The session that wrote the code still holds the reasoning behind every choice, so when it reviews, it checks the code against that reasoning and agrees with itself. Extended thinking (giving Claude more room to reason before answering) doesn't help here: more thinking in the same session carries the same assumptions. An independent review instance is a fresh Claude call, for example a separate claude -p run, that gets the code or the diff but none of the writing session's history. A multi-pass review splits a big change: one pass per file for local problems, then an integration pass across files for problems no single file shows.
The diagram follows the simulator: the reviewer you pick is outlined in bold.
- Yes: run the review in an independent instance that sees the code or diff but none of the writing session's turns. More effort from the same session (re-reading, extended thinking,
/compact) keeps the blind spot. - The reviewer is already independent, but the change is large (thin in the middle, contradictory comments): split it into per-file passes plus a cross-file integration pass.
- Per-file passes already run, but bugs between files slip through (a renamed key, a changed signature): add the cross-file pass.
- The reviewer lacks the team's standards: that is a different problem; review criteria go in CLAUDE.md.
Words in the question that tell you which side you're on
Independent instance
- “the same session”, “reviews its own changes”
- “says the code looks right”, “approves nearly every patch”
- “one call writes the tests, then reviews them”
- “extended thinking didn't help”
Multi-pass review
- “dozens of files”, “14-file PR”, “about 70 changed files”
- “thorough for the first few, thin in the middle”
- “contradictory feedback”
- “missed issues across files”, “a caller still uses the old name”
Try it: review the change
Each change has bugs seeded into it. Some are plain slips. Some come from a decision the writer made on purpose, so the writer reads them as correct. Some only show when you compare two files. Pick a change, then pick the reviewer, and see what it finds.
The changed files
The bugs are seeded, and which ones each reviewer catches is illustrative, chosen to show the shape. It is not a measurement. The exam guide's point is that a session keeps its own reasoning and won't question it, that an independent instance catches subtle issues better than self-review or extended thinking, and that per-file plus cross-file passes avoid attention dilution and contradictions.
Things to try: large + the same session, then + extended thinking: one more bug, the same blind spot. Then large + an independent instance to see the subtle bugs found and the middle skimmed, and large + multi-pass. Last, small + multi-pass, then small + an independent instance.
The four traps
| Trap | What the wrong option looks like | Why it loses |
|---|---|---|
| Only usually works | “Ask the same session to re-read its changes carefully before finishing” | It finds plain slips, but the session keeps its own reasoning and tends not to question it. |
| Same blind spot | Turn on extended thinking for the review in the generating session; run /compact and review again there | More thinking in the same session carries the same assumptions into the review. |
| Attention diluted | Review the whole 12-file (or 40-file) change in one large prompt, or on a larger-context model | Fine for a small change. On a large one, attention spreads thin and findings contradict each other across files. A bigger window is not better attention. |
| Different problem | Add stricter review criteria to CLAUDE.md or the review prompt | Sets the standard, but clearer criteria don't remove the blind spot of reviewing your own work. |
Practice: three exam-style questions
Answer first, then open “Think it through”.
Rule to remember
Exam guide 4.6: “Self-review is limited: a model retains generation reasoning and won't question itself in-session.” “Independent review instances (no prior reasoning) catch subtle issues better than self-review/extended thinking.” “Multi-pass: per-file local analysis + cross-file integration passes (avoid attention dilution, contradictions).” Exam guide 3.6: “Session context isolation: the session that generated code is less effective at reviewing its own changes than an independent instance.”