All 30 task statements · the gate: 85 percent in every domain · ~8 hrs over two weeks · Skip to the mock →
The through line for the whole module: a scaled score of 720 out of 1,000 on a paper weighted 27, 18, 20, 20, 15 across five domains. Every number in this chapter comes back to that one. The pacing is 120 minutes over 60 questions. The gate is 85 percent in each of the five, because the paper is weighted and an average hides the domain that fails you. The drills are in the paper's own style, because two people who scored perfectly on the practice bank tell the same story about the real thing.
Managed settings deny reading .env. A developer allows it in their user settings. Who wins?
Managed, rank one. Deny before allow at every level. Hold the shape of that answer: a rank order that does not care about averages or recency is also how the exam is scored, by domain against a standard.
A nine line subagent runs nightly and posts to a client's tracker. Configuration or system?
A system. The four questions decide by what it can do, and this one runs unattended and posts outward. That module's coach question shape (a situation, then a judgment) is the exam's shape too.
▶ Watch: sixty questions, two hours · 3 min
Your practice scores average 86 percent. Domain 1 is at 78, the other four are above 88. A colleague says "you're over 85, book it." Are you ready?
No. Domain 1 is 27 percent of the paper, and the exam is scored against a standard, not an average. A strong average with a weak domain is the shape of a fail. The gate is 85 in every domain, and Domain 1 is seven points short of it.
First, the facts, and every one of them is from the Exam Guide v0.2 and nowhere else:
| Item | Value |
|---|---|
| Questions | 60, multiple choice, one correct answer and three incorrect options |
| Time | 120 minutes |
| Structure | 4 scenarios, drawn at random from a published bank of 6 |
| Scoring | Scaled score of 100 to 1,000; minimum passing score 720 |
| Result | Pass or fail |
| Delivery | Online proctored or at a test center |
| Fee | $125 USD |
| Validity | 12 months from the date the credential is awarded |
| Unanswered questions | None possible: the platform requires an answer before you can advance |
(Exam Guide v0.2, "Exam Details at a Glance" and "Response Types.")
Two of those rows change how you sit the paper. The scaled score is set "against a minimum standard established by subject matter experts," and "scaled scoring models help equate scores across multiple exam forms that might have slightly different difficulty levels." So 720 is a standard, and it converts to no particular number of questions. A practitioner's video rounds it to "about 75 percent." (Flagged as field experience, and the guide wins: it is a scaled score.) Set your own gate in percent on your own drills, and do not try to convert 720 into a number of questions.
The second row: you cannot leave a question blank. That turns the flag habit from a preference into a procedure, below.
The weights are published, and the question counts follow from them:
| Domain | Weight | Of 60 questions |
|---|---|---|
| 1. Agentic Architecture and Orchestration | 27% | about 16 |
| 2. Tool Design and MCP Integration | 18% | about 11 |
| 3. Claude Code Configuration and Workflows | 20% | 12 |
| 4. Prompt Engineering and Structured Output | 20% | 12 |
| 5. Context Management and Reliability | 15% | 9 |
(Exam Guide v0.2, "Content Outline"; the counts are the weights applied to 60 and rounded, and the guide publishes the weights only.)
Domain 1 is the paper. Sixteen questions on agentic loops, coordinators and subagents, context passing, enforcement, hooks, decomposition, and sessions. An hour of drilling there buys more expected score than an hour anywhere else, and the weak-spot sweep in the next section weights its time the same way.
Four of the six published scenarios appear, each as one long stem with several questions under it: a customer support agent with four named tools and an 80 percent resolution target; a team using Claude Code for code generation; a multi-agent research system; a developer productivity agent; Claude Code in a CI pipeline; a structured extraction system. (Exam Guide v0.2, "Exam Scenarios.") Read the stem once, properly. Every question beneath it reuses the same tools, the same target, the same constraint. Thirty seconds saved by skimming the stem is thirty seconds lost three more times, and a detail missed in the stem is missed in every question that hangs off it.
The arithmetic is the exam's own: 120 minutes over 60 questions is two minutes each. Checkpoints fall out of it: question 15 by minute 30, question 30 by minute 60, question 45 by minute 90, and the last half hour for the flag pile. Ahead of the line, relax and read stems well. Behind it, speed up on the short questions and never on a stem.
The flag habit. A question that has resisted for roughly ninety seconds gets a best guess committed (the platform requires one), a flag, and your departure without guilt. Momentum is worth more than any single question, and the question will still be there at minute 95 with a brain that has now seen the whole paper. Questions answer each other: a stem at question 41 will describe, in passing, the exact setup question 7 asked about. (Flagged as field experience: this is standard pacing practice across scenario-heavy certification exams and matches the guide's arithmetic; no CCAR-F-specific study of it exists.)
Changing answers. On the return pass, change an answer when you can name the specific thing you missed: a constraint in the stem, a word in an option. Do not hold a first pick because it was first. The belief that first instincts are best has a research literature against it. Across four studies, test takers predicted that changing an answer would hurt them more often than help; the recorded changes ran the other way, with more than half going from wrong to right. A 2021 study of 157 real multiple-choice exams found the same direction. The myth persists because a right-to-wrong change produces a sharper regret than a wrong-to-right change produces relief. (Flagged as field experience, measured: Kruger, Wirtz and Miller, 2005; Merry, Elenchin and Surma, 2021.)
The guide's own sample question shows the exam's favorite shape. Two tools have minimal descriptions and the agent picks the wrong one a fifth of the time. Few-shot routing examples would help at the cost of tokens and leave the cause in place. A keyword router would work and is, in the guide's words, over-engineered. Merging the tools is a valid design choice and more than a first step. The answer is rewriting the descriptions, because "tool descriptions are the primary mechanism LLMs use for tool selection," and the guide calls the rewrite the low-effort fix with the biggest effect. (Exam Guide v0.2, sample question 2.) When two options are defensible, pick the one the documentation recommends over the clever one. This exam rewards orthodoxy, and the orthodoxy is written down in the task statement bullets.
What this changes from your chair: the week before the exam, you are drilling the bullets and the shape of the questions, and the opening walkthrough linked at the top of this section is the plan for the two hours themselves.
Question 7 has resisted for ninety seconds. Two options look right. What do you do?
Guess, flag, go. The platform will not let you leave it blank, a third reading rarely yields, and the rest of the paper often does: a later stem will describe the setup this question was about. Change it on the return pass only for a reason you can name.
You have a week. Do you drill your weakest domain to the exclusion of the others, or mix questions from all five in every sitting?
Mix them, with the weak domain getting the most questions. Interleaved practice scored 77 percent on a next-day test against 38 for blocked practice in a controlled study, because mixing forces you to identify which rule applies before applying it, which is exactly what a scenario question tests.
The sweep has three inputs: your per-domain scores from the study app (152 questions, scored by domain on its dashboard), your score by domain on this module's mock, and the mistakes log the closing demo builds. The output is a list of task statements to drill, in order, and a verdict per domain against 85 percent.
The site version of this section reads your study app scores and shows the gate live. The rule it applies: every domain at 85 percent or better, across at least fifteen answered questions in that domain, before you book. The reason is in the through line. The exam is weighted, and it is scored against a standard. A domain you are weak in costs you its share of the paper whatever the other four do. Five scores of 78, 91, 88, 86, and 90 average 86.6 and describe a candidate who is about to lose four or five of Domain 1's sixteen questions.
The 85 is this course's number, set above the passing standard on purpose, because the practice bank is easier than the paper. Two independent accounts say so. One candidate scored perfectly on the official practice exam three times running and then scored 590 on the real one, below the 720 line, because roughly four fifths of the real questions required applying a concept to a broken system rather than recalling a definition. A second candidate, on video, warns that the practice questions are "probably a whole third easier than the actual exam." (Flagged as field experience: two independent accounts, one via a study site citing an anonymous Reddit post, one a YouTube walkthrough; no measured comparison exists.) A clean practice score tells you the facts are in. The 85, on drills written in the paper's style, tells you the repairs are too.
Reads your study app scores from this browser (the app saves a per-domain tally when you answer). Type or correct any number, then judge: is every domain at 85 with at least fifteen answered? If you have not answered fifteen questions in a domain in this browser yet, treat that row as not yet gated rather than as a pass.
| Domain | Weight | Answered | Score | Gate |
|---|---|---|---|---|
| 1 · Agentic Architecture | 27% | · | · | |
| 2 · Tool Design and MCP | 18% | · | · | |
| 3 · Claude Code Configuration | 20% | · | · | |
| 4 · Prompt Engineering | 20% | · | · | |
| 5 · Context and Reliability | 15% | · | · |
Enter five scores, or answer questions in the study app, to get a verdict.
The verdict is GO only when every row is GO. The average is never shown, on purpose.
Spend the hours where the questions are. A practical split for a final week, from one detailed study plan and consistent with the guide's own weights: the most time on Domain 1, then Domains 3 and 4 together, then Domain 2, then Domain 5. (Flagged as field experience: a single practitioner's plan; the weights it follows are official.) Within a domain, the task statements you have missed get the first hour, and the closing demo's weak-spots skill does the ranking for you from the log.
Two measured findings shape the sitting itself.
Interleave. In a controlled study, students who practiced four kinds of problems in mixed order scored 77 percent on a test the next day; students who practiced the same problems blocked by type scored 38, even though the blocked group did better during the practice itself. The effect size was large (d = 1.21). (Flagged as field experience, measured: Taylor and Rohrer, 2010.) A scenario question never tells you which task statement it tests. Mixed practice trains the identification step; blocked practice skips it.
Space. A meta-analysis of 839 measurements across 317 experiments found the best gap between study sessions is roughly 10 to 20 percent of how long you need to remember the material. For an exam two weeks out, that is short sessions every day or two, and never one long session the night before. (Flagged as field experience, measured: Cepeda, Pashler, Vul, Wixted and Rohrer, 2006.)
Every task statement, the module that teaches it, and where its drills sit. Work down the column for any domain under the gate:
| TS | Task statement | Chapter | Drill |
|---|---|---|---|
| 1.1 | Agentic loops for autonomous task execution | 04 | Study app; mock S1 |
| 1.2 | Coordinator and subagent orchestration | 04 | Study app; mock S3 |
| 1.3 | Subagent invocation, context passing, spawning | 04 | Study app; mock S3 |
| 1.4 | Multi-step workflows, enforcement, handoff | 04 | Study app; mock S1 |
| 1.5 | Agent SDK hooks for interception and normalization | 03 | Study app; mock S1 |
| 1.6 | Task decomposition strategies | 04 | Study app; mock S3 |
| 1.7 | Session state, resumption, forking | 05 | Study app; mock S2 |
| 2.1 | Tool interfaces with clear descriptions and boundaries | 06 | Study app; mock S1 |
| 2.2 | Structured error responses for MCP tools | 06 | Study app; mock S1 |
| 2.3 | Tool distribution across agents, tool_choice | 06 | Study app; mock S3 |
| 2.4 | MCP servers in Claude Code and agent workflows | 06 | Study app |
| 2.5 | Built-in tools: Read, Write, Edit, Bash, Grep, Glob | 06 | Study app |
| 3.1 | CLAUDE.md hierarchy, scoping, modular organization | 01 | Study app; mock S2 |
| 3.2 | Custom slash commands and skills | 02 | Study app; mock S2 |
| 3.3 | Path-specific rules for conditional loading | 01 | Study app; mock S2 |
| 3.4 | Plan mode versus direct execution | 05 | Study app; mock S2 |
| 3.5 | Iterative refinement | 05 | Study app |
| 3.6 | Claude Code in CI/CD pipelines | 05 | Study app |
| 4.1 | Explicit criteria for precision | 07 | Study app; mock S6 |
| 4.2 | Few-shot prompting for consistency | 07 | Study app; mock S6 |
| 4.3 | Structured output with tool use and JSON schemas | 07 | Study app; mock S6 |
| 4.4 | Validation, retry, and feedback loops | 07 | Study app; mock S6 |
| 4.5 | Batch processing strategies | 07 | Study app; mock S6 |
| 4.6 | Multi-instance and multi-pass review | 07 | Study app; mock S6 |
| 5.1 | Conversation context across long interactions | 08 | Study app |
| 5.2 | Escalation and ambiguity resolution | 08 | Study app; mock S1 |
| 5.3 | Error propagation across multi-agent systems | 08 | Study app; mock S3 |
| 5.4 | Context in large codebase exploration | 08 | Study app; mock S2 |
| 5.5 | Human review workflows and confidence calibration | 08 | Study app |
| 5.6 | Provenance and uncertainty in synthesis | 08 | Study app |
(Task statements from the Exam Guide v0.2, shortened; the full text and the knowledge and skill bullets are in COVERAGE.md and in each chapter's exam mapping note.)
The order of a sweep, in one sentence: read a chapter's wrap-up list cold and say each item back, drill that domain in the study app with the mock's scenario blocks mixed in, log every miss with its task statement, and rerun only the misses the next day.
Two candidates have a week. One drills Domain 1 only until it is green, then Domain 2, and so on. The other mixes all five in every sitting with extra Domain 1 questions. Who is better prepared for a scenario question?
The second. Interleaved practice scored 77 percent against 38 on a next-day test in a controlled study, even though the blocked group looked better during practice. A scenario question never names its task statement; mixed practice trains you to name it.
A practice question asks "what does stop_reason 'tool_use' mean?" An exam question describes a loop that stops when the model says "I have resolved the issue" and asks what to fix. Same fact. Why is the second one harder?
Because the fact is hidden inside a symptom. The exam gives you a broken system and four plausible repairs, and you have to recognize which task statement bullet the symptom is testing before you can apply it. Recall is the first step; recognition under noise is the skill.
The guide describes the format: "Questions on this exam are grounded in realistic scenarios drawn from actual customer use cases," and "the incorrect options are designed to be plausible to a candidate with incomplete knowledge or experience." (Exam Guide v0.2, "Introduction" and "Response Types.") The shape of a question, then, is a production symptom, a target or constraint from the stem, and four repairs of which three would work somewhere and one is what the documentation recommends here.
This module's mock (site/modules/module-10-quiz.html) is 24 questions in four scenario blocks, built on the guide's own stems for the support agent, the research system, the Claude Code team, and the extraction pipeline, with a 48 minute clock at the exam's pace. The questions are weighted toward the task statements the study app covers most thinly (1.1, 1.5, 1.6, 1.7, 3.3, 4.1, 4.2, 4.4, each with three or four bank questions against the median six), and every explanation names the bullet it tests and the anti-pattern the guide attaches to it. Score it by domain. Anything under 85 goes back to the sweep.
Four moves, in order, and the closing demo's coach is built to make you practice them:
Flagged as field experience, one practitioner's read. One study guide names five wrong-answer shapes it says recur across the question pool:
~/.claude/CLAUDE.md that never reaches a teammateEach maps to a documented rule in this course. The "five traps" framing itself has one source.
"Retry the extraction with a clearer prompt" is offered as a fix when the invoice has no purchase order number. Right or wrong, and why?
Wrong. Retries fix format and structural errors. They cannot invent information the source never contained. The fix is a schema that lets the field be null and a prompt that says absence is an acceptable answer.
The guide attaches anti-patterns to most task statements, and the wrong options on the paper are those anti-patterns dressed as repairs. The study app's lessons collect them, one list per statement; here they are as a round to run cold, covering the list and saying each fix before you read it. On the site, every row is a judge-then-flip card. The pattern is the wrong move; the fix is the documented one.
(Anti-patterns as collected in the course's study app from the Exam Guide v0.2 task statement bullets; 40 rows across 30 statements.)
The round takes eight minutes read cold, and it is the highest-yield eight minutes in the module: every row is a wrong option that will appear on the paper, phrased so that it sounds like a repair.
Which of these is evidence you are ready: three perfect runs on the practice bank, or 85 percent in every domain on drills written in the paper's style, with your last week's misses recovered?
The second. Perfect practice scores are a floor; one documented candidate went from three perfect runs to a 590. The paper asks you to repair broken systems, and readiness is measured on questions shaped like that.
The checklist, in the order the demo's readiness skill writes it:
| Check | Standard |
|---|---|
| Every domain at 85 percent or better | Study app dashboard and the mock, both by domain, at least fifteen answered per domain |
| No open task statement | Nothing missed twice in the log without a recovery (two correct in a row across sessions) |
| The anti-pattern round, cold | Every fix said before it is read |
| The two videos, once more | The mechanics walkthrough the day before; the coach demo whenever the log stalls |
| Booked | Through the Claude Partner Network's registration page; the guide names online proctoring or a test center |
| Exam day | Identification ready, the room and connection tested if online, a night's sleep, two minutes a question, flags without guilt |
Two more facts a candidate needs, one official and one flagged. The certification program now lists four proctored exams, and registration runs through an Anthropic-run partner network page rather than a public sign-up:
| Exam | Fee |
|---|---|
| Claude Certified Associate, Foundations | On its own registration page |
| Claude Certified Developer, Foundations | On its own registration page |
| Claude Certified Architect, Foundations (this course) | $125 |
| Claude Certified Architect, Professional | On its own registration page |
(Anthropic partner network certification page for the Architect Foundations exam, read 2026-08-30; it lists all four exams and prices only its own.) And one practitioner who sat the exam reports that four free Claude Academy courses gate registration (Claude Code in Action, Introduction to Model Context Protocol, Introduction to Agent Skills, Building with the Claude API), with the MCP course's lectures duplicated inside the API course. (Flagged as field experience: one account; check the registration page for the current prerequisites when you book.) Two things the sweep found and could not confirm: the proctoring vendor, and a retake waiting period. Read both from the registration page on the day, and trust nothing older.
One field data point on time, for calibration and nothing more: a candidate who passed with a 743 reports roughly 18 hours of preparation over two days, eight of them in the required courses and ten in drills and practice exams. (Flagged as field experience: one account, one score.) Nine modules of this course is a different starting point; the number says what the last two days can look like.
What the retrieval numbers say about the last week, since the coach in the closing demo is built on them. Students who read a passage once and were tested on it three times recalled 61 percent a week later; students who reread it four times with no testing recalled 40. (Flagged as field experience, measured: Roediger and Karpicke, 2006.) In a 2025 study across two university courses, a week with retrieval-practice questions generated by a language model from the course's own material produced 89 percent accuracy on a later check against 73 for a week without. (Flagged as field experience, measured: arXiv 2507.05629, about 60 students, within-subject design.) The mechanism is the effort of recall, and it works hardest on the items you got wrong. So the coach logs misses and drills them rather than rereading anything.
A teammate says: "I've had three perfect runs on the practice app. I'm booking for Monday." Answer in two or three sentences, out loud or in the box, then compare.
Something like: "The bank asks for facts and the paper asks what to fix; one documented candidate went from three perfect practice runs to a 590. Sit the mock first and score it by domain, and book when every domain is at 85 on scenario-style questions with your last week's misses recovered." The idea to keep: a practice score is a floor.
The credential lasts twelve months. What from these ten modules is still worth something in month thirteen?
The repository. A second brain with a CLAUDE.md, skills, hooks, agents, a governance model, and a coach that drills from your own notes outlasts the twelve month credential. The certificate proves you passed once; the repository keeps working after.
The certificate lasts twelve months. Three things last longer.
The second brain. A learner who ran every module's prompt pack finishes with a repository that holds the course.
The governance playbook. The model written in the enterprise chapter's closing demo.
The coach. Three skills and a mistakes file that drill anything with a syllabus.
One naming note for anything you write for a team: Anthropic's free learning hub is branded Claude Academy at academy.claude.com, and it is a separate track from the paid, proctored certification. (Read 2026-08-30.)
A client asks for "the Claude certification course." Which name goes in the proposal?
Two tracks. The free learning hub is Claude Academy; the paid, proctored exams (Associate, Developer, Architect Foundations, Architect Professional) are a separate program with registration through the Claude Partner Network. A proposal that merges them promises the wrong thing.
The five consultant team at the regional health plan booked the same exam window. Two weeks out, their study app dashboards told two different stories.
One consultant had three perfect runs on the practice bank. All 152 questions answered, every domain green. The plan was to reread the handbook chapters over the weekend and sit the paper on Monday.
Another had a 78 in Domain 1 and a dashboard average above 85. The plan was the same: the average said ready.
The team lead changed three things that Wednesday, and nobody touched the study app. The rule for readiness, the shape of the drills, and where the misses went.
The rule.
The drills.
The misses.
Replay one question through both worlds.
| "The loop stops when the model says it is done. Sometimes it says so and then asks for a tool. Fix?" | |
|---|---|
| Before (bank recall) | "stop_reason tool_use means continue." Correct fact, chosen option: "add an instruction not to say done until it is." Wrong. |
| After (four moves) | Constraint: the loop must run every requested tool. Statement: 1.1. Documented repair: drive the loop from stop_reason. Anti-pattern check: parsing prose for completion is the first row of the round. Correct. |
Sunday night, exam window opens Thursday. A readiness run shows Domain 1 at 84, every other domain above 88, and two statements (1.5 and 1.7) still open in the log. The average is 88. A teammate says: "Close enough. Book Thursday." Pick your move, then read what follows from it. Try all three.
What the working practice looks like now. Every domain is a separate gate. Every drill is a scenario. Every miss is a line with a task statement on it. Every recovery is two correct in a row across sessions, dated. The team's five readiness files are in the repository, next to the governance model, and the next cohort will read them before the handbook.
▶ Watch the demo: the exam coach · 5 min
The prompt pack: every demo prompt, cleaned and explained
The closing demo builds the exam coach on the client-project repo, from the user's chair, in three parts.
Then run the pack in your own repo. The prompt pack linked above holds every prompt from the demo, cleaned up and explained. Copied as is or rephrased in your own words, check what the demo checked as you go:
study/task-statements.md has thirty sections in the guide's own words.study/mistakes.md.Sit the mock exam → then run the anti-pattern round once more, cold.