Claude Certified Architect – Foundations (CCA-F)

What Is CCA-F?

The Claude Certified Architect – Foundations (CCA-F) is Anthropic's professional certification for solution architects who design and build production systems with Claude APIs, the Agent SDK, Claude Code, and the Model Context Protocol (MCP). It validates your ability to architect reliable, maintainable, and scalable AI-powered applications — from single-turn API calls to complex multi-agent orchestration systems.

Unlike vendor certifications that test rote memorisation of service catalogues, CCA-F is scenario-driven. You face 4 randomly selected real-world scenarios (from a bank of 6) and must demonstrate architectural reasoning across agentic loops, tool design, prompt engineering, and context management. The exam targets practitioners with 6+ months of hands-on experience building with Claude in production or advanced prototyping environments.

Earning the CCA-F badge signals to employers and clients that you can independently design Claude-powered architectures that are reliable under edge cases, cost-efficient at scale, and maintainable by engineering teams. The credential is shareable on LinkedIn and verifiable through Anthropic's Skilljar platform.

Key Facts

Exam Format & Structure

CCA-F uses a scenario-based assessment model. Rather than isolated knowledge questions, you receive 4 randomly selected scenarios from a bank of 6. Each scenario presents a realistic business problem requiring Claude-powered architecture decisions. You answer approximately 15 questions per scenario, testing your ability to apply multiple domains simultaneously within a coherent design context.

flowchart LR
    A["Register on
Skilljar"] --> B["Prepare
5 Domains"]
    B --> C["Exam Day
120 min"]
    C --> D["4 Scenarios
~15 Qs each"]
    D --> E{"Score
≥ 720?"}
    E -->|Yes| F["CCA-F Badge
LinkedIn"]
    E -->|No| G["Retake
Section Feedback"]

    style A fill:#3B9797,color:#fff
    style B fill:#16476A,color:#fff
    style C fill:#132440,color:#fff
    style D fill:#16476A,color:#fff
    style E fill:#BF092F,color:#fff
    style F fill:#3B9797,color:#fff
    style G fill:#132440,color:#fff
                            

Domain Breakdown

Domain 1: Agentic Architecture & Orchestration (27%)

The heaviest domain — tests your ability to design agentic loops, multi-agent systems, and workflow patterns.

• Agentic loop lifecycle: stop_reason values ("tool_use" vs "end_turn"), tool result injection, termination conditions
• Multi-agent orchestration: coordinator-subagent patterns, hub-spoke topology, isolated subagent context
• Task tool configuration: allowedTools scoping, context passing strategies, parallel vs sequential execution
• Agent SDK hooks: PostToolUse for data normalisation, tool call interception for policy enforcement
• Workflow handoff patterns: escalation criteria, enforcement gates, graceful degradation
• Task decomposition: prompt chaining, adaptive decomposition, when to use single vs multi-agent
• Session management: --resume, fork_session, state persistence across interactions

Domain 2: Tool Design & MCP Integration (18%)

Tests your ability to design clean tool interfaces, integrate MCP servers, and handle tool errors gracefully.

• Tool interface design: descriptive naming, input/output boundaries, disambiguation strategies
• Structured error responses: isError flag, errorCategory, retryable vs fatal classification
• Tool distribution: scoped access across agents, tool_choice modes ("auto", "any", forced)
• MCP server configuration: .mcp.json (project-level), ~/.claude.json (user-level), environment variable expansion
• Built-in tools: Read, Write, Edit, Bash, Grep, Glob — when to use vs custom MCP tools

Domain 3: Claude Code Configuration & Workflows (20%)

Tests your mastery of Claude Code as a development tool — configuration, customisation, and CI/CD integration.

• CLAUDE.md hierarchy: user-level, project-level, directory-level, @import directives
• Custom slash commands: .claude/commands/ directory, $ARGUMENTS interpolation
• Skills: .claude/skills/ with context: fork for isolated execution
• Path-specific rules: .claude/rules/ with YAML frontmatter globs, file-type enforcement
• Plan mode vs direct execution: complexity assessment, when to engage planning
• CI/CD integration: -p / --print flag for non-interactive mode, --output-format json, --json-schema for structured CI outputs

Domain 4: Prompt Engineering & Structured Output (20%)

Tests your ability to craft precise prompts, extract structured data, and leverage the API for production workloads.

• Explicit criteria: reducing false positives via precise language, avoiding sentiment-based triggers
• Few-shot prompting: handling ambiguous cases, ensuring format consistency across outputs
• Structured output via tool_use: JSON schema definitions, tool_choice forcing, schema validation
• Validation and retry loops: error feedback injection, self-correction patterns, max retry limits
• Message Batches API: 50% cost reduction, 24-hour processing window, custom_id correlation
• Multi-instance review: separate model calls for generation vs evaluation, self-review limitations

Domain 5: Context Management & Reliability (15%)

Tests your strategies for managing context windows, ensuring reliability, and building human-in-the-loop systems.

• Context preservation: protecting case facts during trimming, "lost in the middle" phenomenon
• Escalation design: explicit criteria over sentiment analysis, honouring customer preference for human agents
• Error propagation: structured error context in multi-agent chains, preventing cascade failures
• Large codebase strategies: scratchpad files, /compact command, delegating to subagents for exploration
• Human review integration: confidence calibration, stratified sampling for quality assurance
• Information provenance: claim-source mappings, uncertainty signalling, citation accuracy

Exam Scenarios

Each exam sitting draws 4 of the following 6 scenarios. You cannot predict which 4 you'll receive, so you must prepare for all 6.

Task Statements at a Glance

The CCA-F exam tests 30 task statements across 5 domains. Each task statement defines specific Knowledge of and Skills in requirements. The table below summarises all 30 tasks — for the full knowledge/skills breakdown with article cross-references, see the comprehensive CCA Study Guide.

Domain 1: Agentic Architecture & Orchestration (27% — 7 Tasks)

Domain 2: Tool Design & MCP Integration (18% — 5 Tasks)

Domain 3: Claude Code Configuration & Workflows (20% — 6 Tasks)

Domain 4: Prompt Engineering & Structured Output (20% — 6 Tasks)

Domain 5: Context Management & Reliability (15% — 6 Tasks)

Sample Exam Questions

The following 4 questions illustrate the format and difficulty of the CCA-F exam. Each is scenario-anchored and tests integrated reasoning across domains. For the complete 12-question practice set with explanations, see the full study guide.

Preparation Strategy

Hands-On Exercises

The CCA-F rewards practical experience over theory. Prioritise these hands-on activities:

• Build a multi-agent system with Agent SDK — coordinator + 2 subagents with scoped allowedTools
• Configure a Claude Code project with CLAUDE.md, custom commands, and path-specific rules
• Create a custom MCP server with proper error handling (isError, structured categories)
• Implement structured extraction using tool_use with JSON schemas and validation retries
• Set up a CI pipeline using claude -p with --output-format json for automated PR reviews
• Design an escalation flow with explicit criteria (not sentiment-based) and customer preference honouring

Key Tradeoffs to Understand

Tips & Resources

Study Resources

Common Pitfalls

Syllabus Progress Tracker