4-week study plan

Sit it cold, no notes, 60 minutes max. Note which of the 5 domains 🟡 you bombed. Don't review answers yet; just record raw scores per domain.

Internalize the format: 60 MCQs, 120 minutes, 720/1000 to pass, no guessing penalty 🟡. Skim the domain weights so you know D1 (27%) and D3 (20%) carry the most leverage 🟠.

The 4D framework (Delegation, Description, Discernment, Diligence) is the conceptual spine the exam uses to frame agentic decisions. You'll see it again in scenarios.

Map the framework to your diagnostic mistakes. Most failed D1 questions trace back to a Delegation or Discernment error, not a tool-mechanics error.

Anchors model selection, message structure, and the basic prompt-and-response loop. Even if you've shipped with Claude for a year, do this; the exam tests the canonical Anthropic framing, not your shop's framing.

Focus on messages.create, system prompts, multi-turn structure, and where stop_reason lives in the response. This is the bedrock for every D1 question.

`end_turn`, `tool_use`, `max_tokens`, `stop_sequence` 🟡. Memorize what each implies for control flow. The exam will hand you a transcript and ask which value fired.

Understand the system prompt as the deterministic anchor. Note the 'persona vs. instructions vs. case-facts' separation that case-facts-block doctrine builds on.

The standard loop: send messages, check stop_reason, if tool_use then execute and append tool_result, repeat until end_turn. This is the single most-tested mechanic across D1 (27%) 🟠.

Understand the ==hub-and-spoke== orchestration pattern and the rule that subagents never inherit parent context 🟡. This single fact is worth at least 2 exam questions.

Note when to spawn a subagent (parallel research, isolated context) vs. when to keep the work in the main loop (sequential dependency, shared state).

Read the P3.3 🟡 walkthrough end to end. Don't take the questions yet; just absorb how the architecture is justified.

Learn where Claude struggles: long arithmetic chains, exact recall from the middle of a 200K context, deterministic JSON without schema enforcement. The exam tests calibrated trust, not Claude evangelism.

Internalize the lost-in-the-middle effect 🟡 and the progressive-summarization trap. Both show up in D5 (15%) 🟠 questions.

Know when CacheControlEphemeral saves cost vs. when it silently invalidates. Cache invalidation is a favorite trap question.

Frames the human-in-the-loop pattern that D5 reliability questions reference. Pay attention to the structured handoff format.

D1 carries 27% weight 🟠, which is more than any other domain. If you're below 70% here, plan extra D1 time in week 2.

The canonical 'first scenario' in the official guide 🟡. Notice how the architecture choices map to D1 + D5 reliability concerns.

Just the headings for now. This becomes mandatory reading in week 4, but seeing the failure-mode catalog early reframes the rest of your prep.

Closes the week on a D5 note. Know when to escalate to a human and what the structured handoff packet contains.

Re-read with an eye for the loop's exit conditions. Trace a transcript and predict the next stop_reason before reading on. D1 is 27% of the exam 🟠, the single biggest block.

Internalize that subagents never inherit context 🟡 — the orchestrator passes down only what it explicitly hands over. Most D1 misses are a hidden context-inheritance assumption.

Map each of the 4 values to the control-flow decision it forces. The exam hands you a response object and asks what the loop does next.

The canonical hub-and-spoke scenario. Note where the orchestrator delegates vs. does the work itself, and how results merge without sharing context.

A single-agent loop with escalation. Watch how stop_reason plus tool errors drive the escalation decision — this pattern recurs across D1 and D5 questions.

The tool description is the deterministic selector that drives tool choice 🟡 — description clarity matters more than schema cleverness. Know the 4 isError categories cold.

Memorize auto, any, a specific tool, and none, plus the exact situation each is for. The exam tests when to force any vs. leave auto.

Schema design plus the validation contract. This sets up the D4 validation-retry loop you drill in Week 3.

Watch how tool granularity and description quality change Claude's selection behaviour — the practical face of the deterministic-selector idea.

The bridge between D2 (tool/schema) and D4 (structured output). Note where validation lives and how errors are fed back to Claude.

MCP appears in roughly a quarter of D2 questions. Understand the client/server model and the tool-discovery handshake.

Drill the 18-tool degradation rule 🟠 and when to split a tool server. Read this back-to-back with Foundations.

Sit it timed. D1+D2 are 45% of the exam 🟠 — this is your mid-prep checkpoint on the heaviest block.

The configuration model: where Claude Code reads instructions, how sessions work, and the headless -p flag for pipelines.

Memorize the precedence project > user > enterprise 🟡 and how YAML frontmatter globs scope rules to file paths. Write the hierarchy from memory by end of day.

See configuration applied to a real workflow. Note where Plan Mode is triggered and how hooks gate tool use.

Know when Plan Mode engages and what it changes about tool execution. A common D3 trap is assuming it auto-executes the plan.

Understand the two hook points and what a hook can block or rewrite. The denied by PreToolUse hook message is a tested failure mode.

Skills are the highest-leverage D3 topic. Learn the SKILL.md frontmatter and when a skill is invoked vs. when the work is inlined.

Map the relationship between Skills and subagents, plus the trigger mechanics. Expect at least one Skills-design question.

Skills plus Claude Code applied to codegen. Note the configuration choices that make the workflow repeatable.

The headless -p flag in a pipeline. Watch how non-interactive runs are gated and how output is consumed downstream.

Skills packaged as reusable developer tools. Reinforces the invoke-vs-inline decision.

Few-shot examples drive determinism; system-prompt structure anchors behaviour. Learn the canonical Anthropic framing, not your shop's.

Attention engineering drives recall under long context 🟡 — placement of instructions matters as much as their content.

The canonical D4 pattern: validate the JSON, on failure send the validator's error back as a tool_result, then retry. Be able to draw this loop.

Timed. D3+D4 are another 40% of the exam 🟠 — checkpoint before synthesis week.

The case-facts-block separates immutable facts from persona and instructions 🟡 so long sessions don't drift. The single most-tested D5 idea.

Structured state vs. free-form history. Know why the progressive-summarization trap silently corrupts long sessions.

When to checkpoint and what to persist. Pairs with session-state for the reliability questions woven through scenarios.

The deployment angle D5 sometimes tests: how the platform changes auth, region, and model id, not the agent logic.

Same lens as Bedrock. Skim for the differences the exam might contrast; you don't need depth here.

D5 reliability under long context: chunking, attention placement, and state. Start the 13-scenario sweep here.

Not in the official 6 but on the real exam (13 total) 🟢. Multi-turn control and escalation patterns.

Skills applied to knowledge management. The second confirmed beyond-guide scenario.

Operational agent patterns, where reliability and tool design intersect.

Skills that run code. Watch the safety and verification framing.

Closes the 13-scenario sweep. You should now recognize every scenario family the exam draws from.

120 minutes, no notes, 720/1000 to pass 🟡. Sit it like the real thing. This is your readiness call.

Review every miss from the 60-question mock against the anti-pattern catalog. Most misses map to a named anti-pattern, not a knowledge gap.

Targeted. Confirm the gaps you closed actually moved. If you clear 720+ 🟡 here, you're ready to book.

Re-read the spine (Delegation, Description, Discernment, Diligence) one last time; it frames the judgment questions that separate a pass from a borderline.