Claude Certified Architect – Professional

CCAR-P Study Lab

Everything in the Master Concept Map and the 2-Week Training Plan, organized by week with visuals, in one browser tab. Read it, check off each session, then drill the named traps in the quiz.

The whole exam in one sentence: “Fix the cause, not the symptom; least-privilege everything; prefer structural optimization to blunt instruments; pick the simplest pattern that satisfies the constraints; put must-hold rules in code, not prompts; measure with version-pinned evals; and never remove human judgment from irreversible decisions.”

63

items / exam

120 min

~1.9 min per item

720

of 1000 to pass

12 mo

cert valid

Exam blueprint — where the weight lives

Three domains = 52% of the exam. Governance + Stakeholder = another 28% of non-engineering judgment.

The meta-rule (memorize it) The exam rewards a way of thinking, not memory. Every question presents 4 answers that all sound responsible; exactly one addresses the root cause.

The 6 Master Principles (P1–P6)

Every correct answer satisfies one of these. Every distractor violates one.

The 8 Distractor Classes

Learn to name every wrong option — then reject it on sight. Several options are technically valid; the exam wants the best, not the first-valid.

The 996-scorer’s 4 recurring moves

Internalize these as your filter on every question.

The Named Traps & Answer Doctrines

The condensed cheat sheet — click each trap to reveal the doctrine. These are the same scenarios the Drills quiz tests.

Test-taking strategy

Per-item routine

Read the full scenario before glancing at answers (~30–45s).

Identify the dominant architectural problem — determinism, data freshness, autonomy, SLA, security, cost. Not “which tech” but “what’s really wrong?”

Map the symptom to the component that changed (RAG wrong after a doc refresh → retrieval, never the model).

Evaluate every option against the complete constraint set — fewest unacceptable trade-offs.

The “most Claude-native” tie-breaker only after constraint-checking. Some questions test when not to use Claude.

Time & pacing

Budget your brain, not just your time. Stamina is the real constraint.
Flag-and-return: flag hard ones early, finish the section, come back and change.
Eliminate the obviously wrong first — the highest-value pacing skill.
Multiple-response: treat each option as a binary judgment call. The stated count is a hard constraint.
No penalty for wrong answers — answer everything, never leave a blank.

Readiness benchmarks

Target 82%+ on a full timed 120-min mock with no weak domain.
Practice mocks run easier One candidate scored 1000/1000 on the official practice exam three times → 590/1000 on the real thing. Rising practice scores can be “memorization wearing the costume of mastery.” The real exam shares no questions.
Use the per-domain score report to patch your 2–3 weakest domains (typical senior-architect weak spots: Evaluation, Governance/Compliance, Stakeholder Communication).

Reference resources

Official (verified)

CCAR-P Exam Guide v1.0 PDF — the blueprint. Read it fully; it IS the syllabus.
Official prep videos (5 free lessons, ~12.2 hrs) on the Partner Academy. Lesson 1→Domains 1+2, 2→3+4, 3→5, 4→6, 5→7.
Official docs: docs.claude.com, code.claude.com/docs, MCP spec, “Building Effective Agents,” “The Architect’s Playbook,” github.com/anthropics/courses.

Community / study aids

sarveshtalele/claude-architect-exam-guide (GitHub) — official-guide mirror + CCAR-P prompt packs.
ravikirans.com/claude-architect-professional-study-guide/ — objectives → Anthropic docs.
findskill.ai/degrees/...ccar-p-prep/ — 39 lessons, 125 scenario questions.
leanpub.com/claude-certified-architect-professional-ccar-p — distractor-family failure cases.

Validate any third-party mock against the official weights (17/13/19/16/14/14/7) and 63-item / 120-min format before trusting it.

Verified facts worth repeating

No official full-length practice exam exists — only 3 sample questions (least-privilege removal; prompt caching; RAG retrieval-failure diagnosis).
Proctored via Pearson VUE — 63 items / 120 min / 720 of 1000 to pass / $175 / valid 12 months.
~40% of CCAR-P is absent from CCA-F: RAG, GDPR/HIPAA/FedRAMP, and the entire Stakeholder/Lifecycle domain.
Retake ladder: 14 / 30 / 90 days; max 4 attempts per rolling 12 months; $175 each.
Renewal: on-time = free non-proctored assessment; lapsed = full retake.

About this app Built from cca-p-master-concept-map.md + cca-p-training-plan.md. Open Week 1 for sessions S1–S3, Week 2 for S4–S6, and Drills for exam-format practice. Progress is saved locally in your browser.

Sessions S1 – S3

Week 1 — Concepts + Hands-On

3–6 hrs. The three heaviest domains live here: Integration (19%), Solution Design (17%), Evaluation + Models (29% combined) = the core of the exam.

S1

Integration

Domain 3 · RAG, protocols, auth, observability

19% · largest domain Priority ★★★ done

Focus: RAG pipeline design · MCP vs API/CLI vs agent-to-agent · least-privilege auth · observability at scale · progressive discovery vs monolithic context.

The through-lineTrust boundaries: treat retrieved content as untrusted. This is where the hardest reasoning lives — and where production experience shows.

In-context vs RAG — the decision tree (most-tested concept in Integration)

When it wins	In-context + caching	RAG
Corpus size	Fits in context (< ~150K tokens)	Exceeds ~150K tokens
Sharing	Same doc reused within a session	Thousands of users, different docs
Cross-doc reasoning	Needed (chunked retrieval loses it)	Not the pattern
Latency	Critical (RAG adds round-trips)	Tolerable
Precision	Exact quotes needed	Semantic search over massive corpus
Doc churn	Static docs	Frequently changing

⚠ The #1 trapDefaulting to RAG when the document fits in context. RAG adds latency, retrieval failures, chunking artifacts, and complexity. The exam tests the decision tree, not reflex.

Chunking is a structure decision, not a mechanical step

Chunk size trades retrieval precision against lost cross-chunk context. Match chunking to document structure (don’t split a benefits table), query type, source quality, data freshness, and whether queries need exact identifiers vs semantic similarity.

Embeddings (semantic)Keyword / BM25 (exact facts, legal, numbers)Filtered (metadata)Hybrid + rerankingContextual RetrievalCitations / source attributionFreshness controls

Protocol selection — “three ways in”

MCP breadth + discovery

Heterogeneous, discoverable tools/data across many systems; standard contracts (tools/resources/prompts); progressive discovery. Don’t bolt MCP onto a single internal API call.

Direct API / SDK simplest

One stable integration you control. The simplest path when you own both ends.

CLI / subprocess low ceremony

You already have CLI tools. Cheap, but fragile at scale.

Agent-to-agent autonomous

Two autonomous systems delegating (multi-agent). Needs governance + escalation.

Progressive discovery vs monolithic context

Reveal tools/info as needed vs load everything upfront. But “when monolithic is actually fine” is also tested — don’t default to progressive discovery when a small static toolset is simpler.

Capability bloat

Too many/overlapping tools degrades reasoning and causes misrouting. Keep ~4–5 tools per agent; beyond that use a hub-and-spoke coordinator dispatching to specialized subagents.
Tool descriptions are part of the prompt — describe the user-facing task, not the mechanism (“uses Postgres backend” causes misrouting).

Least privilege & security gaps

Authentication ≠ authorization. Analyze each touchpoint for gaps.
The service-account trap: identity propagation — don’t collapse every caller into one broad credential.
Prompt injection is privilege escalation: a tool’s inputs are untrusted; an attacker-controlled doc can steer the model into calling another tool. Enforce access control at the point of retrieval, not at rendering. Output validation + tool authorization = defense-in-depth that XML-tagging alone can’t enforce.

Accuracy–latency trade-offs & the Batch trap

Justify against the SLA, not taste. Levers: streaming, model choice, prompt caching, batch processing, parallel tool calls.

Message Batches API~50% cost savings / 24-hour window — but only for latency-tolerant jobs. A blocking pre-merge CI check makes batch wrong even though it’s cheaper.

Observability at scale

Request tracing, correlation IDs, prompt/model versioning, tool latency, retry/error rates, quality drift, dashboards. APIs: Usage & Cost, Analytics, Compliance. “Monitoring strategy follows volume.”

Constraint-finding — name the binding constraint before you chooseIs the driver corpus size, latency, precision, doc churn, or security? The answer decides in-context-vs-RAG and which protocol to reach for.

Checkpoint — quick verify (click to reveal)

Q1: A 40K-token doc is reused across a session. RAG or in-context?

A: In-context + prompt caching. RAG would add latency and retrieval failure with zero benefit (Trap 4).

Q2: Your tool description reads “uses a Postgres backend.” What’s wrong and what’s the fix?

A: Describes the mechanism, not the task — it causes misrouting. Describe the user-facing task (Trap 9).

Q3: A blocking pre-merge check is proposed as a Message Batch for the ~50% saving. Is that fine?

A: No. Batch is only for latency-tolerant jobs (Trap 13).

One-liners to memorize

Trust boundaries: retrieved content is untrusted input.
Don’t default to RAG — pick the simplest pattern that satisfies the constraints.
Keep ~4–5 tools per agent; describe the user-facing task.
Remove the risky tool — don’t log around it (least privilege).

S2

Solution Design & Architecture

Domain 1 · patterns, orchestration, lifecycles

17% Priority ★★★ done

Focus: workflow vs agentic vs augmented-LLM · multi-agent orchestration · input→processing→output→feedback loops · SLA + business-value mapping.

The ask is not the problemA stakeholder asks for a chatbot; the problem may be a slow support queue. Distinguish the real problem from the proposed solution. Anti-pattern: “the chatbot nobody asked for.”

Three patterns, one axis — the autonomy dial

Low autonomy

Workflow

Deterministic, predefined steps. Task is predictable, order matters.

Medium

Augmented-LLM

LLM is one step inside a defined pipeline — classification/extraction.

High autonomy

Agentic

Model decides its own actions/tool calls. Steps unknown up front.

The rulePick the simplest pattern that satisfies all constraints. Defaulting to agentic/multi-agent when a deterministic workflow works is a distractor (P4).

Multi-agent orchestration — what actually justifies it

Justified when: genuinely different skills/contexts are needed, parallelizable independent subtasks, separate permission boundaries.
The handoff contract: subagents don’t share context — state must pass explicitly (structured message, shared file, or tool-call result). Design the contract, not just the agents.
Cost side of the ledger: agents multiply tokens, latency, and failure surface. The coordinator owns context and spawns subagents deliberately.
Decomposition: break complex problems into subtasks — sometimes stage the task without agents at all.

End-to-end architecture is a lifecycle, not a static diagram

Input

untrusted

→

Processing

pattern + tools

→

Output

validated

→

Feedback loop

monitor + eval + iterate

Align to the business-value pillar, justify against the SLA

EfficiencyTransformationProductivityCostPerformance SLA

The 4 recurring moves (your filter)

1

Root cause over symptom.

2

Humans on irreversible decisions.

3

Measure before you assert.

4

Treat external input as untrusted.

Constraint-finding — name the binding constraint before you chooseAre the steps known up front (workflow) or discovered as you go (agentic)? Do subtasks need different skills or permission boundaries (multi-agent)?

Checkpoint — quick verify (click to reveal)

Q1: A task is deterministic with known ordering. Agentic or workflow?

A: Workflow — the simplest sufficient pattern. Agentic for a deterministic task is a distractor (P4).

Q2: Name two conditions that genuinely justify multi-agent.

A: Genuinely different skills/contexts needed, and parallelizable independent subtasks. (Separate permission boundaries too.)

Q3: A stakeholder asks for a chatbot; the real pain is a slow support queue. What’s your first move?

A: Diagnose the underlying problem before proposing a solution — the ask is not the problem.

One-liners to memorize

The ask is not the problem.
Pick the simplest pattern that satisfies all constraints.
Design the handoff contract, not just the agents.
Architecture is a lifecycle with a feedback loop, not a static diagram.

S3

Evaluation + Models

Domain 4 (16%) + Domain 2 (13%)

16% + 13% Priority ★★★ done

Focus: metrics (accuracy/latency/cost/safety) · eval datasets · A/B testing · failure diagnosis · model selection trade-offs · prompt caching · context engineering.

Model selection — “three tiers, one trade-off”

Max capability

Opus

Higher cost/latency. Reserve for hard cases.

Balanced default

Sonnet

Start here. Eval-gate every model swap.

Cheap + fast

Haiku

Routing simple queries to a smaller model is a named optimization. (Some sources add Fable as the newest small tier.)

Prompt techniques

Zero-shot

The default for clean tasks — no examples needed.

Few-shot

High-quality examples teach the format. Don’t over-scaffold a clean classification with huge few-shot blocks.

Chain-of-thought / extended thinking

Let the model reason for multi-step problems. On current models this is adaptive thinking — controlled by configuration, not incantation.

Prefilling / output steering

Steer the start of the response. On current 4.6+ models assistant prefills 400 — use structured outputs instead.

Generation parameters

temperature / top_p / top_k. Note: current 4.6+ models reject sampling params — steer with prompting.

System prompt is a contract

Not a guarantee. Guardrails in prompts have a non-zero failure rate — critical logic belongs in hooks.

Prompt caching mechanics — memorize the numbers

1,024

min cacheable block (tokens) on Sonnet/Opus

2,048

min block on Haiku

5 min

cache TTL, refreshed on each hit

~10%

cost on cache hit (of normal input)

~15%

latency on cache hit

Placement: end of the stable prefix, before dynamic content. Cache system prompt + policy + few-shot + reference docs; keep the user’s current question out of the cached prefix.
An 800-token system prompt does not activate caching on Sonnet — combine with a reference doc or expand past the threshold.
Verify with usage fields: cache_creation_input_tokens > 0 = write; cache_read_input_tokens > 0 = hit; both 0 = below threshold.

The named exam trapLarge repeating prefix driving latency + cost → answer is “place static content before dynamic, enable prompt caching” — NOT truncation, NOT a blind model downsize.

“The window is a budget”

Stable-first (cacheable prefix), retrieve-and-summarize-never-stuff, attention lives at the edges (facts buried mid-context get skimmed). Use compaction, context editing, count_tokens.

Conversation history management

Never pass full history forever. Sliding window (simple, loses early context) vs periodic summarization with Haiku (preserves context, one extra call per K turns) vs store-full-history-externally for compliance/audit while passing a sliding window to Claude.

The single most-tested concept across ALL domainsProgrammatic enforcement vs prompt-based guidance. If a rule MUST hold → encode in code (hooks). If it should usually hold → put it in the prompt. Example: “refund > $500 needs manager approval” belongs in a PreToolCall/PostToolUse hook that physically intercepts, NOT in the system prompt.

This domain separates practitioners from readers

1

Define targets before instrumenting. Know the primary metric before building evals.

2

Silent quality drift is the dangerous failure. After a model upgrade, quality can quietly degrade on safety-relevant outputs. The answer is always a version-attributed eval set every upgrade must clear before promotion — and pin models to dated aliases.

“Accepted” ≠ “right”An output can pass a human approval step and still be wrong. The eval must measure correctness, not just acceptance.

Eval dataset design & metric families

Production examples, synthetic cases, expert labels, adversarial prompts, language segments, risk categories, edge cases. This is your golden set + regression gate.

AccuracyLatencyCostSafetySecurityTask completionGroundingUser outcomes

“Five families, one primary.” Accuracy / latency / cost / safety / security form the core metric families — define the primary per use case and instrument around it before building evals.

Eval reliability: pin model to dated version, temperature 0/low, assert on output properties not exact sequences (tool-call sequences are non-deterministic).
Judge model ≥ candidate capability. Same-model evaluation under-detects errors the candidate also makes.
Mixed-method evidence: automated eval + human review + model-based grading + user feedback + production outcomes.
A/B testing: treatment/control, random assignment, guardrail metrics, sample size, confidence, segmented results, stopping rules, staged rollouts — all explicitly tested.

Diagnosis — the change-point discipline

Prompt failure vs hallucination vs model mismatch vs retrieval quality vs missing context vs tool selection vs configuration drift. Investigate what changed. Optimization order: caching before truncation.

The named exam scenarioA RAG system returns confident-but-wrong answers right after a document refresh (latency + model unchanged) → investigate retrieval/indexing (broken re-index, mismatched embeddings), NOT model weights, temperature, or context.

Constraint-finding — name the binding constraint before you chooseIs the driver cost, latency, correctness, or change control? Cost + latency point to caching; correctness + change control point to version-attributed evals.

Checkpoint — quick verify (click to reveal)

Q1: A large repeating prefix drives cost and latency. What’s the structural fix?

A: Place static content before dynamic and enable prompt caching — not truncation, not a blind model downsize (Trap 2).

Q2: After a model upgrade, quality silently degrades. What was missing?

A: A version-attributed eval set every upgrade must clear, with models pinned to dated aliases.

Q3: How do you verify a cache hit on the second call?

A: usage.cache_read_input_tokens > 0. Both usage fields at 0 means the prefix is below threshold or changed.

One-liners to memorize

Static content before dynamic; enable prompt caching.
Pin models to dated aliases; version-attributed evals gate every upgrade.
Assert on output properties, never exact sequences.
Investigate what changed — retrieval, not the model.

Week 1 checklist

Week 1 — Concepts + Hands-On

3–6 hrs · sessions S1–S3

0%

After Week 1

You’ve covered 48% of the exam weight in the three most-tested domains. Session S4 in Week 2 adds the governance and soft-skill layers that most engineers under-prepare.

Sessions S4 – S6

Week 2 — Governance, Practice, Mocks

3–6 hrs. The 35% of governance + stakeholder + developer-productivity weight, then a timed practice set and a full mock.

S4

Governance + Stakeholder + Dev Productivity

Domains 5 + 6 + 7

14% + 14% + 7% Priority ★★ done

Focus: guardrails & LLM failure modes · human-in-the-loop by risk tier · GDPR/HIPAA/FedRAMP · bias/transparency · discovery & trade-off communication · SLA management · Claude Code team config.

Guardrails are layers, not gatesDefense-in-depth — prompt guardrails, retrieval bounds, tool authorization, output validation, human review. Not a single gate. “Fail safe, never silent.”

LLM failure modes to identify

HallucinationPrompt injectionStale informationContext dilutionBiasAutomation biasExcessive agencyRunaway executionUnsupported calculationsPrivacy exposureBehavioral change after model/prompt update

Human-in-the-loop, engineered

Route by confidence × impact. Qualified human review for irreversible/high-impact decisions. Define what evidence reviewers need. Record approvals, corrections, overrides, outcomes.

The rule that never breaksAny answer that strips human oversight for irreversible or high-impact decisions is wrong every single time.

Prompt-injection defense depth

XML-tagging helps the model resist injection but does not enforce it. Defense-in-depth requires checks outside the model — output validation, tool authorization, point-of-retrieval access control.

Compliance at the architecture level

GDPR

Lawful processing, access requests, deletion workflows, data minimization, data residency.

HIPAA

Business Associate Agreement (BAA) is the load-bearing constraint.

FedRAMP

Public-sector constraints — know what each regime constrains and where PII/data-residency enters the architecture.

Zero Data Retention

A workspace-level enterprise control, not a request-level flag. Data residency, retention, auditability.

Ethical AI — bias / fairness / transparency

The “refuses rationalization” trap“We didn’t fine-tune on company data, so bias evaluation is unnecessary” → wrong. Pretraining bias can surface in outcomes regardless. The constructive move: measure outcome disparity across groups empirically before deployment — don’t reason about whether it might exist.

Stakeholder communication & discovery

Discovery is a protocol, not a chat: structured discovery, workflow mapping, stakeholder interviews, acceptance criteria, priority decisions. The “chatbot that died in deployment review” = skipped discovery.
Communicating trade-offs to executive/legal/security/ops audiences: quality, cost, latency, safety, auditability, scalability, delivery speed. “Justify against the SLA, not against taste.” The error rate is a design fact, not a bug to hide.
SLAs for probabilistic systems: “promise the process, not the miracle” — commit to process/reliability measures, not perfect accuracy.
Lifecycle: discovery → design → handoff → monitoring → iteration. The “system that rotted in a month” = skipped monitoring/iteration.
Documentation is a deliverable: architecture diagrams, ADRs, ownership matrices, interface contracts, deployment runbooks, monitoring plans.

The stakeholder scope-creep scenario

Leader-grade responseNeither silently absorb it (surfacing later as a slipped date) nor refuse outright. Name the trade-off honestly and offer real options: defer, descope something else, or extend the timeline. “An architect who cannot align expectations is not an architect, they are a bottleneck.”

Claude Code config — the scope discipline

Managed

Security-critical settings individuals cannot override.

Project

Team-shared servers + permission rules, under version control — everyone inherits the same setup.

User

Personal preferences.

Credentials never belong in a version-controlled file.
Enforce standards structurally (hooks, subagents, Agent Skills) rather than via convention.
Dev/ops tooling: troubleshooting, hooks, team analytics, Claude Code Analytics API, headless CLI.

Constraint-finding — name the binding constraint before you chooseIs the decision irreversible or high-impact (human-in-the-loop)? Is the rule must-hold (code, not prompt)? Is the driver compliance (GDPR/HIPAA/FedRAMP/ZDR)?

Checkpoint — quick verify (click to reveal)

Q1: A $900 refund must be gated. Prompt or hook?

A: Programmatic hook — must-hold rules live in code, not prompts (Trap 6).

Q2: A stakeholder adds scope mid-project. What do you do?

A: Name the trade-off honestly and offer options: defer, descope something else, or extend the timeline.

Q3: “We didn’t fine-tune on company data, so bias evaluation is unnecessary.” True or false?

A: False — pretraining bias can surface regardless. Measure outcome disparity empirically.

One-liners to memorize

Guardrails are layers, not gates; fail safe, never silent.
Never strip human oversight from irreversible decisions.
ZDR is a workspace-level control, not a request flag.
Credentials never belong in a version-controlled file.

S5

Practice Set

Timed practice + scorecard + weak-spot fix

~25 questions done

Run a timed set in exam format, then repair by domain. Use the Drill engine below for exam-format single- and multiple-response items built from the named traps.

Multiple-response handlingThe “how many to select” is a hard constraint — treat each option as a binary judgment call. Distractors in multi-select are often partially correct (meet function, ignore security/cost). No penalty for wrong answers — answer everything.

The method1) Constraint-finding — name the binding constraint before choosing. 2) Trade-off framing — options → trade-off → recommendation + why. 3) Hands-on with the Anthropic stack (MCP server, a RAG flow, Claude Code team config).

Validating third-party mocks: no official full-length mock exists. Validate any third-party mock against the official weights (17/13/19/16/14/14/7) and the 63-item / 120-min format before trusting it as a weak-spot diagnostic.

Constraint-finding — name the binding constraint before you chooseIn every scenario, the binding constraint is the one you cannot trade away — compliance, security, cost, latency, or SLA. Find it before picking an option.

Checkpoint — quick verify (click to reveal)

Q1: Two options both “work.” How do you break the tie?

A: Constraint-check first; then prefer the most Claude-native option — but some questions test when not to use Claude. Read constraints first.

Q2: You’re unsure about one option in a multiple-response item. Mark it or not?

A: Only mark what you’re confident in — each wrong mark is partial-credit risk. (The stated count is a hard constraint.)

Q3: Why can rising practice scores mislead you?

A: Practice mocks run easier — one candidate scored 1000/1000 three times, then 590/1000 on the real exam, which shares no questions.

One-liners to memorize

Read the full scenario before the answers.
Flag-and-return; eliminate the obviously wrong first.
Answer everything — no penalty for wrong.
Patch your 2–3 weakest domains from the score report.

S6

Full Mock Exam

63 Q / 120 min + per-domain score report + repair

63 items · 120 min done

Focus: one full timed simulation, then per-domain repair — not “read everything again.”

Ready when

82%+

on a full timed 120-min mock with no weak domain.

Beware

Practice runs easier

1000/1000 on the official practice exam three times → 590/1000 on the real thing. The real exam shares no questions.

Repair

Weak-domain math

19% + 17% + 16% = 52%. Strong in those three, and you can afford errors in the smaller domains. Patch your 2–3 weakest from the score report.

Budget ~1.9 min/itemFlag and move on; come back. ~45 min of dense questions and people start to fade. Elimination + time-budgeting are the highest-value pacing skills.

If time allows: a second mock, or focused drill on the two weakest domains. Renewal is a free non-proctored assessment; a lapsed cert is a full retake.

Constraint-finding — name the binding constraint before you chooseThe mock’s constraint is time and stamina: 120 minutes, ~1.9 min/item, and ~45 minutes in, people fade. Budget the brain, not just the clock.

Checkpoint — quick verify (click to reveal)

Q1: What’s the readiness benchmark?

A: 82%+ on a full timed 120-min mock with no weak domain.

Q2: How do you stay on pace without sacrificing accuracy?

A: Flag-and-return: flag hard ones early, finish, come back and change. Elimination + time-budgeting are the highest-value pacing skills.

Q3: After the mock, where does remaining prep time go?

A: Per-domain repair on the 2–3 weakest domains — not “read everything again.”

One-liners to memorize

720/1000 to pass; target 82%+ on a timed mock.
Flag hard ones early; come back and change.
Stamina is the real constraint — budget your brain.
Practice runs easier than the real thing — trust the process, not the score.

Week 2 checklist

Week 2 — Governance, Practice, Mocks

3–6 hrs · sessions S4–S6

0%

Overall progress

6 sessions across both weeks

0%

Target exam ~2 weeks out, 3–6 hrs/week. Head to Drills any time for exam-format practice.

Exam-format practice

Drills

Single-answer and multiple-response items built from the named traps and distractor classes. Pick a category, answer, and get the doctrine behind every option.

0

answered

0

correct

–

best %

Full-length simulation

Exam Papers

Five complete CCAR-P-style papers. Each is 63 questions · 120 minutes · scored /1000, 720 to pass, weighted to the official blueprint (Integration 19 / Solution Design 17 / Evaluation 16 / Governance 14 / Stakeholder 14 / Models 13 / Dev Prod 7). No paper shares a question.

Before you startReal exam pacing is ~1.9 min/item. The timer is fixed at 120:00 and keeps running if you switch tabs — just like a proctored exam. Clear two uninterrupted hours, sit Paper 1, then use the per-domain breakdown to repair weak domains before Paper 2.

These papers mirror the real exam’s format and weighting. They are not official questions — no official full-length mock exists. Treat any paper score as a floor, not a prediction: practice mocks run easier than the real thing.

Hands-on · TypeScript / Node

Labs — build it, so it sticks

The training plan’s Method: “we’ll actually build small pieces with the Anthropic stack so mechanics stick.” Each lab is copy-paste-and-run in your own project, tied to the domain it reinforces and the named traps it demonstrates.

How to use theseEach lab = why it’s daily developer work → a copyable snippet → how to run it → a checkpoint. Start a scratch repo, copy the code, run it. Don’t just read it.

L1

Build an MCP server

Reinforces S1 · Integration · protocol selection & tool design

Trap 9 · 10Beginner

Why this is daily developer work: MCP is how you expose your app’s internal tools and data to Claude — and to any other MCP client. Building the server is the integration layer you reach for before wiring one-off REST routes.

Prereqs: npm init -y && npm i @modelcontextprotocol/sdk zod

server.ts

Run it: npx tsx server.ts — then connect from Claude Code with claude mcp add billing -- tsx server.ts

Checkpoint

Q: Why is the tool description “Calculate the final price…” instead of “Runs a SQL query against the orders table”?

A: Tool descriptions are part of the prompt. Mechanism descriptions cause misrouting — the model can’t tell what it’s for. Describe the user-facing task (Trap 9).

Q: What should a failing tool return?

A: A structured result, not an uncaught exception. The MCP error contract is structured error objects — the model can read them and recover (Trap 10).

L2

RAG flow — chunk, embed, retrieve, ground

Reinforces S1 · Integration · retrieval & chunking

Trap 4 · 15Intermediate

Why this is daily developer work: “Chat with your docs” is the most common agent product. This is the honest skeleton: chunk by structure, embed via a provider, rank with cosine similarity, then ground the answer. No vector DB required to learn it.

Accuracy noteAnthropic does not ship its own embedding model — embeddings come from a provider such as Voyage AI. This lab calls Voyage’s HTTP API directly with fetch. Also remember Trap 4: only reach for RAG when the corpus exceeds ~150K tokens or you need cross-user doc retrieval — otherwise in-context + caching wins.

Prereqs: npm i @anthropic-ai/sdk · a VOYAGE_API_KEY + ANTHROPIC_API_KEY

rag.ts

Run it: export DOCUMENT_MD="$(cat docs/plan.md)" && npx tsx rag.ts

Checkpoint

Q: Why pass input_type to the embedder?

A: Voyage prepends a query- or document-specific prompt, which measurably improves retrieval quality. For RAG, always set it.

Q: When would you NOT build this pipeline at all?

A: When the doc fits in context and is reused in-session — in-context + prompt caching is faster, cheaper, and simpler (Trap 4).

Q: The doc is untrusted. What’s the failure mode?

A: Prompt injection at retrieval: an attacker-controlled chunk can steer the model. Mitigate with output validation and tool authorization at the point of retrieval, not XML tags at render time (Trap 15).

L3

Prompt caching + usage verification

Reinforces S3 · Models · context engineering & cost

Trap 2Beginner

Why this is daily developer work: Repeating a large system prompt on every call is the #1 hidden cost in agent products. Caching the stable prefix is the structural fix — and it’s the most-tested optimization concept on the exam.

The ruleStable-first. Put cache_control at the end of the stable prefix, before dynamic content (the user’s question). Any byte change in the prefix invalidates everything after it. Minimum cacheable prefix: 1,024 tokens on Sonnet (the exam number).

Prereqs: npm i @anthropic-ai/sdk · ANTHROPIC_API_KEY

caching.ts

Run it twice: npx tsx caching.ts → first call writes the cache, the second reads it.

Checkpoint

Q: On the second call, what do you expect to see in the usage log?

A: cache_read_input_tokens > 0 and a much smaller fresh_input. If it stays 0, a silent invalidator changed the prefix.

Q: The refund cap is written into the prompt. Is that right?

A: No — a MUST-hold rule belongs in a programmatic hook. The prompt’s guardrail has a non-zero failure rate (Trap 6). The comment in the code says so deliberately.

L4

Message Batches for offline bulk jobs

Reinforces S3 · Models · cost optimization

Trap 13Intermediate

Why this is daily developer work: Summarizing a backlog, classifying a CSV, rewriting 1,000 tickets — anything latency-tolerant. The Batches API cuts cost ~50% and runs the same request shape.

The trapBatch is only for latency-tolerant jobs. A blocking pre-merge CI check must not be batched — it’s wrong even though it’s cheaper (Trap 13).

Prereqs: npm i @anthropic-ai/sdk · ANTHROPIC_API_KEY

batches.ts

Run it: npx tsx batches.ts — expect ~50% lower cost than the same calls sent individually.

Checkpoint

Q: Why key results by custom_id and not array order?

A: Batch results return in any order. Matching by custom_id is the only safe way to map results back to requests.

Q: Would you batch a login-time classification that must answer in under a second?

A: No — batch has a 24-hour window and is asynchronous. Latency-sensitive paths stay synchronous (Trap 13).

L5

Eval harness — gate a model upgrade

Reinforces S3 · Evaluation · version-attributed evals

Trap 7Advanced

Why this is daily developer work: “Accepted” ≠ “right.” Before you promote a model change, a version-attributed eval set must clear it — that’s how you stop silent quality drift from shipping.

DisciplinePin the exact model string and record it with every result. Assert on output properties, never exact strings — tool-call sequences are non-deterministic. The judge model must be ≥ the candidate’s capability (same-model judges under-detect the candidate’s errors).

Prereqs: npm i @anthropic-ai/sdk · ANTHROPIC_API_KEY

eval.ts

Run it: npx tsx eval.ts → the printed RESULT line carries model + date + eval-set, so regressions are attributable.

Checkpoint

Q: Why assert out.action === e.action instead of comparing full response strings?

A: Model output is non-deterministic. Assert on semantic properties (the fields that matter), not exact sequences — that’s the eval-reliability rule.

Q: A human approved an output in review, but the eval says it’s wrong. Which wins?

A: The eval — “accepted” ≠ “right.” Approval measures acceptance, not correctness.

L6

Claude Code team configuration

Reinforces S4 · Developer Productivity · team enablement

Trap 14 · scope disciplineBeginner

Why this is daily developer work: Onboarding a team on Claude Code means committing the setup — permission rules, must-hold guardrails as hooks, and shared guidance. It’s an artifact, not a preference.

Scope disciplineTeam-shared servers + permission rules → project scope under version control. Security-critical settings → managed configuration individuals can’t override. Personal preferences → user scope. Precedence: managed > project > user. Credentials never belong in a version-controlled file.

Create these files in your repo’s .claude/ directory.

.claude/settings.json — permissions + a must-hold guardrail as a hook

CLAUDE.md — project memory, committed at the repo root

.claude/agents/reviewer.md — a scoped subagent

Then try it: run claude in the repo and ask for a review — the subagent should be offered, and git push should be denied by the hook.

Checkpoint

Q: Why is the refund rule enforced by a hook, not just written in CLAUDE.md?

A: Guidance in a prompt/file has a non-zero failure rate. A MUST-hold rule belongs in code that physically intercepts (Trap 6).

Q: Where should a personal keybinding go?

A: User scope, not the committed project file. Team settings live in project scope under version control; credentials never do.

After the labsYou’ve now built the mechanics the exam assumes: an MCP integration, a RAG flow, caching, batches, an eval gate, and team config. Head to Drills for exam-format questions that test the same doctrine.