Why this exists

A course can feel complete and still have a hole in it. This topic is the proof that this one does not: every published test objective, every objective that appears on a real score report, and every task statement in the exam blueprint, each listed with the topics that teach it. It is generated from the course’s own data when the course is built, so it cannot drift from the topics. Use it in two directions — to check that nothing is missing before you sit, and, after a score report, to go from a weak objective straight to its topics.

What this unlocks. No objective of its own. It is the index from the exam’s objectives to this course, and the release gate the course had to pass.

In plain language

Three lists define what the exam tests. The 37 test objectives, published by the certifying body, are the finest-grained statement of what a candidate should be able to do; they carry ids OBJ-1 to OBJ-37 here. Fifteen further objectives appear on a real candidate’s score report in slightly different wording, several of them absent from the published list; they carry ids SR-1 to SR-15. And the 30 task statements are the blueprint’s own structure, five domains of five to seven statements each; they carry ids TS 1.1 to TS 5.6. Every one of the 82 rows below names at least one topic.

How it actually works

Each topic in this course declares which objectives it claims. When the course is assembled, those claims are collected into the three tables below, and the build refuses to complete if any objective is unclaimed. So the tables are not a promise about the course; they are a fact about it, regenerated every time it changes. A topic can claim several objectives, and an objective can be taught by several topics — the , for instance, is claimed by the loop topic, the termination topic and the safeguards topic, because each teaches a different part of it. The Phase 1 foundation topics claim no objectives; they are prerequisites, and each says what it unlocks instead.

Reading the tables from a score report: the report shows percent-correct by domain, and the domain is the first digit of every TS id, so a weak Domain 4 is the TS 4.x rows, and the topics beside them are where to spend the next study session. Reading them before the exam: run down the SR rows in particular, since those are the objectives that appeared on a real report and that the published list does not fully contain — the ones a candidate studying from the published objectives alone would meet cold.

Worked example

A score report comes back with Domain 3 at 50%. The route through this map: Domain 3 is TS 3.1 to 3.6; the score-report objectives that belong to it are SR-5 (slash commands), SR-6 (plan mode), SR-7 (enforcement versus CLAUDE.md) and SR-10 (@ references); each row names its topics, and the enforcement and @import rows point at two of the nine objectives that scored zero on the real report this course was built against. Those two topics are the afternoon’s work.

The 37 test objectives (OBJ)

Id	Objective	Topics
`OBJ-1`	Configure agentic loops to emit multiple tool calls within a single response turn, enabling parallel execution of independent subtasks and reducing total round-trip latency.	Parallel spawning
`OBJ-2`	Apply session resumption techniques—including targeted re-analysis of changed files and context injection—to restore agent state accurately without repeating prior work.	Sessions and resumption
`OBJ-3`	Construct subagent prompts that include all findings, structured data, and source metadata required for task completion without returning to the coordinator for missing context.	Subagents inherit nothing, Subagent outputs
`OBJ-4`	Evaluate subagent delegation strategies—goal-oriented versus procedural instructions—and select the approach that enables adaptive behavior while maintaining coordinator visibility and control.	Goal vs procedure
`OBJ-5`	Configure subagent invocations with appropriate tool restrictions, context scoping, and system prompts that constrain each agent to its designated role.	Task tool and AgentDefinition, Tool distribution
`OBJ-6`	Diagnose misconfigured subagent spawning by identifying missing tool permissions, incorrect AgentDefinition parameters, or absent coordinator-to-subagent wiring.	Task tool and AgentDefinition
`OBJ-7`	Decompose complex tasks into dynamically generated subtasks that adapt as new information is discovered, rather than executing a fixed sequence regardless of intermediate findings.	Fixed vs dynamic decomposition
`OBJ-8`	Select the appropriate agentic review architecture—plan mode, direct execution, or multi-phase workflow—based on task scope, risk level, and human approval requirements.	Plan mode
`OBJ-9`	Design state persistence strategies for multi-agent pipelines that enable reliable resumption after interruption without repeating completed work or losing prior findings.	Sessions and resumption, Scratchpads and /compact
`OBJ-10`	Evaluate multi-agent orchestration patterns—coordinator-worker, parallel execution, and sequential pipelines—to select the structure best satisfying research coverage, latency, and reliability requirements.	Hub-and-spoke, Fixed vs dynamic decomposition
`OBJ-11`	Configure Claude Code CLI invocations for automated CI/CD pipelines using non-interactive flags, permission modes, and cost and turn limits that prevent runaway executions.	Claude Code in CI
`OBJ-12`	Structure iterative refinement workflows by providing concrete input-output examples, targeted feedback on specific failures, and batched issue descriptions for consolidated evaluation.	Iterative refinement
`OBJ-13`	Design Claude Code review configurations that load the correct project standards, restrict unnecessary tool access, and produce structured output suitable for automated downstream processing.	CI review quality
`OBJ-14`	Apply the context: fork frontmatter option to Skill and slash command configurations that should execute in an isolated subagent context, preventing cross-contamination of session state.	Skills and context: fork
`OBJ-15`	Improve automated test generation quality by providing existing test files as context, defining fixture conventions, and specifying criteria that distinguish meaningful behavioral tests from trivial assertions.	CI review quality
`OBJ-16`	Select the correct Claude Code configuration mechanism—CLAUDE.md, .claude/rules/ with glob patterns, Skills, hooks, or settings permissions—based on guidance type and when it should apply.	The configuration surface, Path-scoped rules, Enforce vs guide, The decision table
`OBJ-17`	Apply systematic codebase exploration strategies using Grep, Glob, and Read tools that build incremental understanding while managing context window constraints.	Choosing a built-in tool
`OBJ-18`	Design subagent output schemas that render structured data, prose summaries, and citation metadata in the format best suited to downstream synthesis and reporting.	Subagent outputs
`OBJ-19`	Design synthesis agent behavior that preserves source-level uncertainty, distinguishing well-established findings from contested claims rather than collapsing conflicting data into single confident statements.	Provenance
`OBJ-20`	Apply context management strategies—subagent isolation, scratchpad files, and targeted file reading—to sustain coherent codebase exploration across sessions exceeding context limits.	Explore subagent, Scratchpads and /compact
`OBJ-21`	Apply context window optimization techniques—summarization, sliding windows, structured state objects, and selective retention—to maintain response quality as conversations exceed practical token limits.	Summarisation and retention, Case-facts blocks
`OBJ-22`	Design human review routing strategies that direct extractions to reviewers based on confidence scores, document characteristics, and field-level ambiguity rather than random sampling.	Human review routing
`OBJ-23`	Select the appropriate API processing mode—synchronous Messages API or asynchronous Message Batches API—based on latency requirements, workflow blocking behavior, and acceptable processing windows.	Messages vs Batches
`OBJ-24`	Design specialized review passes that separate concerns—security, business logic, API design—into focused prompts with dedicated few-shot examples, preventing recall trade-offs from competing concerns in a single prompt.	Focused passes
`OBJ-25`	Select and implement the most reliable structured output method—tool use with JSON schema, prompt-based formatting, or prefilled responses—based on required schema compliance strictness.	Structured-output methods
`OBJ-26`	Design extraction schemas with optional fields, nullable values, and appropriate enum definitions that allow the model to accurately represent missing or ambiguous information without fabricating values.	Schema design
`OBJ-27`	Implement tool use with defined JSON schemas to enforce structured output compliance, and configure tool_choice to guarantee tool invocation when conversational responses would cause downstream failures.	Schema plus tool_choice
`OBJ-28`	Resolve structured output truncation failures by splitting large review tasks into smaller scoped API calls and merging resulting data structures, rather than increasing max_tokens beyond practical limits.	Truncation
`OBJ-29`	Apply extraction accuracy patterns—structured schemas with optional fields, format normalization instructions, and few-shot examples—to reduce hallucination and improve consistency across varied document formats.	Few-shot examples, Schema design
`OBJ-30`	Reduce automated review false positive rates by supplying project-specific conventions, accepted patterns, and exclusion criteria as persistent context applied on every review.	CI review quality, Explicit criteria
`OBJ-31`	Design prompt criteria that define explicit inclusion and exclusion boundaries, preventing the model from generating findings or extractions in categories where performance is unreliable.	Explicit criteria
`OBJ-32`	Select the appropriate Claude Code built-in tool—Grep, Glob, Read, or Bash—based on the nature of the search or file operation required for a given codebase task.	Built-in tools, Choosing a built-in tool
`OBJ-33`	Configure tool distribution in multi-agent systems by assigning each subagent only the tools required for its designated role, reducing decision complexity and preventing out-of-role tool invocations.	Tool distribution
`OBJ-34`	Distinguish between MCP resources and tools, and expose server content as resources to reduce exploratory tool calls and improve agent efficiency in cross-system queries.	Resources vs tools
`OBJ-35`	Integrate MCP servers into Claude Code and agent applications by selecting the correct server scope, configuring authentication via environment variable expansion, and verifying tool discovery.	What MCP is, MCP scope and credentials
`OBJ-36`	Write MCP tool descriptions that clearly distinguish each tool's purpose, input formats, use-case boundaries, and relationships to semantically similar tools, reducing misrouting and incorrect tool selection.	Tool descriptions, Tool boundaries
`OBJ-37`	Configure the tool_choice parameter to guarantee tool invocation when structured output is required, and sequence multi-tool workflows so prerequisite data is obtained before dependent tools are called.	tool_choice, Schema plus tool_choice

The 15 score-report objectives (SR)

Id	Objective	Topics
`SR-1`	Design orchestration-layer safeguards ensuring every agent session ends with a completed resolution or human escalation, regardless of how the agentic loop terminates.	Resolved or escalated
`SR-2`	Design structured handoff packages that preserve accumulated context, findings, and authorization state when transferring control between agent steps or to a human operator.	Structured handoff
`SR-3`	Apply PreToolUse and PostToolUse hook patterns to enforce business rules and policy constraints not delegated to model discretion.	PreToolUse hooks
`SR-4`	Explain how the agentic loop uses model responses and stop_reason signals to decide whether to continue tool execution or terminate and return a final response.	The agentic loop, How the loop ends
`SR-5`	Create and deploy custom slash commands in the correct project or user directory so they are available to intended users and invoked on demand for task-specific workflows.	Slash commands
`SR-6`	Determine when to use plan mode versus direct execution based on task scope, reversibility, architectural uncertainty, and the need for stakeholder review before implementation.	Plan mode
`SR-7`	Distinguish instructions that must be enforced through settings permissions or hooks from those appropriately placed in CLAUDE.md, and restructure configurations accordingly.	Enforce vs guide
`SR-8`	Implement PostToolUse hooks that automatically enforce code quality constraints—such as formatting, linting, or test execution—after every file edit, independent of model instruction-following.	PostToolUse hooks, Enforce vs guide
`SR-9`	Configure MCP servers and project settings at the correct scope—project-level for shared team tooling and user-level for personal or experimental configurations.	MCP scope and credentials
`SR-10`	Select the appropriate method for providing project context to Claude Code—@ references, CLAUDE.md, or inline description—based on reusability, specificity, and cross-session need.	@import and /memory
`SR-11`	Explain why conversation history must be explicitly included in each API request and identify the correct mechanism for maintaining state across multiple turns in a stateless API.	Resent history and state
`SR-12`	Apply escalation decision criteria to determine when an agent should immediately honor a human escalation request versus attempt autonomous resolution using available tools.	Escalation criteria
`SR-13`	Design feedback loop mechanisms that capture structured metadata about model errors and use those patterns to improve prompts, schemas, or few-shot examples in future iterations.	Feedback loops
`SR-14`	Implement MCP tool error handling that surfaces structured, type-specific error information to the agent—including recoverability status and suggested next actions—rather than generic failure messages.	Structured MCP errors
`SR-15`	Improve tool selection reliability by expanding tool descriptions with use-case examples, input format specifications, and explicit disambiguation guidance for semantically similar tools.	Tool descriptions

The 30 task statements (TS)

Id	Task statement	Topics
`TS 1.1`	Design and implement agentic loops for autonomous task execution	What a tool is, The agentic loop, Resent history and state, How the loop ends, Resolved or escalated, The rote patch
`TS 1.2`	Orchestrate multi-agent systems with coordinator-subagent patterns	Hub-and-spoke, Subagents inherit nothing, Fixed vs dynamic decomposition
`TS 1.3`	Configure subagent invocation, context passing, and spawning	Subagents inherit nothing, Goal vs procedure, Task tool and AgentDefinition, Parallel spawning, The rote patch
`TS 1.4`	Implement multi-step workflows with enforcement and handoff patterns	Resolved or escalated, Prerequisite gates, PreToolUse hooks, Structured handoff
`TS 1.5`	Apply Agent SDK hooks for tool call interception and data normalization	PreToolUse hooks, PostToolUse hooks, The rote patch
`TS 1.6`	Design task decomposition strategies for complex workflows	Fixed vs dynamic decomposition, Focused passes
`TS 1.7`	Manage session state, resumption, and forking	Sessions and resumption, The rote patch
`TS 2.1`	Design effective tool interfaces with clear descriptions and boundaries	What a tool is, Tool descriptions, Tool boundaries
`TS 2.2`	Implement structured error responses for MCP tools	Structured MCP errors, Error propagation, The rote patch
`TS 2.3`	Distribute tools appropriately across agents and configure tool choice	Tool distribution, tool_choice, The rote patch
`TS 2.4`	Integrate MCP servers into Claude Code and agent workflows	What MCP is, Resources vs tools, MCP scope and credentials, The rote patch
`TS 2.5`	Select and apply built-in tools (Read, Write, Edit, Bash, Grep, Glob) effectively	Built-in tools, Choosing a built-in tool, The rote patch
`TS 3.1`	Configure CLAUDE.md files with appropriate hierarchy, scoping, and modular organization	The configuration surface, CLAUDE.md levels, @import and /memory, The decision table, The rote patch
`TS 3.2`	Create and configure custom slash commands and skills	Slash commands, Skills and context: fork, The decision table, Non-existent and out of scope, The rote patch
`TS 3.3`	Apply path-specific rules for conditional convention loading	Path-scoped rules, The decision table, The rote patch
`TS 3.4`	Determine when to use plan mode vs direct execution	Plan mode, Explore subagent
`TS 3.5`	Apply iterative refinement techniques for progressive improvement	Iterative refinement, The rote patch
`TS 3.6`	Integrate Claude Code into CI/CD pipelines	Claude Code in CI, CI review quality, Independent review, Non-existent and out of scope, The rote patch
`TS 4.1`	Design prompts with explicit criteria to improve precision and reduce false positives	Explicit criteria
`TS 4.2`	Apply few-shot prompting to improve output consistency and quality	Few-shot examples, The rote patch
`TS 4.3`	Enforce structured output using tool use and JSON schemas	Structured-output methods, Schema plus tool_choice, Schema design, What a schema cannot fix, The rote patch
`TS 4.4`	Implement validation, retry, and feedback loops for extraction quality	What a schema cannot fix, Validation and retry, Feedback loops, The rote patch
`TS 4.5`	Design efficient batch processing strategies	Messages vs Batches, The rote patch
`TS 4.6`	Design multi-instance and multi-pass review architectures	Focused passes, Independent review
`TS 5.1`	Manage conversation context to preserve critical information across long interactions	Resent history and state, Context as budget, Lost in the middle, Summarisation and retention, Case-facts blocks, Subagent outputs
`TS 5.2`	Design effective escalation and ambiguity resolution patterns	Resolved or escalated, Escalation criteria, The rote patch
`TS 5.3`	Implement error propagation strategies across multi-agent systems	Error propagation
`TS 5.4`	Manage context effectively in large codebase exploration	Explore subagent, Scratchpads and /compact
`TS 5.5`	Design human review workflows and confidence calibration	Human review routing, The rote patch
`TS 5.6`	Preserve information provenance and handle uncertainty in multi-source synthesis	Provenance

Check yourself

What are the three lists, and how many entries does each have?

The 37 published test objectives (OBJ), the 15 objectives from a real score report (SR), and the 30 task statements of the blueprint (TS) — 82 rows, every one claimed by at least one topic.

Why do the Phase 1 topics not appear in these tables?

Because they are prerequisites, not exam objectives. Each declares what it unlocks instead of claiming an objective; the vocabulary they teach is what the guide assumes rather than tests.

A score report shows Domain 3 at 55% and Domain 5 at 90%. Two ways to spend the next session: re-read the Domain 5 topics you found hardest, or go to the TS 3.x and SR-5/6/7/10 rows and read the topics beside them. Which, and why?

The second. The domain figures are informational, but they point at where marks were lost; the map turns a weak domain into named topics, whereas re-reading a strong domain spends the session where nothing was lost.

Where next

Two choices. Back to the start with The tree, the path, and the slash for a full revision pass. Or The rote patch: everything that is pure memory, the values to hold the night before.