# CCAR-F Course Overview

Claude Certified Architect – Foundations. Blueprint, audience, study allocation, the six exam scenarios, and how to use this course.

import { Card, CardGrid, Badge } from '@prosefly/astro-components';

<Badge color="accent" variant="soft">Exam code CCAR-F</Badge> <Badge color="info" variant="soft">60 items · 120 min</Badge> <Badge color="success" variant="soft">$125</Badge> <Badge color="warning" variant="soft">Pass 720/1000</Badge>

## What the credential validates

That you can **design agentic systems on Claude that are correct, reliable and cost-aware** – choosing between workflows and agents, orchestrating coordinator/subagent hierarchies, configuring Claude Code for teams, engineering prompts and structured output, designing tools and MCP integrations, and managing the context window and failure modes that make or break production systems.

The Architect – Foundations exam is **scenario-driven**. Items are drawn from **4 of 6** reference scenarios, so you must be able to reason about a described system, not just recall a definition. Every question is really asking: *given these constraints, what is the correct architectural decision, and which tempting options are the anti-patterns?*

**Intended for:** solutions architects, technical leads and senior engineers who design Claude-based agentic systems and set standards for teams building with the API, the Agent SDK, Claude Code and MCP.

**Not intended for:** non-technical business users (see CCAO-F Associate) or those who only write application code without designing the system (much of CCDV-F Developer overlaps but is implementation-first).

## Blueprint (Exam Guide v1.0, July 2026)

| # | Domain | Weight | Items (approx.) | Course page |
| --- | --- | --- | --- | --- |
| 1 | Agentic Architecture and Orchestration | **27%** | ~16 | [Domain 1](/ccar-f/domains/d1-agentic-architecture-orchestration/) |
| 2 | Claude Code Configuration and Workflows | 20% | ~12 | [Domain 2](/ccar-f/domains/d2-claude-code-configuration-workflows/) |
| 3 | Prompt Engineering and Structured Output | 20% | ~12 | [Domain 3](/ccar-f/domains/d3-prompt-engineering-structured-output/) |
| 4 | Tool Design and MCP Integration | 18% | ~11 | [Domain 4](/ccar-f/domains/d4-tool-design-mcp-integration/) |
| 5 | Context Management and Reliability | 15% | ~9 | [Domain 5](/ccar-f/domains/d5-context-management-reliability/) |

:::tip[Where the marks are]
Agentic Architecture (27%) plus the two 20% domains are **67%** of the exam. If you can (a) pick workflow-vs-agent and the right orchestration pattern, (b) configure Claude Code correctly, and (c) get structured output out of the model reliably, you are two-thirds of the way to a pass before touching tools and context management.
:::

## The six exam scenarios

Items are drawn from **4 of the 6** scenarios below. You will not know in advance which four, so prepare all six. Each maps to a cluster of domains.

| # | Scenario | Primary domains | Signature decisions |
| --- | --- | --- | --- |
| 1 | Customer Support Resolution Agent | D1, D4, D5 | Agent SDK, MCP tools, capability-based escalation |
| 2 | Code Generation with Claude Code | D2, D3 | CLAUDE.md hierarchy, plan mode, slash commands, hooks |
| 3 | Multi-Agent Research System | D1, D5 | Coordinator/subagent, explicit context passing, partial-failure handling |
| 4 | Developer Productivity | D2, D4 | Built-in tools, MCP servers, codebase exploration |
| 5 | Claude Code for CI/CD | D2, D3 | Headless mode, structured output, Batch API, multi-pass review |
| 6 | Structured Data Extraction | D3, D4 | JSON schemas, tool_use-as-schema, validation-retry |

Full write-ups, reference architectures and 18 practice questions are on the [Scenarios page](/ccar-f/scenarios/).

## The Architect's mindset

The exam rewards one posture repeatedly: **determinism where correctness matters, the model where judgment matters, and explicit contracts everywhere between them.** Correct answers tend to:

- Prefer the **simplest** solution that meets the requirement – a single prompt or workflow before a multi-agent system.
- Drive control flow from **`stop_reason`**, not from parsing the model's prose or capping iterations.
- Enforce critical business rules with **programmatic hooks**, never with prompt instructions.
- Escalate on **explicit request** (immediately) or **capability** (after attempting resolution) – never on sentiment or self-reported confidence.
- Pass context to subagents **explicitly**; never rely on auto-inheritance.
- Surface **structured errors** (category, retryable, partial results) rather than generic messages or silent empty results.
- Give each agent **4–5 focused tools**; use tool search and `defer_loading` beyond ~10.
- Protect the main context window with **subagent isolation, context editing and compaction**, and put anything that must survive in the **memory tool** or external state.

Wrong answers tend to: over-engineer (multi-agent where a workflow suffices), trust the model's self-report, enforce rules by prompt, hide errors, overload agents with tools, and let the context window fill until quality degrades.

## Suggested time allocation (30-hour plan)

| Domain | Weight | Hours |
| --- | --- | --- |
| Agentic Architecture and Orchestration | 27% | 9 |
| Claude Code Configuration and Workflows | 20% | 6 |
| Prompt Engineering and Structured Output | 20% | 6 |
| Tool Design and MCP Integration | 18% | 5 |
| Context Management and Reliability | 15% | 4 |

## Hands-on preparation checklist

- [ ] Build a two-tier **coordinator/subagent** system and pass context to a subagent **explicitly**; observe what breaks if you rely on inheritance.
- [ ] Implement an agentic loop that terminates on **`stop_reason`** and handles `tool_use`, `end_turn`, `max_tokens`, `pause_turn` and `refusal`.
- [ ] Write a Claude Code **PreToolUse hook** that blocks `rm -rf` and a **PostToolUse hook** that runs a linter; confirm exit code 2 blocks the action.
- [ ] Configure a project **CLAUDE.md** hierarchy with an `@import` and a `.claude/agents/` subagent with its own tool allowlist and model.
- [ ] Get structured output three ways – **`output_config.format` JSON schema**, **tool-use-as-schema**, and **strict tools** – and note when each is correct.
- [ ] Stand up a minimal **MCP server** (stdio) exposing one tool and one resource; connect it from Claude Code and via the Messages API MCP connector.
- [ ] Force a **validation-retry loop**: return a schema error to the model and confirm it self-corrects.
- [ ] Trigger **compaction** and **context editing** on a long session; verify what survives via the **memory tool**.

## Course pages

<CardGrid>
  <Card title="D1 · Agentic Architecture and Orchestration" href="/ccar-f/domains/d1-agentic-architecture-orchestration/" icon="lucide:network">27%</Card>
  <Card title="D2 · Claude Code Configuration and Workflows" href="/ccar-f/domains/d2-claude-code-configuration-workflows/" icon="lucide:terminal">20%</Card>
  <Card title="D3 · Prompt Engineering and Structured Output" href="/ccar-f/domains/d3-prompt-engineering-structured-output/" icon="lucide:braces">20%</Card>
  <Card title="D4 · Tool Design and MCP Integration" href="/ccar-f/domains/d4-tool-design-mcp-integration/" icon="lucide:plug">18%</Card>
  <Card title="D5 · Context Management and Reliability" href="/ccar-f/domains/d5-context-management-reliability/" icon="lucide:gauge">15%</Card>
  <Card title="The 6 Exam Scenarios" href="/ccar-f/scenarios/" icon="lucide:layout-dashboard">Reference architectures + 18 questions</Card>
  <Card title="The 10 Anti-Patterns" href="/ccar-f/anti-patterns/" icon="lucide:triangle-alert">The distractors, decoded</Card>
  <Card title="Practice Exam 1" href="/ccar-f/practice-exam/" icon="lucide:clipboard-check">60 timed items</Card>
  <Card title="Practice Exam 2" href="/ccar-f/practice-exam-2/" icon="lucide:clipboard-check">60 new, harder items</Card>
</CardGrid>