examOS.
Exam CatalogueStudy PlansRoadmapsBlogs
Login

ExamOS

Credits PolicyReferral PolicyQuality StandardsPricingPrivacy PolicyTerms of UseContact UsReport a Bug

Follow us

Disclaimer: ExamOS is an independent platform, not affiliated with any certification provider, and does not use or distribute exam dumps.

Share your feedback

Checking sign-in status...

examOS.Study Plan
Disclaimer: ExamOS is an independent platform, not affiliated with any certification provider, and does not use or distribute exam dumps.
← Back to Exam Details

Study Plan

Claude Certified Architect Foundations (CCA-F) – Study Plan

A condensed 6-week plan for CCA-F. Master agentic architecture, MCP integration, Claude Code workflows, prompt engineering, and context management.

AnthropicCCA-FPassing score: 720 / 1000AI engineers, developers, and architects with approximately 6 months hands-on experience building production systems with the Claude API and Claude Code18-Jul-202662 views
Start date: _______________Target exam date: _______________
6 WeeksDuration
~40 hrsTotal Study Time
5 DomainsExam Coverage

Stay consistent by setting a target date for this certification.

Set target

How to use this plan

  1. 1Read and build. Start the week with Anthropic documentation, then immediately build something small with the concept you just read. Passive reading does not transfer to scenario judgment on this exam.
  2. 2Build your judgment. For every pattern you encounter, ask: what problem does this solve, when is it the wrong choice, and what would change my answer if the scenario were slightly different?
  3. 3Practice with ExamOS. Use the quiz modes in the order specified in this Study Plan.
  4. 4Write one sentence per miss. For every practice question you get wrong, write one sentence explaining the architectural principle you missed. That sentence is what actually sticks.
Rookie ModeChallenger ModeLegend Mode

Week-by-Week Breakdown


W1

Week 1

Agentic Architecture and Orchestration, Part 1 (27%)

This first half of the largest domain covers the fundamentals of agentic systems: what an agent loop looks like, when to use an agent versus a simpler pattern, and how to decompose complex tasks effectively.

Topics

  • Agentic loop mechanics and stop_reason
  • Agents vs workflows vs conversations
  • Task decomposition and planning
  • Recognizing decomposition anti-patterns
  • When agentic architecture adds value

Activities

  • Build a minimal agent loop using the Claude Agent SDK. Log every stop_reason you see across a real run.
W2

Week 2

Agentic Architecture and Orchestration, Part 2 (27%)

The second half of this domain covers multi-agent systems: how to coordinate subagents, when to dispatch in parallel versus serial, and when to escalate to a human.

Topics

  • Hub-and-spoke coordinator patterns
  • Subagent context isolation
  • Parallel vs serial dispatch trade-offs
  • Escalation loops and human handoff
  • Model confidence limitations for routing

Activities

  • Build a coordinator that dispatches 2-3 subagents in parallel for independent subtasks. Measure the token cost difference versus serial execution in a single agent.
W3

Week 3

Tool Design and MCP Integration (18%)

Tools are how agents interact with the outside world. This week covers how to write tool descriptions that produce reliable selection, how to scope toolsets to avoid degradation, and how the Model Context Protocol (MCP) standardizes tool integration.

Topics

  • Tool description best practices
  • Structured error responses from tools
  • Scoping tools per agent role
  • Tool search and deferred schemas
  • MCP: servers, primitives, and transports

Activities

  • Write two versions of the same tool description: one vague ("handles deployments"), one specific. Confirm the model routes to the specific one more reliably.
W4

Week 4

Claude Code Configuration and Workflows (20%)

Claude Code is built on the Agent SDK's agentic loop, but it adds its own configuration layer: CLAUDE.md hierarchy, Agent Skills, hooks, and a permissions model that governs what the agent can and cannot do. This week gets those details right.

Topics

  • Claude Code architecture and execution
  • CLAUDE.md hierarchy and precedence
  • Agent Skills: SKILL.md and triggers
  • Hooks, permissions, and deny-wins rule
  • Agent SDK and CI/CD integration

Activities

  • Configure a project-level CLAUDE.md and a nested subdirectory CLAUDE.md. Confirm you understand which one wins for a file in the subdirectory.
W5

Week 5

Prompt Engineering, Structured Output, Context Management, and Reliability (35%)

This week covers two closely related domains: how to structure prompts and outputs for reliability, and how to manage the context window over long-running sessions. In practice, these are the same discipline: getting consistent, accurate responses from Claude at scale.

Topics

  • Prompt structuring with XML tags
  • Extended thinking and effort parameter
  • Structured output: constrained sampling vs tools
  • Context rot and management strategies
  • Prompt caching: breakpoints and invalidation

Activities

  • Implement native structured output (JSON schema) for one task and strict tool use for another. Write down when you would pick each.
W6

Week 6

Exam Simulation and Booking

Your final push. This week is full exam simulation mode: filling in remaining gaps and building the confidence to book the exam.

Topics

  • Full syllabus review across all five domains
  • Time management (120 minutes for 60 questions)
  • Scenario reasoning under time pressure
  • All 6 official production scenarios

Activities

  • Take at least 3 ExamOS Legend mode full quizzes (80% hard questions, 120-minute timer).
  • Simulate real exam conditions at least once: no notes, no breaks, 120 minutes, same time of day you plan to actually sit the exam.

Daily Study Routine

Suggested 2–3 Hour Day

TimeActivity
15 minLook over yesterday's wrong answers. For each one, identify the principle you missed.
30 minRead Anthropic documentation for this week's topic
30 minHands-on coding with Claude API, Agent SDK, or Claude Code
30 minTake an ExamOS quiz (Challenger or Legend mode, depending on the week)
15 minLog missed concepts and review them the next morning

Stay consistent by setting a target date for this certification.

Set target
  • Take a task you would normally hardcode as a script and design it two ways: as a fixed workflow and as an agent. Write down which one you would actually ship and why.
  • Practice decomposing one complex, ambiguous request into subtasks. Identify where a naive decomposition would fail.
  • Take the ExamOS Rookie mode quiz on Agentic Architecture (30 questions). Note any area below 60%.
  • Goal:Be able to justify, in one sentence, why a given scenario calls for an agent rather than a workflow.
    Rookie Mode
    Rookie Mode
  • Design an escalation rule for a scenario where the agent should not trust its own confidence score to decide when to hand off.
  • Take the ExamOS Challenger quiz on Agentic Architecture. Repeat until you pass 2 times in a row.
  • Goal:Design a hub-and-spoke system and correctly argue when parallel subagent dispatch is worth its token cost and when it is not.
    Challenger Mode
    Challenger Mode
  • Stand up a minimal MCP server using stdio transport and connect Claude to it.
  • Build a toolset large enough (15+ tools) to see selection degradation firsthand, then apply tool search or scoping to fix it.
  • Take the ExamOS Challenger quiz on Tool Design and MCP. Repeat until you pass 2 times in a row.
  • Goal:Diagnose, from a scenario description alone, whether a tool-selection failure is caused by a bad description, an oversized toolset, or a scoping problem.
    Challenger Mode
    Challenger Mode
  • Write one Agent Skill (SKILL.md with frontmatter) for a repeated task.
  • Configure a permission rule set and deliberately test what happens when a user-level deny meets a project-level allow (deny wins).
  • Integrate Claude Code into a CI/CD pipeline using non-interactive mode.
  • Take the ExamOS Challenger quiz on Claude Code Configuration. Repeat until you pass 2 times in a row.
  • Goal:Correctly predict which permission rule wins in a three-way conflict between managed, project, and user settings without looking it up.
    Challenger Mode
    Challenger Mode
  • Build a validator-and-retry loop that catches a schema violation and retries with corrective instructions.
  • Deliberately let a long-running agent's context grow past a reasonable size, observe the quality drop, then fix it with compaction.
  • Set up prompt caching on a stable system prompt and tool set. Confirm what a mid-session edit does or does not invalidate.
  • Take the ExamOS Challenger quiz on Prompt Engineering and Context Management. Repeat until you pass 2 times in a row.
  • Goal:Given a long-running agent scenario, correctly choose between compaction, context editing, and the memory tool based on what is actually degrading.
    Challenger Mode
    Challenger Mode
  • For every Legend question you miss, review the explanation and write one sentence naming the architectural principle behind the correct answer.
  • Review all 6 official production scenarios. Only 4 appear per sitting, but you will not know which 4 in advance.
  • Once you are consistently hitting 80% or above on Legend mode across two or more sessions, book your exam. You are ready.
  • Goal:Consistent above 80% on Legend mode across two or more sessions. Confidence to schedule the exam.
    Legend Mode
    Legend Mode

    Overview

    The CCA-F validates your ability to design and deploy production-grade Claude integrations. It tests architectural judgment in real-world scenarios, not definition recall. Questions are anchored in system design problems where you must choose the right approach, justify trade-offs, and reason about reliability, cost, and safety.

    If you already work with the Claude API and Claude Code, you have the hands-on foundation this exam assumes. This plan builds on it by shifting your focus from "how do I use this feature?" to "when and why is this the right architectural choice?"

    Domain Weight
    Agentic architecture and orchestration 27%
    Claude Code configuration and workflows 20%
    Prompt engineering and structured output 20%
    Tool design and MCP integration 18%
    Context management and reliability 15%

    Agentic architecture is the single largest domain and the one most candidates underestimate. It is also the conceptual foundation for how questions in other domains are framed. This plan dedicates two weeks to it.

    Recommended experience: Approximately 6 months of hands-on experience with the Claude API and Claude Code. Understanding of LLM APIs, prompting fundamentals, and message roles.

    Frequently Asked Questions

    Do I need prior LLM experience?

    Basic understanding of LLM APIs is helpful but not required. The certification covers Claude-specific concepts. Approximately 6 months of hands-on experience with the Claude API and Claude Code is a realistic baseline, though motivated candidates with less experience have passed with focused preparation.

    Why does this plan dedicate two weeks to agentic architecture?

    Because it is 27% of the exam and the conceptual foundation for every other domain. Tool design, context management, and Claude Code configuration all assume you understand agentic patterns. Candidates who skim this domain consistently underperform across the entire exam.

    What if i have only 4 weeks to study instead of 6 weeks?

    • Week 1: Merge current Weeks 1–2 (all of Agentic Architecture). This is the biggest domain but do not shortcut it, just move faster.
    • Week 2: Merge current Weeks 3–4 (Tool Design/MCP + Claude Code Configuration). These overlap conceptually (MCP servers show up inside Claude Code), so studying them back-to-back reinforces rather than fragments.
    • Week 3: Current Week 5 unchanged (Prompt Engineering + Context Management).
    • Week 4: Current Week 6 unchanged (Legend mode + booking). Do not compress this, it is the gate that tells you whether you are actually ready.

    How many practice questions should I do?

    Aim for at least 600 unique questions across all domains, ensuring you prioritize quality over quantity. ExamOS provides over 2,000 high quality practice questions covering all domains and designed to explain the rationale behind both correct and incorrect answers.

    When should I book the exam?

    Once you are consistently hitting 80% or above on Legend mode across two or more sessions, and you feel confident explaining architecture decisions for production Claude systems, you are ready. Trust your preparation.

    How long is the exam?

    120 minutes for 60 questions. That averages to 2 minutes per question, but scenario-heavy questions with long context may take 3-4 minutes. Budget your time accordingly.

    What are the core technologies tested?

    Claude Code, Claude Agent SDK, Claude API, and Model Context Protocol (MCP).

    How is this different from other AI certifications?

    CCA-F focuses on decision-making in production contexts, not definition recall. Every question is anchored in a scenario where you must choose the right architectural approach. Knowing what a feature does is table stakes. Knowing when to use it and when not to is what the exam measures.

    What is the most important domain to study?

    Agentic architecture and orchestration (27%) is the single largest domain and the conceptual foundation for how questions in other domains are framed. Tool design, context management, and Claude Code configuration all build on agentic patterns. Get this domain right first.

    Can I use reference materials during the exam?

    No. The CCA-F exam is closed-book. You cannot access external documentation, websites, or AI assistants during the test. All questions are designed to be answerable from your knowledge of Claude architecture, the Claude API, Claude Code, and MCP. Study and practice thoroughly before exam day.

    What are the most common ways people fail?

    • Confusing agents with workflows. Knowing when agentic architecture adds value versus when a deterministic pattern is simpler and more reliable is tested constantly.
    • Ignoring token cost trade-offs in multi-agent systems. Parallel subagent dispatch is powerful but expensive. The exam tests whether you understand when the cost is justified.
    • Poor tool descriptions. Vague descriptions cause the model to misroute or fail to select the right tool. This is one of the most common failure scenarios.
    • Not understanding context rot. Assuming more context is always better is a trap. Long-running sessions degrade accuracy, and the exam tests whether you know how to fix it.
    • Studying features in isolation. The exam tests combined scenarios where multiple domains interact: an agent with MCP tools, structured output, and context management all in one question.

    What are the three biggest preparation mistakes?

    1. Studying documentation without building. CCA-F is a practical, scenario-based exam. If you have not built an agent loop, stood up an MCP server, or configured CLAUDE.md precedence, you will struggle with scenario questions.
    2. Skipping agentic architecture depth. It is 27% of the exam and the foundation for every other domain. Candidates who skim this domain consistently underperform.
    3. Not practicing under time pressure. 60 questions in 120 minutes means you cannot afford to deliberate on every question. Practice timed quizzes to build decision-making speed.


    Quick-Reference: What Is on the Exam (Exam Guide v0.2, June 30, 2026)

    This is a condensed summary. For the definitive list, visit Anthropic's certification page.

    Domain Key Skills
    Agentic architecture and orchestration (27%) Agentic loop mechanics and stop_reason handling, agents vs workflows vs conversational systems, task decomposition and planning strategies, multi-agent orchestration (hub-and-spoke, parallel dispatch), escalation loops and human-in-the-loop patterns, subagent context isolation and delegation
    Claude Code configuration and workflows (20%) Claude Code architecture and execution model, CLAUDE.md hierarchy (user, project, subdirectory) and load timing, Agent Skills (SKILL.md, frontmatter, triggers, progressive disclosure), hooks and lifecycle events, permissions model (managed > project > user deny-wins precedence), Claude Agent SDK for programmatic session control, CI/CD integration with non-interactive mode
    Prompt engineering and structured output (20%) XML tag structuring and few-shot prompting, extended thinking and adaptive thinking, effort parameter for reasoning depth tuning, native structured output (constrained sampling against JSON schema) vs strict tool use, validator and retry loops for output reliability
    Tool design and MCP integration (18%) Tool description best practices for reliable model selection, scoping tools per agent role to prevent selection degradation, tool search and deferred schema loading, MCP primitives (tools, resources, prompts), MCP server design, MCP transports (stdio, SSE, HTTP)
    Context management and reliability (15%) Context rot and its impact on long-running sessions, compaction (server-side conversation summarization), context editing (client-side clearing of stale results), memory tool for cross-session persistence, prompt caching (cache breakpoints, invalidation triggers, cost trade-offs)