Pass the CCAR-F Exam 2026: Claude Certified Architect Course

Open any Messages API request and say what's in it and what it costs. Text becomes tokens, and everything in a request (the system prompt, every message, tool definitions, and the reply with its thinking) shares one fixed context window: 1M tokens on Claude Haiku 5.5, with every input token billed on every request. The API remembers nothing between requests, so a conversation exists only because you send the whole history each time. And each instruction has its place: the role and the rules in the system prompt, the customer's words in the user turn, and max_tokens as a ceiling on the output, thinking included, never a way to ask for a short answer. You measure all three on Harborline with three short scripts: the same request at 59, 664 and 73,323 tokens; a reply that used 179 of its 1,024 tokens, then a 40-token cap that stopped it before any text; and a question Claude couldn't answer without the history, and answered with it. An exam-style question closes the lesson: a support agent that forgets the order number a customer gave two messages earlier.

By the end of this lesson you can:

• Treat tokens and the context window as a fixed budget.
• Carry the whole conversation on a stateless API.
• Tell system prompt, user turns and max_tokens apart.

Take any Messages API reply apart and act on it. A reply is a list of typed content blocks (a thinking block whose text is empty but billed, then text, or a tool_use request), plus usage, a receipt of what you're billed for, and a request ID, the one value support needs to find a call. Your code decides the next step from stop_reason, never from "is there text?": use the answer on end_turn, run the tool on tool_use, never ship a max_tokens reply, send a pause_turn back as is, and on refusal discard the reply and read stop_details. And a conversation is a list you only append to, so the input bill grows every turn. On Harborline you log every call with its request ID and cost, read the same question twice (once answered, once turned into a tool_use request when a tool is added), and run a three-turn support chat whose input grows from 676 to 884 tokens. An exam-style question closes the lesson: a support agent whose own prompt makes 9% of its replies come back as refusals.

By the end of this lesson you can:

• Read a reply's blocks, usage and request ID.
• Decide the next step from every stop_reason.
• Run a chat by appending every turn correctly.

Claude never runs anything: it asks, and your code does the work. This lesson builds that round trip by hand. You define Harborline's first two tools the way the API needs them (a name Claude calls each one by, a description Claude reads to decide when to use it, and a JSON Schema for its input), and you see that Claude knows only those definitions, never the code behind them, and that every definition is billed as input on every request. Then you drive one full round trip on Harborline: Claude asks for get_customer and lookup_order in one response, your code runs both against the backend, and you send Claude's turn back unchanged followed by one user turn of tool_result blocks, each tied to its call by tool_use_id. Claude answers from what you sent: order HL-10196 has shipped. Then a customer gives a wrong order number, the lookup fails, and the failure goes back as a tool_result with is_error: true, so Claude asks for the right number instead of the program crashing. An exam-style question closes the lesson: a support agent whose failed lookups end the chat.

By the end of this lesson you can:

• Define a tool: name, description, JSON Schema.
• Run a tool call by hand, from tool_use to tool_result.
• Answer every call in one turn, failures included.

Last lesson's single round trip becomes a loop: as many turns as Claude needs, every result fed back, and a clear rule for when to stop. You write Harborline's agentic loop on the Messages API: each turn sends the system prompt, the tools and the whole history; Claude's turn goes back exactly as it came; every tool_use block runs and all the results go back in one user turn; the loop continues while stop_reason is tool_use, returns on end_turn, and raises on anything else. A turn cap stays, but only as a safety net. Then you run it on two real tickets. A refund question takes three turns that Claude chooses (verify, look up, answer), and the answer holds facts that exist only in the tool results. A three-question ticket asks for two lookups in one response, and then stops on max_tokens: the loop raises instead of sending a cut-off reply. Finally, three tempting stop rules (a "done"-word detector, a fixed turn count, and "any text means finished") are judged on one real run, and each one gets it wrong. An exam-style question closes the lesson: a support loop that always stops after its third call.

By the end of this lesson you can:

• Loop on stop_reason: continue on tool_use, stop on end_turn.
• Feed every tool result back so Claude reasons on it.
• Spot the three stop-rule anti-patterns.

Last lesson's agent picks its own next step. Today you build the other kind of system on the same tickets and measure both. Harborline's fixed routing workflow lets Claude fill in one label through a forced tool call (route_ticket, a tool nobody runs), then your code takes over: a gate sends anything without a fixed path to people, the same two lookups always run in the same order, and Claude writes one reply from the facts. That is prompt chaining with routing at the front. On a status question it answers in two calls with a path you can predict. On a ticket with three requests in one message, its one fixed path checks one order out of two. Then the same five tickets go through both designs: the workflow used 10 calls and about 40% of the agent's tokens, and the agent looked up every order. The lesson names the workflow patterns (prompt chaining, routing, orchestrator-workers, plus parallelization and evaluator-optimizer), places them on a dial from "fixed by code" to "chosen by Claude", and ends on the architect's rule: start with the simplest design that meets the requirement, and climb only when a measurement shows the gain. An exam-style question closes the lesson: a support agent that must answer order-status questions faster and cheaper without losing quality anywhere else.

By the end of this lesson you can:

• Tell who decides the next step: Claude or your code.
• Match a task to chaining, routing or orchestrator-workers.
• Choose the simplest design that meets the requirement.

Four stop rules were judged on one real run, and three of them sounded reasonable but were wrong. Module 1's exam traps work the same way: every wrong option sounds like a fix. This lesson covers the module's five classic traps: make it bigger, say it in the prompt, read the words, retry it, and more machinery. Each one is checked against the docs pages behind Lessons 1.1 to 1.5 and against the module's own runs. Those runs include a million-token window where the bill was the real limit, a 40-token cap that left no text at all, a request without its history that couldn't see the order number, a reply that was only a tool call, a bad order ID sent back with is_error instead of retried, three wrong stop rules, and a fixed workflow that checked one order of two. Then you solve one original exam-style question in which three options are three of the traps, take Module 1 home on one page, and move on to Lab 1 and the Module 1 quiz.

By the end of this lesson you can:

• Spot Module 1's five classic traps.
• Know the fix each one hides.
• Hold Module 1 on one page.

Hands-on lab for this module. The full instructions are below; the ZIP in Resources holds the starter project, the reference solution and the self-check tests.

Same model, same requests, and only the tool descriptions change. On eight requests held out for testing, the score goes from 6 out of 24 to 23. This lesson shows what Claude reads when it picks a tool: every request carries your tool definitions, and Claude reads the request against all of them. The name chooses the tool; the description chooses the input, and where the tool's job ends. You give Harborline's agent five tools with the one-line first drafts most of us would write, and measure them: right tools, but order numbers passed as customers typed them, and refunds above $500 paid out. Then you rewrite five descriptions and one parameter line with purpose and returns, when to use the tool, the input format, an edge case and a boundary, and measure again on 16 labeled requests and 8 held-out ones, three tries each. You read the misses too: a description steers but doesn't enforce, and two labels turn out to be wrong. An exam-style question closes the lesson: a research analyst that invents source IDs, although both its tool descriptions are accurate.

By the end of this lesson you can:

• Explain why the description decides which tool Claude picks.
• Write descriptions with inputs, examples, edge cases and boundaries.
• Measure tool selection before and after a change.

Same model, same tools, same 16 requests. Add one sentence to the system prompt, and a refund request goes to the wrong tool three times out of three. Good descriptions are necessary, not sufficient: this lesson covers three tool-interface problems that better wording inside one description doesn't fix, and the right move for each. Two tools that claim the same job leave Claude two right answers, so rename each to one distinct job. One generic tool with a mode switch and a free-text query can't say what each job needs or returns, so split it by purpose, each piece with its own input and output contract. And a system-prompt line keyed to a word can quietly beat your best descriptions, so rewrite it around the situation and test it with and without. You type a generic query_backend tool next to Harborline's five tools, split it into the one job no tool did (check_refund, four named fields in, three out), and measure a keyword line against the same intent written by situation on the 16 labeled requests. The lesson also reconciles today's docs, which recommend grouping related operations behind an action parameter, with the exam's purpose-specific tools. An exam-style question closes it: a developer-productivity agent whose one code tool takes a mode and free text.

By the end of this lesson you can:

• Rename overlapping tools so each has one distinct job.
• Split a generic tool into tools with clear inputs and outputs.
• Find system-prompt lines that override good descriptions.

Same request, same script: on Haiku 5.5 every tool_choice setting works; on Sonnet 5.5, two of them are rejected outright. This lesson covers how many tools an agent should get, and who decides whether a tool is called at all. You measure what eighteen tools cost when the job needs five or six: Lesson 2.1's own eval, the same 24 requests and three tries, run with Harborline's six tools and with twelve realistic extras added. Selection held on this model, inside the noise line drawn before the run, but every call carried about 57% more input. Then you scope Lab 1's agent to its role: its prompt said it can't issue refunds, and now its tool list says so too. Last, one request under five settings, auto, any, a named tool, none and auto with the tool asked for, on Haiku 5.5 and then on Sonnet 5.5, where any and a named tool return a 400 error. You'll know what to answer on the exam, what to use on today's newest models, and why asking for a tool steers but doesn't guarantee. An exam-style question closes it: a CI review agent connected to a whole platform toolset.

By the end of this lesson you can:

• Explain why fewer tools select better, and scope tools to a role.
• Choose auto, any, a named tool or none for a requirement.
• Handle models that reject forced tool use.

Same five requests, same tools. Only the error message changes. With one generic string, Claude sends a refund again after it has already been refused; give it the reason, and it stops. This lesson is about what a tool should send back when it fails. You learn the flag that says a tool failed (is_error in the Messages API, isError in MCP) and the four kinds of failure the exam names, each with its own next move: transient (try again), validation (fix the input), business (don't retry; explain) and permission (hand it off). You give every error a body: a category, whether a retry can help, and a message a person can read, plus retriable: false and a customer-friendly reason when the policy says no. And you learn to tell an access failure from a valid empty result, because a timeout turned into [] tells the customer they have no orders. In the hands-on you write harborline/tool_errors.py, wire it into run_tool with one changed line, and measure three kinds of error reply on the same requests with real tools. Then you watch Lab 1's agent retry a timeout because the error said it could. An exam-style question closes it: a build assistant whose every failure says "Operation failed."

By the end of this lesson you can:

• Flag tool failures and tell four error kinds apart.
• Return a category, a retry flag and a readable reason.
• Tell a failed lookup from an empty answer.

Harborline's backend, now an MCP server. Any host can start it, list its tools and call them, and when a lookup times out, it says so in a way Claude can act on. This lesson explains the Model Context Protocol's three roles: the host is the AI application, it creates one MCP client per server, and the server exposes capabilities. It explains the three building blocks a server offers and, above all, who controls each one: tools are actions the model decides to call, resources are data and catalogs the application reads and hands to Claude, and prompts are templates a user picks. Then you build harborline-mcp in Python with the official SDK, mcp 2.3.0: four tools whose descriptions come straight from the earlier lessons, failures returned as tool results with the structured body from Lesson 2.4, the refund policy and the product catalog as resources, and one prompt. You test it twice: in memory with the SDK's own client (three tests, no subprocess), and in the MCP Inspector, where a transient error, a retry, a valid empty list, a resource and a prompt all show up. You also learn the stdio rule: stdout belongs to the protocol. An exam-style question closes it: a docs assistant that spends eight to ten searches learning what exists before doing any work.

By the end of this lesson you can:

• Explain hosts, clients, servers, and the three building blocks.
• Build an MCP server with tools, resources and a prompt.
• Test it in memory and in the MCP Inspector.

One Claude Code session, three kinds of MCP servers: Harborline's server, shared through the project; a memory server that's private to one developer; and the connectors that come with the account. Where each one is configured decides who gets it. This lesson covers Claude Code's three scopes: local, the default (private, one project), project (.mcp.json at the root of the repo, committed, approved once by each developer) and user (private, every project), and which definition wins when a name shows up twice. It shows how to keep a token out of git with environment variable expansion: .mcp.json holds ${HARBORLINE_API_TOKEN}, each developer's environment holds the value, and an unset variable gets a warning and passes through as plain text. And it shows what happens when many servers run at once: with tool search, Claude Code loads only tool names and server instructions at the start, so names and instructions are what point Claude to your tools, and for standard systems there's usually a server already. In the hands-on you add Lesson 2.5's server at each scope, give it instructions and a token check, wire the token through .mcp.json, approve it, and watch Claude call two servers in one conversation. An exam-style question closes it: a Jira token committed in .mcp.json.

By the end of this lesson you can:

• Choose local, project or user scope for an MCP server.
• Keep tokens out of git with ${VAR} expansion.
• Run several servers at once, and know when to build your own.

One search, three files read, and a straight answer: getStatus is just another name for status_name, passed along through two files. No guessing, and no reading the whole repo. This lesson is about Claude Code's built-in tools and the three jobs they do. Find: Grep searches inside files, Glob finds files by name. Change: Read comes first; Edit replaces one exact string that must appear exactly once, so you give it a longer anchor; replace_all is only for when every copy should change; Write, the whole file, is the fallback. Explore: search for the entry point, read it, and follow each name, re-exports included, one step at a time. And one thing has changed since the exam guide was written: on macOS, Linux and WSL, today's Claude Code leaves Grep and Glob out of its default tools and searches through Bash, until you name them. In the hands-on you ask the same question twice, once with the default tools and once with Grep and Glob restored, find test files with Glob, and watch one Edit with a unique anchor rename a variable in legacy code. An exam-style question closes it: an agent that opens 3,000 files one by one.

By the end of this lesson you can:

• Pick Grep for content and Glob for file names.
• Edit with a unique anchor, or fall back to Read + Write.
• Explore step by step: search, read, follow the names.

Same tools, same requests: one line added to the system prompt took tool selection from 45 of 48 to 39. That line sounded like a fix, and Module 2's exam traps work the same way. This lesson covers the module's six classic traps: say it in the prompt, add a layer, one tool for everything, give it everything, hide the failure, and right idea, wrong place. Each one is checked against the docs pages behind Lessons 2.1 to 2.7 and against the module's own runs: a keyword line that cost six of forty-eight, a description rewrite that took held-out requests from 6 to 23 of 24 with no new layer, a generic tool that was never picked, twelve unused tools that made every call about 57% bigger, a generic error that let a refund go out again, and a token kept out of git as a variable reference. Then you solve one original exam-style question in which three options are three of the traps, take Module 2 home on one page, and move on to Lab 2 and the Module 2 quiz.

By the end of this lesson you can:

• Spot Module 2's six classic traps.
• Know the fix each one hides.
• Hold Module 2 on one page.

Hands-on lab for this module. The full instructions are below; the ZIP in Resources holds the starter project, the reference solution and the self-check tests.

Two tool calls, three turns, and a clear answer for a customer, for six hundredths of a cent: a support agent on the Claude Agent SDK, with your own Python functions as its only tools. This lesson starts Module 3. You see what the Agent SDK replaces in the loop you wrote by hand in Lab 1: you call query() with a prompt and options, the SDK runs Claude Code's own agent loop, and your code reads the messages it streams back. You set ClaudeAgentOptions one by one and learn why each is there: a system prompt of your own, tools for what Claude can see, allowed_tools for what runs without asking, dontAsk for everything else, no settings from the machine, and two safety nets. And a plain Python function becomes a tool through an in-process MCP server, with no separate process. In the hands-on you install the SDK, write two tools and a 55-line agent, and run it on a real support ticket. An exam-style question closes it: a support agent caught reading a settings file.

By the end of this lesson you can:

• Explain the SDK: Claude Code's agent loop as a library.
• Configure query() with ClaudeAgentOptions.
• Turn Python functions into tools, in-process.

Fifteen of twenty tickets resolved on first contact, three of three handed to a person, and one refund that should never have been paid: a support agent's real number, measured, not guessed. This lesson gives Lesson 3.1's agent its full set of support tools, two that read and two that act, and wires them from one list so a tool can't be served but forgotten in allowed_tools. You read a run the way the SDK reports it: assistant messages with tool calls and text, then a result message with its subtype, turns, cost and session ID. You learn what the subtype does and doesn't tell you. Then you measure first-contact resolution on twenty labeled tickets, graded on what the agent did, not on what it said. An exam-style question closes it: a report that counts every success as resolved.

By the end of this lesson you can:

• Wire the support agent's four tools, two that read and two that act.
• Read the message stream and the result message.
• Measure first-contact resolution on labeled tickets.

Five tickets, the same five order lookups: with only a rule in the prompt, every one went through; with a gate in the code, every one was blocked. Same agent, same prompt, same tickets. This lesson is about the difference between guidance and enforcement. A system prompt that says "verify the sender first" is followed most of the time, and that's not enough when a step must hold every time: identity verification before an order is read or money moves. You build a prerequisite gate in the support agent's own tools: it remembers the customer that get_customer verified for this ticket, and refuses lookup_order and process_refund without one, or for someone else's order, with an error Claude can read and act on. Then you prove it on tickets built to skip verification. An exam-style question closes it: refunds paid without verification, and the one fix that works every time.

By the end of this lesson you can:

• Explain why a prompt rule can fail.
• Build a prerequisite gate for the order tools.
• Prove it on skipped verification.

Status 7 goes in, "returned" comes out; a $649 refund is denied before it runs. This lesson puts two rules where they hold on every tool call: in hooks. A PreToolUse hook sees every process_refund call before it runs, and above the $500 approval limit it denies the call with a reason that tells Claude to hand the case to a person instead of retrying. A PostToolUse hook sees every lookup_order result before Claude does, and replaces it with one format: UTC ISO 8601 dates and status names, instead of the old warehouse's Unix seconds and numeric codes. Then you prove both: each hook called directly, then the agent on a returned order with the hooks off and on, and on a $649 refund. An exam-style question closes it: an audit that needs proof the agent can never pay a large refund itself.

By the end of this lesson you can:

• Block a refund above $500 with a hook.
• Normalize what the tools return.
• Choose a hook over a prompt rule.

Five tickets, the right call on every one, and both customers who asked for a person handed over at once. This lesson is about when a support agent should hand a case to a person, and when it shouldn't. Three triggers are real: the customer asks for a person, the policy doesn't cover the request, or the agent can't make progress. Two signals look useful and aren't: how upset the customer sounds, and how sure the model says it is. Then the fine line: an explicit request for a person is honored at once, while an annoyed customer with an in-scope issue gets a fix. And when two customers share a name, the agent asks, never guesses. You measure the agent on five tickets, move its system prompt into a Markdown file with written criteria and four examples, and measure again. An exam-style question closes it: two customers named Jordan Lee.

By the end of this lesson you can:

• Name the real escalation triggers.
• Explain why sentiment is a poor trigger.
• Write criteria with few-shot examples.

Three messages that each ask for three things, every request answered, and three cases handed to a person with every field a person needs. This lesson is about two moments around the hand-over decision. First, a message that asks for several things: split it into its requests, look up what you need together, with independent lookups in one turn, and answer every part in one reply, from one shared context, the refund policy. Second, the hand-off itself: the person in the support-leads queue never sees the conversation, so the hand-off carries the customer ID, the order, the root cause, the amount and a recommended action, each one standing on its own. You measure the agent on three multi-request tickets and three hand-offs, add a structured hand-off tool and the policy as shared context, and measure again. An exam-style question closes it: hand-offs that say "see the chat".

By the end of this lesson you can:

• Answer every request in one reply.
• Write a structured hand-off.
• Design it for a person without the transcript.

Eight messages into one support chat, the customer asks for every refund: the amount, the order and the reference. A long conversation can't keep every word, so the older part is summarized, and summarized again as it grows, and each fold keeps the gist and drops the details. This lesson keeps the exact facts outside the summary: a case-facts block built from tool results, one entry per order, sent with every turn, and tool results trimmed to the fields that matter before they pile up in the context. You measure an eight-message conversation with a short running summary, add the case facts and the trim with two hooks, and measure again. An exam-style question closes it: refund details lost late in long chats.

By the end of this lesson you can:

• Explain how summaries blur the facts.
• Keep a case-facts block outside the summary.
• Trim tool results to the fields that matter.

An agent spends an hour reading your code. Tomorrow, do you want that hour back, or a clean slate? A session is the whole conversation, saved under an ID: every prompt, tool call, result and reply. This lesson builds a small code reviewer with the Agent SDK and works with its session three ways: resume it in a new process, fork it to compare two testing plans from one shared review, and tell it exactly what changed after a real fix, so it re-reads one file instead of trusting a stale copy. You also see when a fresh start with a short summary beats resuming. An exam-style question closes it: three of forty analyzed files refactored overnight.

By the end of this lesson you can:

• Resume a named session.
• Fork to compare two approaches.
• Choose resume or a fresh start.

Same five tickets, same system prompt: with the rule in the prompt alone, all five got an order back without a verified owner; with a gate in code, none did. The prompt rule sounded strong enough, and Module 3's exam traps work the same way. This lesson covers the module's six classic traps: say it louder, trust a proxy, count the wrong thing, ship the transcript, summarize harder, and resume blindly. Each one is checked against the docs pages behind Lessons 3.2 to 3.8 and against the module's own runs: a gate that blocked what the prompt let through, a $649 refund denied by a hook with a reason, escalation criteria that took "handed over at once" from 0 of 2 to 2 of 2, twenty runs that all ended with success while two refunds were wrong or missing, hand-offs that went from 0 of 3 complete to 3 of 3, case facts that went from 0 of 9 to 9 of 9, and a resumed session told exactly what changed. Then you solve one original exam-style question in which three options are traps, take Module 3 home on one page, and move on to Lab 3 and the Module 3 quiz.

By the end of this lesson you can:

• Spot Module 3's six classic traps.
• Know the fix each one hides.
• Hold Module 3 on one page.

Hands-on lab for this module. The full instructions are below; the ZIP in Resources holds the starter project, the reference solution and the self-check tests.

One agent that searches and reads everything ends up with every page in its context. A coordinator with subagents splits the work: the coordinator plans, briefs and answers; each subagent does one focused job in a fresh context and hands back a short report. This lesson builds that with the Agent SDK: two research tools over a fixed local corpus, a searcher and an analyst defined as subagents, and a coordinator that is only allowed to delegate. You see the exact prompt each subagent receives, which is everything it knows, and you watch the coordinator call both subagents for a broad question and only one for a narrow one. An exam-style question closes it: a date limit that never reached the subagent.

By the end of this lesson you can:

• Build a coordinator with subagents.
• Brief subagents with everything.
• Pick subagents by the question.

A subagent knows exactly one thing about its job: the prompt it's given. So what happens to your sources when one subagent hands its work to the next? This lesson moves Harborline's research subagents into one shared file of AgentDefinitions (a description for when to use each one, a prompt for how it works, its tools and its model), adds a third subagent that writes the answer with no tools at all, and has the coordinator hand it the analyst's findings complete, as JSON, with every claim kept next to its evidence, publisher, date and method. You see the Agent tool's two names (Task at startup, Agent in each call), check it all against the docs, and close with an exam-style question about reports that lost their sources.

By the end of this lesson you can:

• Define subagents with AgentDefinition.
• Give the coordinator the Agent tool.
• Pass findings as structured data.

A broad question has parts that don't depend on each other, so why wait for them one by one? This lesson rewrites the prompt of Harborline's research coordinator as a goal and the criteria for a good answer, instead of fixed steps: split the work so no two subagents cover the same ground, start independent subagents together in one response, and check the answer against the goal, sending a subagent after any missing part. Then one timed run shows it: three searchers start within a second and a half, split by part of the question; two analysts split by source type; and the last lines measure what running together saved. You check it against the docs, see why a split that's too narrow fails quietly, and close with an exam-style question about a report that missed half its topic.

By the end of this lesson you can:

• Run independent subagents together.
• Split the work without overlap.
• Check the answer against the goal.

Some work has steps you know before you start. Some work only shows its steps as you go. This lesson builds both on Harborline's old warehouse package: a fixed review chain written in code (one pass per file, then one pass across the files with the per-file notes) and an open-ended task, planning unit tests, where the agent maps the package first, says when a finding changes its picture, and picks every next step itself. You see why a per-file pass can't catch what sits between files, what the cross-file pass finds instead, check both shapes against Anthropic's own guidance, and close with an exam-style question that asks you to pick the right shape for two different jobs.

By the end of this lesson you can:

• Chain fixed steps in code.
• Review per file, then across files.
• Map first, then adapt the plan.

An agent uses the tools it's given. Hand a writer a search tool and it starts researching; hand a reader a fetch that takes any address and it reaches pages nobody searched for. This lesson gives each of Harborline's research subagents only its role's tools. The analyst's generic fetch_url becomes load_document, which loads only sources a search returned in this run and says what to do when it refuses. The synthesizer gets one narrow tool, verify_fact, to check a figure against its source, while anything bigger goes back through the coordinator. Tests prove the limits without calling Claude, a real run shows every subagent staying in its role, and the official docs and an exam-style question close it out.

By the end of this lesson you can:

• Give each subagent its role's tools.
• Swap generic tools for constrained ones.
• Add a scoped tool, and route the rest.

A real search times out sometimes. What matters is what happens next. This lesson makes one of Harborline's research tools fail on purpose, for one topic, and follows that failure through every agent. The tool returns a structured error: what failed, the query, what came back before it stopped, and what to try instead. Tests tell a failure apart from a search that simply found nothing. The searcher retries before it gives up and reports only what it couldn't fix, the coordinator carries on with everything else, and the answer says what it doesn't cover, and why. You check it against Anthropic's engineering article on its multi-agent research system, and close with an exam-style question about reports that claim nothing exists when the search never finished.

By the end of this lesson you can:

• Return errors with context.
• Recover locally, and report the rest.
• Say what the answer doesn't cover.

A research report is only as good as the trail behind each claim. This lesson changes Harborline's research pipeline so the last agent returns its report as data: every established claim with its URL and date, every contested topic with all of its figures, each with its source, date and method, and a line on why they differ. Code renders that data into the report people read, answer first, with a table for each disagreement, and checks provenance before anyone reads a word. You see why two return rates must stay side by side instead of being averaged, how dates tell a change over time from a conflict, what a source with no stated method is worth, check it all against Anthropic's own guidance, and close with an exam-style question about a report that averaged two figures nobody should have averaged.

By the end of this lesson you can:

• Keep every claim with its source.
• Show conflicting figures side by side.
• Structure the report to be read.

A multi-agent run is long, and it keeps its state in memory. If the process dies halfway, a restart repeats every search and every read, and pays for them twice. This lesson saves each subagent's report to its own file the moment it arrives, with a manifest written atomically, then crashes a real run on purpose and resumes it from the manifest: the saved reports go into the coordinator's prompt, and only the lost work is redone. It also keeps the state that's easy to forget (the URLs searches returned, which load_document needs) and makes hand-overs compact: structured findings with metadata and a relevance score, and no reasoning. Tests prove the run state without calling Claude, and the official engineering post and an exam-style question close it out.

By the end of this lesson you can:

• Save each agent's work as it lands.
• Resume a crashed run from its manifest.
• Pass facts, not reasoning, downstream.

Two figures for one question: 24.0% of order value and 17.6% of units sold. Each one stays in the report with its source, its date and its method. An average would have sounded reasonable, and Module 4's exam traps work the same way. This lesson covers the module's seven classic traps: hand out every tool, assume shared memory, blame the synthesizer, one shape for every task, swallow or abort, pick a winner, and start over. Each one is checked against the docs pages behind Lessons 4.1 to 4.8 and against the module's own runs: an analyst that could only load what the searchers found, a subagent whose prompt carried every constraint, a hand-over of 21 findings as JSON, a gap search sent out before the synthesizer wrote, a chain and an exploration side by side, three timeouts that ended up named in the answer, a contested table instead of an average, and a crashed run that resumed with three reports already saved. Then you solve one original exam-style question in which three options are traps, take Module 4 home on one page, and move on to Lab 4 and the Module 4 quiz.

By the end of this lesson you can:

• Spot Module 4's seven classic traps.
• Know where a multi-agent failure really starts.
• Hold Module 4 on one page.

Hands-on lab for this module. The full instructions are below; the ZIP in Resources holds the starter project, the reference solution and the self-check tests.

Claude Code can read, run and change a real repository, so how you work with it matters as much as what you ask. This lesson builds one small feature in Harborline's repo, start to finish, the way Anthropic's best practices recommend: explore and plan in plan mode, read the plan before any code exists, approve it into the permission mode that fits the risk, let Claude implement and test against the plan, then commit. Along the way you cycle through the permission modes with Shift+Tab, see what fills the context window with /context, shrink it with a focused /compact, start fresh with /clear and bring a session back with /resume and claude --continue. You check each idea against the docs, and close with an exam-style question about a change that should have started in plan mode.

By the end of this lesson you can:

• Explore, plan, code, commit.
• Pick the permission mode for the risk.
• Keep context and sessions under control.

Claude Code starts every session with a fresh context, so what it knows about your team comes from instruction files called CLAUDE.md. Where you put each instruction decides who gets it. In this lesson you write the team's rules into your own user file and see that only you get them; move them into a short project CLAUDE.md with @path imports of topic files, committed with the code; give the support folder its own CLAUDE.md that loads on demand; and trim your user file to what's really personal. Then you check what loaded with /memory and /context, watch the folder's file load the moment Claude touches it, and run a teammate's check in a fresh clone of the repo: nothing before the commit, every team rule after it. You check each idea against the docs, and close with an exam-style question about standards a new hire never receives.

By the end of this lesson you can:

• Put each instruction at the right level.
• Keep CLAUDE.md short with imports.
• Check what loaded, and fix what didn't.

Everything in CLAUDE.md, and everything it imports, loads at launch in every session, whether or not it matters to the task. This lesson moves topic rules into .claude/rules/ and scopes them with a paths: list of globs, so a rule enters the context only when Claude reads, writes or edits a file it governs. In Harborline's repo you write two rules, one for the tests and one for tool definitions that live in three different folders, then watch them load: a file outside their paths gets no rules, a test file brings in the testing rule, and the MCP server brings in the tool rule. You check how the docs describe rules and their loading, learn when a folder's own CLAUDE.md fits better, commit the rules for the team, and close with an exam-style question about conventions that should follow a kind of file, not a folder.

By the end of this lesson you can:

• Split instructions into rule files.
• Scope a rule to the files it governs.
• Choose a path rule or a folder's CLAUDE.md.

Every team repeats itself: run this test file, then the whole suite; review these tool descriptions against our rules. Typed by hand each time, those asks drift. This lesson turns them into one line that runs the same way for everyone. You write a project command, /run-tests, whose front matter sets an argument hint and pre-approves the project's own pytest command, so it runs without a single permission prompt. You write a forked skill, /review-tool-descriptions, that runs in an Explore subagent with a context of its own and finds a real gap in Harborline's tools, while only its answer reaches your conversation. And you add a personal variant in your home folder, under its own name, so it never shadows the team's skill. You check each idea against the Claude Code docs, commit and push the two project files, and close with an exam-style question about a verbose workflow that every developer should run on demand.

By the end of this lesson you can:

• Turn a workflow into a slash command.
• Write a forked skill with its own tools.
• Pick skill, CLAUDE.md, project or personal.

Every change you hand to Claude Code raises the same question: should it plan first, or just do it? In this lesson you learn to decide per task. You weigh four signals (how many files, who calls the code, how many sensible designs, and whether the diff fits in one sentence), and you see why discovery belongs in the Explore subagent's own context. Then you do one task each way in Harborline's repo: a one-line free-shipping fix that goes straight to direct execution with its test, and the retirement of an old compatibility shim that starts in plan mode, with Explore finding every dependent, a plan you read and approve, and a build that passes the whole suite. You check each idea against the docs, and close with an exam-style question about three tasks that each need a different way of working.

By the end of this lesson you can:

• Go direct on a clear, small change.
• Plan first when files, risk or designs multiply.
• Let Explore do the searching.

Describe a change in prose, and Claude fills the gaps by guessing. Is 10/08 October 8th or August 10th? Is ET a fixed offset, or does daylight saving apply? Each guess can be reasonable and still be wrong. This lesson turns a fuzzy change into an exact one, in a few short loops. You ask Claude to interview you before it writes anything, and it asks nine questions, one of them about something you hadn't considered. You answer in one message, because the answers interact, and you pin the format with three concrete input and output examples. Claude writes the tests first: five of the six fail as expected, and one passes for the wrong reason, which is exactly why you watch tests fail first. Then Claude makes them pass, the whole suite stays green, one more independent example goes on its own, and you commit and push. You check each idea against the Claude Code docs, and close with an exam-style question about a format that prose keeps getting wrong.

By the end of this lesson you can:

• Let Claude interview you first.
• Pin the change with examples and tests.
• Iterate on failures, bundled or one by one.

Real repositories don't fit in one context. As Claude reads file after file, its answers can turn confident and generic, earlier findings slip, and new answers quietly contradict old ones. This lesson shows the habits that keep exploration specific. You learn the signs of context degradation, send the noisy reading to Explore subagents that work in contexts of their own, keep a scratchpad file of specific findings, compact with a focus, and work in phases. In Harborline's repo you map how a refund request travels through the code: three Explore subagents report on three folders, Claude writes the path and the open questions to notes/exploration.md, you compact, and phase two starts from the file and answers its first open question down to one line of code. You check each habit against the Claude Code docs, commit the notes file, and close with an exam-style question about a second phase that went wrong.

By the end of this lesson you can:

• Spot context degradation.
• Split exploration across subagents.
• Carry findings through a scratchpad, phase by phase.

A developer agent lives or dies on tool choice. Grep finds text, not meaning: ask where a function is defined, and a package that imports it under another name has nothing for a text search to find. In this lesson you build a small developer tool the way the exam's Scenario 4 describes it. First an MCP server, codemap, whose two tools read the code's structure with Python's own parser: one lists what a package exports, the other follows re-exports and renames to the real definition. Their descriptions say what each tool returns, and when to use it instead of Grep. Then an Agent SDK agent that gets Claude Code's built-in tools by name, plus codemap, with exactly what may run pre-approved and everything else refused. You ask it where a renamed function really lives (three turns, and not one Grep), then have it write an adapter and its test. It never runs its tests, and says so, so you check its claim with the whole suite before you commit. You check each idea against the Agent SDK docs, and close with an exam-style question about an agent that keeps choosing Grep.

By the end of this lesson you can:

• Give an SDK agent built-in tools plus your MCP server.
• Write tool descriptions the agent prefers over Grep.
• Map legacy code and generate tested boilerplate.

Claude reads one test file, and one line appears: Loaded .claude/rules/testing.md. The team's testing rules arrive for the files they cover, and only then. Most of Module 5's exam traps turn on exactly this: where an instruction lives, and when it loads. This lesson covers the module's eight classic traps: keep it personal, invent a config file, the wrong home for the knowledge, a CLAUDE.md in every folder, one way of working, say it louder, one long conversation, and force the tool. Each one is checked against the docs pages behind Lessons 5.1 to 5.8 and against the module's own sessions: a teammate's clone before and after a commit, the real files that hold instructions, a project skill next to a personal variant, rules that loaded only for their files, one fix done directly and one planned, an interview and tests written first, a codebase explored in phases, and an agent that chose its MCP tool over Grep. You also get the one question that settles most of them, solve one original exam-style question in which three options are traps, take Module 5 home on one page, and move on to Lab 5 and the Module 5 quiz.

By the end of this lesson you can:

• Spot Module 5's eight classic traps.
• Ask who needs it, and when.
• Hold Module 5 on one page.

Hands-on lab for this module. The full instructions are below; the ZIP in Resources holds the starter project, the reference solution and the self-check tests.

A CI job is a script on a machine nobody is watching. There's no one to answer a question, approve a tool or read a friendly paragraph, and if Claude Code stops to ask, the job hangs. This lesson runs Claude Code the way a pipeline does. You pipe a teammate's diff into claude -p and get one answer and an exit code. You write a findings schema, and the review comes back as JSON in exactly that shape: four findings, each with its file, line, category, severity, issue and fix, plus the run's turns, cost and session ID. Then you check where a headless run gets your project's rules: plain -p quotes both convention files through CLAUDE.md's imports, --bare says there are none, and passing CLAUDE.md as a system prompt file brings only its two import lines. You check each idea against the Claude Code docs, and close with an exam-style question about a CI step that posted error messages as reviews.

By the end of this lesson you can:

• Run Claude Code headless with -p.
• Get findings as schema-checked JSON.
• Give a CI run the project's rules.

A review only helps if it runs on every change, and only if people keep reading it. In this lesson you turn the last lesson's headless review into a pipeline that runs on every pull request. A GitHub Actions workflow triggers on opened and synchronize, grants the job only the permissions it needs, and reads the API key from the repository's secrets. A review script runs claude -p with JSON output checked against a schema, and posts each finding as an inline comment on its exact line, with the rest listed in the summary. Then the teammate pushes a fix. The second run gets its own earlier findings back in the prompt, marks each one new or still open, and posts nothing twice: its summary reads 0 new, 0 still open, 3 fixed. You check the pipeline against the Claude Code docs on GitHub Actions, see the packaged action that does the same job, and close with an exam-style question about a review bot that repeats itself on every push.

By the end of this lesson you can:

• Run a review on every pull request.
• Post findings as inline comments.
• Re-review without repeating yourself.

A reviewer nobody trusts is worse than none: developers learn to skip its comments, and the real bug goes out with the nitpicks. Adjectives don't fix that. "Thorough", "conservative", "only when you're confident": each one leaves the decision to the model's own judgment, which nobody has measured. In this lesson you tune the pull-request reviewer from Lesson 6.2 on a teammate's branch with one real problem in it. You move the criteria into a file the team owns, measure the vague version by running it more than once on the same diff, and add a switch that turns a noisy category off in config while its rules are fixed. Then you replace the adjectives with categorical criteria: what to report, what to skip even when it's noticed, and severity levels anchored by code examples from this codebase. The rounding bug that came back as medium under the vague prompt comes back as high in both runs of the explicit one. You check the idea against the prompting best practices, and close with an exam-style question about a reviewer that still posts "consider" comments.

By the end of this lesson you can:

• Replace "be conservative" with report/skip rules.
• Anchor severity with real code examples.
• Switch off a noisy category while you fix it.

After Lesson 6.3 the pull-request reviewer reports the right kinds of problems, but the same diff still comes back in a different shape from run to run: one mistake split into two findings, the same line filed as a bug and then as a convention break. Output like that can't be counted or compared, and anything that tracks findings from one run to the next depends on that shape. In this lesson you measure the drift on a teammate's commit (three findings, then four), then add a few-shot block to the criteria file: one rule line, the format in words, and four short examples. Two examples show a real issue with the exact finding they want, and one says why the plausible alternative loses ("not a second bug finding for the crash: it has the same root cause"). Two show acceptable code answered "None", with the reason. The same diff then gives the same two findings in both runs, and a diff the examples have never seen shows the model generalizing instead of copying. You check the idea against the prompting best practices, and close with an exam-style question about a reviewer whose findings change shape between runs.

By the end of this lesson you can:

• Show the choice, not just the rule.
• Pin the format with examples.
• Put acceptable code next to real issues.

One review pass over a big change spreads its attention thin, and a session that wrote the code reviews its own reasoning. In this lesson you turn the pull-request reviewer from Lessons 6.2 to 6.4 into a small review system. Every file gets its own pass; one cross-file pass looks only at what spans files; and a separate instance, which wrote none of the findings, checks each one against the code and returns a verdict and a confidence. Confident findings become inline comments, and the rest go to the summary for a person to check. Then you run it on a teammate's branch where each of the two files is reasonable on its own, and the bug lives between them: a report that prints $695.00 for a $6.95 fee. You check the idea against the Claude Code best practices, and close with an exam-style question about a reviewer whose wrong comments made developers ignore all of them.

By the end of this lesson you can:

• Review with a fresh, independent instance.
• Split a big change: per-file and cross-file passes.
• Verify findings and route them by confidence.

Generated tests sound like free coverage, but a test that repeats one the module already has, or ignores how the team builds its tests, adds maintenance, not safety. And a reviewer whose rejected findings nobody counts never improves. In this lesson you write the team's testing standards into the project's CLAUDE.md, where every CI run reads them, and build a small generator that hands Claude the module's existing tests and makes every new test say, in a why_new field, which behavior none of them covers. It never writes over an unreviewed draft, and it runs what it generates. On Harborline's normalize module it adds five tests, each with a claim you can check, and the whole suite passes. Then you give every review finding a detected_pattern, log three real reviews, dismiss a finding the way a developer would, and read the dismissals per pattern, including two names for the same kind of problem. You check the idea against the Claude Code docs on running Claude in your own CI, and close with an exam-style question about generated tests that duplicate existing ones and ignore fixture conventions.

By the end of this lesson you can:

• Put testing standards where CI reads them.
• Give existing tests so new ones add coverage.
• Learn from dismissed findings by pattern.

Four review passes over a two-file change, and the bug that lives between the files comes back: found by the cross-file pass, and confirmed by a separate check. Module 6 built that pipeline one piece at a time, and most of its exam traps are a shortcut that skips one of those pieces. This lesson covers the module's eight classic traps: invent a flag, assume the context, parse the prose, say it all again, just be careful, ask for consistency, one bigger pass, and more tests. Each one is checked against the docs pages behind Lessons 6.1 to 6.6 and against the module's own runs: claude -p in a pipe, a run that loaded the conventions and one that ran bare, findings as data in structured_output, a prompt that carries the earlier findings, vague words against explicit criteria, two runs that agreed only once examples were added, a cross-file pass and a confidence check, and generated tests that each say why they're new. You also get the one question that settles most of them, solve one original exam-style question in which three options are traps, take Module 6 home on one page, and move on to Lab 6 and the Module 6 quiz.

By the end of this lesson you can:

• Spot Module 6's eight classic traps.
• Ask what makes the pipeline sure.
• Hold Module 6 on one page.

Hands-on lab for this module. The full instructions are below; the ZIP in Resources holds the starter project, the reference solution and the self-check tests.

A supplier document has to become data that code can use, not a paragraph someone has to parse. In this lesson you build Harborline's extractor in three steps. First, a tool that nothing runs: its input schema is exactly the record you keep, a forced tool_choice makes Claude call it, and the record is read straight from the tool_use block. Then two kinds of documents, invoices and credit notes, with tool_choice any, and a pro-forma that gets filed as an invoice to pay, because any must pick a tool. Then the fix: a forced extract_metadata call classifies the document first, with an enum that can say other, and strict schemas guarantee every record's shape. The last run shows what a schema can't promise: a record that is valid and still wrong. You check each idea against the Claude docs, see what's true today about forced tool choice, and close with an exam-style question about quotations that end up in accounts payable.

By the end of this lesson you can:

• Make the schema the output.
• Classify first, then extract.
• Know what a schema can't promise.

When every field is required, the schema itself asks the model to invent. In this lesson you move the extraction record into Pydantic (extraction/schema.py), build the strict tools from the models with the SDK's transform_schema(), and watch two documents that lack data: a letter with no purchase order and no due date comes back with "<UNKNOWN>" placeholders, and a scan with an illegible total comes back with -1. Then you make every field a document may lack nullable, give the type enum unclear and an other with a detail field, and the same documents come back with null where the source is silent, while a pro-forma invoice is skipped with a detail that says what it is. Finally the format rules go in the prompt, next to the schema: dates as YYYY-MM-DD read by each supplier's convention, decimal commas as plain numbers, ISO currency codes. You check each idea against the Claude docs, and close with an exam-style question about required fields that invite fabrication.

By the end of this lesson you can:

• Let the schema say "not stated".
• Give "other" and "unclear" a place to go.
• Put the format rules next to the schema.

A strict schema guarantees the shape of a record, not its values. In this lesson you add the checks a schema can't make, and a retry that can actually help. Checked puts Pydantic validators on Lesson 7.2's record: dates must be YYYY-MM-DD, and every line's quantity times unit price must equal its amount. When a check fails, the next request carries the document, the failed output and the exact errors, written to carry the evidence. Then four documents, four outcomes: a misread quantity fixed on the second attempt; a reading the model keeps three times, sent to a person instead of looping; an illegible total that no retry should invent; and an invoice whose own totals disagree, flagged with conflict_detected. You check each idea against the Claude docs, and close with an exam-style question about a team that plans to retry every failed record.

By the end of this lesson you can:

• Check what the schema can't.
• Retry with the evidence, and stop in time.
• Flag documents that disagree with themselves.

Rules describe what you want; examples show it. In this lesson you measure before you change anything: dev_check.py runs the twelve labeled dev documents through Lesson 7.3's extract_checked() and lists every value that doesn't match its label. Before any examples: 9 of 12 exact and 7 wrong values, all of them informal quantities and units in prose, tables and emails. Then you write five short examples, one per layout, each with the exact output and a note on the wrong answer it rules out, and send them with every request. The same twelve documents come back 12 of 12. You check each idea against the Claude docs, and close with an exam-style question about a pipeline whose detailed rules haven't fixed informal quantities.

By the end of this lesson you can:

• Measure a labeled dev set before you change the prompt.
• Show each layout with the exact output.
• Make informal quantities consistent.

A hundred supplier invoices a night don't need an answer in seconds, so why pay for one? In this lesson you move the extraction from one document at a time to the whole batch folder with the Message Batches API: half the price, no latency promise. extract.py gets request(), the parameters of one forced call, so the same request works on its own and inside a batch; validate.py gets finish(). Then you type extraction/batch.py: two batches (classify, then record), every result matched by its custom_id, and only the failures sent again, each with its fix: two invoices too long for one reply go back in parts and come back joined. The real run: 100, then 94, then 38 requests, 85 documents ok, about five cents at batch prices. You check each idea against the Claude docs, work out how often a batch must go out to meet a deadline, and close with an exam-style question about matching results and resubmitting failures.

By the end of this lesson you can:

• Know what a batch trades for half the price.
• Batch the work nobody is waiting on.
• Resubmit only what failed, with a fix.

Last lesson's batch is 98.8% right, and one field, the supplier's name, is right only about six times in ten. In this lesson you measure the month against its labels and look past the average: you type extraction/review.py, which compares every value with its label and prints the accuracy overall, by layout and by field. Each field's accuracy in each layout becomes its measured confidence. Records the batch flagged, and records with a field below the target for their layout, go to a person, with the weak fields named. Everything else is trusted, and a few trusted records per layout are still sampled at random on every run. The real result: 42 records routed for low confidence, 9 flagged by the batch, 4 random samples, and 43 records trusted. You check the method against the Claude docs on building evaluations, see why a small slice is a weak estimate, and close with an exam-style question about whether to stop sampling.

By the end of this lesson you can:

• Look past the average.
• Route by measured confidence.
• Keep sampling what you trust.

A hundred supplier documents, read, checked and matched back to their files, for half the price: 85 records okay, nine for a person, and six skipped. Module 7 built that pipeline one piece at a time, and most of its exam traps are a shortcut that skips one of those pieces. This lesson covers the module's eight classic traps: ask for JSON, fill every field, strict means right, retry until it works, more rules, batch the blocking work, resubmit everything, and trust the average. Each one is checked against the docs pages behind Lessons 7.1 to 7.6 and against the module's own runs: a pro-forma that came back as an invoice to pay, a placeholder and a total of -1 where the document said nothing, a strict record that was valid and wrong, a retry that fixed one reading and a cap that sent another to a person, a dev set that went from 9 of 12 to 12 of 12 with examples, the deadline math for a batch, two long invoices sent back in parts, and accuracy measured by layout and field. You also get the one question that settles most of them, solve one original exam-style question in which three options are traps, take Module 7 home on one page, and move on to Lab 7 and the Module 7 quiz.

By the end of this lesson you can:

• Spot Module 7's eight classic traps.
• Ask what makes each value trustworthy.
• Hold Module 7 on one page.

Hands-on lab for this module. The full instructions are below; the ZIP in Resources holds the starter project, the reference solution and the self-check tests.

Every question on the exam sits inside a scenario, and each scenario describes a whole system. This course built one of each, in one repository called Harborline. In this lesson you walk it, system by system. First the map: two foundations (the raw loop and harborline-mcp), then six systems, each placed on its exam scenario and its domains. Then the exam guide's own pages: the blueprint, the six scenarios, and the advice on how to prepare. In the hands-on you read the repository's history as one line of real commits, stop once in each system's code at the lines that matter, and run three of them again: the whole test suite, the support agent on one ticket, one invoice through extraction, and last month's review report. The lesson closes with an exam-style question that spans three systems.

By the end of this lesson you can:

• Walk Harborline's six systems.
• Place each one on its scenario and domains.
• Run the pieces once more, end to end.

Two of the six exam scenarios share one set of domains. A customer support resolution agent and a multi-agent research system both lean on agentic architecture, tool design and context management: 60% of the exam's weight. This sprint recalls the eleven rules from Modules 1 to 5 that carry most of their questions, each with the trap that sounds right: the agentic loop, enforcement and hand-offs, hooks, escalation, long conversations, sessions, coordinators and subagents, decomposition, tools, errors, and provenance. Then the docs pages behind them, and replays from our own runs: a gate that blocked every unverified lookup, a hook that stopped a $649 refund, hand-offs a person can act on, case facts kept 9 of 9, subagents that each got only their prompt, a run that named its gaps, and two sources kept side by side. You finish with one original exam-style question in which three options sound right.

By the end of this lesson you can:

• Recall the rules behind Scenarios 1 and 3.
• Spot the traps that sound right.
• Apply them to a stem from either scenario.

Three exam scenarios run on one tool. Code generation, developer productivity, and code review in CI all run on Claude Code, and its configuration and workflows are a fifth of the exam. This sprint recalls the eleven rules from Modules 2, 5 and 6 that carry most of their questions, each with the trap that sounds right: the CLAUDE.md hierarchy, path rules, commands and skills, plan mode, iterative refinement, large codebases, MCP and the built-in tools, Claude Code in CI, explicit criteria, few-shot examples, and multi-pass review. Then the docs pages behind them, and replays from our own runs: /memory showing what loaded, path rules loading on a match, a forked skill finding a gap, a plan approved before 118 tests passed, tests written first, a findings file and /compact, an MCP tool picked over Grep, a review as structured output, explicit criteria, examples that made two runs agree, and a cross-file bug confirmed at 0.97. You finish with one original exam-style question in which three options sound right.

By the end of this lesson you can:

• Recall the rules behind Scenarios 2, 4 and 5.
• Spot the traps that sound right.
• Apply them to a stem from any of the three.

Scenario 6, structured data extraction, leans on two domains: prompt engineering and structured output, and context management and reliability. The second one is also a primary domain of Scenarios 1, 2 and 3, so its rules pay off almost anywhere. This sprint recalls eleven rules, six from Module 7 and five from Domain 5, each with the trap that sounds right: structured output, schemas, validation and retry, few-shot for documents, batches, human review, long conversations, escalation, errors across agents, large codebases, and provenance. Then the docs pages behind them, and replays from our own runs: a pro-forma skipped as other, a total that came back null instead of a guess, a retry that carried the exact error, a dev set that went to 12 of 12, a resubmission of only the failures, and one field right only 61.7% of the time inside an average of 98.8%. You finish with one original exam-style question about a subagent that times out and returns an empty success.

By the end of this lesson you can:

• Recall the rules behind Scenario 6.
• Recall Domain 5 across every scenario.
• Apply them to a mixed stem.

You've covered all five domains. This lesson is about the exam itself. It starts with the exam on one screen: the format, the score and the non-disclosure agreement. Then five moves for every question: carry the scenario, find the ask, find the deciding constraint, eliminate each wrong option with a reason, and choose what meets the constraint. You'll also learn how to judge a multiple-response question and how to keep a clock of sixty questions in 120 minutes. You read the official exam guide's own pages on scoring, retakes, conduct, the NDA and renewal, and reason through its twelve sample questions with the five moves. In the hands-on, Claude Code writes your one-page exam-day plan from the guide and the course cheat sheets: items per domain, the lessons to review, four checkpoints and a practice-exam tracker. You check three things by hand, one check finds a lesson the plan left out, and one line fixes it. The lesson closes with an exam-style multiple-response question and the next steps to booking.

By the end of this lesson you can:

• Carry the scenario and find the deciding constraint.
• Eliminate with reasons, and handle the questions that ask for two.
• Pace sixty questions in 120 minutes, and know the rules.

How the full exam simulation works: sixty original questions in four scenarios, answered at exam pace. Take the simulation quiz first, closed book, then watch the walkthrough videos.

Part of the full exam simulation. Take the simulation quiz first, closed book, then watch this walkthrough of the answers.

Part of the full exam simulation. Take the simulation quiz first, closed book, then watch this walkthrough of the answers.

Part of the full exam simulation. Take the simulation quiz first, closed book, then watch this walkthrough of the answers.

Part of the full exam simulation. Take the simulation quiz first, closed book, then watch this walkthrough of the answers.