CertSafari

    Free Anthropic Claude Certified Architect – Professional (CCAR-P) - December 7 onwards Sample Questions

    35 free sample questions from our bank of 446+, covering every exam domain, with answers and detailed explanations. Updated November 2026.

    1: Solution Design and Architecture

    1.5: Value-Based Architectural Decisions

    1.Which statement best describes a value-based architectural decision for a Claude solution?

    1. A.Choosing the option that gives the greatest measurable improvement on the stakeholders' stated value pillars while staying within the stated cost and SLA limits.
    2. B.Choosing the option that uses the most capable model tier available, because maximum model capability always yields the greatest return on spend for stakeholders.
    3. C.Choosing the option with the lowest projected token spend, because minimizing cost is the only value pillar that can be quantified reliably in advance.
    4. D.Choosing the option with the most components, because a richer architecture with agents and tools demonstrates transformation to the sponsoring leadership.
    Show answer & explanation

    Correct answer: A — Choosing the option that gives the greatest measurable improvement on the stakeholders' stated value pillars while staying within the stated cost and SLA limits.

    • A. Correct: a value-based decision ties the choice to measurable outcomes on the named pillars and treats the cost and SLA ceilings as constraints rather than variables.
    • B. Incorrect: the most capable tier can exceed the cost ceiling and is unnecessary for easier tasks, so capability alone does not equal value.
    • C. Incorrect: lowest spend ignores outcomes such as quality and productivity; value is the outcome achieved under the ceiling, not the lowest cost.
    • D. Incorrect: more components add cost and complexity, and complexity is not a measured outcome on any pillar; the simplest sufficient design is usually better.

    1.3: Architectural Pattern Selection

    2.A bank wants Claude to handle inbound card disputes. Claude should classify each dispute, then each type follows an approved handling procedure, and refunds above a set amount need a human approver. Compliance states that Claude must never decide refund eligibility. Which pattern and delegation boundary satisfy this?

    1. A.A routing workflow: Claude classifies each case and drafts replies, coded rules determine eligibility, and a staff member signs off on large payouts.
    2. B.A prompt chain: Claude classifies each case, retrieves the matching procedure and rules on eligibility, and a staff member signs off on large payouts.
    3. C.An evaluator-optimizer loop: one Claude drafts the eligibility outcome, a second Claude checks it against policy, and staff sign off on large payouts.
    4. D.An autonomous agent: Claude classifies each case, applies the procedure and decides eligibility itself, and a prompt tells it to escalate large payouts.
    Show answer & explanation

    Correct answer: A — A routing workflow: Claude classifies each case and drafts replies, coded rules determine eligibility, and a staff member signs off on large payouts.

    • A. Correct: Claude is limited to classifying and drafting, deterministic code applies the eligibility rules, and a person signs off on the large refunds. The classify-then-procedure flow is kept and Claude never decides eligibility.
    • B. The chain follows the classify-then-procedure flow and has a human sign-off on large refunds. But Claude still rules on eligibility, which compliance forbids. Sign-off on large amounts does not remove that decision from the model.
    • C. Both Claude instances take part in the eligibility decision, and the second review is still a model judgment. Staff sign-off on large refunds does not change that, so the rule that Claude must never decide eligibility is broken.
    • D. Claude decides eligibility itself, which compliance prohibits. The escalation for large refunds is only a prompt instruction, a non-deterministic control on an agent that holds the authority to act, so the approval requirement is not reliably met.

    1.2: End-to-End Architecture Evaluation

    3.Your team operates a pipeline that calls the Claude Messages API directly. Which API response tells you that the pipeline has exceeded its rate limit and indicates when it should retry?

    1. A.A 413 request_too_large response, returned when traffic goes over the quota, with a retry-after header giving seconds to wait
    2. B.A 401 authentication_error response, returned when the key's allowance runs out, with a retry-after header giving seconds to wait
    3. C.A 529 overloaded_error response, returned when the organization's quota is hit, with a retry-after header giving seconds to wait
    4. D.A 429 rate_limit_error response, returned when request volume tops the limit, with a retry-after header giving seconds to wait
    Show answer & explanation

    Correct answer: D — A 429 rate_limit_error response, returned when request volume tops the limit, with a retry-after header giving seconds to wait

    • A. Incorrect: a 413 request_too_large error means one request body exceeded the maximum size. It is not tied to request volume, quotas or reset timing, so it cannot tell the pipeline it hit a rate limit.
    • B. Incorrect: a 401 authentication_error means the API key is missing or invalid. Running out of allowance does not produce it, so it does not signal a rate limit or say when to retry.
    • C. Incorrect: a 529 overloaded_error reflects temporary load on the API as a whole. It is not triggered by your organization's own quota, so it does not report that the pipeline exceeded its rate limit.
    • D. Correct: exceeding a rate limit returns HTTP 429 with a rate_limit_error body and a retry-after header. The header gives the seconds to wait, and the pipeline should honor it with backoff.

    1.4: Orchestrator and Subagent Decomposition

    4.A contract-review orchestrator launches four subagents in one parallel fan-out: extract clauses, classify risk for each clause, draft redlines for risky clauses, and compile a summary for counsel. The last three subagents frequently return empty or invented output. Which two statements identify why this control flow fails? Choose two.(Select 2)

    1. A.Classifying risk takes the clause list from extraction as its input, so that step has to wait for extraction to finish and receive the list in its prompt
    2. B.The summary step runs on a smaller model tier than extraction, so it cannot condense three separate reports into one document and returns weak output
    3. C.Redlining takes the risk labels and the summary takes the earlier outputs, so the orchestrator must launch them in stages and pass results forward
    4. D.The runtime's concurrency cap is below four subagents, so the last three spawns are rejected and the orchestrator gets empty results back from them
    5. E.Subagents lack file access of their own, so the orchestrator has to read the contract and paste its text into each subagent's prompt before launch
    Show answer & explanation

    Correct answers: A, C — Classifying risk takes the clause list from extraction as its input, so that step has to wait for extraction to finish and receive the list in its prompt; Redlining takes the risk labels and the summary takes the earlier outputs, so the orchestrator must launch them in stages and pass results forward

    • A. Risk classification has a data dependency on extraction. Launched in the same fan-out, it starts without the clause list it needs, so it returns empty or invented output. It has to wait and receive that list in its prompt.
    • B. Model tier affects quality and cost, not whether a step has its inputs. It also says nothing about why classification and redlining fail, since neither involves summarising. The failure comes from the control flow, so a different tier would not fix it.
    • C. Redlining depends on the risk labels and the summary depends on the earlier outputs, so these steps cannot run beside the steps that feed them. The orchestrator must run them in stages and pass each stage's results forward. Only independent subtasks belong in one parallel fan-out.
    • D. Four subagents fall within the default concurrency limit. The three failing steps also clearly ran and returned text, empty or invented, so spawning was not the problem. The cause is missing upstream inputs, not a rejected launch.
    • E. Subagents can be given file tools such as `Read` and open documents themselves. Extraction runs in the same fan-out and works fine, so file access is not what blocks the later steps. They fail because the results they depend on do not exist yet.

    1.1: Task Delegation Between Claude and Humans

    5.In a legal due-diligence project, attorneys must find change-of-control, exclusivity and indemnity provisions across 4,000 supplier contracts before a deal closes. The firm advises the client on risk allocation. Choose two assignments that fit the work.(Select 2)

    1. A.Claude only formats the final report, and attorneys read the 4,000 contracts end to end and mark the relevant clauses by hand before the deal closes.
    2. B.Claude extracts and classifies the clauses, and attorneys review the flagged contracts only; the unflagged ones are treated as clean and are not opened before closing.
    3. C.Claude builds clause tables with citations from the contracts, and attorneys judge how each clause shifts risk and decide what to advise the client.
    4. D.Claude extracts and classifies the clauses, and attorneys review the flagged contracts plus a random sample of unflagged ones to estimate what was missed.
    5. E.Claude assesses how each clause shifts risk and drafts the advice to the client, and attorneys check the citations and formatting before it is sent on.
    Show answer & explanation

    Correct answers: C, D — Claude builds clause tables with citations from the contracts, and attorneys judge how each clause shifts risk and decide what to advise the client.; Claude extracts and classifies the clauses, and attorneys review the flagged contracts plus a random sample of unflagged ones to estimate what was missed.

    • A. Incorrect: reading 4,000 contracts by hand and keeping Claude out of the extraction wastes the strength of a model at locating provisions across large volumes. Extraction accuracy can be checked by sampling against attorney review, so manual reading is not needed to trust it, and it is slow given the closing date.
    • B. Incorrect: a contract with a missed clause looks the same as a clean one, so treating unflagged contracts as clean without attorney review leaves an unknown miss rate. Missed provisions cannot be corrected after signing, and a sample of the unflagged contracts is what would measure the misses.
    • C. Correct: Claude produces the clause tables and citations at scale, while attorneys keep the judgment on how each provision allocates risk and what the client should be told. That is the split that matches who is accountable for the advice.
    • D. Correct: extracting and classifying clauses across thousands of contracts is where a model adds the most value. Sampling the unflagged contracts gives a measured estimate of missed provisions, so the review rests on evidence rather than an assumption.
    • E. Incorrect: the firm is accountable for advising the client on how risk is allocated, and that is professional judgment. Letting Claude draft the advice while attorneys check only citations and formatting removes the attorney's own assessment from the advice that reaches the client.

    1.6: Deployment Surface and Agent Runtime Selection

    6.A healthcare startup's platform architect must ship an autonomous coding-and-document agent. Compliance requires Zero Data Retention for all agent traffic, and the team wants to reuse an existing agent harness with built-in file and shell tools instead of writing its own loop. Which runtime choice fits these constraints?

    1. A.Create a Claude Managed Agents environment with the Anthropic-managed cloud sandbox, and delete each session through the API once its task completes.
    2. B.Run the Agent SDK in containers you operate, with a SessionStore adapter on your own database for transcripts and the tool shell in your own sandbox.
    3. C.Build a Messages API loop in a stateless service, with your own bash and file-edit tool executors running in a locked-down, audited worker pool.
    4. D.Enable Managed Agents on the Claude API and route tool calls to private systems through MCP tunnels, sending the beta header on each request.
    Show answer & explanation

    Correct answer: B — Run the Agent SDK in containers you operate, with a SessionStore adapter on your own database for transcripts and the tool shell in your own sandbox.

    • A. Incorrect. Managed Agents sessions are stateful server-side resources, and their transcripts persist until deleted. The hosted service is not ZDR eligible, so deleting a session after the task does not meet a Zero Data Retention requirement for agent traffic.
    • B. Correct. The Agent SDK provides the ready-made harness with shell and file tools. Running it in your own containers keeps the agent loop, sandbox and transcripts on infrastructure you control, so retention depends on your own storage and the API's ZDR terms rather than a hosted session store.
    • C. Incorrect. A stateless service with audited workers could satisfy the retention rule, but it means writing a new agent loop and your own tool executors. The team wanted to reuse an existing harness with built-in file and shell tools, and the Agent SDK already ships tool execution, context management and permissions.
    • D. Incorrect. The beta header only opts a request into a beta feature and does not change data-handling eligibility. MCP tunnels only affect connectivity to private tools. Sessions and history are still stored server-side by the hosted service, which conflicts with Zero Data Retention.

    2: Claude Models, Prompting, and Context Engineering

    2.3: Prompting Technique Selection

    7.A contract-analysis service on Claude Opus 5.5 uses adaptive thinking to compute penalty amounts across clauses. Answers are right when complete, but about 15% of responses end with `stop_reason: "max_tokens"` partway through the answer. `max_tokens` is 2048, sized for the visible answer alone, and the truncated cases are the ones that need the reasoning. What is the best fix?

    1. A.Raise `max_tokens` to a value that covers the thinking and the reply, leaving `output_config.effort` and the prompt unchanged.
    2. B.Set `output_config.effort` to `low` so the model reasons less, leaving `max_tokens` and the prompt unchanged.
    3. C.Disable thinking and ask for the arithmetic step by step in the reply, leaving `max_tokens` and effort unchanged.
    4. D.Add few-shot examples showing concise reasoning on clause calculations, leaving `max_tokens` and `output_config.effort` unchanged.
    Show answer & explanation

    Correct answer: A — Raise `max_tokens` to a value that covers the thinking and the reply, leaving `output_config.effort` and the prompt unchanged.

    • A. Thinking tokens are counted against `max_tokens`, so a limit sized for the visible reply alone is too small once the model reasons. Enlarging it to cover both thinking and reply lets the cases that need the reasoning finish, without changing how the model works.
    • B. Lower effort suits responses that are over-thought. The truncated requests are the ones that need the reasoning to get the penalty amounts right, so cutting it risks wrong numbers and treats the reasoning as the problem when the undersized limit is the cause.
    • C. Written step-by-step arithmetic in the reply still consumes output tokens from the same 2048 limit, so the long cases get cut off just as before. It also gives up the built-in thinking that the model is designed to use for this kind of calculation.
    • D. Examples can nudge the style of reasoning but do not set a firm limit on thinking length, so truncation can still occur. Shortening deliberation on the multi-clause calculations also removes the reasoning those cases depend on, trading accuracy for tokens.

    2.4: Context Composition and Token Economics

    8.A claims-triage service on the Messages API handles a high daily call volume. Each request carries 60 tool definitions although a given ticket category uses about six, plus the same compliance instructions pasted into the system prompt and again at the top of every user message. The team must cut input tokens without removing any information the model needs. Choose two.(Select 2)

    1. A.Lower `max_tokens` on the triage calls, which trims the input tokens billed for the prompt as well as the generated reply.
    2. B.Mark the rarely needed tools as deferred and add the tool search tool, which loads a definition only when a ticket needs it.
    3. C.Strip the repeated compliance block from the user messages, which leaves the system prompt as the one place it is stated.
    4. D.Replace both compliance blocks with a one-line pointer to standard claims policy, which the model already knows from training.
    5. E.Shorten each tool description to a one-line label, which leaves the parameter schemas to tell the model when to use a tool.
    Show answer & explanation

    Correct answers: B, C — Mark the rarely needed tools as deferred and add the tool search tool, which loads a definition only when a ticket needs it.; Strip the repeated compliance block from the user messages, which leaves the system prompt as the one place it is stated.

    • A. Incorrect. `max_tokens` only caps how many tokens the model generates. The prompt still contains all 60 tool definitions and both copies of the compliance text, so input tokens are unchanged.
    • B. Correct. Tool definitions count as input tokens on each call. Deferring the rarely needed ones and loading them through the tool search tool keeps the unused definitions out of context while the model can still reach any tool it needs.
    • C. Correct. The compliance instructions already sit in the system prompt, so the copy in each user message adds tokens but no information. Removing it shortens every request and loses nothing the model needs.
    • D. Incorrect. The compliance instructions are the team's own rules, and a generic pointer to standard claims policy cannot stand in for their specifics. The model cannot recover them from training, so this cuts tokens by discarding information it needs.
    • E. Incorrect. The description is the main guidance the model has for deciding when and how to use a tool, and schemas alone do not carry that. One-line labels cut tokens by discarding information the model needs, which the team ruled out.

    2.2: System Prompt Diagnosis and Revision

    9.A legal-tech team uses a system prompt for contract summaries that says: "Never include opinions. Always include every clause. Keep summaries brief." Outputs are sometimes a single paragraph that omits termination terms and sometimes a very long clause list. Which two revisions fix the diagnosed problem? Choose two.(Select 2)

    1. A.Set a priority order, giving payment, termination and liability clauses full coverage and compressing the other clauses to one-line entries.
    2. B.Define an output template with labelled sections, giving the model a fixed line to write when a clause type does not appear in the contract.
    3. C.Delete the brevity and no-opinion rules, giving the model a free hand to pick summary length and style according to the contract's complexity.
    4. D.Increase `max_tokens` and leave the prompt wording as is, giving the model enough room to finish long summaries and reach the termination terms.
    5. E.Restate the three original rules in bold at the end of the prompt, giving the final copy more weight than the earlier wording.
    Show answer & explanation

    Correct answers: A, B — Set a priority order, giving payment, termination and liability clauses full coverage and compressing the other clauses to one-line entries.; Define an output template with labelled sections, giving the model a fixed line to write when a clause type does not appear in the contract.

    • A. Correct: the demand for complete clause coverage and the demand for brevity pull against each other, so the output swings between a thin paragraph and a long list. Ranking the goals, with full treatment for the key clauses and compression for the rest, resolves the conflict and keeps both goals.
    • B. Correct: a labelled template with a fixed line for absent clause types gives every summary the same shape, so termination terms cannot silently drop out and the output no longer flips between a paragraph and a list.
    • C. Incorrect: the brevity and no-opinion rules are legitimate requirements for contract summaries. Deleting them discards needs the team has, and leaving length and style to the model makes output even less predictable instead of specifying what to cover.
    • D. Incorrect: `max_tokens` only caps output length. The short paragraphs that skip termination terms are not truncated output; they come from conflicting instructions, which a larger budget does nothing to resolve.
    • E. Incorrect: bold and repetition change emphasis, not content. The rules still demand both complete coverage and brevity, so the model has no basis for deciding which to favour and the inconsistent outputs continue.

    2.6: Reasoning Effort and Context Lifecycle

    10.A research agent on the Messages API runs one long session of about 60 web-fetch and file-read tool calls. The oldest results are huge and rarely needed verbatim again, but their findings must remain available for an accuracy-critical final report. You already enabled `clear_tool_uses_20250919` context editing. Choose two additions.(Select 2)

    1. A.Set `clear_tool_inputs` to `true` in the clearing config, so the parameters of cleared calls are dropped and the retained context stays compact.
    2. B.Add the memory tool next to context editing, so Claude can save important details to files when it is warned that clearing is near.
    3. C.Keep the complete message history on the client and resend it unchanged each turn, so Claude can reread cleared results when drafting the report.
    4. D.Lower the clearing `trigger` to a few thousand input tokens, so bulky fetch results are cleared sooner and the window stays small throughout the session.
    5. E.Add the small authoritative lookup tool to `exclude_tools`, so its calls and results are left in context while bulky fetch results are still cleared.
    Show answer & explanation

    Correct answers: B, E — Add the memory tool next to context editing, so Claude can save important details to files when it is warned that clearing is near.; Add the small authoritative lookup tool to `exclude_tools`, so its calls and results are left in context while bulky fetch results are still cleared.

    • A. Incorrect. `clear_tool_inputs` only removes the call parameters of tool uses that are already being cleared. It saves space but does not store or summarize any findings, so the report would have less information to draw on, not more.
    • B. Correct. The memory tool is designed to pair with context editing: Claude is warned as clearing approaches, can write important results to files, and can read them back after the originals are cleared. That keeps the findings available for the final report.
    • C. Incorrect. Context editing is applied server-side to what Claude sees on each request. The client's history stays complete, but resending it does not bring cleared results back into Claude's view. Claude can only recover them if they were saved elsewhere, such as in memory.
    • D. Incorrect. A lower trigger only makes clearing happen earlier. Findings from the oldest fetches would be discarded sooner with nothing preserving them, which undermines the accuracy-critical report, and each clearing event also invalidates part of the cached prompt prefix.
    • E. Correct. `exclude_tools` names tools whose calls and results are exempt from clearing. The small authoritative data stays in context, while the huge, rarely reread fetch and file-read results are still cleared to free space.

    2.5: Cache Breakpoints and Reusable Packaging

    11.A nightly job on the Messages API fans out 200 parallel requests, each with a different question but all sharing the same 60,000-token policy prefix that ends in a `cache_control` breakpoint. The job launches all 200 at the same instant, and nearly every request is billed as a cache write. Which launch pattern fixes this?

    1. A.Send one request ahead of the rest and start the other 199 once its response begins streaming, so they find the stored prefix.
    2. B.Extend the prefix breakpoint's lifetime with `"ttl": "1h"` and keep the simultaneous launch, so the 200 requests share one cached entry.
    3. C.Place a second breakpoint after each question block, so the cache stores a longer prefix that neighbouring requests can read back.
    4. D.Shuffle the submission order of the 200 requests within the batch, so the first one to arrive writes the entry and the rest read it.
    Show answer & explanation

    Correct answer: A — Send one request ahead of the rest and start the other 199 once its response begins streaming, so they find the stored prefix.

    • A. Correct: a cache entry can be read only after the request that wrote it has begun its response. Letting one request establish the prefix first means the remaining 199 calls read it at the cheaper cache-read rate instead of each paying for a write.
    • B. Incorrect: the TTL sets how long an entry survives once it exists, not when it becomes readable. With 200 requests launched at the same instant, none has begun responding, so none finds an entry, whatever the lifetime.
    • C. Incorrect: each request carries a different question, so a breakpoint after it produces a prefix that no other request matches. It adds write cost and does nothing for the shared 60,000-token prefix that is being rewritten.
    • D. Incorrect: because all requests are in flight together, no request has begun responding when the others arrive, so none can read what another is still writing. Reordering only changes which request writes, not how many pay for a write.

    2.1: Model Tier Selection

    12.You are the architect for a voice assistant on the Messages API. Binding constraints: first-token latency within the voice budget and at least 94% on the team's labeled intent-and-answer set. Measured results: Haiku 5.5 scores 81%, Sonnet 5.5 scores 91%, and Opus 5.5 scores 96% but exceeds the latency budget. Fable 5.2 has not been evaluated. No tier satisfies both constraints as tested. What should you do next?

    1. A.Revise the Sonnet 5.5 prompt using its failed cases, re-run the labeled set, and if the bar is still missed, escalate the latency-quality conflict to the product owner.
    2. B.Ship Opus 5.5 and raise the voice latency budget to its measured response time, since answer quality is the constraint that users notice most in a voice interaction.
    3. C.Ship Haiku 5.5 now and lower the quality threshold from 94% to its measured 81% score, since it is the only tier that comfortably fits the voice latency budget with margin.
    4. D.Ship Fable 5.2 with effort set low, since the strongest tier at reduced effort should respond inside the latency budget while still clearing the 94% bar.
    Show answer & explanation

    Correct answer: A — Revise the Sonnet 5.5 prompt using its failed cases, re-run the labeled set, and if the bar is still missed, escalate the latency-quality conflict to the product owner.

    • A. Correct. Sonnet 5.5 is the nearest tier to meeting both constraints, so improving its prompt and re-measuring on the same set is the cheapest test of whether the gap closes. If it does not, the conflict between binding constraints is a decision for the owner, not for the architect to relax silently.
    • B. Incorrect. Raising the latency budget to fit Opus 5.5 changes a binding constraint without the owner's agreement. Quality is not the only requirement here, and the voice budget exists for a reason.
    • C. Incorrect. Lowering the quality threshold to match Haiku 5.5 would accept a result about 13 points under the stated bar. The architect cannot redefine a binding quality constraint to make a tier fit.
    • D. Incorrect. Fable 5.2 has not been evaluated, so its latency and accuracy at low effort are assumptions. Selecting a tier on an expectation instead of a measurement on the labeled set repeats the mistake the eval is meant to prevent.

    3: Integration

    3.3: Relieving the Binding Performance Constraint

    13.A chat assistant on the Messages API gives long, detailed answers that take about twelve seconds to finish. Users say it feels unresponsive, and answer quality is rated high. Choose two changes that relieve the latency constraint at the least cost to accuracy.(Select 2)

    1. A.Enable streaming on the request and render tokens in the chat UI as they arrive, showing the reply text within moments.
    2. B.Instruct the model to answer in a concise fixed structure and set a max_tokens cap, trimming the number of tokens in each reply.
    3. C.Send each chat turn through the Message Batches API, running generation as a batch job at a lower cost per output token.
    4. D.Add a reranking step to the retrieval pipeline and pass fewer passages, shrinking the prompt the model reads before each reply.
    5. E.Upgrade to the largest model tier on the same prompt, using its greater capacity to finish the same detailed answers sooner.
    Show answer & explanation

    Correct answers: A, B — Enable streaming on the request and render tokens in the chat UI as they arrive, showing the reply text within moments.; Instruct the model to answer in a concise fixed structure and set a max_tokens cap, trimming the number of tokens in each reply.

    • A. Correct: streaming leaves the answer itself unchanged and delivers tokens as they are generated, so users see text begin at once even though the full reply still takes about twelve seconds.
    • B. Correct: generation time grows with the number of output tokens, so a concise fixed format plus a reasonable max_tokens cap shortens the reply. The content users need is kept when the structure is designed well.
    • C. Incorrect: the Message Batches API is asynchronous and returns results later, not within an interactive chat turn. The lower price does nothing for response time and would make the wait longer.
    • D. Incorrect: reranking improves retrieval precision and shortens the input, but the twelve seconds come from generating long output. A smaller prompt barely changes the time to finish.
    • E. Incorrect: larger tiers typically generate more slowly per token, and a bigger model does not make the same detailed answer shorter. The twelve-second completion time would not improve.

    3.2: Authentication and Authorization Posture

    14.A team builds an MCP server over streamable HTTP that fronts a billing API. To save effort, the server accepts whatever bearer token the MCP client presents and forwards it unchanged to the billing API, which trusts any token from the shared identity provider. A review flags confused-deputy and privilege-escalation risk. Choose two mitigations.(Select 2)

    1. A.Validate the audience claim on each token the server receives, and reject tokens that were issued for a different resource.
    2. B.Apply per-client rate limits and burst alerts on the server's billing calls, and cap the volume of records one token can read.
    3. C.Exchange the client's token for a new one issued for the billing API and limited to that user, and call the billing API with it.
    4. D.Move the server-to-billing connection to mutual TLS, and limit the billing API to callers presenting the server's certificate.
    5. E.Write a hash of each forwarded token to the audit log, and alert when one token is presented by more than one client.
    Show answer & explanation

    Correct answers: A, C — Validate the audience claim on each token the server receives, and reject tokens that were issued for a different resource.; Exchange the client's token for a new one issued for the billing API and limited to that user, and call the billing API with it.

    • A. Correct: checking the audience claim and rejecting tokens issued for other resources means the server honours only credentials meant for it, so a token obtained for another service cannot be replayed against it.
    • B. Incorrect: throttling and volume caps limit how quickly a token can be abused, but the server still accepts tokens meant for other resources and forwards them. The confused-deputy and escalation paths stay open within the limits.
    • C. Correct: exchanging the client's token for a separate, user-scoped credential issued for the billing API ends token passthrough. The billing API then receives a token created for that hop rather than the client's original one.
    • D. Incorrect: mutual TLS authenticates the connection between the server and the billing API, but the token it carries was still never issued for billing, and the billing API still trusts it. The escalation path is unchanged.
    • E. Incorrect: hashing tokens and alerting on reuse is detective only. The misuse happens first, and the server still forwards tokens it should never have accepted, so it keeps acting as a confused deputy.

    3.1: Least-Privilege Tool Configuration

    15.A support agent on the Messages API is given 14 per-endpoint tool definitions for a ticketing system plus 60 tools from three MCP servers. Traces show the tool definitions consume a large share of every request's input tokens, while most conversations use fewer than five tools. Which change best reduces the footprint without removing any capability?

    1. A.Set `defer_loading` on the rarely used tools and add the tool search tool, so Claude fetches a schema only when a conversation needs that tool.
    2. B.Replace the 74 tool definitions with one `execute` tool that takes an endpoint name and a JSON body, so the request carries a single small schema.
    3. C.Move the tool schemas into the system prompt as XML with a `cache_control` breakpoint, so repeat requests read that block at the cached-token rate.
    4. D.Cut each tool description to one sentence and strip the property descriptions from the input schemas, so the definitions stay loaded at a smaller size.
    Show answer & explanation

    Correct answer: A — Set `defer_loading` on the rarely used tools and add the tool search tool, so Claude fetches a schema only when a conversation needs that tool.

    • A. Correct: tools marked with `defer_loading` stay out of the prompt until the tool search tool finds them, so most requests carry only a few definitions while every tool remains available.
    • B. Incorrect: a single `execute` tool leaves Claude without the per-endpoint names, parameters and validation it needs to call the ticketing and MCP tools correctly, so the capability is effectively lost.
    • C. Incorrect: prompt caching only makes re-reading cheaper. The schemas still sit in the context window and count toward input size on every request, and the MCP tools no longer exist as callable tool definitions.
    • D. Incorrect: trimming descriptions saves some tokens, but all 74 definitions are still sent each time. The lost parameter detail also makes Claude less accurate at choosing tools and filling their arguments.

    3.5: Retrieval Architecture Selection

    16.A developer-tools team uses the Claude Agent SDK to answer questions about a monorepo that receives hundreds of commits a day. An earlier prototype embedded the code into a vector store, but answers kept citing files that had since been changed or deleted. Questions usually name a function or module. Which architecture should replace it?

    1. A.Keep the vector store and re-embed the full repository on a nightly schedule, replacing the old index each run
    2. B.Load the repository source into the system prompt and apply prompt caching so repeated requests reuse the prefix
    3. C.Give the agent Glob, Grep and Read tools over a checkout synced to main, searching files when a question arrives
    4. D.Index commit messages and changelogs in the vector store, answering from those summaries of recent changes
    Show answer & explanation

    Correct answer: C — Give the agent Glob, Grep and Read tools over a checkout synced to main, searching files when a question arrives

    • A. With hundreds of commits landing daily, a nightly rebuild leaves the index out of date for most of the day. Answers can still cite files that were changed or deleted since the last run, so the original problem remains and a costly pipeline is added.
    • B. A monorepo's source is typically far larger than a context window, so it cannot be loaded as a prompt prefix. Each new commit would also change the prefix and invalidate the cache, so repeated requests would rarely get a cache hit.
    • C. Correct. Searching a checkout kept in sync with main means no index has to be built or refreshed, so answers reflect files as they are now, including deletions. Because questions name a function or module, Grep and Glob find the target quickly and Read opens the actual code.
    • D. Commit messages and changelogs describe what changed but do not contain the code. Questions about a named function or module need the source itself, so answers built from these summaries would be incomplete or wrong.

    3.7: Progressive Discovery vs. Monolithic Context Loading

    17.An Agent SDK coding agent works in a monorepo far larger than any context window. Users ask narrow questions such as where a retry policy is configured, and they tolerate several seconds per answer. Which approach should the architect choose?

    1. A.Give the agent grep and file-read tools, and let it find matching files and open the relevant line ranges for each question it receives.
    2. B.Pack the repository into one long-context prompt at session start, and have the agent locate the answer in that text for each question it receives.
    3. C.Build an embedding index of the repository once, and give the agent the top-ranked code chunks for each question, with no file tools.
    4. D.Preload a generated summary of each top-level module into the prompt, and have the agent answer from those summaries with file reads disabled.
    Show answer & explanation

    Correct answer: A — Give the agent grep and file-read tools, and let it find matching files and open the relevant line ranges for each question it receives.

    • A. Correct. The codebase is too large to preload, and the questions are targeted lookups. Letting the agent search and read files on demand finds the relevant code, and the extra turns fit the latency users accept.
    • B. Incorrect. The repository is larger than any available context window, so it cannot be packed into one prompt. Any truncated version could omit the file that holds the setting.
    • C. Incorrect. With no file tools the agent can only see the chunks retrieval returns. A retry setting is often defined in one file and overridden or consumed in others, and the agent cannot follow those references to check. Users accept several seconds per answer, so the speed of precomputed retrieval is not needed.
    • D. Incorrect. Module summaries describe what code does at a high level and rarely record specific configuration values or locations. With file reads disabled, the agent has no way to verify where the retry policy is set.

    3.8: Production Reliability Controls

    18.A support agent built on the Messages API calls an `issue_refund` tool that wraps an internal payments service. Traces show the payments service completed the refund, but the tool wrapper's HTTP call timed out before reading the response and retried, so roughly one in fifty timeouts produced a double refund. Which control removes the duplicate effect while keeping the retry?

    1. A.Instruct Claude in the system prompt to check the order's refund history before calling `issue_refund` again and skip it if one exists.
    2. B.Remove the wrapper's retry for `issue_refund` and return a failed-refund error on timeout, so the user can resubmit the request.
    3. C.Send a stable idempotency key built from the order id and `tool_use` id on each call, so payments returns the stored result on replays.
    4. D.Add randomized backoff of several seconds between attempts, so the payments service finishes the first call before the next one.
    Show answer & explanation

    Correct answer: C — Send a stable idempotency key built from the order id and `tool_use` id on each call, so payments returns the stored result on replays.

    • A. Incorrect. The duplicate comes from the HTTP wrapper retrying on its own, below the model. Claude never sees the second request, so a prompt rule cannot intercept it, and an instruction gives no deterministic guarantee.
    • B. Incorrect. The payments service had already completed the refund when the timeout hit, so reporting a failure misstates the outcome and invites a manual resubmission. It also removes the retry, which the requirement says to keep.
    • C. Correct. A key that stays the same for one logical refund lets the payments service recognise a replayed call after a timeout with an unknown outcome and return the stored result. The retry stays in place and the refund happens once.
    • D. Incorrect. In the failing case the first request had already completed on the service side and only the response was lost. Waiting longer does not tell the service that the second call repeats the first, so the refund is issued twice.

    4: Evaluation, Testing, and Optimization

    4.1: Evaluation Coverage Gaps

    19.A coding-ops agent built on the Agent SDK browses web pages and can call a `delete_record` tool. In production, a retrieved page contained hidden text telling the agent to delete customer records, and the agent complied. The pre-release suite only measured task success on benign requests. Choose two additions that would have detected this failure before release.(Select 2)

    1. A.Add an LLM-judged helpfulness rubric on the final reply text so tone and completeness regressions are scored before each release
    2. B.Track an injection-resistance rate over a red-team set of direct and indirect injection prompts, with a minimum rate as a release gate
    3. C.Measure end-to-end task latency percentiles for each tool-calling workflow so slow tool chains are caught under realistic load
    4. D.Add cases where retrieved pages embed instructions to call destructive tools, and fail runs whose trace shows an unauthorized call
    5. E.Expand the benign task-success set with more paraphrased user requests so the pass rate rests on a larger and more varied sample
    Show answer & explanation

    Correct answers: B, D — Track an injection-resistance rate over a red-team set of direct and indirect injection prompts, with a minimum rate as a release gate; Add cases where retrieved pages embed instructions to call destructive tools, and fail runs whose trace shows an unauthorized call

    • A. Incorrect because a helpfulness rubric grades the final text for quality; the incident was an unauthorized action, which a text-quality score does not reveal.
    • B. Correct because an injection-resistance rate over a red-team set turns the security risk into a measurable number, and a minimum value as a release gate would have blocked this build.
    • C. Incorrect because latency percentiles are a performance dimension. Slow or fast tool chains tell nothing about whether the agent obeys injected instructions.
    • D. Correct because it adds the missing security dimension: adversarial inputs inside tool results, graded deterministically on the trace for tool calls outside the allowlist.
    • E. Incorrect because more benign paraphrases deepen accuracy coverage but contain no hostile content, so the agent would keep passing exactly as before.

    4.2: Deriving Evaluations from Business Processes

    20.A bank plans to gate the release of a Claude assistant that drafts replies to customer disputes. Compliance, operations and product each describe 'good' differently, and no acceptance criteria are written. The architect is about to build the test set. Which step must come first in sequence before the release gate threshold is set?

    1. A.Choose an LLM judge and draft its scoring rubric from the compliance team's dispute policy, then build the test set around that rubric.
    2. B.Have compliance, operations and product agree on one set of measurable pass/fail criteria and a tolerable failure rate, then build the test set.
    3. C.Score the current prompt on last quarter's disputes and take its result as the baseline, then build the test set and set the gate to match.
    4. D.Collect a large sample of last quarter's disputes and have the architect label good and bad replies, then build the test set from the labelled pool.
    Show answer & explanation

    Correct answer: B — Have compliance, operations and product agree on one set of measurable pass/fail criteria and a tolerable failure rate, then build the test set.

    • A. Incorrect: compliance, operations and product define good replies differently, so a rubric drawn from one team's policy fixes that team's view as the standard. The judge should implement criteria all three have agreed, not stand in for them.
    • B. Correct: with no written acceptance criteria and three conflicting views of quality, the business owners must first reach one shared, measurable pass/fail standard and a tolerable failure rate. The test set, the grader and the gate threshold all derive from that agreement.
    • C. Incorrect: taking the current prompt's score as the baseline makes today's behaviour the standard. The stakeholders' competing definitions of a good reply are never resolved, and the gate then reflects what the prompt happens to do, not what the bank requires.
    • D. Incorrect: labelling replies as good or bad requires a definition of good, which does not yet exist. The architect's labels would settle the disagreement between the three teams by default, and the set could cover the wrong cases.

    4.7: Model Version Migration

    21.Which statement correctly describes how model retirement works for Anthropic-operated platforms, and is therefore the right planning assumption for a migration timeline?

    1. A.Customers with active deployments get at least 60 days' notice before a publicly released model is retired, and requests sent to it fail after that date.
    2. B.Retired model IDs are mapped to the closest current model on the retirement date, so existing integrations keep working without code or prompt changes.
    3. C.Retirements are posted on the deprecations page with no direct notice sent to customers, so teams need to check that page on a regular schedule.
    4. D.Retired models keep serving requests at lower priority for a grace period after the retirement date, so unmigrated applications slow down rather than fail.
    Show answer & explanation

    Correct answer: A — Customers with active deployments get at least 60 days' notice before a publicly released model is retired, and requests sent to it fail after that date.

    • A. Correct. Anthropic's deprecations policy commits to at least 60 days' notice for publicly released models, and once a model is retired, requests to it fail. The notice period sets the migration deadline.
    • B. Incorrect. Retired model IDs are not mapped to a successor. After the retirement date, requests to the old ID fail, so applications must be migrated beforehand, which usually means testing prompts against the new model.
    • C. Incorrect. Notice is not limited to the documentation, because customers with active deployments are also notified directly, for example by email. Watching the deprecations page is still a useful habit but is not the only channel.
    • D. Incorrect. There is no reduced-priority grace period after retirement. Deprecated models stay available until the retirement date, and after it requests fail outright instead of degrading gradually.

    4.6: Cost and Latency Optimization

    22.An orchestrator on the Messages API fans out 40 subagent requests at the same instant. All share one 20,000-token prefix with a `cache_control` breakpoint, followed by a unique task message. Telemetry for the first wave shows `cache_creation_input_tokens` on all 40 requests and no cache reads; a second wave moments later reads the cache normally. Quality must not change. What should you change?

    1. A.Send one request ahead of the batch and release the other 39 once its response begins streaming, so they read the stored prefix.
    2. B.Add a second breakpoint after each subagent's task message, so each request stores its full prompt for the others to read.
    3. C.Set the shared prefix breakpoint to a 1-hour TTL, so the stored prefix stays available beyond the default five-minute window.
    4. D.Cap dispatch at a handful of requests per second, so later requests find the cache entry written by the earlier ones.
    Show answer & explanation

    Correct answer: A — Send one request ahead of the batch and release the other 39 once its response begins streaming, so they read the stored prefix.

    • A. Correct. A stored prefix can be read only after the request that writes it has begun responding, so 40 simultaneous requests each write their own copy. Sending one request ahead of the others lets the remaining 39 read the prefix at the cached rate, and the prompts are unchanged.
    • B. Incorrect. Each task message is unique to its subagent, so an entry ending after it can never match another request's prompt. The extra breakpoints add write cost and leave the missing reads on the shared prefix unresolved.
    • C. Incorrect. A longer TTL only extends how long an entry survives. The later wave already reads the cache normally, so expiry is not the cause; the first wave misses because no entry had been written when those requests arrived. A 1-hour TTL also costs more per write.
    • D. Incorrect. A rate cap spaces requests out by time but does not tie them to the first response. Any request dispatched before that response has begun still misses and writes its own copy, so misses can recur on every request sent early in the ramp, and total dispatch time grows.

    4.5: Root-Cause Isolation from Logs and Traces

    23.You are the architect reviewing an invoice-extraction service on the Claude Messages API. About 6% of requests fail JSON parsing because the output ends mid-string. In the traces for those requests, `stop_reason` is `max_tokens`, the request sets `max_tokens` to 1024, and every failing document has more than 40 line items. The prompt, retrieval, tools and model are identical to the passing requests. Which TWO actions address the root cause? Choose two.(Select 2)

    1. A.Raise `max_tokens` to cover the longest expected invoice JSON, and enable streaming on the request so long generations do not hit a request timeout.
    2. B.Alert on responses whose `stop_reason` is `max_tokens` in the trace pipeline, and score them as failed eval cases so partial JSON is not parsed as valid.
    3. C.Set `temperature` to 0 on the extraction call, and pin a dated model snapshot so the generated JSON is reproducible from run to run.
    4. D.Move the extraction step to a larger model tier, and add a retry on parse failure so the long invoices get a second attempt at a full answer.
    5. E.Reduce retrieval to the top two passages per request, and trim the system prompt so the input leaves more room in the context window for output.
    Show answer & explanation

    Correct answers: A, B — Raise `max_tokens` to cover the longest expected invoice JSON, and enable streaming on the request so long generations do not hit a request timeout.; Alert on responses whose `stop_reason` is `max_tokens` in the trace pipeline, and score them as failed eval cases so partial JSON is not parsed as valid.

    • A. Correct: the failures stop with `max_tokens` at a 1024 cap and occur only on documents with many line items, so the JSON simply needs more room. A limit sized to the longest output removes the truncation, and streaming keeps long generations from hitting request timeouts.
    • B. Correct: `stop_reason` of `max_tokens` is a reliable marker that a response was cut off. Alerting on it and scoring those responses as failures makes the truncation visible and keeps partial JSON from being treated as a valid extraction.
    • C. Temperature changes how tokens are sampled, not how many the response may contain. Output that reached the 1024-token cap is cut off at that cap at any temperature, and pinning a model snapshot does not alter that limit.
    • D. A larger tier does not change the configured 1024-token cap, so the same long invoices still stop at that limit. A retry sends the same request with the same cap and truncates at the same point again.
    • E. The stop reason shows the output cap was reached, not the input window, and retrieval is identical for passing requests. Trimming input leaves the 1024-token output limit unchanged, so long invoices still truncate.

    5: Governance, Safety, and Risk Management

    5.2: Prompt Injection Surface and Controls

    24.A Claude Code CLI agent reviews pull requests from external forks and has a Bash tool. Reviewers worry that text in a PR description could instruct the agent to send repository contents to an outside host. Which two controls hold even if the model is fully persuaded by the injected text? Choose two.(Select 2)

    1. A.Enable the Bash sandbox and limit its network access to a short list of approved domains, covering the commands the agent starts in that session
    2. B.Add deny rules for `curl` and `wget` in the project permission settings, covering the commands most often used to push files to an outside host
    3. C.Add a system prompt rule that PR descriptions are untrusted data and must not be obeyed, placed ahead of the PR text in the context window
    4. D.Strip secrets and deploy credentials from the environment the review job runs in, leaving the session with nothing sensitive to read
    5. E.Require the agent to write its planned Bash command into a PR comment first, and have a hook cancel the run when that text names an external address
    Show answer & explanation

    Correct answers: A, D — Enable the Bash sandbox and limit its network access to a short list of approved domains, covering the commands the agent starts in that session; Strip secrets and deploy credentials from the environment the review job runs in, leaving the session with nothing sensitive to read

    • A. Correct. Sandbox network isolation is enforced by the operating system on the processes Bash starts. It does not depend on the wording of a command or on the model's judgment, so a persuaded model still cannot reach unapproved hosts.
    • B. Deny rules match the command as written, and they only cover the two named tools. A persuaded model can send data with another binary, an interpreter one-liner or a script, so this does not hold under that assumption.
    • C. A system prompt rule is an instruction the model can weigh against the injected text. If the model is fully persuaded by that text, nothing enforces the rule, so it does not hold under the stated assumption.
    • D. Correct. Least privilege limits the damage regardless of model behavior. If secrets and deploy credentials are absent from the session, a successful injection has little sensitive material to reach.
    • E. The announced command comes from the same model that has been manipulated. It can word the target so the check misses it, or run something other than what it announced, so this is not an enforced control.

    5.1: Guardrail Placement

    25.A team runs the Claude Code CLI in a CI job to review pull requests from external contributors. A red-team pull request contains a code comment telling the agent to run `curl` with the repository's deploy token against an outside host. The job must still run the project's unit tests and read every source file. Choose two.(Select 2)

    1. A.Add permission rules that deny `curl`, `wget` and other network-capable Bash commands, and allow only the test-runner commands the job needs.
    2. B.Disable the Bash tool for the agent in the job configuration, leaving it with file reads and pull request comments but no way to execute commands.
    3. C.Add a CLAUDE.md rule telling the agent to treat text in code comments as untrusted data, and to refuse to send the deploy token to outside hosts.
    4. D.Run the agent on a runner that holds no deploy credentials, and restrict its outbound traffic to an allowlisted set of hosts such as the package registry.
    5. E.Scan the changed files and the pull request text with a keyword filter for `curl` and `wget`, and fail the job when either string appears.
    Show answer & explanation

    Correct answers: A, D — Add permission rules that deny `curl`, `wget` and other network-capable Bash commands, and allow only the test-runner commands the job needs.; Run the agent on a runner that holds no deploy credentials, and restrict its outbound traffic to an allowlisted set of hosts such as the package registry.

    • A. Permission rules are enforced by the harness, not by the model's judgment, so a denied network command is refused even if the injected comment persuades the model. Allowing the test-runner commands keeps the unit tests running.
    • B. Without the Bash tool the agent cannot execute the unit tests, which the job must still run. Targeted permission rules close the exfiltration path while keeping test execution available.
    • C. CLAUDE.md is context the model weighs, not an enforced boundary, so a crafted comment can still outweigh it and trigger the command. It is a reasonable supplement but does not close the exfiltration path.
    • D. With no deploy credentials on the runner and egress limited to an allowlist, a successful injection has nothing valuable to send and nowhere untrusted to send it. Reading source files and running tests still work.
    • E. A string filter is not a security boundary. The command can be obfuscated, encoded or replaced by another network-capable tool, and legitimate pull requests that mention `curl` or `wget` would fail the job.

    5.5: Architectural Controls for Compliance Obligations

    26.A legal-tech company serves many law firms from one Claude-based research assistant that uses retrieval. Each firm's contract forbids any cross-client leakage. Which two controls most directly evidence tenant isolation? Choose two.(Select 2)

    1. A.Have the orchestrator attach a tenant filter and scoped data credentials to each retrieval call, with the tenant value outside the model's control.
    2. B.Tag each document with its firm in the index metadata, with a system prompt telling Claude to use only passages that match the current firm.
    3. C.Give each firm its own Claude workspace and API key, with retention settings, geo restrictions and spend configured and tracked per tenant.
    4. D.Expose a `tenant_id` parameter on the search tool, with Claude filling it in from the session context and each call logged for audit review.
    5. E.Keep one shared API key and put the firm name in each request's metadata, with usage and logs exported per firm for audit attribution.
    Show answer & explanation

    Correct answers: A, C — Have the orchestrator attach a tenant filter and scoped data credentials to each retrieval call, with the tenant value outside the model's control.; Give each firm its own Claude workspace and API key, with retention settings, geo restrictions and spend configured and tracked per tenant.

    • A. Correct. The orchestrator, not the model, supplies the tenant filter and the scoped credentials, so a read across tenants is refused at the data layer. This behaviour is deterministic and can be shown by testing and by access logs.
    • B. Incorrect. Metadata tags and a prompt instruction only ask the model to ignore other firms' passages. Retrieval still pulls those passages into the context, so the separation depends on model compliance. That cannot be shown as an enforced control to a client whose contract forbids any leakage.
    • C. Correct. Separate workspaces and keys give each firm its own configuration boundary for retention and geo restrictions, along with spend that can be attributed to that firm. This is platform-level evidence that tenants are kept apart.
    • D. Incorrect. Because Claude chooses the `tenant_id`, a prompt injection or a plain mistake can select another firm's data. Audit logging records such a leak after it has happened, so it is detection rather than isolation.
    • E. Incorrect. One shared key with metadata tags makes usage attributable per firm, but retention settings, limits and credentials stay common to all firms. Reporting by firm does not show that one firm's data is kept apart from another's.

    5.3: Risk Assessment and Ranking

    27.You are the architect reviewing a proposed Claude Agent SDK deployment for a finance team. The risk register has four open items with similar estimated likelihood. Which item should be ranked highest for exposure and be mitigated first?

    1. A.The agent posts draft journal entries to the ledger under the wrong cost centre, and a controller reclassifies them at month-end.
    2. B.The agent emails ledger summaries to department heads with a minor line item missing, and a corrected summary is sent the same day.
    3. C.The agent issues customer refunds through a payments tool without a sign-off step, and funds cannot be pulled back once a refund settles.
    4. D.The agent's scheduled dashboard refresh jobs slow down during month-end peaks, and the delayed jobs are re-run afterwards at no extra cost.
    Show answer & explanation

    Correct answer: C — The agent issues customer refunds through a payments tool without a sign-off step, and funds cannot be pulled back once a refund settles.

    • A. Incorrect. A miscoded cost centre is a bookkeeping error that a controller can reclassify at month-end, so the impact is limited and reversible. It ranks below an action that cannot be undone.
    • B. Incorrect. An omitted minor line item sent to department heads is a quality problem, but a corrected summary can go out the same day. The effect is contained and recoverable, so it ranks below an unguarded irreversible action.
    • C. Correct. With likelihood roughly equal, exposure is driven by impact. An external money movement with no approval step that cannot be recalled once settled has the highest impact, so it should be mitigated first, ideally with a deterministic control such as an approval gate.
    • D. Incorrect. Slow scheduled jobs at peak times are an availability problem, and re-running them afterwards costs nothing. The consequence is delay rather than lasting harm, so it ranks lowest.

    5.4: Human-in-the-Loop Checkpoints

    28.A team is migrating an authentication module across 40 files in an agent session. Stakeholders want to sign off on the approach before anything changes. After that, they don't want to be interrupted for routine in-project edits. The command that applies the schema change to shared staging must still need a human approval. Which permission sequence fits?

    1. A.Start in plan mode, where Claude only reads and proposes, and have stakeholders review that plan; then switch to accept-edits mode, which applies file edits directly while the staging schema command keeps its prompt.
    2. B.Start in accept-edits mode and tell Claude in the prompt to stop after the first file, then have a reviewer judge the approach from that edit before the remaining 39 files are changed.
    3. C.Start in default mode and have reviewers approve each of the 40 edits one by one, then treat the accumulated diffs as the stakeholders' review of the migration approach before the schema command runs.
    4. D.Start in plan mode, where Claude only reads and proposes, and have stakeholders review that plan; then switch to bypass-permissions mode, which applies file edits and runs the staging schema command with no prompts.
    Show answer & explanation

    Correct answer: A — Start in plan mode, where Claude only reads and proposes, and have stakeholders review that plan; then switch to accept-edits mode, which applies file edits directly while the staging schema command keeps its prompt.

    • A. Correct. Plan mode keeps Claude read-only, so stakeholders review the proposal before any file changes. Accept-edits mode then applies in-project file edits without prompts, while shell commands such as the schema change against shared staging still ask for a human decision.
    • B. Incorrect. Accept-edits mode starts changing files immediately, so the first edit lands before stakeholders have approved anything. The instruction to stop after one file is only a request in the prompt, not an enforced checkpoint, so it does not guarantee a review point.
    • C. Incorrect. Default mode prompts on each edit, so the team is interrupted 40 times for routine in-project changes it wanted to run freely. Approving edits piecemeal also means the first change is applied before anyone has reviewed the approach as a whole, so stakeholders never get the sign-off they wanted before anything changes.
    • D. Incorrect. The planning step is right, but bypass-permissions mode removes the prompts altogether, including the one on the schema command for shared staging. That command would run with no human approval, which the team required to stay in place.

    5.6: Bias Source Identification and Mitigation

    29.A company drafts performance-review summaries with Claude on the Messages API. The prompt template tells Claude to "highlight employees who come across as abrasive or difficult to work with." Women's summaries contain this language at twice the rate of men's, and rerunning identical manager notes with only the names swapped shows the same shift. Which mitigation matches the source?

    1. A.Relabel the historical reviews used to fine-tune a separate scoring model and reweight records where women received harsher language, then retrain it on the corrected set.
    2. B.Replace the subjective trait instruction with behavior-based criteria that require quoted evidence from the notes, then rerun the name-swapped notes and compare trait wording by gender.
    3. C.Expand the evaluation set with more women's summaries until group sizes match, then rerun the name-swapped notes and compare trait wording by gender on the larger set.
    4. D.Move the summarization step to a larger Claude model tier and keep the template as written, then rerun the name-swapped notes and compare trait wording by gender.
    Show answer & explanation

    Correct answer: B — Replace the subjective trait instruction with behavior-based criteria that require quoted evidence from the notes, then rerun the name-swapped notes and compare trait wording by gender.

    • A. Cleaning labels and retraining applies to training-data bias in a separate scoring model. The summaries here come from Claude following a template instruction, and identical notes shift with the name alone, so the loaded instruction is the cause and stays in place.
    • B. Correct. Identical notes produce different language when only the name changes, and the template asks for subjective, trait-based judgments. Behavior-based criteria tied to quoted evidence remove that cue, and name-swapped reruns verify the change.
    • C. Equalizing group sizes in the evaluation set only makes the measurement more representative. The template still prompts for the same trait language, so the same gap would appear on the larger set and nothing about the outputs changes.
    • D. A larger model tier given the same template still receives the same loaded instruction to flag abrasive or difficult employees and is likely to follow it. Changing tier does not address the prompt framing that produces the gap.

    6: Stakeholder Communication and Lifecycle Management

    6.1: Unsupportable Commitments in Requirements and SLAs

    30.A document-processing SLA draft commits to "50,000 documents per hour at all times." Your Claude API organization is on a rate limit tier whose limits cannot sustain that volume at the measured tokens per document. Which two actions make the throughput commitment supportable? Choose two.(Select 2)

    1. A.Check the SLA figure against the organization's tier limits and measured token cost per document, then request higher limits or lower the promised volume.
    2. B.Route non-urgent documents through the Message Batches API and give that path its own turnaround target, apart from the real-time figure.
    3. C.Keep the 50,000 per hour figure and retry 429 responses with exponential backoff, so queued requests drain once each limit window resets.
    4. D.Issue separate API keys to each worker pool and spread traffic across them, so each pool draws on its own per-key rate limit allowance.
    5. E.Trim the system prompt and cap max_tokens on responses, so each request uses fewer tokens and the 50,000 per hour figure fits the limits.
    Show answer & explanation

    Correct answers: A, B — Check the SLA figure against the organization's tier limits and measured token cost per document, then request higher limits or lower the promised volume.; Route non-urgent documents through the Message Batches API and give that path its own turnaround target, apart from the real-time figure.

    • A. Correct: the draft needs to be checked against the real capacity, meaning the organization's tier limits and the measured token cost per document. Higher limits or a smaller promised volume then tie the SLA to throughput that actually exists.
    • B. Correct: the Message Batches API suits work that is not time-sensitive, and a separate turnaround target for that path splits the promise into real-time and bulk parts. This takes bulk volume off the real-time rate limit path.
    • C. Incorrect: exponential backoff absorbs short bursts of 429 responses but cannot lift sustained throughput above the limit. Because the limits cannot sustain the required volume, the backlog keeps growing and the hourly figure is missed.
    • D. Incorrect: rate limits are enforced for the organization as a whole, not per key, so additional keys draw on the same allowance and add no capacity. The throughput gap remains and key management gets more complicated.
    • E. Incorrect: a shorter prompt and capped output trim some tokens per request, but they do not close the structural gap between the volume promised and what the tier allows. It is a tuning step and does not make the SLA figure supportable.

    6.3: Operational Handoff Completeness

    31.A retail company is about to double traffic to a Claude-powered assistant by launching in a new region. The handoff package to site reliability describes the prompts and tools but is silent on capacity. Peak-hour requests are expected to hit API rate limits. Which two additions to the package close the gap? Choose two.(Select 2)

    1. A.A load model listing the assumed peak requests and tokens per minute beside the organization's current limits, and the owner who requests an increase
    2. B.A sizing sheet listing the context window and maximum output tokens per request against the longest conversations expected in the new region
    3. C.A runbook entry covering 429 handling in the client: backoff that follows the retry-after header, a bounded queue, and a defined degrade path
    4. D.A prompt-tuning guide listing ways to trim the system prompt and tool descriptions, with a target token count for each request type
    5. E.A cost forecast listing projected monthly token spend at doubled traffic against the current budget, and the owner who approves an overage
    Show answer & explanation

    Correct answers: A, C — A load model listing the assumed peak requests and tokens per minute beside the organization's current limits, and the owner who requests an increase; A runbook entry covering 429 handling in the client: backoff that follows the retry-after header, a bounded queue, and a defined degrade path

    • A. Setting the assumed peak requests and tokens per minute against the organization's current limits, and naming the owner who requests an increase, gives site reliability the missing capacity assumption and a named owner for acting on it.
    • B. Context window and maximum output tokens are per-request ceilings. The expected problem is the per-minute request and token rate limits at peak, which this sheet does not size or compare to the organization's limits.
    • C. Throttled calls return 429 responses. A runbook entry for retrying with backoff that follows the retry-after header, queueing within a bound, and degrading gracefully tells operators how the system behaves when peak traffic hits the limits.
    • D. Trimming prompts can lower tokens per request, but it is an optimization rather than a capacity statement. It does not compare the doubled load to the limits, name an owner for raising them, or say what happens when requests are throttled.
    • E. Spend and budget approval concern cost. Rate limits cap throughput per minute regardless of budget, so this forecast neither shows whether peak load fits the limits nor describes how to handle throttling.

    6.2: Architecture Decision Records

    32.An ADR selects Claude Opus with extended thinking for a live-chat agent-assist feature. The support director's constraint is that suggested replies must appear within 3 seconds at p95 during peak hours. The draft says only: "Opus meets the latency target." Which revision best addresses the constraint?

    1. A.Reword the constraint in the Context section as a 10-second p95 target, and cite the accuracy gain from extended thinking as the reason for loosening it.
    2. B.Add a p95 figure from a peak-concurrency load test, state whether it is under 3 seconds, and name a smaller-model fallback with its quality cost.
    3. C.Add the p95 latency from a single-user pilot run off-peak, state that it is under 3 seconds, and note that peak traffic should stay close to that figure.
    4. D.Enable response streaming and add that the first tokens of a suggestion reach the agent within 3 seconds, keeping Opus as the only choice for the feature.
    Show answer & explanation

    Correct answer: B — Add a p95 figure from a peak-concurrency load test, state whether it is under 3 seconds, and name a smaller-model fallback with its quality cost.

    • A. The 3-second p95 limit was set by the support director, and an ADR author cannot loosen it to fit the chosen model. The accuracy benefit may be worth a trade-off, but that has to be proposed and agreed, not written in as a new requirement.
    • B. Correct. The draft asserts a result without evidence. Measuring p95 under peak concurrency tests the exact percentile and load the director set, and it records an honest pass or fail. A named smaller-model fallback with its quality cost makes the trade-off explicit.
    • C. A single-user run off-peak does not reflect contention at peak hours, so even its p95 says little about peak behavior. Expecting peak latency to stay near it is an assumption, and tail latency usually grows faster than typical latency under load.
    • D. Streaming can improve perceived responsiveness, but this is still an assertion with no measurement at p95 under peak load. Extended thinking runs before the visible answer, so the first tokens may arrive later than claimed. Dropping any fallback leaves no plan if the limit is missed.

    7: Developer Productivity and Operational Enablement

    7.2: Agent SDK and Claude Code Configuration

    33.A platform owner lets engineers run a long Agent SDK repository audit on a model that delegates to subagents heavily. Finance wants a hard bound on nesting, simultaneous subagents and total spend, enforced however Claude chooses to delegate. Which approach does that?

    1. A.Set subagent depth and concurrency limits through environment variables in the `env` option, and pass `maxBudgetUsd` as a query option.
    2. B.Write the depth, concurrency and spend limits into the system prompt and each `AgentDefinition` prompt, then check the cost reports after each run.
    3. C.Set `maxTurns` as a query option and on each `AgentDefinition`, and add a `PreToolUse` hook that records each subagent launch in a log file.
    4. D.Leave `Agent` out of each `AgentDefinition` `tools` list to stop subagents launching further ones, and cap spend with `maxBudgetUsd`.
    Show answer & explanation

    Correct answer: A — Set subagent depth and concurrency limits through environment variables in the `env` option, and pass `maxBudgetUsd` as a query option.

    • A. Correct: environment variables in `env` limit how deep subagents nest and how many run at once, and `maxBudgetUsd` caps spend. Claude Code enforces all three itself, whatever delegation pattern Claude picks, and at the budget it refuses new subagents and ends the query.
    • B. Incorrect: limits written into prompts only guide the model and nothing enforces them, so Claude can still nest deeper, launch more subagents or spend more. Cost reports after each run reveal overspend but cannot prevent it.
    • C. Incorrect: `maxTurns` limits the turns of an individual agent, not how many subagents exist or run together, and several can be launched within one turn. A hook that only records launches observes delegation without limiting nesting, concurrency or spend.
    • D. Incorrect: leaving `Agent` out of the subagents' tool lists stops them spawning further subagents and `maxBudgetUsd` caps spend. Nothing limits how many subagents the main agent starts at the same time, so the bound on simultaneous subagents is missing.

    7.3: Accountability for AI-Generated Code

    34.A company wants to let Claude Code changes to documentation merge automatically to speed up work, while keeping review for application code. What should the team establish first before enabling that exception?

    1. A.Define which documentation directories qualify using CODEOWNERS and branch protection rules, and require human approval on the remaining paths.
    2. B.Enable auto-merge on the repository and require passing CI checks, with the test suite standing in for human review of application code.
    3. C.Run a two-week trial where Claude Code merges its own changes to main across the repository, then audit how many needed correction afterwards.
    4. D.Add a CLAUDE.md rule telling Claude to merge changes it judges documentation-only directly to main, and to ask for review on the rest.
    Show answer & explanation

    Correct answer: A — Define which documentation directories qualify using CODEOWNERS and branch protection rules, and require human approval on the remaining paths.

    • A. Correct: listing the qualifying directories in CODEOWNERS and branch protection puts the exception in enforceable repository rules. Documentation paths can merge without a human gate, and application paths still need approval.
    • B. Incorrect: passing CI shows the tests succeed, not that a person reviewed the change. Repository-wide auto-merge with tests as the only gate removes human review from application code, which was meant to stay.
    • C. Incorrect: a trial with merge rights over the whole repository exposes application code to unreviewed changes while the team collects data. The scope of the exception can be defined in advance, so the trial adds risk without being a prerequisite.
    • D. Incorrect: a CLAUDE.md rule is guidance the agent follows, not an enforced control, and it leaves the agent classifying its own changes. A misjudged change would merge to main with no human check, since nothing in the repository's rules limits it to documentation.

    7.1: Packaging and Distributing Claude Code Workflows

    35.Which two statements about the contents of a Claude Code plugin are accurate? Choose two.(Select 2)

    1. A.A skill in `skills/review/` of a plugin named `my-plugin` is invoked as `/my-plugin:review`, namespaced by the plugin name.
    2. B.A `CLAUDE.md` at the plugin root is read into context when the plugin is enabled, so standing instructions ship as plain Markdown.
    3. C.A plugin's hooks are registered when one of its skills or commands is first invoked, and then stay active for the rest of that session.
    4. D.A plugin needs a `.claude-plugin/plugin.json` manifest to be loaded, so components in a directory without one are skipped.
    5. E.A plugin ships its standing instructions as a skill, since a `CLAUDE.md` at the plugin root is not read into context when the plugin is enabled.
    Show answer & explanation

    Correct answers: A, E — A skill in `skills/review/` of a plugin named `my-plugin` is invoked as `/my-plugin:review`, namespaced by the plugin name.; A plugin ships its standing instructions as a skill, since a `CLAUDE.md` at the plugin root is not read into context when the plugin is enabled.

    • A. Plugin skills are namespaced as `/<plugin>:<directory>`, so `skills/review/` in `my-plugin` becomes `/my-plugin:review`. This keeps same-named skills from different plugins from colliding.
    • B. Claude Code does not read a `CLAUDE.md` at a plugin root into context, and plugin validation warns about it. Instructions shipped this way would silently have no effect.
    • C. Plugin hooks are registered when a session loads the plugin and fire on their configured events from then on. Invoking one of the plugin's skills or commands is not a precondition, so a matcher is what limits when a hook runs.
    • D. The manifest is optional, and only `name` is required inside it when one exists. Claude Code loads a plugin's components from a directory that has no manifest.
    • E. A `CLAUDE.md` at a plugin root is not read into context, so a plugin delivers standing instructions as a skill. A rule that has to be enforced on every occasion belongs in a hook instead.

    Want the full experience?

    These are just samples. Practice the full Anthropic Claude Certified Architect – Professional (CCAR-P) - December 7 onwards question bank in quiz mode — free, no signup, with domain practice and exam simulation.