Diagram gallery (QA)

Give the learner a decision rule: hard business rules go in hooks for deterministic guarantees, judgment calls go in the prompt.

Let the learner pick a decomposition pattern from one property: whether the subtasks are enumerable before work begins.

Show that misrouting comes from overlapping descriptions, and that the two fixes are renaming with a scoped description and splitting a generic tool into purpose-specific tools with their own contracts. The graph converges top-down rather than splitting into a left and a right half: the two vague tools head it, the renamed and split tools sit below them, and the broken-versus-fixed contrast is carried by color — vague tools and the misrouted call in red, the purpose-specific tools and the correct call in green. The three split tools share one grouped box so the fixed side stays readable.

Explain why the session that generated the code is a weaker reviewer than a fresh instance that sees only the diff and the project standards.

Show that precision comes from replacing the decision rule with a decidable predicate, not from asking the model to be more confident or conservative — and show the downstream trust consequence of each path.

Make clear that the cure for the "lost in the middle" effect is input layout — summary first, addressable sections below — rather than a stronger instruction to the model.

Cement the distinction that drives most items here, and show what each of the two anti-patterns costs the coordinator.

Show why keeping both conflicting values with attribution, methodology and dates is the only option that lets the coordinator reconcile knowingly.

Show that all communication radiates from the coordinator, that there are no spoke-to-spoke edges, and that each subagent has its own isolated context.

Show that synthesis is evaluated for coverage gaps and re-delegated with targeted queries until coverage is sufficient, rather than emitted after one forward pass.

Show that the gate sits between the model's tool request and execution, denies with an actionable reason, and records verified state only from the prerequisite tool's result.

Show identity established once, three concern branches investigated in parallel against that shared context, and a single synthesized resolution.

Show that heterogeneous MCP results pass through a PostToolUse hook and reach the model in a single canonical shape.

Show that equal-depth per-file analysis and a dedicated cross-file pass together cover what a single combined pass cannot.

Give the learner a decision path keyed on whether prior tool results are still valid and whether divergent branches are needed.

Show that one expensive baseline is inherited by independent branches whose contexts never mix, and that only one branch is carried forward.

Show the decision path from an MCP tool result to either local recovery or propagation, and show that a valid empty result bypasses error handling entirely.

Show which config file serves which audience, where environment variable expansion injects credentials, and that tools and resources from every configured server are discovered at connection time into one list the agent sees.

Show that Edit is gated on anchor-text uniqueness, and that the recovery path when it is not unique is Read followed by Write rather than another Edit attempt.

Make clear that the paths glob in a rule file is evaluated against the files being edited, so only matching rules enter the session context while non-matching rules cost nothing.

Give the learner a repeatable decision path from a task description to plan mode, direct execution, or the combined plan-then-execute pattern, including where the Explore subagent fits.

Map the symptom you are seeing to the refinement technique the guide prescribes, and show test-driven iteration as a closed loop with an objective stopping condition.

Make the batching decision concrete: interacting fixes must be described together, independent fixes are more reliably handled one at a time.

Show the full non-interactive review loop: what context goes in (CLAUDE.md, diff, existing tests, prior findings), which flags shape the output, and how structured findings become inline PR comments without duplicates.

Show the two pass types with the question each asks and the question each structurally cannot answer, then how their findings are merged by authority and routed by calibrated self-reported confidence.

Show that the prompt sent on every request is deliberately assembled from distinct layers in a fixed order — pinned case facts first, summarized older turns in the middle where the lost-in-the-middle effect bites, the last N turns verbatim at the end — and that pinned case facts bypass compaction entirely while older turns and tool results are lossy on purpose.

Fix the order in which triggers are evaluated: an explicit human request short-circuits everything, policy gaps escalate, multiple matches trigger clarification, and frustration alone leads to an offer to resolve.

Show the funnel from a broad question to a specific answer, and where verbose output is deliberately kept out of the main agent context.

Contrast the path that carries claim-source mappings as structured data through synthesis with the path that compresses findings into prose and loses attribution irreversibly.

Show that each subagent holds only a few role-relevant tools, that one scoped cross-role tool is a deliberate exception, and that complex cross-role work is routed back through the coordinator instead of widening a tool set.

Show the three levels of CLAUDE.md configuration as a tree of scopes, which of them travel through version control to teammates, and which modular files (@import targets, .claude/rules/) hang off each level. It describes scoping and sharing only, not any precedence or override order.

Make the masking effect concrete so the learner instinctively decomposes any headline accuracy figure by document type and field.

Let the learner read off, for each of the four MCP error categories, whether the call is retryable and what the agent should do next. Draw it as a 4-row by 2-column grid: the four categories are the rows, the two columns are isRetryable and the agent recovery action, and the relation labels are the cell values. The point is that the category is what makes recovery mechanical.

Give the learner a cheat-sheet grid: the six built-in tools are the rows, and the two columns are what the tool operates on and the stem wording that makes it the right choice. Relation labels are the cell values. Reading down the second column is what makes the scored Grep/Glob (content versus path) and Edit/Write (targeted versus whole-file) distinctions decidable from a question stem.

Help the learner choose the right home for an instruction on two axes — always needed versus invoked on demand, and team-wide versus personal — with each of the four cells naming the file location that fits.

Give the three tool_choice modes as rows against the three columns the exam tests — what the call guarantees, who selects the schema, and which stem it fits — so a stem maps to a mode in one lookup.

Give the learner a two-row table of the two APIs against the four columns the exam tests — cost, latency guarantee, multi-turn tool calling and workload fit — so a stem can be mapped to an API in one lookup.

Show that routing is two-dimensional: confidence alone does not decide, because source ambiguity overrides a high score, and the automated cell still owes a sampled audit.

Show that parallel subagents come from multiple Task calls in one coordinator response, and that each Task prompt must carry its own complete context.

Trace one tool call from the agent through the MCP client and server to the backend and back, so the learner sees where description-based selection happens, where credentials are applied, and where the isError payload originates. Every hop stays on an adjacent layer — the agent never talks to the server directly.

Show that a skill declared with context: fork executes in an isolated sub-agent context and returns only a summary, so the main session context is preserved.

Show the concrete call path from document to validated record, and make clear that the tool schema removes syntax errors while only the semantic validator can catch wrong values.

Trace one failure end to end: local recovery first, then a structured propagation that lets the coordinator re-route, and finally a coverage annotation in the output.

Show that resumability comes from agents exporting state to known locations and the coordinator loading a manifest and injecting recovered state, rather than from re-running the exploration.

Walk the four steps of the loop — send the request, inspect stop_reason, execute the requested tools, append their results — and show that the only transition signal is the structured stop_reason field: "tool_use" sends tool results back into conversation history before the next request, "end_turn" leaves the loop, and an iteration or time limit is the other exit.

Show that the retry edge carries the document, the failed extraction and the specific errors, that the loop is bounded, and that an absent-information failure exits to escalation rather than looping.

Make the SLA arithmetic visual: the queue wait plus the 24-hour worst-case processing window must fit inside the promised SLA, which is what fixes the submission interval.