Resources & Wiki
The community knowledge base for the Claude certification program — the exam domains and objectives for all four tracks, how to prepare, a glossary, an FAQ, and the official documents.
CCAO-FAssociate · Foundation · Beginner
Claude Certified Associate — Foundations
The entry-level certification for everyday Claude users. Covers configuring Projects, prompting fundamentals, managing context and memory, using Claude's interfaces, and responsible-use principles.
Price
$99 USD
Format
~60 items · ~120 min
Practice bank
376 questions
Delivery
Pearson VUE
Domains & objectives
Percentages are the official exam blueprint weights — budget your revision against them, since the score report is per domain.
Prompting and Task Execution
14%64 practice questions here· objectives summarised from our bank
- Identify and apply iterative prompt refinement techniques to improve output quality when initial responses are partially correct or incomplete.
- Decompose complex, ambiguous requests into appropriately-scoped subtasks that balance granularity with coherence in Claude's responses.
- Select and apply prompting methodologies (such as chain-of-thought, structured formats, or role-based prompting) that align with specific task characteristics and desired output types.
- Clarify vague or underspecified requests through follow-up questioning to uncover actual user needs before sending prompts to Claude.
- Revise prompts to include sufficient context, constraints, and examples that enable Claude to produce complete, accurate responses across all requested elements.
- Maintain conversation productivity and clarity across extended multi-turn interactions by using organizational techniques such as summarization or context management.
Output Evaluation and Validation
21%73 practice questions here· objectives summarised from our bank
- Verify factual accuracy and detect potential hallucinations in Claude-generated content before distribution or use.
- Assess structural completeness and requirement alignment in Claude outputs to identify gaps or missing components.
- Evaluate and revise Claude-generated content to align with organizational style guides, terminology standards, and editorial requirements.
- Select appropriate output formats and structures that optimize clarity, scannability, and usability for intended stakeholders.
- Establish quality assurance protocols by defining evaluation criteria and completing prerequisite activities before validating Claude outputs.
- Apply the AI Fluency Framework's Discernment and Diligence competencies to systematically review and validate Claude-generated deliverables.
Product and Model Selection
12%31 practice questions here· objectives summarised from our bank
- Identify use cases that align with Claude's core capabilities and strengths for organizational deployment.
- Select the appropriate Claude model tier based on task complexity, reasoning requirements, and processing volume.
- Evaluate model-to-task alignment decisions to determine whether selected models match specific capability and performance requirements.
- Characterize the three Claude model tiers accurately in terms of their capabilities, performance characteristics, and appropriate use cases.
- Determine prerequisite activities and foundational work required before benchmarking and evaluating Claude models for critical applications.
- Match model selection to operational requirements including response latency, throughput, and reasoning complexity for specific workflows.
Workflow Integration and Solution Design
16%50 practice questions here· objectives summarised from our bank
- Identify which tasks and process stages in knowledge work are most suitable for Claude integration based on impact potential and workflow characteristics.
- Conduct foundational planning activities including process mapping and stakeholder analysis before implementing Claude into operational workflows.
- Sequence the rollout of Claude integration into critical processes by first assessing stages, then piloting with monitoring, and finally scaling based on results.
- Evaluate and select workflow activities for Claude assistance by analyzing which steps are genuinely well-suited for AI support versus those requiring human judgment.
- Design Claude-assisted workflows by leveraging existing process documentation and performance metrics to identify optimization opportunities and appropriate delegation points.
- Prepare organizational change management for Claude integration by developing communication materials that address leadership and departmental stakeholder concerns.
- Validate Claude integration readiness by confirming prerequisites such as data platform compatibility and security requirements before authorizing implementation.
Configuration and Knowledge Management
12%53 practice questions here· objectives summarised from our bank
- Configure custom instructions to establish tone, style, and output requirements for Project-specific use cases.
- Organize and structure reference documents within Projects to enable effective source attribution and information retrieval.
- Design Projects with appropriate access controls and isolation mechanisms to protect client data and maintain security boundaries across multiple deployments.
- Establish system-level instructions as the foundational step before implementing document-review workflows and other Project processes.
- Integrate Skills with Projects to enhance workflow effectiveness and support ongoing operational processes.
- Select and configure appropriate Project components—including custom instructions, documents, and Skills—to address specific business requirements.
- Utilize Project Memory to maintain context and configuration across multiple conversations without requiring reconfiguration.
Governance, Risk, and Responsible Use
15%71 practice questions here· objectives summarised from our bank
- Identify and classify sensitive data types that require masking, removal, or careful handling before use with Claude.
- Evaluate organizational AI governance frameworks to determine whether proposed Claude use cases comply with established policies and restrictions.
- Assess Claude implementation configurations for security, privacy, and responsible use alignment with organizational standards.
- Apply data privacy protection measures including de-identification and removal of personally identifiable information from datasets before Claude processing.
- Determine appropriate levels of human oversight and decision-making authority when integrating Claude into business processes that affect compliance, HR, or financial outcomes.
- Communicate AI model capabilities and limitations to stakeholders to establish realistic expectations about Claude's role in organizational workflows.
Troubleshooting and Optimization
10%34 practice questions here· objectives summarised from our bank
- Conduct baseline assessment and performance analysis of existing Claude workflows before implementing optimization changes.
- Apply systematic feedback loops and iterative refinement processes to improve Claude output quality across multiple attempts.
- Execute structured troubleshooting diagnostics by developing targeted hypotheses about prompt components and testing them methodically.
- Recognize diminishing returns in iterative optimization and determine when to pivot strategy or escalate for redesign.
- Identify and isolate specific prompt components responsible for output deficiencies such as incomplete responses or format deviations.
- Analyze multi-stage workflows to locate performance bottlenecks and determine appropriate corrective actions.
- Optimize context management by filtering and prioritizing relevant information from large reference materials to improve Claude efficiency.
CCDV-FDeveloper · Foundation · Easy
Claude Certified Developer — Foundations
For developers building on Claude. Covers the Messages API, the Claude Agent SDK, tool use and MCP, prompt engineering for code, streaming, and evaluation and testing. A good place to start if you're new to building on the platform.
Price
$125 USD
Format
~53 items · ~120 min
Practice bank
731 questions
Delivery
Pearson VUE
Domains & objectives
Percentages are the official exam blueprint weights — budget your revision against them, since the score report is per domain.
Agents and Workflows
14.7%173 practice questions here· objectives summarised from our bank
- Design a multi-agent system architecture where a coordinator agent delegates specialized tasks to subagents and orchestrates their contributions toward a unified goal.
- Implement agent-to-agent communication patterns that enable subagents to receive delegated tasks from a coordinator and return findings for synthesis.
- Configure specialized subagents to perform domain-specific analysis tasks such as document review, data auditing, research synthesis, or code examination.
- Integrate MCP tools and backend service connections into agents to enable access to external systems, databases, and APIs required for task execution.
- Develop coordination logic that aggregates, synthesizes, or processes outputs from multiple subagents to produce final results or recommendations.
- Build multi-tier agent hierarchies where a primary coordinator validates inputs, distributes work to specialized subagents, and manages task dependencies.
Applications and Integration
33.1%67 practice questions here· objectives summarised from our bank
- Integrate Claude into CI/CD pipelines to analyze code submissions and provide structured feedback on pull requests using tool use and the Messages API.
- Implement tool use patterns in code review systems to generate structured findings with specific fields such as file path, line number, severity, and remediation suggestions.
- Use the Message Batches API to process multiple code review tasks efficiently while handling custom tool calls for validation and analysis.
- Design document processing pipelines that extract structured data from unstructured documents using Claude and validate outputs against JSON schemas.
- Route documents to specialized extraction workflows based on content classification and integrate validated results with downstream business systems.
- Handle errors and unexpected outputs in extraction systems by implementing validation logic that ensures data quality before passing results to backend applications.
Claude Code
3.1%92 practice questions here· objectives summarised from our bank
- Build code assistance agents using the Claude Agent SDK that integrate with MCP services and execute tools like file reading, writing, code search, and test execution.
- Design agents that navigate and comprehend large, complex codebases by strategically reading files and gathering context without exhausting token budgets.
- Configure Claude Code with custom commands and CLAUDE.md settings to enforce team-specific patterns for testing, error handling, module organization, and code review workflows.
- Implement agents that perform code analysis and debugging by correlating production errors with source code to identify root causes in complex systems.
- Generate structured code review outputs including severity levels, affected line numbers, remediation guidance, and deployment impact assessments in JSON format.
- Develop refactoring agents that identify outdated patterns, suggest modernization replacements, and generate implementation code while managing dependencies across multiple services.
Eval, Testing, and Debugging
2.6%132 practice questions here· objectives summarised from our bank
- Implement validation layers that check extracted or generated output against business rules, JSON schemas, and domain-specific constraints to catch semantic errors that pass syntactic validation.
- Design and execute evaluation methodologies to measure accuracy, identify failure patterns, and audit system performance across diverse document types and use cases.
- Build error handling and graceful degradation mechanisms that allow systems to process incomplete or malformed inputs without failing entirely.
- Construct multi-agent architectures that route tasks to specialized Claude agents and aggregate their outputs while maintaining consistency and quality.
- Identify and address systematic gaps in AI-generated code by analyzing reviewer feedback, test failures, and domain-specific requirements to improve generation quality.
- Integrate Claude into CI/CD pipelines and automated workflows using the Claude Agent SDK, including session management and tool integration for code generation and review tasks.
Model Selection and Optimization
16.8%57 practice questions here· objectives summarised from our bank
- Select between Claude models based on task complexity, latency requirements, and cost constraints to optimize system performance.
- Evaluate and apply model versioning strategies (pinned versions, aliases, or latest) to balance stability, feature access, and change management requirements.
- Design multi-agent system architectures that distribute specialized tasks across agents while managing coordination, context, and output quality.
- Implement asynchronous processing patterns (batching, streaming, or deferred execution) to meet throughput and cost requirements when latency constraints permit.
- Configure conditional feature usage (extended thinking, code execution, agentic loops) based on task characteristics to optimize latency and cost trade-offs.
- Diagnose model behavior changes and performance degradation by distinguishing between model updates, configuration drift, and prompt/data variations.
- Match document processing workflows to appropriate Claude capabilities (extraction, structured output, batch processing) based on latency, accuracy, and volume requirements.
Prompt and Context Engineering
11%107 practice questions here· objectives summarised from our bank
- Design prompts that extract structured data from unstructured documents and validate outputs against formal schemas.
- Implement multi-turn agent workflows that coordinate specialized subagents to handle complex, multi-part user requests.
- Construct system prompts and context windows that balance comprehensive instruction coverage with token efficiency and clarity.
- Craft prompts for code review systems that deliver specific, actionable feedback on code quality, security, and test coverage.
- Build extraction pipelines that consolidate information from multiple source documents into unified, validated structured outputs.
Security and Safety
8.1%63 practice questions here· objectives summarised from our bank
- Implement access controls and tool permissions to restrict agent capabilities to only necessary functions and prevent unauthorized operations on sensitive systems.
- Design multi-agent systems with clear delegation boundaries and coordinator oversight to ensure subagents operate within approved scopes and cannot bypass safety constraints.
- Validate and sanitize all inputs and outputs in agent workflows to prevent injection attacks, data leakage, and misuse of tool results across agent handoffs.
- Implement human escalation checkpoints and approval workflows for high-risk agent actions such as financial transactions, refunds, and account modifications.
- Configure agents to detect and handle discrepancies, conflicts, and anomalies in data before taking autonomous action, with escalation when confidence thresholds are not met.
- Establish audit logging and monitoring for all agent tool calls and decisions to enable post-incident analysis and compliance verification of autonomous system behavior.
Tools and MCPs
10.6%40 practice questions here· objectives summarised from our bank
- Configure and authenticate custom MCP servers with Claude agents, including bearer token authentication and API credential management.
- Design multi-tool agent workflows that coordinate access to specialized MCP tools for distinct operational domains (e.g., CRM, billing, code repositories).
- Implement error handling and fallback strategies when MCP tools return incomplete or unreliable data in production agent systems.
- Build multi-agent systems using the Claude Agent SDK where specialized sub-agents delegate tasks to a coordinator agent and integrate with MCP servers.
- Develop agent-based solutions that decompose complex customer service requests into independent sub-tasks and route them to appropriate MCP tools.
- Integrate Claude agents with code analysis and repository navigation tools via MCP to enable automated code review, architecture understanding, and template generation.
CCAR-FArchitect · Foundation · Hard
Claude Certified Architect — Foundations
The deeper foundation exam — architecture, design decisions and the trade-offs behind them. Covers Claude Code and developer tooling, prompt and context engineering, agentic patterns, integration, and governance foundations.
Price
$125 USD
Format
~60 items · ~120 min
Practice bank
516 questions
Delivery
Pearson VUE
Domains & objectives
Percentages are the official exam blueprint weights — budget your revision against them, since the score report is per domain.
Agentic Architecture & Orchestration
27%150 practice questions hereofficial objectives
- Configure agentic loops to emit multiple tool calls within a single response turn, enabling parallel execution of independent subtasks and reducing total round-trip latency.
- Evaluate subagent delegation strategies — goal-oriented versus procedural instructions — and select the approach that enables adaptive behavior while maintaining coordinator visibility and control.
- Configure subagent invocations with appropriate tool restrictions, context scoping, and system prompts that constrain each agent to its designated role.
- Diagnose misconfigured subagent spawning by identifying missing tool permissions, incorrect AgentDefinition parameters, or absent coordinatorto-subagent wiring.
- Decompose complex tasks into dynamically generated subtasks that adapt as new information is discovered, rather than executing a fixed sequence regardless of intermediate findings.
- Select the appropriate agentic review architecture — plan mode, direct execution, or multi-phase workflow — based on task scope, risk level, and human approval requirements.
- Evaluate multi-agent orchestration patterns — coordinator-worker, parallel execution, and sequential pipelines — to select the structure best satisfying research coverage, latency, and reliability requirements.
Tool Design & MCP Integration
18%69 practice questions hereofficial objectives
- Select the appropriate Claude Code built-in tool — Grep, Glob, Read, or Bash — based on the nature of the search or file operation required for a given codebase task.
- Configure tool distribution in multi-agent systems by assigning each subagent only the tools required for its designated role, reducing decision complexity and preventing out-of-role tool invocations.
- Distinguish between MCP resources and tools, and expose server content as resources to reduce exploratory tool calls and improve agent efficiency in cross-system queries.
- Integrate MCP servers into Claude Code and agent applications by selecting the correct server scope, configuring authentication via environment variable expansion, and verifying tool discovery.
- Write MCP tool descriptions that clearly distinguish each tool's purpose, input formats, use-case boundaries, and relationships to semantically similar tools, reducing misrouting and incorrect tool selection.
- Configure the tool_choice parameter to guarantee tool invocation when structured output is required, and sequence multi-tool workflows so prerequisite data is obtained before dependent tools are called.
Claude Code Configuration & Workflows
20%98 practice questions hereofficial objectives
- Configure Claude Code CLI invocations for automated CI/CD pipelines using non-interactive flags, permission modes, and cost and turn limits that prevent runaway executions.
- Design Claude Code review configurations that load the correct project standards, restrict unnecessary tool access, and produce structured output suitable for automated downstream processing.
- Apply the context: fork frontmatter option to Skill and slash command configurations that should execute in an isolated subagent context, preventing cross-contamination of session state.
- Select the correct Claude Code configuration mechanism — CLAUDE.md, .claude/rules/ with glob patterns, Skills, hooks, or settings permissions — based on guidance type and when it should apply.
Prompt Engineering & Structured Output
20%98 practice questions hereofficial objectives
- Construct subagent prompts that include all findings, structured data, and source metadata required for task completion without returning to the coordinator for missing context.
- Structure iterative refinement workflows by providing concrete inputoutput examples, targeted feedback on specific failures, and batched issue descriptions for consolidated evaluation.
- Improve automated test generation quality by providing existing test files as context, defining fixture conventions, and specifying criteria that distinguish meaningful behavioral tests from trivial assertions.
- Design subagent output schemas that render structured data, prose summaries, and citation metadata in the format best suited to downstream synthesis and reporting.
- Design synthesis agent behavior that preserves source-level uncertainty, distinguishing well-established findings from contested claims rather than collapsing conflicting data into single confident statements.
- Design human review routing strategies that direct extractions to reviewers based on confidence scores, document characteristics, and field-level ambiguity rather than random sampling.
- Design specialized review passes that separate concerns — security, business logic, API design — into focused prompts with dedicated few-shot examples, preventing recall trade-offs from competing concerns in a single prompt.
- Select and implement the most reliable structured output method — tool use with JSON schema, prompt-based formatting, or prefilled responses — based on required schema compliance strictness.
- Design extraction schemas with optional fields, nullable values, and appropriate enum definitions that allow the model to accurately represent missing or ambiguous information without fabricating values.
- Implement tool use with defined JSON schemas to enforce structured output compliance, and configure tool_choice to guarantee tool invocation when conversational responses would cause downstream failures.
- Apply extraction accuracy patterns — structured schemas with optional fields, format normalization instructions, and few-shot examples — to reduce hallucination and improve consistency across varied document formats.
- Design prompt criteria that define explicit inclusion and exclusion boundaries, preventing the model from generating findings or extractions in categories where performance is unreliable.
Context Management & Reliability
15%101 practice questions hereofficial objectives
- Apply session resumption techniques — including targeted re-analysis of changed files and context injection — to restore agent state accurately without repeating prior work.
- Design state persistence strategies for multi-agent pipelines that enable reliable resumption after interruption without repeating completed work or losing prior findings.
- Apply systematic codebase exploration strategies using Grep, Glob, and Read tools that build incremental understanding while managing context window constraints.
- Apply context management strategies — subagent isolation, scratchpad files, and targeted file reading — to sustain coherent codebase exploration across sessions exceeding context limits.
- Apply context window optimization techniques — summarization, sliding windows, structured state objects, and selective retention — to maintain response quality as conversations exceed practical token limits.
- Select the appropriate API processing mode — synchronous Messages API or asynchronous Message Batches API — based on latency requirements, workflow blocking behavior, and acceptable processing windows.
- Resolve structured output truncation failures by splitting large review tasks into smaller scoped API calls and merging resulting data structures, rather than increasing max_tokens beyond practical limits.
- Reduce automated review false positive rates by supplying projectspecific conventions, accepted patterns, and exclusion criteria as persistent context applied on every review.
CCAR-PArchitect · Professional · Advanced
Claude Certified Architect — Professional
The advanced architect certification. Covers designing complex multi-agent systems, production scale and reliability, evaluation strategy, cost and performance trade-offs, and enterprise governance.
Price
$175 USD
Format
~63 items · ~120 min
Practice bank
367 questions
Delivery
Pearson VUE
Domains & objectives
Percentages are the official exam blueprint weights — budget your revision against them, since the score report is per domain.
Solution Design & Architecture
17%54 practice questions hereofficial objectives
- Translate business problems into Claude-based AI solutions
- Design end-to-end architectures (input → processing → output → feedback loops)
- Select appropriate architectural patterns (workflow, agentic, augmented LLM)
- Design multi-agent systems and orchestration strategies
- Align solutions to business value pillars (efficiency, transformation, productivity, cost, SLAs)
Claude Models, Prompting & Context Engineering
13%21 practice questions hereofficial objectives
- Select appropriate Claude models based on trade-offs
- Apply prompt engineering techniques (zero-shot, few-shot, chainof-thought, etc.)
- Evaluate tool/agent configuration for capability bloat
- Apply decomposition techniques for complex problem solving
- Design system prompts, templates, and guardrails
- Implement prompt reuse strategies (e.g., caching, modular prompts)
Integration
19%25 practice questions hereofficial objectives
- Evaluate connection protocols and select the appropriate integration mechanism
Evaluation, Testing & Optimization
16%83 practice questions hereofficial objectives
- Evaluate accuracy-latency tradeoffs and justify configuration decisions
- Analyze observability challenges and select monitoring strategies at scale
- Design evaluation datasets and test frameworks using a mix of testing methodologies
- Conduct A/B testing and iterative improvements
- Diagnose system issues (prompt failure, hallucinations, model mismatch)
- Optimize token usage, latency, and cost-performance trade-offs
- Monitor system performance using logging and observability tools
- Define evaluation metrics (accuracy, latency, cost, safety, security)
Governance, Safety & Risk Management
14%89 practice questions hereofficial objectives
- Analyze authentication and authorization requirements to identify security gaps
- Implement guardrails and safety controls
- Identify risks, limitations, and failure modes of LLM systems
- Apply human-in-the-loop validation strategies
- Ensure compliance with regulations (e.g., GDPR, HIPAA, FedRAMP)
- Address ethical AI considerations (bias, fairness, transparency)
Stakeholder Communication & Lifecycle Management
14%54 practice questions hereofficial objectives
- Conduct structured discovery and requirement gathering
- Communicate architectural decisions and trade-offs
- Manage stakeholder feedback loops and expectation alignment (including SLAs)
- Document architectures and provide implementation guidance
- Support lifecycle phases (discovery, design, handoff, monitoring, iteration)
Developer Productivity & Operational Enablement
7%41 practice questions hereofficial objectives
- Configure Claude tools and environments for teams (e.g., Claude Code)
- Improve developer workflows using AI-assisted tooling
- Support debugging and operational issue resolution
How to prepare
- Take the free Anthropic Academy courses for your track (see below) to cover the concepts end to end.
- Study the domains & objectives above — they map directly to what each exam tests.
- Drill our free mock exams in Practice mode (instant explanations), then simulate the real thing with a timed Mock exam and review the per-domain score report.
- Read the official documents (infographic, policy, terms) before you book.
FAQ
Are these official exams?
The certifications are Anthropic's official role-based credentials, delivered proctored via Pearson VUE with a Credly badge. This site is an independent, community-built study resource — not affiliated with Anthropic.
How much do they cost?
Approximately: Associate $99, Developer $125, Architect Foundations $125, Architect Professional $175 (USD, paid to Anthropic). Always confirm current pricing with the vendor.
What's the passing score?
The reports use a 720 / 1000 scale (about 72%). The pass mark used in our mock exams is a site default, not a published vendor cut score.
How do I register?
Through the Claude SG partner network: complete the screening, receive a free @claudecode.sg partner-network email, sign a short agreement, then sit the proctored exam. See the Certification page.
How long is a certification valid?
Around 12 months (verify with the vendor).
How should I prepare?
Take the recommended free Anthropic Academy courses, study the objectives on this page, then drill our free mock exams with explanations.
Glossary
- Claude Projects
- A workspace with custom instructions and a knowledge base that persist across every conversation in the Project.
- Custom instructions
- Standing guidance (role, tone, rules, output format) applied to all chats in a Project.
- Knowledge base
- Reference documents attached to a Project so Claude can use them across conversations.
- Context window
- The amount of text (tokens) Claude can consider at once; managing it well is core to long tasks.
- System prompt
- Application-level, persistent instructions sent with every API request.
- Messages API
- The stateless API for multi-turn conversations; you resend history each request.
- Message Batches API
- Asynchronous processing for large, non-latency-sensitive workloads.
- Tool use
- Letting Claude call defined tools (with name, description and a typed input schema) and act on the results.
- MCP (Model Context Protocol)
- An open standard connecting models to external tools and data via interoperable servers.
- Claude Agent SDK
- The SDK for building agents with built-in tools (Read/Write/Bash), subagents and a coordinator.
- Subagents
- Specialized agents a coordinator dispatches; the coordinator owns shared state across them.
- Prompt caching
- Reusing a large, stable prompt prefix across requests to cut cost and latency.
- Structured output
- Enforcing a schema (via tool use / JSON) so responses can be parsed reliably.
- Claude Code
- Anthropic's agentic coding tool, configurable via CLAUDE.md, rules, hooks, skills and settings.