Claude Certified Architect - Professional (CCAR-P) Exam Questions

Domain 1: Solution Design and Architecture (17%)

A company wants Claude to help with accounts-payable intake from emailed invoices and notes. Existing software already validates supplier records and catches duplicate invoice numbers, and finance staff must keep payment approval authority. Claude should be used only where language understanding adds value. Which design is scoped best?

⬜ Let Claude interpret invoices, validate suppliers, and approve payments with no separate application control or finance review.
⬜ Use Claude to interpret ambiguous invoice details, keep the existing deterministic checks, and leave final payment approval with finance.
⬜ Replace the intake process with an autonomous agent that interprets invoices, decides on payment, and initiates it without finance approval.
⬜ Keep the existing software for everything and stop Claude from reading unstructured notes or unusual invoice wording.

An architect split a modernization assessment into one subagent per file section and system export. Many subagents repeat the same context and produce overlapping recommendations, leaving the coordinator to reconcile hundreds of fragments. Some analyses truly depend on each other; others are independent. What should the architect do?

⬜ Add more source-specific subagents and have the coordinator reconcile all overlaps once every analysis finishes.
⬜ Run every current subtask sequentially so overlapping scopes can’t conflict, even where there’s no dependency.
⬜ Redefine subtasks around cohesive architecture concerns with authoritative sources, keeping only the dependencies and handoffs that really exist.
⬜ Put every source into one large prompt and ask for the full modernization plan in a single step.

A global company must assess hundreds of applications for a data-center migration. Security, dependency, cost, and compliance analyses can often run independently, but the final recommendation must keep its evidence and resolve conflicting findings. The company wants parallelism without duplicated assessments or lost accountability. Which three controls should the architect include? (select three)

⬜ Give each specialist a distinct domain, bounded evidence, and a non-overlapping deliverable that the coordinator checks before synthesis.
⬜ Run assessments concurrently only when their inputs and conclusions don’t depend on another specialist’s output.
⬜ Have the coordinator resolve conflicts, keep source traceability, and escalate unresolved migration risks to an accountable person.
⬜ Give every specialist the same broad tools and have each one write a complete migration recommendation for every application.
⬜ Use one shared conversation so every specialist can see all intermediate results from every other agent.
⬜ Accept the first finished specialist report as final and cancel the rest to save time and cost.

A regulator receives applications with structured fields and supporting documents. Claude must recommend whether each one needs additional review, but recommendations must rest on current rules, no final decision may be automated, and reviewer corrections should improve the system. Auditors need evidence for every recommendation. Which architecture fits best?

⬜ Send each application straight to Claude and keep only the final recommendation and its citations as the audit record.
⬜ Validate the documents and store Claude’s recommendation, then let reviewers correct bad decisions after downstream processing.
⬜ Validate inputs and retrieve the governing clauses, generate a cited recommendation, run deterministic checks, and require reviewer approval with recorded feedback before disposition.
⬜ Make every eligibility decision with rules and use Claude only to reword decisions that have already been approved.

An insurer runs a nightly claims batch that has to be ready before adjusters start work. During seasonal peaks, there isn’t enough capacity to finish both the required claim classification and optional narrative summaries by morning. No claim may be lost, and classification must be available first. Which graceful-degradation strategy should the architect recommend?

⬜ Prioritize the required classification and queue the optional narratives until capacity frees up, keeping every deferred request and its state.
⬜ Retry every unfinished request immediately at maximum concurrency until both outputs finish together.
⬜ Drop claims that exceed the latency budget and have operations staff find the missing records by hand.
⬜ Send all peak traffic to the most capable model and accept slower completion to protect narrative quality.

A company is building an employee support assistant for payroll, benefits, access, and travel. Each category has a documented resolution workflow, approved data sources, and specific actions that need authorization. Unsupported requests must go to a human specialist. Which architecture gives the needed flexibility with the least unnecessary autonomy?

⬜ One autonomous agent with access to every employee system, free to invent a resolution path for any request.
⬜ A single augmented call that receives all employee records and performs whatever the user asks.
⬜ Separate agents for each category, all invoked on every request.
⬜ Route each request into its predefined workflow with scoped tools and deterministic approvals, and escalate unsupported cases to a specialist.

A compliance team must turn a long regulatory dossier into a normalized control catalog. Requirements point to definitions and exceptions elsewhere in the document, and cross-references must be validated before the catalog is final. A single large prompt has produced omissions and inconsistent terminology. Which decomposition is most appropriate?

⬜ One request that transforms the whole dossier and validates all citations before publishing.
⬜ Controlled stages for extraction, normalization, cross-reference validation, and final synthesis, passing structured output between steps.
⬜ Agents assigned to page ranges whose outputs are concatenated, with another model inferring the missing cross-references.
⬜ An autonomous agent that picks its own sequence and approves the catalog without independent validation.

A financial-services company reviews loan exception requests with Claude. Every request goes through the same ordered stages: extract facts, compare with policy, draft a recommendation, and get human approval before the case is updated. Auditors need reproducible paths and evidence at each stage, and unusual cases may go to a specialist. Which architecture fits best?

⬜ A deterministic workflow that sequences Claude calls and policy checks, captures evidence at each stage, and requires human approval before any update.
⬜ One augmented call holding all policies, updating the case directly whenever it recommends approval.
⬜ An autonomous agent with broad tools that chooses a different review path for each request.
⬜ Several specialist agents run in parallel on every case, with their recommendations combined into the decision.

A customer assistant must meet a strict response-time target for routine questions while keeping answer quality high on complex account issues. There’s a fixed cost budget per conversation and a large stable policy prefix sent every time. Testing shows no single model configuration works best for every request type. What should the architect recommend?

⬜ Use the most capable model for everything and accept the higher latency and cost.
⬜ Use the fastest model for everything and drop retrieval so routine answers stay inside the target.
⬜ Stream every response and treat faster first rendering as proof the service objective is met.
⬜ Route routine requests to an evaluated efficient model, escalate complex ones, cache the stable prefix, and measure every budget.

A research system gives market, legal, technical, and financial analysis to specialist agents. The coordinator keeps receiving contradictory conclusions, missing citations, and incompatible report formats, and its final synthesis hides unresolved disagreements. The specialists need to keep separate contexts and expertise. Which two design changes should the architect make? (select two)

⬜ Give every specialist all the source material, the other roles’ instructions, and the full synthesis guidance.
⬜ Replace the team with one unrestricted agent that researches everything and publishes without review.
⬜ Require structured specialist outputs that state each claim with its sources and confidence, and flag unresolved conflicts for the coordinator.
⬜ Have the coordinator pick the majority view whenever specialists disagree, even if the evidence favors the minority.
⬜ Add a verification stage that checks cited evidence and resolves cross-domain contradictions before the final synthesis.

An enterprise knowledge assistant answers employee questions from a frequently updated policy repository. The company wants reviewer feedback to improve future releases without letting users edit production prompts, and teams must tell retrieval failures from generation failures and measure whether updates improve cited answers. Which two components should the architect add? (select two)

⬜ Capture reviewer-labeled retrieval and generation failures and add representative cases with expected evidence to a versioned evaluation set.
⬜ Track source coverage, citation support, and escalation outcomes for every deployed version of the knowledge base.
⬜ Let users edit the production system prompt whenever an answer looks incomplete.
⬜ Keep only thumbs-up totals, without failed queries, retrieved passages, or reviewer reasons.
⬜ Retrain the model after every negative rating without separating retrieval from generation problems.

A manufacturer needs to compare supplier contracts across four jurisdictions. Clauses are organized differently in each, and obligations like data residency, termination, and subcontracting often span several sections. Legal wants both clause-by-clause comparisons and a reliable view of cross-cutting obligations. Which decomposition supports this best?

⬜ Split every contract into equal token blocks and compare blocks in the same position.
⬜ Summarize each contract on its own and compare only the summaries.
⬜ Analyze coherent clause families first, then run a separate cross-cutting obligation pass, then synthesize the jurisdiction comparison.
⬜ Give each jurisdiction its own agent and forbid analysis across headings, even when an obligation spans sections.

A maintenance organization is designing an assistant that proposes likely causes of equipment failures. It must use approved manuals and current telemetry, show technicians the evidence it used, and get better after confirmed repairs. Safety policy says a technician must approve every repair instruction. Which end-to-end design fits best?

⬜ Fine-tune on historical repairs and let the model issue instructions without checking current telemetry.
⬜ Ground each diagnosis in approved manuals and live telemetry, show technicians the evidence before they approve, and feed confirmed repair outcomes back into future recommendations.
⬜ Retrieve the manuals and publish the first suggested repair right away, tracking only latency.
⬜ Have technicians approve retrieved passages before Claude sees them, and discard repair outcomes.

A procurement group researches unfamiliar technology vendors across changing markets, regulatory databases, product documentation, and customer references. The research path can’t be planned in advance, because each finding decides the next source. A procurement committee must make the final call, and research spend is capped. Which architecture fits best?

⬜ A constrained research agent limited to approved sources and a fixed budget, logging its evidence and leaving the decision to the committee.
⬜ A fixed sequence of searches that runs the same way for every vendor and stops after a set number of sources.
⬜ An agent with unrestricted browsing and purchasing access that completes vendor selection on its own.
⬜ A single model call on the vendor’s website, with the committee checking unsupported claims afterward.

A publisher uses Claude to localize regulated product instructions into twelve languages. Terminology must come from an approved glossary, layouts must follow deterministic templates, and an editor must approve the final rendered document. The publisher also needs traceability from source text to release. Which two components should the architect include? (select two)

⬜ Have editors approve the English source once, then translate and publish every language automatically.
⬜ Translate with Claude using retrieved glossary terms, and keep the source and terminology evidence for each section.
⬜ Include the whole glossary in every request and accept any output that contains all mandatory terms.
⬜ Validate the layout deterministically after translation and send the rendered document to an editor before release.
⬜ Translate and format in one step, and sample documents only after publication.

An education provider wants Claude to help produce curriculum materials for hundreds of courses. Leaders expect productivity gains, but instructors remain accountable for accuracy and teaching quality, and there’s no evidence that fully automated publishing is safe. The architect must show measurable value before scope grows. Which rollout fits best?

⬜ Start with instructor-reviewed drafting, measure the revision effort it saves and whether instructors adopt it, and expand only once the results show value.
⬜ Automate drafting and publishing for every course now, removing courses that draw complaints.
⬜ Limit Claude to private brainstorming lists so nothing enters instructor workflows.
⬜ Auto-publish drafts for low-enrollment courses and review only popular ones.

A pilot assistant that summarizes clinician intake notes shows strong technical results: low latency, high accuracy, and acceptable cost per request. Executives now ask why they should pay for a production rollout. What should the architect’s business case emphasize?

⬜ Benchmark scores showing the model beats competitors at summarization.
⬜ Token savings achieved during the pilot through prompt caching.
⬜ The measured reduction in clinician documentation time compared with a baseline taken before the pilot.
⬜ How sophisticated the agentic architecture is and how advanced the model tier is.

A permit-processing pipeline uses Claude to extract application data into structured records that a downstream system ingests automatically. Incomplete records sometimes reach that system and cause ingestion failures hours later. Which architectural change addresses this most directly?

⬜ A nightly reconciliation job that finds and reruns failed ingestions.
⬜ A higher output limit so extraction responses are never cut short.
⬜ The most capable model tier, to make output more reliable.
⬜ Validate each output for completeness before handoff, retrying or flagging any that fail.

A team uses Claude to write plain-language summaries of insurance policies. The quality criteria are clearly defined, and drafts measurably improve when they’re critiqued against those criteria and then revised. Which architectural pattern fits best?

⬜ A single call with the evaluation criteria embedded as few-shot examples.
⬜ An autonomous agent with tools that plans its own revision approach per document.
⬜ Parallel voting that generates several drafts and keeps the highest-scoring one.
⬜ A loop where one call writes the draft and a second call evaluates it and returns feedback.

A team is choosing an orchestration approach for a new multi-step Claude solution. Which two choices correctly apply the parallelization pattern? (select two)

⬜ Run independent subtasks at the same time to cut end-to-end latency.
⬜ Order the steps so each one uses the previous step’s output.
⬜ Have a coordinating model work out the needed subtasks for each request.
⬜ Run the same task several times and aggregate the different outputs for higher confidence.

A team is designing a system for complex code-change requests. The number of files to change and the supporting analyses needed can’t be listed in advance and differ for every request. Which orchestration pattern fits best?

⬜ An orchestrator that breaks each request into subtasks, delegates them to workers, and synthesizes the results.
⬜ Parallelization that runs a predefined set of independent subtasks and merges the outputs.
⬜ An evaluator-optimizer loop where one model drafts changes and another critiques them.
⬜ A prompt chain that sends every request through the same fixed sequence of steps.

A team’s multi-turn assistant calls the Messages API directly. Users say it forgets details they mentioned earlier in the same conversation, and a review shows each request contains only the latest user message. What fixes this most directly?

⬜ Store the conversation history in the application and resend the earlier turns with each request.
⬜ Enable extended thinking so the model reasons over earlier exchanges.
⬜ Enable prompt caching so the API keeps earlier turns between requests.
⬜ Switch to a model with a larger context window.

A team must generate summaries for 250,000 archived documents on a recurring schedule. Nobody waits interactively for any single result, and lowering per-document cost is a priority. Which approach fits these requirements best?

⬜ Submit each run asynchronously through the Message Batches API.
⬜ Move to the most capable model tier so summaries never need rework.
⬜ Enable prompt caching on each document’s content to lower its token cost.
⬜ Run synchronous requests in parallel with aggressive retries.

A team generates regulatory filings with Claude. Compliance reviewers must inspect and approve each intermediate analysis before the final document is produced. The model already handles the full reasoning well in a single call. Which design best meets the review requirement?

⬜ Enable extended thinking so reviewers can read the reasoning before the answer.
⬜ Delegate the analysis to a subagent that reports back in the same turn.
⬜ Keep the single call and ask the model to include its full analysis in the output.
⬜ Chain the work as sequential API calls, exposing each step’s output for approval before the next.

A single Claude call doing a long, multi-part analysis skips required subtasks, and its reasoning gets noticeably shallower in later sections. Which two changes address these failures most directly? (select two)

⬜ Break the task into sequenced subtasks, each given only the context it needs.
⬜ Lower the temperature so repeated requests stop varying in wording.
⬜ Run the subtasks as separate chained calls, passing structured output between steps.
⬜ Enable prompt caching so the large static prefix is reused on every request.

A team is automating invoice processing. Invoices arrive as unstructured supplier emails and must be validated against purchase orders before payment. Which two responsibilities belong in the Claude-based component? (select two)

⬜ Recalculating extracted line totals and tax to confirm the amounts add up.
⬜ Extracting line items and payment terms from free-text supplier emails.
⬜ Applying the fixed rules that match each invoice to its purchase order.
⬜ Drafting clarification messages to suppliers when an invoice is ambiguous or disputed.

A team is designing a Claude solution for complex multi-step legal reasoning. The executive sponsor wants to commit to the most capable frontier model from day one to avoid rework. What should the architect recommend?

⬜ Start with a capable standard-tier model and move up only if evaluations show a shortfall.
⬜ Adopt the frontier model immediately, since complex reasoning always justifies maximum capability.
⬜ Standardize on the fastest, cheapest tier so spending stays predictable.
⬜ Alternate requests between two tiers to hedge against either one underperforming.

A document-localization feature translates and summarizes files in a single Claude call and consistently meets its quality and latency targets. An engineer proposes rebuilding it as five sequential chained calls, citing decomposition best practice. What should the architect advise?

⬜ Adopt the chain now so the pipeline is easier to extend later.
⬜ Rebuild it as a supervisor agent delegating each step to a specialist agent.
⬜ Keep the single call, and decompose only if quality or control needs actually appear.
⬜ Split the task across parallel subagents to offset the added latency.

A property insurer is defining success criteria for a Claude solution that triages inbound claims. Which two criteria measure business value most directly, rather than technical activity? (select two)

⬜ The share of claims triaged within the committed response SLA.
⬜ The model’s score on a widely cited public reasoning benchmark.
⬜ Peak token throughput during the busiest processing hour.
⬜ Cost per claim handled, compared with the pre-launch baseline.

A drafting feature will use a self-correction pattern: write a draft, review it against criteria, then refine. Which two things does running each stage as a separate API call let the team do? (select two)

⬜ Log and evaluate each stage on its own against its own criteria.
⬜ Use fewer tokens overall than doing all three stages in one call.
⬜ Guarantee that the refined output meets every review criterion.
⬜ Branch on the review result, for example skipping refinement when the draft passes.

A team handles inbound customer messages in three clear categories: billing disputes, outage reports, and plan changes. Each needs different instructions and tools, messages can be classified accurately up front, and a single generalist prompt performs poorly on all three. Which pattern fits best?

⬜ Run all three specialized handlers on every message in parallel and keep the best output.
⬜ Use an orchestrator model that breaks each message into dynamically chosen subtasks.
⬜ Keep one generalist prompt and add more few-shot examples for every category.
⬜ Add a classification step that routes each message to a category-specific prompt and tool set.

A team runs two Claude workloads: interactive customer queries with a committed response-time SLA, and nightly summary reports with no urgency. Leadership wants lower inference costs without breaching the SLA. Which recommendation balances cost and the performance commitment best?

⬜ Batch the nightly reports and keep the interactive queries synchronous.
⬜ Put both workloads through batch processing to get the most discount.
⬜ Renegotiate the SLA so interactive traffic can also be batched.
⬜ Move both workloads to the smallest model tier to cut token spend.

A pipeline sends scanned forms, forwarded emails, and spreadsheet exports to Claude in raw form, and output quality varies widely by source. Which two input-stage changes improve reliability most directly? (select two)

⬜ Validate incoming content and flag malformed or unreadable inputs before processing.
⬜ Raise max output tokens so responses to messy inputs are never cut off.
⬜ Preprocess each source into a consistent, structured format before the model call.
⬜ Switch to the most capable tier so it can handle any raw input.

A public library uses Claude to write a short catalog note for each new book by summarizing the publisher’s description, with the library’s subject-heading guidelines supplied as context. Requirements are stable, and prototype quality has been acceptable. Which architectural pattern fits best?

⬜ An orchestrator that hands summarization subtasks to specialist worker calls.
⬜ A single augmented LLM call with the guidelines supplied as context.
⬜ An autonomous agent that plans its own steps and tool use for each book.
⬜ A multi-step chained workflow with a validation gate between each call.

A publishing company reviews its Claude initiatives against business value pillars. Which two outcomes belong to the transformation pillar rather than incremental efficiency or cost savings? (select two)

⬜ Cutting per-request inference spend by enabling prompt caching on repeated content.
⬜ Redesigning the editorial workflow around capabilities the company couldn’t offer before.
⬜ Reducing average turnaround on the existing proofreading process by about 30 percent.
⬜ Launching a personalized manuscript advisory service that wasn’t practical at the needed scale before.

A team runs an autonomous agent that loops through planning, tool calls, and observation to resolve infrastructure tickets. Some runs go down unproductive paths and keep iterating, running up cost with nothing to show. Which safeguard contains this risk most directly?

⬜ Replace the loop with one large call that contains every instruction up front.
⬜ Enforce a maximum iteration limit, with human review checkpoints at key milestones.
⬜ Give the agent more tools so it finds productive paths sooner.
⬜ Move the agent to the most capable tier to reduce mistakes per step.

A game studio’s coding agent delegates almost every step to subagents, including short sequential refactoring edits where each step depends on the one before. End-to-end latency has grown, and subagents keep missing context from earlier steps. What should the architect recommend?

⬜ Use subagents for parallel work or isolated context, and run dependent steps directly in the main agent.
⬜ Split the work further so each subagent gets an even smaller slice.
⬜ Move every subagent to the most capable tier so the context gaps get filled.
⬜ Forward the whole conversation history to each subagent before it starts.

A grant-review pipeline splits each application into equal-sized chunks, runs the same full prompt (extract details, check eligibility, assess merit, draft a recommendation) on every chunk, and merges the results. Merit assessments contradict each other, and eligibility rules that span chunk boundaries get missed. What should the architect recommend?

⬜ Run the chunks in parallel and add a final call to reconcile contradictions.
⬜ Overlap adjacent chunks so boundary-spanning rules appear in both.
⬜ Decompose by subtask into sequential steps, each working on the whole application.
⬜ Increase the chunk size so fewer boundaries cut through eligibility rules.

---

Domain 2: Claude Models, Prompting and Context Engineering (13%)

A policy team uses Claude to classify requests into categories whose definitions overlap. A clear zero-shot instruction handles typical requests but gives inconsistent labels on boundary cases, though the output format is stable. The team has reviewed examples of correct edge-case decisions. What prompting change should the architect recommend?

⬜ Use the highest reasoning effort on every request and leave the definitions and zero-shot instruction unchanged.
⬜ Stay zero-shot and repeat each category label several times so Claude weighs the names more heavily.
⬜ Add varied few-shot examples covering the overlapping categories and boundary cases, then evaluate the revised prompt on representative requests.
⬜ Have Claude write out its reasoning for every request and treat longer explanations as evidence the label is right.

A document platform handles both routine field extraction and complex risk analysis. The company wants lower cost and latency, but complex analyses must keep meeting a strict expert-reviewed quality bar, and document length doesn’t reliably indicate how hard a document is. Which two actions should come before introducing model routing? (select two)

⬜ Build a labeled evaluation set for both task types with separate quality, latency, and cost thresholds for each.
⬜ Route by document length alone, since longer inputs always need the most capable model.
⬜ Use the most capable model for everything until production volume shows the cost can’t be sustained.
⬜ Send straightforward extraction to an evaluated efficient model and escalate to a stronger model whenever the selected one misses its threshold.
⬜ Choose models from public benchmark rankings and skip workload-specific evaluation to ship faster.

A service classifies millions of short support messages into a few stable categories. Responses must be fast and cheap, the company has representative labeled examples, and the task needs no tools or complex reasoning. Which model-selection strategy fits?

⬜ Start with a fast, low-cost model and evaluate it on representative data, moving up only if quality misses the release threshold.
⬜ Pick the most capable model right away, since any accuracy gain always justifies the cost.
⬜ Pick the cheapest model without evaluating it and add examples until errors disappear.
⬜ Send each message to several models and use the majority label.

A regulated extraction service produces inconsistent structured records from uploaded forms. The prompt repeats output rules in the system message, user template, and examples, and some of those rules conflict when optional fields are missing. Stable policy instructions must be kept, and malformed results rejected. Which redesign fits best?

⬜ Add more prose examples to each request while keeping the conflicting rules in several places.
⬜ Put policies, source documents, examples, and validation feedback together in one growing system prompt.
⬜ Move every instruction into the user message and let the uploaded document decide which rules apply.
⬜ Separate the stable policy instructions from clearly delimited source text, and define one output contract that the application validates deterministically.

An investigation agent can run for hours, accumulate large tool results, and resume after interruptions. Key decisions, cited evidence, and open tasks must survive, but quality drops when every raw result stays in the active context. Prompt caching is already on for the stable instructions. Which design gives the best continuity?

⬜ Keep every message and raw result in context so no detail is ever lost.
⬜ Clear the conversation whenever token use grows and ask Claude to rebuild earlier findings from memory.
⬜ Rely on prompt caching, since cached prefixes act as durable memory across sessions.
⬜ Use server-side compaction for in-session continuity, and store key decisions and evidence externally so task state can be restored after an interruption.

A benefits assistant explains coverage and can submit enrollment changes through a client tool. The system prompt holds the eligibility rules, but testing shows persuasive user text can lead Claude to propose changes that break them. Some changes affect employee cost and coverage immediately. Which two controls should the architect implement? (select two)

⬜ Add more eligibility rules to the prompt and execute changes whenever Claude’s explanation cites them.
⬜ Validate every proposed change against deterministic eligibility rules before the application lets the tool call run.
⬜ Log rejected and completed changes for later review without stopping unauthorized requests.
⬜ Give the assistant broad benefits permissions so missing scopes never interrupt users.
⬜ Limit the assistant to the actions it needs and require human approval before any change to cost or coverage takes effect.

An internal assistant answers from thousands of policy documents that change through the year. Loading the full corpus into every request is costly and slow, and very long prompts sometimes miss a decisive exception. Employees need answers grounded in current passages with traceable sources. Which context strategy fits best?

⬜ Load the whole corpus into every request so Claude can see every clause.
⬜ Retrieve only the relevant policy sections with their provenance, and keep the ability to fetch more evidence if needed.
⬜ Summarize the corpus once, discard the source sections, and answer from the summary.
⬜ Increase the context window and load everything without measuring retrieval quality or context use.

A global consulting firm produces recurring client-risk reports with Claude. Every report follows the same multistep method, uses approved templates, and runs a validation script, but those instructions should load only when that report is requested. Teams want one maintained package that works the same across supported Claude environments. Which reuse mechanism fits best?

⬜ Put the full method in every system prompt and keep a separate copy in each application.
⬜ Package the method, templates, and validation script as an Agent Skill that loads only for relevant reporting tasks.
⬜ Enable prompt caching and treat each cached prefix as the governed procedure.
⬜ Keep the method in conversation history and rely on compaction summaries to preserve it.

A facilities company wants Claude to inspect photos of equipment rooms alongside written maintenance notes and flag visible safety concerns. The model has to reason across images and text, fit the needed context, and respond within an interactive time target. Several models with different prices and capabilities are available. What should the architect do first?

⬜ Pick the cheapest text model and pass each photo’s filename instead of the image.
⬜ Pick the model with the largest context window without measuring image reasoning or latency.
⬜ Use the most capable model for everything and look at cost once traffic settles.
⬜ Shortlist models with the required vision and context capabilities, then evaluate their inspection accuracy against the latency target on representative cases.

A company generates proposals for several product lines. Every proposal shares legal policy, while product rules and customer facts vary independently and belong to different owners. Changing one product’s rules currently means editing and retesting one large monolithic prompt. Which prompt architecture is easiest to maintain?

⬜ One even larger prompt with all products, telling Claude to ignore the sections that don’t apply.
⬜ Product rules only in few-shot outputs, with explicit policy instructions removed.
⬜ Let sales teams rewrite the shared legal section per proposal to suit each product’s tone.
⬜ Assemble the prompt from separately versioned modules owned by the legal and product teams, with customer context managed separately, and evaluate every change before release.

A logistics company extracts customs declarations from unstructured shipping documents. The downstream system needs a fixed JSON schema, and legal rules decide which combinations of codes, dates, and values are allowed. Relying on prompt instructions alone is producing malformed fields and legally invalid combinations. Which design addresses this best?

⬜ Put every customs rule in the system prompt and accept a response whenever Claude says it’s valid.
⬜ Use schema-constrained structured outputs with clear examples, and enforce the customs rules with deterministic validation in the application.
⬜ Parse free-form prose with regular expressions and retry until every expected key appears.
⬜ Fine-tune on accepted declarations and drop downstream validation to cut latency.

A warranty-resolution agent runs many searches, inventory checks, and policy lookups before proposing an outcome. Repeated tool results and outdated availability data pile up, while customer commitments and open exceptions must stay visible. The long context is raising cost and leading the model to rely on stale facts. Which context strategy fits best?

⬜ Keep every tool result verbatim and move the system prompt to the end of the context.
⬜ Delete the conversation after every tool call and ask the customer to repeat their commitments.
⬜ Remove superseded tool results while keeping anything that still affects the decision, including commitments, open constraints, and the identifiers and evidence needed to act.
⬜ Cache the growing conversation indefinitely, assuming cached tokens can’t affect later decisions.

An audit firm is designing a prompt to produce plans across several entities, control areas, and evidence dependencies. The designers believe a longer reasoning trace will automatically be more accurate, but nobody has compared approaches on representative audits. The architect wants a structured decomposition and objective evidence that it helps. Which three actions should the architect take? (select three)

⬜ Generate one final plan and approve the prompt after a single good demo.
⬜ Break planning into explicit stages for entities and control areas, resolving evidence dependencies and gaps before the final synthesis.
⬜ Require every stage to name its supporting evidence and open gaps before its output can feed the next stage.
⬜ Compare the staged approach with direct prompting on representative audits, scoring coverage, accuracy, evidence quality, dependency handling, latency, and reviewer effort.
⬜ Require longer reasoning on every audit and treat extra detail as proof of better accuracy.
⬜ Use staging only when a reviewer feels an audit is hard, with no objective criteria.

A team is adding few-shot examples to a prompt so that output format and tone become more consistent. Which two practices match Anthropic’s guidance for effective examples? (select two)

⬜ Use about three to five examples that closely resemble the real use case.
⬜ Use one carefully chosen example to keep the prompt short.
⬜ Vary the examples enough to cover edge cases and unusual inputs.
⬜ Make all the examples nearly identical so the pattern can’t be misread.

A support assistant’s prompt template pastes the operator’s rules and the customer’s message together into one plain-text block. Now and then, instructions written into a customer message override the operator’s rules. Which template change reduces this risk most directly?

⬜ Repeat the operator rules right after the customer message on every request.
⬜ Put the customer message at the top of the prompt, above the operator rules.
⬜ Set temperature to zero so sampling favors the operator rules.
⬜ Wrap the customer message in delimiter tags and state that its contents are data, not instructions.

A team turns on prompt caching for a 150,000-token reference corpus, expecting cached tokens to stop counting toward the context window and free up room for longer conversations. Requests still fail with prompt-too-long errors as conversations grow. What should the architect recommend?

⬜ Move the corpus into the system prompt, since system content doesn’t count toward the window.
⬜ Cut the tokens sent per request with retrieval or compaction instead of relying on caching.
⬜ Add more cache breakpoints so each cached segment is excluded from the window.
⬜ Switch to the one-hour cache lifetime so cached tokens stay outside the window longer.

A classification pipeline asks Claude to reason step by step before giving a verdict. Accuracy improved measurably, but the reasoning is now mixed in with the verdict and breaks the downstream parser. Which prompt change keeps the accuracy gain and restores reliable parsing?

⬜ Lower the temperature so the model stops including reasoning.
⬜ Add few-shot examples showing verdicts with no reasoning at all.
⬜ Tell Claude to put its reasoning and its final verdict in separate, clearly tagged sections.
⬜ Remove the step-by-step instruction so the response contains only the verdict.

A document-processing assistant’s system prompt includes 10,000 tokens of compliance rules plus 20 specialized workflow guides, though each request usually needs just one guide. Per-request cost is high. Which restructuring cuts token cost best while keeping capability?

⬜ Cache the compliance rules as a stable prefix and load the needed workflow guide on demand.
⬜ Keep every guide in the prompt and cache the whole block behind one breakpoint.
⬜ Fine-tune a custom model on the guides so prompts no longer need them.
⬜ Summarize the compliance rules so every request carries a shorter static block.

A platform group must pick a Claude model tier for a new production feature that has defined quality targets and a strict cost budget. Which two practices should guide the choice? (select two)

⬜ Default to the most capable tier, since quality failures always outweigh compute costs.
⬜ Pick the most recently released model, since newer models win everywhere.
⬜ Compare cost per completed task, since a more capable model may finish in fewer turns.
⬜ Choose the cheapest model that meets the quality target, and confirm it with ongoing evaluation.

A long-running coding agent explores large codebases before making changes. It reads dozens of files that it needs only briefly, and the main conversation’s context fills up long before implementation begins. Which change protects the main context most directly?

⬜ Enable prompt caching on the explored file contents so they stop taking up context.
⬜ Move to a model with a bigger context window and keep the workflow the same.
⬜ Delegate exploration to a subagent that returns only a summary of what it found.
⬜ Add a system prompt instruction telling the agent to disregard files it has already read.

A voice assistant’s system prompt states output rules as bare prohibitions, like “never use ellipses” and “never use markdown.” The rules are well placed and well structured, yet Claude follows them inconsistently. Which prompt change is most likely to improve adherence?

⬜ Explain the reason behind the rules, for example that a text-to-speech engine reads the output aloud.
⬜ Repeat the full rule list at the end of every user message as well as in the system prompt.
⬜ Move the rules out of the system prompt into the first user message.
⬜ Switch to the most capable model, since adherence scales with capability.

A team evaluates a complex multi-step reasoning workload on a high-capability model. Scores fall just short of the quality target on the hardest cases, and moving to the top frontier tier would sharply raise costs. What should the team try before switching models?

⬜ Switch to the frontier tier now, since any shortfall proves the current model isn’t enough.
⬜ Raise the current model’s effort setting and rerun the evaluation suite.
⬜ Split traffic randomly between the current and frontier tiers to average quality and cost.
⬜ Lower the temperature so the model reasons through hard cases more carefully.

A team iterating on an agent caches its tool definitions, a long system prompt, and the growing conversation. Each time a developer edits one tool’s description, every cached segment misses on the next request, not only the tools. What should the architect recommend to restore cache reuse?

⬜ Use the one-hour cache duration so entries survive each editing cycle.
⬜ Add more cache breakpoints so an edit in one segment doesn’t clear the others.
⬜ Settle the tool definitions first, because they come first in the cached prefix and any change there invalidates everything after it.
⬜ Put the tool definitions after the conversation history to isolate their edits.

An application uses prompt caching on a large shared prefix but sees intermittent cache misses. Which two practices improve the hit rate most directly? (select two)

⬜ Reuse the same wording anywhere in the prompt, whatever its position.
⬜ Keep the prefix identical up to the cache breakpoint on every request.
⬜ Make sure reuse happens within the cache lifetime, or choose the longer cache duration.
⬜ Move all reusable content into the system prompt instead of the user messages.

An assistant’s system prompt contains emphatic directives such as “CRITICAL: You MUST use this tool,” added earlier to fix undertriggering. After moving to a newer Claude model, it now calls tools unnecessarily on simple requests. Which prompt revision best restores balanced behavior?

⬜ Lower the sampling temperature so the model applies the instructions more cautiously.
⬜ Replace the emphatic mandates with plain, conditional guidance on when each tool applies.
⬜ Add equally forceful counter-instructions against unnecessary tool calls.
⬜ Move the emphatic directives from the system prompt into each user message.

A team runs two endpoints: one does multi-step fraud-pattern analysis on claims, the other extracts three fields from a standardized form. Both prompts ask for step-by-step reasoning before the answer. The extraction endpoint’s latency and cost have gone up with no accuracy gain. What change fits best?

⬜ Lower the temperature on the extraction endpoint so the reasoning gets shorter.
⬜ Keep step-by-step reasoning for fraud analysis and remove it from field extraction.
⬜ Add more detailed reasoning instructions to extraction until accuracy improves.
⬜ Remove step-by-step reasoning from both endpoints so prompts stay uniform.

A prompt runs task instructions, background reference material, two worked examples, and the user’s variable input together as one block of prose. Claude sometimes follows text inside the worked examples as if it were an instruction. What fixes this most directly?

⬜ Lower the temperature so the model reads the prompt more literally.
⬜ Repeat the full task instructions again at the end of the prompt.
⬜ Remove the worked examples so their text can’t be misread.
⬜ Wrap each type of content in its own clearly labeled XML tag.

An agent workflow makes dozens of tool calls per session. Results from early steps are never used again, but they pile up until requests near the context limit. The team wants to remove only that stale tool output and leave the conversation messages intact. Which approach fits best?

⬜ Enable context editing to clear tool results that are no longer needed automatically.
⬜ Add a system prompt instruction telling the model to ignore earlier tool results.
⬜ Lower max output tokens so more of the window is left for tool results.
⬜ Enable prompt caching so processed tool results stop taking up the window.

A compliance reviewer objects to a proposed Claude deployment, arguing that the chosen model’s behavior could silently drift as Anthropic updates it, which would invalidate the team’s validation evidence. How should the architect respond?

⬜ Explain that a dated model snapshot ID pins fixed weights; changes in the serving stack can cause only minor variation.
⬜ Choose the most capable tier, since frontier models are updated less often than smaller ones.
⬜ Set temperature to zero so output is deterministic and can’t drift.
⬜ Schedule weekly full re-validation to catch silent in-place updates to the model’s weights.

A team packages its report-formatting procedures as a custom skill so they don’t have to repeat the instructions in every prompt. Claude rarely invokes the skill automatically, and users have gone back to pasting the instructions. The skill’s description lists only what it can do. What change is most likely to restore automatic invocation?

⬜ Shorten the skill’s instruction body so it loads faster.
⬜ Put the skill’s full instructions in every system prompt so they always apply.
⬜ Rewrite the skill’s description to say both what it does and when it should be used.
⬜ Raise the temperature so the model weighs the skill more heavily.

An application reuses a large, static system prompt with prompt caching on. Traffic comes in bursts separated by long quiet periods, so the cache expires and the first request after each lull pays full processing latency. What addresses this first-request penalty most directly?

⬜ Send scheduled warm-up requests that write the prompt to the cache before traffic resumes.
⬜ Add more cache breakpoints inside the prompt so cached segments outlast the expiry.
⬜ Send the first request after each lull to a smaller, faster model.
⬜ Shorten the system prompt so uncached requests finish faster.

A document-processing pipeline sends variable-length bundles to Claude, and some requests fail with a prompt-too-long error. The team wants to catch oversized inputs before sending so they can go to chunked processing instead. Which approach is most reliable?

⬜ Estimate size with a fixed four-characters-per-token rule on the input text.
⬜ Lower max_tokens so input plus output stays within the window.
⬜ Call the token counting API on each request before sending it.
⬜ Let the API trim the oldest content when the input is too long.

An assistant’s system prompt gets reworded every time a stakeholder reports a bad answer. Some edits fix one complaint while quietly breaking something else, and nobody can tell which version performs best. What should the architect put in place before any more prompt changes?

⬜ Few-shot examples covering every complaint raised so far.
⬜ A lower temperature, where supported, so outputs vary less between versions.
⬜ Clear success criteria and an empirical evaluation set for comparing prompt versions.
⬜ An upgrade to the most capable tier so the wording matters less.

A team designing an invoice-intake assistant needs image input and tool calling. The workload is high-volume and sensitive to latency and cost. The team plans to use the most capable model, believing smaller tiers don’t support these features. What should the architect recommend?

⬜ Add an external OCR step so a text-only lightweight model can handle requests.
⬜ Send image requests to the largest model and text requests to the smallest.
⬜ Evaluate the smaller, faster tiers as well, since vision and tool use are available across the model family.
⬜ Keep the most capable model, because image input is only available in the top tier.

---

Domain 3: Integration (19%)

A coordinator agent hands fulfillment investigations to inventory, shipping, and billing subagents, each of which calls internal tools. After a bad refund recommendation, operators can read isolated model and tool logs but can’t work out which delegation produced it. Latency and token dashboards look normal. Which observability change closes this gap most directly?

⬜ Keep only each agent’s final response and investigate discrepancies later through operator interviews and manual log review.
⬜ Record per-model token usage while leaving out identifiers that tie a request to a specific agent or tool call.
⬜ Store each tool error as a standalone event without recording which parent agent delegated it or consumed its result.
⬜ Carry one trace identifier from the coordinator through every downstream call so parent-child spans show how the recommendation was built.

An enterprise assistant has grown to 180 tools across finance, HR, sales, and engineering. Most users need fewer than ten, logs show Claude confusing similarly named operations, and security wants each session to get only the capabilities its work requires. What should the team implement first?

⬜ Route each request by role and expose only the small tool set that user’s approved workflow needs.
⬜ Keep the full catalog but replace precise tool descriptions with short generic summaries and one broad selection instruction.
⬜ Put every capability behind one execute-action tool that takes a free-form payload and works out the operation itself.
⬜ Keep all 180 tools loaded and instruct Claude to review the entire catalog before picking one.

A manufacturer is indexing technical manuals made up of chapters, procedures, warnings, tables, and version notes. Questions usually concern one procedure, but the right answer often depends on its section heading and a nearby warning. Manuals are updated by edition. What chunking strategy should the team start with?

⬜ Split at meaningful section boundaries with modest overlap, and attach hierarchy and edition metadata to every chunk.
⬜ Use uniform fixed-size chunks that ignore headings and editions so ingestion stays simple.
⬜ Embed each whole manual as a single vector and rely on document-level similarity.
⬜ Index only the section headings and return the entire manual when a heading matches.

Before drafting a reply, a support assistant fetches the account profile, open tickets, entitlement status, and service health. Traces show these four independent read-only calls running one after another and dominating response time, while answer quality is fine. Latency must drop without weakening data freshness or authorization. What should the architect recommend?

⬜ Move all traffic to the fastest model without first checking that answer quality stays above the threshold.
⬜ Run the independent read-only calls concurrently, and keep dependent or state-changing actions in their required order.
⬜ Raise the output token limit so Claude can plan every tool call in one turn.
⬜ Turn off streaming and wait for each full result before showing the user anything.

An incident-response agent connects to twelve MCP servers that together expose hundreds of infrastructure, ticketing, and messaging tools. Tool definitions eat a large share of the context, selection accuracy drops during urgent incidents, and responders shouldn’t get admin capabilities outside their assigned service. Which two changes best reduce tool bloat while keeping useful coverage? (select two)

⬜ Merge every server behind one admin MCP gateway that exposes all operations in each incident session.
⬜ Load every tool schema up front and rely on a larger context window to keep selection accurate.
⬜ Use tool search with deferred loading so only the tools discovered for the current incident enter the context.
⬜ Route incidents to role-specific agents that get allowlisted tools and credentials limited to the service under investigation.
⬜ Replace the typed MCP tools with prose instructions explaining how to call each service’s API.

A software provider runs a remote MCP server that lets corporate tenants read and update records in a third-party case-management API. The prototype forwards each client’s existing API token downstream unchanged and trusts a tenant ID passed in tool arguments. A security review finds the tokens may be valid for several services and that users could change the tenant ID. Which two changes should the architect recommend? (select two)

⬜ Use one shared downstream credential for all tenants and filter by tenant only after the records come back.
⬜ Issue tokens specifically for the MCP server, validate their claims, and use separate server-side credentials for the downstream API.
⬜ Tell Claude to compare the tenant argument with the organization named in the user’s prompt before each call.
⬜ Derive tenant scope from the authenticated identity and enforce authorization for each tool on the server, not from supplied arguments.
⬜ Keep forwarding the existing tokens but rotate them often and reject requests without a tenant ID.

A service agent gets a delegated user token and calls a SaaS ticket API through a tool. The tool checks that the token is valid but accepts whatever account ID Claude passes, and the downstream service account can see every customer. Tests show that changing the ID returns another customer’s tickets. What’s the main architecture gap?

⬜ The user’s account ID isn’t repeated in the system prompt before each tool call.
⬜ The delegated token isn’t stored in the conversation history for Claude to compare against.
⬜ There’s no server-side object authorization that derives the permitted account scope from the verified identity before tickets are fetched.
⬜ The context window is too small to keep the original account visible throughout the session.

A parts assistant gets queries with exact codes such as XR-417B and descriptive ones such as “heat-resistant pump seal.” Semantic search finds similar parts but sometimes misses exact codes, while keyword search misses paraphrases. The catalog carries product-family and region metadata. Which retrieval strategy fits best?

⬜ Dense semantic retrieval only, with every product code listed in the system prompt to help recognition.
⬜ Merge keyword and semantic candidates, apply metadata filters, and rerank a short list against the exact query.
⬜ Keyword matching only, since the catalog has many exact identifiers and structured fields.
⬜ Return every part in the matching family and have Claude choose from the full list.

Several internal Claude applications need the same governed access to ticketing, messaging, and project-management services. The platform team wants reusable typed operations, central maintenance, and consistent authorization instead of custom wrappers in every app. Non-Claude systems don’t need to use the interface. Which integration mechanism fits?

⬜ Give each application direct database credentials and describe each vendor schema in its prompt.
⬜ Write separate command-line scripts inside each application and coordinate releases by hand.
⬜ Expose the approved operations through maintained MCP servers that each Claude application connects to as a client.
⬜ Build one unrestricted REST proxy and let each application’s prompt define its own authorization rules.

A global platform runs Claude applications for hundreds of tenants with different data-retention obligations. Operators need to diagnose agent, retrieval, and tool failures, but dashboards show only global averages, and logging raw payloads would expose customer data. Several small tenants report severe tail latency that the averages hide. Which three controls should the architect include? (select three)

⬜ Carry correlation IDs through API requests, agent delegations, retrieval steps, and tool calls for each tenant interaction.
⬜ Store complete prompts, outputs, tool arguments, and retrieved documents centrally with no privacy controls.
⬜ Measure quality, latency, errors, and cost by tenant-safe segments, and report tail percentiles that expose outliers.
⬜ Show all tenant content unredacted on a dashboard every operations and engineering user can open.
⬜ Apply redaction, sampling, retention limits, and role-based access before any diagnostic payload is stored.
⬜ Alert only on organization-wide averages to keep dashboards simple.

Developers use a local MCP server that runs build commands and inspects project files. Teams install it on their own, and some configurations allow shell commands outside the repository. Security wants a rollout that scales, keeps the useful automation, and stops local privileges from quietly growing. Which two controls matter most? (select two)

⬜ Treat the stdio transport as trusted because the server is local, and turn off confirmation prompts.
⬜ Distribute an allowlisted server configuration with restricted command and filesystem scopes through managed settings, and keep evidence of its use.
⬜ Let each project swap the managed server for any executable that exposes the same tool names.
⬜ Store administrator credentials in the repository so privileged builds never stop for authentication.
⬜ Require explicit approval for sensitive operations and keep an audit record linking each tool call to its arguments and the user’s decision.

A remote MCP server reads employee files for several enterprise customers. The client authenticates every request with one shared service token, so downstream logs can’t show which employee started a read. Customers require per-user consent, tenant isolation, and the ability to revoke access for an individual. What should replace the shared credential?

⬜ Keep the shared token and pass the employee’s email as an unverified tool argument.
⬜ Issue one long-lived token per tenant and let that tenant’s employees share it through the client.
⬜ Per-user OAuth authorization, so the server can enforce audience and tenant boundaries, record consent, and revoke access per employee.
⬜ Move the shared token into the system prompt so Claude presents it only when access seems justified.

A troubleshooting assistant must cite evidence from a large knowledge base. Retrieving more candidates improves citation recall but adds reranking time and sometimes pulls in loosely related passages that distract the model. Different query categories need different amounts of evidence. What should the architect recommend?

⬜ Use maximum candidate depth for every query, since extra evidence can never hurt answer quality.
⬜ Tune retrieval depth and reranking per query category, balancing citation recall and groundedness against measured tail latency.
⬜ Apply one latency limit to every category and pick the smallest candidate set that meets it.
⬜ Drop citations to save time and tell users to search the knowledge base when unsure.

An incident assistant searches millions of timestamped log messages. Operators usually name a service and a narrow time window, then describe the symptom in plain language. Pure semantic search keeps returning similar incidents from the wrong service or month. Which retrieval strategy should the architect choose?

⬜ Run global semantic search first and have Claude discard service and time mismatches afterward.
⬜ Use exact keyword matching only, since service and timestamp are already structured fields.
⬜ Summarize logs daily and retrieve only the summaries.
⬜ Filter by service and time window first, run semantic retrieval within that subset, and rerank the results for symptom relevance.

A product-catalog assistant retrieves candidates quickly, but its reranker adds 350 ms to every request. Offline tests show reranking clearly helps ambiguous natural-language queries but rarely changes results for exact product-code lookups. The interactive latency target is strict. Which configuration balances this best?

⬜ Remove reranking everywhere, since exact-code lookups already meet accuracy targets.
⬜ Rerank every request and loosen the latency target so the service stays compliant.
⬜ Run cheap retrieval first and invoke reranking only when evaluated query and result signals show real ambiguity.
⬜ Retrieve many more candidates and skip checking whether the larger context helps.

Two partner companies run specialized agents. One must hand a bounded analysis task to the other, receive status and results, and keep each company’s tools, policies, and internal context separate. Neither company should expose its whole tool catalog. Which three design characteristics support this integration? (select three)

⬜ A formal task contract that defines accepted inputs, progress updates, returned results, and failure handling for both sides.
⬜ One shared MCP server exposing every internal tool so either agent can call operations directly.
⬜ Each partner’s tools and internal context stay behind its own agent boundary.
⬜ Natural-language requests by email, treating any fluent reply as a completed task.
⬜ Both agents merged into one process with combined system prompts.
⬜ Authenticated caller and correlation information passed along so delegated work stays attributable across both organizations.

A desktop engineering assistant needs to discover approved build targets, compile locally, and inspect test artifacts on the same workstation. The company already has a command-line build system and doesn’t want to expose it as a network service. Tools should be discoverable through a standard interface. Which integration mechanism fits best?

⬜ Wrap the approved build operations in a local stdio MCP server with constrained tools and explicit permissions that can be managed centrally.
⬜ A public REST endpoint for each local command, with workstation credentials sent on every model request.
⬜ Command documentation pasted into the prompt, with Claude free to emit any shell command.
⬜ An agent-to-agent protocol so the build system negotiates tasks as an autonomous peer.

A finance assistant has separate tools called create_payment, submit_payment, initiate_transfer, and schedule_disbursement. Their descriptions overlap, the schemas differ slightly, and selection errors have grown as operations were added. Most users need only two approved actions for their role. Which change best reduces the bloat and ambiguity?

⬜ Keep every tool and add to each description examples of the other tools that might apply.
⬜ Consolidate the overlapping operations into distinct, governed capabilities and expose only the role-relevant ones in each session.
⬜ Replace them with one universal finance command that accepts any natural-language instruction.
⬜ Make users type the exact internal tool name before Claude can act.

An industrial assistant answers questions about which upstream assets can cause a downstream failure. The evidence includes dependency records, maintenance notes, and operating manuals. Flat semantic search finds similar descriptions but doesn’t reliably follow the relationships between specific assets. Which retrieval architecture fits best?

⬜ Retrieve the relevant assets and their dependency paths, then pair those relationships with semantically matched passages that support each link.
⬜ Return more semantically similar maintenance notes per query without following the recorded dependencies.
⬜ Put the full asset inventory and every manual in the system prompt, regardless of relevance or context limits.
⬜ Match exact asset names only and exclude narrative maintenance evidence.

A data platform runs a scheduled remediation job with fixed inputs, deterministic validation, and no interactive user. The team proposes an MCP server so Claude can discover operations dynamically, even though the job always calls the same approved action. Governance prefers the simplest integration that keeps service identity and auditability. What should the architect recommend?

⬜ A remote MCP marketplace exposing every data-platform operation to the scheduled job.
⬜ Call the remediation through a governed API or CLI workflow with fixed inputs, a service identity, deterministic validation, and auditable execution.
⬜ Agent-to-agent messaging so a second agent chooses which remediation to run.
⬜ Let Claude generate a fresh shell command on each run, with no approved interface.

An engineering assistant searches drawings, captions, specifications, and revision notices for manufacturing teams. The current text-only index separates diagram references from the specification that governs them and sometimes returns superseded dimensions. Retrieval must keep technical relationships and revision authority intact. Which indexing design fits best?

⬜ Extract all visible text, drop drawing identifiers, and index fixed token blocks.
⬜ Index each drawing with its captions, referenced specification sections, revision metadata, and parent-child links.
⬜ Store drawings apart from specifications and have users reconcile revision conflicts themselves.
⬜ Index only the latest drawing image, with no captions, identifiers, or specification links.

An agent uses four tools and a short reference document. All of them are needed on nearly every request, and together they fit easily in the context window. An engineer proposes switching to progressive discovery for tools and context. How should the architect respond?

⬜ Adopt progressive discovery, since minimal up-front context is the right default for every agent.
⬜ Move to on-demand loading and rely on prompt caching to offset the extra lookup steps.
⬜ Keep loading everything up front, because on-demand discovery would add steps without saving meaningful context.
⬜ Split the four tools across specialist subagents so each request carries fewer tools.

A security review finds that every production service on a Kubernetes platform calls the Claude API with the same long-lived key, created under one engineer’s personal account and copied into each service’s environment. Which change closes this gap most directly?

⬜ Use workload identity federation to exchange each service’s platform identity for short-lived API credentials.
⬜ Encrypt the key at rest in each service’s configuration and restrict access to deployment tooling.
⬜ Rotate the shared key monthly and distribute it through a central secrets manager.
⬜ Tag each service’s requests with a distinct ID so misuse can be traced in audit logs.

A team is building a Q&A assistant over an internal operations handbook. The handbook fits easily in the model’s context window and changes only a few times a year. Which approach suits this corpus size and update pattern best?

⬜ Chunk the handbook into small segments and retrieve them with vector search.
⬜ Put the whole handbook in the prompt and cache the shared prefix.
⬜ Summarize the handbook into a short digest and answer only from that.
⬜ Build a hybrid BM25 and embedding index with a reranking stage.

A nightly job produces compliance summaries from regulatory filings, and the results aren’t needed until the next morning. The team chose the fastest model tier to minimize per-document latency, but reviewers report frequent factual errors. How should the architect think about this trade-off?

⬜ Keep the fast model and run each document through two identical passes, comparing the outputs.
⬜ Add few-shot examples to the fast model’s prompt until it’s as accurate as a more capable tier.
⬜ Move to a more capable model, since the overnight window makes accuracy, not latency, the constraint that matters.
⬜ Stream partial output so reviewers can start checking before generation finishes.

An architect is auditing an agent’s tool configuration for bloat. Which two audit actions most directly show that the registered tool catalog is bloated? (select two)

⬜ Flag any heavily used tool that accounts for most invocations.
⬜ Look for individual tool calls with occasional large results that need truncating.
⬜ Use usage telemetry to find registered tools that are never called in production.
⬜ Measure how much of the context window tool definitions use on every request.

An application uses the Messages API. The team wants Claude to call tools from an MCP server that runs as a local stdio process on their private network and can’t be made publicly reachable. Which integration approach meets this constraint?

⬜ Run an MCP client inside the application that connects to the local server and relays its tools to the API.
⬜ Give Claude direct access to the systems behind the server and drop the MCP layer.
⬜ Use an agent-to-agent protocol so the server negotiates tool calls with Claude itself.
⬜ Use the MCP connector so the API connects to the local stdio server directly.

An assistant handles thousands of sessions a day. Dashboards track latency, error rates, and token spend, yet a prompt change that hurt answer quality went unnoticed for three weeks. Which monitoring addition closes this gap most directly?

⬜ Store full prompts and responses for every session for manual review.
⬜ Treat rising complaint volume as the main signal of quality regressions.
⬜ Run automated quality evaluations continuously against a sample of production sessions.
⬜ Alert on token spikes as a proxy for worse answers.

A team is shipping a consumer iOS app that calls the Claude API directly from the device, with no backend. The current design embeds a static API key in the app binary, and a security review flags it. Which change closes this gap best?

⬜ Use App Attest so verified app installations get short-lived, workspace-scoped tokens.
⬜ Fetch the key from a remote configuration service at launch instead of embedding it.
⬜ Obfuscate the embedded key and rotate it with each release.
⬜ Scope the embedded key to a dedicated workspace to limit what extraction exposes.

A nightly reporting service authenticates to the Claude API through workload identity federation. A security review finds that the federation rule issues tokens with organization-admin scope, although the service only ever calls the Messages API. Which change closes this gap most directly?

⬜ Shorten the token lifetime so the elevated access only lasts briefly.
⬜ Narrow the federation rule so the tokens it issues carry only the inference scope the service needs.
⬜ Add audit logging and alerts on any administrative actions the service takes.
⬜ Route the token exchange through a separate hardened service that performs it on the service’s behalf.

A RAG pipeline chunks quarterly financial filings for embedding and keyword indexing. Retrieval often surfaces passages like “revenue grew 3% over the prior quarter” from the wrong company or period, because the passage text alone never names its source. Which change addresses this most directly?

⬜ Make chunks much larger so each one includes more surrounding text.
⬜ Prepend short chunk-specific context identifying the source document to each chunk before indexing.
⬜ Attach each document’s summary to its chunks after retrieval.
⬜ Use a larger embedding model that captures more nuance per passage.

A RAG assistant indexes each internal research report as one embedding. Reports cover many unrelated topics, so queries about one topic often return reports where the answer is just a passing mention. Which change improves retrieval precision most directly?

⬜ Use a larger embedding model with more dimensions to capture each whole report.
⬜ Split each report into smaller, topic-coherent chunks and embed each chunk separately.
⬜ Retrieve more reports per query so the relevant material shows up somewhere.
⬜ Rewrite queries to be longer and more detailed before embedding them.

A team upgrades the embedding model in its RAG pipeline and, to save money, re-embeds only documents added after the upgrade. Queries now use the new model, and retrieval for older documents falls apart. What’s the most direct fix?

⬜ Switch query embedding back to the old model while keeping the new document vectors.
⬜ Re-embed the entire corpus with the new model so every vector lives in the same space.
⬜ Lower the similarity threshold so more older documents pass.
⬜ Retrieve more chunks per query so older documents get included.

A RAG assistant retrieves 20 candidate chunks per query. Evaluation shows the correct chunk is almost always in the 20, but only five fit the context budget, and similarity ranking often puts irrelevant chunks first. Which change most directly improves which chunks reach the model?

⬜ Make chunks smaller so more of them fit in the budget.
⬜ Add a reranking stage that rescores the 20 candidates and passes the top five.
⬜ Raise the similarity threshold so only high-scoring chunks get through.
⬜ Grow the candidate pool to 100 chunks so the correct one ranks higher.

A conversational assistant handles both quick FAQ lookups and complex multi-step troubleshooting. The team turned thinking on for every request. Troubleshooting accuracy improved a lot, but simple FAQ answers now miss the interactive latency target. What should the architect do?

⬜ Turn thinking off everywhere so every request meets the latency target.
⬜ Route by query complexity and enable thinking only on the troubleshooting path.
⬜ Keep thinking on everywhere and stream responses so the delay feels shorter.
⬜ Relax the latency target to make room for the better reasoning.

Six unrelated internal applications call the Claude API with keys from the organization’s default workspace, sharing its spend and rate limits. A security review requires per-application isolation, so that a compromised key can be revoked and contained without affecting the others. Which change meets this requirement best?

⬜ Create a dedicated workspace for each application and scope its keys to that workspace.
⬜ Replace all keys with one service-account key tied to a service identity instead of a person.
⬜ Turn on detailed usage monitoring so key misuse can be traced afterward.
⬜ Rotate every key in the shared workspace much more often.

An architect is deciding between an MCP server and a direct API integration for connecting an internal system to Claude-based applications. Which two recommendations apply the MCP server correctly? (select two)

⬜ Use the MCP server so autonomous agents at two separate companies can coordinate without exposing internal systems.
⬜ Use the MCP server for a scheduled job that moves records between databases with no model reasoning involved.
⬜ Use the MCP server when several current and future AI applications need reusable access to the same system.
⬜ Use the MCP server when the tool set changes often and the owning team wants to maintain the integration in one place.

An agent exposes fifty tools. Telemetry shows five of them handle nearly every request, and the rest cover occasional edge cases. Tool definitions are taking enough context to hurt response quality. Which loading strategy best balances latency and context efficiency?

⬜ Keep the five frequently used tools loaded up front and discover the rest on demand.
⬜ Keep all fifty loaded and rely on prompt caching to absorb the growth.
⬜ Move the entire catalog to on-demand discovery so nothing loads at session start.
⬜ Split the tools between two agents that each load half the catalog.

An architect has to choose among MCP, direct API integration, and an agent-to-agent protocol for several integration needs. Which two recommendations apply agent-to-agent communication correctly? (select two)

⬜ Use it for a single deterministic model call inside a nightly pipeline the application fully owns.
⬜ Use it when independently operated agents must coordinate across an organizational boundary without exposing internal systems.
⬜ Use it when each party’s agent has to negotiate outcomes dynamically, rather than call a fixed tool the other exposes.
⬜ Use it when several internal applications need standardized, reusable access to one shared system’s tools.

A support assistant retrieves 150-token chunks from equipment repair guides. Retrieval reliably finds the right passage, but answers are shallow because each chunk leaves out the surrounding steps of its procedure. Which change improves answers most directly without giving up retrieval precision?

⬜ Keep small-chunk retrieval, but pass each match’s enclosing parent section to the model.
⬜ Re-embed the corpus with much larger chunks so each vector covers a whole procedure.
⬜ Tell the model to fill in the missing procedure steps from its own knowledge.
⬜ Return many more chunks per query so adjacent steps are likely to be included.

An agent platform logs every prompt, response, and tool payload in full, and logging costs have become unsustainable at scale. Which two practices cut cost while keeping failures diagnosable? (select two)

⬜ Log only each session’s final response and discard intermediate steps.
⬜ Capture full payloads automatically whenever a session hits an error condition.
⬜ Capture full payloads for a sampled fraction of sessions.
⬜ Move detailed payload logging to a staging environment for reproduction.

A document-review assistant is connected to a third-party MCP server that exposes 40 tools, but its workflow uses only five. Since the server was added, tool-selection accuracy has dropped and per-request token use has grown. What should the architect change?

⬜ Put the server behind one free-text tool that proxies every command.
⬜ Add system prompt instructions telling the assistant to ignore the tools it doesn’t need.
⬜ Move to a more capable tier that copes better with large tool catalogs.
⬜ Configure the server connection to enable only the five tools the assistant needs.

A security team’s incident runbook permanently deletes any Claude API key that triggers an anomaly alert. Most alerts turn out to be false positives, and each deletion forces the affected service to be re-provisioned with a new key. Which runbook change best balances fast revocation with recoverability?

⬜ Disable flagged keys during triage, and delete only keys confirmed as compromised.
⬜ Shorten the expiry on flagged keys so they lapse while triage continues.
⬜ Suppress anomaly alerts until an analyst manually confirms compromise.
⬜ Restore deleted keys once triage shows the alert was a false positive.

A legal research assistant uses semantic retrieval with a general-purpose embedding model over case law and statutes. Evaluation shows it keeps missing relevant passages because specialized legal terminology is poorly represented in the embedding space. Which change improves retrieval most directly?

⬜ Switch answer generation to the most capable Claude tier.
⬜ Move to a larger general-purpose embedding model with more dimensions.
⬜ Retrieve more chunks per query so the relevant passages show up.
⬜ Adopt an embedding model trained for legal text and re-index the corpus.

A support assistant writes detailed multi-paragraph answers. Users complain about long waits, and profiling shows nearly all latency comes from generating the response rather than retrieval. Answer quality must not drop. Which change addresses the complaint most directly?

⬜ Retrieve fewer documents to speed each request.
⬜ Move to the fastest model tier to shorten generation time.
⬜ Enable streaming so users see the answer as it’s generated.
⬜ Lower the maximum output length so responses finish sooner.

---

Domain 4: Evaluation, Testing and Optimization (16%)

A team thinks a revised system prompt improves support resolution, but traffic mix and load change from day to day. They can send a limited share of eligible production traffic to the new prompt and already track quality, escalation, latency, and cost. Leadership wants evidence that isolates the prompt’s effect. Which experiment should the architect propose?

⬜ Run the current prompt one week and the revised prompt the next week, then compare the two weekly averages.
⬜ Send experienced users to the revised prompt while everyone else stays on the current one.
⬜ Roll the revised prompt out to all users and compare the next monthly dashboard with historical results.
⬜ Randomly split eligible traffic between the two fixed prompt versions, with metrics and stopping rules defined before the analysis.

A policy assistant sends the same long system instructions, reference material, and tool definitions on thousands of requests; only the user’s question at the end changes. Repeated input processing dominates both cost and time to first token, and Claude must still see all of the content. What should the architect test first?

⬜ Drop the reference material and rely on Claude’s general knowledge for policy answers.
⬜ Put the stable instructions and references in a reusable prefix with prompt caching, and monitor cache reads and invalidations.
⬜ Raise the output token limit so longer answers offset the repeated input cost.
⬜ Shuffle the order of tool definitions on each request to spread selection across positions.

A regulated team uses Claude to summarize case files for licensed reviewers. Summaries must preserve decisions, exceptions, and citations accurately, and an unsupported high-impact claim must block release even if readability improves on average. The team has a representative, expert-annotated evaluation set. Which two metrics should anchor the release gate? (select two)

⬜ Weighted factual accuracy and citation correctness, with mandatory checks that every required exception and limitation is present.
⬜ Average output length, treated as a sign that each summary covers the case completely.
⬜ Reviewer reading speed, approving any version that shortens review time.
⬜ How often formal terminology from the source is repeated, with higher coverage as the threshold.
⬜ A strict guardrail on unsupported high-impact claims that blocks release whenever their measured rate exceeds the approved limit.

An operations agent reads incidents, queries monitoring tools, updates tickets, and drafts remediation notes. Some outcomes can be checked exactly, such as tool arguments and ticket state; note quality and use of evidence need judgment. The team wants a scalable regression harness with dependable scoring. Which two grading methods should it combine? (select two)

⬜ Have the same agent judge whether its own final response and tool choices were right, with no independent check.
⬜ Deterministic assertions on tool selection, arguments, side effects, and final state wherever outcomes are machine-checkable.
⬜ Rubric-based model or human graders for semantic quality, calibrated with examples and rechecked for reliability over time.
⬜ Token count as a universal measure of both operational correctness and note quality.
⬜ Pass every run that ends without an API error, even if the ticket state or side effects are wrong.

A support assistant is moving from prototype to a limited production release. Business leaders want faster resolution; operations needs to control wrong answers, failed escalations, latency, and cost. Right now the team reports only average user satisfaction. Which measurement approach gives an adequate release gate?

⬜ Explicit thresholds for task quality, resolution, latency, cost, safety, and escalation behavior, agreed before release.
⬜ Average satisfaction as the only metric, since it indirectly reflects every concern.
⬜ Offline model accuracy only, with operational behavior evaluated after the release.
⬜ Request volume, declaring success whenever adoption rises between two reporting periods.

After a tool schema update, an assistant intermittently sends an invalid enum value, but only on some prompts. The same release changed both the schema description and the system prompt. Logs keep the error message but not the raw tool call or the schema version. What should the architect recommend first?

⬜ Capture the raw tool calls and replay failing requests against the exact versioned schema and validator before changing the prompt again.
⬜ Add more retries to every tool call and hide schema errors from operators to cut alert noise.
⬜ Rewrite the whole system prompt and ship it with another schema revision before finding the cause.
⬜ Switch to a different model and assume the current schema is valid without replaying anything.

An insurer’s RAG assistant answered policy questions well until a scheduled document refresh and reindex. The model, system prompt, and latency are unchanged, but regression tests now show confident answers that leave out exceptions in long multi-section manuals. Citations are well formed, yet several point to broad introductory passages instead of the clauses that decide eligibility. What should the architect do first to find the source of the regression?

⬜ Strengthen the prompt so Claude always cites evidence and refuses when passages look incomplete.
⬜ Move to a more capable model with a larger context before looking at retrieval.
⬜ Replay the failing queries against both index versions and compare the retrieved chunks, metadata, and boundary coverage before changing generation settings.
⬜ Lower the retrieval threshold for everyone and return more chunks while collecting more complaints.

A customer-service assistant will launch in eight languages across regions with different product rules and volumes. The English prototype performs well, but pilot reviewers saw failures on mixed-language messages, rare refund cases, and low-resource languages. The release gate must estimate typical performance and expose serious weaknesses. How should the evaluation set be built?

⬜ Use only high-volume English requests, since they give the most stable average.
⬜ Stratify by language, intent, region, and traffic volume, and include the known high-impact failure modes.
⬜ Machine-translate one English benchmark into every language and accept similar averages as enough.
⬜ Use only reviewer-submitted failures, so every case is a hard edge case.

A proposed model migration improves overall answer quality offline but raises cost and gives mixed tool-use results in two languages. Leadership wants a production experiment before the current model is deprecated, and the service has strict latency and safety SLOs. Traffic can be routed by model version. Which three safeguards matter most? (select three)

⬜ Move all traffic to the new model, since offline quality improved and the migration code passes tests.
⬜ Randomize representative traffic and report results separately by language, complexity, and risk segment.
⬜ Keep adjusting prompts during the experiment without tracking which requests got which version.
⬜ Set one primary quality metric with non-inferiority guardrails for latency, safety, and cost before any exposure.
⬜ Increase exposure gradually, with automatic rollback whenever an approved guardrail is breached.
⬜ Choose the model with the lowest average latency even if quality and tool use regress in key languages.

A shared RAG service supports legal, support, and engineering assistants with different corpora and SLOs. Teams can see overall API availability but can’t connect a poor answer to its retrieval results, corpus version, model call, citations, or user feedback. Sensitive document text can’t be copied freely into dashboards. Which monitoring design fits best?

⬜ Monitor only API availability and treat every successful response as a healthy outcome.
⬜ Store every retrieved document and full prompt indefinitely in one open operations index.
⬜ Correlate each query with its corpus version, retrieval metrics, model usage, citations, and feedback through access-controlled traces.
⬜ Track monthly token spend across assistants and look at quality only when cost goes over budget.

A travel-disruption agent can rebook flights, request hotel vouchers, and escalate to staff. Management proposes evaluating only whether the final message is helpful. The architect needs to capture both user outcomes and the risks of tool execution. Which two metrics are the most important additions? (select two)

⬜ Word count per response, rewarding the longest explanations.
⬜ Whether each disruption is actually resolved, including how the agent recovers from tool failures and when it escalates.
⬜ Tool selection only, ignoring whether the arguments were valid or the action had the intended effect.
⬜ Unauthorized or incorrect side effects from bookings and vouchers, measured together with latency and cost.
⬜ Staff preference for the response tone, used as the only release gate.

During peak traffic an assistant sometimes stops mid-sentence. Offline prompts finish normally, but production requests can hit rate limits, retries, fallback models, and different output caps, and nobody can tell which path handled a failing request. Which diagnostic action comes first?

⬜ Rewrite the system prompt for brevity before finding which path or limit cut generation short.
⬜ Trace each affected request end to end, recording the retry route, fallback model, active output limit, and stop reason.
⬜ Increase the primary model’s context window, since truncation always means too little input capacity.
⬜ Compare monthly average latency between models and ignore per-request stop reasons and retries.

A retailer generates millions of product descriptions overnight from structured attributes and a shared policy prefix. Nothing is interactive, but every description must pass deterministic format checks, and a sample must pass a groundedness review before publication. The company wants lower cost and predictable completion. Which three actions fit best? (select three)

⬜ Submit the workload through batch processing and monitor completion and failure categories.
⬜ Send every item as a synchronous request and retry failures immediately with no backoff.
⬜ Publish each completed description automatically, since batch completion shows the content is correct.
⬜ Put the stable policy prefix before the product data and reuse it with prompt caching where supported.
⬜ Validate required fields deterministically and review a representative groundedness sample before publishing.
⬜ Remove the shared policy prefix to save tokens and let each record imply the style rules.

A system extracts obligations from commercial contracts for human review. Missing a termination obligation costs more than flagging an extra clause, and reviewers care how often they have to correct the output. Leaders have also set latency and cost limits. Which evaluation design best represents success?

⬜ Clause-level precision and recall on representative contracts, plus reviewer correction effort and whether latency and cost limits are met.
⬜ Document-level exact match as the only metric, treating all contracts as equally hard.
⬜ Average response length and reviewer satisfaction, without checking extractions against labels.
⬜ Recall only, since false positives can always be removed by hand at no cost.

A forecasting assistant explains seasonal demand from several years of sales data. Randomly splitting rows puts near-duplicate weekly patterns in both the examples and the evaluation cases, which inflates results. Rare promotions and supply disruptions are underrepresented. What should replace the random split?

⬜ A larger random holdout that still keeps adjacent weeks from the same season in both sets.
⬜ Only the most recent normal month, since current data matters more than unusual events.
⬜ Holdout sets from later representative periods, with dedicated coverage of rare events and adversarial requests, plus an untouched release set.
⬜ Use the training examples as the evaluation set and tune the prompt until every explanation matches.

A knowledge assistant’s monthly averages are steady, yet specialists report worse answers for a newly launched product line. The retrieval corpus, the query mix, and escalation behavior have all shifted gradually. Leaders want monitoring that catches this kind of drift before complaints pile up. Which observability design is most effective?

⬜ Track global accuracy only, since stable averages show every segment is healthy.
⬜ Monitor latency and token use without keeping retrieval or user-outcome data.
⬜ Monitor each product and user segment separately, evaluating retrieval quality, groundedness, and user outcomes alongside latency and cost.
⬜ Wait for support tickets, since complaints make the most reliable evaluation dataset.

After a prompt-template update, a summarization assistant regresses in two languages only. English quality, latency, retrieval, and the model version are all unchanged. The team proposes moving every request to a larger model. What should the architect investigate first?

⬜ Compare representative failures by language and template version to see whether the regression comes from how the new template behaves in those languages.
⬜ Move all traffic to the largest model, since broader capability will fix a localized regression.
⬜ Increase sampling randomness for the two languages so summaries explore more wording.
⬜ Turn off evaluation for those languages until enough users say whether it matters.

After a model and prompt update, a production assistant’s overall refusal rate hasn’t moved. Safety reviewers, though, see more harmful completions in one risk category and more unnecessary refusals in another. Aggregate monitoring can’t show whether the update helped or hurt users. Which monitoring design addresses this best?

⬜ Keep tracking only the overall refusal rate, since a stable number means safety is unchanged.
⬜ Count harmful completions but ignore false refusals, since unnecessary blocking doesn’t affect users.
⬜ Evaluate safety per risk category, separating valid refusals from false refusals and harmful completions, and track escalations, latency, and cost by model and prompt version.
⬜ Review a random monthly sample without recording which model and prompt version produced each response.

A policy assistant cites guidance that changes often across employment, tax, and privacy domains. Users like its fluent answers, but reviewers recently found citations to policy versions that had been replaced. The team wants production monitoring that catches grounding decay before a major audit. Which signals fit best?

⬜ Policy freshness and effective dates per domain, plus citation support, retrieval failures, and reviewer corrections traced to the index version.
⬜ Engagement and longer sessions, taken as evidence that the cited policies are still current.
⬜ Citation count, assuming any answer with three or more links is well grounded.
⬜ Only complaints where a user can prove an outdated citation caused financial loss.

An infrastructure team is evaluating an assistant that can call privileged diagnostic and remediation tools. Current tests cover only well-formed requests from authorized users, not hostile instructions, invalid arguments, permission changes, or tool outages. Some actions need expert judgment because their risk depends on production context. Which two additions make the strongest mixed evaluation framework? (select two)

⬜ More ordinary requests from authorized users, with every tool always available and permissions unchanged.
⬜ One LLM grader for every behavior, with no deterministic security checks or expert review.
⬜ Deterministic tests of permissions and argument schemas, plus simulated prompt injection, malformed requests, authorization changes, and tool or dependency failures.
⬜ Evaluation only after production deployment, since synthetic tests can’t reproduce every condition.
⬜ Specialist review of ambiguous high-risk actions against explicit rubrics, including whether the assistant recognizes uncertainty and escalates before acting.

A team drafting pre-launch success criteria for a public-facing assistant needs a safety requirement. How should the requirement be written so it can be used as an evaluation metric before launch?

⬜ Fewer than 0.1% of test-set outputs flagged for harm by the content filter.
⬜ The number of user-reported safety complaints in the first month after launch.
⬜ A qualitative commitment that the assistant always produces safe, appropriate, trustworthy output.
⬜ The underlying model’s published safety benchmark score, adopted as the requirement.

A team is designing an evaluation suite for a document-classification assistant. Each release, they can either hand-grade 50 expert-reviewed cases or automatically grade 1,500 cases with slightly noisier scoring. Which gives the stronger evaluation signal?

⬜ Hand-grade the 50 cases, since grading precision matters more than coverage.
⬜ Alternate the two approaches from release to release.
⬜ Run the 1,500 automated cases and accept slightly noisier grading per case.
⬜ Hand-grade a rotating 50-case sample so every case eventually gets human review.

A team iterating on a production assistant ships a revised prompt and a newer model version together as the treatment arm of an A/B test. The treatment wins, but the team can’t tell which change produced the improvement. What practice prevents this in future iterations?

⬜ Increase traffic until the combined result is statistically significant.
⬜ Accept the combined gain and keep bundling changes to iterate faster.
⬜ Change one thing at a time against a stable baseline with defined metrics.
⬜ Credit the model upgrade, since model changes usually dominate.

A real-time RAG assistant sends many retrieved passages per request, and most traffic is simple, repetitive questions. Which two optimizations reduce latency and cost without hurting quality? (select two)

⬜ Lower the effort setting for simple, high-volume queries once evaluations confirm quality holds.
⬜ Trim retrieved context so each request carries only passages relevant to the query.
⬜ Send all requests through batch processing to get discounted pricing.
⬜ Apply a sharply lower output-token cap to every request regardless of task.

A team is A/B testing a revised prompt against the production prompt. After one day, the revision leads on the primary quality metric by a small margin. What should the team do before acting on this?

⬜ Ship the revision to all traffic now, since it’s ahead.
⬜ Keep the test running until the planned sample size and significance criteria are met.
⬜ Stop the test and revert, treating the small margin as noise.
⬜ Broaden the revision’s changes so the effect grows large enough to detect quickly.

Whenever its warranty-lookup tool finds no matching record, a support assistant confidently produces a plausible-looking registration number. Latency, model version, and the prompt’s formatting rules haven’t changed. What fixes this failure most directly?

⬜ Add few-shot examples of correctly formatted registration numbers to the system prompt.
⬜ Tell the assistant to answer only from tool results and to say plainly when no record is found.
⬜ Set temperature to zero for more deterministic output.
⬜ Upgrade to the most capable tier, since fabrication reflects limited reasoning.

A document-analysis assistant runs on the fastest, lowest-cost tier. It extracts simple fields well, but its multi-step reasoning over complex contract clauses stays shallow after several rounds of careful prompt refinement, with clear structure and worked examples. What should the architect do next?

⬜ Evaluate the task on a more capable tier and compare the results.
⬜ Raise the output-token limit so responses have room to reason.
⬜ Add even more few-shot examples of correct reasoning.
⬜ Lower the temperature so the model follows reasoning instructions more closely.

A team grades thousands of outputs from a research-summary assistant with an LLM grader. The grader writes free-form paragraph judgments, and the team can’t reliably aggregate them or compare prompt versions across runs. Which grading change fixes this most directly?

⬜ Replace the automated grader with human review of every output.
⬜ Have the grader reason first, then output only a categorical verdict.
⬜ Run each grading prompt twice and keep the more favorable judgment.
⬜ Ask the grader for longer, more detailed qualitative assessments.

A team A/B tests two prompt variants for a multi-turn support assistant. Each message is assigned to a variant independently, so one conversation often mixes both prompts. Which change makes the comparison valid?

⬜ Replace the online test with a rerun of the offline evaluation for each variant.
⬜ Send more traffic to the treatment arm so results accumulate faster.
⬜ Alternate variants on every other message so both arms get equal exposure.
⬜ Randomize at the conversation level so each session uses a single variant throughout.

A team is building an assistant that summarizes documents submitted by outside parties. A stated security requirement is that it must never follow instructions embedded in that content. Which evaluation metric measures compliance with this requirement most directly?

⬜ How often injected instructions in a seeded adversarial test suite actually get executed.
⬜ The number of user-reported security incidents in the first month of production.
⬜ The percentage of outputs a content filter flags as toxic or harmful.
⬜ Average latency when processing documents that contain adversarial content.

A classification service asks Claude for one category label per record, but every response includes several paragraphs of justification before the label. Latency and generation cost are both high. Which change addresses both problems most directly?

⬜ Enable prompt caching so the repeated system prompt is reused.
⬜ Send the classification traffic through the Message Batches API for the discount.
⬜ Tell the model to return only the category label, with no justification.
⬜ Lower the temperature so responses get shorter.

An A/B test shows a revised prompt beating the production baseline on the primary task-completion metric, with the agreed sample size and significance criteria met. The team wants to roll it out to all traffic. What should they confirm first?

⬜ That guardrail metrics such as safety, cost, and latency didn’t regress.
⬜ Nothing more, since significance has already been reached.
⬜ That the offline evaluation suite reproduces the production result.
⬜ That the improvement margin roughly doubles if the test runs longer.

A benefits-enrollment assistant switches unpredictably between terse one-line replies and long multi-paragraph walkthroughs for similar requests. Several contributors have edited its system prompt over time; the model, tools, and retrieval haven’t changed. What should the architect investigate first?

⬜ Add retrieval grounding so responses stay anchored to source documents.
⬜ Review the system prompt for conflicting instructions about length and style.
⬜ Lower the sampling temperature to make formatting more deterministic.
⬜ Move to a more capable tier with stronger instruction following.

A legal-research assistant often gives wrong answers in production. One engineer blames the prompt, another model capability, a third hallucination. What should the architect do before committing to a fix?

⬜ Add stronger anti-hallucination wording to the system prompt and watch the results.
⬜ Review a sample of failing outputs with their inputs and classify each type of failure.
⬜ Rewrite the system prompt immediately, treating it as the source of the failures.
⬜ Move all traffic to the most capable tier to rule out a capability gap.

A production assistant calls several internal tools. Those calls fail intermittently, and the model quietly works around the failures, producing weaker answers. Latency and cost dashboards look normal. Which monitoring addition detects these incidents earliest and most reliably?

⬜ Review a weekly sample of user complaints for mentions of tool failures.
⬜ Alert when daily token use deviates significantly from its normal level.
⬜ Add finer percentile breakdowns to the end-to-end latency dashboard.
⬜ Emit per-tool error and retry rate metrics, with alerts when they cross thresholds.

A team grades a summarization assistant’s output at scale with an LLM rubric grader. The grader runs on the same model and configuration that produces the summaries. Which change reduces systematic bias in the grades most directly?

⬜ Raise the grader’s temperature so its judgments vary more between runs.
⬜ Average two grading passes from the same model to smooth out noise.
⬜ Shorten the rubric so the grader has fewer criteria to weigh.
⬜ Use a different model as the grader from the one generating the outputs.

A team is setting latency and cost metrics for an interactive assistant before launch. Which two metric definitions give the most decision-useful signal? (select two)

⬜ Survey pilot users on whether responses feel fast enough.
⬜ Compare the total monthly inference invoice with the department’s budget.
⬜ Track average token cost per completed request against an agreed target.
⬜ Measure p95 response time against a two-second target on representative queries.

A team exports usage metrics from its developers’ Claude Code sessions. The metric dimensions trace a token-cost spike to a handful of sessions, but not to the specific prompts and tool activity inside them. What enables that deeper investigation most directly?

⬜ Enable log and event export so each prompt and tool action is recorded.
⬜ Shorten the metrics aggregation interval for finer time resolution.
⬜ Set threshold alerts on the token usage metric to flag future spikes.
⬜ Mirror the metrics into a second dashboard with richer visualizations.

A ticket-classification assistant meets its accuracy targets but keeps missing its latency and cost targets under production load. Two sprints of shortening and restructuring the prompt haven’t helped much. What’s the most appropriate next step?

⬜ Relax the latency and cost targets, since accuracy is what matters most.
⬜ Keep restructuring the prompt until the targets are met.
⬜ Lower the temperature so classifications are generated faster.
⬜ Try a faster, cheaper model tier and confirm accuracy on the evaluation suite.

While defining launch criteria for a classification assistant, an executive proposes a 100% accuracy threshold so no error ever reaches a customer. How should the architect define the accuracy metric?

⬜ Adopt it, but limit the test set to examples the assistant already gets right.
⬜ Replace accuracy with a satisfaction survey, since perfect accuracy can’t be measured.
⬜ Set an achievable threshold based on baselines and benchmarks, with an escalation path for the remaining errors.
⬜ Accept it and delay launch until the system is perfect on the test set.

Users of a production assistant occasionally report very slow responses, yet the latency dashboard, which shows mean response time, looks healthy. Which monitoring change surfaces the problem most directly?

⬜ Alert on deviations in daily token use to catch abnormal request volume early.
⬜ Monitor the API endpoint’s uptime percentage to detect availability problems sooner.
⬜ Track latency at high percentiles such as p95 and p99, broken down by request type.
⬜ Refresh the dashboard more often so brief slowdowns show up between updates.

---

Domain 5: Governance, Safety and Risk Management (14%)

A company is designing a Claude service that processes customer records from several regions. Privacy owners require documented data flows, approved processing locations, data minimization, enforceable retention and deletion, and evidence of access and architecture changes. Feature eligibility varies across the planned workflow. Which three actions should the architect include? (select three)

⬜ Send requests through any available region and rely on contract wording alone to meet residency requirements.
⬜ Document every data flow and have privacy owners verify processor terms and feature eligibility before approving the workflow.
⬜ Configure approved inference locations and retention controls, and strip unnecessary personal data before requests reach Claude.
⬜ Turn on prompt caching for all personal data, since cached prefixes satisfy deletion and residency rules automatically.
⬜ Keep every complete prompt indefinitely in one global log so any future compliance question can be answered.
⬜ Assign named control owners and keep audit evidence for access reviews, deletions, incidents, and approved architecture changes.

A support assistant answers questions from an approved product knowledge base. An offline review finds it sometimes states refund conditions that don’t appear in the retrieved passages, even when it’s asked for citations. It has no transaction tools, and latency is fine. Which failure mode is the main risk?

⬜ A grounding failure: the assistant confidently states refund conditions that the retrieved passages don’t support.
⬜ An authorization failure: the assistant has too much write access to refund systems.
⬜ A prompt-caching failure: stable instructions are being reprocessed and inflating cost.
⬜ A retrieval latency failure: too many accurate passages come back before the answer is generated.

A service agent asks for the same manual confirmation on informational lookups, reversible draft edits, account suspensions, and permanent deletions. Reviewers now click through without looking at the evidence, and one deletion was approved by mistake. The company wants to keep oversight and get reviewers’ attention back. What should the architect recommend?

⬜ Keep the same approval step for every action regardless of its value, reversibility, or impact.
⬜ Skip approval whenever Claude’s confidence is above a threshold, whatever the consequences of the action.
⬜ Send only high-impact or hard-to-reverse actions for review, and show reviewers the evidence and clear criteria they need to decide.
⬜ Keep approval for everything but reduce the review screen to a single confirm button so reviewers go faster.

A retail agent investigates customer disputes and drafts refund proposals using order and shipment tools. Refunds above a set value materially affect revenue and are hard to recover once paid. Finance wants faster investigations but won’t let Claude release those payments on its own. Where should human review go?

⬜ Approve refunds automatically when Claude reports high confidence, and have finance review the justifications monthly.
⬜ A finance reviewer approves the validated proposal before the application calls the payment tool for any high-value refund.
⬜ Have Claude confirm its own recommendation against historical transaction patterns.
⬜ Pay the refund immediately and send unusual cases to specialists afterward to attempt a reversal.

A public-benefit assistant triages incoming requests by urgency across eight languages. Overall accuracy meets the release target, but advocates report that some language groups get more low-priority labels for similar needs. The company must find out whether outcomes are materially unequal before expanding. Which evaluation design fits best?

⬜ Report overall accuracy only, since a large global sample averages out differences between languages.
⬜ Translate every case into English and infer multilingual fairness from the translated results.
⬜ Stratify the evaluation by language and affected group, compare error patterns, and review material differences with domain experts.
⬜ Use the same confidence threshold in every language and treat identical configuration as proof of equal outcomes.

A healthcare company plans to summarize patient correspondence through the Claude API. Compliance hasn’t yet confirmed which features its required contractual arrangement covers, or how retention, deletion, access, and audit obligations will be evidenced. Engineering wants to pick integrations now. What should the architect recommend before approving the production design?

⬜ Assume the signed healthcare agreement covers every feature and let engineering choose freely.
⬜ Have compliance confirm feature eligibility and map retention, deletion, access, and audit controls to named owners and evidence before approval.
⬜ Start with de-identified samples and decide on retention, access, deletion, and audit once usage stabilizes.
⬜ Take the fastest path and treat encryption as proof the whole workflow meets every obligation.

A recruiting application uses Claude to summarize evidence and recommend which candidates get extra review. Candidates can be adversely affected, but the interface shows only a score and an AI disclaimer. The company needs meaningful transparency for candidates, recruiters, and auditors without exposing private prompts or hidden reasoning. What should the architect recommend?

⬜ Publish the full system prompt and the raw reasoning as the explanation for each recommendation.
⬜ Show only a general AI disclaimer, since real decision factors might reveal proprietary process details.
⬜ Let recruiters override without explanation and use the override rate as the only transparency measure.
⬜ Show source-backed decision factors and known limitations, record accountable approvals, and provide a documented review and appeal process.

An incident-response agent can read telemetry, restart services, change network controls, and delete cloud resources. Most investigations need read access only, but the same unrestricted credentials stay active for every session, so a poisoned log line or a bad plan could trigger destructive remediation. Which two changes should the architect recommend? (select two)

⬜ Keep every tool available and rely on detailed logs to find destructive misuse after the incident.
⬜ Use a larger model so better instruction following makes up for the broad privileges.
⬜ Remove destructive tools from routine sessions and grant narrowly scoped capabilities only after incident-specific approval.
⬜ Improve the tool descriptions while keeping destructive tools and unrestricted credentials active.
⬜ Require explicit human approval before any irreversible remediation runs against shared production resources or network controls.

A procurement agent retrieves vendor contracts and email attachments, summarizes their terms, and can submit payment-account changes to the finance platform. Security testing shows a supplier can embed instructions in a document that Claude may treat as workflow directions. A fraudulent account change would be hard to undo, and the company wants defense in depth without turning off document analysis. Which architecture addresses this best?

⬜ Screen documents for prompt injection and let Claude execute payment changes when the screen reports low risk.
⬜ Strengthen the system prompt and log completed account changes for later investigation.
⬜ Disable retrieval and have employees paste approved contract terms into every request by hand.
⬜ Treat retrieved text as untrusted, isolate it, and apply deterministic authorization plus human approval to every payment-account change.

A benefits assistant must pass sensitive eligibility guidance through a safety-classification service before showing it. That service sometimes goes down during regional outages. Product wants the assistant to stay responsive; compliance says sensitive guidance must never skip the control. Which two behaviors should the architect specify? (select two)

⬜ When the classifier is unavailable, block or queue sensitive guidance and record the decision instead of bypassing the control.
⬜ Let Claude judge whether a request is safe and continue when its self-reported confidence clears a threshold.
⬜ Monitor the control’s availability and show users a safe message with a documented recovery and escalation path.
⬜ Reuse the last cached classification for every new request until the service is back.
⬜ Shut down the assistant globally whenever one region loses the classifier.

Investment analysts use a copilot to summarize filings and propose research conclusions. The output reads fluently, and junior analysts increasingly accept it without opening the cited material, even when evidence coverage is low. Final recommendations can move substantial capital. Which control best addresses the main risk?

⬜ Use a more capable model and hide uncertainty indicators so analysts stay confident.
⬜ Auto-approve recommendations that are detailed and use professional financial terminology.
⬜ Have analysts rate helpfulness after acting and review the scores quarterly.
⬜ Require evidence review and independent verification before analysts act on a high-impact conclusion, with a formal escalation path for unresolved uncertainty.

A customer exercises a legal right to erase their personal data from a Claude-powered service. Their data may sit in application stores, retrieval indexes, logs, backups, and vendor systems, each with different retention rules. Auditors want evidence that the responsible owners carried out every applicable deletion. Which architecture supports the obligation best?

⬜ Delete the chat history from the primary database and treat that as service-wide erasure.
⬜ Map each data location to an accountable owner and retention rule, run the deletion workflow, and keep auditable proof that it completed.
⬜ Add an erasure statement to the privacy policy and let each engineering team interpret it.
⬜ Remove the user’s name from prompts while keeping linked identifiers in downstream systems indefinitely.

A team is building an agent that sends supplier emails and updates billing records through tools. Compliance requires a human to approve every external action before it happens. Where should the approval step be implemented?

⬜ An instruction in the system prompt telling the model to ask permission before acting.
⬜ An approval gate in the application layer that runs before the model’s tool request is executed.
⬜ An audit log of executed actions that compliance reviews weekly.
⬜ A prompt telling the model to assess each action’s risk in its reasoning and pause when unsure.

An assistant’s system prompt says never to reveal the company’s internal pricing formulas. In red-team testing, adversarial prompts still occasionally get it to disclose them. Which change enforces the requirement most directly?

⬜ Lower the sampling randomness so the model behaves more deterministically.
⬜ Log all responses and audit a weekly sample for violations.
⬜ Add an output filter that blocks any response containing the formulas before it’s delivered.
⬜ Rewrite the system prompt with stronger, all-caps language forbidding disclosure.

A team is preparing pre-deployment fairness testing for an assistant that ranks scholarship applications. Applicant names, gender, and ethnicity have already been removed from the input. What must the evaluation still include to assess fairness properly?

⬜ Spot-checks of a small sample for openly discriminatory or offensive language.
⬜ Ranking outcomes measured across demographic slices, to detect disparities driven by proxy variables.
⬜ A second check that no protected attributes remain anywhere in the input pipeline.
⬜ Reliance on the base model’s alignment training to prevent discriminatory rankings.

An agent runs SQL against a production database to build reports. Its system prompt says to run SELECT statements only, but adversarial testing shows crafted inputs can sometimes get it to issue UPDATE statements. Which control prevents data changes most reliably?

⬜ Set temperature to zero so the model follows instructions deterministically.
⬜ Connect the agent through a database account that has read-only permissions.
⬜ Rewrite the system prompt with stronger warnings against write statements.
⬜ Log every query and review the logs weekly for violations.

A rental platform uses an AI system to screen tenant applications. After complaints from rejected applicants, a housing regulator finds the platform falls short of its obligations to people affected by consequential automated decisions. Which design measure addresses this finding most directly?

⬜ Log every screening decision so auditors can review them quarterly.
⬜ Publish technical details of the model architecture on the help pages.
⬜ Give rejected applicants a meaningful explanation and a route to human review.
⬜ Show a notice saying screening decisions are automated and can’t be appealed.

A team handling regulated customer data has a zero-data-retention (ZDR) arrangement with Anthropic. Which two design decisions correctly account for how the platform retains data? (select two)

⬜ Check each feature’s retention behavior and ZDR eligibility before adding it to the design.
⬜ Treat the organization-wide ZDR arrangement as covering every feature the workload uses.
⬜ Rely on stored batch results expiring automatically to meet the workload’s retention obligation.
⬜ Keep regulated data out of features that store inputs and outputs server-side, such as batch processing.

An email-triage assistant reads inbound messages from outside senders and can file tickets and update customer records. A security review tested only attack prompts typed by authenticated internal users. Which additional test covers the untested attack vector most directly?

⬜ Red-team malicious instructions embedded in inbound email from external senders.
⬜ Test whether received emails can poison the underlying model’s training data.
⬜ Probe for system-prompt extraction through crafted queries from internal users.
⬜ Test jailbreak prompts from authenticated internal users trying to bypass guardrails.

A university deploys a student-facing advising assistant built on Claude. Leadership asks how the design will meet transparency expectations toward students. Which two measures address this most directly? (select two)

⬜ Tell students clearly that they’re talking to an AI system.
⬜ Explain the assistant’s limitations so students can judge how much to rely on it.
⬜ Log every conversation to an internal warehouse for periodic quality review.
⬜ Add the exact model version identifier to every response.

A healthcare team uses structured outputs to extract fields from clinical notes that contain PHI, and has confirmed the feature is HIPAA eligible. Which design constraint must the architecture enforce to keep PHI under HIPAA safeguards?

⬜ Disable prompt caching on every request so no PHI persists between calls.
⬜ Keep PHI in message content only, never in the JSON schema definition.
⬜ Encrypt the schema in transit so cached copies stay protected.
⬜ Turn on zero data retention, which extends HIPAA safeguards to cached schemas.

A coding agent with shell access processes untrusted external content, and testing shows crafted inputs can occasionally push it toward destructive commands. Which two controls reduce the risk of harm most directly? (select two)

⬜ Require human confirmation before destructive or irreversible commands run.
⬜ Run the agent in a sandbox that restricts filesystem and network access.
⬜ Add stronger prohibitions against destructive commands to the system prompt.
⬜ Log every executed command for weekly review.

An agent’s tool calls go through human approval before they run. Partway through a task, a reviewer declines one requested action. How should the application handle the declined request so the agent can keep working usefully?

⬜ Return a fake success result so the workflow carries on uninterrupted.
⬜ Return a tool result saying the action was denied, so the model can adjust its plan.
⬜ End the session, since one denial means the task can’t be finished.
⬜ Remove the declined request from the history and resend the earlier conversation unchanged.

An AI system that shortlists job candidates passed a structured fairness audit before launch. Which two practices most directly keep it fair once it’s in production? (select two)

⬜ Treat the pre-launch audit as enough, since the underlying model doesn’t change.
⬜ Stop calculating demographic breakdowns so no one can claim disparities.
⬜ Rerun the fairness evaluation whenever the model, prompts, or data sources change.
⬜ Monitor production outcomes across demographic groups to catch new disparities.

A legal research assistant grounds every answer in retrieved documents, cites its sources, and is allowed to say “I don’t know.” Stakeholders want to drop human review of high-stakes outputs, arguing that hallucination is solved. What should the architect advise?

⬜ Approve, since grounded, cited answers can’t contain fabricated claims.
⬜ Keep review for high-stakes outputs, because grounding and citations reduce hallucination but don’t eliminate it.
⬜ Keep review only until the model is fine-tuned on the corpus, after which hallucination stops.
⬜ Approve after setting temperature to zero, which makes the model output only verified facts.

A team compares an assistant that approves or denies small-business grant applications against ten years of past human decisions and finds 94% agreement. What should an architect recommend before the team calls the system fair?

⬜ Keep tuning until agreement with the historical record approaches 100%, then call it fair.
⬜ Replace quantitative evaluation with expert judgment, since fairness can’t be measured numerically.
⬜ Treat the historical decisions as ground truth and certify fairness based on the 94% agreement.
⬜ Audit the historical decisions for bias, and evaluate outcomes across applicant groups against independent fairness criteria.

An agent runs unattended in a scheduled overnight pipeline. Some tool calls require human approval, but no reviewer is available during these runs. How should the system handle a gated tool call when it comes up?

⬜ Let the model assess the risk itself and proceed if it judges the call safe.
⬜ Auto-approve gated calls so the run isn’t blocked overnight.
⬜ Treat the unavailable approval as a denial, so the gated action never runs.
⬜ Run the call and log it for a reviewer to inspect in the morning.

An assistant’s system prompt contains proprietary pricing logic the business wants kept strictly confidential. The architect is asked to assess this design. Which two risks or limitations apply? (select two)

⬜ Encrypting the system prompt at rest reliably stops users from extracting it.
⬜ System prompts are architecturally hidden from generation, so they can’t leak.
⬜ Heavy leak-resistant prompt engineering adds complexity that can hurt task performance.
⬜ Users may still extract the prompt’s contents, because leak-prevention techniques aren’t foolproof.

An agent issues customer refunds automatically, and a deterministic check caps each refund at $100. A risk review warns that a malfunctioning or manipulated agent could still issue thousands of small refunds within hours. Which control addresses this remaining risk most directly?

⬜ Export refund records to a data warehouse for monthly reconciliation.
⬜ Enforce an aggregate volume limit in the refund system that halts payouts when it’s exceeded.
⬜ Tell the agent in its system prompt to issue refunds conservatively and rarely.
⬜ Lower the per-refund cap from $100 to $50.

An agent calls an internal data tool on every request. To steer the agent, developers append their own operating instructions to each tool result alongside the data. The agent follows these instructions only some of the time. What change addresses this most directly?

⬜ Restate the instructions in each tool result with stronger, more emphatic wording.
⬜ Set temperature to zero so the model follows them deterministically.
⬜ Upgrade to the most capable model tier to improve compliance.
⬜ Move the operator instructions into the system prompt and keep tool results as pure data.

A team’s assistant summarizes intake submissions and turns out to produce consistently less accurate summaries for users who write in regional dialects. The team blames bias in the base model’s training data. What should the architect recommend?

⬜ Preprocess all submissions into standardized language so every input reaches the model in the same form.
⬜ Accept the limitation and wait for a future base model, since training-data bias can’t be fixed downstream.
⬜ Apply application-level mitigations such as prompt guidance and dialect-diverse examples, then measure the disparity again.
⬜ Lower the temperature so summaries are more consistent across groups.

A public-facing assistant screens its final responses with an output filter, but red-team testing shows jailbreak messages can trigger unsafe tool actions mid-turn, before any final response exists to screen. Which addition reduces this risk most directly?

⬜ Log all tool actions from flagged conversations for weekly security review.
⬜ Classify incoming messages and block likely jailbreak attempts before the model processes them.
⬜ Add more known jailbreak phrases to the output filter.
⬜ Switch to a more capable tier, since stronger models resist jailbreaks better.

---

Domain 6: Stakeholder Communication and Lifecycle Management (14%)

A product board prefers a managed agent capability because it shortens delivery. Security has confirmed that one required data-handling arrangement isn’t supported by that capability, while a Messages API design can meet it with more engineering effort. Product leaders ask the architect to endorse the faster option and call the gap an implementation detail. How should the architect respond?

⬜ Reject agent-based architectures for good because this one capability falls short on a single requirement.
⬜ Delay the decision until the managed service changes, without evaluating the compliant alternative.
⬜ Explain the confirmed limitation and its impact, present the compliant alternatives, and name who can formally accept any residual risk.
⬜ Pick the faster option, describe the gap as temporary, and leave engineering to carry the compliance exposure.

An executive steering committee must approve a support modernization proposal. Engineering prefers a flexible agent, security prefers a bounded workflow, and finance wants the lowest initial cost. The architect has evaluation results for both options covering quality, latency, operating cost, and residual risk. What should the architect present so the decision can be defended later?

⬜ Only the architect’s preferred design, leaving out the rejected option so the message stays simple.
⬜ A decision record comparing business value, cost, risk, and reversibility for each option, with the evidence and the accountable approvals.
⬜ Detailed SDK examples, asking executives to pick whichever looks easiest for engineering to build.
⬜ The expected benefits now, with residual risks discussed later once security reviews the chosen design.

An enterprise Claude platform serves support, engineering, and compliance teams. Support cares most about latency, engineering wants the most capable model, compliance wants conservative safety behavior, and finance has set a cost ceiling. Each group says the platform is failing, but each uses its own reports and thresholds. Which two actions establish a workable service agreement? (select two)

⬜ Define measurable objectives for quality, latency, safety, and cost, with owners and an explicit order for resolving conflicts between them.
⬜ Instrument metrics per segment, with breach triggers, regular reviews, escalation paths, and documented decisions for material changes.
⬜ Publish one overall availability number as the whole SLA and let each group interpret everything else itself.
⬜ Let finance set the platform objective alone, since cost is the easiest thing to measure.
⬜ Keep separate, undocumented targets per team and reconcile them only after a major incident.

A Claude prototype has shown value with a small curated dataset and five internal users. The sponsor wants to open it to every employee next month, but adversarial inputs, realistic load, access boundaries, and failure recovery haven’t been tested, and nobody owns monitoring or on-call. What should the architect require next?

⬜ Release to everyone and let production usage reveal requirements before adding controls.
⬜ Treat the sponsor’s enthusiasm as production acceptance, since value has already been shown.
⬜ Tune the model for lower cost first and set up monitoring once usage settles.
⬜ A production-readiness gate covering representative evaluation, security, data handling, and observability, with named owners and a rollback plan.

A financial-services team wants Claude to summarize applications and recommend cases for enhanced review. Stakeholders have provided sample prompts and a preferred model, but haven’t said how a wrong recommendation affects an applicant or which records may be used. Which two missing requirements should the architect pursue first? (select two)

⬜ Which decisions stay with humans, what errors cost, and the escalation triggers and evidence required before anything happens downstream.
⬜ Choose the most capable model before identifying prohibited decisions or acceptable error rates.
⬜ The authoritative data sources, retention constraints, audit requirements, and representative evaluation cases.
⬜ Ask compliance to sign off once a few demos look accurate to the implementation team.

A consulting team has finished a Claude solution design and is handing implementation to an external partner in another region. The partner wasn’t part of discovery, and the solution includes retrieval, tool calls, human approvals, and regulated-data boundaries. Procurement asks for a single architecture diagram to speed onboarding. What’s the minimum handoff package that’s actually sufficient?

⬜ Versioned architecture views, interface contracts, trust boundaries, decision records, evaluation gates, runbooks, and named escalation owners.
⬜ The final architecture diagram, with questions answered as they come up during development.
⬜ The prototype repository, leaving the partner to infer data flows, controls, and responsibilities from the code.
⬜ The Claude prompts only, leaving infrastructure and governance to the implementation team.

An operations director wants an autonomous Claude agent to resolve service exceptions end to end. Interviews show that regional teams follow different procedures, several exceptions need a manager’s judgment, and nobody has defined acceptable error rates. The sponsor wants a model chosen and a pilot started this week. What should the architect do next?

⬜ Run structured discovery to define outcomes, data sources, exception paths, human decision points, and measurable acceptance criteria.
⬜ Commit to an autonomous agent and find the constraints while staff test unrestricted actions on live records.
⬜ Build one augmented call around the current procedures and treat the request as the full requirements.
⬜ Choose a deterministic workflow on principle, before understanding how much flexibility is needed.

A mature support assistant has to move to a newer Claude model and replace its retrieval index at the same time. Evaluations show answer quality depends on how retrieved passages interact with model behavior. The release window is fixed, and operations needs a fast return to the current baseline if quality or latency drops. Which migration plan best handles the risk?

⬜ Swap both the model and the index for all traffic at once, since a mature assistant has a stable baseline.
⬜ Change only the model first and accept any retrieval regression as an unavoidable side effect.
⬜ Keep the current system indefinitely, since changing both makes meaningful evaluation impossible.
⬜ Compare versions in shadow mode, then canary the combined change with guardrail monitoring and a separate rollback path for each component.

A production knowledge assistant breached its agreed latency and answer-quality objectives after a large corpus expansion. Business leaders want quick assurance that service is back, while engineering suspects only one document class and one region are affected. The incident process names product, engineering, and risk owners but hasn’t been triggered. What should the architect recommend?

⬜ Promise the SLA is restored immediately and have engineers tune prompts before isolating the affected workload.
⬜ Stop collecting user feedback until the original latency target is met again.
⬜ Lower the quality threshold without stakeholder approval so reported performance recovers within the window.
⬜ Trigger the breach process, segment the affected requests, and share the evidence and recovery options with the owners at defined review checkpoints.

A pilot assistant meets the product team’s response-time goal, but compliance expected mandatory review for certain cases and operations assumed round-the-clock support that was never funded. Each group now says the pilot failed for a different reason. The architect has to restore alignment before more money is spent. What’s the best action?

⬜ Reconcile the original assumptions into measurable service levels with explicit exclusions, and assign an owner to each review trigger.
⬜ Let the product team’s latency target decide, since it’s the only requirement measured in production.
⬜ Pause until every stakeholder agrees that all outcomes have equal priority.
⬜ Add a larger model and continuous support now, since more capability will satisfy everyone.

A newly launched service-desk assistant reports very few escalations, and leaders read that as success. Interviews show some users abandon sessions or open separate tickets when answers don’t help, and those events aren’t linked to the session. The team needs a feedback loop that tells real resolution apart from silent failure. Which two changes come first? (select two)

⬜ Link each session to its actual outcome, distinguishing resolution from abandonment, correction, a follow-up ticket, or negative feedback.
⬜ Keep using escalation rate alone, since users who leave without escalating probably solved it themselves.
⬜ Make responses longer so users get more information before deciding to leave.
⬜ Create centrally governed review triggers for adverse trends, with owners assigned by issue type, affected users, and the relevant SLO.
⬜ Have support review one random transcript a year without linking sessions to outcomes.

Procurement is comparing direct Claude API access with cloud-platform delivery routes for a multi-region enterprise deployment. Identity integration, compliance evidence, feature availability, latency, commercial terms, and exit strategy all differ by route. A sponsor wants the incumbent cloud vendor before any of this has been analyzed. What should the architect recommend?

⬜ Choose the incumbent cloud now, since existing procurement always outweighs technical and compliance differences.
⬜ Choose direct access for earlier features and make security accept the identity and evidence gaps.
⬜ Build every route at once and defer the trade-offs until production traffic arrives.
⬜ Compare each route against the enterprise requirements, checking identity, compliance support, feature availability, latency, operating cost, and exit options before approval.

A search assistant has gradually degraded as new products and query types outgrew its original index and prompt design. Small prompt fixes help some cases while repeatedly breaking others, and operators can roll changes back. Leaders need to decide whether to keep iterating or redesign retrieval. Which approach best supports that decision?

⬜ Keep editing prompts, since a retrieval redesign takes more engineering effort up front.
⬜ Replace the whole system now, without finding which slices or components are failing.
⬜ Freeze the system and lower the quality targets so current results fit the service level.
⬜ Use slice-level diagnostics and explicit architecture thresholds to choose between targeted iteration and a controlled redesign with rollback.

An internal knowledge assistant drew many employees in its launch month, but repeat usage has fallen steadily. Aggregate answer scores are stable, and the product team wants to add features right away to win users back. The architect suspects activation never reflected lasting value and wants evidence before the roadmap changes. Which two actions should the architect take? (select two)

⬜ Use the registered-user total as the main success measure, since it stays stable even when people stop coming back.
⬜ Measure whether users complete tasks, need corrections, abandon workflows, or escalate, and compare repeat use and feedback across user groups and workflows.
⬜ Build the most-requested feature first, on the assumption that stated demand proves it will bring users back.
⬜ Interview both retained and departed users, connect what they say to observed usage, and define measurable hypotheses before reprioritizing.
⬜ Replace the model, since stable answer quality can’t coexist with declining usefulness.

An architect is starting discovery for an assistant that should speed up insurance claims handling. So far every requirement has come from senior managers who don’t process claims themselves. What should the architect do next?

⬜ Interview and observe frontline claims handlers to see how the work is actually done.
⬜ Send managers a feature checklist to rank before design starts.
⬜ Build a prototype from the management requirements and gather feedback in testing.
⬜ Finalize the requirements from management, since managers own the process and the budget.

During discovery for an internal reporting assistant, two department heads give conflicting definitions of a successful response, and each expects the system to follow theirs. What should the architect do before moving into design?

⬜ Design two response variants so each department gets its preferred behavior.
⬜ Adopt the definition from the more senior of the two.
⬜ Start design now and resolve the disagreement during user acceptance testing.
⬜ Run a session to reconcile the two definitions into shared, measurable success criteria.

A sponsor wants the service agreement for a new assistant to say only that responses will be “fast and accurate.” What should the architect do before the SLA is final?

⬜ Commit to the vague wording for launch and set numeric targets once production data exists.
⬜ Accept it as written, since loose terms give the delivery team flexibility.
⬜ Guarantee zero errors so the sponsor’s accuracy concern is fully covered.
⬜ Turn the wording into measurable targets, such as percentile latency and accuracy thresholds.

A hospital network’s governance board, mostly non-technical, asks an architect to justify choosing retrieval augmentation over fine-tuning for a clinical policy assistant. Which communication approach conveys the decision most effectively?

⬜ Say retrieval augmentation is the industry standard and needs no further justification.
⬜ Walk the board through embedding generation, vector search, and retrieval internals.
⬜ Pass the question to the board’s engineering advisors and carry on with the plan.
⬜ Frame the trade-off around the board’s own requirements, such as policy freshness and cost, supported by evaluation evidence.

Six months after go-live, a sponsor asks whether the assistant still meets the expectations agreed during discovery. Which two practices sustain that alignment over time? (select two)

⬜ Feed user feedback and downstream corrections into the evaluation set and share the trends.
⬜ Report performance only when a target is missed, to cut down on reporting noise.
⬜ Report regularly against the SLA targets and success criteria agreed at launch.
⬜ Give the sponsor raw dashboard access and let them draw their own conclusions.

An architect chose a fixed workflow over an autonomous agent for a claims-intake pipeline. Engineers who join later keep challenging the choice and proposing a rebuild as an agent. Which practice best preserves the reasoning and stops these recurring debates?

⬜ A decision record documenting the context, the alternatives considered, and the trade-offs.
⬜ Inline code comments saying the workflow pattern is intentional.
⬜ A team policy saying the architecture can’t change without sign-off.
⬜ A live walkthrough each time a new engineer questions the design.

An architect reviews the delivery plan for a document-classification project at a utility. It runs from discovery through design, build, and go-live, then ends with nothing scheduled after launch. What should the architect recommend?

⬜ Approve it, since a well-designed solution shouldn’t need changes after launch.
⬜ Schedule a one-time prompt rewrite six months after launch.
⬜ Add a post-launch monitoring and iteration phase with clear operational ownership.
⬜ Extend pre-launch testing until the system is proven, so post-launch work isn’t needed.

An architect is writing an implementation guide for engineers who will build a Claude solution with several custom client-side tools. None of them has integrated an LLM before. Which point is most important to state explicitly?

⬜ Claude only requests tool calls; the application runs them and sends back the results.
⬜ Including tool definitions makes the API run the tools automatically when they’re relevant.
⬜ Client-side tools require managed infrastructure, so the team should move to Claude Managed Agents.
⬜ Custom tools run on Anthropic’s servers, the same way the web search tool does.

An architect is presenting a recommended architecture to a client’s steering committee for sign-off. Evaluation results meet the agreed targets overall, but testing found a known weakness on one rare category of input. How should the architect handle it in the presentation?

⬜ Disclose the weakness with its measured impact and the planned mitigation.
⬜ Postpone sign-off until testing shows the weakness is gone.
⬜ Mention it only if someone asks about edge cases.
⬜ Show only the aggregate metrics that meet the targets.

An architect and a client sponsor are finalizing the SLA for an insurance claims-triage assistant before launch. Which two practices align expectations best? (select two)

⬜ Base latency and quality targets on measured performance under realistic load.
⬜ Accept the sponsor’s requested targets and commit to optimizing toward them after launch.
⬜ Guarantee zero misclassifications to secure the sponsor’s confidence.
⬜ Agree in advance how missed targets will be handled and escalated.

Monitoring of a recruitment assistant shows a growing share of users asking it to draft offer letters, which was never scoped in the original engagement. The team proposes extending the system prompt to cover these requests. What should the architect recommend?

⬜ Extend the prompt now, since the infrastructure already supports the requests.
⬜ Move to a more capable model so broader requests are handled reliably.
⬜ Configure the assistant to permanently refuse offer-letter requests as out of scope.
⬜ Run a scoped discovery pass for the new use case before extending the solution.

A consultancy will support a deployed AI solution for three months before the client’s operations team takes full ownership. Which two practices structure this transition best? (select two)

⬜ Define which responsibilities move at each milestone and agree on exit criteria for full ownership.
⬜ Extend support indefinitely until the client team says it feels fully confident.
⬜ Move incident handling to the client team step by step, with the consultancy shadowing and reviewing each response.
⬜ Have the consultancy resolve every incident so the client team never sees production failures.

An architect has finished discovery workshops for a contract-analysis assistant. Business goals and success criteria are agreed, but nobody has yet looked at the contracts the system will process or where they’re stored. What should the architect do before design begins?

⬜ Build a prototype on synthetic contracts to validate the design before touching real data.
⬜ Assess the contracts’ availability, quality, access constraints, and compliance obligations.
⬜ Move into design, since agreed success criteria are enough to anchor the architecture.
⬜ Pick the model tier first and derive the data requirements from its capabilities.

An architect has to explain the decision to run a new document-triage assistant on a faster, cheaper tier instead of the most capable model. The audiences are the executive steering group and the delivery engineering team. Which approach works best?

⬜ Simplify the message for both by leaving out the measured latency and cost trade-offs.
⬜ Show both groups the same detailed technical deck so the message stays consistent.
⬜ Give executives only the conclusion and keep the reasoning for the engineers.
⬜ Tailor the framing to each audience while keeping the facts and conclusion identical.

Halfway through a build, testing shows that the fixed workflow the architect chose during design can’t handle how varied real production inputs are. Switching to an agentic pattern would raise cost and stretch the timeline. How should the architect tell the sponsor?

⬜ Wait for the next scheduled steering review so the change goes through the formal channel.
⬜ Keep the original architecture and log the input variability as a known limitation.
⬜ Promptly present the new evidence, the revised recommendation, and its cost and schedule impact.
⬜ Rework the architecture quietly and absorb the extra cost inside the existing budget.

An architect has finished evaluating two viable architectures for a manufacturer’s maintenance-log analysis solution and will present them to the client’s technical review board, which must approve the design. Which presentation structure best supports the board’s decision?

⬜ Compare both options against the agreed decision criteria, then give a clear recommendation and its trade-offs.
⬜ Walk through every architecture explored in equal detail and let the board choose with no recommendation.
⬜ Present only the recommended architecture so debate isn’t reopened.
⬜ Share the raw benchmark data and hold back a recommendation until the board forms its own view.

An architect is planning discovery workshops for an assistant that will summarize a utility company’s field-maintenance reports. Which two activities belong in discovery? (select two)

⬜ Write the exact system prompt wording and its few-shot examples.
⬜ Choose the specific model tier and configuration for production.
⬜ Assess the legal, privacy, and access constraints that limit what the solution may do.
⬜ Investigate how reports are handled today: volumes, pain points, and who uses them.

An architect is documenting how to control JSON output format on a current-generation Claude model. The application validates responses and retries failures. Which two approaches should the guide recommend? (select two)

⬜ Prefill a partial assistant message so the model continues in the required format.
⬜ Set temperature to zero so the model always produces valid JSON.
⬜ State the exact output format requirements directly in the system prompt.
⬜ Use structured outputs to constrain responses to the required schema.

Three months after launch, the assistant’s dashboards show every agreed SLA target being met, yet the sponsor reports a steady rise in user complaints. Which two actions best restore alignment? (select two)

⬜ Propose revised success criteria to the sponsor and re-baseline reporting against them.
⬜ Present the passing dashboards as evidence that the complaints aren’t systemic.
⬜ Analyze the complaints to find quality dimensions the agreed metrics don’t capture.
⬜ Report less often so short-term complaint spikes average out.

An architect is writing the build-path section of an architecture document for two workloads: a latency-sensitive assistant that needs a custom agent loop with fine-grained control, and long-running asynchronous research tasks. What guidance should the document give?

⬜ Use the Messages API for the custom agent loop and Claude Managed Agents for the asynchronous research work.
⬜ Use the Messages API for both, since direct access always gives finer control.
⬜ Use Claude Managed Agents for both, since the managed harness minimizes custom infrastructure.
⬜ Document both paths as interchangeable and let each engineer choose.

An engagement covers two Claude workloads: an interactive customer-support assistant and an overnight batch document-classification pipeline. The sponsor proposes one SLA committing both to sub-two-second response times. What should the architect recommend?

⬜ Drop latency from the agreement and commit to accuracy and uptime only.
⬜ Adopt the single sub-two-second target for both to simplify monitoring.
⬜ Move the batch pipeline to the fastest tier so both can meet the stricter target.
⬜ Set separate latency targets that reflect each workload’s real-time needs and users’ expectations.

During discovery for an assistant that will draft clinical discharge summaries, stakeholders expect it to “save clinicians significant time,” but nobody has measured how long summaries take now. What should the architect do?

⬜ Accept the expectation and quantify the results after launch.
⬜ Measure the current process to establish a baseline before setting improvement targets.
⬜ Use an industry-standard time-saving figure from published AI productivity studies.
⬜ Go straight to design, since the time savings will be obvious once the assistant is live.

An architect is wrapping up the design phase of an AI engagement, and the build starts next week. Which two items need to be settled before it begins? (select two)

⬜ The operational runbooks the client’s support team will use after handoff.
⬜ A labeled sample of the deployed system’s own outputs for the monitoring feedback set.
⬜ The evaluation approach that will verify outputs against the agreed success criteria.
⬜ The architectural pattern and how the solution’s components will interact.

---

Domain 7: Developer Productivity and Operational Enablement (7%)

A platform team wants every repository to follow the same Claude-assisted pull-request review process. It includes repository-specific review guidance, deterministic lint and test checks, and a required maintainer decision before merge. Teams need to version the process and update it without rewriting personal prompts. Which design fits best?

⬜ Each developer keeps the review instructions in a personal prompt and maintains their own version.
⬜ Package the review procedure as a project skill, run the deterministic checks in CI, and require a maintainer’s approval to merge.
⬜ Merge automatically once Claude has commented, using the number of comments as the quality bar.
⬜ Put the whole procedure in CLAUDE.md without automated tests, since project guidance can enforce the checks.

A global company is rolling Claude Code out to hundreds of repositories. Security needs non-bypassable restrictions on certain tools and sensitive paths, while teams need repository-specific build commands and review conventions. Developers may adjust harmless preferences but must not weaken enterprise controls. Which configuration approach fits best?

⬜ Enforce organization-wide restrictions through managed settings and use project scope only for repository-specific workflow guidance.
⬜ Put the mandatory restrictions in each developer’s user settings so they can change them when a repository needs an exception.
⬜ Commit one unrestricted settings file to each repository and rely on source control to enforce policy.
⬜ Use CLAUDE.md instructions for mandatory restrictions, since Claude reads project guidance at session start.

A team has configured an MCP server for Claude Code. Some developers can’t see its tools; others see them but get permission denials. The server works from a standalone client, and the model supports tool use. Configuration exists at several scopes because teams experimented during rollout. What should the team inspect first?

⬜ Change the model, since missing MCP tools usually mean the model can’t discover them.
⬜ Reinstall Claude Code before checking anything else.
⬜ MCP connection status and authentication, the tools actually discovered, and the permission decisions, to find exactly where it fails.
⬜ Add the server at every scope and allow all MCP tools to remove the uncertainty.

A regulated enterprise will let contractors use Claude Code on a limited set of repositories. Contractors must not read certain sensitive directories or use unapproved tools, and security needs central evidence of tool activity. Repository teams can provide workflow guidance but can’t approve policy exceptions. Which two controls should the architect include? (select two)

⬜ Give contractors the same permissions as employees and rely on later code review to catch misuse.
⬜ Store unrestricted access rules in each contractor’s local settings so admins can’t change them.
⬜ Use managed settings to enforce approved tools and deny sensitive paths, and limit contractor identities to the required repositories and roles.
⬜ Run Claude Code inside approved sandbox boundaries and export tool activity and usage events to central monitoring.
⬜ Ask contractors to agree verbally to stay away from regulated files and unapproved tools.

Developers say Claude Code starts slowly and loads different tools in similar repositories. Application tests are fine, but teams recently changed hooks, plugins, skills, and MCP configurations at several scopes. Engineers want to start editing project code to speed it up. What should the architect recommend first?

⬜ Refactor the application, since slow Claude Code startup usually means slow production code.
⬜ Delete every configuration file and recreate settings from memory until startup is faster.
⬜ Upgrade the model for every team, since stronger reasoning speeds up hook and plugin initialization.
⬜ Use Claude Code’s diagnostic commands to see which settings and extensions actually load before changing any project code.

A platform team must migrate a deprecated API across many repositories. The work splits cleanly by service, but every generated edit must follow that repository’s conventions, pass deterministic tests, and get code-owner approval before a staged release. The team wants Claude Code to speed things up without weakening engineering controls. Which workflow fits best?

⬜ One unrestricted session edits every repository and merges everything automatically.
⬜ Give Claude Code repository-specific guidance, split the migration into independent changes, run deterministic tests, and require code-owner approval before a staged release.
⬜ Use Claude Code only to explain the old API and have engineers do every migration by hand.
⬜ Skip repository guidance and let the largest model infer conventions from whatever files it reads first.

A team uses Claude Code to repair failing tests in a safety-critical service. Some patches look plausible but treat symptoms without reproducing the original failure, and reviewers get changes too broad to assess quickly. The architect wants a repeatable workflow that’s faster without weakening accountability. Which two practices should the team adopt? (select two)

⬜ Require a deterministic reproduction of the failure, repository guidance, and a narrowly scoped repair plan before Claude changes implementation code.
⬜ Accept any patch that makes the failing test pass, skipping regression tests, root-cause analysis, and diff review.
⬜ Grant unrestricted repository permissions so Claude can fix unrelated issues in the same session.
⬜ Run focused and regression tests, review the full diff, and require explicit code-owner approval before any generated fix is applied.
⬜ Replace human review with a second Claude session, since an independent model gives equivalent accountability.

After an enterprise policy update, Claude Code unexpectedly gains access to a tool a team thought was blocked. Application code hasn’t changed, but the environment includes managed settings, user settings, repository configuration, plugins, hooks, MCP servers, and permission rules. The architect must understand the effective configuration before proposing a fix. What should happen first?

⬜ Rewrite application authorization, treating the access as a product-code defect.
⬜ Reinstall Claude Code, assuming installation state overrides all settings.
⬜ Delete all repository configuration and connected tools, then rebuild with restrictive defaults.
⬜ Inspect every effective configuration layer and permission rule using the precedence diagnostics to find which one actually grants the tool.

A team’s project instructions tell Claude Code to run the formatter after every file edit. Claude usually does, but sometimes skips it, and unformatted code keeps reaching review. What’s the most reliable fix?

⬜ Have developers re-prompt Claude to run the formatter whenever it’s skipped.
⬜ Add stronger emphasis, such as IMPORTANT, to the formatting instruction.
⬜ Configure a PostToolUse hook that runs the formatter automatically after each file edit.
⬜ Repeat the formatting instruction in several places in the instructions file.

A team streams responses to users to keep perceived latency low. Its dashboard, based on HTTP status codes, shows a near-perfect success rate, yet users report answers that stop mid-response with nothing logged. What should the team change first?

⬜ Handle and log the error events that arrive inside the stream after the connection has succeeded.
⬜ Raise the SDK retry limit so transient errors are retried more often.
⬜ Increase the response timeout so long generations can finish.
⬜ Turn off streaming so every failure shows up as a non-success HTTP status.

A team’s shared CLAUDE.md tells Claude Code never to read files in the repository’s credentials directory, but those files still get read now and then. The team wants the restriction guaranteed in every member’s sessions for this repository. What should they do?

⬜ Restate the restriction in every custom subagent’s system prompt.
⬜ Move the instruction to the top of CLAUDE.md and mark it IMPORTANT.
⬜ Add a deny permission rule for that path in the checked-in project settings.
⬜ Copy the instruction into each developer’s user-level CLAUDE.md.

A developer uses Claude Code for multi-file changes. Claude often says the work is done when it later fails testing, so the developer now checks every change by hand and has lost most of the time savings. Which adjustment does the most to reduce manual supervision?

⬜ Give Claude a runnable check, such as the test suite, and have it iterate until the check passes.
⬜ Require manual approval before every file edit to catch mistakes earlier.
⬜ Move to the most capable model so output needs less checking.
⬜ Write more detailed prompts listing every edge case before each task.

A platform team must make sure organization-wide coding standards load into every Claude Code session on every developer machine and in every repository, and that developers can’t opt out. Which deployment approach meets these requirements?

⬜ Commit a CLAUDE.md to the root of every repository.
⬜ Ask each developer to add the standards to their personal CLAUDE.md.
⬜ Deploy a managed CLAUDE.md to the system policy location through configuration management.
⬜ Express the standards as deny permission rules in a shared project settings file.

A summarization service sometimes returns output that stops mid-sentence. Every call returns HTTP 200 and nothing shows in the error logs. An engineer wants to raise the output-token limit right away. What should the team do first?

⬜ Move to the most capable tier, since mid-sentence cutoffs mean insufficient capability.
⬜ Raise max_tokens on every request on the assumption that the cap was hit.
⬜ Add automatic retries with exponential backoff so truncated responses are regenerated.
⬜ Inspect the affected requests and responses, including the stop reason, to see what’s ending generation before changing anything.

A team’s Claude Code workflows depend on three MCP servers: an issue tracker, a database, and a monitoring service. New members set each one up by hand, and configurations drift over time. What standardizes these connections most effectively?

⬜ Document the server setup commands in the project’s CLAUDE.md.
⬜ Hand new members a one-time shell script that registers the servers.
⬜ Commit a project-scoped .mcp.json file to the repository so every clone loads the same servers.
⬜ Have each developer add the servers to their user-level configuration.

A team has built several specialized Claude Code subagents for code review and debugging. Which two practices organize them best for team and personal use? (select two)

⬜ Paste each subagent’s full instructions into the shared CLAUDE.md so every session loads them.
⬜ Keep personal cross-project subagents at user scope on each developer’s machine.
⬜ Check project-specific subagent definitions into version control so the whole team shares them.
⬜ Ask each developer to install the team’s subagents manually at their own user scope.

A project’s CLAUDE.md has grown to thousands of lines, including full API documentation, file-by-file codebase descriptions, and workflow guides that are used only occasionally. Claude now routinely ignores the coding standards it contains. What’s the most effective fix?

⬜ Add IMPORTANT and YOU MUST to every instruction in the file.
⬜ Start each session by asking Claude to reread the whole file carefully.
⬜ Repeat the coding standards at the start and end of the file.
⬜ Cut the file down to broadly applicable rules and move the occasional workflows into skills.

A team shares Claude Code configuration through a settings file committed to the repository. One developer needs a machine-specific environment value for this project that must not be committed or affect teammates. Where should it go?

⬜ In the project’s local settings file, which is kept out of version control.
⬜ In the developer’s user-level settings, so the repository is never touched.
⬜ In the committed shared project settings, so it loads reliably every session.
⬜ In organization-managed settings, so it can’t be changed by accident.

A team’s service wraps an official Anthropic SDK and also adds its own immediate-retry loop around every failed call. During a brief API overload, outbound request volume spiked to several times the user traffic, and errors lasted longer than expected. What change addresses this most directly?

⬜ Disable the SDK’s retries and keep the immediate application-level loop.
⬜ Remove the application-level retry loop and rely on the SDK’s built-in exponential backoff.
⬜ Raise the application retry count so more attempts succeed during the overload.
⬜ Treat overload errors as fatal and show every failure directly to users.

---