Alloy
Written and recorded from the official exam guides — strategy, comparisons, answers to the questions people actually ask, and every podcast episode in full.
30 published
You do not need to write code, design an agent or build a tool integration to earn the Claude Certified Associate – Foundations (CCAO-F) credential. It is Anthropic's entry-level certification of the four, the only one aimed at operators rather than builders, and it has no prerequisites: it is awarded on exam performance alone. What it measures is judgement in use — whether you can get good work out of Claude, check it, and know where its limits and yours sit. ## Who the exam is written for Anthropic names the audience and, unusually, names the exclusion too. CCAO-F is for professionals who use Claude as a productivity tool: operations, marketing, product management, education and communications. It is explicitly **not** for API developers or agentic-system designers — that is Architect and Developer scope. Anthropic draws the same line from the other side when it teaches you to know your boundary. When a solution needs API integration, agent building or tool development, it belongs with a Claude Developer. When it needs enterprise architecture, integration design or governance at scale, it belongs with a Claude Architect. And recognising that boundary, and escalating across it, is itself an Associate-level skill. That makes the boundary testable content rather than a syllabus footnote. A question that describes a request beyond operator scope is not asking you to solve it; it is asking whether you know to hand it on. ## What the exam asks of someone who does not write code The exam is scenario-style. Its 60 questions ask you to apply a skill or make a judgement rather than recall a fact, so expect a situation, a constraint and a decision — not a definition. Seven domains carry published weights, and each has a published list of objectives. Read as plain work, they ask for the following. **Output Evaluation and Validation — 21%, the largest.** Evaluate what Claude gives you for accuracy and completeness; spot hallucinations, inconsistencies and bias; fact-check and validate; decide when a human must review; edit, adapt and compare outputs for the reader they are meant for; and choose the right output format — an artifact, an inline answer or structured data. Anthropic opens this topic by calling it the largest section of the exam, and gives the reason: when you put your name on a deliverable, you own every claim in it, whether you wrote the words or Claude did. **Workflow Integration and Solution Design — 16%.** Use Claude to analyse requirements and use cases, to research and plan, to support design and iteration, and to fit into an existing workflow — and explain Claude's value and its limitations to the people around you. **Governance, Risk, and Responsible Use — 15%.** Tell an appropriate use case from an inappropriate one, weigh data sensitivity, regulatory and privacy considerations, follow your organisation's AI policy, and understand the ethical implications. The course teaches which question to ask and who owns the answer; it does not supply named regulations, retention periods or legal thresholds, and neither does Anthropic's own material. **Prompting and Task Execution — 14%.** Write effective prompts for business and technical tasks, break a complex request into steps, iterate a prompt to improve the result, and adapt your approach to the kind of task — analysis, research, drafting or brainstorming. **Product and Model Selection — 12%.** Choose among Claude's product features (Projects, research mode, chat, artifacts), tell the Haiku, Sonnet and Opus models apart, match the model to the task's cost, speed and quality needs, and manage context limits — when to restart, summarise or keep something for later. **Configuration and Knowledge Management — 12%.** Configure Projects with instructions and knowledge sources, manage uploaded knowledge and connectors such as Google Drive and Gmail, write system-level instructions, and keep all of it maintained. **Troubleshooting and Optimization — 10%.** Diagnose a prompt or an output that is underperforming, adjust from feedback, and make a workflow more efficient. None of that needs a line of code. All of it needs judgement, and the exam tests the judgement. ## Four words that run through all seven domains Anthropic names four competencies that recur in every area, and carrying them as one model helps, because scenario questions often turn on which one is really being tested: - **Description** — telling Claude precisely what you want: structuring a request and adapting it to the task. - **Discernment** — critically evaluating what comes back, and checking an output against the signals that should trigger a closer look before you trust it. - **Diligence** — owning the output and verifying it; the stance that keeps a person answerable for what Claude produces. - **Delegation** — deciding what is right for Claude, what stays with a person, and what the two do together. When a question offers four reasonable-sounding actions, asking which of the four the scenario is about often separates the intended answer from the merely sensible ones. A question about a number that does not add up is a Discernment question, however much prompting appears in the stem. ## Where to start **First, audit yourself against Anthropic's own capability lines.** Anthropic states one capability per domain. Mark each one honestly as *can do under a new scenario* or *cannot yet* — not *have read about*: | Domain | Can you… | |---|---| | Product and Model Selection | choose the right entry point, model and features for a task? | | Prompting and Task Execution | build structured prompts and adapt them to the task type? | | Output Evaluation and Validation | validate output and know when human review is mandatory? | | Workflow Integration and Solution Design | map a workflow against Delegation criteria and redesign it safely? | | Configuration and Knowledge Management | configure and maintain Projects, instructions and knowledge? | | Governance, Risk, and Responsible Use | apply use-case, data, policy and ethics judgement? | | Troubleshooting and Optimization | diagnose underperformance and optimise workflows? | **Then check the audit with the free diagnostic, before you study anything.** It is 24 questions and takes about 20 minutes. It draws from the same question bank, under the same rules, as the rest of the course, and its mix follows the exam's own weighting. For each domain it reports how many questions you saw and how many you got right — a pointer to where to begin, not a grade. **Then spend your hours by weight.** The exam is scored on the total scaled score only — 720 on a 100–1,000 scale — with no separate minimum for any domain. So the rational plan is to maximise total items correct, which means weighting effort by how many items a domain carries. At 21% of 60 items, Output Evaluation and Validation is about 13 questions; Troubleshooting and Optimization, at 10%, is about 6. An hour that lifts your accuracy in the first by ten points is worth about 1.3 items; the same hour in the second is worth about 0.6. If two domains are equally shaky, open the heavier one first. **Study by re-deciding, not re-reading.** That is Anthropic's own instruction: find your weakest area, study it against the weight it carries, and work back through its decision frameworks rather than rereading the prose. ## What the first domain lesson looks like The course's first domain lesson — free, with its podcast — shows what "no code" preparation means in practice. It teaches the five components a professional prompt is built from: **role**, **context**, **task**, **constraints** and **output format**. Its opening example takes "Write me a summary of how operations went last quarter" and rebuilds it: an operations analyst's perspective, a one-page update for a regional director who reads for throughput and cost, one task verb, only the three metrics that moved more than ten percent against target, and a headline with three one-sentence bullets. Same model, same data; what changed was the specification. The lesson then shows that not every request needs all five — a quick factual question is complete with a task and one boundary — and that the component people leave out most is context: the audience, the situation, prior decisions and the source material Claude cannot see. It ends with task decomposition, where a request such as "assess these three vendors and tell me which one to go with" becomes ordered, checkable steps, with the evaluation criteria confirmed before any vendor is scored. ## The mistakes that cost non-engineers the most - **Preparing by memorising definitions.** If you can state what a Project is but cannot decide whether a given piece of work belongs in one, you are prepared for an exam this is not. - **Trying to solve what should be handed on.** A request needing API integration, agent building or tool development belongs with a Developer; one needing enterprise architecture or governance at scale belongs with an Architect. Recognising that is the answer. - **Grinding the smallest domain first.** There is no per-domain bar, so an hour in a 10% domain is worth about half an hour in the 21% one. - **Assuming every question has one answer.** The format is multiple-choice and multiple-response, and each item states how many to select. Read the final sentence of the stem before the options. - **Treating the result as a percentage.** 720 is a scaled score, not 72% of questions right, and it does not convert to one. - **Booking before the audit is clean.** Retakes wait 14 days after a first miss, 30 after a second and 90 after a third, with at most four attempts in any rolling 12 months, each paid at $99. ## The exam in brief | Detail | Published value | |---|---| | Fee | $99 per attempt | | Items | 60 | | Time | 120 minutes | | Passing | 720 on a 100–1,000 scale | | Format | multiple-choice and multiple-response; each item states how many to select | | Prerequisites | none | | Validity | 12 months, with free, non-proctored renewal on the Partner Academy if you renew before it lapses | | Delivery | Pearson VUE, online proctored or at a test centre | These are the values Anthropic published in July 2026; confirm them with Pearson VUE when you register, and where a newer published revision disagrees, the newer revision wins. ## Next step Create a free account — no card, no trial clock — and take the diagnostic for CCAO-F: 24 questions, about 20 minutes. Then open the first two lessons, which are free with their podcasts: the exam-strategy lesson and the lesson on the five-part prompt and task decomposition.
The Claude Certified Architect – Professional (CCAR-P) course has three free podcast episodes, hosted by Morgan and Casey. "How to Take This Exam", about 26 minutes, goes with the free exam-strategy lesson. The second free lesson — splitting a request three ways before you design it, and pricing the split before you commit — has its own episode and a question walkthrough. ## How to Take This Exam — about 26 minutes If you are already experienced, your biggest risk is not that you know nothing: it is choosing an answer that sounds right but does not satisfy what the question asks. The episode is about making disciplined choices under ambiguity. **What it covers** - **Vocabulary and the warning about shortcuts (1:22–2:34).** A distractor is the proposal that would make a convincing slide in the wrong meeting. Across the forty question-shaped items in Anthropic's official course material, exactly one carries a recorded correct answer, so "the longest option is usually right" cannot be tested. - **Five wrong-answer shapes and their checks (3:34–5:28)** — the absolutist and the counter-example test; true but irrelevant, where verifying a true statement is the trap; the right action at the wrong layer; the over-engineered option, where "fully satisfies" is not "cheapest"; and the answer to a different question, where your restatement becomes the comparison standard. - **Changing an answer (5:28–6:29)** — only for a named miss, such as a stem requiring answers grounded in current internal documents; not because uncertainty lowered the lights. - **Pacing (6:29)** — 63 questions in 120 minutes is about one minute fifty each; three minutes on one question puts you a full item behind. - **Scoring (6:51–11:34)** — $175 an attempt, twelve months' validity, 720 on a 100–1,000 scaled score judged on the total, and no false conversions to percentages. What is unpublished: flagging, adaptive delivery and items per domain on the day. The seven weighted domains, led by Integration at 19% (8:15), and what they mean in questions: about twelve for Integration and four for Developer Productivity. Why an hour on Integration is worth about three times an hour on Developer Productivity (9:28). Compounding retake waits of 14, 30 and 90 days with four attempts a year (10:07); the result report as a plan (10:45); and never leaving an item blank, because guessing costs nothing (11:17). - **Why the wrong answer looks right (11:34–14:11)** — one intended answer per item; options that are defensible in isolation and wrong in context; the official material's checkpoints outnumbering its quizzes almost six to one; and reading the stem's constraint — latency, data residency, human review, cost, an existing system — before the options. - **Eight moves in Alloy (14:11–26:00)** — the diagnostic first, honest confidence ratings, flashcards when due, proof over ticks, Recommended next, one readiness number, a curriculum kept current, and labs, scenarios, the activity strip and the Curriculum — with a closing reminder to bring ID that matches your registration exactly. ## Split the request three ways before you design it, and price the split before you commit to it — about 12 minutes The first domain lesson, from Solution Design & Architecture. It opens on a claims team asking for "an assistant that reads claims, sets priority, checks coverage and sends notifications" — one sentence that is really language interpretation, deterministic rules, current operational data and communication. - **A delegation map with three owners.** Claude-owned, existing-system-owned and human-owned work, each assignment justified by reversibility, stakes and accountability — not by excitement about what Claude can do. Capability answers whether Claude *can* do a step; architecture asks whether it *should* own it. A deterministic rule belongs with the system that guarantees it, a current value with its system of record, and a high-stakes or accountable decision with a person. - **Three solution shapes, each with a cost.** An augmented call supports a live interaction while the person keeps control; a workflow is a defined sequence with stages, transitions and failure handling; an agent acts on its own *within the design*. Choosing early prevents a costly pivot, and over-assigning work to Claude makes the process more expensive, slower and harder. - **Four properties of generative AI** — next-token prediction, knowledge, working memory and steerability — each with a limitation and a mitigation. - **Retrieval is not live state.** "Very recent" is not current when transactions change minute by minute. - **Layered safety.** Input screening, output screening and tool-call authorisation, each placed where it can do its job. Screening detects disallowed content; authorisation decides permission to act — "please change the account address" can be harmless language and still unauthorised. Every layer adds latency and engineering cost, and the architect owns each control's location, owner and failure path. The alignment boundary separates behaviour from Claude's training from rules the deployment must enforce. - **Price and verdict.** Size the design from call volume, input and output tokens, model tier and the token spread, then record one of three verdicts: feasible as scoped, feasible with constraints, or not feasible. ## Question walkthrough — about 19 minutes Six questions built around a claims-processing request, each with a pause to commit before the discussion: - **Scoping starts by naming each piece of work as a separate capability** — extract fields, retrieve coverage, route to the adjuster queue, draft the notification — which is what makes each one assignable. - **Capability is not a verdict.** A commitment made on "Claude can do it" without volume, input size and the latency requirement is not sound. - **Priority and coverage belong to the systems that hold them**, because both answers change when somebody edits a table the model cannot see. - **One step can split in two.** Claude lifts an amount out of free text; the existing check compares it with the thresholds and decides the route. - **Value is stated against the right pillar.** Handling time falling from twenty-four minutes to eight is efficiency; newly reviewable claims are transformation — each in a unit the business already tracks. - **Price from the spread, not the mean,** and carry the reviewer's hours in the run cost; averaging understates recurring cost and overstates the net benefit. ## Who these episodes are for Experienced architects preparing for CCAR-P who want to find where experience misleads them before the exam does. All three are free with the first two lessons. Start with the free diagnostic — 24 questions across all seven domains, about 20 minutes.
## What is the Claude Certified Architect – Professional exam? Claude Certified Architect – Professional (CCAR-P) is Anthropic's advanced architect certification, official and live as of July 2026. It tests whether you can take a business problem to a scalable Claude-based solution across its whole lifecycle. ## Who is it for? Mid-level and senior architects — typically with three or more years of architecture experience and six or more months running Claude in production. ## How is it different from Claude Certified Architect – Foundations? Foundations has five domains; Professional has seven, led by Integration, and adds the business and lifecycle side of architecture — value, evaluation, governance and stakeholders. Alloy's Professional course assumes you already understand agent control flow and tool use. ## How many questions are there, and how long do I get? 63 questions in 120 minutes — about one minute fifty per question. ## How much does it cost? $175 per attempt. ## What score do I need to pass? 720 on a scaled score from 100 to 1,000. ## Is 720 the same as 72%? No. A scaled score is a result on a defined range, not a percentage of items answered correctly. Do not convert it into a raw-percentage target. ## Do I have to pass every domain? No. The decision is made on the total scaled score. Per-domain percentages are informational, not separate pass gates. ## What are the domains and their weights? - Integration — 19% - Solution Design & Architecture — 17% - Evaluation, Testing & Optimization — 16% - Stakeholder Communication & Lifecycle Management — 14% - Governance, Safety & Risk Management — 14% - Claude Models, Prompting & Context Engineering — 13% - Developer Productivity & Operational Enablement — 7% ## How many questions come from each domain? That is not published; the weights are informational percentages, not a promised count per sitting. Applied to 63 items, Integration is roughly 12 and Developer Productivity about 4. ## What does Integration cover? Judging tool and agent configuration for capability bloat, finding authentication and authorisation gaps, justifying accuracy-versus-latency configuration, observability at scale, retrieval pipelines with suitable chunking and indexing, retrieval strategies matched to data shape and query pattern, choosing MCP, an API or CLI, or agent-to-agent connections, and progressive discovery versus monolithic context. ## What does Solution Design & Architecture cover? Translating business problems into Claude solutions, end-to-end architectures with feedback loops, choosing between workflow, agentic and augmented-LLM patterns, multi-agent orchestration, decomposition, and aligning a design to a business value pillar — efficiency, transformation, productivity, cost or performance SLAs. ## What does Evaluation, Testing & Optimization cover? Metrics for accuracy, latency, cost, safety and security; evaluation datasets and test frameworks; A/B testing; diagnosing prompt failures, hallucinations and model mismatch; optimising tokens, latency and cost; and monitoring through logging and observability. ## What does Stakeholder Communication & Lifecycle Management cover? Structured discovery and requirements gathering, communicating decisions and trade-offs, managing feedback and expectations including SLAs, documenting architectures with implementation guidance, and supporting discovery, design, handoff, monitoring and iteration. ## What does Governance, Safety & Risk Management cover? Guardrails and safety controls, the risks and failure modes of LLM systems, human-in-the-loop validation, compliance obligations such as GDPR, HIPAA and FedRAMP, and bias, fairness and transparency. ## What does Claude Models, Prompting & Context Engineering cover? Choosing models on their trade-offs, system prompts, templates and guardrails, zero-shot, few-shot and chain-of-thought prompting, context-window and token management, and prompt reuse through caching, modular prompts and Skills. ## What does Developer Productivity & Operational Enablement cover? Configuring Claude tools such as Claude Code for teams, improving developer workflows with AI-assisted tooling, and supporting debugging and operational issue resolution. ## What question format does the exam use? Every item has exactly one intended answer. You are choosing the best design, not every defensible one. ## What do the questions look like? Typically a business situation, a constraint that narrows it, and four architectures that all look reasonable if you skim. The constraint decides — a latency budget, data residency, a human-review requirement, a cost ceiling, or an existing system you must integrate with. ## Should I guess if I am unsure? Yes. An unanswered question is scored as incorrect and there is no penalty for guessing, so never leave an item blank. ## Can I flag questions and return to them? Is the exam adaptive? Neither is published, and anyone stating them confidently is guessing. ## Are the official practice answers available? No. Across the forty question-shaped items in Anthropic's official course material, exactly one carries a recorded correct answer. The material records stems and options, not keys. ## Does the longest answer tend to be right? That cannot be tested — with one key in forty items, the pattern cannot be checked either way. Never let it override a reading of the constraint. ## What wrong-answer patterns should I expect? The absolutist; the answer that is true but irrelevant; the right action at the wrong layer; the over-engineered option; and the option answering a different question. The most common trap on this exam is an option that is individually defensible but satisfies only half the requirement. ## When should I change an answer? Only when you can name what you missed — a specific constraint, detail or interpretation. If the honest answer is "nothing, but I dislike uncertainty", keep your original choice and move on. ## How long should I spend on a question? About one minute fifty on average. If a question has taken three minutes, you are more than a full item behind; choose the best option you have and move. ## How many attempts do I get? Up to four in a rolling 12 months. The waits compound — 14 days after a first failure, 30 after a second, 90 after a third — so sit when you are ready, not early. ## What does my result report show? Pass or fail, the scaled score, and percent correct by domain. If you do not pass, keep the breakdown: it tells you where to spend the time before your next attempt. ## How long is the credential valid? 12 months. ## What should I bring on the day? Identification whose name matches your registration exactly. Check the spelling when you book, not on the day. ## What is the free CCAR-P diagnostic? 24 questions drawn from all seven domains, weighted like the exam and taken in one sitting of about 20 minutes. It draws from the same question bank, under the same rules, as the rest of the course. ## Is the diagnostic free? Your first run is free and needs no card; a retake uses credits. ## What do the diagnostic results show? A starting readiness figure and each domain reported as questions right out of questions asked — three or four per domain, enough to show where to look first, not to grade a domain on its own. ## Why does it ask how confident I am? Because certain-and-wrong is what fails people. Alloy watches the gap between how sure you were and how right you were, and can hand you back exactly the questions you were confident about and got wrong. ## Can I shorten the diagnostic? No. Its length is set by the course. A partial diagnostic measures less and still reports with the same confidence, so it is a worse diagnostic, not a smaller one. ## What should I do after the diagnostic? Run the confident-and-wrong practice set, then open your weakest heavy domain, or follow Recommended next, which puts the single action that would move your readiness most in front of you. ## How is Alloy's CCAR-P course organised? Fifteen lessons: an exam-strategy lesson, then fourteen domain lessons — three for Integration, two each for Solution Design & Architecture, Evaluation, Testing & Optimization, Governance, Safety & Risk Management, Stakeholder Communication & Lifecycle Management and Claude Models, Prompting & Context Engineering, and one for Developer Productivity & Operational Enablement. ## What is in the free lessons? The exam-strategy lesson, on what CCAR-P measures and how to sit it, and the first domain lesson, on splitting a request among Claude, existing systems and people and pricing the split before you commit. Both come with podcasts, hosted by Morgan and Casey. ## Is the exam-strategy lesson worth it? Yes. The exam-strategy lesson is worth a 10–20% score bump. ## Is Alloy the official exam? No. Alloy's course is preparation for CCAR-P, not the official exam or certification, and Alloy is not affiliated with Anthropic. ## Does one subscription cover Foundations as well? Yes. Alloy's Full membership covers all four Claude certification courses, including Claude Certified Architect — Foundations, and every course that opens while you are a member. Prices are on the pricing page.
The Claude Certified Architect – Foundations (CCAR-F) course has three free podcast episodes, hosted by Morgan and Casey. "How to Take This Exam", about 23 minutes, goes with the free exam-strategy lesson: how to sit CCAR-F without giving marks away to answers that merely sound impressive. The second free lesson, on agentic loops and `stop_reason` control flow, has its own episode and a question walkthrough. ## How to Take This Exam — about 23 minutes **The premise (1:05).** You can know the material and still miss the question. Several answers may be technically credible, but only one answers the requirement actually written. A distractor is not random nonsense; it is a competitor. **Four rules (1:34).** The score is scaled — 720 on 100–1,000, not a percentage. Recognise five wrong-answer shapes and test them mechanically. Change an answer only when you can name a missed fact or requirement. And assume every plausible wrong option was built to tempt you: the question is never "could this work?" but "does this best satisfy this exact requirement?" **Read the instruction line first (2:07).** How many options an item offers and how many to select is stated by the item itself, and the format differs between certifications. **The five shapes (2:26–4:06).** The absolutist, beaten by one counter-example (2:26); true but not the question, where the stem's final sentence says whether the exam wants the best design, the first action, the main benefit, the most appropriate control or the explanation for a failure (2:57); right action at the wrong layer (3:21); the over-engineered one (3:38); and the strong answer to an adjacent question (3:53). At 4:06, the misconception behind all five: that the most impressive answer must be the best. **Changing an answer (4:18).** Anxiety is not new evidence, and the clock is the worst reason of all. At 5:00, the business version: you revisit a supplier decision because the first supplier cannot meet the deadline, not because the second slide deck used a darker blue. It is not "never revise"; it is "revise for a reason". **The scaled score (5:39–7:13).** 720 does not mean 72% of items right and does not convert to one percentage, so do not set your target by guessing how many questions you can miss. At 7:13: you are scored on the total, and per-area percentages are information, not five bars. **Why wrong answers look right (7:27–9:16).** A distractor may describe a valid technique, a sensible safeguard or a familiar architecture; its flaw is usually alignment. The exam is built to defeat memorisation — it measures the design decisions an architect makes where more than one answer looks plausible (8:03) — which is why most items are scenarios (8:44). At 9:16, the honest caveat: spotting these shapes is a mechanical skill that stops you donating questions you knew; it does not do the knowing for you. **Using Alloy to pass it (9:28–23:08).** The diagnostic first, weighted like the exam (9:28); the five domains described (10:47); agentic architecture and Claude Code workflows carrying the most concepts and questions (12:23); honest confidence and the confident-and-wrong practice set (12:50); flashcards when due (14:13); proof over ticks, with every concept's state — studied, practised, built, passed, demonstrated (15:21–15:51); Recommended next (17:07); interleaving (18:38); the readiness state — not ready, almost, ready, strongly ready — that opens the final exam (18:54–19:17); a curriculum kept current by people (20:19); and how to study each domain the way it is tested (21:51) — build a real loop for agentic architecture, practise "what should the run do next" for Claude Code, and over-weight anti-pattern questions for context reliability. ## Agentic loops and stop_reason control flow — about 8 minutes What decides whether the next turn runs? Not punctuation and not optimism: a fixed response field, `stop_reason`. On `tool_use`, continue; on `end_turn`, ordinary generation is complete. That field, not the model's prose, is the termination test. The episode sets out the protocol. Preserve the complete assistant response exactly as returned — every content block, not just the `tool_use` blocks. Keep an append-only history and send it, with the tool definitions, on every request. Return all tool results together in one user message, each matched to its `tool_use_id`; without the identifier, when several tools ran in one turn, the model cannot tell which request failed. Three failures follow from getting it wrong: premature termination while tool work is pending, runaway execution after the model has finished, and control flow that depends on how the model phrased things. An iteration cap still has a place — as a circuit breaker for runs that take too long or fail to converge, never as evidence the task completed. Non-tool stop reasons need their own branches: `max_tokens` may mean a response was cut short, `stop_sequence` that it ended at a configured boundary. The worked case is a refund request, where the process must not tell a customer the refund succeeded because generation happened to stop. The design choice underneath: when the next step is unknown and the model must choose, build a model-directed agent; when the sequence is known, a preconfigured workflow is simpler, more predictable and easier to audit. Agents buy flexibility at the cost of more variable cost, latency and behaviour. ## Question walkthrough — about 14 minutes Five exam-style questions on the agent loop, each read with its options and a pause for you to commit: - **What decides whether the loop continues?** Asked twice, for a document-review assistant and a support agent. Inspect `stop_reason`: continue on `tool_use`, stop on `end_turn`. - **An agent that calls two always-needed tools one after the other, in separate responses**, averaging four or five loops per resolution. Prompt the model to bundle related tool requests into a single turn, using its native ability to issue parallel tool calls — no architectural change needed. - **Nine percent of conversations end abruptly** because the loop exits when the assistant writes "I am done" or "all set". Branch on `stop_reason`, which the API generates regardless of what the model writes. An option that has the model emit a JSON completion flag looks deterministic, but the model still decides when to emit it. ## Who these episodes are for Anyone preparing for CCAR-F who knows the material and wants to stop losing items to plausible wrong answers — and anyone who wants the core of the heaviest domain, agentic architecture, before paying for anything. All three are free with the first two lessons. Pair them with the free diagnostic: 24 questions, about 20 minutes.
The Claude Certified Developer – Foundations (CCDV-F) course has three free podcast episodes, hosted by Morgan and Casey. "How to Take This Exam" (about 24 minutes) goes with the exam-strategy lesson: how to sit CCDV-F without giving marks away to answers that merely sound right. The second free lesson — what a request costs, why it varies and how it reaches Claude — has a short episode and a question walkthrough. ## How to Take This Exam — about 24 minutes **The hook (1:03).** The question you lose may not be on unfamiliar material. It may offer several reasonable answers — one technically true but irrelevant, another an elaborate solution to a problem nobody asked. Stop asking "could this be right?" and ask whether it is the best answer to this exact request. At 1:39: the paper mixes multiple-choice with multiple-response, so the number of options and answers is whatever the item says. **The short version (1:51).** Challenge universal claims with one counter-example, re-read the final sentence, identify the layer before judging options, prefer the simplest answer that fully meets the requirement, restate the question before matching, and change an answer only when you can name what you missed. **The five wrong-answer shapes (2:30).** The absolutist, true but not the question, right action at the wrong layer, the over-engineered one, and a strong answer to a question nobody asked. At 2:54, a format warning from the captured items: twelve of seventeen offered four options and five offered three. **Changing an answer (3:13).** A change needs a receipt — "I missed the word *only*", "I overlooked the constraint" — not a mood. **The pass mark and the paper (3:37–5:54).** 720 on a scaled score from 100 to 1,000; 53 items in 120 minutes, a shade over two minutes each, with long developer stems; $125 an attempt, no prerequisites, 12 months' validity and free on-time renewal (4:18). 720 is a threshold on the reporting scale, not a count of correct answers; the cut score is criterion-referenced, not a curve (5:06); domain lines on your report are commentary, not hurdles (5:27); and the retake waits of 14, 30 and 90 days matter less than the cap of four attempts in a rolling 12 months (5:39). **Why a wrong answer looks right (5:54–8:27).** Wrong answers are written to compete with the right one. At 6:15, the shapes to rehearse: a four-reading scenario, a session trace asking for the surgical fix, configuration blanks, deployment scenarios matched to transport and scope, free text compared against a model answer, and a cumulative debug with four planted bugs. At 6:50, a caution: of the 32 courseware items visible, none carries a recorded correct answer. At 7:22, the developer distractor — real fields in a real order that repair a different class of defect than the error names — and at 8:01, the anti-pattern wearing best-practice clothing: rotating a key but updating the credentials file, or concatenating every past transcript "for memory". **Using Alloy to pass it (8:27–23:26).** - **The diagnostic first (8:27)** — same question bank and rules as the course, weighted like the exam, fixed length, one sitting. At 9:50 the eight weights are read out; at 10:24, Claude Code and Eval together are 5.7%, about three items; at 10:40, the 25 weighted sub-objectives, with Claude Application Design heaviest at 8.6% and Claude Hooks lightest at 1.0%. - **Weighting your hours (11:45)** — ten points of accuracy in Applications and Integration is worth about 1.8 items, the same in Eval about 0.1. At 12:08, Software Engineering Foundations (7.4%) outweighs Tool Implementation (4.4%). - **Honest confidence (12:31)** — the gap between sure and right is what fails people, and it unlocks a practice set of confident-and-wrong questions. - **Flashcards when due (13:58)**, rated again, hard, good or easy. - **Proof, not ticks (15:06)** — reading is the weakest evidence; a podcast counts only when you have really listened to part of it; a concept needing a refresh has faded with time and needs one review. - **Recommended next (16:38)** and choosing a practice mode by the question you are asking (17:50). - **One readiness number (18:22)**, bounded changes from practice exams, and the day-of rules for Pearson VUE, the NDA, ID and cancellation (19:05). - **The near-zero exception (19:36)** — going from nothing to competent in Security and Safety is a bigger swing than its 8.1% suggests. - **A curriculum kept current by people (19:55)**, and at 20:49 what is not published: flagging, adaptive delivery, partial credit, breaks and scratch paper. - **Labs, scenarios, the activity strip and the Curriculum (21:11)**, then reading each domain as failure prevention (22:06) and how the twelve domain lessons are ordered (22:22). - **Closing drills (22:51)** — evidence first, then the layer, then the options; practise subtraction; review your reasoning rather than your letter. ## What a request costs, why it varies, and how it reaches Claude — about 4 minutes A short introduction to the course's first domain lesson. A request that looks unchanged on screen can cost more, exceed the model's capacity or come back worded differently, and none of that is random. A token is the unit the model reads, generates and bills in — not quite a word, not quite a character — and the tokenizer that splits text is model-specific. Token accounting counts every input and output component, not only the visible prompt. The context window is one shared ceiling for the prompt, history, documents, tools and answer. And because Claude samples each next token from a probability distribution, the same prompt can produce different wording while still satisfying the request. The episode closes with three checks: what counts as tokens beyond the visible prompt, how input too large to start differs from generation that reaches the ceiling, and why temperature zero is not a universal determinism switch. ## Question walkthrough — about 16 minutes Questions from the course's own bank on cutting cost without giving up reliability, with a pause to commit before each discussion: - **A tagging service that pinned a low temperature starts failing with a `400` after an upgrade to a newer model.** Remove the non-default sampling parameter: the newest models reject non-default `temperature`, `top_p` and `top_k`, and consistency is shaped through the prompt instead. - **A million documents a month on the most expensive model.** Benchmark a cheaper model zero-shot against labelled accuracy targets first — it tests whether the cheaper model is capable and whether extra prompt guidance is needed at all. - **The same volume, with some documents containing regulated information.** Route validated-redacted documents to the lower-cost model and sensitive ones to the approved model; the routing layer carries the data boundary. ## Who these episodes are for Developers preparing for CCDV-F who know the material and want to stop losing items to plausible wrong answers. All three are free with the first two lessons. Pair them with the free diagnostic — 24 questions, about 20 minutes — to see which domains to open first.
The Claude Certified Associate – Foundations (CCAO-F) course has three free podcast episodes, hosted by Morgan and Casey: "How to Take This Exam", the companion to the free exam-strategy lesson; the episode for the first domain lesson, on the five components of a professional prompt and ordered steps for complex requests; and a question walkthrough for that lesson. ## How to Take This Exam — about 26 minutes The argument is that most lost marks on CCAO-F are decision failures, not knowledge failures: you know the topic, see three options that could work, and choose the one that answers a nearby question. **The five wrong-answer shapes (1:41–3:56).** The absolutist ("always", "never" — name one counter-example); true but not the question (re-read the stem's final sentence); right action at the wrong layer (prompt, retrieval, model or application — name it first); the over-engineered one (prefer the simplest complete answer); and an answer to a different question (restate the question, then match). Along the way: the final sentence also carries how many options to select, because the format is multiple-choice and multiple-response (2:12), and several things are not published at all — flagging and revisiting, linear or adaptive delivery, items per domain, breaks, scratch paper and partial credit (2:37). **The rule not given (3:56).** "The longest answer is usually right" is set aside: across 123 questions in Anthropic's three certification sets, one carries a recorded correct answer, and for this exam none of 44 does. **Changing an answer (4:47).** Only when you can name what you missed on the first read. Doubt is normal and is not new information. **How practice items are built (5:21).** Classify-and-justify with a required reason, card-into-bucket where every layer is used at least once, multi-part items that recognise then defend — and the instruction to compare your reasoning, not just your selection (5:58). **Scoring (6:19–10:06).** 720 on a 100–1,000 scaled score, not a percentage; 60 items, 120 minutes, $99, valid 12 months; the total score only, with per-domain percentages informational; the seven weighted domains, with Output Evaluation and Validation largest at 21%; what that means for your hours (about 13 items against about 6 for Troubleshooting); the retake ladder and the four-attempt annual cap; the three things your result returns; and a criterion-referenced cut score. **Sitting it (10:26–11:35).** Pearson VUE, matching ID, the NDA, the 24-hour cancellation rule, appeals, and free renewal before the credential lapses. **Who it is for and how to prepare (11:35–15:32).** Requirement matching; the audience and the Developer and Architect boundary, where handing a request on is the right answer; judgement, not recall; the four competencies — Description, Discernment, Diligence, Delegation; the seven capabilities as a self-audit; and re-deciding rather than re-reading. **Working the course (15:32–26:10).** The diagnostic first, honest confidence ratings, flashcards when due, proof rather than ticks, Recommended next, one readiness number, a curriculum kept current, and what labs, scenarios, the activity strip and the Curriculum are each for. ## Five Components Carry a Prompt, and Ordered Steps Carry a Complex Request — about 15.5 minutes The first domain lesson, on professional prompting. A vague request produces fluent output that looks finished until somebody tries to use it; "review this policy and prepare what we need" leaves both the operation and the deliverable to guesswork. The episode's answer is five components — role, context, task, constraints and output format — used as a checklist, not a ritual. - **Task.** One clear primary verb — summarise, compare, classify, draft, extract, calculate, identify — because the verb decides the operation. "Review this" decides nothing; "identify the three requirements that changed and explain the operational effect of each" decides everything. - **Constraints.** Length, tone, scope, audience level, evidence standards, exclusions and how uncertainty is handled. "Distinguish observed facts from inferences" matters: that support tickets rose 20% in April may be observed; that the new process caused it is an inference unless the evidence establishes it. Where a calculation is central, code execution can check the arithmetic. - **Context.** The audience, the situation, the source documents, definitions, prior decisions and success criteria — what Claude cannot know because it was not in the meeting or the inbox. A connector reaches only what your existing permissions allow and does not fill every gap. Missing context produces generic, interchangeable output. - **Role.** A lens, not a qualification badge. A financial analyst, a copy editor and a security reviewer notice different things in the same document; "act as an expert" does not make the answer expert. - **Structure drives quality.** A quick factual question may need only a task and one boundary; a client deliverable may need all five. More prompt is not more quality. The episode ends on decomposition. A communications manager turning a revised policy into an announcement, a staff questions page and an executive briefing should first extract every substantive change into a checkable list, verify it, and only then draft the three documents from it. Drafting all three at once repeats one misreading three times and produces documents that disagree. Two misconceptions are named: that a bigger model or another retry can repair missing specification, and that decomposition means putting every step in its own conversation — dependent steps need their shared foundation carried forward. ## Question walkthrough — about 21 minutes Six questions from the course's own bank, read with their options and a pause for you to commit to an answer before the discussion. They centre on when Claude chat is the right tool for one-off exploration, data screening, claim verification and workflow redesign: - **Twenty customer records and an unreviewed AI policy.** The first move is to confirm approved handling, then test with a de-identified sample. Adding a privacy instruction to the prompt is the right action at the wrong layer — prompt wording cannot establish permission. - **A twelve-step onboarding checklist that takes three days per hire.** Use chat to compare alternative drafts before choosing a redesign; embedding Claude in the HR application answers a different question, and a multi-agent workflow is over-engineered for exploration. - **A Claude-drafted client report due tomorrow, with confident figures and three cited sources.** A focused chat review of each figure, citation and uncertainty. Citation presence is not citation fidelity: three genuine sources can sit beside figures they never contained. Each wrong option is named by its shape — the absolutist, true but not the question, right action at the wrong layer, the over-engineered one, an answer to a different question. The closing advice is to restate the stem in plain language, name the layer where the problem lives, and apply the counter-example test to any "every" or "only". ## Who these episodes are for Anyone preparing for CCAO-F, Anthropic's exam for people who use Claude as a productivity tool. All three are free with the first two lessons of the course. Listen alongside the free diagnostic — 24 questions, about 20 minutes — which tells you which domains to open first.
Anthropic's architect certification has two exams: Claude Certified Architect – Foundations (CCAR-F) and Claude Certified Architect – Professional (CCAR-P). Alloy's Full membership covers the prep for both — and for the other two Claude certifications, Associate and Developer. If you sit Foundations now and Professional next, the second course does not start with a second buying decision. ## The two exams | | Foundations (CCAR-F) | Professional (CCAR-P) | |---|---|---| | Questions | 60 in 120 minutes | 63 in 120 minutes | | Pass mark | 720 on a 100–1,000 scaled score | 720 on a 100–1,000 scaled score | | Registration | $125 | $175 | | Largest domain | Agentic Architecture & Orchestration, 27% | Integration, 19% | | Domains | 5 | 7 | Foundations certifies that you can build on Claude: agents driven by `stop_reason`, Claude Code workflows, grounded context, parseable output, and well-designed tools and MCP servers. Professional certifies that you can take a business problem to a scalable solution across its lifecycle: integration, solution design, evaluation, governance, stakeholders and the operation of what you built. Neither has a prerequisite. The exam registrations are separate from Alloy and are booked with Pearson VUE. ## What one membership includes - **A course per exam**, built from its published blueprint and teaching only what a numbered objective in the official exam guide asks for — thirteen lessons for Foundations, fifteen for Professional. - **Structured tracks, spaced repetition and weak-area drilling.** Flashcards come back just before you would forget them; practice modes answer different questions — where am I thin, where am I fooling myself, can I hold it together for a whole paper. - **Every wrong answer explained**, including the options that looked reasonable, with your confidence recorded beside your answer and confident-and-wrong answers collected for their own practice set. - **Full practice exams, and a Coach you can ask anything.** - **Hands-on work where a course has it** — on Foundations, labs where you build a real agent loop, reviewed against the exercise's acceptance criteria and its common failure modes. - **One readiness figure per course**, built from mastery, honest confidence and coverage, so you book each exam when the work says you are ready. - **A monthly credit allowance**, usable on any course. - **Notice when something changes.** These exams move; when something you have already studied changes, you hear what moved and what it means for your answer. - **Every course that opens while you are a member**, and cancellation whenever you pass. Prices are on the pricing page. Credits you buy on top never expire. ## Why one membership fits the architect path The two exams overlap in method more than in content. Both are scenario-based, both are scored on a total scaled score with no per-domain bars, and both reward the same discipline: match the requirement rather than the most impressive answer, name the layer a problem lives in, prefer the simplest sufficient option, and change an answer only when you can name what you missed. The Professional course assumes the agent control flow and tool use that Foundations teaches, so taking them in sequence means the second builds on the first — inside the same membership. ## Start free Create a free account — no card needed, no trial clock — and take the diagnostic for either exam: 24 questions, about 20 minutes, reporting each domain as questions right out of questions asked. The first two lessons are free on both courses, with their podcasts: for Foundations, the exam-strategy lesson and agentic loops with `stop_reason` control flow; for Professional, the exam-strategy lesson and splitting a request among Claude, existing systems and people and pricing it before you commit.
Anthropic's architect certification has two levels: Claude Certified Architect – Foundations (CCAR-F) and Claude Certified Architect – Professional (CCAR-P). They share a scoring model and differ in almost everything else — who they are for, what they weight, and what a question asks you to decide. ## The two exams side by side | | Foundations (CCAR-F) | Professional (CCAR-P) | |---|---|---| | Questions | 60 | 63 | | Time | 120 minutes | 120 minutes | | Time per question | two minutes | about one minute fifty | | Pass mark | 720 on 100–1,000, total score only | 720 on 100–1,000, total score only | | Registration | $125 | $175 | | Answer format | one correct response, three distractors | one intended answer per item | | Domains | 5 | 7 | | Largest domain | Agentic Architecture & Orchestration, 27% | Integration, 19% | | Attempts | four in a rolling 12 months | four in a rolling 12 months, with waits of 14, 30 and 90 days | | Validity | 12 months, free renewal before it lapses | 12 months | On both, 720 is a scaled score rather than a percentage, per-domain percentages are informational rather than separate bars, unanswered questions are scored as incorrect and there is no penalty for guessing. ## Who each is for **Foundations** is for solution architects building production applications on Claude. Alloy's Foundations course assumes you have prompted Claude and read its output — not that you have shipped an agent, written an MCP server or sat a certification before. The exam covers Claude Code, the Claude Agent SDK, the Claude API and the Model Context Protocol. **Professional** is for mid-level and senior architects — typically three or more years of architecture experience and six or more months running Claude in production — who take a business problem to a scalable solution across its lifecycle. Alloy's Professional course assumes you already understand agent control flow and tool use. ## What each weights **Foundations** — Agentic Architecture & Orchestration (27%), Claude Code Configuration & Workflows (20%), Prompt Engineering & Structured Output (20%), Tool Design & MCP Integration (18%) and Context Management & Reliability (15%). Its centre of gravity is building: `stop_reason`-driven loops, subagent routing, plan–edit–verify, parseable output, and tool schemas the model uses correctly. **Professional** — Integration (19%), Solution Design & Architecture (17%), Evaluation, Testing & Optimization (16%), Stakeholder Communication & Lifecycle Management (14%), Governance, Safety & Risk Management (14%), Claude Models, Prompting & Context Engineering (13%) and Developer Productivity & Operational Enablement (7%). Its weight is spread more evenly and reaches into the business: value pillars, evaluation design, compliance, stakeholder discovery and the lifecycle after handoff. ## How the questions differ **Foundations** questions are scenarios drawn from Anthropic's official scenarios — including Customer Support Resolution Agent, Code Generation with Claude Code, Multi-Agent Research System, Developer Productivity with Claude, Claude Code for CI/CD and Structured Data Extraction — with four presented on each exam form. Its published out-of-scope list rules out topics such as fine-tuning, computer use, vision, streaming, tokenization and MCP server hosting. **Professional** questions typically give a business situation, a constraint that narrows it, and four architectures that all look reasonable. The constraint — a latency budget, data residency, a human-review requirement, a cost ceiling, an existing system to integrate with — decides. Options are often individually defensible and contextually wrong. On both, the same five wrong-answer shapes recur: the absolutist, true but not the question, right action at the wrong layer, the over-engineered option, and the answer to a different question. And on both, change an answer only when you can name what you missed. ## Which to take first Neither exam has a prerequisite — none of Anthropic's four Claude certifications does — so you can sit Professional without holding Foundations. If you are building your first production agents, Foundations is the on-ramp: its heaviest domain is the control flow the Professional course takes for granted. If you already design and run Claude systems in production, and your work includes justifying designs to the business, Professional tests that directly. The free diagnostics are the quickest way to decide: take both, 24 questions each, about 20 minutes, and compare where you stand. ## How Alloy prepares you for each **Foundations** — thirteen lessons: an exam-strategy lesson and twelve domain lessons (three each for agentic architecture and Claude Code workflows, two each for the other three domains), with hands-on labs where you build a real loop. **Professional** — fifteen lessons: an exam-strategy lesson and fourteen domain lessons (three for Integration, two for each of five domains, one for Developer Productivity), with scenarios built around constrained architecture choices. On both courses the first two lessons are free with their podcasts: the exam-strategy lesson, and a first domain lesson — agentic loops and `stop_reason` control flow for Foundations; splitting a request among Claude, existing systems and people and pricing it for Professional. Alloy's Full membership covers the prep for both exams, and for the other two Claude certifications; the exam registrations are separate. Prices are on the pricing page. ## Next step Create a free account — no card needed — and take the diagnostic for either exam, or both.
If you are an experienced architect preparing for the Claude Certified Architect – Professional exam (CCAR-P), "How to Take This Exam" is about the risk experience does not protect you from: choosing an answer that sounds right but does not satisfy what the question asks. The episode runs about 26 minutes and is the podcast for the free first lesson, What CCAR-P Measures, and How to Sit It. Morgan and Casey frame it from the first line — four answer choices "nodding at you like they've all been approved by the board" — as a lesson in disciplined choices under ambiguity, not a technical build session and not a memory contest. ## The problem, and the vocabulary (0:00–3:34) At 1:22 Morgan states the risk plainly: not that you know nothing, but that you pick an answer that sounds right. Casey defines a distractor at 1:35 as the proposal that would make a very convincing slide in the wrong meeting, and Morgan names the stem and item construction at 1:46. The method is mechanical checks, not "this one feels architect-like" (2:03). At 2:12 comes a warning about borrowed tricks: across all forty question-shaped items in the official course material, exactly one carries a recorded correct answer, so nobody is reading keys off that material and "the longest option is usually right" cannot be tested. The short version follows at 2:34–3:23: five wrong-answer shapes, each with a counter; change an answer only for a named miss; 720 on a 100–1,000 scaled score is not a percentage; and expect wrong answers to compete with the right one. ## Five shapes, five checks (3:34–5:28) The counter-example test for the absolutist (3:45), with its tell of always, never, all, only, every (4:09) — a confident universal sounds authoritative precisely because it removes the conditions real systems contain. True but irrelevant (4:20): verifying a true statement feels like work done, and that is the trap. Right action at the wrong layer (4:43): identify whether the problem lives in the prompt, retrieval, application or model before reading options. The over-engineered option (4:58): "fully satisfies" matters — not the cheapest, not the shortest, not "strategic minimalism as a lifestyle". And the answer to a different question (5:11): restate the question as "I need the first step to reduce this risk", and that sentence becomes your comparison standard. ## Changing an answer, and the clock (5:28–6:51) Uncertainty is theatrical — it enters, lowers the lights and tells you your first answer was foolish. A named miss (5:42) is "the question says the response must be grounded in current internal documents". Not stubbornness (5:56): revise because new information arrived, not because the room became uncomfortable. At 6:29 the clock gets specific: 63 questions in 120 minutes is about one minute fifty each, and a question that has taken three minutes has already cost you more than a full item. ## Scoring without false conversions (6:51–11:34) $175 an attempt and twelve months' validity set the stakes (7:00). "Humans love false conversions" — pounds into kilograms, scaled scores into percentages (7:10); the safe reading is that 720 is the threshold on the published scale and the result is the total (7:24). At 7:33, what is not published: flagging and revisiting, adaptive delivery, items per domain on the day. At 8:15 Morgan lists the seven domains, led by Integration at 19%; at 8:59 Casey converts them into questions — about twelve for Integration, four for Developer Productivity. At 9:28 the study strategy: no single domain can fail you, so maximise total items — an hour on Integration is worth about 1.2 items, on Developer Productivity about 0.4. At 10:07 the retake waits compound — 14, 30, 90 days, four attempts in a rolling year — the strongest argument for sitting when ready. At 10:45, what the report returns and why to keep it. And at 11:17, the one absolute rule: unanswered is incorrect and guessing costs nothing, so never leave a blank. ## Why the wrong answer looks right (11:34–14:11) The format is settled at 11:43: unlike the Associate exam, every Professional item has exactly one intended answer, and several options will be defensible in isolation — the constraint discriminates. An option can be individually defensible and contextually wrong (12:25): improving monitoring detects exposure rather than preventing it; adding stale context is "a larger pile of yesterday" (12:56). At 13:09, how Anthropic's own material is built: five modules, forty question-shaped screens, checkpoints outnumbering quizzes almost six to one — it stops you after a decision and asks you to defend it. At 13:35 the discipline that protects everything: a business situation, a narrowing constraint and four reasonable-looking architectures, where the constraint — latency, data residency, human review, cost, an existing system — decides. ## Eight moves in Alloy (14:11–26:00) The diagnostic first, before any revision, weighted like the exam and impossible to shorten (14:11–16:26); an honest confidence rating on every answer and the confident-and-wrong practice set (16:26); flashcards when due, rated again, hard, good or easy (17:56); marking a lesson complete only when done and using Scenarios and Labs to prove it (19:11), with a concept's refresh prompt read as time passing, not demotion (20:34); Recommended next, which gives you your evening back (20:51); practice modes chosen by the question you are asking, and a quick drill that mixes in what you know (21:49); one readiness number built from mastery, honest confidence and coverage, moved within bounds by practice exams (22:21); and coming back, because people keep the curriculum current (23:15). The last move covers labs, scenarios, the activity strip and the Curriculum (24:05), and at 25:11 a caution — all seven domains are taught, but coverage is not depth, so check yourself against the published blueprint. Casey's final practical note at 25:38: bring identification whose name matches your registration exactly, and check the spelling when you book.
If you are preparing at a professional architect level, lesson one of Alloy's Claude Certified Architect – Professional (CCAR-P) course — What CCAR-P Measures, and How to Sit It — is free, with its podcast, "How to Take This Exam". It is about how the exam's questions are built as much as what they cover, because on CCAR-P the risk is rarely that you know nothing. It is that you choose an answer that sounds right and does not satisfy what the question asked. ## Item construction The lesson starts by fixing three words. The **stem** is the question prompt — everything before the options. A **distractor** is a plausible but incorrect option; not random nonsense, but the proposal that would make a convincing slide in the wrong meeting. **Item construction** is the deliberate design of a question and its options together. So a question that feels unfair because all four options look defensible is usually not badly written. It is well constructed, which is a slightly less comforting thought. Knowing the material is necessary and not sufficient: the losses come from options that look right, not from topics you never learned. For CCAR-P the published rule is one best response per item, so you are choosing the best design, not every defensible one. ## The wrong-answer shapes and their counters Five shapes recur, each with a check that converts a vague feeling of doubt into a specific diagnostic: - **The absolutist** — always, never, all, only, every. Name one credible counter-example and the option is out. It often sounds authoritative precisely because it removes the messy conditions real systems contain. - **True, but irrelevant** — a correct answer to the wrong request is still wrong. Because you can verify it, it feels like work completed; re-read the stem's final sentence and ask what it actually requested. - **The correct remedy at the wrong layer** — fixing in the prompt what belongs in retrieval, or in the application what belongs in the model. Name the layer before reading the options. - **The over-engineered option** — prefer the simplest option that fully satisfies the requirement. - **An answer to a different question** — restate the question in your own words, then match. The lesson adds two refinements that stop the counters misfiring. **"Simplest" means simplest sufficient** — not cheapest, not shortest, not minimalism as a principle; an option too thin to meet the requirement fails the same test from the other side. And **your restatement is the comparison standard**: make it operational — *I need the first step that reduces this risk*, or *I need the design choice that best meets this constraint* — and comparing options becomes a match against one sentence you wrote, instead of a contest between four paragraphs the exam wrote. ## Changing an answer Change an answer when you can name what you missed on the first read, not on a feeling. Uncertainty is theatrical: it arrives late, lowers the lights and tells you your first answer was probably foolish. A named miss sounds like "the stem says the response must be grounded in current internal documents". It does not sound like "nothing, but I dislike uncertainty". This is not stubbornness — in a leadership setting it is the difference between revising a decision because new information arrived and reversing it because the room became uncomfortable. And time is the constraint people forget: reopening settled decisions without new evidence costs you items you have not read yet. ## The blueprint | Domain | Weight | |---|---| | Integration | 19% | | Solution Design & Architecture | 17% | | Evaluation, Testing & Optimization | 16% | | Stakeholder Communication & Lifecycle Management | 14% | | Governance, Safety & Risk Management | 14% | | Claude Models, Prompting & Context Engineering | 13% | | Developer Productivity & Operational Enablement | 7% | At 19% of 63 items, Integration is roughly twelve questions; Developer Productivity, at 7%, about four. The eight-item gap is comfortably enough to decide a borderline result. The exam is 63 questions in 120 minutes, $175 an attempt, passed at 720 on a 100–1,000 scaled score, and valid for 12 months. ## Two misreadings of your own result Both cost preparation time rather than marks. **Treating a domain figure as a hurdle** — "I failed that domain, therefore I failed the assessment" — when the decision is made on the total scaled score. And **chasing a raw-percentage target the scoring never promised**: converting a scaled score into a percentage-correct goal invents a number and then optimises against it. A reported score has meaning inside its own scale, the way a credit rating or an investment index does. In the other direction, the result is a certification outcome, not an operating review, a leadership assessment or a crystal ball. ## The shape that dominates The characteristic item gives you a business situation, a constraint that narrows it, and four architectures. The constraint decides: a latency budget, data residency, a human-review requirement, a cost ceiling, or an existing system you must integrate with rather than replace. So read the last sentence of the stem before the options; reading the options first primes you to like whichever one you would have picked in an unconstrained world. Why can a defensible option still be wrong? Because it satisfies half the requirement. *Improve monitoring* is good advice — but if the stem asks for the immediate way to prevent unauthorised data exposure, monitoring detects rather than prevents. *Add more context* often helps — but if the retrieved information is stale, more of it is a larger pile of yesterday. The shift from concept recognition to requirement matching is where most of the available performance sits, and it is a habit, not a fact you can revise. ## What the lesson will not tell you - **Which option of any official item was correct.** Across all 40 Professional items in Anthropic's course material, exactly one carries a recorded answer. - **That "the longest option is usually correct".** With one key in forty, the pattern cannot be tested either way; never let it override a reading of the constraint. - **Whether items can be flagged and revisited, whether delivery is adaptive, or how many items each domain contributes to a sitting.** None of it is published. ## Working the course The lesson closes with the moves that make Alloy pay back: take the diagnostic first (24 questions, about 20 minutes, weighted like the exam); rate your confidence honestly on every answer, because certain-and-wrong is what fails people and Alloy can hand those questions back; work flashcards when they are due; prove material rather than tick it, since reading is the weakest evidence and Scenarios and Labs the strongest; open Recommended next when you do not know what to do; watch the readiness figure and sit a practice exam when it says so; and come back, because the curriculum is watched and kept current by people. All seven domains are taught — but coverage is not depth, so check yourself against the published blueprint before you sit. The exam-strategy lesson is worth a 10–20% score bump. ## Next step Take the free CCAR-P diagnostic, then open lesson one and its podcast. The second lesson — splitting a request among Claude, existing systems and people, and pricing the split before you commit — is free too.
If you are preparing for the Claude Certified Architect – Professional exam (CCAR-P), experience is an advantage and a risk at once: the exam's wrong answers are written to look like good proposals. The strategy is to find where your experience misleads you before the exam does, weight your time by the blueprint rather than by comfort, and sit with a method that converts doubt into a specific check. ## The paper - **63 questions in 120 minutes** — about one minute fifty each. Enough to read a scenario carefully once and decide; not enough to relitigate. - **$175 per attempt**, and the credential is valid for **12 months**. - **One intended answer per item.** Unlike the Associate exam, which mixes multiple choice with multiple response, you are choosing the best design, not every defensible one. - **720 on a 100–1,000 scaled score**, judged on the total. The per-domain percentages on your report are informational, not separate gates. - **Unanswered questions are scored as incorrect, and there is no penalty for guessing.** A guess has positive expected value and a blank has none; if time is running out, fill everything. ## Step 1: find the blind spots Take a diagnostic before you study. Alloy's is free: 24 questions, about 20 minutes, weighted like the exam, with each domain reported as questions right out of questions asked and a confidence rating on every answer. The confident-and-wrong answers are the ones to find first — being unsure and wrong sends you back to check; being certain and wrong never does. ## Step 2: weight by the blueprint, not by experience | Domain | Weight | About how many of 63 | |---|---|---| | Integration | 19% | 12 | | Solution Design & Architecture | 17% | 11 | | Evaluation, Testing & Optimization | 16% | 10 | | Stakeholder Communication & Lifecycle Management | 14% | 9 | | Governance, Safety & Risk Management | 14% | 9 | | Claude Models, Prompting & Context Engineering | 13% | 8 | | Developer Productivity & Operational Enablement | 7% | 4 | Because no single domain can fail you, you are not raising a floor; you are maximising total items correct. An hour that lifts Integration by ten points is worth about 1.2 items, the same hour on Developer Productivity about 0.4. The per-domain counts on the day are not published — the right-hand column is each weight applied to 63 — but the eight-item gap between largest and smallest is enough to decide a borderline result. Check yourself against the published blueprint before you sit. Coverage is not the same as depth; work every domain against its weight rather than against how many lessons mention it. ## Step 3: read for the constraint The characteristic CCAR-P item gives you a business situation, a constraint that narrows it, and four architectures that all look reasonable if you skim. The constraint is what decides: a latency budget, data residency, a human-review requirement, a cost ceiling, or an existing system you must integrate with rather than replace. - **Read the last sentence of the stem before the options.** That is where the constraint usually sits, and reading options first primes you to like whatever you would pick in an unconstrained world. - **Restate the question as a sentence you can measure against** — "I need the first step that reduces this risk", "I need the design choice that best meets this constraint". Comparing options then becomes a match against one sentence you wrote, not a contest between four paragraphs the exam wrote. - **Expect partial truth.** An option can be individually defensible and contextually wrong. *Improve monitoring* detects exposure; it does not prevent it. *Add more context* does nothing for context that is stale. The shift from concept recognition to requirement matching is where most of the available performance sits. ## Step 4: apply the five checks 1. **The absolutist** — "always", "never", "all", "only", "every". Name one credible counter-example and it is out. 2. **True, but irrelevant** — a correct answer to the wrong request is still wrong. Re-read the stem's final sentence. 3. **Right action, wrong layer** — name where the problem lives (prompt, retrieval, application or model) before reviewing options. 4. **The over-engineered option** — choose the simplest *sufficient* option. That is not the cheapest or the shortest; an option too thin to meet the requirement fails the same test from the other side. 5. **An answer to a different question** — your restatement is the standard every option is measured against. ## Step 5: change answers only with a named miss Uncertainty is theatrical: it arrives late, lowers the lights and tells you your first answer was foolish. A named miss sounds like "the stem says the response must be grounded in current internal documents" — a specific constraint that changes the evaluation. "Nothing, but I dislike uncertainty" is not one. This is not stubbornness; it is the difference between revising a decision because new information arrived and reversing it because the room became uncomfortable. And watch the clock: if a question has taken three minutes, you are already more than a full item behind — choose the best option you have and move. ## Step 6: ignore the shortcuts Across the forty question-shaped items in Anthropic's official course material, exactly one carries a recorded correct answer, so nobody is reading the keys from that material, and "the longest option is usually right" cannot be tested in either direction. Whether items can be flagged and revisited, whether delivery adapts, and how many items each domain contributes on the day are also unpublished. The official material's checkpoints outnumber its quizzes almost six to one: it stops you after a decision and asks whether you can defend it. Prepare the same way. ## Step 7: book deliberately, and use the result You have up to four attempts in a rolling 12 months, and the waits compound — 14 days after a first failure, 30 after a second, 90 after a third — so a fourth attempt sits more than four months behind the third. That is the strongest argument for sitting when ready. Bring identification whose name matches your registration exactly; check the spelling when you book. Your report returns pass or fail, the scaled score and percent correct by domain. If you do not pass, keep the breakdown: it tells you where the next fourteen days should go. And read the result for what it is — a certification outcome, not an operating review, a leadership assessment or a crystal ball. ## Next step Take the free CCAR-P diagnostic, then the free exam-strategy lesson and its podcast. The exam-strategy lesson is worth a 10–20% score bump.
If you are preparing for the Claude Certified Architect – Professional exam (CCAR-P), experience is both your advantage and your risk. The exam's wrong answers are written to look like good proposals, and an experienced architect's instincts are exactly what they are built to catch. The free diagnostic shows where your experience carries you and where it does not — before you spend any preparation time. ## What the diagnostic is - 24 questions across all seven of the exam's domains, about 20 minutes, in one sitting - Drawn from the same question bank, under the same rules, as the rest of the course - Weighted the way the exam is weighted, and spread across different tasks within each domain - Each domain reported as questions right out of questions asked - A confidence rating on every answer - Your first run is free and needs no card; a retake uses credits ## Why experience is not enough CCAR-P is 63 questions in 120 minutes, and every item has exactly one intended answer. On architecture questions several options will be defensible in isolation, so the constraint in the stem is what decides — a latency budget, data residency, a human-review requirement, a cost ceiling, or an existing system you must integrate with rather than replace. A distractor on this exam is not nonsense: it is the proposal that would make a convincing slide in the wrong meeting. That is where experience misleads. You can know exactly what retrieval is and why governance matters, and still pick the option that satisfies half the requirement. *Improve monitoring* is good advice — unless the stem asks for the immediate way to **prevent** unauthorised data exposure, which monitoring only detects. *Add more context* often helps — unless the problem is that the retrieved information is **stale**, in which case more of it is a larger pile of yesterday. The diagnostic tests that fit, not recognition. ## Where the weight sits | Domain | Weight | About how many of 63 | |---|---|---| | Integration | 19% | 12 | | Solution Design & Architecture | 17% | 11 | | Evaluation, Testing & Optimization | 16% | 10 | | Stakeholder Communication & Lifecycle Management | 14% | 9 | | Governance, Safety & Risk Management | 14% | 9 | | Claude Models, Prompting & Context Engineering | 13% | 8 | | Developer Productivity & Operational Enablement | 7% | 4 | The item counts are each weight applied to 63; how many items each domain contributes on the day is not published. The exam is passed at 720 on a 100–1,000 scaled score, judged on the total only, so the eight-item gap between Integration and Developer Productivity is enough to decide a borderline result — and an hour that lifts your Integration accuracy by ten points is worth about 1.2 items, against about 0.4 for the same hour on Developer Productivity. ## What you get back A starting readiness figure and, for each domain, how many questions you saw and how many you got right. That is three or four per domain: enough to show where to look first, not enough to grade a domain on its own — the same reason Anthropic treats its own per-domain percentages as informational. If you rated your confidence honestly, you also get the questions you were sure of and got wrong, the most valuable pile in your preparation. ## Mistakes experienced candidates make - Skipping the diagnostic because experience feels like evidence. - Reading the options before the stem's final sentence, where the constraint usually sits. - Choosing the more sophisticated architecture when a simpler one fully meets the requirement — "simplest sufficient" is not "cheapest", and an option too thin to meet the requirement fails the same test. - Treating a lower domain figure as a failed domain; the decision is made on the total. ## Start free Take the free diagnostic, then start the free first lesson — on what CCAR-P measures and how to sit it — and its podcast. The second lesson, on splitting a request among Claude, existing systems and people and pricing it before you commit, is free too.
## What is Claude Certified Architect – Foundations? Claude Certified Architect – Foundations (CCAR-F) is a real, published Anthropic certification. It certifies that you can architect systems on Claude: agents that drive their own control flow, real development workflows, grounded and reliable context, parseable output, and tools and MCP servers that hold up in production. It was previously known as CCA-F; the blueprint did not change with the name. ## Which technologies does it cover? Claude Code, the Claude Agent SDK, the Claude API and the Model Context Protocol (MCP). ## Who is it for? Solution architects building production applications on Claude. Alloy's Foundations course assumes you have prompted Claude and read its output; it does not assume you have shipped an agent, written an MCP server or sat a certification exam before. ## How many questions are there, and how long do I get? 60 questions in 120 minutes. ## How much does it cost, and how do I book it? $125 per registration, booked through Pearson VUE — online proctored via OnVUE, or in person at a Pearson VUE test centre. ## What score do I need to pass? 720 on a scaled score from 100 to 1,000. The exam is pass or fail, scored against a minimum standard set by subject-matter experts. ## Is 720 the same as 72%? No. It is a scaled score, not a percentage of items answered correctly, and it does not convert to one. Do not plan by guessing how many questions you can afford to miss. ## Do I have to pass each domain separately? No. You are scored on the total scaled score only. The per-domain percentages on your result report are informational, not separate bars. ## When do I get my result? Not immediately. Your score is emailed within seven business days. ## What are the domains and their weights? - Agentic Architecture & Orchestration — 27% - Claude Code Configuration & Workflows — 20% - Prompt Engineering & Structured Output — 20% - Tool Design & MCP Integration — 18% - Context Management & Reliability — 15% ## What should I study first? Agentic Architecture & Orchestration, the largest domain and the heart of the credential. Study it first and most, and weight the rest to the exam, not to your comfort. ## What does the exam ask about agentic architecture and orchestration? It is 27% of the exam: an agent whose control flow is driven by the model's `stop_reason`, subagents coordinated through a clear router, context passed between agents, and the choice between a fixed pipeline and a dynamic, adaptive workflow. Pair the reading with a lab where you build a real loop. ## What does it ask about Claude Code configuration and workflows? 20%: running Claude inside a real development loop — plan, edit, verify — and keeping an autonomous run honest rather than letting it confidently ship something broken. Practise questions about what a run should do next, not what each command means. ## What does it ask about prompt engineering and structured output? 20%: getting machine-parseable output you can act on, reliably. The distinction that matters is between asking for JSON and constraining the output so it parses every time. ## What does it ask about tool design and MCP integration? 18%: designing tools and MCP servers whose descriptions and schemas make the model use them correctly rather than guess. It is the smallest domain by concept count, and a fast source of points once the patterns click. ## What does it ask about context management and reliability? 15%: keeping the model grounded in retrieved evidence, making it cite, and recognising when a fluent answer is quietly wrong because its context was thin, stale or unverified. Its anti-pattern questions are the ones learners most often miss. ## What does the exam not test? Anthropic's exam materials list as out of scope: fine-tuning or training models; API authentication, billing or account management; detailed implementation of specific languages or frameworks beyond tool and schema configuration; deploying or hosting MCP servers; Claude's internal architecture, training or weights; Constitutional AI, RLHF or safety-training methods; embedding models and vector-database internals; computer use; vision; streaming and server-sent events; rate limits, quotas and pricing; OAuth, key rotation and authentication protocols; specific cloud-provider configuration; benchmarking and model comparison; prompt-caching implementation beyond knowing it exists; and token-counting algorithms or tokenization. ## Is the exam scenario-based? Yes. Questions are drawn from Anthropic's official scenarios — including Customer Support Resolution Agent, Code Generation with Claude Code, Multi-Agent Research System, Developer Productivity with Claude, Claude Code for CI/CD and Structured Data Extraction — and each exam form presents four of them. Practise every scenario rather than betting on the draw. ## What do the questions look like? Most are scenarios: a realistic design and what to do, or a flawed approach and what fails and what the correct alternative is. Recall questions exist but are the minority. Anthropic's exam materials describe each question as one correct response and three distractors. Still read each item's instruction line before answering. ## Should I guess if I do not know? Yes. Unanswered questions are scored as incorrect and there is no penalty for guessing, so never leave an item blank. ## What are the common wrong-answer traps? Five recur: the absolutist ("always", "never", "only" — one counter-example defeats it); true but not the question (re-read the stem's final sentence); right action at the wrong layer (name the layer before reading options); the over-engineered option (prefer the simplest sufficient answer); and an answer to a different question (restate the question first). The misconception behind all five is that the most impressive answer must be the best. ## When should I change an answer? Only when you can name what you missed — an overlooked qualifier, a missed requirement, a misread outcome, a fact that changes the comparison. Never because of anxiety, a louder-sounding distractor or the clock. ## What are the rules on the day? Using AI products or services during the exam is prohibited. Online OnVUE sessions need a webcam, microphone, screen sharing and a stable internet connection, and are monitored and recorded throughout; test-centre sittings are invigilated on site. Your government-issued photo ID must match the name on your registration. ## What happens if the rules are broken? Violations can result in score invalidation, suspension from future exams or permanent prohibition, with no fee refund. Misconduct and enforcement decisions can be appealed within 14 calendar days through Anthropic's academy support. ## Are accommodations available? Yes. Reasonable accommodations for disabilities are available — contact Anthropic's academy support before your exam date. ## How many times can I take it? Four attempts in a rolling 12-month period. Each attempt is a separate $125 registration, so the allowance limits how often you may sit; it does not make retakes free. ## How long is the certification valid, and how do I renew it? 12 months from the date you pass. Renewal is free and non-proctored, but it must be completed before the term expires; if it lapses, you re-earn the certification from scratch. ## Do I get a badge? Yes. Passing issues a Credly digital badge, the shareable and publicly verifiable form of the credential. ## Does it count towards the Claude Partner Network? Yes. CCAR-F is one of the exams that count towards Claude Partner Network eligibility. ## Is the exam guide enough on its own? Anthropic's own advice is to get very familiar with the exam guide, and that unless you already have hands-on practice with Claude Code, the Agent SDK, the Claude API and MCP, skipping it will likely mean not passing. Reading the guide is necessary; practising the decisions it describes is what the exam rewards. ## How should I study? Read just enough to understand why each mechanism exists, then practise immediately: commit to an answer, rate your confidence, and review where your reasoning broke. Interleave domains rather than cramming one to exhaustion. ## How is Alloy's CCAR-F course organised? Thirteen lessons: an exam-strategy lesson, then twelve domain lessons — three each for agentic architecture and Claude Code workflows, and two each for structured output, tool design and MCP, and context reliability — alongside practice, flashcards, scenarios, hands-on labs and a final exam that unlocks when your readiness reaches ready. ## Why use Alloy for this exam prep? Start with the free diagnostic — 24 questions, about 20 minutes, weighted like the exam, each domain reported as questions right out of questions asked. Every answer carries a confidence rating, so Alloy can hand back what you were sure of and got wrong. Readiness is computed from mastery, calibration and coverage on the exam's domains, never from a countdown. The first two lessons of the course are free too. ## What is in the free lessons? The exam-strategy lesson — how CCAR-F is scored, its wrong-answer shapes, what it measures and how to study the five domains — and the first domain lesson, on agentic loops and `stop_reason` control flow. Both come with their podcasts, hosted by Morgan and Casey. ## Is the exam-strategy lesson worth it? Yes. The exam-strategy lesson is worth a 10–20% score bump: it stops you giving away questions you already knew. ## Is Alloy the exam? No. Alloy is independent preparation and is not affiliated with Anthropic. Finishing the course confers no credential; the credential comes from sitting CCAR-F with Pearson VUE. ## Does one subscription cover the Professional exam too? Yes. Alloy's Full membership covers all four Claude certification courses — including Claude Certified Architect — Professional — and every course that opens while you are a member. Prices are on the pricing page.
Take a free 24-question diagnostic for the Claude Certified Architect – Foundations (CCAR-F) exam. It takes about 20 minutes, needs no card, and tells you where you actually stand across the exam's five domains before you spend a week studying the wrong one. ## What the diagnostic is A short sitting built to the shape of CCAR-F. It draws from the same question bank, under the same rules, as the rest of the course — it is not a quiz bolted on the side — so what it reports is where you stand against this exam rather than against a warm-up. Like the exam, it is about decisions: a realistic design and what to do next, or a flawed approach and what fails. ## Why it comes first CCAR-F is scored on one total scaled score — 720 on a 100–1,000 scale — with no separate minimum per domain, and its domains are not equal: - Agentic Architecture & Orchestration — 27% - Claude Code Configuration & Workflows — 20% - Prompt Engineering & Structured Output — 20% - Tool Design & MCP Integration — 18% - Context Management & Reliability — 15% A weak spot in agentic architecture costs you nearly twice what the same weak spot costs in context reliability. The diagnostic tells you which of your weak spots are the expensive ones, and the instinct to revise a little first — so the result is less embarrassing — is the instinct that costs you a week, because a diagnostic taken after a warm-up measures the warm-up. ## How it is shaped - **Weighted like the exam.** The domains it draws from, and how heavily, follow the exam's published weights. - **Spread inside each domain.** It covers different tasks within a domain rather than asking the same thing four times, so a weak result is proportionally expensive rather than one unlucky question. - **Fixed length, one sitting.** The course sets its length and Alloy will not shorten it. A partial diagnostic is not a smaller one, it is a worse one: it measures less and still reports with the same confidence. - **A confidence rating on every answer.** You cannot submit without it. Alloy watches the gap between how sure you were and how right you turned out to be — certain and wrong is what fails people, because an answer you were sure of never gets re-checked. ## What you get back A starting readiness figure, and each of the five domains reported as questions right out of questions asked, on the summary screen. With 24 questions across five domains, each gets only a handful, so read the counts as a pointer to where to begin, not a precise score. Anthropic treats its own per-domain percentages the same way: informational, never the pass decision. If you rated honestly, you also get the set of questions you were sure about and got wrong — the highest-value pile to study first. ## What to do with the result 1. **Open your weakest heavy domain first.** Agentic architecture, at 27%, is the heart of the credential; if it is weak, start there, and pair the reading with a lab where you build a real loop. 2. **Run the confident-and-wrong practice set** straight after the diagnostic. 3. **Follow Recommended next** when you are unsure what to study; it weighs what you are closest to forgetting, where you are weakest and what carries the most weight that you have not started. 4. **Leave out what the exam does not test** — fine-tuning, computer use, vision, streaming, tokenization specifics, cloud configuration and MCP server hosting are all on its published out-of-scope list. ## Mistakes to avoid - Revising before the diagnostic. - Rating every answer at the top of the scale — it throws away the signal and buys nothing. - Treating a handful of questions per domain as a percentage. - Stopping partway through. - Studying the domain you already find comfortable because the result made it look close. ## What is free A free account has no card and no trial clock. It includes this diagnostic, the first two lessons of the course with their podcasts — the exam-strategy lesson, on how CCAR-F is scored and how its wrong answers are built, and the lesson on agentic loops and `stop_reason` control flow — and a place to store and verify certifications you already hold. Take the diagnostic, then start the free first lesson.
If you are moving toward Claude solution architecture and wondering what to study first, lesson one of Alloy's Claude Certified Architect – Foundations (CCAR-F) course answers it: what the exam measures, how it asks, and how to be ready. The lesson is free, and so is its podcast, "How to Take This Exam". It has four parts. ## Part 1: how the assessment works CCAR-F is a real published certification, and its pass mark is 720 on a scaled score of 100–1,000 — a scaled score, not a percentage of items answered correctly, and it does not convert to one. Scoring is on the total scaled score only; the per-domain percentages on your result are informational, not separate bars. The lesson draws the practical consequence straight away: do not set your preparation target by guessing how many questions you can afford to miss, because the scoring model does not support that conversion. Doing it anyway produces false confidence in one of two directions — stopping too early, or over-investing in the wrong area because the number was read as something it is not. ## Part 2: how to take the exam Knowing the material is half a pass; the other half is what you do in the seat. A certification question's wrong answers are written to compete with the right one, so the losses come from options that look right rather than from material you never learned. The misconception underneath every wrong-answer shape is that the most impressive answer must be the best. The test is never *could this work?* — plenty of wrong options would — but *does this best satisfy this exact requirement?* The lesson names five shapes, each with its tell and its counter: | Shape | The tell | The counter | |---|---|---| | The absolutist | always / never / all / only / every | Name one counter-example. You only need to show it is not universally true. | | True, but not the question | A correct statement that does not answer what was asked | Re-read the stem's final sentence: does it want the best design, the first action, the main benefit, the most appropriate control, or the explanation for a specific failure? | | Right action, wrong layer | The right remedy in the wrong place — the prompt instead of retrieval, the application instead of the model | Name the layer the problem lives in before reading the options. | | The over-engineered one | More architecture than the scenario needs — an agent where one call works | Prefer the simplest option that fully satisfies the requirement. | | Answers a different question | A strong answer to an adjacent question | Restate the question in your own words first, then match. | **Changing an answer.** Change it when you can name what you missed on the first read, and not on a feeling. A valid change has a specific trigger — an overlooked qualifier, a missed requirement, a misread outcome, a fact that changes the comparison. Anxiety is not new evidence, and the ticking clock is the worst reason of all. The rule prevents two opposite failures: keeping an answer after discovering a genuine miss, and abandoning a defensible one because a distractor has become psychologically louder. ## Part 3: what the Architect exam measures The exam is built to defeat a vocabulary strategy. It measures whether you can make an architect's design decisions on real systems: should this be a fixed pipeline or an adaptive agent loop, how does control flow terminate, where does grounded context come from and how do you know it has gone stale, what output can the next system parse, and which tools does the model get and how are they described? None has a one-word answer, so most questions are scenarios — a realistic design and "what do you do?", or a flawed approach and "what fails, and what is the correct alternative?" Recall questions exist but are the minority. Five domains organise that judgement: 1. **Agentic Architecture & Orchestration (27%)** — an agent whose control flow is driven by `stop_reason`, subagents coordinated through a clear router, and the choice between a fixed pipeline and a dynamic workflow. The largest domain. 2. **Claude Code Configuration & Workflows (20%)** — plan, edit, verify, and keeping an autonomous run honest. 3. **Prompt Engineering & Structured Output (20%)** — machine-parseable output you can act on, reliably. 4. **Tool Design & MCP Integration (18%)** — tools and MCP servers whose descriptions and schemas make the model use them correctly. 5. **Context Management & Reliability (15%)** — grounding in retrieved evidence, citation, and spotting a fluent answer built on thin, stale or unverified context. ## Part 4: the five domains as a study plan Weight your effort to the exam, not your comfort. The lesson's first pass through the path: 1. **Agentic architecture — study first, study most.** Agentic loops, coordinator and subagent orchestration, context passing and the pipeline-versus-workflow trade-off, paired with the lab where you build a real loop. 2. **Claude Code workflows.** The plan → edit → verify loop and the verification discipline that stops an autonomous run confidently shipping something broken. Practise questions about what a run should do next. 3. **Context reliability.** Retrieval, grounding and citation, and the anti-patterns learners most often miss — over-weight them. 4. **Prompting and structured outputs.** The difference between asking nicely for JSON and constraining output so it parses every time. 5. **Tool design and MCP.** Descriptions and schemas that make the model use tools correctly — the smallest domain by concept count and a fast source of points. The discipline that works: read just enough to understand why a mechanism exists, then practise immediately — commit, rate your confidence, review where your reasoning broke — and interleave domains rather than cramming one. ## How to use Alloy to get ready The lesson ends with the workspace itself, in order: 1. **Take the diagnostic first**, before a single lesson, in one sitting — 24 questions, about 20 minutes, from the same question bank and weighted like the exam, with a breakdown by domain on the summary screen. 2. **Rate your confidence honestly on every answer.** Certain-and-wrong is what fails people; Alloy can hand back exactly those questions. 3. **Do flashcards on the day they come up**, rating recall Again, Hard, Good or Easy — "Again" is the most useful answer. 4. **Prove it rather than tick it.** Reading is the weakest evidence; being right when confident is stronger; a scenario or lab stronger still. Each concept carries a state — studied, practised, built, passed, demonstrated — and a passing lab, especially one done with no help, is the strongest proof you can produce. 5. **Open Recommended next** when you do not know what to do; it weighs what you are closest to forgetting, where you are weakest, and what carries the most weight that you have not started. 6. **Watch readiness** — not ready, almost, ready, strongly ready — and sit a practice exam when it says to. When it reaches ready, the course's final exam unlocks. 7. **Come back**, because the curriculum is watched and kept current by people. 8. **Use labs and scenarios** where they appear, and the Curriculum as the map everything is indexed against. The exam-strategy lesson is worth a 10–20% score bump, because it stops you giving away questions you already knew. ## Next step Take the free CCAR-F diagnostic, then start lesson one and its podcast. The second lesson, on agentic loops and `stop_reason` control flow, is free too.
If you are preparing for the Claude Certified Architect – Foundations (CCAR-F) exam, two published facts should decide where your hours go: how its five domains are weighted, and the list of topics the exam says it will not test. Together they tell you what to study hardest and what to leave alone. ## What the exam certifies CCAR-F is not a quiz about a single API call. It certifies that you can architect systems on Claude: design agents that drive their own control flow, run them through real development workflows, keep their context grounded and reliable, prompt them for output you can parse, and extend them with tools and MCP servers that hold up in production. The technologies it covers are Claude Code, the Claude Agent SDK, the Claude API and the Model Context Protocol. It is built to defeat a vocabulary strategy. Memorising parameter names and definitions does not pass it, because it measures whether you can make an architect's design decisions under realistic constraints, where more than one answer looks plausible and only one holds up. Most questions are scenarios: you are handed a realistic design and asked what to do, or shown a flawed approach and asked to name the failure and the correct alternative. Recall questions exist, but they are the minority. ## Where the weight sits Five weighted domains, largest first: **Agentic Architecture & Orchestration — 27%.** The heaviest domain and the heart of the credential: an agent whose control flow is driven by the model's `stop_reason`, subagents coordinated through a clear router, context passed between agents, and the choice between a fixed pipeline and a dynamic, adaptive workflow. **Claude Code Configuration & Workflows — 20%.** Running Claude inside a real development loop — plan, edit, verify — and keeping an autonomous run honest rather than letting it confidently ship something broken. **Prompt Engineering & Structured Output — 20%.** Getting machine-parseable output you can act on, reliably, instead of prose you have to regex your way through downstream. The distinction that matters is between asking nicely for JSON and constraining the output so it parses every time. **Tool Design & MCP Integration — 18%.** Tools and Model Context Protocol servers whose descriptions and schemas make the model use them correctly rather than guess. It is the smallest domain by concept count, but a fast source of points once the patterns click. **Context Management & Reliability — 15%.** Keeping the model grounded in retrieved evidence, making it cite, and recognising where a fluent answer is quietly wrong because its context was thin, stale or unverified. The anti-pattern questions here are the ones learners most often miss. Scoring is on the total scaled score only — 720 on a 100–1,000 scale — and the per-domain percentages on your result report are informational, not separate bars. So the weights are the plan: an hour spent in a 27% domain buys more than an hour in a 15% one. ## What the exam will not test Anthropic's exam materials list topics that are out of scope. Every hour spent on them is an hour taken from the weighted domains: - Fine-tuning Claude models or training custom models - Claude API authentication, billing or account management - Detailed implementation of specific programming languages or frameworks, beyond what tool and schema configuration needs - Deploying or hosting MCP servers — infrastructure, networking, container orchestration - Claude's internal architecture, training process or model weights - Constitutional AI, RLHF or safety-training methodologies - Embedding models or vector-database implementation details - Computer use (browser automation, desktop interaction) - Vision and image analysis - Streaming API implementation or server-sent events - Rate limiting, quotas or API pricing calculations - OAuth, API key rotation or authentication protocol details - Specific cloud-provider configurations (AWS, GCP, Azure) - Performance benchmarking or model comparison metrics - Prompt-caching implementation details, beyond knowing it exists - Token-counting algorithms or tokenization specifics Notice what that list does to a developer's instincts. Streaming, tokenization, authentication and cloud configuration are real engineering work, and none of it is examined here. MCP server *design* is in scope; MCP server *hosting* is not. ## The scenarios questions are drawn from CCAR-F is scenario-based. Questions are drawn from Anthropic's official scenarios, and each exam form presents four of them. The official scenarios include Customer Support Resolution Agent, Code Generation with Claude Code, Multi-Agent Research System, Developer Productivity with Claude, Claude Code for CI/CD and Structured Data Extraction. Practise every scenario rather than betting on the draw. ## How to study each domain - **Agentic architecture — first and most.** Study agentic loops with `stop_reason`-driven control flow, coordinator and subagent orchestration, context passing, and the pipeline-versus-workflow trade-off, and pair the reading with a lab where you build a real loop. There is no substitute for having written the control flow yourself. - **Claude Code workflows.** Practise the scenario questions that ask what a run should do next, not what each command means. - **Context reliability.** Over-weight the anti-pattern questions, where a fluent answer is wrong because its context was thin, stale or unverified. - **Prompting and structured outputs.** Learn the difference between requesting JSON and constraining output so it parses every time. - **Tool design and MCP.** Focus on descriptions and schemas that make the model choose and call tools correctly. For every concept: read just enough to understand why the mechanism exists, then practise immediately — commit to an answer, rate your confidence, review where your reasoning broke. Interleave the domains rather than cramming one to exhaustion. ## What the first domain lesson looks like The course's first domain lesson — free, with its podcast — is on agentic loops and `stop_reason` control flow, the core of the heaviest domain. It teaches that the loop is model-directed: your runtime sends messages and tools, reads `stop_reason`, executes every requested tool on `tool_use`, appends the results, and leaves the loop on anything else. Text in a response never decides whether to continue — Claude routinely writes prose and requests a tool in the same message. The API keeps no conversation state, so your runtime resends the whole history every time. Tool results pair with their calls by `tool_use_id`, not by order, and return together in one user message. And if you know the exact steps in advance, you build a workflow; if you do not, you build an agent. ## The mistakes that waste the most time - Studying out-of-scope engineering — streaming, tokenization, authentication, hosting — because it feels relevant. - Treating the exam as recall and memorising definitions. - Over-studying the domain you already find comfortable. - Reading 720 as 72% and planning by how many questions you can afford to miss. - Preparing for some scenarios and hoping the draw avoids the others. ## How the course maps to the blueprint Thirteen lessons: an exam-strategy lesson, then twelve domain lessons — three each for Agentic Architecture & Orchestration and Claude Code Configuration & Workflows, and two each for Prompt Engineering & Structured Output, Tool Design & MCP Integration and Context Management & Reliability. ## Next step Take the free CCAR-F diagnostic before you study anything: 24 questions, about 20 minutes, drawn from the same question bank as the rest of the course and weighted like the exam. It reports each domain as questions right out of questions asked — only a few per domain, so a pointer rather than a precise score. The exam-strategy lesson and the lesson on agentic loops are free, with their podcasts.
## What is Claude Certified Developer – Foundations? Claude Certified Developer – Foundations (CCDV-F) is a real, published, proctored Anthropic certification for developers who build applications on the Claude API. It is one of Anthropic's four Claude certifications, alongside the Associate and the two Architect exams. ## Who is it for? AI and machine-learning engineers, technical leads and senior software engineers — typically with one to five years of software engineering and at least six months of hands-on work with Claude or a comparable LLM system. ## Are there prerequisites? No. The credential is awarded on exam performance alone. ## How long is the exam, and what does it cost? 53 questions in 120 minutes, at $125 per attempt — a shade over two minutes an item. ## How is it delivered? Through Pearson VUE, online proctored or at a test centre. ## What score do I need to pass? 720 on a scaled score from 100 to 1,000. ## Is 720 the same as 72%? No. It is a scaled score, not a percentage of items answered correctly, and it does not convert to a number of questions you must get right. ## Is the exam graded on a curve? No. The cut score is criterion-referenced: it comes from a formal standard-setting study, and every candidate is measured against the same fixed standard, not against the other people who sat that week. ## Do I have to pass every domain? No. You are judged on your total scaled score. The per-domain percentages on your result report are informational and are not used to decide pass or fail. ## What does my result report show? Pass or fail, your scaled score from 100 to 1,000, and the percentage of items you answered correctly in each domain. ## What are the domains and their weights? - Applications and Integration — 33.1% - Model Selection and Optimization — 16.8% - Agents and Workflows — 14.7% - Prompt and Context Engineering — 11.0% - Tools and MCPs — 10.6% - Security and Safety — 8.1% - Claude Code — 3.1% - Eval, Testing, and Debugging — 2.6% ## Roughly how many questions come from each domain? The guide publishes weights, not item counts. Multiplying each weight by 53 gives an expectation of about 18, 9, 8, 6, 6, 4, 2 and 1 items, from Applications and Integration down to Eval, Testing, and Debugging. ## Which domain matters most? Applications and Integration, at 33.1% — a third of the exam, more than the next two domains combined and more than the four lightest together. ## Is Applications and Integration just the API? No. It carries six weighted sub-objectives: Understanding Requirements, Systems Life Cycle, Claude API Mechanics, Software Engineering Foundations, Claude Application Design and Configuration Management. Requirements gathering and life-cycle placement are graded. ## Does the guide weight anything below the domains? Yes — uniquely in Anthropic's certification family, it weights 25 sub-objectives, each with its own share of the paper. Claude Application Design is the heaviest at 8.6%, more than the whole Security and Safety domain. Software Engineering Foundations (7.4%) outweighs Tool Implementation (4.4%). Claude Hooks is the lightest at 1.0%, about half an item. ## What does each domain actually test? - **Applications and Integration:** turning a requirement into a Claude application that survives production — request and response shape, `stop_reason` branching, error paths, configuration and versioning. - **Model Selection and Optimization:** tokens, the context window as a fixed budget, sampling and non-determinism, cost and token management, and choosing a model versus enabling a reasoning mode. - **Agents and Workflows:** workflow versus agent, loops that terminate, memory across sessions, and human-in-the-loop checkpoints where actions are irreversible. - **Prompt and Context Engineering:** system prompts, XML structure, few-shot examples, output constraints, compaction, clearing history, subagent handoff and output parsing. - **Tools and MCPs:** tool schemas Claude selects correctly, results returned in the expected form, and MCP servers with the right transport and configuration scope. - **Security and Safety:** prompt injection from fetched content, jailbreaks, untrusted input, scoped identity, secrets management and data boundaries. - **Claude Code:** the explore–plan–code loop, permission modes matched to risk, and durable project context. - **Eval, Testing, and Debugging:** defining "done" before deploying, choosing a grading method, and telling retriable errors from terminal ones. ## Does the guide publish in-scope or out-of-scope topic lists? No. The guide publishes no such appendix; its task statements are the whole of the published scope. ## What question formats should I expect? Multiple-choice and multiple-response items, each stating how many responses to select. Do not assume four options or a single answer: in the captured courseware items, twelve of seventeen offered four options and five offered three. ## What do the questions look like? Anthropic's courseware uses four-option scenarios, targeted fixes read off a session trace, fill-in-the-blank configuration, matching deployment scenarios to transport-and-scope pairs, free-text corrections compared against a model answer, a multi-layer debug with bugs planted in the schema, streaming, context and memory layers, and "assemble the minimal configuration" items that ask you to leave out what does not belong. These are courseware shapes; nothing states the exam reuses them. ## Can I get the official answers to practice questions? No. None of the 32 courseware items visible to the course carries a recorded correct answer, so anyone claiming to know the official answers is not reading them from the courseware. ## What are the most common wrong-answer traps? The absolutist ("always", "never", "only"); true but not the question; right action at the wrong layer; the over-engineered option; and an answer to a different question. The developer versions add a plausible-but-wrong API shape — real fields that fix a different class of defect than the error names — and an anti-pattern wearing best-practice clothing, such as rotating a key but leaving it in the credentials file. ## How should I read a trace or error question? Evidence first: classify the defect as schema validation, message ordering, transport or authentication, and name the layer it lives in. Then read the options and discard everything outside that class. ## When should I change an answer? Only when you can name what you missed on the first read — never because your confidence wobbled. ## Can I flag and revisit questions? Are breaks allowed? Not published. Nothing says whether you can flag and revisit items, whether delivery is adaptive, whether partial credit or negative marking applies, or whether breaks and scratch paper are allowed. Confirm anything your pacing depends on when you register. ## What ID do I need, and what is the NDA? Valid, unexpired, government-issued photo ID whose name matches your registration exactly. You must accept the NDA before the exam begins; declining ends the session with no refund. ## What is the cancellation policy? Cancelling less than 24 hours before your slot forfeits the fee, as does not showing up. ## What if I do not pass? The retake waits are 14 days, then 30, then 90, with a maximum of four attempts in a rolling 12 months, and the fee is payable each time. Keep your per-domain breakdown — it is your plan for the retake. ## Can I appeal? Appeals must be filed within 14 days. Neither the standard-setting outcome nor the content of an individual item is appealable. ## How long does the credential last? 12 months. Renewing on time is a free, non-proctored assessment on the Partner Academy; if it lapses, you sit the full exam again at full fee. ## Does it count towards the Claude Partner Network? Yes. CCDV-F is one of the exams that count towards Claude Partner Network eligibility. ## Which topics should I study first? The heaviest ones, because only the total score counts: an hour that lifts Applications and Integration by ten points is worth about 1.8 items, against about 0.1 for Eval, Testing, and Debugging. The exception is a domain where you are near zero — security items are decidable once you know the failure modes and undecidable otherwise. ## Are Claude Code and evals worth studying? An hour each. Together they are 5.7% of the exam, about three items — the two most enjoyable topics and the two worst places to spend a third of your revision. ## Does setting temperature to 0 make Claude deterministic? No. The newest models reject non-default `temperature`, `top_p` and `top_k` with a `400`, and where temperature is accepted, `0` makes output more repeatable without guaranteeing identical text. Tests should assert properties, not exact prose. ## Does streaming make responses faster? No. Streaming changes when the pieces of one response arrive; it does not reduce total generation time or raise throughput. Fast mode raises output tokens per second at premium pricing, and does not improve time to first token. ## Does Claude's API use websockets? No. Claude streams over server-sent events on an ordinary HTTP response. A websocket can legitimately sit between a browser and your server; the hop to Claude is HTTPS. ## Is Alloy the exam? No. Alloy is independent preparation and is not affiliated with Anthropic. Passing CCDV-F is what earns the credential; finishing the course confers none. ## How is Alloy's CCDV-F course organised? Thirteen lessons: an exam-strategy lesson, then twelve domain lessons in a teaching order — fundamentals before API mechanics, mechanics before what is built on them. Applications and Integration gets four lessons, Model Selection and Optimization two, and each other domain one. Every domain lesson is built against the exam's published objectives. ## Where should I start? With the free diagnostic, before you study anything: 24 questions, about 20 minutes, drawn from the same question bank as the course and weighted like the exam. It reports each domain as questions right out of questions asked — about three per domain, so a pointer, not a grade. ## What is free? A free account needs no card and has no trial clock. It includes the full diagnostic, the first two lessons with their podcasts — the exam-strategy lesson and the lesson on what a request costs, why it varies and how it reaches Claude — and a place to store and verify certifications you already hold. ## Is the exam-strategy lesson worth it? Yes. The exam-strategy lesson is worth a 10–20% score bump: it targets getting wrong a question you actually knew. ## Why does Alloy ask how confident I am? Because certain-and-wrong is what fails people: an answer you were sure of never gets re-checked. Alloy tracks the gap between confidence and correctness, counts it towards readiness, and can hand back exactly the questions you were confident about and got wrong. ## Is there a podcast? Yes, hosted by Morgan and Casey. "How to Take This Exam" (about 24 minutes) goes with the exam-strategy lesson; the second lesson has a short episode and a question walkthrough. ## Does one subscription cover the other Claude certifications? Yes. Alloy's Full membership covers all four Claude certification courses, and every course that opens while you are a member. Prices are on the pricing page, and credits you buy never expire.
Claude Certified Developer – Foundations (CCDV-F) is a judgement exam. Fifty-three items in 120 minutes is a shade over two minutes each, the stems are long, and most marks are lost to options that look right rather than to material you never learned. The strategy comes down to four things: where your hours go, how you read an item, how you practise, and when you sit. ## The rules the strategy rests on - **720 on a 100–1,000 scaled score.** Not 72%, and it converts to no number of correct items, so do not plan by counting how many you can afford to miss. - **Total score only.** The domain percentages on your report are informational; there is no bar to clear in each domain. - **Criterion-referenced.** The cut score comes from a formal standard-setting study, not from how other candidates did that week. - **Multiple-choice and multiple-response.** Each item states how many options to select. In the captured courseware items, twelve of seventeen offered four options and five offered three — never assume a shape. - **$125 an attempt, four attempts at most in a rolling 12 months**, with waits of 14, 30 and 90 days after successive misses. ## Where your hours go Because only the total counts, the rational plan is to maximise total items correct, so weight your time by what each domain carries: | Domain | Weight | Expected items of 53 | |---|---|---| | Applications and Integration | 33.1% | ~18 | | Model Selection and Optimization | 16.8% | ~9 | | Agents and Workflows | 14.7% | ~8 | | Prompt and Context Engineering | 11.0% | ~6 | | Tools and MCPs | 10.6% | ~6 | | Security and Safety | 8.1% | ~4 | | Claude Code | 3.1% | ~2 | | Eval, Testing, and Debugging | 2.6% | ~1 | (The guide publishes weights; the item column is each weight multiplied by 53.) An hour that lifts your accuracy ten points in Applications and Integration is worth about 1.8 items; the same hour in Eval, Testing, and Debugging is worth about 0.1. Both are real improvements, and one is worth about a dozen of the other. Go below the domains, because this guide lets you. It weights 25 sub-objectives. Claude Application Design (8.6%) outweighs the whole Security and Safety domain; Software Engineering Foundations (7.4%) outweighs Tool Implementation (4.4%), the heaviest sub-objective in Tools and MCPs; Claude Hooks (1.0%) is about half an item. Applications and Integration is not "the API chapter": requirements, the systems life cycle, engineering foundations, application design and configuration management are all graded inside it. **The one exception to ordering by weight** is a domain where you are near zero rather than weak. Security items are decidable once you know the failure modes and undecidable when you do not, so going from nothing to competent there is a bigger swing than 8.1% suggests. Find out which domains are yours to fix before you start: Alloy's free diagnostic is 24 questions, about 20 minutes, weighted like the exam. ## How you read an item **Evidence first, then the layer, then the options.** Many items hand you an error, a trace or a configuration. Read it before the options and classify the defect — schema validation, message ordering, transport or authentication. Then name the layer it lives in — prompt, parser, schema, loop, tool or transport. Only then read the choices, and discard everything outside that class and layer. This reading order is what makes the trace items fast. **Use what the stem closes off.** A trace item that tells you the schema is valid and the description is specific has eliminated two of three fixes before you read them. **Watch for the five wrong-answer shapes, in their developer form:** 1. **The absolutist** — "always", "never", "only". One counter-example and it is out. 2. **True, but not the question** — a correct statement about `stop_reason` or `is_error` in an item about ordering. Re-read the final sentence. 3. **Right action, wrong layer** — a prompt change for a parser defect, a schema change for a loop defect. 4. **The over-engineered one** — an agent where one call works, a retrieval index where a cached prefix works, a stronger model where a corrected prompt works. Prefer the simplest option that fully meets the requirement. 5. **An answer to a different question** — restate the question in your own words, then match. Two developer-specific traps sit on top of those. A **plausible-but-wrong API shape** names real fields in a real order and fixes a different class of defect than the error names — a `required` array added to a schema when the failure is a mismatched `tool_use_id`. An **anti-pattern wearing best-practice clothing** promises thoroughness or convenience while removing a control: rotating a key but leaving it in the credentials file, concatenating every past transcript "for memory", or switching to `bypassPermissions` for fewer prompts. **Practise subtraction.** One item shape hands you four plausible pieces of configuration and tells you to leave out anything that does not belong. That clause is the whole item; the over-engineering instinct loses it. **Change an answer only with a receipt.** "I missed the word *only*." "I overlooked the constraint." "The question asks which action comes first." Those are auditable reasons. A wobble in confidence is not. **Pace for reading.** Two minutes an item is comfortable for recall and tight for a trace. Nothing published says whether you can flag and revisit items, whether delivery is adaptive, whether partial credit or negative marking applies, or whether breaks and scratch paper are allowed; confirm anything your pacing depends on when you register. ## How you practise - **Read each domain as failure prevention.** Anthropic's courseware frames every topic as the implementation decision that prevents a specific production failure. Ask that question and scenario items stop looking like trivia. - **Review your reasoning, not the letter you picked.** The right option for the wrong reason will not survive a rephrased trace. - **Rate your confidence honestly.** Certain-and-wrong answers never get re-checked; Alloy collects them into a practice set of their own. - **Keep flashcards due.** Reviewed just before you would forget them, exact values — status codes, field names, defaults — stay available without a cram session. - **Know the fundamentals precisely.** The exam rewards distinctions such as choosing a model versus enabling extended thinking, streaming versus async, `max_tokens` as the only hard ceiling, and why `temperature: 0` does not make output identical — the material of the course's free second lesson. ## When you sit, and what you do after The binding constraint is not the retake ladder but the four-attempt annual cap, with the full fee each time. Book when your practice says you are ready, not when a date feels motivating. In Alloy that is the readiness figure, built from mastery, honest confidence and coverage, and adjusted — within bounds — by practice exams. On the day: accept the NDA (declining ends the session with no refund), bring government photo ID matching your registration exactly, and never cancel inside 24 hours. After: keep the per-domain breakdown if you need a retake — it is your plan. Appeals run within 14 days but cannot contest the standard-setting outcome or item content. Renew within 12 months and it is a free, non-proctored assessment; let it lapse and you sit the full exam again. ## Next step Take the free CCDV-F diagnostic, then the free exam-strategy lesson and its podcast. The exam-strategy lesson is worth a 10–20% score bump.
The first lesson of Alloy's Claude Certified Developer – Foundations (CCDV-F) course is about the exam as an assessment: how it is scored, where its weight sits, what shapes its questions take, how its wrong answers are built, and how to sit it. It is free, with its podcast, "How to Take This Exam". Its premise is that the items you lose are rarely on unfamiliar material. They offer several reasonable answers — one technically true but irrelevant, another an elaborate solution to a problem nobody asked — and the lesson trains you to see the difference. ## Why item construction is worth studying A certification question's wrong answers are written to compete with the right one. A distractor is not random debris: it is there because a knowledgeable person might pick it, for a nameable reason — it is true but does not answer what was asked, it is the right action at the wrong layer, or it addresses a problem the stem did not describe. "Not nonsense" is a very low bar, and most distractors clear it. So the lesson asks you to stop asking *"could this be right?"* and ask *"is this the best answer to this exact request, at this exact layer, with this exact evidence?"* ## The credential, in published facts | Detail | Published value | |---|---| | Fee | $125 USD per attempt | | Items | 53 | | Time | 120 minutes | | Passing | 720 on a 100–1,000 scale | | Format | multiple-choice and multiple-response; each item states how many to select | | Validity | 12 months | | Delivery | Pearson VUE, online proctored or at a test centre | | Prerequisites | none | Fifty-three items in 120 minutes is a shade over two minutes an item — comfortable for recall and tight for a question that hands you a session trace and asks which of three fixes is targeted. Developer stems run long, so budget reading time as well as deciding time. 720 is a scaled score, not a percentage, and does not convert to "answer this many of 53 correctly". The cut score is criterion-referenced, set by a formal standard-setting study rather than a curve, and you are judged on the total scaled score only: the per-domain percentages on your report are informational, not separate bars. ## The blueprint, and the weights below it Eight domains carry published weights: Applications and Integration 33.1%, Model Selection and Optimization 16.8%, Agents and Workflows 14.7%, Prompt and Context Engineering 11.0%, Tools and MCPs 10.6%, Security and Safety 8.1%, Claude Code 3.1%, and Eval, Testing, and Debugging 2.6%. Multiplied by 53, that is roughly 18, 9, 8, 6, 6, 4, 2 and 1 items — the lesson's arithmetic, not a published count. Applications and Integration is a third of the exam and more than the next two domains combined. Its six sub-objectives — Understanding Requirements, Systems Life Cycle, Claude API Mechanics, Software Engineering Foundations, Claude Application Design and Configuration Management — make requirements gathering and life-cycle placement gradeable content. CCDV-F is the only certification in the family whose guide weights **25 sub-objectives**, and those weights change what a plan can do. Claude Application Design, at 8.6%, outweighs the whole Security and Safety domain. Software Engineering Foundations, at 7.4%, outweighs Tool Implementation at 4.4%. Claude Hooks, at 1.0%, is about half an item. And the two most enjoyable topics, Claude Code and Eval, Testing, and Debugging, are together 5.7% — about three items, and the two worst places to spend a third of your revision. ## What each domain is really asking The lesson reads every domain the way Anthropic's courseware frames it: each topic exists because it prevents a specific production failure. Applications and Integration asks whether you can take a requirement, place the work in the right life-cycle phase and design an application that survives production, down to `stop_reason` branching, error paths, configuration and versioning. Model Selection and Optimization covers tokens, the context window as a fixed budget, sampling and non-determinism, cost, and the difference between choosing a model and enabling a reasoning mode. Agents and Workflows is workflow-versus-agent, loops that terminate, memory across sessions and human-in-the-loop checkpoints where actions are irreversible. Prompt and Context Engineering covers system prompts, XML structure, few-shot examples, output constraints, context management and output parsing. Tools and MCPs is schemas Claude selects correctly, results in the expected form, and MCP servers with the right transport and scope. Security and Safety is prompt injection, jailbreaks, untrusted input, scoped identity, secrets and data boundaries. Claude Code is the explore–plan–code loop, permission modes and durable project context; Eval is defining done, choosing a grading method, and retriable versus terminal errors. ## The question shapes The lesson describes the shapes the official courseware uses: - **The four-option scenario** — for example, a teammate insisting two identical prompts must return identical text, with temperature, sampling and determinism beneath four differently wrong explanations. - **The three-option targeted fix, read off a trace** — an assistant turn issuing `tool_use` id `toolu_01`, a `tool_result` referencing `toolu_02`, and an `invalid_request_error`, with the stem stating that the schema is valid and the description specific. - **Fill in the configuration blank** — a hooks block needing the lifecycle event that runs before a tool call (`PreToolUse`) and a command that blocks by exiting `2`, against distractors that log and exit `0`. - **Match into buckets** — deployment scenarios against transport-and-scope pairs such as `stdio + Local`, `HTTP + Project (.mcp.json)` and `HTTP + User (~/.claude.json)`. There are only three installation scopes, so an "Enterprise" bucket is a distractor. - **Free text with a model-answer reveal** — "the prompt contains one defect; write the corrected system prompt." - **The cumulative multi-layer debug** — an agent with four planted bugs, one each in the schema, streaming, context and memory layers: name each bug and its layer, then correct it. - **Assemble the minimal configuration** — four plausible pieces and the instruction to leave out anything that does not belong. The item is testing subtraction. ## How a developer distractor is built The five general shapes — the absolutist, true but not the question, right action at the wrong layer, the over-engineered one and the answer to a different question — each have a developer form: - **A plausible-but-wrong API shape.** Real fields in a real order that fix a different class of defect than the error names: adding a `required` array to an `input_schema` when the failure is a mismatched `tool_use_id`. Read the error first, classify it — schema validation, message ordering, transport or authentication — and discard every option outside that class. - **An anti-pattern wearing best-practice clothing.** Rotating a key but updating the credentials file, which leaves the secret in the file; concatenating every past session transcript "for memory"; switching to `bypassPermissions` for fewer prompts, which removes the protected-path guard. The tell is a stated benefit of thoroughness or convenience whose cost is a control you have removed. - **Right action, wrong layer.** A repair in the prompt when the defect is in the parser, in the schema when it is in the loop, in the tool when it is in the transport. Name the layer from the evidence before comparing options. - **The over-engineered one.** An agent where one call works, a retrieval index where a cached prefix works, a stronger model where a corrected prompt works. Prefer the simplest option that fully satisfies the requirement. - **True, but not asked.** A correct statement about `stop_reason` or `is_error` in an item about ordering. Re-read the stem's final sentence. The lesson's rule for changing an answer: only when you can name what you missed on the first read — "I missed the word *only*", "I overlooked the constraint" — never because your confidence wobbled. ## Sitting it Pearson VUE, online proctored or at a test centre. Accept the NDA before the exam begins; declining ends the session with no refund. Bring valid, unexpired government photo ID with a name matching your registration exactly. Cancelling within 24 hours forfeits the fee, as does not showing up. Retakes wait 14, then 30, then 90 days, capped at four attempts in a rolling 12 months with the fee payable each time — so sit when ready rather than early. Appeals must be filed within 14 days, and neither the standard-setting outcome nor item content is appealable. The credential lasts 12 months; renewing on time is free and non-proctored on the Partner Academy. ## How to work the course The lesson closes with how to use Alloy: take the diagnostic first, in one sitting (24 questions, about 20 minutes, about three per domain and reported as counts); rate your confidence honestly so Alloy can hand back what you were sure of and got wrong; prove material rather than tick it, since reading a lesson is the weakest evidence and a podcast counts only when you have genuinely listened to part of it; open Recommended next when you do not know what to study; and use labs where a real authored lab exists and scenarios for judgement calls. Twelve domain lessons follow, in a teaching order — fundamentals before API mechanics — with four for Applications and Integration and one or two for each other domain. The exam-strategy lesson is worth a 10–20% score bump: it targets the costliest mistake, getting wrong a question you actually knew. ## Next step Create a free account, take the CCDV-F diagnostic, then open this lesson and its podcast. The second lesson — what a request costs, why it varies and how it reaches Claude — is free too.
Claude Certified Developer – Foundations (CCDV-F) is Anthropic's proctored certification for developers building on the Claude API: 53 questions in 120 minutes, $125 an attempt, and a pass mark of 720 on a 100–1,000 scaled score. Before you spend a week revising, find out where you stand. Alloy's diagnostic is free, needs no card, and takes about 20 minutes. ## What the diagnostic is Twenty-four questions drawn from the same question bank, under the same rules, as everything else in the course. It is not a quiz bolted on the side, so what it reports is where you stand against this exam rather than against a warm-up. The questions are the kind the exam asks: a situation, a constraint and a decision — which fix is targeted, which layer the defect lives in, which configuration fits. ## Why it comes before anything else On CCDV-F the domains are wildly unequal, and a developer's instinct about where the marks are is usually wrong. Applications and Integration is 33.1% of the exam — about 18 of the 53 items — while Claude Code (3.1%) and Eval, Testing, and Debugging (2.6%) together are about three. The exam is scored on the total scaled score only, with no separate bar for any domain, so an hour that lifts your accuracy by ten points in Applications and Integration is worth about 1.8 items, and the same hour in Eval, Testing, and Debugging is worth about 0.1. Knowing which of your weak spots sit in heavy domains is worth a week of studying the wrong thing. The instinct is to revise a little first so the result is not embarrassing. That instinct costs you the week. A diagnostic taken after a warm-up measures the warm-up. ## How it is shaped **Weighted like the exam.** The areas it draws from, and how heavily it draws from each, follow the exam's published weights across its eight domains: Applications and Integration (33.1%), Model Selection and Optimization (16.8%), Agents and Workflows (14.7%), Prompt and Context Engineering (11.0%), Tools and MCPs (10.6%), Security and Safety (8.1%), Claude Code (3.1%) and Eval, Testing, and Debugging (2.6%). **Spread inside each area.** Within a domain it covers different tasks rather than asking the same thing four times, so a weak result is a real signal, not one unlucky question. **Fixed length, one sitting.** The course sets its length and Alloy will not let you shorten it. A diagnostic that quietly got smaller would measure less and still report the same confidence; a partial diagnostic is not a smaller one, it is a worse one. **A confidence rating on every answer.** You cannot submit without saying how sure you are. Alloy watches the gap between how sure you were and how right you turned out to be. Unsure and wrong, you go back and check; certain and wrong, you never look at it again, and it walks into the exam with you. ## What you get back A starting readiness figure and, for every domain, how many questions you saw and how many you got right. Read them on the summary screen while they are in front of you. They are counts, not percentages, deliberately. With eight domains and 24 questions, a domain gets about three. Three questions can only come out four ways, and one lucky guess would move a percentage by a third, so a per-domain percentage would claim a precision three questions cannot give. Anthropic takes the same position on the real exam, which is more than twice as long: its per-domain percentages are informational and never decide a pass. Use the counts to decide what to open first. ## What to do next 1. **Open your weak domains heaviest first** — with one exception. A domain where you are near zero, rather than merely weak, can be worth more than its weight suggests: security items are decidable once you know the failure modes and undecidable when you do not. 2. **Run the confident-and-wrong set.** Alloy can hand back exactly the questions you were sure of and got wrong — the most valuable practice in your preparation, available only if you rated honestly. 3. **Follow Recommended next** when you are unsure what to study. It weighs what you are about to forget, where you are weakest and the heavy material you have not opened, and puts one action in front of you. 4. **Read the error before the options** as you practise. Decide whether a defect is schema validation, message ordering, transport or authentication, and discard every option outside that class. ## Mistakes to avoid - Warming up before the diagnostic. - Rating every answer at the top of the scale — it throws the signal away. - Reading three questions as a percentage. - Spending the first week on Claude Code and evals because they are the most enjoyable topics. - Treating the starting readiness figure as a forecast of your exam score; it is where you begin, and it moves with the work. ## What is free A free account has no card and no trial clock. It includes the full diagnostic on any of Alloy's four Claude certification courses, the first two lessons of every course with their podcasts — on CCDV-F, the exam-strategy lesson and the lesson on what a request costs, why it varies and how it reaches Claude — and a place to store and verify certifications you already hold. Start free, take the diagnostic, then study what it tells you to study.
Claude Certified Developer – Foundations (CCDV-F) is Anthropic's proctored certification for engineers who build, integrate and ship production applications on Claude. It is written for AI and machine-learning engineers, technical leads and senior software engineers — typically one to five years of software engineering and at least six months of hands-on work with Claude or a comparable LLM system. There are no prerequisites; the credential is awarded on exam performance alone. A working developer's instinct is to revise the Claude-specific mechanics: tool calls, streaming, MCP. The published blueprint says most of the marks are somewhere else. ## Where the weight sits The exam has 53 items in 120 minutes, spread across eight weighted domains: | Domain | Weight | Expected items of 53 | |---|---|---| | Applications and Integration | 33.1% | ~18 | | Model Selection and Optimization | 16.8% | ~9 | | Agents and Workflows | 14.7% | ~8 | | Prompt and Context Engineering | 11.0% | ~6 | | Tools and MCPs | 10.6% | ~6 | | Security and Safety | 8.1% | ~4 | | Claude Code | 3.1% | ~2 | | Eval, Testing, and Debugging | 2.6% | ~1 | The guide publishes the weights; the item estimates are each weight multiplied by 53 and rounded, an expectation rather than a published count. **Applications and Integration is a third of the exam on its own** — more than the next two domains combined, and more than the four lightest together. It is also the domain developers most often under-read, because its name sounds like "the API chapter". It is not. It carries six weighted sub-objectives: Understanding Requirements, Systems Life Cycle, Claude API Mechanics, Software Engineering Foundations, Claude Application Design and Configuration Management. Requirements gathering and placing work in the right life-cycle phase are graded here. ## The weights below the domains CCDV-F is the one certification in Anthropic's family whose guide publishes weights for **25 sub-objectives** beneath the eight domains, each with its own share of the whole paper. That lets you rank topics rather than whole domains, and three results are worth carrying: - **Claude Application Design is the heaviest single sub-objective at 8.6%.** On its own it outweighs the entire Security and Safety domain (8.1%), and it is larger than Claude Code and Eval, Testing, and Debugging combined (5.7%). - **Software Engineering Foundations, at 7.4%, is heavier than Tool Implementation (4.4%)**, the largest sub-objective in Tools and MCPs. Ordinary engineering discipline around a Claude application is worth more on this exam than the Claude-specific mechanics most people revise. - **Claude Hooks, at 1.0%, is the smallest sub-objective on the paper** — about half an item. Know what a hook is; do not spend an evening on it. ## What each domain is really asking Anthropic's courseware frames every topic the same way: each one exists because it prevents a specific production failure. Read the domains as "which implementation decision prevents which failure" and the scenario questions stop looking like trivia. - **Applications and Integration (33.1%)** — take a requirement, place the work in the right life-cycle phase, and design a Claude application that survives production: request and response shape, `stop_reason` branching, error paths, configuration and versioning. The courseware makes the versioning point with a deployment that broke when a model alias moved. - **Model Selection and Optimization (16.8%)** — tokens, the context window as a fixed budget, sampling and non-determinism, cost and token management, and the difference between choosing a model and enabling a reasoning mode such as extended thinking. - **Agents and Workflows (14.7%)** — choosing between a workflow and an agent, wiring tools and context into a loop that terminates, managing memory across sessions, and placing human-in-the-loop checkpoints where actions are irreversible. These items frequently reward the smaller architecture. - **Prompt and Context Engineering (11.0%)** — system prompts, XML structure, few-shot examples, output constraints, the context-management moves (compaction, clearing history, subagent handoff) that keep a long session inside budget, and output handling — the parsing side. - **Tools and MCPs (10.6%)** — declaring a schema Claude selects correctly, returning results in the expected form, and building an MCP server with the right transport and configuration scope. - **Security and Safety (8.1%)** — prompt injection from fetched content, jailbreaks, untrusted input, scoped identity, secrets that must not reach a config file, and data boundaries that hold under a compliance review. - **Claude Code (3.1%)** — the explore–plan–code loop, permission modes matched to risk, and durable project context. - **Eval, Testing, and Debugging (2.6%)** — defining "done" before deploying, choosing a grading method, and telling retriable errors from terminal ones. ## What the fundamentals look like in practice The course's first domain lesson — free, with its podcast — is on what a request costs, why it varies and how it reaches Claude. It shows the level of precision the exam expects: - **Tokens are the billing unit and the budget unit.** Thinking tokens are billed as output tokens even when the reasoning is not returned. A token count does not transfer between models: on Claude 4.7 and later, a newer tokenizer produces roughly 30% more tokens for the same text, so a cost model built on an older model is wrong before you change the prompt. - **One request, one budget.** The system prompt, tool definitions, the history your application re-sends on every call and the generated output all share one context window; the API keeps no state between calls. The two overflow failures differ: input that alone exceeds the window returns a `400` before generation, while generation that reaches the ceiling stops with `stop_reason: "model_context_window_exceeded"` — a truncated answer, not an error. - **Sampling makes identical inputs produce different text.** The newest models reject non-default `temperature`, `top_p` and `top_k` with a `400`; where temperature is accepted, `0` makes output more repeatable without making it identical. Tests assert properties — the structure parses, the field is present, the value is in range — never exact prose. - **Thinking, effort and fast mode are per-request settings, not different models.** Effort has five levels with `high` as the default and affects every token, tool calls included; only `max_tokens` is a hard ceiling. Fast mode raises output tokens per second at premium pricing, not time to first token. - **An SDK is a REST client** that adds retries, timeouts, typed errors and a request id. Synchronous, streaming, async and batch answer one question — who is waiting — and Claude streams over server-sent events, never a websocket. ## Where developers go wrong - **Spending revision on the enjoyable topics.** Claude Code and Eval, Testing, and Debugging together are about three items. - **Reading Applications and Integration as "the API chapter"** and skipping requirements, life cycle, engineering foundations and configuration management. - **Picking the option with real API fields that fixes a different class of defect** — a `required` array added to a schema when the error names a mismatched `tool_use_id`. - **Choosing an anti-pattern that sounds disciplined** — rotating a key but leaving it in the credentials file, or concatenating every past transcript "for memory". - **Believing `temperature: 0` makes output deterministic**, or that streaming makes generation faster. - **Treating 720 as a percentage.** It is a scaled score on 100–1,000 and converts to no number of correct items. One exception to ordering study by weight: a domain where you are near zero rather than merely weak. Going from nothing to competent in Security and Safety is a bigger swing than its 8.1% suggests, because security items are decidable once you know the failure modes and undecidable when you do not. ## How the course is laid out against the blueprint Thirteen lessons: an exam-strategy lesson, then twelve domain lessons in a teaching order — fundamentals before API mechanics, mechanics before what is built on them. Applications and Integration gets four lessons (API mechanics; requirements and the systems life cycle; software-engineering foundations; application design and configuration management); Model Selection and Optimization gets two; every other domain gets one. ## Next step Create a free account and take the CCDV-F diagnostic before you study anything: 24 questions, about 20 minutes, weighted like the exam, with each domain reported as questions right out of questions asked. The exam-strategy lesson and the lesson on what a request costs, why it varies and how it reaches Claude are both free, with their podcasts.
Claude Certified Associate – Foundations (CCAO-F) is scored on one total scaled score, and that single fact decides most of the strategy. Passing without burning weekends comes down to five decisions, in the order you meet them: where your hours go, how you practise, how you answer on the day, when you book, and what you do with the result. ## The mechanics every decision rests on - **$99 per attempt, 60 items, 120 minutes.** Two minutes an item. - **A pass is 720 on a 100–1,000 scaled score** — not 72% of questions right, and not convertible to a percentage. - **Total score only.** The per-domain percentages on your report are informational; there is no per-domain minimum. - **Criterion-referenced.** The cut score was set by a formal standard-setting study, not a curve, so nobody else's performance moves your mark. - **Multiple-choice and multiple-response**, and each item states how many options to select. - **Scenario-style.** The questions ask you to apply a skill or make a judgement rather than recall a fact. - **Four attempts at most in any rolling 12 months**, each paid, with waits of 14, 30 and 90 days after successive misses. These are Anthropic's values as published in July 2026; confirm them with Pearson VUE when you register. ## Decision 1: where your hours go Because the exam is not conjunctive, the rational goal is the most items correct in total, which means weighting effort by how many items each domain carries: | Domain | Weight | About how many of 60 items | |---|---|---| | Output Evaluation and Validation | 21% | 13 | | Workflow Integration and Solution Design | 16% | 10 | | Governance, Risk, and Responsible Use | 15% | 9 | | Prompting and Task Execution | 14% | 8 | | Product and Model Selection | 12% | 7 | | Configuration and Knowledge Management | 12% | 7 | | Troubleshooting and Optimization | 10% | 6 | The exact number of items per domain is not published; the right-hand column is each weight applied to 60. An hour that lifts your accuracy by ten points in Output Evaluation and Validation is worth about 1.3 items; the same hour in Troubleshooting and Optimization is worth about 0.6. Both are real, and one is worth twice the other. If two areas are equally weak, open the heavier one first. Output Evaluation and Validation deserves its lead. Three signals agree it is the largest: the published weights, Anthropic's own statement when it opens the topic, and its practice quiz on that topic carrying seven items where every other carries five. Its objectives are the heart of the exam: evaluating accuracy and completeness, spotting hallucinations, inconsistencies and bias, fact-checking, deciding when a human must review, editing for the audience, and choosing the output format. To know where you stand before spending any hours, take a diagnostic first. Alloy's is free: 24 questions, about 20 minutes, weighted like the exam, reporting each domain as questions right out of questions asked. With three or four questions per domain, read those as pointers, not percentages. ## Decision 2: how you practise **Re-decide, don't re-read.** Anthropic's own advice is to find your weakest area, study it against its weight, and work back through its decision frameworks rather than rereading the prose. If you can define a Project but cannot decide whether a given piece of work belongs in one, you are prepared for an exam this is not. **Check your reasoning before your letter.** Anthropic's instruction for its practice questions — compare your reasoning, not just your selection — is a study method. On a judgement exam, a right answer reached for the wrong reason will not survive a rephrased scenario. **Rate your confidence honestly.** Being unsure and wrong is survivable, because you go back and check. Being certain and wrong is what fails people, because you never look again. Alloy asks for a confidence rating on every answer and can hand back exactly the questions you were sure of and got wrong — the highest-value practice set you will have. **Space your review.** Material studied three weeks ago is the most likely to fall over on the day. Flashcards reviewed when they come due, just before you would lose them, keep it for a fraction of the hours re-reading costs; cramming a deck in one sitting throws that away. **Mix, don't block.** A drill that only showed your weakest material would collapse onto the same narrow set. Material you already know, mixed in, is part of the method. **Carry four words into every scenario.** Anthropic's four competencies — Description, Discernment, Diligence and Delegation — recur in every domain. A question about a number that does not add up is a Discernment question, however much prompting appears in the stem. ## Decision 3: how you answer on the day **Read the last sentence of the stem first.** It states how many options to select. Assuming "pick one" on a multiple-response item loses it even when you know the material. **Match the requirement, not the familiar phrase.** Ask what the scenario demands, what constraint governs the decision, and whether the option meets it without adding a different objective. Then test the options against the five shapes wrong answers take: 1. **The absolutist** — "always", "never", "only". Name one counter-example and it is out. 2. **True, but not the question** — accurate and irrelevant. Re-read what was asked. 3. **Right action, wrong layer** — name the layer (prompt, retrieval, model or application) before you read the options. 4. **The over-engineered one** — choose the simplest option that fully meets the requirement. 5. **An answer to a different question** — restate the question in your own words, then match. **Know when a request is not yours.** Work that needs API integration, agent building or tool development belongs with a Claude Developer; enterprise architecture, integration design or governance at scale belongs with a Claude Architect. On this exam, recognising that and handing it on is the right answer. **Change an answer only when you can name what you missed.** What did I believe and why, what exact detail did I miss, does it overturn the choice? If you cannot name the detail, leave it. **Do not lean on option length.** The rule that the longest, most qualified option usually wins is not published and cannot be supported: for CCAO-F, none of Anthropic's 44 practice questions carries a recorded correct answer. **Plan pacing on what is published.** Whether items can be flagged and revisited, whether breaks or scratch paper are allowed, and whether partial credit applies to multiple-response items are not published. If your plan depends on any of them, confirm with Pearson VUE. ## Decision 4: when you book The waits between attempts are not the binding constraint; the cap of four attempts in a rolling 12 months is, and every attempt is paid in full. So register when your self-audit is clean — when you can say yes, in a new scenario, to each of Anthropic's seven one-line capabilities — not when a date feels motivating. In Alloy, the readiness figure is built for this decision: it combines how well you know the material, how honest your confidence is, and how much of the course you have real evidence on, and a practice exam adjusts it in both directions, within bounds, with its weight fading as it ages. Before booking, check the practical terms that end attempts before a question is read: an ID whose name matches your registration exactly, an NDA you accept before starting (declining ends the session with no refund), and cancellation at least 24 hours ahead or the fee is forfeited. ## Decision 5: what you do with the result Your report returns pass or fail, the scaled score and percent-correct by domain. If you pass, put the renewal date in a calendar: renewing within 12 months is free and non-proctored on the Partner Academy, and a lapse means the full exam at the full fee. If you do not pass, the domain breakdown is the study plan for the retake — keep it. Appeals run within 14 days, but the standard-setting outcome and item content are not appealable. ## The strategy mistakes that cost the most - Studying the seven domains equally. - Treating the per-domain percentages as bars to clear. - Preparing a judgement exam by memorising definitions. - Losing known items to the selection count. - Changing answers on a feeling. - Booking early "to see what it is like", against a four-attempt annual cap. ## Next step Take the free CCAO-F diagnostic, then the free exam-strategy lesson and its podcast. The exam-strategy lesson is worth a 10–20% score bump.
The first lesson of Alloy's Claude Certified Associate – Foundations (CCAO-F) course is about the exam itself: what it measures, how it is scored, how its questions are built to make capable people choose wrong, and how to plan your preparation around all three. It is free, with its podcast, and it comes before any domain content because most preparation mistakes on this exam are not knowledge gaps. They are allocation errors that follow from a wrong picture of what is being graded. ## What the lesson covers ### The credential, in published facts | Detail | Published value | |---|---| | Fee | $99 USD per attempt | | Items | 60 | | Time | 120 minutes | | Passing | 720 on a 100–1,000 scale | | Validity | 12 months | | Format | multiple-choice and multiple-response; each item states how many to select | | Prerequisites | none — awarded on exam performance alone | Sixty items in 120 minutes is two minutes an item: generous for a recall exam, moderate for a judgement exam, which this is. Every value is Anthropic's, as published in July 2026; the lesson advises confirming them with Pearson VUE when you register, because where a newer published revision disagrees, the newer revision wins. ### Who it is for, and the boundary it will not cross The published audience is professionals who use Claude as a productivity tool — operations, marketing, product management, education, communications — and it is explicitly not for API developers or agentic-system designers. The lesson treats that boundary as testable content: work needing API integration, agent building or tool development belongs with a Claude Developer; work needing enterprise architecture, integration design or governance at scale belongs with a Claude Architect; and recognising that boundary and escalating across it is itself an Associate-level skill. ### The blueprint Seven domains: Prompting and Task Execution (14%), Output Evaluation and Validation (21%), Product and Model Selection (12%), Workflow Integration and Solution Design (16%), Configuration and Knowledge Management (12%), Governance, Risk, and Responsible Use (15%), and Troubleshooting and Optimization (10%). Output Evaluation and Validation is the largest, and Anthropic says so twice — in the weights, and when it opens the topic by calling it the largest section of the exam, because when you put your name on a deliverable you own every claim in it. At 21% of 60 items it is roughly 13 questions; Troubleshooting and Optimization, at 10%, is roughly 6. ### The scoring rule that should change your study plan Scoring is by the total scaled score only. The domain percentages are informational, not conjunctive, and there is no per-domain minimum. If the exam were conjunctive, the rational plan would be to raise your floor in your weakest domain whatever its size. It is not, so the rational plan is to maximise total expected items correct — to weight effort by how many items a domain carries. An hour that lifts Output Evaluation and Validation by ten points is worth about 1.3 items; the same hour on Troubleshooting and Optimization is worth about 0.6. Two more published facts shape the plan. The 720 cut score is criterion-referenced, set by a formal standard-setting study, so nobody else's performance moves your mark. And your result report returns pass or fail, the scaled score and percent-correct by domain — which, if you do not pass, names where the wait should be spent. ### Anthropic's own preparation advice, taken literally The exam is scenario-style: its 60 questions ask you to apply a skill or make a judgement rather than recall a fact, so memorising definitions is the wrong preparation. It mirrors the same seven subject areas Anthropic teaches, so the highest-leverage move is to find your weakest area and study it against its weight. And you should work back through that area's decision frameworks rather than rereading the prose. Re-reading is the weakest form of study; re-deciding is the strongest. ### The four competencies Description (telling Claude precisely what you want), Discernment (critically evaluating what comes back), Diligence (owning and verifying the output) and Delegation (deciding what is right for Claude, what stays with a person, and what the two do together) recur across every domain. Asking which one a scenario is really about often separates the intended answer from the merely sensible ones. ### A readiness self-audit Anthropic states one capability per domain. The lesson makes them a checklist to mark honestly as *can do under a new scenario*: choose the right entry point, model and features for a task; build structured prompts and adapt them to the task type; validate output and know when human review is mandatory; map a workflow against Delegation criteria and redesign it safely; configure and maintain Projects, instructions and knowledge; apply use-case, data, policy and ethics judgement; diagnose underperformance and optimise workflows. Any line you cannot answer yes to is a domain to open first, ties broken by weight. ## How the questions are built A certification question's wrong answers are written to compete with the right one. You know the topic, you see three options that could work, and you pick the one that answers a nearby question. A distractor earns its plausibility by describing a genuine best practice the scenario does not call for, by solving a neighbouring problem, or by sounding more advanced than the correct option. All three exploit the same reflex: *I recognise this, so it must be right.* Familiarity is not evidence. The counter is requirement matching, in three questions: what does the scenario actually demand, what constraint governs the decision, and does this option satisfy that requirement without smuggling in a different objective? The lesson names five recurring wrong-answer shapes and a counter for each: 1. **The absolutist** — always, never, all, only, every. Real answers are conditional. If you can name one counter-example, the option is out. 2. **True, but not the question** — a correct statement that does not answer what was asked. It feels safe because you can verify it, and verifying it is the trap. Re-read the stem's final sentence. 3. **Right action, wrong layer** — the right remedy in the wrong place. Name the layer before reading the options: the **prompt** (the instruction), **retrieval** (bringing relevant information into view), the **model** (what generates the answer) or the **application** (the surrounding product). 4. **The over-engineered one** — more architecture than the scenario needs. Prefer the simplest option that fully satisfies the stated requirement. 5. **An answer to a different question** — a strong answer to an adjacent question. Restate the question in your own words first, then match. ### When to change an answer Change it when you can name what you missed on the first read — never on a feeling. Doubt on a hard question is normal and is not new information. Run three questions in order: what did I initially believe and on what basis, what exact detail did I fail to notice, and does that detail overturn the choice? If the second has no answer, the third cannot either. ### What Anthropic's practice questions show The lesson counts every question-shaped item in Anthropic's teaching for this exam: 44 in all, 38 with an option list, four options on every one of those 38, and zero with a recorded correct answer. They are practice items, not exam items, but they show how Anthropic builds an Associate-level question: four-option scenario items; classify-and-justify, where the reason field is required; card-into-bucket matching, where "each layer is used at least once" eliminates any assignment that leaves a bucket empty; multi-part items that ask you to recognise a configuration and then defend it; and free-text answers you compare against a model answer. Every quiz carries five items except the one on Output Evaluation and Validation, which carries seven. The most transferable instruction in the set is to compare your reasoning, not just your selection. The lesson is also explicit about what it will not tell you. Because no CCAO-F practice item carries a published key, it does not claim which option of a published item was correct, and it does not teach the popular "longest answer is usually right" rule, which nothing published supports. It lists what Anthropic does not publish at all — whether items can be flagged and revisited, whether the exam is linear or adaptive, the item count per domain, whether breaks or scratch paper are allowed, and whether partial credit or negative marking applies to multiple-response items. ### Sitting it Pearson VUE, online proctored or at a test centre. A valid, unexpired, government-issued photo ID whose name matches your registration exactly. An NDA accepted before the exam begins, where declining ends the session with no refund. Cancel at least 24 hours ahead or forfeit the fee; a no-show forfeits it too. Retakes wait 14, 30 and 90 days after successive misses, with at most four attempts in a rolling 12 months, each paid — which is why you sit when ready rather than early. Appeals run within 14 days, but the standard-setting outcome and item content are not appealable. Renewal within the 12 months is free and non-proctored on the Partner Academy; a lapse means the full exam at full fee. ### The plan it ends on 1. Audit yourself against the seven capabilities. 2. Order what you cannot yet do by published weight. 3. Study by re-deciding, not re-reading. 4. Review reasoning, not letters. 5. Drill reading the last line of each stem before the options until it is automatic. 6. Register only when the audit is clean. ## How to work the course The last part of the lesson is about using Alloy the way it was built: - **Take the diagnostic before anything else**, in one sitting — 24 questions, about 20 minutes, from the same question bank as the rest of the course and weighted like the exam. It reports, for every domain, how many questions you saw and how many you got right: three or four per domain, so counts, not percentages. - **Rate your confidence honestly on every answer.** Alloy watches the gap between how sure you were and how right you were, and can hand back exactly the questions you were confident about and got wrong. - **Do flashcards when they are due**, rating each recall again, hard, good or easy — the rating decides when the card returns, and "again" is the most useful answer. - **Open Recommended next when you do not know what to do.** It gives you one action, chosen against the shape of the exam and the time you actually have. - **Watch the readiness figure, and sit a practice exam when Alloy says to.** Readiness is built from mastery, honest confidence and coverage; a practice exam moves it both ways, within bounds. - **Use labs and scenarios where they appear** — a lab only where a real authored lab covers the concept, scenarios hardest first — and treat the Curriculum as the map everything else is indexed against. ## The mistakes it is written to prevent Studying every domain equally; grinding a small domain because it looks weak; memorising definitions for a judgement exam; losing multiple-response items to an assumed single answer; changing answers on a feeling; reading 720 as a percentage; and booking before the self-audit is clean. The exam-strategy lesson is worth a 10–20% score bump, because it targets the costliest kind of mistake: getting wrong a question you actually knew. ## Next step Create a free account — no card needed — take the CCAO-F diagnostic, then open this lesson and its podcast, "How to Take This Exam". The second lesson, on the five components of a professional prompt and breaking a complex request into ordered steps, is free too.
## What is the Claude Certified Associate – Foundations exam? Claude Certified Associate – Foundations (CCAO-F) is a real, published, proctored Anthropic certification. It is the entry-level credential of Anthropic's four Claude certifications and the only one aimed at operators rather than builders. It opened on 13 July 2026. ## Who is it for? Professionals who use Claude as a productivity tool: operations, marketing, product management, education and communications. Anthropic's guide also names external consultants who support implementation, use-case identification and process redesign. ## Do I need to be an engineer or write code? No. Anthropic states that CCAO-F is explicitly not for API developers or agentic-system designers — that is Architect and Developer scope. You do not need to write code, design an agent or build a tool integration. What it measures is judgement in use. ## Are there any prerequisites? None. The credential is awarded on exam performance alone. ## How much does it cost? $99 USD per attempt. ## How many questions are there, and how long do I get? 60 items in 120 minutes — two minutes per item, which is generous for a recall exam and moderate for a judgement exam, which this is. ## What score do I need to pass? 720 on a scaled score from 100 to 1,000. ## Is 720 the same as getting 72% right? No. It is a scaled score, not a percentage of items answered correctly, and it does not convert to one. ## Do I have to pass each domain separately? No. Scoring is by the total scaled score only. The per-domain percentages on your result report are informational; there is no per-domain minimum to clear. ## What topics does the exam cover? Seven domains, with published weights: - Output Evaluation and Validation — 21% - Workflow Integration and Solution Design — 16% - Governance, Risk, and Responsible Use — 15% - Prompting and Task Execution — 14% - Product and Model Selection — 12% - Configuration and Knowledge Management — 12% - Troubleshooting and Optimization — 10% ## What does each domain actually ask me to do? - **Output Evaluation and Validation:** evaluate outputs for accuracy and completeness; identify hallucinations, inconsistencies and biases; apply fact-checking and validation; decide when human review is required; edit, adapt, refine and compare outputs for their audience; organise information and choose an output format (artifacts, inline, structured data). - **Workflow Integration and Solution Design:** analyse requirements and use cases; use Claude for research, planning and process optimisation; support solution design, development and iteration; integrate Claude into existing workflows; communicate Claude's value and limitations to stakeholders. - **Governance, Risk, and Responsible Use:** identify appropriate and inappropriate use cases; apply data-sensitivity, regulatory and privacy considerations; follow organisational AI policy; understand ethical implications. - **Prompting and Task Execution:** create effective prompts for business and technical tasks; decompose complex requests; iterate prompts; adapt prompting to analysis, research, drafting or brainstorming. - **Product and Model Selection:** select product features (Projects, research mode, chat, artifacts); differentiate Haiku, Sonnet and Opus; align the model with cost, speed and quality; manage context limits and memory — when to restart, summarise or persist. - **Configuration and Knowledge Management:** configure Projects with instructions and knowledge sources; manage uploaded knowledge and connectors such as Google Drive and Gmail; create system-level instructions; maintain and update configurations. - **Troubleshooting and Optimization:** diagnose and resolve underperforming prompts or poor outputs; adjust from feedback; optimise workflows for efficiency. ## Which domain matters most? Output Evaluation and Validation, at 21% — about 13 of the 60 items. Three independent signals agree: the published weights, Anthropic's own statement when it opens that topic that it is the largest section of the exam, and its quiz on that topic, which carries seven items where every other carries five. The reason Anthropic gives is accountability: when you put your name on a deliverable, you own every claim in it. ## How should the weights change how I study? Because the exam is scored on the total only, the rational plan is to maximise total items correct. Ten points of accuracy in Output Evaluation and Validation is worth about 1.3 items; ten points in Troubleshooting and Optimization (10%, about 6 items) is worth about 0.6. When two areas are equally weak, study the heavier one first. ## What kinds of questions are on the exam? Multiple-choice and multiple-response, and each item states how many options to select. The exam is scenario-style: its questions ask you to apply a skill or make a judgement rather than recall a fact, so expect a situation, a constraint and a decision. ## How do I avoid losing multiple-response questions? Read the final sentence of the stem before the options. It carries the selection count. Candidates who assume "pick one" on a multiple-response item lose it even when they know the material. ## How many options does each question have? The exam's own items state what to select, so do not assume. In Anthropic's own practice material at this level — 44 questions — the 38 that carry an option list all offer four options. Those are practice items; nothing states that the real exam reuses their shapes. ## Can I flag questions and come back to them? Is the exam adaptive? Are breaks allowed? Anthropic does not publish whether items can be flagged and revisited, whether the exam is linear or adaptive, the exact number of items per domain, whether breaks or scratch paper are permitted, or whether partial credit or negative marking applies to multiple-response items. Confirm anything your pacing depends on with Pearson VUE when you register. ## Is the exam graded on a curve? No. The 720 cut score is criterion-referenced, set by a formal standard-setting study. Nobody else's performance moves your mark. ## What does my result report tell me? Pass or fail, your scaled score, and your percent-correct by domain. If you do not pass, the domain breakdown is the most useful thing you receive: it is the study plan for a retake. ## How and where do I take it? Through Pearson VUE, online proctored or at a test centre. ## What ID do I need? A valid, unexpired, government-issued photo ID whose name matches your registration exactly. Check the spelling when you register, not on the day. ## What is the NDA? A non-disclosure agreement you accept before the exam begins. Declining it ends the session with no refund. ## Can I cancel or reschedule? Cancel at least 24 hours before your appointment or the fee is forfeited. A no-show forfeits it too. ## What if I fail? How do retakes work? You wait 14 days after a first miss, 30 after a second and 90 after a third, with a maximum of four attempts in any rolling 12 months, each paid at $99. The annual cap, not the waiting ladder, is the reason to sit when you are ready rather than early. ## Can I appeal a question or my score? Appeals must be made within 14 days, but the standard-setting outcome and the content of individual items are explicitly not appealable. Disputing a question is not a route that exists. ## How long does the certification last, and how do I renew it? 12 months. Renewing before it lapses is free and non-proctored, an assessment on the Partner Academy. Letting it lapse means sitting the full exam at the full fee. ## What about accommodations and misconduct rules? Anthropic does not publish the accommodations process or the sanctions for misconduct for this certification. Request accommodations through the Pearson VUE registration flow and confirm the current terms there. ## Is there an official CCAO-F practice exam? There is no official CCAO-F practice exam on Anthropic's academy site, and Anthropic names no scenario bank for this exam (it names one for the Architect Foundations exam only). ## Is the longest answer usually the right one? That rule is not published and the evidence cannot support it. Across Anthropic's three certification question sets, 123 questions, exactly one carries a recorded correct answer — and for CCAO-F it is zero of 44. Stems and options are published; keys are not. Never let option length override a reading of the stem. ## What wrong-answer patterns should I watch for? Five recur: the **absolutist** ("always", "never", "only" — name one counter-example and it is out); **true but not the question** (re-read the stem's final sentence); **right action, wrong layer** (name whether the problem lives in the prompt, retrieval, the model or the application before reading options); **the over-engineered one** (prefer the simplest option that fully meets the requirement); and **an answer to a different question** (restate the question in your own words first). ## Should I change an answer I am unsure of? Only when you can name what you missed on the first read. Ask: what did I believe and why, what exact detail did I miss, and does it overturn the choice? If you cannot answer the second question, leave the answer. ## What are Description, Discernment, Diligence and Delegation? The four competencies Anthropic names across every domain: telling Claude precisely what you want; critically evaluating what comes back; owning and verifying the output; and deciding what is right for Claude, what stays with a person and what the two do together. Asking which one a scenario is about often separates the intended answer from the merely sensible ones. ## What will the exam not ask me? How to build with the API, design agents or develop tools. But it does test whether you recognise such a request and hand it on: work needing API integration, agent building or tool development belongs with a Claude Developer, and work needing enterprise architecture, integration design or governance at scale belongs with a Claude Architect. ## Does the governance domain require me to know specific regulations? No named regulations, retention periods or legal thresholds are part of Anthropic's material for this exam. It teaches which question to ask and who owns the answer. ## How do I know when I am ready? When you can say yes to each of Anthropic's seven one-line capabilities in a new scenario, not when you have read about them: choose the right entry point, model and features for a task; build structured prompts and adapt them to the task type; validate output and know when human review is mandatory; map a workflow against Delegation criteria and redesign it safely; configure and maintain Projects, instructions and knowledge; apply use-case, data, policy and ethics judgement; diagnose underperformance and optimise workflows. ## What is the best way to study? Anthropic's own advice: find your weakest area, study it against the weight it carries, and work back through its decision frameworks rather than rereading the prose. Re-deciding is the strongest form of study; re-reading the weakest. When you review practice, compare your reasoning, not just your selection. ## Are the published details current? They are the values Anthropic published in July 2026. Anthropic itself advises confirming the question count, domain weights and format before relying on them. Where a newer published revision disagrees, the newer one wins. ## What is Alloy's CCAO-F course? A prep course built from the exam's own published objectives, teaching only what a numbered objective in the official exam guide asks for. It has fifteen lessons: an exam-strategy lesson on how the exam works, then fourteen domain lessons in the order of the published blueprint — prompting, output evaluation (three lessons, the most of any domain), product and model selection, workflow integration, configuration, governance and troubleshooting. Each lesson is organised around the decision its domain asks you to make. Alloy builds preparation courses; it is not affiliated with Anthropic, and buying a course is not the exam or the certification. ## Where should I start? With the free diagnostic, before you study anything: 24 questions, about 20 minutes. It draws from the same question bank as the rest of the course, is weighted like the exam, and reports each domain as questions right out of questions asked — a pointer to where to start, not a grade. ## What is free? A free account needs no card and has no trial clock. It includes the full diagnostic, the first two lessons of the course with their podcasts, and a place to store and verify certifications you already hold. The first two lessons are the exam-strategy lesson and the first domain lesson, on the five components of a professional prompt and breaking a complex request into ordered, checkable steps. ## Is the exam-strategy lesson worth doing? Yes — the exam-strategy lesson is worth a 10–20% score bump. It targets the most expensive kind of mistake: getting wrong a question you actually knew. ## Why does Alloy ask how confident I am on every answer? Because being certain and wrong is what fails people. Alloy watches the gap between how sure you were and how right you turned out to be, counts it towards your readiness, and can hand back exactly the questions you were confident about and got wrong. ## How does Alloy decide I am ready? One readiness figure, built from how well you know the material, how honest your confidence is, and how much of the course you have real evidence on. A practice exam moves it in both directions, within bounds, and its weight fades as it ages. The course's own final is locked until your readiness reaches ready. It mirrors the blueprint's proportions, but it is not the CCAO-F exam and its score is not a scaled score. ## Is there a podcast? Yes. Every free lesson has a podcast episode, hosted by Morgan and Casey. "How to Take This Exam" covers the exam-strategy lesson in about 26 minutes; the first domain lesson has its own episode and a question walkthrough. ## Does Alloy cover the other Claude certifications? Yes. Alloy has four courses: Claude Certified Associate — Foundations, Claude Certified Architect — Foundations, Claude Certified Architect — Professional and Claude Certified Developer — Foundations. One Full membership covers all four, and every course that opens while you are a member. Prices are on the pricing page; credits you buy never expire.
"How to Take This Exam" is the free podcast for the first lesson of Alloy's Claude Certified Associate – Foundations (CCAO-F) course, about 26 minutes long. Morgan and Casey start from an uncomfortable claim — that most lost marks on this exam are not knowledge failures but decision failures — and work through everything that follows from it: the wrong-answer shapes, when to change an answer, how the exam is scored and sat, who it is written for, and how to prepare. The last third is a guide to working the course itself. ## The argument: decision failures, not knowledge failures (0:57) You know the topic, you see three options that could work, and you pick the one that answers a nearby question. A distractor — a deliberately plausible wrong answer — wins because it feels reasonable. The short version, from 1:21: expect five recurring wrong-answer shapes and test each against the exact requirement. ## The five wrong-answer shapes (1:41–3:56) - **The absolutist (1:41).** "Always", "never", "all", "only", "every". Real recommendations are conditional; if you can name one counter-example, the option is out. - **True, but not the question (2:00).** An accurate, useful statement that does not answer what was asked. Re-read the stem's final sentence. - **Read that final sentence for a second reason (2:12).** The published format is multiple-choice and multiple-response, and each item states how many options to select. Assume "pick one" on a multiple-response item and you lose it while knowing the material perfectly. - **What is not published (2:37).** Whether you can flag and revisit items, whether delivery is linear or adaptive, how many items each domain gets, whether breaks or scratch paper are allowed, and whether partial credit or negative marking applies to multiple-response items. Confirm any of it with Pearson VUE if your pacing depends on it. - **Right action, wrong layer (3:05).** Name the layer before reading the options: the prompt (the instruction), retrieval (bringing information into view), the model (what generates the answer) or the application (the surrounding product). - **The over-engineered one (3:27).** Choose the simplest option that fully meets the requirement; complexity is not evidence of quality. - **An answer to a different question (3:38).** Restate the question in your own words, then match. At 3:56 Casey sets aside a popular rule on purpose — that the longest, most qualified option is usually right. Across all three Anthropic certification question sets, 123 questions, exactly one carries a recorded correct answer, and for CCAO-F it is zero of 44. Stems and options are published; keys are not. At 4:23 Morgan gives what the practice material does show: 44 questions across Anthropic's teaching, 38 with an option list, every one of those with four options, and every quiz carrying five items except Output Evaluation and Validation's, which carries seven. ## Changing an answer (4:47) Change it only when you can name what you missed on the first read. Doubt on a hard question is normal and is not new information. The review is three questions: what did I initially believe, what exact detail did I fail to notice, and does that detail overturn the choice? ## How Anthropic's practice items are built (5:21) Classify-and-justify, where the reason field is required, so the category alone is not the answer. Card-into-bucket, where every layer must be used at least once — a constraint that eliminates any assignment leaving a bucket empty. Multi-part items that ask you to recognise the right configuration and then defend it. And at 5:58, Anthropic's most transferable instruction: compare your reasoning, not just your selection. ## Scoring and the published shape of the exam (6:19–10:06) A pass is 720 on a scaled score from 100 to 1,000 — not 72% of questions right, and not convertible to a percentage. Sixty items in 120 minutes, $99 an attempt, valid for 12 months: two minutes an item, generous for a recall exam and moderate for a judgement exam, which this is. At 6:58, the caveat: these are the numbers published in July 2026, and where a newer published revision disagrees, the newer one wins. From 7:47, per-domain percentages are informational, not separate bars. At 8:01 Morgan lists the seven weighted domains, with Output Evaluation and Validation largest at 21%. At 8:42 Casey converts that into hours: about 13 questions against about 6 for Troubleshooting at 10%, so an hour on the first is worth roughly twice an hour on the second. At 9:23, the retake ladder — 14, 30 and 90 days, at most four attempts in a rolling 12 months — and why the annual cap, not the ladder, is the reason to sit when ready. At 9:46, what the result report returns (pass or fail, the scaled score, percent-correct by domain) and why it is the study plan for a retake. At 10:06, the cut score is criterion-referenced: nobody else's performance moves your mark. ## Sitting it (10:26–11:35) Pearson VUE, online proctored or at a test centre; government-issued photo ID whose name matches your registration exactly; an NDA accepted before the exam begins, where declining ends the session with no refund; cancellation at least 24 hours ahead or the fee is forfeited. At 11:09: appeals within 14 days, but the standard-setting outcome and item content are not appealable; renewal is free and non-proctored on the Partner Academy if you renew before the credential lapses. ## Who the exam is for, and how to prepare (11:35–15:32) Item construction is meant to make wrong answers compete with the right one (11:35), so the remedy is requirement matching. From 12:32: the audience is professionals using Claude as a productivity tool, with no prerequisites, and explicitly not API developers or agentic-system designers; recognising a request that belongs with a Developer or an Architect, and handing it on, is itself tested. At 13:31: the questions ask you to apply a skill or make a judgement, so memorising definitions is the wrong preparation. At 13:58: Anthropic's four competencies — Description, Discernment, Diligence and Delegation — as a way to see which one a scenario is about. At 14:35: the seven one-line capabilities as a self-audit, ties broken by weight. At 15:15: go back to a weak area's decisions, not its paragraphs. ## Working the course (15:32–26:10) - **The diagnostic first (15:32)** — same question bank and rules as the rest of the course, weighted like the exam, fixed length, one sitting, and a breakdown by area to read while it is in front of you. - **Honest confidence on every answer (17:32)** — the gap between sure and right is what Alloy watches, and it unlocks a practice set of exactly the questions you were confident about and got wrong. - **Flashcards when they are due (18:55)** — rated again, hard, good or easy, which decides when a card returns; "again" is the most useful answer. - **Proof, not ticks (20:02)** — reading a lesson is the weakest evidence, a confident right answer stronger, a scenario or lab stronger still; a lesson is marked complete on purpose, and a podcast counts only when you have really listened to part of it. A concept that needs a refresh has faded with time; one review brings it back. - **Recommended next (21:30)** — one action chosen against the exam's shape and the time you have; choose a practice mode by the question you are asking, and expect the quick drill to mix in material you know. - **One readiness number (23:21)** — built from mastery, honest confidence and coverage; a practice exam moves it both ways, within bounds, and its weight fades with age. - **A curriculum kept current (24:10)** — people watch these exams and pull changes in. - **The rest (24:57)** — labs only where a real authored lab exists, scenarios hardest first, an activity strip that records what you did, and the Curriculum everything is indexed against. Casey closes at 25:59 with the whole method in one line: do the diagnostic, rate honestly, keep the cards due, prove it rather than tick it, follow Recommended next, and come back, because it keeps changing.
The quickest way to find out whether you would pass the Claude Certified Associate – Foundations (CCAO-F) exam is to sit a real diagnostic before you study anything. Alloy's is free, needs no card, and takes about 20 minutes: 24 questions that tell you where you actually stand against this exam rather than where you hoped. ## What the diagnostic is It is a short practice sitting built to the shape of CCAO-F. It is not a quiz bolted on the side: it draws from the same question bank, under the same rules, as everything else in the course, so what it reports is where you stand against this exam rather than against a warm-up. Like the exam, it asks you to apply a skill or make a judgement rather than recall a fact. Expect a short working situation and a decision about what to do — the kind Anthropic's own practice questions use, such as an operations analyst who uploads a new file each week for an inventory reconciliation against a threshold document, and has to choose the configuration that fits. ## Why it comes first The instinct is to revise a little first, so the result does not embarrass you. That instinct costs you a week. A diagnostic taken after a warm-up chapter measures the warm-up; one taken first measures you, and tells you where your study hours are worth the most before you have spent any of them. That matters more on CCAO-F than it might seem, because the seven domains are not equal. Output Evaluation and Validation carries 21% of the exam — about 13 of its 60 questions — while Troubleshooting and Optimization carries 10%, about 6. The exam is scored on the total scaled score only (720 on a 100–1,000 scale), with no separate minimum for any domain, so a weak spot in a heavy domain costs you twice what the same weak spot costs in a light one. The diagnostic shows you which of your weak spots are the expensive ones. ## How it is shaped **Weighted like the exam.** The areas it draws from, and how heavily it draws from each, follow the exam's published weights across its seven domains: Output Evaluation and Validation (21%), Workflow Integration and Solution Design (16%), Governance, Risk, and Responsible Use (15%), Prompting and Task Execution (14%), Product and Model Selection (12%), Configuration and Knowledge Management (12%), and Troubleshooting and Optimization (10%). **Spread inside each area.** Within a domain it deliberately covers different tasks rather than asking the same thing four times, so a weak result in an area is a real signal and not one unlucky question. **Fixed length, one sitting.** Its length is set by the course, and Alloy will not let you shorten it. That is deliberate: a diagnostic that quietly gets smaller measures less and still reports the same confidence. A partial diagnostic is not a smaller diagnostic; it is a worse one. Finish it in one sitting. **A confidence rating on every answer.** Each answer asks how sure you are, and you cannot submit without it. That rating is the one thing you cannot supply later. Alloy watches the gap between how sure you were and how right you turned out to be, because being certain and wrong is what fails people: an answer you were unsure of, you go back and check; an answer you were certain of, you never look at again, and it walks into the exam with you. ## What you get back **A starting readiness figure**, and **for every domain, how many questions you saw and how many you got right.** Read those counts while they are in front of you; the summary screen is the moment they are most useful. They are counts, not scores, on purpose. The exam has seven domains and the diagnostic is 24 questions, so each domain gets three or four. A handful of questions can only come out a handful of ways, and one lucky guess would move a percentage a long way — so a per-domain percentage would look far more precise than anything that handful can tell you. Anthropic takes the same position on the real exam, at more than twice this length: its per-domain percentages are informational and never decide a pass. Use the counts to choose what to open first, not to decide how far along you are. ## What to do with the result 1. **Open the domains the diagnostic found weak, heaviest first.** An hour that lifts your accuracy by ten points in Output Evaluation and Validation is worth about 1.3 items; the same hour in Troubleshooting and Optimization is worth about 0.6. 2. **Run the confident-and-wrong practice set.** Alloy can hand back exactly the questions you were sure of and got wrong. That set is the most valuable pile of questions in your preparation, and it exists only if you rated honestly. 3. **Follow Recommended next when you are unsure what to do.** It weighs revisiting recent material, attacking your weakest area and starting a heavy domain you have been avoiding, against the shape of the exam, and puts one action in front of you sized to the time you have. 4. **Study by re-deciding, not re-reading.** Anthropic's own advice for this exam: find your weakest area, study it against its weight, and work back through its decision frameworks. ## The mistakes people make with a diagnostic - **Warming up first.** It shifts the result towards what you just read and away from what you know. - **Rating everything at the top of the scale "to be safe".** That throws away the signal and buys nothing. - **Reading three or four questions as a percentage.** Two right out of three is a pointer to an area, not a verdict on it. - **Stopping halfway.** An unfinished diagnostic reports on less of the exam and says so less clearly. - **Treating the readiness figure as a prediction of your exam score.** It is where you start, and it moves as you work. ## Who it is for CCAO-F is the one Claude certification written for people who use Claude at work rather than build with it — operations, marketing, product management, education and communications. It has no prerequisites. The exam itself is $99 an attempt, 60 items in 120 minutes, delivered by Pearson VUE. ## What is free The free account needs no card and has no trial clock. It includes the full diagnostic on any of Alloy's four Claude certification courses, the first two lessons of every course with their podcasts — on CCAO-F, the exam-strategy lesson and the first domain lesson, on building a prompt from five components and breaking a complex request into ordered steps — and a place to store and verify certifications you already hold. Start free, take the diagnostic, then study what the result says to study.
Experienced architects often know a lot—and still miss hidden gaps under exam-pressure scenario design. The free diagnostic for the Claude Certified Architect – Professional exam (CCAR-P) is built to surface those blind spots. The diagnostic is 24 questions across the exam's seven domains, about 20 minutes, and each area is reported as questions right out of questions asked. That is three or four questions per domain: enough to show where to look first, not enough to grade a domain on its own. ## What this diagnostic is designed to reveal The diagnostic draws from the exam's seven published domains: - Integration (19%) - Solution Design & Architecture (17%) - Evaluation, Testing & Optimization (16%) - Stakeholder Communication & Lifecycle Management (14%) - Governance, Safety & Risk Management (14%) - Claude Models, Prompting & Context Engineering (13%) - Developer Productivity & Operational Enablement (7%) Every answer also asks how sure you are. Being certain and wrong is what fails people, so the questions you were confident about and missed are the ones to study first. ## Why this matters for experienced architects Senior practitioners usually carry strong intuition from production work. The risk is uneven coverage: strong in one domain, weaker in another that still appears in professional-level architecture scenarios. A structured diagnostic gives you a fast way to identify where to concentrate practice. ## Where the weight sits The weights make the case: Integration is 19% of 63 items — roughly twelve questions — while Developer Productivity is 7%, about four. The gap between the largest and smallest domain is enough to decide a borderline result on its own, so knowing which domains you are weak in matters more than overall familiarity. These are published weights, not a guaranteed count per sitting. ## Start with a focused baseline If your target is Claude architect professional-level difficulty, use this diagnostic as a baseline pass to locate hidden weak points before deeper scenario prep.
You can know the material and still miss the question. In this conversation, Morgan and Casey work through how to sit the Claude Certified Architect – Foundations exam (CCAR-F) without giving marks away to answers that merely sound impressive. They cover four things, in this order: five wrong-answer shapes you can test mechanically; change an answer only when you can name a missed fact or requirement; the score is scaled — the pass mark is 720 on a range from 100 to 1,000, not a percentage; and assume every plausible wrong option was built to tempt you. The question is never “could this work?” but “does this best satisfy this exact requirement?” The full conversation follows.
# Claude Architect Foundations Exam: What to Study First, and How the Exam Takes Marks from People Who Know the Material The Claude Certified Architect – Foundations (CCAR-F) exam gives every question four options and one correct answer, scores you on a scaled total, and weights agentic architecture most heavily. Each of those facts changes how you should prepare and how you should sit it. ## A progression you can actually execute ### 1) Know the five domains, and weight your effort to them The Claude Certified Architect – Foundations exam publishes five weighted domains: - Agentic Architecture & Orchestration (27%) - Claude Code Configuration & Workflows (20%) - Prompt Engineering & Structured Output (20%) - Tool Design & MCP Integration (18%) - Context Management & Reliability (15%) Study agentic architecture first and most; weight the rest to the exam, not to your comfort. ### 2) Know what the score means The pass mark is 720 on a scaled score of 100 to 1,000 — a scaled score, not a percentage, and it does not convert to one. Scoring is on the total only; the per-domain percentages on your result are informational, not separate bars to clear. So do not plan by guessing how many items you can afford to miss. Unanswered questions are scored as incorrect and there is no penalty for guessing, so never leave an item blank. ### 3) Learn the five wrong-answer shapes Most lost items are not knowledge failures. The lesson names five shapes and a counter for each: the absolutist (find one counter-example), true but not the question (re-read the stem's final sentence), right action at the wrong layer (name the layer first), the over-engineered option (choose the simplest sufficient answer), and the answer to a different question (restate the question before matching an option). The stem's final sentence usually says whether it wants the best design, the first action, the main benefit, the most appropriate control, or the explanation for a specific failure. ### 4) Change an answer only for a reason you can name Revise when you can state what you missed on the first read — a specific constraint or detail. Not because a distractor has become psychologically louder. ## Know the scenario draw CCAR-F is scenario-based: questions are drawn only from Anthropic's official scenarios, and each exam form presents four of them. Practise every scenario rather than betting on the draw. ## Where to start Take the free diagnostic before you study anything — 24 questions, about 20 minutes, from the same question bank as everything else — so its per-domain breakdown is where you stand against this exam. Then read the free first lesson, which this page summarises, or listen to its companion episode, How to Take This Exam.
This is the full conversation from 'How to Take This Exam', the 24-minute episode that goes with the free exam-strategy lesson for Claude Certified Developer – Foundations. In this conversation Morgan and Casey take the Claude Certified Developer – Foundations exam (CCDV-F) apart as an assessment: reading questions, spotting distractors, deciding whether to change an answer, and interpreting the score. The short version: learn the five wrong-answer shapes; re-read the question's final sentence; name the layer before judging the options; prefer the simplest answer that fully meets the requirement; and change your choice only when you can name what you missed. The pass mark is 720 on a 100–1,000 scaled score — not 72 percent — and each item states how many options to select, so read its instruction line first. In order: the wrong-answer shapes (from 2:30), changing an answer (3:13), how the exam is scored (3:37), how items are built (5:54), and how to use Alloy day to day (8:27). The full conversation follows.