Reference · Preparation Exercises

Hands-On Preparation Exercises

Source: official exam guide PDF, v0.1, "Preparation Exercises" section. These are Anthropic's own recommended hands-on exercises — reproduced here with pointers back to the lessons that cover each prerequisite concept. Build these for real; reading about a hook is not the same as watching one block a call.

Exercise 1: Build a Multi-Tool Agent with Escalation Logic

Objective: practice designing an agentic loop with tool integration, structured error handling, and escalation patterns.

1. Define 3–4 MCP tools with detailed descriptions that clearly differentiate each tool's purpose, expected inputs, and boundary conditions. Include at least two tools with similar functionality that require careful description to avoid selection confusion. (Lesson 8)
2. Implement an agentic loop that checks stop_reason to determine whether to continue tool execution or present the final response. Handle both "tool_use" and "end_turn" correctly. (Lesson 1)
3. Add structured error responses to your tools: include errorCategory (transient/validation/permission), an isRetryable boolean, and human-readable descriptions. Test that the agent handles each error type appropriately — retrying transient errors, explaining business errors to the user. (Lesson 8)
4. Implement a programmatic hook that intercepts tool calls to enforce a business rule (e.g. blocking operations above a threshold amount), redirecting to an escalation workflow when triggered. (Lesson 3)
5. Test with multi-concern messages (requests involving multiple issues) and verify the agent decomposes the request, handles each concern, and synthesizes a unified response. (Lesson 3, Lesson 13)

Domains reinforced: Domain 1, Domain 2, Domain 5.

Exercise 2: Configure Claude Code for a Team Development Workflow

Objective: practice configuring CLAUDE.md hierarchies, custom slash commands, path-specific rules, and MCP server integration for a multi-developer project.

1. Create a project-level CLAUDE.md with universal coding standards and testing conventions. Verify instructions placed at the project level are consistently applied across all team members. (Lesson 5)
2. Create .claude/rules/ files with YAML frontmatter glob patterns for different code areas — e.g. paths: ["src/api/**/*"] for API conventions, paths: ["**/*.test.*"] for testing conventions. Test that rules load only when editing matching files. (Lesson 5)
3. Create a project-scoped skill in .claude/skills/ with context: fork and allowed-tools restrictions. Verify the skill runs in isolation without polluting the main conversation context. (Lesson 6)
4. Configure an MCP server in .mcp.json with environment variable expansion for credentials. Add a personal experimental MCP server in ~/.claude.json and verify both are available simultaneously. (Lesson 9)
5. Test plan mode versus direct execution on tasks of varying complexity: a single-file bug fix, a multi-file library migration, and a new feature with multiple valid implementation approaches. Observe when plan mode actually provides value. (Lesson 7)

Domains reinforced: Domain 3, Domain 2.

Exercise 3: Build a Structured Data Extraction Pipeline

Objective: practice designing JSON schemas, using tool_use for structured output, implementing validation-retry loops, and designing batch processing strategies.

1. Define an extraction tool with a JSON schema containing required and optional fields, an enum with an "other" + detail string pattern, and nullable fields for information that may not exist in source documents. Process documents where some fields are absent and verify the model returns null rather than fabricating values. (Lesson 11)
2. Implement a validation-retry loop: when schema validation fails, send a follow-up request including the document, the failed extraction, and the specific validation error. Track which errors are resolvable via retry (format mismatches) versus which are not (information absent from source). (Lesson 11)
3. Add few-shot examples demonstrating extraction from documents with varied formats (inline citations vs. bibliographies, narrative descriptions vs. structured tables) and verify improved handling of structural variety. (Lesson 10)
4. Design a batch processing strategy: submit a batch of 100 documents using the Message Batches API, handle failures by custom_id, resubmit failed documents with modifications (e.g. chunking oversized documents), and calculate total processing time relative to SLA constraints. (Lesson 12)
5. Implement a human review routing strategy: have the model output field-level confidence scores, route low-confidence extractions to human review, and analyze accuracy by document type and field to verify consistent performance. (Lesson 14)

Domains reinforced: Domain 4, Domain 5.

Exercise 4: Design and Debug a Multi-Agent Research Pipeline

Objective: practice orchestrating subagents, managing context passing, implementing error propagation, and handling synthesis with provenance tracking.

1. Build a coordinator agent that delegates to at least two subagents (e.g. web search and document analysis). Ensure the coordinator's allowedTools includes "Task" and that each subagent receives its research findings directly in its prompt rather than relying on automatic context inheritance. (Lesson 2)
2. Implement parallel subagent execution by having the coordinator emit multiple Task tool calls in a single response. Measure the latency improvement compared to sequential execution. (Lesson 2)
3. Design structured output for subagents that separates content from metadata: each finding should include a claim, evidence excerpt, source URL/document name, and publication date. Verify the synthesis subagent preserves source attribution when combining findings. (Lesson 14)
4. Implement error propagation: simulate a subagent timeout and verify the coordinator receives structured error context (failure type, attempted query, partial results). Test that the coordinator can proceed with partial results and annotate the final output with coverage gaps. (Lesson 14)
5. Test with conflicting source data (two credible sources with different statistics) and verify the synthesis output preserves both values with source attribution rather than arbitrarily selecting one, structuring the report to distinguish well-established from contested findings. (Lesson 14)

Domains reinforced: Domain 1, Domain 2, Domain 5.