The study guide
What CCAR-P is, and what this guide covers
This ccar-p study guide covers the Claude Certified Architect - Professional exam, Anthropic's top-tier credential for people who design and deliver Claude systems that run in production. The exam is 63 multiple-choice and multiple-response items in 120 minutes, delivered by Pearson VUE online or at a test centre, with a $175 fee, a pass mark of 720 on a 100 to 1,000 scale, and a credential that stays valid for 12 months.
It is a judgment exam, not a recall exam. Stems describe an engagement, an incident or a disagreement and ask what an architect should do next, and the seven domains follow the arc of a real project: shape the solution, steer the models, integrate, prove it works, govern the risk, carry stakeholders along and leave a team able to run it. Weights run from 19 percent for Integration to 7 percent for Developer Productivity, so nothing can be skipped.
Everything below derives from the official Exam Guide v1.0 (effective July 2026) and the platform documentation: a summary per domain, our decision rules, the commonest wrong-answer patterns, and a documentation link per objective where one exists.
Study guide text checked against Exam Guide v1.0 (July 2026) on 17 September 2026. It is written from the published blueprint and the official documentation, never from a sitting.
The blueprint
Exactly what CCAR-P tests you on
7 domains and 38 published objectives, each with its official weight, what the domain tests, the decision rules that settle most of its items, the traps the wrong options set, and every objective in plain words, with the official documentation page to read where there is one.
1
Solution Design & Architecture
17% of the exam · 6 published objectives
17%
Domain 1 asks whether the shape you chose fits the problem actually stated. Items open with a bundled business request and expect you to separate language-shaped work from lookups an existing system already performs, decide what Claude owns, what a human owns and what stays put, then pick a pattern. The objective names three shapes: a single augmented call, a workflow with predetermined steps, and an agent that plans its own route. Candidates trained on a two-way choice miss the middle one.
The other objectives cover the loop from input through processing and output to feedback, orchestrating several agents, decomposing into testable steps, and tying a design to the value it should produce. Expect one item where the impressive answer fails because it ignores the value pillar the stakeholder named, and one where the right move is not to use Claude for a step at all.
Decision rules
- Start with the cheapest pattern that can work, a single augmented call, and escalate only when a named constraint rules the simpler shape out.
- Route exact arithmetic, transactions and facts that can change before the next sync to the system of record through a tool call, never into the prompt.
- Read the value pillar in the stem before the architecture; the answer that serves the stated pillar beats the one with the most capability.
Traps
- Choosing the agentic pattern because the scenario sounds complex, when the steps are knowable in advance and a workflow would be cheaper.
- Splitting work across several agents for flexibility when one well-prompted call would meet the requirement.
- Treating a fast-changing fact as a knowledge-base problem and retrieving a stale value instead of calling the live system.
Objectives
- Translate business problems into Claude-based AI solutions. Turn a loosely stated business need into a Claude solution with a defined scope, owners and a measurable outcome. Read: Guides to common use cases
- Design end-to-end architectures (input, processing, output, feedback loops). Lay out the full path a request takes through the system, and the loop that feeds results back in. Read: Building with Claude
- Select appropriate architectural patterns (workflow, agentic, augmented LLM). Choose between one augmented call, a predetermined workflow and an autonomous agent on step predictability and error cost.
- Design multi-agent systems and orchestration strategies. Decide when several agents beat one, and how an orchestrator delegates, scopes and reassembles their work. Read: Subagents
- Apply decomposition techniques for complex problem solving. Break a large problem into smaller steps that can each be prompted, tested and replaced on their own. Read: Chain complex prompts for stronger performance
- Align solutions to business value pillars. Tie every design choice to the business outcome it serves: efficiency, transformation, productivity, cost or a performance commitment.
2
Claude Models, Prompting & Context Engineering
13% of the exam · 5 published objectives
13%
Domain 2 is the per-call layer: what one request costs, what it guarantees and how you keep it behaving the same next month. Items give you a task and a constraint and ask which model tier, prompting technique or context strategy fits. The guide's sample item here is instructive: a long static system prompt resent on every request, with latency and cost both under pressure, where the right move is to put stable content first and cache it rather than truncate or downgrade.
The objectives cover choosing a model on its trade-offs, system prompts and templates with guardrails written in, techniques from bare instruction through worked examples to step-by-step reasoning, window and token budgeting, and reuse through caching, modular components and Skills. Name the binding constraint before touching any dial; tier, extended thinking, caching and retrieval are independent levers.
Decision rules
- Name the binding constraint first, then pull the lever that addresses it; a larger model does not fix a caching problem, and caching does not fix quality.
- Start extraction, classification, routing and formatting on the fastest tier and move up only when an evaluation set shows it missing the bar.
- Put stable content at the front of the prompt and cache it; for a long system prompt this is usually the largest single saving available.
- When the corpus is large or changes often, invest in retrieval instead of stuffing the window, with a source hierarchy so the model knows which text wins.
Traps
- Reaching for the largest model by reflex when the task is bounded and an evaluation would have shown the smaller tier passing.
- Cutting the policy document to save tokens when caching would have kept it intact and still cut cost and latency.
- Turning extended thinking on globally instead of for the one step whose reasoning depth needs it.
Objectives
- Select appropriate Claude models based on trade-offs. Pick the model tier by weighing capability, speed and price against the task, and prove the choice with an evaluation. Read: Choosing the right model
- Design system prompts, templates, and guardrails. Write system prompts and reusable templates that fix the role, the rules and the output shape, guardrails included. Read: Giving Claude a role with a system prompt
- Apply prompt engineering techniques (zero-shot, few-shot, chain-of-thought). Know when a bare instruction is enough, when worked examples are needed and when to ask for step-by-step reasoning. Read: Prompt engineering overview
- Optimize context windows and manage token usage. Keep the context window to what the task needs, budget tokens deliberately and know what happens as it fills. Read: Context windows
- Implement prompt reuse strategies (caching, modular prompts, Skills). Reuse prompt work through caching, modular prompt components and packaged Skills instead of rewriting instructions per call. Read: Prompt caching
3
Integration
19% of the exam · 8 published objectives
19%
Domain 3 is the heaviest and broadest, eight objectives across roughly twelve items, so most are worth a single question and none can be skipped. Its question is whether the system can reach the data and tools it needs, safely and within the time budget. The guide's sample item is the pattern to internalise: an agent holding tools its users never need, where the answer is to remove the capability rather than log it, confirm it or buy a bigger model.
Two objectives appear on no other Claude exam: evaluating an agent for capability bloat, and choosing between progressive discovery and loading everything up front. The rest cover authentication and authorization gaps, accuracy against latency, observability at scale, RAG design with chunking and indexing, matching retrieval to the data and the queries, and choosing among MCP, a direct API or CLI, and agent-to-agent protocols. Governance constraints eliminate options before any technical preference applies.
Decision rules
- Remove a capability the role does not need; least privilege is removal, and logging or confirmation prompts are compensating controls, not substitutes.
- Check the compliance and residency constraint first; a route that cannot satisfy it is not a candidate however fast or cheap it is.
- Choose MCP when several clients need a governed, decoupled tool surface, and a direct API or SDK call when one application owns the whole loop.
- Prefer progressive discovery when the tool or document set is large or changes often, and a monolithic context when it is small, stable and always needed.
Traps
- Adding an audit log to a dangerous tool and calling it secure, when the task was to close the gap rather than watch it.
- Blaming the model for wrong answers when the retrieval step is returning stale or irrelevant chunks.
- Choosing a protocol because it is newer or more flexible rather than because the scenario has multiple clients or a governance need.
Objectives
- Evaluate tool/agent configuration for capability bloat. Audit an agent's tools and instructions for capability the job does not need, and take it out. Read: Tool use with Claude
- Analyze authentication and authorization requirements to identify security gaps. Trace who and what can act through the system, find where identity, scopes or consent are missing, and close it. Read: MCP connector
- Evaluate accuracy-latency trade-offs and justify configuration decisions. Weigh the accuracy a configuration buys against the latency it costs, and defend the setting with a measurement. Read: Reducing latency
- Analyze observability challenges and select monitoring strategies at scale. Recognise what breaks in monitoring as volume grows, and pick tracing, sampling and alerting that scale.
- Design a RAG pipeline with appropriate chunking and indexing strategies. Design the ingestion side of retrieval: how documents are split, embedded and indexed so the right passage is findable. Read: Embeddings
- Apply retrieval strategies matched to data shape and query pattern. Fit the retrieval method to the data and the questions, whether semantic, keyword, hybrid or a structured lookup.
- Evaluate connection protocols and select the appropriate integration mechanism. Choose the connection mechanism per integration, comparing MCP, a direct API or command-line call and agent-to-agent handoffs. Read: Model Context Protocol (MCP)
- Evaluate progressive discovery vs. monolithic context strategy. Decide whether tools and context are discovered as needed or loaded in full, on size, change rate and per-call cost. Read: Agent Skills overview
4
Evaluation, Testing & Optimization
16% of the exam · 6 published objectives
16%
Domain 4 is the measurement layer, and it decides whether any claim made elsewhere can be supported. Items describe a drifting system, a proposed prompt or model change, or a cost or latency target, and ask what to measure, how to build the test set or where to look first. The guide's sample item shows the style: answers that turn confidently wrong right after a corpus refresh, with the model untouched, implicate retrieval and indexing rather than weights, temperature or the window.
The metrics objective lists five families, and a suite that measures output quality alone has covered one; security, safety, cost and latency each need their own measure. The others cover test sets built from golden examples, rubrics and model-graded checks, A/B testing, diagnosis of prompt failure, hallucination and model mismatch, token, latency and cost optimisation, and monitoring through logging and observability tooling. Throughout, an evaluation gate sits in front of every production change, a model swap included.
Decision rules
- Define the metric and the acceptance threshold before you change anything, and cover all five families rather than accuracy alone.
- When quality drops after a change, compare current output with the golden set and check what changed in the prompt, model or corpus before touching anything.
- Instrument latency by stage before changing model tier; context growth, a slow tool call and a cache miss each show up differently.
- Use tail percentiles for latency and cost commitments; averages hide the slow requests that breach a service level.
Traps
- Answering a diagnosis item with a model or setting change when the stem points to retrieval, the prompt or the data.
- Treating a dashboard as an evaluation; monitoring tells you something moved, an evaluation tells you whether it is acceptable.
- Optimising cost per token when the real driver is the number of calls or a cache that stopped hitting.
Objectives
- Define evaluation metrics (accuracy, latency, cost, safety, security). Set out the measures a system is judged on, accuracy and latency through cost, safety and security, each with a threshold. Read: Define your success criteria
- Design evaluation datasets and test frameworks using mixed methodologies. Assemble test data and a harness mixing exact checks, rubric grading and model-graded review to catch different failure types. Read: Create strong empirical evaluations
- Conduct A/B testing and iterative improvements. Compare two variants fairly on the same inputs and grader, then iterate on the evidence rather than on instinct. Read: Using the Evaluation Tool
- Diagnose system issues (prompt failure, hallucinations, model mismatch). Work out from symptoms whether a failure is the prompt, a hallucination or the wrong model, and fix the actual cause. Read: Reduce hallucinations
- Optimize token usage, latency, and cost-performance trade-offs. Reduce token use, latency and spend without dropping below the quality bar, knowing which lever addresses which cost. Read: Batch processing
- Monitor system performance using logging and observability tools. Keep a running system visible through logs, traces and metrics so drift and incidents surface before users report them.
5
Governance, Safety & Risk Management
14% of the exam · 5 published objectives
14%
Domain 5 is the only place in the programme that names regulations, with GDPR, HIPAA and FedRAMP as examples in one objective. It is not a law exam. What is tested is the chain from an obligation to a named control, an accountable owner and an evidence artefact a reviewer could inspect. Items describe a regulated or high-stakes deployment and ask where a guardrail belongs, which failure mode was overlooked, where a human must sign off, or what makes a compliance claim defensible.
The objectives cover guardrails at each checkpoint of the request path, the failure modes specific to LLM systems, human review routed by stakes rather than applied everywhere, regulatory compliance, and bias, fairness and transparency. Two ideas do most of the work: a control that fails open protects nothing while looking like it does, and the model's training does not know your organisation's policies, so any rule you did not give it is unenforced.
Decision rules
- Place a deterministic authorization check in front of any tool with side effects; a filter on the reply judges text and cannot reverse an action already taken.
- Make every control fail closed, block and log, and never let uncertainty pass through silently.
- Route human review on how reversible the action is and what a wrong answer costs, weighting those above the model's confidence when they disagree.
- For each regulatory obligation, name the control, the owner and the artefact that proves it, and check that logs, caches and monitoring stay inside the same boundary.
Traps
- Assuming Claude's alignment training enforces a policy the prompt never stated.
- Putting a single filter at the end of the pipeline and treating input screening and tool authorization as covered.
- Treating a compliant-sounding hosting route as proof of compliance, when the obligation still needs a control, an owner and evidence.
Objectives
- Implement guardrails and safety controls. Put screening on inputs, outputs and tool calls, deterministic for fixed rules and model-based where judgment is required. Read: Mitigate jailbreaks and prompt injections
- Identify risks, limitations, and failure modes of LLM systems. Name the ways an LLM system can fail, from fabrication and injection to silent drift, and design around the intolerable ones.
- Apply human-in-the-loop validation strategies. Decide where a person reviews, before the action, after it or on a sample, and give them what they need to judge.
- Ensure compliance with regulations (e.g., GDPR, HIPAA, FedRAMP). Map each applicable regulation to the outcome it demands and to the deployment choices, controls and evidence that satisfy it. Read: Claude on Amazon Bedrock
- Address ethical AI considerations (bias, fairness, transparency). Design for fair outcomes across groups, make decisions explainable and be open about where AI is used.
6
Stakeholder Communication & Lifecycle Management
14% of the exam · 5 published objectives
14%
Domain 6 exists on no other Claude exam and, with Domain 7, forms a fifth of the paper that candidates from a technical track have never been tested on. Its discriminating question is disclosure: who learns what, and in time to change anything. Items put you in a discovery workshop, an executive design review, a service-level negotiation or a handoff, and ask which action keeps the engagement honest and the system supportable after you leave.
The objectives cover structured discovery, communicating decisions and their trade-offs, managing feedback loops and expectations including SLAs, documenting the architecture with implementation guidance, and supporting every lifecycle phase from discovery to iteration. A service-level commitment is where this domain turns technical again: a number agreed in a meeting constrains integration and evaluation choices, so it must trace to a real source rather than a figure that sounded reasonable.
Decision rules
- Present every trade-off in three parts: the gain, the cost, and what reversing the choice would take once the system is built around it.
- Set a service-level threshold from a traceable source, a user expectation, business criticality or an evaluation criterion, never from a round number.
- Run a feedback loop as signal, triage, decision and action with a named owner at each step; a dashboard alone is not governance.
- Write documentation to one test: could a capable architect who was absent from the design work change the system safely from it alone.
Traps
- Reporting only what an option delivers and leaving the stakeholder to discover the cost of reversing it later.
- Accepting a latency or availability target because it was requested, without checking the architecture can measure and meet it.
- Handing off a system with a diagram but no decision log, so the next team cannot tell which choices were deliberate.
Objectives
- Conduct structured discovery and requirement gathering. Run discovery as a structured process that surfaces the real problem, constraints, stakeholders and success measures before design begins.
- Communicate architectural decisions and trade-offs. Explain a design choice to technical and non-technical audiences in terms of what it gains, costs and forecloses.
- Manage stakeholder feedback loops and expectation alignment (including SLAs). Keep stakeholders aligned through the build, agree service levels that trace to real needs and handle changing expectations without silent scope drift.
- Document architectures and provide implementation guidance. Leave documentation and implementation guidance that lets another team build, operate and change the system safely.
- Support lifecycle phases (discovery, design, handoff, monitoring, iteration). Stay involved past delivery, through monitoring and iteration, and plan for change such as model retirements. Read: Model deprecations
7
Developer Productivity & Operational Enablement
7% of the exam · 3 published objectives
7%
Domain 7 is the smallest, about four items, and also unique to this track. It asks whether a team can work inside the architecture without you: configuring Claude tooling such as Claude Code for a group rather than an individual, improving development workflows with AI assistance without lowering the review bar, and diagnosing operational issues once the system is live. With so few items, one miss costs a quarter of the domain score, so read that line of your report as pass or fail.
Stems tend to describe a team adopting AI-assisted tooling, a shared convention or Skill that needs distributing, or a production symptom that must be traced to its cause. The expectation is that generated work meets the same standard as any other change, that shared assets have an owner and a rollback path, and that adoption is proved on one real workflow before it reaches everyone.
Decision rules
- Choose how a shared Skill or convention is distributed by who needs it and how tightly it must be governed, and give it an owner and a way back.
- Hold generated code to a concrete check for correctness, security and maintainability, and require that whoever merges it can explain what it does.
- Prove adoption on one real workflow with a champion before widening it to the next group; switching everyone on at once hides the failures.
- Trace a symptom to its architectural cause before changing anything: gradual quality loss points at the corpus or an unchecked model swap, a latency jump at context growth or a slow tool.
Traps
- Treating a Claude Code rollout as installing a tool rather than configuring permissions, memory and shared conventions for a team.
- Merging generated code because the tests pass, when nobody on the team can say what it does.
- Changing the model tier to fix a latency spike before instrumenting which stage got slower.
Objectives
- Configure Claude tools and environments for teams (e.g., Claude Code). Set up Claude tooling such as Claude Code for a team, with shared settings, permissions and conventions rather than per-person defaults. Read: Claude Code settings
- Improve developer workflows using AI-assisted tooling. Use AI assistance to speed up development work while keeping review, testing and ownership standards unchanged. Read: Common workflows
- Support debugging and operational issue resolution. Help a team trace a live problem to its cause and resolve it, using logs, configuration checks and a repeatable diagnostic order. Read: Troubleshooting
Weights are the official domain weightings from the exam guide. Objective titles are Anthropic's published wording; the sentence after each is ours.
Practice
Six CCAR-P practice questions, written for the 2026 blueprint
Written for this page from the official guide's domains and objectives, never recalled from a sitting. Each shows its key and the reason every option holds or fails. The CCAR-P mock exam has the full paper under a clock, with no account needed.
Question 1 · Domain 1: Solution Design & Architecture · Single responseEvery day, 12,000 customs declarations go through the same four steps: identify the type, extract twelve fields, validate the tariff code against a live service, and flag failures. Which pattern fits best?
- A. A code-driven workflow that uses Claude to extract fields.
- B. An agent per declaration that decides which steps to run next.
- C. One prompt that does all four steps.
- D. Agents that check each other's work on every declaration.
Answer: A. Predictable steps call for a workflow, not an agent
A workflow suits work whose steps are known and repeat every time. The order lives in code, a deterministic call checks each tariff code against the live service, and Claude handles the language work of reading and extracting. This keeps cost per declaration low and results consistent. An agent per declaration adds cost and variation, one prompt mixes checks with extraction, and reviewing agents multiply cost.
A. Correct. Fixed steps in code, a deterministic tariff check and Claude only for extraction keep it cheap and consistent.
B. The steps never change, so letting an agent choose them adds cost and unpredictable behavior.
C. A single prompt cannot call the live tariff service deterministically, and it mixes validation with extraction.
D. Agents checking each other multiply calls and cost for a process that needs none of it.
Question 2 · Domain 2: Claude Models, Prompting & Context Engineering · Single responseA ticket router on the top model tier scores 96.1 percent on 2,000 labeled tickets, with a 3.8-second p95. The target is under 2 seconds at 95 percent. What should you do first?
- A. Test the fastest tier on the same 2,000 tickets.
- B. Keep the top tier and trim its short system prompt.
- C. Switch straight to the fastest tier and skip the labeled test.
- D. Stream the routing label so it reaches the queue sooner.
Answer: A. The lightest tier that clears the evaluation and the target
Choose the lightest model that meets the target, and prove it on the evaluation set you already have. Running the fastest tier on the same 2,000 tickets shows whether it clears 95 percent and the latency target; if not, try the next tier up. Trimming a short prompt barely moves latency, skipping the test risks quality, and streaming a one-word label saves almost nothing.
A. Correct. The existing labeled set shows whether the cheapest, fastest tier meets both targets before anything ships, and the next tier up is tried only if it misses.
B. The top tier's generation speed sets the latency; trimming a short prompt saves very little.
C. Switching without measuring risks dropping below the 95 percent target with no warning at all.
D. The router emits a short label, so streaming it saves almost no time.
Question 3 · Domain 3: Integration · Single responseA clinical policy assistant cites dosing tables from superseded policy versions. Chunks are fixed 4,000-token windows with no metadata that often split tables, and the index is rebuilt quarterly. What should change?
- A. Rebuild the whole index weekly, with the same 4,000-token chunks.
- B. Chunk by section, tag versions and re-index on each revision.
- C. Tell the model to check dates and prefer the newest version it sees.
- D. Retrieve twice as many chunks per question.
Answer: B. Chunk by structure, index by version
A RAG pipeline needs chunking that respects document structure and an index that tracks versions. Section-based chunks keep tables whole, version metadata lets retrieval filter to the effective policy, and re-indexing on each revision keeps the index current. A weekly rebuild still splits tables and has no version filter, a prompt cannot tell versions apart without metadata, and more chunks add more stale text.
A. More frequent rebuilds narrow the stale window but keep split tables and give no way to filter versions.
B. Correct. Section chunks keep tables whole, version metadata filters to the current policy, and re-indexing on each revision keeps it fresh.
C. Without version metadata, nothing tells the model which retrieved chunk is the current one.
D. Retrieving more chunks brings in more superseded text and more tables cut in half.
Question 4 · Domain 4: Evaluation, Testing & Optimization · Single responseA claim-summary assistant must never omit an injury the claimant stated. The proposed release check is four adjusters rating 30 summaries on a five-point scale. Which evaluation fits best?
- A. The same four adjusters and 30 summaries, on a stricter scale.
- B. A code check for missing injuries across hundreds of labeled claims.
- C. A model grader scoring each summary from 1 to 10.
- D. Ratings from 100 adjusters on the same 30 summaries.
Answer: B. Deterministic checks for rules, humans for judgment
Evaluation frameworks should mix methods by what each requirement needs. A hard rule such as never omitting a stated injury is checked by a programmatic test over a labeled set large enough to catch rare misses, while readability and usefulness are judged by adjusters with a rubric on a stratified sample. Thirty ratings cannot show a rule is never broken, and generic quality scores do not test the rule.
A. Thirty summaries cannot show that an omission never happens, whatever the scale.
B. Correct. A programmatic check enforces the hard rule at scale, and rubric ratings can then cover what code cannot judge.
C. An overall quality score from a model does not test the specific never-omit rule.
D. More raters on the same 30 summaries still sample too few claims to catch rare omissions.
Question 5 · Domain 5: Governance, Safety & Risk Management · Single responseAn assistant drafts 600 benefit appeal decisions a month with a confidence score. A wrong uphold leaves a resident without support, usually unnoticed. Officers have four minutes per appeal. Where should review sit?
- A. Auto-issue decisions above 0.9 confidence; send the rest to an officer.
- B. Auto-issue upholds and send every overturn to an officer for sign-off.
- C. Issue all decisions and audit 5 percent weekly.
- D. An officer checks sources and approves each decision before issue.
Answer: D. Reversibility and cost outrank model confidence
Human-in-the-loop placement follows the cost and reversibility of a wrong outcome, not model confidence. A wrong uphold harms a resident and is rarely caught, so every decision needs an officer's approval before it is issued, and showing the sources, draft and reason makes four minutes enough. A confidence cutoff trusts the model's own estimate, reviewing only overturns protects the recoverable outcome, and a sampled audit lets harm land first.
A. Confidence is the model's own estimate; confident errors on upholds would be issued unchecked.
B. This automates the dangerous outcome and reviews the recoverable one, which inverts the stakes.
C. A sampled audit finds errors only after residents have already lost the support they need.
D. Correct. Officer approval before issue, with the sources in view, protects residents from the hard-to-reverse wrong uphold.
Question 6 · Domain 6: Stakeholder Communication & Lifecycle Management · Single responseA registrar wants a student-help assistant's service agreement to state 99.9 percent accuracy. The golden set scores 91 percent, and most misses are questions the knowledge base does not cover. What should you do?
- A. Accept 99.9 percent and add prompt instructions to reach it before launch.
- B. Agree to 91 percent, today's score, as the target.
- C. Explain the 91 percent and agree on a target for harmful errors.
- D. Leave accuracy out of the agreement entirely.
Answer: C. Turn an aspiration into a measurable criterion
Managing expectations means turning an aspiration into a measurable commitment the evidence supports. Showing what the 91 percent covers, and that most misses are gaps in the knowledge base, lets you agree on a criterion for the failures that matter, such as no wrong deadline or fee, plus a fallback for uncovered questions. Accepting 99.9 percent sets up a breach, freezing today's score ignores what fails, and omitting accuracy leaves no commitment.
A. Prompt changes cannot fill missing knowledge, so the target would be missed from day one.
B. A single number hides that the misses are coverage gaps and says nothing about harmful errors.
C. Correct. It ties the commitment to evidence and to the errors that matter, with a fallback for coverage gaps.
D. An agreement with no accuracy term gives the registrar nothing to hold the service to.
Sit the CCAR-P mock, no account
