CCA-F start here · Trap gym · Self-review

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

At a glance: review with a separate Claude instance that didn't write the code, and review large changes file by file before one pass across all the files.

Start here: proofreading your own essay

Think about checking a piece of writing.

Your own essay. You read what you meant to write, not what is on the page, so the typos slip through. Reading it again, more slowly, mostly finds the same nothing: you are still reading with the same intentions in your head.
A friend who never saw the draft. They only have the page, so they catch the slips in a minute. For a long report, they check it page by page first, then once more to see the pages agree with each other.

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.

Writer session keeps its own reasoning: “round each line” writes The change 2 files, or 12 files Reviews itself same session, with or without extended thinking agrees with its own reasoning Fresh instance sees the code, not the reasoning big change: split it Per-file passes local bugs, full attention Cross-file pass keys, signatures, units

The diagram follows the simulator: the reviewer you pick is outlined in bold.

The one question to ask: is the same session that produced the work also being asked to judge it?

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.

1. The change
2. Who reviews it

The changed files

green all bugs foundpink a bug misseddashed only skimmed

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

TrapWhat the wrong option looks likeWhy 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 spotTurn on extended thinking for the review in the generating session; run /compact and review again thereMore thinking in the same session carries the same assumptions into the review.
Attention dilutedReview the whole 12-file (or 40-file) change in one large prompt, or on a larger-context modelFine 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 problemAdd stricter review criteria to CLAUDE.md or the review promptSets 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

The writer doesn't grade its own work: use a fresh reviewer, per file first, then across files.

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.”

← All traps