Claude Certified Architect – Foundations Preparation Details
The Claude Certified Architect – Foundations (CCAR-F) exam tests practical judgment across the Claude Agent SDK, Claude Code, the Claude API, and Model Context Protocol. This study guide maps every exam objective to official Anthropic documentation so you can prepare domain by domain with verified sources. You can also explore more Claude certification study guides on the Claude category to keep building your skills.
Claude Certified Architect – Foundations Materials
Domain 1: Agentic Architecture & Orchestration (27%)
Task Statement 1.1: Design and implement agentic loops for autonomous task execution
Knowledge of: The agentic loop lifecycle: sending requests to Claude, inspecting stop_reason (“tool_use” vs “end_turn”), executing requested tools, and returning results for the next iteration
Knowledge of: How tool results are appended to conversation history so the model can reason about the next action
Knowledge of: The distinction between model-driven decision-making (Claude reasons about which tool to call next based on context) and pre-configured decision trees or tool sequences
Skills in: Implementing agentic loop control flow that continues when stop_reason is “tool_use” and terminates when stop_reason is “end_turn”
Skills in: Adding tool results to conversation context between iterations so the model can incorporate new information into its reasoning
Skills in: Avoiding anti-patterns such as parsing natural language signals to determine loop termination, setting arbitrary iteration caps as the primary stopping mechanism, or checking for assistant text content as a completion indicator
Task Statement 1.2: Orchestrate multi-agent systems with coordinator-subagent patterns
Knowledge of: Hub-and-spoke architecture where a coordinator agent manages all inter-subagent communication, error handling, and information routing
How we built our multi-agent research system
Knowledge of: How subagents operate with isolated context—they do not inherit the coordinator’s conversation history automatically
How we built our multi-agent research system
Knowledge of: The role of the coordinator in task decomposition, delegation, result aggregation, and deciding which subagents to invoke based on query complexity
How we built our multi-agent research system
Orchestrate subagents at scale with dynamic workflows
Knowledge of: Risks of overly narrow task decomposition by the coordinator, leading to incomplete coverage of broad research topics
How we built our multi-agent research system
Skills in: Designing coordinator agents that analyze query requirements and dynamically select which subagents to invoke rather than always routing through the full pipeline
How we built our multi-agent research system
Orchestrate subagents at scale with dynamic workflows
Skills in: Partitioning research scope across subagents to minimize duplication (e.g., assigning distinct subtopics or source types to each agent)
How we built our multi-agent research system
Skills in: Implementing iterative refinement loops where the coordinator evaluates synthesis output for gaps, re-delegates to search and analysis subagents with targeted queries, and re-invokes synthesis until coverage is sufficient
How we built our multi-agent research system
Orchestrate subagents at scale with dynamic workflows
Skills in: Routing all subagent communication through the coordinator for observability, consistent error handling, and controlled information flow
Observability with OpenTelemetry
How we built our multi-agent research system
Task Statement 1.3: Configure subagent invocation, context passing, and spawning
Knowledge of: The Task tool as the mechanism for spawning subagents, and the requirement that allowedTools must include “Task” for a coordinator to invoke subagents
Knowledge of: That subagent context must be explicitly provided in the prompt—subagents do not automatically inherit parent context or share memory between invocations
Effective context engineering for AI agents
Knowledge of: The AgentDefinition configuration including descriptions, system prompts, and tool restrictions for each subagent type
Agent SDK reference – TypeScript
Knowledge of: Fork-based session management for exploring divergent approaches from a shared analysis baseline
Skills in: Including complete findings from prior agents directly in the subagent’s prompt (e.g., passing web search results and document analysis outputs to the synthesis subagent)
How we built our multi-agent research system
Effective context engineering for AI agents
Skills in: Using structured data formats to separate content from metadata (source URLs, document names, page numbers) when passing context between agents to preserve attribution
Get structured output from agents
How we built our multi-agent research system
Skills in: Spawning parallel subagents by emitting multiple Task tool calls in a single coordinator response rather than across separate turns
Skills in: Designing coordinator prompts that specify research goals and quality criteria rather than step-by-step procedural instructions, to enable subagent adaptability
How we built our multi-agent research system
Task Statement 1.4: Implement multi-step workflows with enforcement and handoff patterns
Knowledge of: The difference between programmatic enforcement (hooks, prerequisite gates) and prompt-based guidance for workflow ordering
Intercept and control agent behavior with hooks
Knowledge of: When deterministic compliance is required (e.g., identity verification before financial operations), prompt instructions alone have a non-zero failure rate
Intercept and control agent behavior with hooks
Knowledge of: Structured handoff protocols for mid-process escalation that include customer details, root cause analysis, and recommended actions
Get structured output from agents
Handle approvals and user input
How we built our multi-agent research system
Skills in: Implementing programmatic prerequisites that block downstream tool calls until prerequisite steps have completed (e.g., blocking process_refund until get_customer has returned a verified customer ID)
Intercept and control agent behavior with hooks
Skills in: Decomposing multi-concern customer requests into distinct items, then investigating each in parallel using shared context before synthesizing a unified resolution
How we built our multi-agent research system
Skills in: Compiling structured handoff summaries (customer ID, root cause, refund amount, recommended action) when escalating to human agents who lack access to the conversation transcript
Get structured output from agents
Handle approvals and user input
Task Statement 1.5: Apply Agent SDK hooks for tool call interception and data normalization
Knowledge of: Hook patterns (e.g., PostToolUse) that intercept tool results for transformation before the model processes them
Intercept and control agent behavior with hooks
Knowledge of: Hook patterns that intercept outgoing tool calls to enforce compliance rules (e.g., blocking refunds above a threshold)
Intercept and control agent behavior with hooks
Knowledge of: The distinction between using hooks for deterministic guarantees versus relying on prompt instructions for probabilistic compliance
Skills in: Implementing PostToolUse hooks to normalize heterogeneous data formats (Unix timestamps, ISO 8601, numeric status codes) from different MCP tools before the agent processes them
Intercept and control agent behavior with hooks
Skills in: Implementing tool call interception hooks that block policy-violating actions (e.g., refunds exceeding $500) and redirect to alternative workflows (e.g., human escalation)
Intercept and control agent behavior with hooks
Handle approvals and user input
Skills in: Choosing hooks over prompt-based enforcement when business rules require guaranteed compliance
Task Statement 1.6: Design task decomposition strategies for complex workflows
Knowledge of: When to use fixed sequential pipelines (prompt chaining) versus dynamic adaptive decomposition based on intermediate findings
Orchestrate subagents at scale with dynamic workflows
How we built our multi-agent research system
Knowledge of: Prompt chaining patterns that break reviews into sequential steps (e.g., analyze each file individually, then run a cross-file integration pass)
Knowledge of: The value of adaptive investigation plans that generate subtasks based on what is discovered at each step
Orchestrate subagents at scale with dynamic workflows
How we built our multi-agent research system
Skills in: Selecting task decomposition patterns appropriate to the workflow: prompt chaining for predictable multi-aspect reviews, dynamic decomposition for open-ended investigation tasks
Orchestrate subagents at scale with dynamic workflows
Skills in: Splitting large code reviews into per-file local analysis passes plus a separate cross-file integration pass to avoid attention dilution
Effective context engineering for AI agents
Skills in: Decomposing open-ended tasks (e.g., “add comprehensive tests to a legacy codebase”) by first mapping structure, identifying high-impact areas, then creating a prioritized plan that adapts as dependencies are discovered
Orchestrate subagents at scale with dynamic workflows
Task Statement 1.7: Manage session state, resumption, and forking
Knowledge of: Named session resumption using –resume <session-name> to continue a specific prior conversation
Knowledge of: fork_session for creating independent branches from a shared analysis baseline to explore divergent approaches
Run parallel sessions with worktrees
Knowledge of: The importance of informing the agent about changes to previously analyzed files when resuming sessions after code modifications
Knowledge of: Why starting a new session with a structured summary is more reliable than resuming with stale tool results
Effective context engineering for AI agents
Skills in: Using –resume with session names to continue named investigation sessions across work sessions
Skills in: Using fork_session to create parallel exploration branches (e.g., comparing two testing strategies or refactoring approaches from a shared codebase analysis)
Run parallel sessions with worktrees
Skills in: Choosing between session resumption (when prior context is mostly valid) and starting fresh with injected summaries (when prior tool results are stale)
Effective context engineering for AI agents
Skills in: Informing a resumed session about specific file changes for targeted re-analysis rather than requiring full re-exploration
Domain 2: Tool Design & MCP Integration (18%)
Task Statement 2.1: Design effective tool interfaces with clear descriptions and boundaries
Knowledge of: Tool descriptions as the primary mechanism LLMs use for tool selection; minimal descriptions lead to unreliable selection among similar tools
Writing effective tools for AI agents—using AI agents
Knowledge of: The importance of including input formats, example queries, edge cases, and boundary explanations in tool descriptions
Writing effective tools for AI agents—using AI agents
Knowledge of: How ambiguous or overlapping tool descriptions cause misrouting (e.g., analyze_content vs analyze_document with near-identical descriptions)
Writing effective tools for AI agents—using AI agents
Knowledge of: The impact of system prompt wording on tool selection: keyword-sensitive instructions can create unintended tool associations
Skills in: Writing tool descriptions that clearly differentiate each tool’s purpose, expected inputs, outputs, and when to use it versus similar alternatives
Writing effective tools for AI agents—using AI agents
Skills in: Renaming tools and updating descriptions to eliminate functional overlap (e.g., renaming analyze_content to extract_web_results with a web-specific description)
Writing effective tools for AI agents—using AI agents
Skills in: Splitting generic tools into purpose-specific tools with defined input/output contracts (e.g., splitting a generic analyze_document into extract_data_points, summarize_content, and verify_claim_against_source)
Writing effective tools for AI agents—using AI agents
Skills in: Reviewing system prompts for keyword-sensitive instructions that might override well-written tool descriptions
Task Statement 2.2: Implement structured error responses for MCP tools
Knowledge of: The MCP isError flag pattern for communicating tool failures back to the agent
Knowledge of: The distinction between transient errors (timeouts, service unavailability), validation errors (invalid input), business errors (policy violations), and permission errors
Connect to external tools with MCP
Knowledge of: Why uniform error responses (generic “Operation failed”) prevent the agent from making appropriate recovery decisions
Writing effective tools for AI agents—using AI agents
Knowledge of: The difference between retryable and non-retryable errors, and how returning structured metadata prevents wasted retry attempts
Skills in: Returning structured error metadata including errorCategory (transient/validation/permission), isRetryable boolean, and human-readable descriptions
Skills in: Including retriable: false flags and customer-friendly explanations for business rule violations so the agent can communicate appropriately
Writing effective tools for AI agents—using AI agents
Skills in: Implementing local error recovery within subagents for transient failures, propagating to the coordinator only errors that cannot be resolved locally along with partial results and what was attempted
How we built our multi-agent research system
Skills in: Distinguishing between access failures (needing retry decisions) and valid empty results (representing successful queries with no matches)
How we built our multi-agent research system
Task Statement 2.3: Distribute tools appropriately across agents and configure tool choice
Knowledge of: The principle that giving an agent access to too many tools (e.g., 18 instead of 4-5) degrades tool selection reliability by increasing decision complexity
Writing effective tools for AI agents—using AI agents
Knowledge of: Why agents with tools outside their specialization tend to misuse them (e.g., a synthesis agent attempting web searches)
How we built our multi-agent research system
Knowledge of: Scoped tool access: giving agents only the tools needed for their role, with limited cross-role tools for specific high-frequency needs
Knowledge of: tool_choice configuration options: “auto”, “any”, and forced tool selection ({“type”: “tool”, “name”: “…”})
Skills in: Restricting each subagent’s tool set to those relevant to its role, preventing cross-specialization misuse
Skills in: Replacing generic tools with constrained alternatives (e.g., replacing fetch_url with load_document that validates document URLs)
Writing effective tools for AI agents—using AI agents
Skills in: Providing scoped cross-role tools for high-frequency needs (e.g., a verify_fact tool for the synthesis agent) while routing complex cases through the coordinator
How we built our multi-agent research system
Skills in: Using tool_choice forced selection to ensure a specific tool is called first (e.g., forcing extract_metadata before enrichment tools), then processing subsequent steps in follow-up turns
Skills in: Setting tool_choice: “any” to guarantee the model calls a tool rather than returning conversational text
Task Statement 2.4: Integrate MCP servers into Claude Code and agent workflows
Knowledge of: MCP server scoping: project-level (.mcp.json) for shared team tooling vs user-level (~/.claude.json) for personal/experimental servers
Connect Claude Code to tools via MCP
Knowledge of: Environment variable expansion in .mcp.json (e.g., ${GITHUB_TOKEN}) for credential management without committing secrets
Connect Claude Code to tools via MCP
Knowledge of: That tools from all configured MCP servers are discovered at connection time and available simultaneously to the agent
Connect Claude Code to tools via MCP
Connect to external tools with MCP
Knowledge of: MCP resources as a mechanism for exposing content catalogs (e.g., issue summaries, documentation hierarchies, database schemas) to reduce exploratory tool calls
Connect Claude Code to tools via MCP
Skills in: Configuring shared MCP servers in project-scoped .mcp.json with environment variable expansion for authentication tokens
Connect Claude Code to tools via MCP
Skills in: Configuring personal/experimental MCP servers in user-scoped ~/.claude.json
Connect Claude Code to tools via MCP
Skills in: Enhancing MCP tool descriptions to explain capabilities and outputs in detail, preventing the agent from preferring built-in tools (like Grep) over more capable MCP tools
Writing effective tools for AI agents—using AI agents
Connect Claude Code to tools via MCP
Skills in: Choosing existing community MCP servers over custom implementations for standard integrations (e.g., Jira), reserving custom servers for team-specific workflows
Connect Claude Code to tools via MCP
What is the Model Context Protocol (MCP)?
Control MCP server access for your organization
Skills in: Exposing content catalogs as MCP resources to give agents visibility into available data without requiring exploratory tool calls
Connect to external tools with MCP
Task Statement 2.5: Select and apply built-in tools (Read, Write, Edit, Bash, Grep, Glob) effectively
Knowledge of: Grep for content search (searching file contents for patterns like function names, error messages, or import statements)
Knowledge of: Glob for file path pattern matching (finding files by name or extension patterns)
Knowledge of: Read/Write for full file operations; Edit for targeted modifications using unique text matching
Rewind file changes with checkpointing
Knowledge of: When Edit fails due to non-unique text matches, using Read + Write as a fallback for reliable file modifications
Skills in: Selecting Grep for searching code content across a codebase (e.g., finding all callers of a function, locating error messages)
Set up Claude Code in a monorepo or large codebase
Skills in: Selecting Glob for finding files matching naming patterns (e.g., **/*.test.tsx)
Skills in: Using Read to load full file contents followed by Write when Edit cannot find unique anchor text
Rewind file changes with checkpointing
Skills in: Building codebase understanding incrementally: starting with Grep to find entry points, then using Read to follow imports and trace flows, rather than reading all files upfront
Set up Claude Code in a monorepo or large codebase
Effective context engineering for AI agents
Skills in: Tracing function usage across wrapper modules by first identifying all exported names, then searching for each name across the codebase
Set up Claude Code in a monorepo or large codebase
Domain 3: Claude Code Configuration & Workflows (20%)
Task Statement 3.1: Configure CLAUDE.md files with appropriate hierarchy, scoping, and modular organization
Knowledge of: The CLAUDE.md configuration hierarchy: user-level (~/.claude/CLAUDE.md), project-level (.claude/CLAUDE.md or root CLAUDE.md), and directory-level (subdirectory CLAUDE.md files)
How Claude remembers your project
Knowledge of: That user-level settings apply only to that user—instructions in ~/.claude/CLAUDE.md are not shared with teammates via version control
How Claude remembers your project
Knowledge of: The @import syntax for referencing external files to keep CLAUDE.md modular (e.g., importing specific standards files relevant to each package)
How Claude remembers your project
Set up Claude Code in a monorepo or large codebase
Knowledge of: .claude/rules/ directory for organizing topic-specific rule files as an alternative to a monolithic CLAUDE.md
How Claude remembers your project
Set up Claude Code in a monorepo or large codebase
Skills in: Diagnosing configuration hierarchy issues (e.g., a new team member not receiving instructions because they’re in user-level rather than project-level configuration)
How Claude remembers your project
Skills in: Using @import to selectively include relevant standards files in each package’s CLAUDE.md based on maintainer domain knowledge
How Claude remembers your project
Set up Claude Code in a monorepo or large codebase
Skills in: Splitting large CLAUDE.md files into focused topic-specific files in .claude/rules/ (e.g., testing.md, api-conventions.md, deployment.md)
How Claude remembers your project
Set up Claude Code in a monorepo or large codebase
Skills in: Using the /memory command to verify which memory files are loaded and diagnose inconsistent behavior across sessions
How Claude remembers your project
Task Statement 3.2: Create and configure custom slash commands and skills
Knowledge of: Project-scoped commands in .claude/commands/ (shared via version control) vs user-scoped commands in ~/.claude/commands/ (personal)
Knowledge of: Skills in .claude/skills/ with SKILL.md files that support frontmatter configuration including context: fork, allowed-tools, and argument-hint
Knowledge of: The context: fork frontmatter option for running skills in an isolated sub-agent context, preventing skill outputs from polluting the main conversation
Knowledge of: Personal skill customization: creating personal variants in ~/.claude/skills/ with different names to avoid affecting teammates
Skills in: Creating project-scoped slash commands in .claude/commands/ for team-wide availability via version control
Skills in: Using context: fork to isolate skills that produce verbose output (e.g., codebase analysis) or exploratory context (e.g., brainstorming alternatives) from the main session
Skills in: Configuring allowed-tools in skill frontmatter to restrict tool access during skill execution (e.g., limiting to file write operations to prevent destructive actions)
Skills in: Using argument-hint frontmatter to prompt developers for required parameters when they invoke the skill without arguments
Skills in: Choosing between skills (on-demand invocation for task-specific workflows) and CLAUDE.md (always-loaded universal standards)
How Claude remembers your project
Task Statement 3.3: Apply path-specific rules for conditional convention loading
Knowledge of: .claude/rules/ files with YAML frontmatter paths fields containing glob patterns for conditional rule activation
How Claude remembers your project
Set up Claude Code in a monorepo or large codebase
Knowledge of: How path-scoped rules load only when editing matching files, reducing irrelevant context and token usage
How Claude remembers your project
Knowledge of: The advantage of glob-pattern rules over directory-level CLAUDE.md files for conventions that span multiple directories (e.g., test files spread throughout a codebase)
How Claude remembers your project
Set up Claude Code in a monorepo or large codebase
Skills in: Creating .claude/rules/ files with YAML frontmatter path scoping (e.g., paths: [“terraform/**/*”]) so rules load only when editing matching files
How Claude remembers your project
Set up Claude Code in a monorepo or large codebase
Skills in: Using glob patterns in path-specific rules to apply conventions to files by type regardless of directory location (e.g., **/*.test.tsx for all test files)
How Claude remembers your project
Set up Claude Code in a monorepo or large codebase
Skills in: Choosing path-specific rules over subdirectory CLAUDE.md files when conventions must apply to files spread across the codebase
How Claude remembers your project
Set up Claude Code in a monorepo or large codebase
Task Statement 3.4: Determine when to use plan mode vs direct execution
Knowledge of: Plan mode is designed for complex tasks involving large-scale changes, multiple valid approaches, architectural decisions, and multi-file modifications
Best practices for Claude Code
Knowledge of: Direct execution is appropriate for simple, well-scoped changes (e.g., adding a single validation check to one function)
Best practices for Claude Code
Knowledge of: Plan mode enables safe codebase exploration and design before committing to changes, preventing costly rework
Plan in the cloud with ultraplan
Knowledge of: The Explore subagent for isolating verbose discovery output and returning summaries to preserve main conversation context
Skills in: Selecting plan mode for tasks with architectural implications (e.g., microservice restructuring, library migrations affecting 45+ files, choosing between integration approaches with different infrastructure requirements)
Best practices for Claude Code
Skills in: Selecting direct execution for well-understood changes with clear scope (e.g., a single-file bug fix with a clear stack trace, adding a date validation conditional)
Best practices for Claude Code
Skills in: Using the Explore subagent for verbose discovery phases to prevent context window exhaustion during multi-phase tasks
Skills in: Combining plan mode for investigation with direct execution for implementation (e.g., planning a library migration, then executing the planned approach)
Plan in the cloud with ultraplan
Task Statement 3.5: Apply iterative refinement techniques for progressive improvement
Knowledge of: Concrete input/output examples as the most effective way to communicate expected transformations when prose descriptions are interpreted inconsistently
Use examples (multishot prompting) to guide Claude’s behavior
Best practices for Claude Code
Knowledge of: Test-driven iteration: writing test suites first, then iterating by sharing test failures to guide progressive improvement
Best practices for Claude Code
Knowledge of: The interview pattern: having Claude ask questions to surface considerations the developer may not have anticipated before implementing
Best practices for Claude Code
Handle approvals and user input
Knowledge of: When to provide all issues in a single message (interacting problems) versus fixing them sequentially (independent problems)
Best practices for Claude Code
Skills in: Providing 2-3 concrete input/output examples to clarify transformation requirements when natural language descriptions produce inconsistent results
Use examples (multishot prompting) to guide Claude’s behavior
Best practices for Claude Code
Skills in: Writing test suites covering expected behavior, edge cases, and performance requirements before implementation, then iterating by sharing test failures
Best practices for Claude Code
Skills in: Using the interview pattern to surface design considerations (e.g., cache invalidation strategies, failure modes) before implementing solutions in unfamiliar domains
Best practices for Claude Code
Handle approvals and user input
Skills in: Providing specific test cases with example input and expected output to fix edge case handling (e.g., null values in migration scripts)
Use examples (multishot prompting) to guide Claude’s behavior
Best practices for Claude Code
Skills in: Addressing multiple interacting issues in a single detailed message when fixes interact, versus sequential iteration for independent issues
Best practices for Claude Code
Task Statement 3.6: Integrate Claude Code into CI/CD pipelines
Knowledge of: The -p (or –print) flag for running Claude Code in non-interactive mode in automated pipelines
Run Claude Code programmatically
Knowledge of: –output-format json and –json-schema CLI flags for enforcing structured output in CI contexts
Run Claude Code programmatically
Get structured output from agents
Knowledge of: CLAUDE.md as the mechanism for providing project context (testing standards, fixture conventions, review criteria) to CI-invoked Claude Code
How Claude remembers your project
Knowledge of: Session context isolation: why the same Claude session that generated code is less effective at reviewing its own changes compared to an independent review instance
How we built our multi-agent research system
Skills in: Running Claude Code in CI with the -p flag to prevent interactive input hangs
Run Claude Code programmatically
Skills in: Using –output-format json with –json-schema to produce machine-parseable structured findings for automated posting as inline PR comments
Run Claude Code programmatically
Skills in: Including prior review findings in context when re-running reviews after new commits, instructing Claude to report only new or still-unaddressed issues to avoid duplicate comments
Skills in: Providing existing test files in context so test generation avoids suggesting duplicate scenarios already covered by the test suite
How Claude remembers your project
Best practices for Claude Code
Skills in: Documenting testing standards, valuable test criteria, and available fixtures in CLAUDE.md to improve test generation quality and reduce low-value test output
How Claude remembers your project
Best practices for Claude Code
Domain 4: Prompt Engineering & Structured Output (20%)
Task Statement 4.1: Design prompts with explicit criteria to improve precision and reduce false positives
Knowledge of: The importance of explicit criteria over vague instructions (e.g., “flag comments only when claimed behavior contradicts actual code behavior” vs “check that comments are accurate”)
Knowledge of: How general instructions like “be conservative” or “only report high-confidence findings” fail to improve precision compared to specific categorical criteria
Knowledge of: The impact of false positive rates on developer trust: high false positive categories undermine confidence in accurate categories
Catch security issues as Claude writes code
Skills in: Writing specific review criteria that define which issues to report (bugs, security) versus skip (minor style, local patterns) rather than relying on confidence-based filtering
Skills in: Temporarily disabling high false-positive categories to restore developer trust while improving prompts for those categories
Catch security issues as Claude writes code
Skills in: Defining explicit severity criteria with concrete code examples for each severity level to achieve consistent classification
Use examples (multishot prompting) to guide Claude’s behavior
Task Statement 4.2: Apply few-shot prompting to improve output consistency and quality
Knowledge of: Few-shot examples as the most effective technique for achieving consistently formatted, actionable output when detailed instructions alone produce inconsistent results
Use examples (multishot prompting) to guide Claude’s behavior
Knowledge of: The role of few-shot examples in demonstrating ambiguous-case handling (e.g., tool selection for ambiguous requests, branch-level test coverage gaps)
Use examples (multishot prompting) to guide Claude’s behavior
Knowledge of: How few-shot examples enable the model to generalize judgment to novel patterns rather than matching only pre-specified cases
Use examples (multishot prompting) to guide Claude’s behavior
Knowledge of: The effectiveness of few-shot examples for reducing hallucination in extraction tasks (e.g., handling informal measurements, varied document structures)
Use examples (multishot prompting) to guide Claude’s behavior
Skills in: Creating 2-4 targeted few-shot examples for ambiguous scenarios that show reasoning for why one action was chosen over plausible alternatives
Use examples (multishot prompting) to guide Claude’s behavior
Skills in: Including few-shot examples that demonstrate specific desired output format (location, issue, severity, suggested fix) to achieve consistency
Use examples (multishot prompting) to guide Claude’s behavior
Increase output consistency (JSON mode)
Skills in: Providing few-shot examples distinguishing acceptable code patterns from genuine issues to reduce false positives while enabling generalization
Use examples (multishot prompting) to guide Claude’s behavior
Skills in: Using few-shot examples to demonstrate correct handling of varied document structures (inline citations vs bibliographies, methodology sections vs embedded details)
Use examples (multishot prompting) to guide Claude’s behavior
Skills in: Adding few-shot examples showing correct extraction from documents with varied formats to address empty/null extraction of required fields
Use examples (multishot prompting) to guide Claude’s behavior
Task Statement 4.3: Enforce structured output using tool use and JSON schemas
Knowledge of: Tool use (tool_use) with JSON schemas as the most reliable approach for guaranteed schema-compliant structured output, eliminating JSON syntax errors
Knowledge of: The distinction between tool_choice: “auto” (model may return text instead of calling a tool), “any” (model must call a tool but can choose which), and forced tool selection (model must call a specific named tool)
Knowledge of: That strict JSON schemas via tool use eliminate syntax errors but do not prevent semantic errors (e.g., line items that don’t sum to total, values in wrong fields)
Knowledge of: Schema design considerations: required vs optional fields, enum fields with “other” + detail string patterns for extensible categories
Skills in: Defining extraction tools with JSON schemas as input parameters and extracting structured data from the tool_use response
Skills in: Setting tool_choice: “any” to guarantee structured output when multiple extraction schemas exist and the document type is unknown
Skills in: Forcing a specific tool with tool_choice: {“type”: “tool”, “name”: “extract_metadata”} to ensure a particular extraction runs before enrichment steps
Skills in: Designing schema fields as optional (nullable) when source documents may not contain the information, preventing the model from fabricating values to satisfy required fields
Skills in: Adding enum values like “unclear” for ambiguous cases and “other” + detail fields for extensible categorization
Skills in: Including format normalization rules in prompts alongside strict output schemas to handle inconsistent source formatting
Increase output consistency (JSON mode)
Task Statement 4.4: Implement validation, retry, and feedback loops for extraction quality
Knowledge of: Retry-with-error-feedback: appending specific validation errors to the prompt on retry to guide the model toward correction
Knowledge of: The limits of retry: retries are ineffective when the required information is simply absent from the source document (vs format or structural errors)
Knowledge of: Feedback loop design: tracking which code constructs trigger findings (detected_pattern field) to enable systematic analysis of dismissal patterns
Knowledge of: The difference between semantic validation errors (values don’t sum, wrong field placement) and schema syntax errors (eliminated by tool use)
Increase output consistency (JSON mode)
Skills in: Implementing follow-up requests that include the original document, the failed extraction, and specific validation errors for model self-correction
Skills in: Identifying when retries will be ineffective (e.g., information exists only in an external document not provided) versus when they will succeed (format mismatches, structural output errors)
Skills in: Adding detected_pattern fields to structured findings to enable analysis of false positive patterns when developers dismiss findings
Skills in: Designing self-correction validation flows: extracting “calculated_total” alongside “stated_total” to flag discrepancies, adding “conflict_detected” booleans for inconsistent source data
Task Statement 4.5: Design efficient batch processing strategies
Knowledge of: The Message Batches API: 50% cost savings, up to 24-hour processing window, no guaranteed latency SLA
Knowledge of: Batch processing is appropriate for non-blocking, latency-tolerant workloads (overnight reports, weekly audits, nightly test generation) and inappropriate for blocking workflows (pre-merge checks)
Knowledge of: The batch API does not support multi-turn tool calling within a single request (cannot execute tools mid-request and return results)
Knowledge of: custom_id fields for correlating batch request/response pairs
Skills in: Matching API approach to workflow latency requirements: synchronous API for blocking pre-merge checks, batch API for overnight/weekly analysis
Skills in: Calculating batch submission frequency based on SLA constraints (e.g., 4-hour windows to guarantee 30-hour SLA with 24-hour batch processing)
Skills in: Handling batch failures: resubmitting only failed documents (identified by custom_id) with appropriate modifications (e.g., chunking documents that exceeded context limits)
Skills in: Using prompt refinement on a sample set before batch-processing large volumes to maximize first-pass success rates and reduce iterative resubmission costs
Task Statement 4.6: Design multi-instance and multi-pass review architectures
Knowledge of: Self-review limitations: a model retains reasoning context from generation, making it less likely to question its own decisions in the same session
How we built our multi-agent research system
Knowledge of: Independent review instances (without prior reasoning context) are more effective at catching subtle issues than self-review instructions or extended thinking
Knowledge of: Multi-pass review: splitting large reviews into per-file local analysis passes plus cross-file integration passes to avoid attention dilution and contradictory findings
Effective context engineering for AI agents
Skills in: Using a second independent Claude instance to review generated code without the generator’s reasoning context
Skills in: Splitting large multi-file reviews into focused per-file passes for local issues plus separate integration passes for cross-file data flow analysis
Orchestrate subagents at scale with dynamic workflows
Effective context engineering for AI agents
Skills in: Running verification passes where the model self-reports confidence alongside each finding to enable calibrated review routing
Domain 5: Context Management & Reliability (15%)
Task Statement 5.1: Manage conversation context to preserve critical information across long interactions
Knowledge of: Progressive summarization risks: condensing numerical values, percentages, dates, and customer-stated expectations into vague summaries
Effective context engineering for AI agents
Knowledge of: The “lost in the middle” effect: models reliably process information at the beginning and end of long inputs but may omit findings from middle sections
Effective context engineering for AI agents
Knowledge of: How tool results accumulate in context and consume tokens disproportionately to their relevance (e.g., 40+ fields per order lookup when only 5 are relevant)
Effective context engineering for AI agents
Knowledge of: The importance of passing complete conversation history in subsequent API requests to maintain conversational coherence
Skills in: Extracting transactional facts (amounts, dates, order numbers, statuses) into a persistent “case facts” block included in each prompt, outside summarized history
Effective context engineering for AI agents
Skills in: Extracting and persisting structured issue data (order IDs, amounts, statuses) into a separate context layer for multi-issue sessions
Effective context engineering for AI agents
Skills in: Trimming verbose tool outputs to only relevant fields before they accumulate in context (e.g., keeping only return-relevant fields from order lookups)
Writing effective tools for AI agents—using AI agents
Skills in: Placing key findings summaries at the beginning of aggregated inputs and organizing detailed results with explicit section headers to mitigate position effects
Effective context engineering for AI agents
Skills in: Requiring subagents to include metadata (dates, source locations, methodological context) in structured outputs to support accurate downstream synthesis
How we built our multi-agent research system
Get structured output from agents
Skills in: Modifying upstream agents to return structured data (key facts, citations, relevance scores) instead of verbose content and reasoning chains when downstream agents have limited context budgets
Effective context engineering for AI agents
Get structured output from agents
How we built our multi-agent research system
Task Statement 5.2: Design effective escalation and ambiguity resolution patterns
Knowledge of: Appropriate escalation triggers: customer requests for a human, policy exceptions/gaps (not just complex cases), and inability to make meaningful progress
Handle approvals and user input
How we built our multi-agent research system
Knowledge of: The distinction between escalating immediately when a customer explicitly demands it versus offering to resolve when the issue is straightforward
Handle approvals and user input
Keep Claude in character with role prompting and prefilling
Knowledge of: Why sentiment-based escalation and self-reported confidence scores are unreliable proxies for actual case complexity
Handle approvals and user input
Knowledge of: How multiple customer matches require clarification (requesting additional identifiers) rather than heuristic selection
Handle approvals and user input
Skills in: Adding explicit escalation criteria with few-shot examples to the system prompt demonstrating when to escalate versus resolve autonomously
Use examples (multishot prompting) to guide Claude’s behavior
Handle approvals and user input
Skills in: Honoring explicit customer requests for human agents immediately without first attempting investigation
Handle approvals and user input
Keep Claude in character with role prompting and prefilling
Skills in: Acknowledging frustration while offering resolution when the issue is within the agent’s capability, escalating only if the customer reiterates their preference
Keep Claude in character with role prompting and prefilling
Handle approvals and user input
Skills in: Escalating when policy is ambiguous or silent on the customer’s specific request (e.g., competitor price matching when policy only addresses own-site adjustments)
Handle approvals and user input
How we built our multi-agent research system
Skills in: Instructing the agent to ask for additional identifiers when tool results return multiple matches, rather than selecting based on heuristics
Handle approvals and user input
Task Statement 5.3: Implement error propagation strategies across multi-agent systems
Knowledge of: Structured error context (failure type, attempted query, partial results, alternative approaches) as enabling intelligent coordinator recovery decisions
How we built our multi-agent research system
Knowledge of: The distinction between access failures (timeouts needing retry decisions) and valid empty results (successful queries with no matches)
How we built our multi-agent research system
Knowledge of: Why generic error statuses (“search unavailable”) hide valuable context from the coordinator
How we built our multi-agent research system
Writing effective tools for AI agents—using AI agents
Knowledge of: Why silently suppressing errors (returning empty results as success) or terminating entire workflows on single failures are both anti-patterns
How we built our multi-agent research system
Skills in: Returning structured error context including failure type, what was attempted, partial results, and potential alternatives to enable coordinator recovery
How we built our multi-agent research system
Skills in: Distinguishing access failures from valid empty results in error reporting so the coordinator can make appropriate decisions
How we built our multi-agent research system
Skills in: Having subagents implement local recovery for transient failures and only propagate errors they cannot resolve, including what was attempted and partial results
How we built our multi-agent research system
Skills in: Structuring synthesis output with coverage annotations indicating which findings are well-supported versus which topic areas have gaps due to unavailable sources
How we built our multi-agent research system
Get structured output from agents
Task Statement 5.4: Manage context effectively in large codebase exploration
Knowledge of: Context degradation in extended sessions: models start giving inconsistent answers and referencing “typical patterns” rather than specific classes discovered earlier
Effective context engineering for AI agents
Set up Claude Code in a monorepo or large codebase
Knowledge of: The role of scratchpad files for persisting key findings across context boundaries
Effective harnesses for long-running agents
Effective context engineering for AI agents
Knowledge of: Subagent delegation for isolating verbose exploration output while the main agent coordinates high-level understanding
Effective context engineering for AI agents
Knowledge of: Structured state persistence for crash recovery: each agent exports state to a known location, and the coordinator loads a manifest on resume
Effective harnesses for long-running agents
Persist sessions to external storage
Skills in: Spawning subagents to investigate specific questions (e.g., “find all test files,” “trace refund flow dependencies”) while the main agent preserves high-level coordination
Skills in: Having agents maintain scratchpad files recording key findings, referencing them for subsequent questions to counteract context degradation
Effective harnesses for long-running agents
Effective context engineering for AI agents
Skills in: Summarizing key findings from one exploration phase before spawning sub-agents for the next phase, injecting summaries into initial context
Effective context engineering for AI agents
Skills in: Designing crash recovery using structured agent state exports (manifests) that the coordinator loads on resume and injects into agent prompts
Effective harnesses for long-running agents
Persist sessions to external storage
Skills in: Using /compact to reduce context usage during extended exploration sessions when context fills with verbose discovery output
Task Statement 5.5: Design human review workflows and confidence calibration
Knowledge of: The risk that aggregate accuracy metrics (e.g., 97% overall) may mask poor performance on specific document types or fields
Knowledge of: Stratified random sampling for measuring error rates in high-confidence extractions and detecting novel error patterns
Knowledge of: Field-level confidence scores calibrated using labeled validation sets for routing review attention
Knowledge of: The importance of validating accuracy by document type and field segment before automating high-confidence extractions
Skills in: Implementing stratified random sampling of high-confidence extractions for ongoing error rate measurement and novel pattern detection
Skills in: Analyzing accuracy by document type and field to verify consistent performance across all segments before reducing human review
Skills in: Having models output field-level confidence scores, then calibrating review thresholds using labeled validation sets
Skills in: Routing extractions with low model confidence or ambiguous/contradictory source documents to human review, prioritizing limited reviewer capacity
Handle approvals and user input
Task Statement 5.6: Preserve information provenance and handle uncertainty in multi-source synthesis
Knowledge of: How source attribution is lost during summarization steps when findings are compressed without preserving claim-source mappings
How we built our multi-agent research system
Knowledge of: The importance of structured claim-source mappings that the synthesis agent must preserve and merge when combining findings
How we built our multi-agent research system
Get structured output from agents
Knowledge of: How to handle conflicting statistics from credible sources: annotating conflicts with source attribution rather than arbitrarily selecting one value
How we built our multi-agent research system
Knowledge of: Temporal data: requiring publication/collection dates in structured outputs to prevent temporal differences from being misinterpreted as contradictions
How we built our multi-agent research system
Skills in: Requiring subagents to output structured claim-source mappings (source URLs, document names, relevant excerpts) that downstream agents preserve through synthesis
Get structured output from agents
How we built our multi-agent research system
Skills in: Structuring reports with explicit sections distinguishing well-established findings from contested ones, preserving original source characterizations and methodological context
How we built our multi-agent research system
Effective context engineering for AI agents
Skills in: Completing document analysis with conflicting values included and explicitly annotated, letting the coordinator decide how to reconcile before passing to synthesis
How we built our multi-agent research system
Skills in: Requiring subagents to include publication or data collection dates in structured outputs to enable correct temporal interpretation
How we built our multi-agent research system
Skills in: Rendering different content types appropriately in synthesis outputs—financial data as tables, news as prose, technical findings as structured lists—rather than converting everything to a uniform format
How we built our multi-agent research system
Effective context engineering for AI agents
Wrapping Up Claude Certified Architect – Foundations
This Claude Certified Architect – Foundations (CCAR-F) study guide has walked through all five exam domains, mapping every task statement to official Anthropic documentation covering the Agent SDK, Claude Code, the Claude API, and MCP. Work through each objective hands-on, build a real agent, and revisit the linked docs until the tradeoffs feel intuitive. You can also explore more Claude certification study guides on the Claude category to keep building your skills. Have a question or tip? Leave a comment below.
Receive Updates on Claude Certified Architect – Foundations Exam
Want to be notified as soon as I post? Subscribe to the RSS feed / leave your email address in the subscribe section. Share the article to your social networks with the below links so it can benefit others.
