Claude Certified Architect - Foundations course
6 modules, one per exam domain. 56 lessons, each ending in a checkpoint; 6 timed practice tests.
One purchase covers the lessons and the tests.
What does the CCA‑F course cover?
Every module is one of the 5 exam domains Anthropic publishes, in exam order, with the domain's share of the exam as its bar. Agentic Architecture and Orchestration and Claude Code Configuration and Workflows carry the most at 27% and 20%. The exam runs 120 minutes for 60 questions (all scored). Open a module for its lessons; the practice tests close the course.
Build the loop that lets Claude act, then put a coordinator in front of many agents and keep control of every message.
27% of the exam · Exam domain: Agentic Architecture & Orchestration
The Agentic Loop
One turn of an agent, from the request to the tool result that starts the next turn.
- 1.1
The Agentic Loop, One Turn at a Time
An agent is a loop around one model call · Claude asks for a tool, your code runs it · Tool results go back into the conversation history · The model decides the next action from the new context · The loop is model driven, so no fixed tool order applies
25 minHigh priority
- 1.2
Reading stop_reason to Control the Loop
stop_reason tool_use means run the tool and loop again · stop_reason end_turn means the task is complete · The loop condition is a field, so it needs no parsing · Every tool result is appended before the next request · max_tokens and stop_sequence are separate outcomes
25 minHigh priority
- 1.3
Loop Anti-Patterns That Break Termination
Do not read the text to guess that the agent finished · Do not use an iteration cap as the main stop rule · An iteration cap is a safety net behind stop_reason · Dropping tool results makes the model repeat the call · A fixed tool sequence removes the model decision
25 minHigh priority
Coordinator and Subagents
Hub and spoke, isolated context, and the Task tool that spawns the spokes.
- 1.4
Hub and Spoke: The Coordinator Owns Every Message
The coordinator routes all traffic between subagents · One route gives you one place to log and recover · The coordinator decomposes, delegates and aggregates · Query complexity decides which subagents run · Direct subagent chatter removes observability
25 minHigh priority
- 1.5
Subagent Context Is Never Inherited
A subagent starts with an empty conversation · The prompt must carry every finding the subagent needs · Structured fields keep content apart from source metadata · Attribution survives only if you pass it forward · Shared memory between invocations does not exist
25 minHigh priority
- 1.6
Spawning Subagents with the Task Tool
The Task tool spawns a subagent · allowedTools must include Task for the coordinator · AgentDefinition sets the description, prompt and tools · Several Task calls in one response run in parallel · Spawning across turns makes the work sequential
25 minHigh priority
- 1.7
Partitioning Scope and Refining Until Coverage Is Enough
Give each subagent a distinct subtopic or source type · Overlapping scope buys duplicate findings · Narrow decomposition leaves parts of the topic uncovered · The coordinator reads the synthesis and looks for gaps · Targeted re-delegation closes a gap without a full rerun
25 minCore topic
Enforcement, Hooks and Handoff
Where a prompt is enough, and where only code gives you a guarantee.
- 1.8
Prerequisite Gates: The Guarantee a Prompt Cannot Give
Prompt instructions fail some fraction of the time · A gate blocks the tool call until the prerequisite returns · Identity verification before money movement needs a gate · Guidance suits preference, enforcement suits policy · The gate lives in your code, so the model cannot skip it
25 minHigh priority
- 1.9
Agent SDK Hooks for Interception and Normalization
PostToolUse hooks transform a result before the model reads it · Normalize timestamps and status codes in one place · A call interception hook blocks a policy violation · A blocked action can redirect to human escalation · Hooks are deterministic, prompts are probabilistic
25 minHigh priority
- 1.10
Structured Handoff When a Human Takes Over
The human agent cannot see the conversation transcript · A handoff carries the customer ID and the root cause · State the amount and the recommended action · Escalation mid-process still needs the full summary · A transcript dump is not a handoff
25 minCore topic
Decomposition and Sessions
Choose a pipeline or an adaptive plan, then decide whether to resume, fork or start fresh.
- 1.11
Fixed Pipelines and Adaptive Decomposition
Prompt chaining suits a predictable multi-aspect review · Dynamic decomposition suits open-ended investigation · An adaptive plan creates subtasks from what it finds · Map the structure first on an unfamiliar codebase · Prioritize high-impact areas before writing the plan
25 minHigh priority
- 1.12
Per-File Passes and the Cross-File Pass
One large review dilutes attention across files · A local pass reviews each file on its own · A separate pass looks at flow between files · Integration issues appear only in the cross-file pass · The split also keeps each prompt inside a sane budget
25 minCore topic
- 1.13
Sessions: Resume, Fork or Start Fresh
--resume with a session name continues one conversation · fork_session branches from a shared baseline · Two forks explore two approaches from one analysis · Tell a resumed session which files changed · Stale tool results beat nothing, a fresh summary beats both
25 minHigh priority
Write tool descriptions the model can choose between, return errors it can act on, and wire MCP servers into the right scope.
18% of the exam · Exam domain: Tool Design & MCP Integration
Tool Interfaces
The description is the interface the model reads, so it decides which tool runs.
- 2.1
The Tool Description Is the Selection Mechanism
The model picks a tool from its description · A minimal description makes selection unreliable · State the input format and give an example query · Name the edge cases and the boundary of the tool · Say when to use this tool instead of the near neighbor
25 minHigh priority
- 2.2
Removing Overlap: Rename, Split, Scope
Two similar descriptions cause misrouting · Rename a vague tool to name its real job · Split a generic tool into purpose-specific tools · Each tool gets a defined input and output contract · A constrained tool prevents a whole class of misuse
25 minHigh priority
- 2.3
When the System Prompt Overrides Your Tool Description
Keyword-sensitive wording creates unintended associations · A good description loses to a stronger prompt cue · Review the system prompt when routing looks wrong · Fix the prompt wording before rewriting the tool · Test routing with the ambiguous request that failed
25 minCore topic
Errors and Tool Distribution
What a failing tool must tell the agent, and how many tools one agent can hold.
- 2.4
Structured Tool Errors with isError
The MCP isError flag reports a tool failure · A generic failure message blocks any recovery decision · Return errorCategory, isRetryable and a readable reason · A business rule violation carries retriable false · Add a customer-friendly explanation the agent can repeat
25 minHigh priority
- 2.5
Four Error Categories and What Each One Buys
Transient errors come from timeouts and outages · Validation errors come from bad input · Business errors come from policy · Permission errors come from access rules · An empty result is a success, so never flag it as an error
25 minHigh priority
- 2.6
Tool Budgets, Scoped Access and tool_choice
Eighteen tools select worse than four or five · Give each agent only the tools its role needs · An off-role tool invites off-role behavior · A scoped cross-role tool covers a frequent need · tool_choice auto, any, or a named tool sets the rule
25 minHigh priority
MCP and Built-In Tools
Where a server belongs, what a resource is for, and which built-in tool answers which question.
- 2.7
Where an MCP Server Belongs: Project or User Scope
Project scope lives in .mcp.json and ships in git · User scope lives in ~/.claude.json and stays personal · Expand ${GITHUB_TOKEN} so no secret enters the repo · All configured servers connect and offer tools at once · Prefer a community server for a standard integration
25 minHigh priority
- 2.8
MCP Resources and Descriptions That Win
A resource exposes a catalog of available content · A catalog removes exploratory tool calls · Issue summaries and schemas suit resources · A thin MCP description loses to a built-in tool · Describe the output, so the agent knows the payoff
25 minCore topic
- 2.9
Built-In Tools: Grep, Glob, Read, Write, Edit, Bash and LSP
Grep searches file contents for a pattern · Glob matches file paths by name pattern · Read and Write handle a whole file · Edit changes a unique piece of text · Read plus Write is the fallback when the anchor repeats · LSP answers symbol questions when a language server runs
25 minHigh priority
Configure the memory files, commands, skills and rules that a team shares, then run Claude Code without a human at the keyboard.
20% of the exam · Exam domain: Claude Code Configuration & Workflows
Memory and Rules
The files that tell Claude Code how this repository works.
- 3.1
The CLAUDE.md Hierarchy and Who Sees It
User level sits at ~/.claude/CLAUDE.md · Project level sits at CLAUDE.md or .claude/CLAUDE.md · A directory CLAUDE.md scopes rules to a subtree · User level never reaches a teammate through git · /memory shows which memory files loaded
25 minHigh priority
- 3.2
Modular Memory: @import and .claude/rules
@import pulls an external file into CLAUDE.md · Each package imports the standards it needs · .claude/rules holds topic files such as testing.md · A monolithic memory file loads context nobody needs · Split by topic, then import by relevance
25 minCore topic
- 3.3
Path-Scoped Rules with Glob Frontmatter
A rules file takes a paths field in its frontmatter · The rule loads only when a matching file is edited · Glob patterns cross directory boundaries · **/*.test.tsx reaches every test file in the repo · Path rules beat directory memory for scattered conventions
25 minHigh priority
Commands and Skills
Two ways to package a workflow, and the frontmatter that keeps it contained.
- 3.4
Slash Commands: Project Scope and User Scope
.claude/commands ships commands to the team · ~/.claude/commands keeps a command personal · A command is a prompt the team can reuse · Version control makes the command reviewable · Name the command for the job it does
25 minCore topic
- 3.5
Skills, Frontmatter and context: fork
A skill lives in .claude/skills with a SKILL.md · context: fork runs the skill in an isolated subagent · A forked skill keeps verbose output out of the session · allowed-tools restricts what the skill may do · argument-hint prompts for the missing parameter
25 minHigh priority
Working Modes
Plan first or act now, and how to iterate when the first answer misses.
- 3.6
Plan Mode or Direct Execution
Plan mode suits architectural and multi-file work · Direct execution suits a scoped single-file change · Several valid approaches call for a plan · Planning explores safely before any file changes · Plan the migration, then execute the plan directly
25 minHigh priority
- 3.7
The Explore Subagent for Verbose Discovery
Discovery output fills a context window fast · Explore runs the search and returns a summary · The main session keeps its high-level thread · Use it before a multi-phase task, not after · A summary is cheaper to carry than a file dump
25 minCore topic
- 3.8
Iterative Refinement: Examples, Tests and the Interview
Two or three input and output pairs beat a paragraph · Write the test suite first, then share the failures · The interview pattern surfaces the questions you missed · Interacting problems go in one message · Independent problems go one at a time
25 minHigh priority
Claude Code in CI
Headless runs, machine-readable output and reviews that stay useful.
- 3.9
Headless Claude Code: -p, JSON and Schemas
The -p flag runs one prompt and exits · Interactive mode hangs a pipeline · --output-format json gives parseable output · --json-schema pins the shape of the findings · CLAUDE.md carries the project context into CI
25 minHigh priority
- 3.10
Review Bots That Do Not Repeat Themselves
Pass prior findings into the next review run · Ask for new or unresolved issues only · A generator reviewing itself misses its own reasoning · An independent instance reviews without that context · Existing test files stop duplicate test suggestions
25 minHigh priority
Write criteria a reviewer can apply, force the output into a schema, then validate what comes back.
20% of the exam · Exam domain: Prompt Engineering & Structured Output
Precision and Examples
Why explicit criteria and a few examples move quality where instructions do not.
- 4.1
Explicit Criteria Against Vague Instruction
Name the condition that makes an issue reportable · Be conservative gives the model no rule to apply · List which categories to report and which to skip · Define each severity with a code example · Concrete criteria produce consistent classification
25 minHigh priority
- 4.2
False Positives and Developer Trust
One noisy category discredits the accurate ones · Developers stop reading a bot that cries wolf · Disable the noisy category while you fix its prompt · Measure the rate per category, never in aggregate · Restore the category after the prompt improves
25 minHigh priority
- 4.3
Few-Shot Examples That Teach Judgment
Two to four examples beat another paragraph of rules · Show the reasoning for the choice you made · Cover the ambiguous case, not the easy one · Examples fix output format as well as decisions · The model generalizes the judgment to new patterns
25 minHigh priority
Structured Output
Tool use as the contract, and the schema choices that stop fabrication.
- 4.4
Tool Use as the Output Contract
A tool schema guarantees valid JSON · Read the data from the tool_use block · Syntax errors disappear, semantic errors do not · A total that does not sum still passes the schema · Validate meaning in your own code
25 minHigh priority
- 4.5
tool_choice: auto, any and Forced
auto lets the model answer with text · any forces a tool call and lets the model pick · A named tool forces one specific call · Force extract_metadata before the enrichment step · any suits an unknown document type with several schemas
25 minHigh priority
- 4.6
Schema Design: Optional Fields, Enums and unclear
A required field invites a fabricated value · Make a field nullable when the source may omit it · An enum plus other and a detail string stays extensible · Add unclear for the genuinely ambiguous case · Put format normalization rules in the prompt
25 minHigh priority
- 4.7
Validation, Retry and the Limits of Retry
Send the document, the failed output and the errors · Specific errors guide a correction · A missing fact never appears on the second try · Format and structure errors do respond to retry · Extract calculated_total beside stated_total to catch drift
25 minHigh priority
Scale and Review
Batch work that can wait, and review passes that catch what one pass misses.
- 4.8
The Message Batches API and Its Limits
Batch costs half of the synchronous price · Processing takes up to 24 hours with no latency SLA · Overnight and weekly jobs fit the batch API · A pre-merge check needs the synchronous API · Batch requests cannot run tools mid-request
25 minHigh priority
- 4.9
Sizing Batch Windows Against an SLA
custom_id links each response to its request · Submission frequency plus 24 hours must fit the SLA · Four-hour submissions meet a 30-hour promise · Resubmit only the failed custom_ids · Chunk the document that exceeded the context limit
25 minCore topic
- 4.10
Independent Review Instances and Multi-Pass Design
A model keeps its own reasoning in session · Self-review rarely questions that reasoning · A fresh instance reviews without the generator context · Per-file passes catch local issues · Self-reported confidence routes the review queue
25 minHigh priority
Keep the facts that matter inside a long conversation, escalate at the right moment, and never lose the source of a claim.
15% of the exam · Exam domain: Context Management & Reliability
Managing a Long Context
What summarizing costs you, where the model reads least, and how to survive a long exploration.
- 5.1
What Summarization Loses, and the Case Facts Block
Summaries flatten amounts, dates and order numbers · A customer expectation becomes a vague sentence · Keep transactional facts in a separate block · Include that block in every prompt · Trim a 40-field tool result to the five fields you use
25 minHigh priority
- 5.2
Lost in the Middle, and How to Order a Long Input
Models read the start and the end most reliably · Findings in the middle can drop out · Put the key findings summary at the top · Give every detailed section an explicit header · Ask subagents for structured output with metadata
25 minHigh priority
- 5.3
Long Explorations: Scratchpads, Subagents and /compact
Extended sessions drift toward typical patterns · A scratchpad file holds findings across the boundary · Subagents keep verbose discovery out of the main thread · /compact reduces context during a long session · A state manifest lets a crashed run resume
25 minHigh priority
Escalation and Error Propagation
When the agent should stop, and what a failing subagent owes the coordinator.
- 5.4
Escalation Triggers That Hold Up
Honor an explicit request for a human at once · Escalate when policy is silent on the request · Escalate when progress has stopped · Sentiment is a poor proxy for complexity · Self-reported confidence is another poor proxy
25 minHigh priority
- 5.5
Ambiguity: Ask for One More Identifier
Several customer matches means the lookup is ambiguous · A heuristic pick is a silent wrong answer · Ask for an order number or a postal code · Acknowledge frustration and still offer the fix · Escalate if the customer repeats the request
25 minCore topic
- 5.6
Error Propagation Across Agents
Return the failure type and what was attempted · Include partial results and an alternative · Recover locally from a transient failure · Propagate only what the subagent cannot fix · Silent suppression and full shutdown are both wrong
25 minHigh priority
Confidence and Provenance
Prove the accuracy before you automate, and keep every claim attached to its source.
- 5.7
Confidence Calibration and Stratified Sampling
An aggregate accuracy figure hides a weak segment · Check accuracy by document type and by field · Sample high-confidence extractions at random · Calibrate field confidence on a labeled set · Route low confidence to the reviewer queue
25 minHigh priority
- 5.8
Provenance: Claim-Source Mappings and Conflicts
Summarization drops the link from claim to source · Subagents output claim and source together · Synthesis merges mappings and keeps them · Annotate a conflict with both sources · Dates stop a time difference looking like a contradiction
25 minHigh priority
The exam frames its questions inside six production contexts. Each lesson walks one context and names the decision each domain forces.
Scenario Walk-Throughs
Four of these six scenarios appear on your exam, chosen at random.
- 6.1
Scenario 1: Customer Support Resolution Agent
MCP tools reach the backend systems · A gate blocks a refund before verification · Case facts survive a long conversation · Escalation criteria decide the handoff · First-contact resolution is the target metric
25 minHigh priority
- 6.2
Scenario 2: Code Generation with Claude Code
CLAUDE.md carries the team conventions · Slash commands package the repeated work · Plan mode covers the architectural change · Direct execution covers the scoped fix · Context degrades over a long refactor
25 minHigh priority
- 6.3
Scenario 3: Multi-Agent Research System
A coordinator delegates to four specialists · Scope partitioning stops duplicate research · Claim-source mappings survive synthesis · Structured errors keep coverage honest · The report cites what it used
25 minHigh priority
- 6.4
Scenario 4: Developer Productivity with Claude
Built-in tools explore an unfamiliar codebase · Grep finds the entry point, Read follows the imports · MCP servers add the systems around the code · Subagents isolate the verbose searches · Boilerplate generation needs a worked example
25 minHigh priority
- 6.5
Scenario 5: Claude Code for Continuous Integration
Headless runs post inline PR comments · A JSON schema shapes each finding · Explicit criteria cut the false positives · Prior findings prevent duplicate comments · An independent instance reviews the generated code
25 minHigh priority
- 6.6
Scenario 6: Structured Data Extraction
Tool use guarantees a valid JSON shape · Optional fields stop fabricated values · Retry with the validation errors attached · Batch processing suits the overnight run · Sampling proves the accuracy before automation
25 minHigh priority
Each test mirrors the real exam: 120 minutes, 65 questions, all domains in proportion. Learning mode shows the explanation after each answer; exam mode runs the clock and scores at the end. The study plan below schedules them across the weeks.
- 1
Practice test 1
With strong focus on Agentic Architecture & Orchestration. Covers agentic loop design, hub-and-spoke multi-agent patterns, subagent context isolation, parallel execution, session management, and failure recovery in production Claude applications.
65 questions · 120 min
- 2
Practice test 2
Emphasizing Tool Design & MCP Integration and Claude Code Configuration. Covers tool description best practices, MCP server configuration, CLAUDE.md hierarchy, skills frontmatter, CI/CD pipeline integration, and path-specific rules.
65 questions · 120 min
- 3
Practice test 3
With deep coverage of Prompt Engineering & Structured Output and Context Management & Reliability. Covers few-shot prompting, JSON schema validation, Batch API constraints, lost-in-the-middle mitigation, error propagation patterns, and crash recovery.
65 questions · 120 min
- 4
Practice test 4
Full exam simulation #4 matching real CCA-F domain weights. Covers all five domains proportionally: agentic architecture, tool design, Claude Code workflows, prompt engineering, and context management with production-grade scenarios.
65 questions · 120 min
- 5
Practice test 5
Focusing on anti-patterns and common mistakes. Tests the 7 most frequently tested anti-patterns: prompt-based ordering enforcement, self-reported confidence for escalation, batch API misuse, context window misconceptions, silent failures, tool overloading, and prompt-only JSON enforcement.
65 questions · 120 min
- 6
Practice test 6
Advanced difficulty practice exam #6 with complex multi-layered scenarios and nuanced trade-off decisions. Covers cross-domain concepts, production debugging, cost-vs-latency trade-offs, and edge cases in tool design, MCP configuration, and context management.
65 questions · 120 min
Try 15 free questions on the certificate page before you buy.
What does a lesson look like?
Lesson 1.1, played through: read the concept, play the mini-game, pass the checkpoint, and the next lesson is queued. Every lesson in the course runs this way; 184 diagrams and mini-games and 168 checkpoints in all.
1.1The agentic loop, one turn at a time25 min
On this page
- The four steps of a turn, and who runs each one
- The field that ends the loop
An agent is a loop. Your code sends a request to Claude. Claude answers with text, or it asks for a tool.
Your code runs the tool, adds the result to the conversation, and sends the conversation again. The loop runs until Claude has nothing left to ask for.
The model chooses each action. Your code supplies the tools and the loop.
How long does it take to prepare with this course?
About 23 hours of lessons, 56 of them at roughly 25 minutes each. The modules run in exam order, so the heaviest domains come first. Pick a pace and the plan lays itself out.
- Week 1Agentic Architecture and Orchestration5h 25m of lessons5h 25m
- Week 2Tool Design and MCP Integration · Claude Code Configuration and WorkflowsPractice tests 1 and 27h 55m of lessons7h 55m
- Week 3Prompt Engineering and Structured OutputPractice tests 3 and 44h 10m of lessons4h 10m
- Week 4Context Management and Reliability · The Six Exam ScenariosPractice tests 5 and 6 · Schedule the exam once you clear 75% on a fresh test5h 50m of lessons5h 50m
Is it enough to pass?
- 511
- 42
- 31
- 20
- 10
Good tests
I like the tests, though, I wish they were 60 questions instead of 65 to match the exam. Small little thing. The tests so far have been pretty good.
Verified purchase · Jun 2026
Nive pratice test
This test cover all the needed areas with visual and reasonable explanations about the correct answers.
Verified purchase · Aug 2026
I liked the entire setup
Difficult enough questions. Clear and detailed explanation with visuals.
Verified purchase · Aug 2026
Ready to start the CCA-F course?
The course and the practice tests come together in one purchase, or go Pro to add 12 build-and-submit projects for this cert plus every other track on Preporato.
Course + practice tests
Lifetime access: pay once, study forever
- 56 interactive lessons with checkpoints
- 6 full-length practice tests
- 390+ exam-style questions
- Detailed explanations for every answer
- Exam mode & learning mode
- ×No hands-on labs
Preporato Pro
Billed monthly, cancel anytime
- 12 build-and-submit projects for CCA-F, graded instantly
- Every course and practice test across every certification
- GPU sandboxes and hosted environments
- Flashcards, study guides and articles
- Cancel anytime, no contract
from$19.99course + tests