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
~50 items · ~90 min
Practice bank
316 questions
Delivery
Pearson VUE
Domains & objectives
Projects & Configuration
- Configure a Claude Project with custom instructions that set role, tone, and explicit output rules.
- Add and organize knowledge sources so guidance persists across every conversation in a Project.
- Resolve vague or conflicting instructions into explicit, grounded operational boundaries.
- Decide what belongs in custom instructions vs the knowledge base vs a single message.
Prompting Fundamentals
- Write prompts that state context, goal, audience, and the desired output format.
- Use worked examples (few-shot) to steer output structure and quality.
- Iteratively refine a prompt to fix format, length, or tone problems.
- Ask Claude to reason step by step for complex analytical tasks.
Context & Memory
- Keep long conversations productive with summarization and restated constraints.
- Recognize context-window limits and decide when to restart, summarize, or persist state.
- Focus Claude on the relevant section of a large document instead of dumping everything.
- Start a clean conversation seeded with a concise summary when a thread becomes cluttered.
Claude Features & Interfaces
- Choose the right Claude surface for a task (chat, Projects, artifacts, file upload).
- Explain what custom instructions, the knowledge base, and a single message each do.
- Set standing preferences (language, tone) at the Project level rather than per message.
Responsible Use
- Apply responsible-use principles: avoid deception, respect privacy, avoid harmful content.
- Decide when a human must review a high-stakes output before it is acted on.
- Recognize and avoid fabrication/hallucination, and verify facts that matter.
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
~60 items · ~120 min
Practice bank
678 questions
Delivery
Pearson VUE
Domains & objectives
Messages API
- Use the system prompt for application-level, persistent instructions.
- Maintain multi-turn context by resending conversation history (the API is stateless).
- Use streaming to keep interactive apps responsive.
- Apply prompt caching for large, stable prefixes to cut cost and latency.
Agent SDK
- Build agents with the Claude Agent SDK using built-in tools (Read, Write, Bash).
- Use a coordinator that owns shared state and passes findings to subagents.
- Scope an agent's tools and permissions to the minimum its task requires.
Tool Use & MCP
- Define tools with clear names, precise descriptions, and well-typed input schemas.
- Run the tool-use loop correctly: return a tool_result referencing the tool_use id.
- Use MCP to connect models to external tools and data via interoperable servers.
- Configure tool_choice to guarantee a tool is called when structured output is required.
Prompt Engineering for Code
- Produce reliable structured output using a JSON schema, examples, and tool use.
- Ground the model in real docs/types and verify with tests to avoid hallucinated APIs.
- Write prompts that keep code output scoped, correct, and easy to parse.
Evaluation & Testing
- Build representative test sets with expected outcomes or checkable criteria.
- Prefer deterministic, programmatic checks (schema validation, assertions) where possible.
- Test edge cases, not just the happy path, to catch regressions.
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
456 questions
Delivery
Pearson VUE
Domains & objectives
Multi-Agent Orchestration & Subagents
- Construct subagent prompts that include all findings, structured data, and source metadata needed without returning to the coordinator.
- Evaluate subagent delegation strategies (goal-oriented vs procedural) balancing adaptive behavior with coordinator visibility.
- Configure subagent invocations with tool restrictions, context scoping, and role-constraining system prompts.
- Diagnose misconfigured subagent spawning (missing tool permissions, wrong AgentDefinition params, absent coordinator-to-subagent wiring).
- Evaluate orchestration patterns (coordinator-worker, parallel, sequential pipelines) for coverage, latency, and reliability.
- Distribute tools so each subagent gets only the tools its role requires.
Agentic Workflows & Task Design
- Configure agentic loops to emit multiple tool calls in one turn for parallel execution of independent subtasks.
- Decompose complex tasks into dynamically generated subtasks that adapt to new findings.
- Select the agentic review architecture (plan mode, direct execution, multi-phase) by scope, risk, and approval needs.
- Structure iterative refinement with concrete input-output examples, targeted feedback, and batched issues.
Claude Code Configuration & Tooling
- Configure Claude Code CLI for CI/CD using non-interactive flags, permission modes, and cost/turn limits.
- Design Claude Code review configurations that load project standards, restrict tools, and emit structured output.
- Apply the context: fork frontmatter to Skills/slash commands for isolated subagent context.
- Select the right configuration mechanism (CLAUDE.md, .claude/rules/ globs, Skills, hooks, settings permissions).
- Select the right built-in tool (Grep, Glob, Read, Bash) for a codebase task.
- Improve automated test generation with existing tests as context and criteria for meaningful assertions.
Context & Session Management
- Apply session resumption (targeted re-analysis of changed files, context injection) without repeating work.
- Design state persistence for multi-agent pipelines that resume after interruption.
- Apply systematic codebase exploration (Grep/Glob/Read) while managing context-window limits.
- Apply context management (subagent isolation, scratchpad files, targeted reading) across long sessions.
- Apply context-window optimization (summarization, sliding windows, structured state, selective retention).
Structured Output & Tool Use
- Select the most reliable structured-output method (tool use with JSON schema, prompt formatting, prefilled responses).
- Design extraction schemas with optional/nullable fields and enums to represent missing or ambiguous data without fabricating.
- Implement tool use with JSON schemas and configure tool_choice to guarantee invocation.
- Resolve structured-output truncation by splitting scoped calls and merging results, not just raising max_tokens.
- Sequence multi-tool workflows so prerequisite data is obtained before dependent tools run.
MCP & API Integration
- Distinguish MCP resources from tools and expose content as resources to reduce exploratory calls.
- Integrate MCP servers (server scope, environment-variable auth, tool discovery verification).
- Write MCP tool descriptions that distinguish purpose, inputs, boundaries, and relationships.
- Select the API processing mode (synchronous Messages API vs asynchronous Message Batches API).
Review, Extraction & Evaluation
- Design human-review routing by confidence, document characteristics, and field ambiguity rather than random sampling.
- Design specialized review passes that separate concerns (security, business logic, API design) with dedicated few-shot examples.
- Apply extraction accuracy patterns (structured schemas, format normalization, few-shot) to reduce hallucination.
- Reduce automated-review false positives with project conventions and exclusion criteria as persistent context.
- Design synthesis behavior that preserves source-level uncertainty instead of collapsing conflicting data.
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
309 questions
Delivery
Pearson VUE
Domains & objectives
Solution Design & Architecture
- Translate a business problem into a Claude-based AI solution.
- Design an end-to-end architecture (input, processing, output, feedback loops).
- Select an architectural pattern (workflow, agentic, augmented LLM) for a scenario.
- Design multi-agent systems and orchestration strategies.
- Align a solution to business value pillars (efficiency, transformation, productivity, cost, SLAs).
Models, Prompting & Configuration
- Select an appropriate Claude model based on capability, cost, and latency trade-offs.
- Apply prompt engineering techniques (zero-shot, few-shot, chain-of-thought).
- Evaluate tool/agent configuration for capability bloat.
- Justify accuracy-latency trade-offs in a configuration decision.
Security, Compliance & Governance
- Analyze authentication and authorization requirements to identify security gaps.
- Evaluate connection protocols and select the appropriate integration mechanism.
- Ensure compliance with regulations such as GDPR, HIPAA, and FedRAMP.
Safety & Risk
- Implement guardrails and safety controls.
- Identify risks, limitations, and failure modes of LLM systems.
- Apply human-in-the-loop validation strategies.
- Address ethical AI considerations (bias, fairness, transparency).
Evaluation & Testing
- Design evaluation datasets and test frameworks using mixed methodologies.
- Conduct A/B testing and iterative improvements.
- Diagnose system issues (prompt failure, hallucinations, model mismatch).
Observability & Optimization
- Analyze observability challenges and select monitoring strategies at scale.
- Optimize token usage, latency, and cost-performance trade-offs.
- Monitor system performance using logging and observability tools.
Delivery & Stakeholder Management
- Conduct structured discovery and requirement gathering.
- Communicate architectural decisions and trade-offs.
- Manage stakeholder feedback loops and expectations, including SLAs.
- Document architectures and provide implementation guidance.
- Support lifecycle phases (discovery, design, handoff, monitoring, iteration).
Developer Enablement
- 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.