This Anthropic certification validates practitioners’ ability to make informed tradeoff decisions when building production-grade solutions with Claude AI. This site consolidates the Claude Certified Architect exam domains, scenarios, sample questions, and preparation strategies.
Target audience, prerequisites & eligibility
Domains, scenarios, format & scoring
Pricing, access & sign-up steps
12 questions from the exam guide
15 additional questions across all domains
Study plan, exercises & exam-day tips
Roles, market demand & certification value
The Claude Certified Architect – Foundations is Anthropic's first architecture-level technical certification. It validates practitioners' ability to make informed design decisions and tradeoffs when building production-grade applications powered by Claude.
60 multiple-choice questions in 120 minutes. Closed-book, no AI assistance. Each question has one correct and three distractor responses. 4 of 6 scenarios randomly selected.
Scaled score 100–1,000. Passing score: 720. No penalty for guessing — unanswered questions are scored as incorrect. Score report within 2 business days with section breakdowns.
Solution architects with 6+ months experience building with Claude APIs, Agent SDK, Claude Code, and MCP in production environments.
$99 exam fee ($0 for the first 5,000 Claude Partner Network employees). Register through Anthropic Academy on Skilljar. Score report delivered within 2 business days.
The exam covers five weighted domains. Each domain tests specific knowledge and skills required for building production Claude applications.
Design and implement autonomous task execution systems using the Claude Agent SDK, including agentic loop lifecycle management, multi-agent coordinator-subagent patterns, hook interception mechanisms, and session state management.
Build effective tool interfaces and integrate with MCP servers, covering description best practices, structured errors, and tool distribution.
Manage context in production systems, covering escalation patterns, error propagation, and information provenance.
Configure Claude Code for team development workflows, mastering the CLAUDE.md hierarchy, custom commands and skills, Plan Mode, and CI/CD pipeline integration.
Production-grade prompt engineering, including explicit criteria, few-shot prompting, guaranteed structured output via tool_use, validation-retry loops, and multi-pass review.
The exam randomly presents 4 of these 6 scenarios. Each places you in a realistic production context requiring architectural decisions.
Building a customer support agent with Agent SDK and MCP tools (get_customer, lookup_order, process_refund, escalate_to_human). Target: 80%+ first-contact resolution rate.
stop_reason: continue looping on "tool_use", exit on "end_turn"
Using Claude Code for code generation, refactoring, debugging, and documentation. Configuring custom commands, CLAUDE.md, and plan mode for a development team.
.claude/CLAUDE.md (version-controlled, shared across the team)
~/.claude/CLAUDE.md (personal only, not shared with teammates)
context: fork and allowed-tools restrictions
Building a coordinator-subagent research system: web search, document analysis, synthesis, and report subagents working in parallel to produce comprehensive cited reports.
Building an agent to help engineers explore codebases, understand legacy systems, and generate template code. Uses built-in tools and MCP server integration.
Read tool (purpose-built for file reading)
Bash('cat config.json') — never use Bash when a dedicated tool exists
${ENV_VAR} environment variables in .mcp.json, commit to version control
Edit for targeted modifications (preserves unchanged content)
Write overwrites the entire file — anything not included is lost
Integrating Claude Code into CI/CD pipelines for automated code reviews, test generation, and PR feedback. Designing actionable prompts and minimizing false positives.
-p flag for non-interactive mode, combined with --output-format json for structured output
--json-schema flag to force output conforming to a specific schema
Extracting structured information from unstructured documents with JSON schema validation, handling edge cases, and integrating with downstream systems.
tool_use + JSON Schema + tool_choice to force a specific tool
These questions are drawn from the official exam guide to illustrate format and difficulty. Each includes a detailed explanation.
Production data shows your agent skips get_customer 12% of the time, calling lookup_order directly with the customer's name, occasionally causing incorrect identity matches and refunds. Which change most effectively addresses this reliability issue?
When a specific tool calling sequence is essential for critical business logic (like verifying identity before issuing refunds), programmatic enforcement provides deterministic guarantees that prompt-based approaches cannot. Options B and C rely on probabilistic LLM compliance, which is insufficient when errors have financial consequences. Option D addresses tool availability rather than tool call ordering, which isn't the actual problem.
Logs show the agent frequently calls get_customer when users ask about orders (e.g., "check my order #12345") instead of lookup_order. Both tools have minimal descriptions ("Get customer info" / "Get order details") and accept similar identifier formats. What is the most effective first step to improve tool selection accuracy?
Tool descriptions are the primary signal the LLM uses for tool selection. When descriptions are too brief, the model lacks context to distinguish between similar tools. B directly addresses the root cause with low effort and high leverage. Few-shot examples (A) add token overhead without fixing the underlying issue; a routing layer (C) is over-engineered and bypasses the LLM's natural language understanding; merging tools (D) is too heavy as a "first step."
Your customer support agent achieves only 55% first-contact resolution. Analysis reveals it escalates too aggressively for simple issues but fails to escalate complex cases that require human judgment. How should you calibrate escalation behavior?
Explicit criteria combined with few-shot examples directly address both failure modes: over-escalation (by defining what doesn't warrant escalation) and under-escalation (by specifying clear triggers). Option B relies on self-assessed confidence, which is unreliable for calibration. Option C manipulates tool positioning, which doesn't address the decision logic. Option D uses sentiment as a proxy, but frustrated customers may have simple issues while calm customers may have genuinely complex ones.
You want to create a custom /review slash command that runs your team's standard code review checklist. All developers should be able to use this command after cloning or pulling the repo. Where should the command file be placed?
Project-level custom slash commands belong in the repository's .claude/commands/ directory, which is version-controlled and automatically available to all developers. ~/.claude/commands/ (B) holds personal commands not shared via version control. CLAUDE.md (C) is for project instructions and context, not command definitions. A commands array in .claude/config.json (D) describes a configuration mechanism that doesn't exist in Claude Code.
You are tasked with refactoring your team's monolith into microservices. This will involve changes across dozens of files, requiring decisions about service boundaries and module dependencies. Which approach should you take?
Plan mode is designed for complex tasks involving large-scale changes, multiple viable approaches, and architectural decisions — exactly what a monolith-to-microservices migration requires. It allows safe codebase exploration and design before committing changes. B risks costly rework when dependencies are discovered; C assumes you already know the correct structure without exploration; D ignores that the complexity is already evident in the requirements, not something that might appear later.
Your project uses TypeScript for the frontend, Python for the backend, and Terraform for infrastructure. Each has different coding conventions and linting rules. How should you configure Claude Code to apply different conventions based on file type?
The .claude/rules/ directory with glob patterns in YAML frontmatter is specifically designed for conditional convention loading based on file paths and patterns. This approach loads only the relevant rules when working with specific file types, keeping context clean and focused. A single CLAUDE.md (B) loads all conventions regardless of context, wasting tokens. Directory-level CLAUDE.md files (C) work for directory-based separation but don't handle mixed-language directories or cross-cutting conventions. Environment variables (D) describe a mechanism that doesn't exist in Claude Code.
Your multi-agent research system produces a report on "the impact of AI on creative industries," but the final output only covers visual arts, missing music, writing, and film. All subagents completed successfully. What is the most likely root cause?
When all subagents complete successfully but the output is incomplete, the problem typically lies in the coordinator's task decomposition. If the coordinator decomposed "creative industries" into only visual arts categories, every subagent would diligently research only those areas. The coordinator is responsible for ensuring comprehensive coverage through proper task breakdown. The other options describe downstream issues that wouldn't explain all subagents converging on the same narrow topic.
The web search subagent times out while researching a complex topic. You need to design how failure information is communicated back to the coordinator. Which error propagation approach best supports intelligent recovery?
Structured error context gives the coordinator the information needed to make intelligent recovery decisions — whether to retry with modified queries, try alternative sources, or proceed with partial results. B's generic status hides valuable context from the coordinator; C disguises failure as success, preventing any recovery; D unnecessarily terminates the entire workflow when recovery strategies may still work.
The synthesis subagent needs to verify specific facts from the research findings before including them in the final report. How should you provide this capability?
A scoped verification tool follows the principle of giving each subagent exactly the tools it needs for its specific task. The synthesis subagent needs fact-checking, not full web search capabilities. Option B adds unnecessary coordination overhead; C violates tool scoping best practices by giving too many tools; D assumes perfect pre-verification, which may miss claims that only become questionable during synthesis.
Your team integrates Claude Code into the CI pipeline, but it hangs during execution waiting for user input. What is the correct fix?
The -p flag is the official way to run Claude Code in non-interactive (headless) mode for CI/CD pipelines. It accepts a prompt as an argument and runs without requiring user input. Piping stdin (B) is fragile and not the designed interface. Timeout-based restarts (C) don't solve the root cause. --auto-accept (D) addresses permission prompts but doesn't switch to non-interactive mode.
Your engineering manager proposes using the Message Batches API for both the PR review workflow (triggered on every PR) and the nightly codebase audit. Which recommendation is correct?
The Message Batches API provides 50% cost savings with a 24-hour completion window, making it ideal for non-time-sensitive workloads like nightly audits. PR reviews require timely feedback for developers and should use synchronous processing. B sacrifices developer experience for cost savings on a latency-sensitive workflow. C ignores valid cost optimization for the nightly audit. D inverts the correct mapping of urgency to processing mode.
A PR modifies 14 files in the inventory tracking module. Your single-pass review of all files produces inconsistent results: some files get detailed feedback while others receive superficial comments, obvious bugs are missed, and identical code patterns are flagged in one file but ignored in another. How should you restructure the review process?
Splitting into focused multi-pass reviews directly addresses the root cause: attention dilution from processing too many files simultaneously. Per-file analysis ensures consistent depth, while a separate integration pass catches cross-file issues. B shifts the burden to developers without improving the system. C misunderstands that a larger context window doesn't solve attention quality problems. D would actually suppress detection of real bugs that are only caught intermittently by requiring consensus.
Complete these exercises to build practical familiarity with exam topics.
Objective: Practice agentic loop design, tool integration, structured error handling, and escalation patterns.
get_customer, lookup_order, process_refund).stop_reason to determine continuation vs termination.isError, errorCategory, and isRetryable fields in each tool.Objective: Master CLAUDE.md hierarchies, custom commands, path-specific rules, and MCP integration.
~/.claude/CLAUDE.md), project-level (.claude/CLAUDE.md), and directory-level files..claude/commands/ (e.g., /review and /test)..claude/rules/ using YAML frontmatter glob patterns for different file types (e.g., TypeScript vs Python conventions).context: fork and allowed-tools restrictions for isolated codebase exploration..mcp.json using ${ENV_VAR} for credential management.Objective: Practice JSON schemas, tool_use for guaranteed structure, validation-retry loops, and batch processing.
tool_use with tool_choice to guarantee the output conforms to the schema.Objective: Practice subagent orchestration, context passing, error propagation, and information provenance.
.claude/rules/, custom skills with frontmatter options, and at least one MCP server.A structured 6-week study plan combining 13 free Anthropic Academy courses, 4 hands-on building exercises, 27 practice questions, and exam-day strategies.
The Claude Certified Architect credential positions you in a rapidly growing market backed by Anthropic’s $100M partner investment and enterprise adoption at scale.
Become one of the first to earn Anthropic's official technical certification. Demonstrate your expertise in designing production-grade Claude solutions and establish professional credibility in AI architecture.