CCAR-F — Claude Certified Architect, Foundations
Anthropic’s first professional certification: a scenario-based exam on architecting production Claude systems. This hub covers what it tests, how it maps onto the concepts in this course, and a study program to get there. It is now one of four Claude certifications — check you are aiming at the right one.
The official exam code is CCAR-F, as published on Anthropic’s exam guide and the Pearson VUE program page (the sibling codes are CCAO-F for Associate, CCDV-F for Developer, and CCAR-P for Architect Professional). “CCA-F” appears widely in prep-site and blog content but in no primary source. Some prep sites say it was Anthropic’s original code at the March 2026 launch and was replaced when the program grew to four exams; others treat it as shorthand that was never official. No primary source settles it, and Anthropic has not published a rationale — though the obvious guess is that a bare “CCA” would collide with Claude Certified Associate. Either way, this page kept its original URL, but the credential is CCAR-F.
This is an independent, third-party study resource — not affiliated with, endorsed by, or an official product of Anthropic. “CCAR-F,” “Claude,” and “Anthropic” are trademarks of their owners, used here only to describe what this course helps you study. The practice questions are original study material, not real exam content. Always confirm current exam details on Anthropic’s official certification page.
The CCAR-F is a badge from the company that makes Claude. It proves you really know how to build helpful robot-assistant apps out of Claude the right way — like a swimming badge shows you can swim, this badge shows you can build. To earn it you sit a test where each question is a little pretend problem and you pick the smartest way to solve it.
Launched March 2026 through the Claude Partner Network, CCAR-F validates that you can design, deploy, and maintain production-grade Claude applications — agent-based and code-centric systems, not chat. It’s a design exam: every question drops you in a real production scenario and asks for the right architectural call.
Foxy: A scenario says the agent should “stop when it’s done.” Do I just count the words and halt at, say, fifty?
Professor Owl: Careful — that’s the trap answer. The loop keeps going while stop_reason is tool_use, and stops when Claude returns end_turn. A word count is never the real signal.
Timmy the Turtle: So before you pick, verify the option checks end_turn itself — not a length cap, not text-matching. If it counts words, it’s wrong.
Foxy: Got it — read the reason the model stopped, don’t guess from how long it talked.
☺ Like you’re 10: This test doesn’t ask you to remember facts, like naming all the planets. It gives you a real make-believe puzzle — "your app keeps breaking, what do you do?" — and you pick the best plan, the way a coach asks what play you’d call in a tricky moment of the game.
| Logistics | |
|---|---|
| Format | 60 multiple-choice, scenario-based questions · 120 minutes |
| Pass | 720 on a scaled 100–1000 range |
| Cost | $125 USD per attempt (retakes are charged again; partner-tier discounts may apply at checkout) |
| Validity | 12 months, then a free non-proctored renewal assessment |
| Who can sit it | Currently limited to Claude Partner Network organizations — see the eligibility note below |
| Delivery | Online proctored or test center · English |
| Prep | ~6 months hands-on Claude API + Claude Code recommended; the 200-level Academy courses |
The five domains
☺ Like you’re 10: The test is split into five topic baskets, like a school report card with five subjects. Some baskets count for more of your grade than others, so it tells you how much to study each one — spend the most time on the biggest basket.
| Domain | Weight | Core of it |
|---|---|---|
| 1 · Agentic Architecture & Orchestration | 27% | Agentic loops, stop_reason (tool_use vs end_turn), multi-agent / hub-and-spoke, the Agent SDK |
| 2 · Tool Design & MCP Integration | 18% | MCP servers, tool boundaries, resources, prompts, isError, least privilege |
| 3 · Claude Code Configuration & Workflows | 20% | CLAUDE.md hierarchy, Agent Skills, plan mode, slash commands, hooks, CI/CD |
| 4 · Prompt Engineering & Structured Output | 20% | Context engineering, JSON-schema extraction, tool_choice, few-shot, retry-validation |
| 5 · Context Management & Reliability | 15% | Long-context, “lost in the middle”, handoffs, error propagation, caching, evals |
Questions sit inside six recurring scenarios (four appear on any exam): a customer-support resolution agent, code generation with Claude Code, a multi-agent research system, developer productivity with Claude, Claude Code in CI/CD, and structured data extraction.
Two official Anthropic sources say slightly different things, and the difference matters. The exam guide says there are no mandatory prerequisites and the credential is awarded on exam performance alone — that is about knowledge. The Partner Academy certifications FAQ says certification is currently available to people at Claude Partner Network organizations, and that registration needs a partner email on a recognized company domain — personal addresses will not work. That is an eligibility gate, and it applies to all four Claude certifications.
So: no course or prior badge is required to pass, but you may not be able to register at all without a partner-org email. Anthropic's wording (“currently”) suggests this could open up. Confirm your eligibility before you budget time or money — and note the material below is worth learning regardless of whether you ever sit the exam.
Here’s the payoff of a Learning AI approach: most CCAR-F material is the same agentic concepts taught across this course, expressed in Claude’s specific vocabulary. The mapping:
☺ Like you’re 10: You already learned these ideas in this course — Claude just uses its own special words for them, like how "soccer" and "football" can mean the same game. This chart is a translation sheet that lines up each idea you know with the name Claude gives it.
| Course concept | In Claude terms (CCAR-F) |
|---|---|
| The agent loop (reason → act → observe) | The agentic loop driven by stop_reason: keep going on tool_use, stop on end_turn — never parse text or cap iterations as the primary stop. |
| MCP (host / client / server, tools·resources·prompts) | The same open standard — plus the isError flag, .mcp.json scoping, and tool boundaries by least privilege. |
| Tools as a building block | The model picks tools from their descriptions — write rich ones (formats, examples, edge cases). tool_choice: auto vs any. |
| Multi-agent patterns | Hub-and-spoke coordinator + subagents — and subagents have no shared memory, so pass everything explicitly in the prompt. |
| Customizing the assistant | Claude Code’s CLAUDE.md hierarchy, .claude/rules/, hooks, plan mode, and slash commands. |
| Building agents / SDK | The Claude Agent SDK — your own harness around the loop, with permissions and lifecycle hooks. |
| Evals & reliability | Lightweight eval frameworks; the “lost in the middle” effect; prompt caching (and where it breaks on dynamic content). |
Drill all of this with the Self-Check and Flashcards — both now have a ★ CCAR-F filter that pulls these Claude-specific items plus the shared agentic and MCP cards.
CCAR-F’s recurring lesson: prefer programmatic enforcement over prompt-based hope, and use independent review instances over self-review (a model that generated code retains its reasoning and won’t question itself). Both echo this course’s “match autonomy to blast radius, keep a human/independent gate.”
The exam’s recurring answer archetype
Look closely at every official sample question in the exam guide and one pattern repeats: the scenario describes a real production failure with numbers attached, and the four options are one deterministic, root-cause fix plus three specific flavors of tempting-but-wrong. Learn to recognize the flavor of wrong, not just “that’s wrong” — it’s the fastest way to convert a guess into a correct answer under time pressure.
| The trap | Why it’s tempting | What’s actually correct |
|---|---|---|
| A prompt-based instruction dressed up as a fix (“tell it to always verify first”, “add a rule to the system prompt”) | Reads like it solves the problem, and costs nothing to add | If the rule must never be violated, enforce it programmatically — a hook, a permission gate, a schema constraint. Prompts are probabilistic; a non-zero failure rate is still a failure rate. |
| Self-reported confidence or sentiment as a signal (“have it rate its own certainty”, “check the tone of the response”) | Feels like real, measurable signal | A model has no privileged access to its own error rate. Use explicit, checkable criteria instead (verified data, a rule, a threshold) — never a self-assessment as the deciding input. |
| An over-engineered layer (a new classifier model, a routing layer, consolidating tools, upgrading to a bigger model) | Feels rigorous — “throw more AI at an AI problem” | Try the cheap, direct lever first: a better tool description, explicit criteria in the prompt, a schema fix. Infrastructure is often solving a different problem than the one described. |
| A fix aimed at the symptom, not the cause (bigger context window, more retries, a stronger model) | Addresses where the pain is felt | Ask what actually produces the failure — a missing prerequisite check, an ambiguous instruction, an unstructured review pass — and restructure that step instead of throwing more compute at it. |
☺ Like you’re 10: On this test, the wrong answers aren’t random — they’re the same four “almost right” ideas over and over: “just ask nicely,” “ask it how sure it feels,” “build a fancier robot to watch the first robot,” and “fix where it hurts instead of why it hurts.” Once you can spot which trap an answer is, the real answer is usually the plain, boring, guaranteed one.
Cheat sheet — choosing a structured-output method (Domain 4)
| Need | Use | Why |
|---|---|---|
| Guaranteed schema-compliant output | tool_use + a JSON schema | The most reliable method — eliminates syntax/shape errors. It does not catch semantic errors (a value in the wrong field, a total that doesn’t sum), so still validate content. |
| A tool call must happen every single time | tool_choice forced to a named tool | "auto" lets Claude reply with plain text instead; "any" guarantees some tool call but not which one. Only a forced, named choice guarantees this exact call. |
| A field may legitimately be absent from the source | Optional / nullable schema field | A required field with no real value invites fabrication. Let “not present” be representable. |
| A category the schema can’t fully enumerate up front | enum + an "other" value with a free-text detail field | Lets Claude flag “doesn’t fit the list” honestly instead of forcing the nearest wrong label. |
| Output is inconsistent across varied input formats | 2–4 targeted few-shot examples spanning the variation | The most effective lever for consistency and hallucination-resistance — more effective than adding more prose instructions. |
| Required info is simply missing from the source document | Don’t retry — surface it as missing | Retry-with-error-feedback only fixes structural/format errors. It can’t recover data that was never in the source to begin with. |
Cheat sheet — hooks vs. CLAUDE.md (Domains 1 & 3)
| Situation | Use | Why |
|---|---|---|
| A rule must never be violated (block a refund above a threshold, block edits outside the project directory, require identity verification before a financial action) | A PreToolUse hook — inspect and allow/block/modify the call before it executes | Deterministic. It can return structured guidance (not just an exit code) to block-and-redirect, e.g. to a human-escalation path. |
| Code must always be linted, formatted, or tested after every edit | A PostToolUse hook | Runs independent of whether the model remembers or chooses to run the check — the gate can’t be skipped by an oversight in the model’s plan. |
| Style or convention guidance where an occasional miss is tolerable | CLAUDE.md / the system prompt | Probabilistic guidance is appropriate exactly when the cost of non-compliance is low. It’s guidance, not a guarantee. |
| You’re tempted to add “always remember to…” to the prompt for something that truly can’t fail | Stop — move it to a hook or a permission setting | If failure is unacceptable, the enforcement mechanism must be code, not a request to the model. |
A self-contained study program (pick 2, 3, or 4 weeks): a calendar tracker, a verified resource library (Anthropic Academy + the engineering essays), and a day-by-day build path — Messages API and streaming, the Batch API, tool use and caching, subagents, Claude Code, MCP, context engineering, and timed mock exams.
It’s pitched at the level Anthropic suggests: most first-time passers report ~20–30 hours over 2–4 weeks if they already build with Claude.
The program is a standalone app included in the course download. If you’re viewing the single-file build on its own, keep cca-f-4week.html in the same folder for the launch link to work.
Rehearse under exam conditions — timed exam mode, instant-feedback practice, or single-domain drills.
The official and most-recommended materials:
- Exam access request (Claude Partner Network, Skilljar): anthropic.skilljar.com · CCAR-F access — also where the official 60-question practice exam lives.
- Anthropic Academy (free courses): Claude 101, Building with the Claude API, Introduction to Subagents, Claude Code in Action, Agent Skills, and MCP — on anthropic.skilljar.com.
- Engineering essays (read these twice): Building effective agents, Agents with the Agent SDK, Writing effective tools, Context engineering, Claude Code best practices.
- Prompt engineering tutorial: anthropics/prompt-eng-interactive-tutorial — chapter-by-chapter exercises.
- Claude docs: docs.anthropic.com — Messages API, tool use, streaming, prompt caching, the Agent SDK.
- Community tutorials: the course’s Further Reading library collects hands-on Claude, Claude Code, and Cowork walkthroughs (third-party).
Doing both? The GH-300 hub covers GitHub Copilot’s certification. GH-300 is a features & governance exam; CCAR-F is an architecture & design exam — but the agentic concepts, MCP, and tool design overlap heavily.