Claude Certified Developer - Foundations (CCDV-F) Exam Questions

Domain 1: Agents and Workflows (14.7%)

A research system must assess four independent vendors and then make one recommendation against a shared scoring rubric. Every step must stay inspectable. Which execution pattern fits best?

⬜ Research the vendors one after another in a single agent, then have separate reviewers redo all the research before synthesis.
⬜ Have a supervisor delegate the vendor investigations in parallel, then synthesize the results against the shared rubric.
⬜ Let independent researchers each publish a recommendation, with no coordinator comparing their evidence against the rubric.
⬜ Store the vendor names in memory and let a later session produce the recommendation.

A claims service always runs four known steps: extract fields, validate a schema, compare policy rules and route exceptions for human approval. Only the policy step benefits from Claude, and the team needs predictable paths, bounded cost and auditable checkpoints. Which architecture fits?

⬜ Give an autonomous agent every service tool and let it choose the order, completion criteria and approval timing.
⬜ Run several independent agents that vote on every step, including schema validation.
⬜ Put all four steps in one prompt and rely on Claude to follow the order.
⬜ Build a predefined workflow, use Claude only for the bounded policy step, and keep programmatic validation and human approval.

A maintenance assistant interprets open-ended incident evidence and proposes actions, but every executed action must pass a machine-enforced target allowlist and change window. Which design fits?

⬜ Claude proposes actions, and each proposal passes deterministic policy validation before the executor runs it.
⬜ Claude both proposes and approves actions, so one model decision keeps control in one place.
⬜ Several agents vote, and the majority choice runs without checking it against trusted state.
⬜ The policy is written into the prompt, and the agent calls the executor directly.

A tool can keep returning the same recoverable error, and the agent loop is while True: response = create(...); if response.stop_reason == "end_turn": return response; request = handle_tools(...). What prevents an endless run?

⬜ Remove the end_turn check so every response goes through another tool cycle.
⬜ Treat every tool_use response as a successful finish.
⬜ Add a maximum turn or tool-call budget and return a controlled error when it’s exceeded.
⬜ Reset the conversation after each call so the model can’t see earlier failures.

A team picks Claude Managed Agents with asynchronous sessions and an attached memory store for customer preferences. What does this choice most directly mean for the deployment?

⬜ Anthropic hosts the agent harness, including the asynchronous sessions and the scoped memory store.
⬜ The application runs every loop in its own web process and builds persistence, scheduling and scaling itself.
⬜ Managed sessions can’t use tools, because asynchronous execution returns only final text.
⬜ The client must keep its connection open until all the long-running work finishes.

An Agent SDK PreToolUse callback in TypeScript should block an unapproved deploy call, but the deploy still runs. The callback logs “Denied” and then returns {}. What’s the defect?

⬜ The callback reads approved from tool_input, but callbacks can’t inspect tool arguments.
⬜ The callback checks “deploy” in lowercase, but the SDK makes every tool name uppercase.
⬜ Async callbacks can’t make permission decisions; only synchronous ones can block tools.
⬜ The denied branch returns an empty object, so no deny permission decision reaches the runtime.

A support agent should remember each customer’s communication preference across sessions without keeping raw transcripts. Which design fits?

⬜ Replay full transcripts in every session to recover the preference.
⬜ Store the validated preference in customer-scoped memory and start each session with a fresh context.
⬜ Expect Claude to recall earlier sessions without supplying any saved state.
⬜ Keep all customers’ preferences in one shared memory record.

A team needs durable state, explicit transition rules, resumable human approvals and visual inspection of every branch of a workflow. Which approach fits?

⬜ A stateless tool loop that rebuilds earlier decisions from logs after an interruption.
⬜ One prompt that asks Claude to remember stages, approvals and branch state.
⬜ A state-graph framework that models transitions, durable checkpoints, approval pauses and resumable execution.
⬜ Independent agents for each branch, without recording dependencies or approval state.

A team is building a repository maintenance agent in Python and wants built-in file and command tools, sessions, permissions and an existing agent loop instead of building each piece. What fits?

⬜ Use the Anthropic client SDK and write a custom loop with file access, command execution, permissions and session storage.
⬜ Call the Messages API once with the repository path and expect Claude to edit the files.
⬜ Use the Claude Agent SDK with an explicit set of allowed tools, and consume its async message stream.
⬜ Run several Messages API calls in parallel and take the first response as the result.

A compliance system runs mandatory deterministic checks, then an open-ended investigation that may need different evidence tools for each case, and the final decision must pass an approval step. Which two architecture choices fit? (select two)

⬜ Give one autonomous agent control of the checks and the investigation, and let it approve its own decision.
⬜ Replace the investigation with a script that queries every source in the same order.
⬜ Implement the mandatory checks and the approval as deterministic workflow stages the model can’t skip.
⬜ Let a bounded agent choose investigation tools within its stage and return its findings to the workflow.

A TypeScript Agent SDK deployment agent inspects releases, runs tests and requests production rollouts. Production changes need external approval, while read-only investigation should proceed automatically. How should it be built?

⬜ Allow every tool at session start and add a final prompt asking Claude to confirm the approver probably meant it.
⬜ Remove the deploy tool and have Claude print a shell command for another component to run.
⬜ Start a second unrestricted agent whenever a deployment is requested.
⬜ Use a permission callback or hook that auto-allows read-only tools and holds the deploy tool until the approval service authorizes it.

A company must run its migration agent inside an existing Kubernetes cluster that already has private package mirrors, custom observability sidecars and internal identity controls. Operations staff must own the runtime and deployment lifecycle. Which approach fits?

⬜ A managed agent, because it removes infrastructure work, even though the company needs its own sidecars and runtime control.
⬜ Claude Code on an engineer’s laptop, connected to the production cluster with the engineer’s personal credentials.
⬜ Stateless Messages API calls from the cluster with no agent loop, since the model handles tools and retries itself.
⬜ The Claude Agent SDK hosted inside the company’s Kubernetes service, with its tools wired into the existing runtime, identity and observability controls.

A TypeScript agent edits infrastructure files, and every successful edit must trigger the same formatter and policy scanner before Claude continues, without depending on the model remembering an instruction. What should the developer use?

⬜ A system-prompt line asking Claude to run the formatter and scanner when it thinks they’re useful.
⬜ A PostToolUse hook on the file-edit tools that runs the formatter and scanner and returns the results to the agent loop.
⬜ Running the formatter only after the whole session ends, and discarding the session if anything fails.
⬜ A PreToolUse hook that formats the file before the edit, and assuming the result stays compliant.

A market-research agent investigates many companies over several days, and the main conversation becomes unreliable when every source and note stays in context. Verified findings must survive restarts, and each company’s research must stay separate. Which two changes fit? (select two)

⬜ Store verified findings and their sources in an external persistent store, and retrieve only what the current decision needs.
⬜ Keep every search result in one conversation and rely on compaction to preserve every citation and figure.
⬜ Write unverified notes to persistent memory as soon as they appear, so later sessions can skip re-checking.
⬜ Give each company its own subagent context, returning a concise, validated, structured summary to the coordinator.

Six analysts in a retail forecasting system all update the same demand plan. The proposal is six peer agents that message each other and edit the shared forecast whenever they disagree. Which architecture keeps decisions consistent and recoverable?

⬜ Let every agent edit the forecast directly and reconcile conflicts through later messages.
⬜ Use one coordinator that assigns bounded analyses, collects structured recommendations and applies approved updates to the forecast in a controlled order.
⬜ Run all six agents in one conversation so they share the full transcript.
⬜ Have each agent write its own forecast file and keep the one with the biggest reasoning budget.

An Agent SDK service runs on several stateless containers behind a load balancer and keeps session IDs only in process memory (sessions[user_id] = result.session_id). Users must be able to resume a long investigation even when the next request lands on a different container. What should the developer do?

⬜ Keep sessions in memory and make the load balancer prefer the original container.
⬜ Start a new session for every request and paste in the user’s latest message.
⬜ Store only the final assistant reply and have Claude infer the rest.
⬜ Persist session transcripts and IDs in shared external storage, and resume the session from whichever container gets the request.

A legal filing agent prepares documents but must pause for the client’s signature or clarification. The TypeScript handler throws an error whenever the SDK asks for input, so the analysis restarts from scratch. What preserves progress and keeps the client in control?

⬜ Show the agent’s approval or clarification request to the client, keep the session, and continue that same session with the client’s answer.
⬜ Pick the lowest-risk interpretation, finish the filing and tell the client afterward.
⬜ Discard the paused session and start a new one with only the client’s reply.
⬜ Raise the maximum turn count so the agent decides on its own.

A database migration agent writes a migration, runs it on a disposable copy and checks the resulting schema. When the check fails, it should revise the migration using the failure details and test again. Which pattern is this?

⬜ A single prompt that writes the migration and predicts whether it would pass.
⬜ Parallel agents that each write a migration, then deploying the longest one.
⬜ An evaluator-optimizer loop, where one step proposes the migration and a separate evaluation step returns concrete defects for the next revision.
⬜ A router that sends each failed migration to a different model without the test results.

A media company must transcribe an interview, translate the transcript and then generate subtitles using the translated timing. Each stage needs the exact output of the one before it. How should the workflow run?

⬜ Run all three stages in parallel from the original audio and merge whatever comes back.
⬜ Do everything in one unrestricted conversation, keeping all intermediate audio analysis in context.
⬜ Generate subtitles first, translate them afterward and accept the timing drift.
⬜ Run the stages in order, passing a versioned, structured result from transcription to translation to subtitles.

A public-sector assistant gets requests about permits, tax balances and service outages. Each category has its own tools and rules, and a request should go only to the matching specialist. Which pattern fits?

⬜ One general agent with every tool, choosing freely each time.
⬜ A routing step that classifies the request into a defined category and sends it to that specialist, with only that specialist’s tools.
⬜ Run all three specialists for every request and keep the most complete-looking answer.
⬜ Put all three policies in one system prompt and answer without tools unless the user names a system.

A team is evaluating Claude Managed Agents for long-running asynchronous agent tasks. Which two things can they correctly expect? (select two)

⬜ Stateful sessions that keep context across interactions and can be steered or interrupted mid-run with more events.
⬜ Sessions that produce identical, deterministic output for repeated runs of the same task.
⬜ A Python or TypeScript library that runs the agent loop and tools inside the team’s own process.
⬜ A pre-built, configurable agent harness running in managed infrastructure, so the team doesn’t build an agent loop.

A coding agent built with the Agent SDK works on a large project over many separate sessions. Each new session wastes time re-exploring the codebase and retracing earlier decisions before it makes progress. Which pattern addresses this?

⬜ Turn on prompt caching so the context from earlier sessions is served from cache.
⬜ Replay the full transcripts of all earlier sessions into each new session.
⬜ Move to a model with a bigger context window so the whole project history fits.
⬜ Keep a progress log and feature checklist that the agent updates at the end of each session and reads at the start of the next.

A backend service is written in Go. The team wants to drive the same agent loop and tools that power Claude Code from it, without rewriting the service in Python or TypeScript. What does Anthropic support?

⬜ Claude Managed Agents, since a hosted harness is the only option outside Python and TypeScript.
⬜ The Message Batches API, which runs the Claude Code agent loop asynchronously.
⬜ Running the Claude Code CLI as a subprocess with -p and JSON output.
⬜ The Go client SDK, which includes the same built-in agent loop.

A developer is building an interactive assistant with the Python Agent SDK. Each prompt depends on Claude’s last reply, the conversation must stay in one session, and users must be able to interrupt a long turn. Which interface fits?

⬜ The Messages API with a hand-built loop, since the Agent SDK can’t hold multi-turn state.
⬜ ClaudeSDKClient, which keeps one session across exchanges and supports interrupting a turn in progress.
⬜ query() for each exchange, since every call continues the previous conversation and can be interrupted.
⬜ query() with continue_conversation=True, which also adds interrupt support.

An Agent SDK agent spawns a subagent for almost every step, including single-file edits and quick lookups, which adds latency and cost. Which kind of delegation is actually warranted?

⬜ Sequential steps where each depends on context built up earlier.
⬜ Small single-file edits where the code is already in context.
⬜ Quick lookups that a single search would answer.
⬜ Independent subtasks that can run in parallel and don’t need shared state.

A team building a multi-step research agent is comparing agent frameworks such as LangGraph and PydanticAI with writing a custom harness on the Messages API. What can they correctly expect from a framework?

⬜ Deterministic agent behavior, since the framework controls sampling.
⬜ The vendor hosts the agent loop, so there’s no deployment or scaling work.
⬜ Reusable scaffolding for the tool-dispatch loop, state handling and model calls, instead of building a custom harness.
⬜ Automatically generated system prompts, with no need for prompt design or evaluation.

A team wants Claude to draft a summary, review it against acceptance criteria and then refine it, and the app must log and evaluate each intermediate output before the next step. Which pattern fits?

⬜ Hand the whole task to a subagent in an isolated context.
⬜ Turn on thinking in one call so the model revises internally.
⬜ Raise max_tokens so one response holds the draft, critique and final version.
⬜ Chain separate API calls: draft, review against the criteria, then refine based on the review.

A team wants Claude Managed Agents’ pre-built harness and session management, but a compliance policy requires agent execution on infrastructure they control. What satisfies both?

⬜ Configure a self-hosted sandbox environment, so sessions run on the team’s own infrastructure.
⬜ Use the Anthropic cloud sandbox with network access disabled.
⬜ Rebuild the agent on the Messages API, since Managed Agents sessions run only in Anthropic’s cloud.
⬜ Embed the Agent SDK inside each session to redirect tool execution.

An agent runs every step, including routine log summaries and simple lookups, on its most capable model, which drives up cost. Complex planning really does need that model. What reduces cost without hurting the complex work?

⬜ Delegate the routine subtasks to subagents configured with a faster, cheaper model.
⬜ Move the interactive tool loop to the Message Batches API for the discount.
⬜ Switch the whole agent, planning included, to the cheapest model.
⬜ Lower max_tokens on every request.

An Agent SDK app delegates a security analysis to a custom subagent, which returns a summary. Later in the same session, the analysis must be extended to a second module without redoing the earlier work. What should the app do?

⬜ Resume the existing subagent, which keeps its full conversation history from the earlier run.
⬜ Raise the parent’s max_tokens so earlier subagent results stay available.
⬜ Spawn a new subagent of the same type, since same-type subagents share state.
⬜ Copy the parent’s transcript into a new subagent’s prompt.

A Python Agent SDK script fails at startup with an “API key not found” error, even though a .env file with ANTHROPIC_API_KEY is in the project folder. What fixes it?

⬜ Pass the key as an argument to query(), since the SDK never reads environment variables.
⬜ Move the .env file into ~/.claude/, where the SDK loads it automatically.
⬜ Reinstall the SDK, since the bundled binary is missing.
⬜ Export ANTHROPIC_API_KEY in the shell, or load the .env file in code first, since the SDK reads only the process environment.

A lead agent delegates a dependency audit to a subagent, which checks dozens of manifest files but reports back only that four outdated packages were found. What lets the lead name the packages while keeping the context isolation that justified delegating?

⬜ Raise the lead’s max_tokens.
⬜ Have the lead reread every manifest after the subagent returns.
⬜ Have the subagent’s prompt require the package names and file paths in its final report.
⬜ Move the subagent to a model with a bigger context window.

An Agent SDK app defines a read-only code-reviewer subagent in code and runs with permission_mode dontAsk and allowed_tools of Read, Grep and Glob. Logs show Claude trying to delegate, but every Agent tool call is denied. What fixes this?

⬜ Add Agent to the subagent’s own tools list.
⬜ Switch permission_mode to acceptEdits.
⬜ Name the subagent explicitly in the prompt.
⬜ Add Agent to allowed_tools, so subagent invocations are auto-approved.

Early in a session, a user tells the lead agent that all generated code must stay compatible with an older runtime. The lead later delegates implementation to a custom subagent, whose code ignores the constraint. What fixes this most reliably?

⬜ Run the subagent on the same model as the lead.
⬜ Have the lead review the output and rerun the delegation when the constraint is broken.
⬜ Raise the subagent’s turn limit so it discovers the constraint itself.
⬜ Have the lead restate the compatibility constraint in the task prompt it writes when delegating.

---

Domain 2: Applications and Integration (33.1%)

A product brief says a Claude assistant must classify support tickets and that the service must stay available through one regional outage. The team wants each requirement tested and owned separately. How should the two statements be classified?

⬜ Both are functional requirements, because each one shapes the customer’s experience of the service.
⬜ Both are infrastructure requirements, because the deployed architecture supports each capability.
⬜ Ticket classification is an infrastructure requirement, and outage tolerance is functional product behavior.
⬜ Ticket classification is functional behavior, and outage tolerance is a separate infrastructure availability constraint.

A team’s only requirement says, “The system should extract invoice fields accurately and respond quickly.” Which two additions make it testable? (select two)

⬜ A labeled invoice set, a field-level scoring method and a minimum accuracy threshold that must pass before release.
⬜ A maximum end-to-end latency at a stated percentile, under a stated production load and measurement window.
⬜ Choosing the strongest available model and treating its published capability description as the acceptance threshold.
⬜ Letting reviewers approve outputs informally whenever the extracted fields look reasonable during manual checks.

A new classifier passed its offline tests but may behave differently on live traffic. Reviewers want failures caught before most users are affected. What should happen next?

⬜ Release to a small monitored cohort with predefined rollback thresholds, and expand only when live results meet the criteria.
⬜ Replace the production classifier everywhere, since offline evaluation already proves behavior on live traffic.
⬜ Keep the classifier offline until every conceivable input has been tested.
⬜ Release everywhere and define rollback thresholds after users start reporting problems.

A TypeScript service streams a response with a tool call and runs JSON.parse on every input_json_delta.partial_json value. It throws when a fragment ends mid-string, for example {"city":"San. How should it build the tool input?

⬜ Parse each fragment separately, then merge the objects after message_stop.
⬜ Concatenate the partial_json fragments for the block in order and parse once the block ends, or use the SDK’s streaming helpers.
⬜ Ignore the input_json_delta events and rebuild the arguments from the final text.
⬜ Remove the tools during streaming so the arguments arrive as one text block.

A Messages API request contains "messages": [{"role": "system", "content": "Be concise."}, {"role": "user", "content": "Summarize this."}]. What’s the main problem?

⬜ The user content must be an image block, because Messages requests don’t accept text.
⬜ Instructions that apply from the start belong in the top-level system parameter, not as a message.
⬜ The request needs two user turns before Claude can respond.
⬜ The request must start with assistant content, because prefill is required.

A support app classifies screenshots, and the visual layout affects the answer. How should the request be built?

⬜ Run OCR and send only the extracted text, discarding the image.
⬜ Upload the screenshots as separate files and ask Claude which one belongs to each ticket.
⬜ Send the screenshot as an image content block in the same message as the ticket question.
⬜ Describe each screenshot from memory and leave the image out.

Claude returned a tool_use block with id toolu_123, and the next request fails validation. The user message is [{"type": "text", "text": "Thanks"}, {"type": "tool_result", "tool_use_id": "different_id", "content": "18 C"}]. Which two defects are present? (select two)

⬜ The tool_result uses different_id instead of the id from Claude’s tool_use block.
⬜ The tool_result content is invalid, because tool results can’t be plain strings.
⬜ The message should use the assistant role, because Claude started the tool request.
⬜ The text block comes before the tool_result, but tool results must come first in the content array.

A REST endpoint expects tags as an array of strings and receives {"title": "Quarterly report", "tags": "finance,review", "priority": 2}. What’s wrong with the payload?

⬜ tags is a single comma-separated string instead of an array of separate strings.
⬜ title is invalid, because JSON strings can’t contain spaces.
⬜ priority must be quoted, because REST bodies reject numbers.
⬜ Every property needs a trailing comma for REST compatibility.

An async Python function summarizes independent documents one at a time with for doc in docs: results.append(await summarize(client, doc)), so latency grows with the number of documents. What improves throughput safely?

⬜ Remove async and make the same calls synchronously in the loop.
⬜ Run the summaries concurrently with a bound on how many are in flight, and keep the results in document order.
⬜ Launch every request at once with no limit, timeout or handling for partial failures.
⬜ Cache the first summary and return it for every document.

A pull request changes a response parser to handle text, tool calls, refusals and truncation. Which evidence best supports approving it?

⬜ A reviewer says the new branches look cleaner than the old parser.
⬜ A screenshot shows one text response working on the developer’s machine.
⬜ Table-driven tests with assertions for text, tool_use, refusal and truncated responses.
⬜ A plan to log parser failures after release, with no pre-merge tests for non-text blocks.

A team will replace a widely used Claude client wrapper behind a ClaudeGateway interface across fifty services. Which two practices most reduce the risk? (select two)

⬜ Replace all fifty services and their tests in one unreviewed release.
⬜ Keep the gateway interface and add the new implementation behind the existing contract.
⬜ Run contract and regression tests while migrating services in steps, with rollback points between releases.
⬜ Delete the legacy implementation before checking parity so every service has to switch.

A support classifier must return exactly one category and a confidence value within a set range, using the schema {"category": {"type": "string"}, "confidence": {"type": "number"}}. Which two changes improve enforcement? (select two)

⬜ Accept any category string and rely on reviewers to spot unsupported labels.
⬜ Restrict category with an enum of the labels the application can process.
⬜ Replace confidence with free-form text that has no numeric contract.
⬜ Mark both properties as required, then check the confidence bounds after parsing.

A web app reuses one conversation history for all signed-in users, and users sometimes see details from other people’s sessions. What’s the fix?

⬜ Raise max_tokens so each response can include more of the shared history.
⬜ Tell Claude to forget identities while still loading the same history for everyone.
⬜ Shuffle the earlier messages before each request.
⬜ Store a separate history per authorized user and check access before loading any history into a request.

An app compares two contracts and must show which document supports each finding. Which two message-design choices keep the sources identifiable? (select two)

⬜ Paste both contracts into one string without names or boundaries.
⬜ Send each contract in its own document block with a stable title naming the source.
⬜ Upload only the first contract and have Claude infer the differences.
⬜ Put the comparison question after the document blocks and ask for source-specific citations.

A team is considering a third-party Claude Code plugin that asks for broad filesystem access. What should they do before rolling it out across the organization?

⬜ Install it right away, since marketplace listing guarantees trusted code.
⬜ Grant more access than it asks for so later versions don’t need another review.
⬜ Review its source, publisher, permissions, dependencies and version, and record the approval.
⬜ Copy its marketplace description into CLAUDE.md as the security assessment.

A backend service must call Claude programmatically, pass structured tool definitions and process the responses without a human in the loop. Which surface fits?

⬜ An official Claude SDK in the backend, sending Messages requests with tools and handling the responses.
⬜ An employee pastes each request into claude.ai and copies the answer back.
⬜ Claude Desktop running on the server, driven by automated mouse clicks.
⬜ Requests written into CLAUDE.md files for a future Claude Code session to pick up.

Several services share a production prompt. The team needs reproducible behavior and fast rollback after a regression. Which design fits?

⬜ Let each service edit its own copy without recording which text produced which result.
⬜ Fetch the newest unreviewed prompt on every request.
⬜ Hard-code one prompt in each binary and discard evaluation records after each deployment.
⬜ Publish immutable prompt versions with their evaluations, and switch production through a reversible release pointer.

A regulated extraction service needs reproducible validation and controlled model upgrades. Which two practices support that? (select two)

⬜ Use a moving model alias so upgrades happen without review.
⬜ Pick a different model per request based on current availability.
⬜ Evaluate a candidate model version before deliberately changing the pinned production configuration.
⬜ Record the exact model identifier with each evaluation result and release.

A TypeScript dashboard shows Claude’s output as it streams, but it saves every stream event as if it were a complete response. It must show partial text and still store one reliable final message. What should it do?

⬜ Accumulate the text deltas and block events in memory for display, and after the stream completes, store the SDK’s final assembled message as one assistant turn.
⬜ Save each stream event as its own assistant turn, and merge the rows when the user reloads the conversation.
⬜ Ignore the incremental events, wait for the connection to close and parse the whole stream as one JSON object.
⬜ Restart the request whenever a delta arrives, using the partial text as assistant history for the new request.

A Python route returns response.content[0].text, assuming the first content block is always text. Responses can contain text and tool_use blocks. What should change?

⬜ Convert the whole response object to a string and return it.
⬜ Iterate over response.content and handle each block according to its type.
⬜ Read response.content[-1].text, since the final text always comes last.
⬜ Remove the tools from any request that might return text.

A shared Claude Code plugin depends on two other plugins, and an unreviewed update to one dependency changed behavior in every repository. The team needs reproducible installs and controlled upgrades. What’s the best practice?

⬜ Let every dependency track its newest release, since new versions should be compatible.
⬜ Remove the dependency metadata and let each developer use whatever is installed locally.
⬜ Copy the dependencies into every repository and let teams change their own copies.
⬜ Declare compatible version constraints for the dependencies, test the resolved set and promote updates only through change control.

After Claude asks for inventory data, the next request is [{"role": "user", "content": "Check stock for SKU-19"}, {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "toolu_new", "content": "12"}]}], and the API rejects it. What’s the fix?

⬜ Generate a new tool_use_id for the result.
⬜ Turn the tool result into an assistant text message.
⬜ Include the earlier assistant message with its tool_use block, and return the result in a user message carrying that exact tool_use_id.
⬜ Drop the original user message and send only the tool result.

A workflow tested in claude.ai with project instructions behaves differently once the same user prompt is sent from a backend through the Messages API. What should the developer do?

⬜ Assume the claude.ai project instructions sync automatically to the API through the user’s identity.
⬜ Send the prompt repeatedly until the project instructions take effect.
⬜ Add the project URL to the API message so Claude can fetch the configuration.
⬜ Send the needed instructions explicitly in the API request, versioned with the backend code.

A compliance service keeps asking Claude to analyze the same large policy PDF for different cases. The document rarely changes and shouldn’t be uploaded with every request. What’s the right design?

⬜ Convert the PDF to a long system prompt and resend it each time.
⬜ Upload the PDF once through the Files API and reference the returned file_id in later requests.
⬜ Store the PDF in the app database and send only its record ID.
⬜ Encode the PDF bytes in a JSON string and resend it each time.

A developer asks Claude Code to modernize a widely used authentication module. The change touches many files and could quietly alter security behavior if reviewed as one big patch. What’s the right approach?

⬜ Split the work into bounded changes with focused tests, and review each diff and run integration checks before merging.
⬜ Rewrite the module in one pass and merge once it compiles.
⬜ Turn off version control so Claude can reorganize freely.
⬜ Auto-approve mechanical changes and review only the final tree.

A team shares Claude Code settings in the repository, and developers also have personal settings. A developer’s local setting unexpectedly overrides the team’s permission rule. What should they do first?

⬜ Check the effective configuration and the documented settings precedence, find the higher-priority source, and fix the rule at the right scope.
⬜ Copy the rule into every settings file and rely on the duplicates.
⬜ Delete the repository settings and rely on verbal guidance.
⬜ Rename settings.json to CLAUDE.md, since instructions override configuration.

A company is retiring an old Claude gateway after moving services to a new client library. Several batch jobs still call the old endpoint, and removing it now would break overnight processing. What should the migration owner do next?

⬜ Inventory the remaining callers, publish a deprecation schedule, move each one over through a compatible adapter, and remove the gateway once usage reaches zero.
⬜ Delete the gateway now and let failing jobs reveal who still depends on it.
⬜ Keep both gateways indefinitely and let teams choose, without tracking usage.
⬜ Redirect every old request to the new endpoint without compatibility testing.

A case-management service sends only the latest user message and expects the Messages API to remember earlier turns. After a restart, follow-up answers lose facts the user already accepted. What preserves the conversation?

⬜ Reuse the same API key, since the key lets Claude recover the earlier conversation.
⬜ Persist the conversation in the application, rebuild the ordered user and assistant messages for each request, and keep each case’s history separate.
⬜ Put the accepted facts in max_tokens so the API reconstructs the discussion.
⬜ Send the last assistant reply as a new user message and leave out the original user turns.

A TypeScript transcription service streams a summary to the browser and records the final result. A network drop can leave partial text on screen, and a retry mustn’t create two final records for the same job. Which two actions fit? (select two)

⬜ Store every text delta as its own final summary row.
⬜ Treat streamed deltas as provisional display data, and write the final summary only after the stream completes successfully.
⬜ Give the workflow an idempotency key or job ID, so a retry updates the same logical result.
⬜ Resume the original stream from its last byte, since the API keeps interrupted streams open until the client reconnects.

A team calls Claude through two supported cloud platforms and wants one configuration for both, but the current file assumes every provider accepts the same model ID and request options. What’s the safest design?

⬜ Keep one model ID and silently drop any field that causes an error.
⬜ Send one provider’s model name unchanged to every platform.
⬜ Fail over to the other provider automatically without checking residency or feature support.
⬜ Keep a model ID mapping and capability checks per provider, and validate each deployment against that provider’s supported request format before release.

A request using server tools comes back with stop_reason “pause_turn” and a text block saying “I have gathered the first sources.” The task isn’t finished, and the client still has the accumulated assistant content. What should the application do?

⬜ Treat pause_turn as the final answer and show the latest text.
⬜ Discard the content and resend the original request from scratch.
⬜ Append the returned assistant content to the conversation and send it back so Claude can continue the paused server-tool loop.
⬜ Convert each server_tool_use block into a client tool_result and send those.

A batch holds thousands of document requests, a few fail and the rest succeed. The pipeline must match every result to its source document and retry only the failures. Which two practices fit? (select two)

⬜ Give every request a stable, unique custom_id and record its mapping to the source document before submitting.
⬜ Assume results come back in request order and match them by position.
⬜ Retry the whole batch whenever any request fails.
⬜ Check each result individually, save the successes, and submit a new batch containing only the retryable failures.

A TypeScript handler switches on block.type with cases for “text” and “tool_use” and a default that returns undefined. A newly supported block type is silently ignored in production, and the team wants the compiler to catch missing handlers. What change prevents this?

⬜ Keep the default and log unknown blocks at debug level.
⬜ Use the discriminated union with an exhaustive switch and a compile-time never check, plus test fixtures for every supported block type.
⬜ Cast every block to a text block.
⬜ Serialize unknown blocks and append them to the visible answer.

A billing assistant retries a request after a transient API failure. The model may call a charge tool, and the first attempt might have completed the charge before the response was lost. What prevents duplicate charges?

⬜ Disable retries whenever a tool can change data.
⬜ Ask Claude whether it already charged the customer.
⬜ Generate a new transaction ID for every retry.
⬜ Give the charge an application-generated idempotency key, record its outcome durably, and return the existing result when the same key is retried.

A Python service streams Claude output into a queue drained by a slow browser connection. The producer reads events without limit, and memory grows during long responses. What fixes the real problem?

⬜ Use a bounded async queue, and pause reading or cancel the stream when the consumer can’t keep up.
⬜ Raise the process memory limit.
⬜ Shorten each event’s string before queueing it.
⬜ Read the whole response into memory first, then send it all at once.

A compliance app sends scanned reports through the legacy Amazon Bedrock Converse API as a plain PDF document. Claude sees the extracted text but misses the charts, and the app must analyze the visuals. Which two changes fit? (select two)

⬜ Enable citations on the Converse document request, so the full visual PDF processing mode is used instead of text extraction only.
⬜ Convert each report to plain text and let the model infer the charts from captions.
⬜ Raise max_tokens so the model has room to inspect the visuals.
⬜ Add regression cases with charts and tables, and confirm the answers cite evidence from those regions.

An operations agent can use more than two thousand internal tools. Sending every definition on every turn drives up input cost and makes tool selection less reliable. What’s the right design?

⬜ Shorten every tool name and keep sending all the definitions.
⬜ Move the catalog into a user message instead of the tools array.
⬜ Give Claude one generic execute_tool that takes any tool name and free-form JSON.
⬜ Use tool search with deferred loading, so Claude discovers a small relevant set at runtime.

Requirements for a Claude-based document assistant have been approved. The team is now choosing the model tier, synchronous versus batch processing, and the prompt caching and error-handling architecture, before any code is written. Which systems life cycle phase is this?

⬜ Implementation.
⬜ Operations and maintenance.
⬜ System design.
⬜ Requirements analysis.

A replaced Claude application is being shut down: traffic moves to the successor system, stored conversations are archived according to the retention policy, and the app’s API keys are revoked. Which systems life cycle phase is this?

⬜ Disposal.
⬜ System design.
⬜ Operations and maintenance.
⬜ Implementation.

A team uploads a custom skill to the Claude API whose SKILL.md description says only “Helps with data.” Claude rarely picks it, even for tasks that clearly fit. What most directly improves discovery?

⬜ Bundle more reference files and examples.
⬜ Rewrite the description to say what the skill does and when to use it, with specific trigger terms.
⬜ Pin the skill to a specific version.
⬜ Expand the SKILL.md body with more detailed steps.

A production service uses a custom skill through the container parameter with version “latest”. When a teammate uploads a new version to the shared workspace, the service’s behavior changes with no deployment. The team must keep using the skill and its scripts. What prevents this?

⬜ Copy the SKILL.md content into the system prompt.
⬜ Tell Claude in the system prompt to keep the behavior it had at deployment time.
⬜ Let only one engineer upload new skill versions.
⬜ Pin the request to a specific skill version ID, and move to newer versions deliberately after validating them.

A team moves a production integration to a Claude 4.6 model. Requests that end with a partial assistant message, used to force how Claude’s reply starts, now fail with HTTP 400. What should they do?

⬜ Retry with exponential backoff, treating the 400s as capacity errors.
⬜ Remove the trailing assistant prefill and shape the output with prompt instructions or structured outputs instead.
⬜ Move the trailing assistant message into the top-level system field.
⬜ Pin the integration to the earlier model permanently.

A direct HTTP streaming integration (no SDK) sometimes crashes on events of type ping that show up between content events. What’s the correct behavior?

⬜ Parse each ping payload as a partial content delta.
⬜ Close the connection and restart whenever a ping arrives.
⬜ Ignore ping events as a normal part of the stream and keep processing the events that follow.
⬜ Treat ping like an error event and stop processing.

A field-service company sends equipment photos to Claude through the Messages API to produce inspection summaries. Which two practices handle image input correctly? (select two)

⬜ Run every photo through an external OCR service first, since the API accepts only text.
⬜ Put the photo’s local file path in the prompt so the API loads it.
⬜ Send each photo as an image content block, using base64 data, a URL or a Files API file ID.
⬜ Use Claude to analyze and describe the images, but not to create or edit image files.

A custom skill’s scripts pip-install packages and download a 5 MB static dataset (freely redistributable) at runtime. It works in claude.ai but fails through the Claude API’s code execution tool. What makes it work on the API?

⬜ Pin the skill to a specific version ID.
⬜ Move the pip install and download commands into SKILL.md.
⬜ Bundle the dataset inside the skill and rewrite the scripts to use only pre-installed packages.
⬜ Reuse the same container ID across requests so installs persist.

A backend streams long responses to users. Network errors sometimes cut the stream after most of the answer has arrived, and the service throws the partial output away and starts over. What’s the recommended recovery?

⬜ Return the partial content as the final answer and log the interruption.
⬜ Turn off streaming so the response can’t be interrupted.
⬜ Save what was received and send a continuation request asking Claude to continue from that point.
⬜ Retry from scratch with backoff, discarding the partial output.

A team uses Claude to generate code changes in a shared production repository. Which two practices keep those changes safe to merge? (select two)

⬜ Put Claude’s changes through the same code review as human-written code.
⬜ Push Claude’s changes straight to main to avoid pipeline delays.
⬜ Skip review for model-generated commits, since Claude already reasoned through them.
⬜ Run the automated test suite in CI on every change before it merges.

A direct server-sent events integration (no SDK) needs a reliable sign that a streamed response finished successfully before saving the text. What should it rely on?

⬜ The first content_block_stop event.
⬜ Accumulated output reaching the request’s max_tokens.
⬜ The message_stop event, after the message_delta’s stop_reason shows the response wasn’t truncated.
⬜ The connection closing.

A Claude coding agent fixes bugs in a shared library, but reviewers find the fixes hard-code values that match the failing test inputs. The changes pass CI but break on other valid inputs. What addresses this?

⬜ Remove the failing tests so their values stop influencing the code.
⬜ Tell Claude to implement general logic that works for all valid inputs, and to treat tests as verification rather than the definition of the solution.
⬜ Generate several fixes and merge the first one that passes CI.
⬜ Raise max_tokens so Claude can write a more complete implementation.

Reviewers are nervous about a Claude-assisted refactor of a legacy scheduling module with little test coverage. Which two practices best guard against regressions? (select two)

⬜ Refactor in small steps, running the tests after each one.
⬜ First capture the module’s current behavior in characterization tests.
⬜ Delete tests that start failing so the pipeline stays green.
⬜ Deliver the whole refactor in one large commit.

A custom skill inlines full API documentation and schemas in SKILL.md, now well over 2,000 lines. Once it loads, Claude’s responses get worse and token use spikes. Which change fits how skills are designed?

⬜ Minify SKILL.md by removing headings, examples and blank lines.
⬜ Turn on prompt caching so the big SKILL.md is cheaper.
⬜ Split it into a dozen narrower skills, one per API area.
⬜ Keep SKILL.md as a concise overview and move the reference material into separate bundled files that are read on demand.

A custom skill tells Claude to call MCP tools by bare names such as create_issue. With several MCP servers connected, Claude sometimes can’t find the tools. What fixes this?

⬜ Connect only one MCP server.
⬜ Prefix each tool reference with its server name, in the ServerName:tool_name format.
⬜ Copy every server’s tool definitions into SKILL.md.
⬜ Tell Claude to retry failed tool calls until they work.

A developer asks Claude Code to fix one off-by-one bug in a date parser. The pull request also renames variables, adds docstrings to untouched functions and restructures two unrelated helpers, making it hard to review. What most directly prevents this?

⬜ Run the fix in a fresh session with the whole repository in context.
⬜ Merge as-is, since the cleanup reduces technical debt.
⬜ Ask Claude to annotate the remaining functions too, for consistency.
⬜ Tell Claude to change only what the fix needs and leave unrelated cleanup out of the diff.

---

Domain 3: Claude Code (3.1%)

A team keeps telling Claude Code the repository’s test command, formatting rules and architecture conventions. They want these loaded every session and shared through version control, but not applied to other repositories. What should they do?

⬜ Commit a concise project-level CLAUDE.md with the shared instructions.
⬜ Put the instructions in the user-level CLAUDE.md so every repository gets them.
⬜ Paste the full instructions into the first prompt of every session.
⬜ Add the conventions as permission allow rules.

A CI job needs one non-interactive Claude Code run that prints machine-readable output and exits. Which invocation fits?

⬜ claude -p "Summarize the repository" --output-format json, which runs once without interaction and exits.
⬜ Start claude interactively and wait for someone to run /export.
⬜ Run claude without -p, since interactive mode prints JSON after each turn.
⬜ Pipe the prompt into /memory, which runs the job and exits.

A developer finished debugging one service and wants to start an unrelated task without the old conversation, which is full of tool results and assumptions, influencing it. What should they do?

⬜ Run /compact first, since summarizing removes every earlier assumption.
⬜ Run /resume to reopen an older session.
⬜ Run /clear to wipe the session history, then give only the context the new task needs.
⬜ Keep the session and tell Claude to ignore everything it learned before.

A developer finished an exploratory Claude Code session and wants to pick the same repository task up tomorrow with its conversation intact. An unrelated incident must start with none of that context. What should they do?

⬜ Resume or continue the saved session for the original task, and start a new session for the incident.
⬜ Use one resumed session for both and ask Claude to ignore the earlier details.
⬜ Delete the repository’s CLAUDE.md so Claude can’t remember the earlier session.
⬜ Compact the original session and treat the summary as a clean context for the incident.

A freshly cloned repository has no Claude Code project instructions, and contributors keep re-explaining the build commands and architecture. The team wants a shared, reviewable starting point. What should the owner do?

⬜ Put the commands in one developer’s personal memory file.
⬜ Paste the entire source tree into CLAUDE.md.
⬜ Share a long-running session’s ID with contributors.
⬜ Run /init, review the generated CLAUDE.md, and commit concise build commands and architecture guidance.

A team wants project coding rules loaded in every Claude Code session, a long release procedure loaded only during releases, and a security reviewer that works in its own context. Which two choices fit? (select two)

⬜ Put the rules, the release procedure and the security checklist into one large CLAUDE.md.
⬜ Keep concise always-on rules in CLAUDE.md and move the release procedure into a skill that loads only when needed.
⬜ Define the security reviewer as a subagent with focused instructions and limited tools.
⬜ Store the release procedure in auto memory and expect Claude to work it out after one release.

An engineering organization wants to distribute one approved package containing a release skill, two subagents, repository hooks and an MCP connection, and have teams install and update it from a controlled internal catalog. What’s the best fit?

⬜ Copy the files into every repository and configure the hooks and MCP by hand.
⬜ Package them as a Claude Code plugin and distribute it through an approved organization marketplace with reviewed versions.
⬜ Put everything in one user-level CLAUDE.md.
⬜ Publish the release procedure as an MCP prompt containing all the components.

A developer is building a Claude Code plugin with skills, agents and hooks and wants to test each change quickly, without publishing or reinstalling it every time. What’s the recommended workflow?

⬜ Edit the installed copy inside Claude Code’s internal plugin cache.
⬜ Start Claude Code with –plugin-dir pointing at the plugin folder, and reload plugins to pick up edits.
⬜ Copy the skills, agents and hooks into ~/.claude by hand after every change.
⬜ Publish each change to a private marketplace, then uninstall and reinstall before every test.

A team is defining custom Claude Code subagents for recurring project workflows. Which two practices follow the recommended design? (select two)

⬜ Combine many unrelated responsibilities into one broad subagent.
⬜ Keep project subagent files out of version control so each developer can tune them.
⬜ Write a detailed description so Claude knows when to delegate to the subagent.
⬜ Give each subagent only the tools its task needs.

An organization wants standard instructions for Claude Code, such as compliance reminders and code style, applied to every session on every developer machine, without users being able to exclude them. How should they deploy them?

⬜ Distribute a CLAUDE.md to the managed policy location on each machine through MDM or similar tooling.
⬜ Commit them to a project CLAUDE.md in a shared repository that everyone clones.
⬜ Put them in a rules file in a shared repository’s .claude/rules folder.
⬜ Ask each developer to add them to their own user-level CLAUDE.md.

A project CLAUDE.md has grown to several hundred lines of vague guidance like “keep code clean” and “test things properly,” and Claude Code follows it inconsistently. What most improves adherence?

⬜ Add emphatic wording and repeat the key rules at the top and bottom.
⬜ Rewrite the guidance as specific, checkable instructions with concrete commands and paths, and shorten the file.
⬜ Move the guidance into settings.json so it’s enforced.
⬜ Copy the instructions into a CLAUDE.md in every subdirectory.

A developer wants to try a different implementation from an existing Claude Code conversation, while keeping the original conversation intact to come back to. What should they do?

⬜ Resume with claude –continue and try the alternative there.
⬜ Fork the session with –fork-session, which copies the history into a new session ID.
⬜ Start fresh and rely on auto memory to restore the state.
⬜ Run /compact in the original session first.

A developer in a shared repository wants Claude Code to auto-approve their own lint and test commands for that project only, without affecting teammates who clone it. Where should the rules go?

⬜ In the shared .claude/settings.json, so they load for every clone.
⬜ In the project’s .claude/settings.local.json, which is kept out of version control.
⬜ In the project CLAUDE.md, so Claude reads them each session.
⬜ In managed settings on the developer’s machine, so nothing can override them.

A developer launches Claude Code from packages/api/ in a monorepo. The team wants repository-wide conventions and API-team guidance in every session. Which two placements achieve this? (select two)

⬜ Put the repository-wide conventions in a CLAUDE.md at the repository root, since files in parent directories load at launch.
⬜ Put the API-team guidance in packages/api/CLAUDE.md, which is loaded alongside the root file.
⬜ Spread the guidance across CLAUDE.md files below packages/api/, since they all load at launch.
⬜ Copy the root conventions into packages/api/CLAUDE.md, since the nearest file replaces the ones above it.

A developer wants Claude Code to follow personal instructions for one project, such as their own debugging workflow, without committing them or affecting other projects. Where should they go?

⬜ In a CLAUDE.local.md at the project root, added to .gitignore.
⬜ In the committed CLAUDE.md, marked as personal.
⬜ As keys in .claude/settings.local.json.
⬜ In ~/.claude/CLAUDE.md.

A CI pipeline runs claude -p, but results differ across runners because each host’s hooks, CLAUDE.md files and MCP configuration load into the session. What gives every run the same minimal starting environment?

⬜ Set temperature to 0.
⬜ Add –bare, so the session skips auto-discovery of hooks, CLAUDE.md, MCP servers and auto memory.
⬜ Pass an empty –allowedTools list.
⬜ Append a system prompt telling Claude to ignore the runner’s configuration.

An organization rolling out Claude Code to hundreds of developers must guarantee that Claude can never read .env files or push straight to protected branches, on any machine and whatever a developer configures. Where should this go?

⬜ A managed CLAUDE.md telling Claude never to do those things.
⬜ permissions.deny rules in managed settings deployed to the managed policy location.
⬜ The project CLAUDE.md in each repository.
⬜ Each developer’s settings.local.json.

A Claude Code skill deploys the application to production, and Claude sometimes triggers it on its own when deployment simply comes up in conversation. The team wants it to run only when someone types /deploy. What does this?

⬜ Remove the description from the frontmatter.
⬜ Add a line telling Claude never to run it unprompted.
⬜ Set disable-model-invocation: true in the skill’s frontmatter.
⬜ Move the skill to the user-level skills folder.

A script runs claude -p to review pull-request diffs. Claude should keep its default coding-assistant behavior and built-in tool guidance while also following a house style guide for review comments. What does this?

⬜ Add the style rules under permissions.allow in settings.json.
⬜ Pass the style guide with –system-prompt, replacing the default prompt.
⬜ Pass the style guide with –append-system-prompt, adding it to the default prompt.
⬜ Define the style guide as a subagent in .claude/agents/.

Deep into a Claude Code session, a developer has built up a lot of investigation context and wants a subagent to try an alternative fix in parallel. The subagent’s work depends on almost everything discussed so far. Which delegation fits best?

⬜ Fork the conversation into a subagent that inherits the full history and returns only its result.
⬜ Compact the main conversation first, so a fresh subagent starts from the summary.
⬜ Try the alternative directly in the main conversation.
⬜ Spawn a fresh custom subagent and paste a hand-written summary into its prompt.

A team has detailed conventions for test files that apply to *.test.ts files across the repository. The conventions must be shared through version control but should load only when Claude works with a matching file. How should this be set up?

⬜ Add a section to the root CLAUDE.md headed with the test-file pattern.
⬜ Put the conventions in CLAUDE.local.md.
⬜ Add a markdown file under .claude/rules/ with a paths frontmatter glob that matches the test files.
⬜ List the glob under claudeMdExcludes in settings.json.

A team defines a custom Claude Code subagent that reviews pull-request diffs and reports findings. It must be unable to change files, even if a delegated task asks it to. What enforces this?

⬜ Limit the tools frontmatter field to read-oriented tools such as Read, Grep and Glob.
⬜ Set permissionMode to bypassPermissions.
⬜ Enable project memory so it remembers it’s read-only.
⬜ Tell it in its system prompt never to edit files.

A repository already has an AGENTS.md that several other coding agents read. The team wants Claude Code to follow the same instructions plus a few Claude-specific rules, without keeping two copies of the shared content. What should they do?

⬜ Create a CLAUDE.md that imports the existing file with @AGENTS.md, and add the Claude-specific rules after the import.
⬜ Rename AGENTS.md to CLAUDE.md and add the rules, since Claude Code recognizes only that name.
⬜ Copy the instructions and rules into .claude/settings.json.
⬜ Rely on Claude Code reading AGENTS.md automatically, and put the extra rules in a gitignored CLAUDE.local.md.

A developer keeps several personal skills in ~/.claude/skills/ that work in local Claude Code sessions, but they aren’t available when the developer starts a cloud session on the same repository. What makes them available there?

⬜ Add ~/.claude to permissions.additionalDirectories in the project settings.
⬜ Commit the skill folders to the repository’s .claude/skills/ directory, so they load as project skills.
⬜ Run /reload-plugins in the cloud session so it rescans the home directory.
⬜ List the skill files’ absolute paths in the project CLAUDE.md.

---

Domain 4: Evaluation, Testing and Debugging (2.6%)

After an organization splits its resources into workspaces, a service’s ordinary Messages API calls still work with its existing key. Requests for a file created in another workspace now return HTTP 403 permission_error. What’s the most likely cause?

⬜ The request is malformed, so the API rejects it before checking access.
⬜ The key authenticates but doesn’t have access to that resource, so the access configuration is at fault.
⬜ The organization hit a rate limit, so retrying will succeed.
⬜ The API is overloaded, so the 403 should be treated like a retryable 529.

A trace shows the order lookup tool returned delivery_date “2026-08-04”, but the assistant told the user “August 14”. The request succeeded and the tool result is in the trace. Where should the developer look first?

⬜ The network transport, since a successful response proves the model never got the result.
⬜ The model output and orchestration path, checking that the result was sent in the right block and actually used in the reply.
⬜ The order database, since any date mismatch means a stale record.
⬜ Rate-limit settings, since wrong dates come from exceeding quotas.

A troubleshooting assistant ranks root causes slightly differently each time the same incident evidence is submitted. The team wants a reliable quality estimate before changing prompts or models. Which evaluation approach fits?

⬜ Run the same representative cases several times, measure the outcome distribution and critical failure rate, and compare revisions against fixed acceptance criteria.
⬜ Accept the first response that matches an engineer’s expectation as proof of reliability.
⬜ Raise the temperature until responses vary enough for reviewers to pick the best one.
⬜ Rely on a fixed random seed as the only quality control.

A dispatch service starts getting intermittent HTTP 529 responses with error type overloaded_error. What do they mean, and how should the service respond?

⬜ The API is temporarily overloaded; retry the same requests with exponential backoff.
⬜ The organization is being rate limited; reduce concurrency to stay within workspace limits.
⬜ The credentials are invalid; rotate the API key before sending more requests.
⬜ The requests are malformed; fix the payload before resending.

After a change to the code that builds API requests, every call fails with HTTP 400 invalid_request_error, and retries return the same error. What should the team do?

⬜ Inspect the request payload for malformed or invalid parameters, and fix the code that builds it.
⬜ Add exponential backoff, since this means server overload.
⬜ Wait for the service disruption to end.
⬜ Raise the SDK’s max_retries.

A nightly translation job starts receiving HTTP 429 rate_limit_error responses. The SDK’s retries run out, and the failures continue for hours even after the job sharply reduces its request rate. What should the developer check first?

⬜ Move to the Message Batches API, since batch requests aren’t rate limited.
⬜ Lower max_tokens to get back under the output-tokens-per-minute limit.
⬜ Raise max_retries and lengthen the backoff.
⬜ Whether the 429 has a retry-after header, and what error.details.error_code says, since a spend-cap 429 has no retry-after.

---

Domain 5: Model Selection and Optimization (16.8%)

A classification service sends the identical request to Claude several times and sometimes gets different labels back. Which explanation reflects how LLMs work?

⬜ Claude samples tokens probabilistically, so repeated calls with the same input can produce different outputs.
⬜ The Messages API quietly rewrites identical prompts whenever the same API key is reused.
⬜ The SDK rotates between model families after each successful request to balance regional load.
⬜ Claude remembers each label it returned and deliberately avoids repeating it on later calls.

A service rejects some valid requests before calling Claude. Its size check is estimated_tokens = len(text) // 4 and it raises “Prompt too large” when the estimate exceeds 80,000. What fixes the underlying problem?

⬜ Raise the character divisor until every rejected document passes the local check.
⬜ Call the token counting endpoint with the real message structure before enforcing the budget.
⬜ Remove the budget check, because Claude silently truncates oversized inputs without an error.
⬜ Count only alphabetic characters, because punctuation never contributes tokens.

A response arrives with content text “The policy requires”, stop_reason “max_tokens” and 80 output tokens. What should the application conclude first?

⬜ The input exceeded the context window, so the API dropped the earlier instructions.
⬜ The model finished naturally, so the cut-off sentence is the intended answer.
⬜ Generation hit the configured output limit, so the text is incomplete.
⬜ The SDK failed to parse a tool result and substituted partial text.

A TypeScript service using the official SDK runs const pending = client.messages.create({...}); console.log(pending.content); and logs nothing useful. What’s the fix?

⬜ Call JSON.stringify on the unresolved promise before reading its content field.
⬜ Open a WebSocket connection and wait for the socket’s close event.
⬜ Keep reading pending.content, because the SDK blocks until the response is complete.
⬜ Await client.messages.create, then read the content blocks of the resolved message.

During an invalid-request incident, a wrapper while True: try: return create(**params) except Exception: continue floods the API with calls. What’s the right correction?

⬜ Classify failures, retry only transient ones with bounded backoff, and surface errors that won’t succeed on retry.
⬜ Keep catching every exception but log it before retrying immediately.
⬜ Remove the error handling so the process exits on any error.
⬜ Retry invalid requests with progressively larger payloads until they’re accepted.

A team is choosing between the official SDK and direct REST calls for two services. Which two statements are correct? (select two)

⬜ The official SDK gives typed request objects and language-native response handling.
⬜ With raw REST, you send the documented headers and a JSON body to the Messages endpoint.
⬜ SDK and raw REST responses are identical, including the language-specific helper methods.
⬜ Raw REST calls can omit the API version header, since compatibility follows the JSON body.

A support platform has high-volume routine classification and rare policy appeals that need deeper reasoning. Which model strategy is most defensible?

⬜ Route by published model descriptions and vendor benchmarks, skipping workload-specific evaluation.
⬜ Use the cheapest tier that passes one combined benchmark across both task types.
⬜ Benchmark candidate tiers on representative evaluations, route each task type to the tier that meets its needs, and retest before changing models.
⬜ Route by traffic volume and review appeal quality after the next model release.

A team’s monthly Claude bill is higher than their spreadsheet forecast. Which investigation best checks the cost model?

⬜ Estimate every request from the median character count and ignore the usage fields.
⬜ Add up actual input, output, cache and request usage by workload, then compare it with current pricing.
⬜ Lower max_tokens everywhere before finding which workload caused the gap.
⬜ Assume the invoice is wrong whenever responses are shorter than prompts.

A nightly job checks thousands of documents against the same long policy and doesn’t need immediate answers. Which two changes cut cost most? (select two)

⬜ Keep the policy prefix identical across requests and cache it with a breakpoint after it.
⬜ Stream every response to a browser, even though nobody watches it.
⬜ Raise every output limit to the maximum before measuring what’s needed.
⬜ Submit the requests through the Message Batches API, since results can arrive asynchronously.

A document assistant sends a 70,000-token prompt to a model with a fixed context window and needs room for a detailed answer and possible tool results. How should it budget?

⬜ Count the full input (instructions, history, tool definitions and documents) and reserve enough output space before accepting the request.
⬜ Treat the context window as an output allowance, since input tokens don’t reduce response space.
⬜ Count only the visible document text, since tool definitions and earlier turns sit outside the context window.
⬜ Set max_tokens equal to the whole context window and let Claude discard whatever input it doesn’t need.

A developer using the TypeScript SDK expects a streaming call to return one completed JSON body, but gets an asynchronous sequence of events instead. What’s the right interpretation?

⬜ That’s how streaming works: consume the event sequence and assemble the content into one response, keeping block boundaries and the final metadata.
⬜ It’s an SDK bug, since every REST wrapper must return a complete body.
⬜ The API uses a database protocol, so each token has to be polled from a table.
⬜ Each event is a separately billed request, so cancel after the first delta.

A fraud-analysis prompt works on ordinary cases but misses complex chains of evidence. The team has already clarified the prompt and measured the gap. What’s the most appropriate next step?

⬜ Run the request several times and keep the longest response.
⬜ Raise the temperature until the responses vary more, and pick the most detailed.
⬜ Add the whole production database to every request.
⬜ Turn on a suitable thinking mode for the hard cases, and weigh the quality gain against the extra latency and token cost in evaluations.

An async Python web handler calls Claude through the synchronous SDK client. Under load, each call blocks the event loop and delays unrelated users. What’s the fix?

⬜ Keep the sync client and raise max_tokens.
⬜ Use the async client (AsyncAnthropic) and await the call, keeping the usual timeout and error handling.
⬜ Wrap the sync call in a polling loop.
⬜ Create a new sync client for every request.

A claims service sends the same long policy, tool definitions and output rules with every request, but puts the current timestamp near the start of the prompt. Cache reads stay low even when only the customer details change. Which two changes fit? (select two)

⬜ Insert a unique request ID before the policy so every call has its own cache key.
⬜ Move the timestamp and customer details after the stable policy, tools and output rules.
⬜ Cache the whole request, customer details included, and reuse it for later customers.
⬜ Put a cache breakpoint after the stable shared content, and confirm cache reads in the usage fields on repeated requests.

A risk analyst wants to use the probability of Claude’s chosen next token as a calibrated probability that the final business conclusion is correct, and to auto-approve above a threshold. Why is this unsound?

⬜ It fails only because the API can’t return any likelihood information.
⬜ It would work at low temperature, since deterministic output is always correct.
⬜ It becomes calibrated once the prompt includes a few examples.
⬜ Next-token probabilities describe individual generation choices, not a calibrated confidence that the whole decision is correct.

A TypeScript service concatenates text_delta events by hand, but logging needs the complete message with its metadata. The browser still needs incremental text. Which implementation is better?

⬜ Open a WebSocket to the Messages endpoint and wait for a final frame.
⬜ Store only the concatenated text, since metadata isn’t needed afterward.
⬜ Use the SDK’s streaming helper for the text events, and call its final-message method after the stream completes.
⬜ Make one streaming request for the browser and a second non-streaming one for the log.

A Python service creates a new HTTP client for every Claude request, causing connection churn, with no timeout policy and inconsistent retries. The team still wants to call the API directly. What improves the integration?

⬜ Reuse one configured HTTP client with connection pooling, explicit timeouts and bounded retries that follow the API’s error semantics.
⬜ Raise the OS file-descriptor limit and keep creating clients.
⬜ Retry every failure in a tight loop inside the handler.
⬜ Put the API key in a query parameter so intermediaries can cache responses.

A request to Claude Opus 5.5 contains "thinking": {"type": "adaptive"}, "temperature": 0.2, "tool_choice": {"type": "tool", "name": "approve_claim"}, and the API rejects it with a 400. The request still needs adaptive reasoning and the tool. Which two corrections should be made? (select two)

⬜ Raise max_tokens until the request succeeds.
⬜ Remove the custom temperature setting, since this model rejects non-default sampling parameters.
⬜ Move temperature and tool_choice into the user message as instructions.
⬜ Replace the forced tool_choice with “auto”, using strict tool use if the inputs must match the schema.

A coding service uses one capable model for both short lint explanations and hard repository-wide debugging. The team wants lower routine cost without adding a second model family unless evaluations show it’s needed. What should it test first?

⬜ Maximum effort for everything, since it avoids second attempts.
⬜ Moving all lint tasks to the smallest model without evaluation.
⬜ One setting with shorter prompts, since effort affects only prose length.
⬜ Lower effort for routine lint tasks and higher effort for debugging, comparing quality, latency and token use before rollout.

A service caches stable tool definitions and a system prompt, but changes tool_choice between stages of one conversation, and cache hits are lower than expected. How should it preserve the reusable prefix?

⬜ Keep the tools and system prompt identical with a cache breakpoint on them, accepting that a tool_choice change invalidates only the cached message blocks.
⬜ Move tool_choice into the cached system prompt as an instruction.
⬜ Add a breakpoint after every tool definition so later parameters can’t affect them.
⬜ Stop caching the tools and cache only the latest user message.

An agentic code-refactoring tool runs on Sonnet. Evaluations show its reasoning falls short on complex multi-file changes; the workload tolerates latency and the budget allows a higher unit cost. What’s the most appropriate next step?

⬜ Turn on fast mode for the Sonnet requests to get a more capable variant of the model.
⬜ Stay on Sonnet and raise max_tokens a lot, since a bigger output budget means deeper reasoning.
⬜ Move to Haiku, run each task three times and take a majority vote.
⬜ Move the workload to the Opus tier and confirm the improvement on the same evaluation suite before switching over.

An app runs a Claude model with adaptive thinking at high effort. On complex requests, responses are cut off with stop_reason “max_tokens”, even though the input is well under the context window. What fixes the truncation?

⬜ Turn on fast mode so output finishes before the cap is reached.
⬜ Retry the same request, since thinking tokens don’t count toward max_tokens.
⬜ Trim older turns, since the history has pushed the input over the context window.
⬜ Raise max_tokens or lower the effort level, since thinking tokens count toward max_tokens and can crowd out the reply.

A developer new to LLMs is learning how Claude represents and produces text. Which two statements are accurate? (select two)

⬜ Each token is exactly one whole word, so the token count always equals the word count.
⬜ A token is a piece of text, often part of a word, and how many tokens a text produces depends on its language, its content and the model’s tokenizer.
⬜ The same text produces the same token count on every Claude model, so counts carry over between models.
⬜ Claude generates output one token at a time, each based on the tokens before it.

After an app turns on prompt caching, the input_tokens it uses for cost tracking falls far below the real prompt size. How should the team fix its cost tracking?

⬜ Multiply input_tokens by the cache write multiplier, since it already nets out reads and writes.
⬜ Treat the drop as expected, since cached tokens are free and left out of usage.
⬜ Add input_tokens, cache_read_input_tokens and cache_creation_input_tokens; input_tokens covers only the tokens after the last cache breakpoint.
⬜ Report it as an API bug, since input_tokens should always equal the full prompt.

A developer replaces the official SDK with hand-written HTTP calls to the Messages endpoint. Requests that worked through the SDK now fail with a 400 about a missing required header. What was the SDK doing for them?

⬜ Retrying rejected requests with backoff until they were accepted.
⬜ Opening a persistent WebSocket before each request.
⬜ Sending the required anthropic-version header along with the JSON content type.
⬜ Adding an anthropic-workspace-id header, which every request needs.

A developer is tuning token spend on a model that supports the effort parameter. Which two approaches reflect how effort actually works? (select two)

⬜ Lower the effort level to cut total token spend across tool calls, text and thinking, not just reasoning depth.
⬜ Treat effort as soft guidance and use max_tokens as the hard output limit, since Claude can still think at low effort.
⬜ Pass “adaptive” as the effort value to turn on adaptive thinking.
⬜ Set effort to low to guarantee responses contain no thinking.

An application routes traffic across several Claude models and needs each model’s token limits and capabilities at runtime, not hard-coded. What’s the correct approach?

⬜ Query the Models API, which returns max_input_tokens, max_tokens and a capabilities object for each available model.
⬜ Send a minimal Messages request to each model and read the limits from usage.
⬜ Call the token counting endpoint, which returns each model’s limits along with the count.
⬜ Use the SDK’s bundled model catalog, which updates itself between releases.

A developer turns on adaptive thinking and writes parsing code that assumes every assistant message starts with a thinking block. Some production responses fail to parse because there’s no thinking block. What should they do?

⬜ Set effort explicitly, since leaving it unset disables thinking.
⬜ Make the parser treat thinking blocks as optional, since adaptive thinking can skip thinking for simple inputs.
⬜ Switch to streaming, since thinking blocks appear only in streams.
⬜ Raise max_tokens, since thinking blocks are removed near the output cap.

A team runs a latency-sensitive coding assistant on Claude Opus and wants to know what fast mode actually changes before turning it on. Which description is accurate?

⬜ It turns off thinking so responses finish sooner.
⬜ It serves the same Opus model with faster output generation, at premium per-token pricing.
⬜ It routes requests to a smaller, faster model with somewhat weaker reasoning.
⬜ It moves requests up the rate-limit queue at no extra cost.

A team caches a large stable prefix with a cache_control breakpoint, but each user’s follow-ups arrive about 20 minutes apart, so every request rewrites the cache. What restores cache hits?

⬜ Set ttl to “1h” in cache_control, accepting the higher write cost so the entry outlasts the gap.
⬜ Move the breakpoint onto each new user message.
⬜ Add more breakpoints to extend how long the entry lasts.
⬜ Lower max_tokens, since the cache timer starts when generation finishes.

An app built on an official SDK calls a list endpoint whose results span many pages. The developer wants every item without writing pagination code. What’s the idiomatic approach?

⬜ Parse raw responses and issue follow-up requests with the last ID yourself.
⬜ Resend the same request until it reports no more results.
⬜ Iterate over the list result with the SDK’s auto-paginating iterator, which fetches further pages as needed.
⬜ Call once and let the SDK buffer every page into one response.

A Python backend uses the official SDK. Rate-limit failures must be re-queued for later, while malformed requests are logged and dropped. How should the code tell them apart?

⬜ Match substrings in the error message, since the SDK uses one generic exception.
⬜ Look in the assistant message content, since errors come back as text.
⬜ Catch the SDK’s typed exception classes, which map different API errors to distinct types.
⬜ Drop the SDK for raw HTTP, since SDK exceptions hide the status code.

A developer sets manual extended thinking with budget_tokens of 10,000 on a supported model. On many requests, Claude uses far fewer thinking tokens. What’s the right understanding?

⬜ Add an instruction requiring Claude to use the whole budget.
⬜ budget_tokens is a target, not a quota: Claude may use fewer, and max_tokens caps total output.
⬜ It’s a misconfiguration, since a budget is always fully used.
⬜ Billing is for the full 10,000 tokens on every request.

A multi-turn assistant on Claude Sonnet 4.6 caches a stable conversation prefix, but the app changes output_config.effort on each request based on difficulty. Usage now shows a cache write on every turn and no reads. What should change?

⬜ Add a separate breakpoint for each effort level.
⬜ Switch to automatic caching so the breakpoint moves around the change.
⬜ Use the 1-hour TTL.
⬜ Keep one effort level for the conversation, and steer per-turn reasoning depth with guidance in the user messages.

An app calls the token counting endpoint to size prompts before sending them to the Messages API. Which two statements about the endpoint are accurate? (select two)

⬜ The returned count is an estimate; the actual input tokens at message creation can differ slightly.
⬜ It’s free to call, and its rate limits are separate from message creation.
⬜ A count measured on one model applies to every other model, since all Claude models share one tokenizer.
⬜ Including cache_control in the count request pre-warms the prompt cache.

An app uses adaptive thinking with the thinking display set to omitted, so no reasoning text comes back. Invoices show output token charges far above the visible response length. How should the team explain the bill?

⬜ The thinking system prompt is injected on every request and billed as output.
⬜ Omitted thinking is billed at the cache-write rate.
⬜ The display setting was ignored, and summary generation carries a surcharge.
⬜ Thinking tokens are billed as output tokens in full whatever the display setting; omitting them only hides the text.

A team is moving a production workload from Claude Sonnet 4.6 to a Claude 4.7 or later model. Which two changes must they plan for before switching? (select two)

⬜ Recount prompts on the new model, since its tokenizer produces roughly 30 percent more tokens for the same text.
⬜ Remove any non-default temperature, top_p or top_k values, since the newer models reject them with a 400.
⬜ Keep manual extended thinking with budget_tokens, since every current model accepts it.
⬜ Drop the effort parameter, since newer models don’t support it.

Shared code sends thinking-enabled requests to Claude Haiku 4.5, Claude Sonnet 4.6 and Claude Opus 4.7. Which two configuration rules must it follow? (select two)

⬜ Don’t send budget_tokens to Claude Opus 4.7, since it rejects manual extended thinking with a 400 and uses effort instead.
⬜ Strip budget_tokens from Claude Sonnet 4.6 requests, since it rejects extended thinking with a 400.
⬜ Send thinking type “adaptive” only to Claude Sonnet 4.6 and Claude Opus 4.7, since Claude Haiku 4.5 rejects adaptive thinking.
⬜ Leave out the thinking parameter on Claude Opus 4.7, since thinking is on by default there.

A team is preparing a Claude API integration for launch traffic. Which two statements correctly describe how the API rate-limits requests? (select two)

⬜ Throttling risk depends only on call count; prompt and response size don’t matter.
⬜ Plan capacity around the requests-per-minute and token-per-minute limits of the organization’s usage tier.
⬜ Tier placement advances automatically with usage history, and higher limits can be requested in the Console.
⬜ Extra API keys in the same organization each get their own throughput allowance.

A latency-sensitive chat service moves from Claude Sonnet 4.6 to Claude Sonnet 5 without changing its requests, which have never included a thinking parameter. Output tokens and response times rise sharply. What addresses the cause?

⬜ Raise max_tokens, since Sonnet 5 needs a bigger output budget.
⬜ Turn on fast mode, since Sonnet 5 is slower at standard speed.
⬜ Wait for prompt caching support on Sonnet 5.
⬜ Set the thinking configuration and effort level explicitly, since leaving out the thinking parameter turns thinking on for Sonnet 5.

A multi-turn assistant with thinking on moves from Claude Sonnet 4.5 to Claude Sonnet 4.6 with the prompts unchanged. Input token counts now grow noticeably faster from turn to turn. What directly addresses the growth?

⬜ Recount with the token counting endpoint for Sonnet 4.6’s newer tokenizer.
⬜ Shorten the system prompt so the thinking system prompt stops compounding.
⬜ Configure the clear_thinking_20251015 context editing strategy with an explicit keep value, to limit how many earlier thinking blocks stay in context.
⬜ Lower the effort level so reasoning is billed as output instead of input.

---

Domain 6: Prompt and Context Engineering (11%)

A long-running research assistant is close to its context limit but must keep the user’s goal, constraints and accepted findings. What should it do?

⬜ Delete the earliest turns without recording their decisions, and continue with only recent messages.
⬜ Cache the history, since cached tokens no longer take up the context window.
⬜ Compact the earlier history into a summary that keeps the key state, and check continuity afterward.
⬜ Move all earlier tool outputs into the system prompt so they can never be removed.

An agent keeps citing old search results and now reports out-of-date customer status. Which two actions most improve what’s in its active context? (select two)

⬜ Keep all results and label the newest one as authoritative in the prompt.
⬜ Summarize the transcript periodically, keeping the old status in the summary.
⬜ Clear stale tool results after saving the current verified facts and their sources elsewhere.
⬜ Run verification as a separate subtask and return only its validated findings to the main agent.

Claude follows an incident-summary format inconsistently, even though the field names are clear. Which prompt change most directly shows the pattern you want?

⬜ Repeat the instruction in capital letters at the start and end of the prompt.
⬜ Add unrelated background documents so Claude has more context for choosing a format.
⬜ Remove the field constraints and let each response choose a format.
⬜ Provide representative input and output examples that show the exact fields and acceptable values.

A prompt builder concatenates Question: ${question} with the joined documents and “Answer briefly.” Answers get worse as the document set grows. Which revision follows long-context guidance?

⬜ Put the delimited documents first, then the question and the response constraints after them.
⬜ Repeat the question between every document.
⬜ Remove the document boundaries and merge everything into one paragraph.
⬜ Put the constraints first and leave the question out when the documents are long.

Claude returns schema-valid JSON for a production configuration update. What should the application do before applying it?

⬜ Apply it straight away, because schema conformance guarantees the content is correct.
⬜ Check the stop reason, validate the business rules and facts, then authorize the change.
⬜ Convert it to prose and go with whichever explanation sounds most confident.
⬜ Skip semantic checks when the property names appear in the expected order.

Two prompt revisions each improve different sample cases, and reviewers disagree about which to ship. What’s the strongest next step?

⬜ Pick the longer prompt, since more instructions always improve accuracy.
⬜ Deploy both at random without a success metric or version records.
⬜ Go with the senior reviewer’s choice and drop the competing test cases.
⬜ Evaluate both versions on representative held-out cases against predefined quality and latency criteria.

A moderation prompt is built as “Policy: " + policy + “\nPost: " + post + “\nReturn a label.” The policy must govern the label, and any instructions inside the post must be treated as content. Which two revisions should be made? (select two)

⬜ Put the stable moderation rules in the system prompt and keep the submitted post in user content.
⬜ Put the post before the policy so Claude reads the user text first.
⬜ Wrap the policy and the post in clearly named XML sections and say that text inside the post section is data, not instructions.
⬜ Ask Claude to report any hidden instructions and trust the label if it says there are none.

A claims prompt works on the development examples but fails when the evidence has several dates and conflicting notes. The team wants to improve it without guessing. What approach should they use?

⬜ Collect representative failures, define the decisions you want, change one thing at a time, and rerun a held-out evaluation after each change.
⬜ Add stronger adjectives to the system prompt and release without testing.
⬜ Keep the prompt and rerun failed requests until one matches.
⬜ Replace all the examples with the single hardest case.

A financial assistant returns a confident investment summary with calculated ratios and a recommendation. The JSON is well formed, but it could affect a client’s portfolio and the source figures may be incomplete. What should happen before it’s presented as approved advice?

⬜ Present it immediately, since valid JSON proves the calculations are right.
⬜ Validate the calculations and source completeness, flag uncertainty, and require qualified human review.
⬜ Ask for a longer explanation and treat the extra reasoning as proof.
⬜ Remove the confidence value and leave the rest unchecked.

A research assistant can draw on a large policy repository, but most questions need only two or three sections. It preloads every policy and hits the context limit before the analysis starts. What’s the better design?

⬜ Raise the history limit in the app database.
⬜ Summarize the whole repository once and use that summary for every question.
⬜ Retrieve only the relevant sections when a question arrives, and include them with source IDs and concise instructions.
⬜ Split the repository into random chunks and rotate one into each request.

A quality-check prompt says both “always give a concise answer” and “include a detailed explanation for every failed check.” Claude alternates between leaving out explanations and writing long answers for passing cases. What’s the best first fix?

⬜ Add examples without changing the conflicting rules.
⬜ Rewrite the instructions with an explicit priority and condition: concise for passes, detailed explanations only for failures.
⬜ Raise effort so Claude reasons longer about which rule wins.
⬜ Set a very small max_tokens.

A claims workflow drafts a decision and then asks the same conversation to confirm it’s correct. The confirmation almost always agrees, even when a known exception was missed. Which design is more likely to catch the error?

⬜ A separate verification step that gets the policy, the draft and a checklist asking for unsupported claims and missed exceptions.
⬜ Asking the same conversation for a yes or no after the draft.
⬜ Repeating the drafting prompt and accepting matching answers.
⬜ Raising the temperature for the confirmation turn.

An app asks for strict JSON, but a prohibited request returns stop_reason “refusal” with the text “I cannot assist with that request.” The parser assumes every response matches the business schema and crashes. What should change?

⬜ Catch the JSON error and substitute a default approval.
⬜ Strip everything before the first brace and parse what remains.
⬜ Retry until the model returns schema-valid JSON.
⬜ Check the stop reason and content blocks before schema parsing, and route refusals and other non-standard outcomes to explicit handling.

A voice app’s prompt says just “NEVER use ellipses,” yet responses still include them now and then. According to Anthropic’s prompting guidance, what makes the instruction more effective?

⬜ Set the temperature to zero so the model always follows negative instructions.
⬜ Prefill the start of the assistant message with correctly punctuated text.
⬜ Explain the reason: the output is read aloud by a text-to-speech engine that can’t pronounce ellipses.
⬜ Repeat the rule several times in capital letters.

A developer enables JSON outputs with a schema in output_config.format and wants to remove all other response handling, assuming every response now matches the schema. What must the application still check?

⬜ Retry each request and compare results, since schema conformance is only probabilistic.
⬜ The stop_reason, since a refusal still returns HTTP 200 and a max_tokens stop can leave the output incomplete.
⬜ Re-parse the text with regular expressions, since constrained decoding sometimes emits malformed JSON.
⬜ Strip markdown code fences, since JSON outputs come wrapped in them.

A report prompt says “Do not use markdown. Do not use bullet points. Do not use bold text.” The output still has lists and headings. What revision does Anthropic’s guidance recommend?

⬜ Repeat the instructions in capitals at the start and end.
⬜ Move them from the system prompt into the last user message.
⬜ Lower the temperature.
⬜ Say what to do instead: write in smoothly flowing prose paragraphs.

A coding assistant is prompted with “Can you suggest some changes to improve this function?” Claude gives recommendations but never applies them, though the team wants the edits made. What should change?

⬜ Ask for suggestions twice in the prompt.
⬜ Phrase it as an explicit instruction to act, such as “Change this function to improve its performance.”
⬜ Give the assistant more file-editing tools so it infers that edits are expected.
⬜ Raise the temperature so it acts more on its own.

A contract-review assistant answers accurately but in a generic, unfocused tone, even though each user message carries detailed instructions. Which technique does Anthropic recommend to focus Claude for this use case?

⬜ Give Claude a role in the system prompt, such as an experienced contract lawyer.
⬜ Raise max_tokens.
⬜ Prefill the assistant turn with an expert persona statement.
⬜ Lower the temperature.

An agentic workflow makes dozens of tool calls per session, and old tool results now take up most of the context window. The team wants stale results removed automatically on the server while recent ones stay. What does this?

⬜ Raise max_tokens for more headroom.
⬜ Cache the tool results so they stop counting toward the window.
⬜ Add the memory tool so results move into memory files automatically.
⬜ Turn on context editing’s tool-result clearing strategy, so the API removes the oldest results server-side.

A developer passes a JSON schema in output_config.format that uses a recursive $ref and numeric minimum and maximum, and the API rejects it with a 400. What should they do?

⬜ Lower the temperature and resend.
⬜ Retry unchanged, since the first use of a schema is slow to compile.
⬜ Add the structured-outputs beta header.
⬜ Remove the recursive reference and the numeric bounds from the schema, and enforce those constraints in application code.

A long-running agent uses context editing’s tool-result clearing to stay within the context window, but sometimes needs facts from results that were already cleared, and ends up redoing work. What preserves that information?

⬜ Raise max_tokens so Claude can restate cleared facts.
⬜ Tell Claude to memorize results, since the model retains what it has processed.
⬜ Add the memory tool, so Claude can save key facts to files before results are cleared and read them back later.
⬜ Turn off clearing entirely.

An extraction pipeline defines its tools with strict: true and asks Claude for a final JSON summary as plain text, which downstream code parses without validation. Summaries sometimes arrive missing a required field. What fixes this?

⬜ Add strict: true to the remaining tools, so the guarantee covers the final response.
⬜ Prefill the assistant turn with an opening brace.
⬜ Raise max_tokens and restate the field names.
⬜ Request the final summary through output_config.format with a JSON schema.

A claims-triage assistant runs with thinking on. Its prompt dictates a twelve-step numbered procedure for exactly how Claude must reason through each claim, yet scores on complex cases stay poor. What’s the recommended revision?

⬜ Replace the prescriptive steps with a general instruction to reason thoroughly, and let Claude structure its own thinking.
⬜ Break the procedure into even finer sub-steps.
⬜ Move the procedure into each user message.
⬜ Lower the temperature to zero.

A prompt for weekly status reports says “use our standard format and follow the usual conventions.” The structure changes from run to run, and reviewers reject most drafts. Which change is most likely to fix this?

⬜ Give Claude the role of a senior member of the reporting team so it infers the format.
⬜ Repeat “follow the usual conventions” in the system prompt and every user message.
⬜ Spell out the exact sections, order and conventions, as if briefing a new hire with no company context.
⬜ Switch to a larger model that’s more likely to know the team’s conventions.

A research agent’s system prompt, tuned for an earlier model, says “If in doubt, use the search tool.” After moving to Claude Opus 4.6, the agent searches on almost every turn, even trivial follow-ups. What’s the recommended first adjustment?

⬜ Switch back to the earlier model.
⬜ Repeat the search instruction more strongly.
⬜ Replace the blanket instruction with targeted guidance about when searching actually helps.
⬜ Raise the effort level.

---

Domain 7: Security and Safety (8.1%)

An agent summarizes supplier web pages and can draft payments through a finance tool. A page could hide instructions that try to trigger a payment. Which two actions keep summarization working while blocking the attack? (select two)

⬜ Put retrieved page content in a clearly delimited untrusted-data section and tell Claude not to treat it as instructions.
⬜ Give the finance tool read and write access so Claude can reverse a malicious payment itself.
⬜ Require deterministic authorization and human approval before any payment tool call runs.
⬜ Move the page text into the system prompt so it gets the highest instruction priority.

A Claude classifier needs only a ticket’s issue text, but the app sends full account histories and keeps raw requests forever in a broadly accessible analytics workspace. What most directly reduces leakage risk?

⬜ Encrypt the raw logs at rest and keep sending the full histories.
⬜ Tell Claude in the system prompt never to reveal personal data.
⬜ Strip unneeded fields, redact identifiers and send only the ticket content the classifier needs.
⬜ Keep everything in a restricted workspace so reviewers can investigate any decision later.

A content-moderation assistant passes its overall offline score, but safety-critical misses are concentrated in a small adversarial slice. Which deployment plan best limits risk while the guardrails improve?

⬜ Deploy everywhere once the average passes, and turn off detailed logging.
⬜ Stay offline until every possible adversarial input has a blocking rule.
⬜ Release to everyone and rely on user complaints to find problems.
⬜ Roll out in stages with thresholds for the safety slice, layered screening, production monitoring and a tested rollback path.

A production Claude API key was committed to a public repository, and account usage now looks suspicious. What should the team do first?

⬜ Revoke the key immediately, issue a replacement and store the new key in a secrets manager.
⬜ Delete the commit and keep using the key, since removing it from history stops misuse.
⬜ Wait for clear evidence of misuse before changing the key.
⬜ Move the key to an ignored .env file and keep using it.

A healthcare assistant summarizes patient records for authorized clinicians. The source files contain unnecessary identifiers and records from several clinics. Which two actions reduce privacy exposure before any content reaches Claude? (select two)

⬜ Remove fields the summary doesn’t need, and redact identifiers whenever the task works without them.
⬜ Enforce clinic and clinician authorization before retrieving records, and send only the records allowed for that request.
⬜ Send every available record and have Claude strip sensitive details from its final answer.
⬜ Use one shared conversation history for all clinics, so Claude learns recurring terminology.

A refund agent can look up orders and issue payments, and large refunds could cause real losses. The team wants routine cases automated without giving the agent unlimited authority. Which two controls fit? (select two)

⬜ Give the agent one unrestricted payment credential and let it issue every refund.
⬜ Restrict the refund tool to approved fields and a maximum amount, enforced in code before the executor runs.
⬜ Require human approval before any refund above the threshold or one that triggers a risk rule.
⬜ Have Claude promise in the system prompt never to issue an unsafe refund, and remove the application checks.

A Claude Code workflow can run shell commands, and the organization wants destructive production commands blocked even if a user accidentally approves a broad permission mode. The control must act before execution and tell the workflow what happened. Which two hook behaviors fit? (select two)

⬜ A PostToolUse hook that restores production data after a destructive command runs.
⬜ A PreToolUse hook that inspects matching shell commands and blocks prohibited ones before they run.
⬜ A rule in CLAUDE.md, trusting Claude to remember it.
⬜ Returning an explicit denial reason when blocking, so Claude can change its plan instead of retrying.

A maintenance agent can delete obsolete files in a shared production repository. A wrong interpretation could remove active customer assets. Which design is the strongest practical guardrail?

⬜ Run the agent with full repository permissions and rely on a detailed system prompt.
⬜ Give the agent read access first, have it produce a deletion plan, and run only file operations that pass a narrowly scoped review.
⬜ Load the repository into context and let Claude delete directly after reading.
⬜ Allow automatic deletion only during low-traffic hours.

A benefits app takes user-submitted case details and has Claude produce a structured recommendation that can trigger a downstream workflow. Which two controls protect both the model boundary and the business process? (select two)

⬜ Trust all text from authenticated users.
⬜ Run the workflow whenever Claude sounds confident, even if the response doesn’t parse.
⬜ Validate and sanitize incoming fields, keep untrusted case content separate from trusted instructions, and send only the data needed.
⬜ Validate the structured response and the business rules before triggering the workflow, and route failures to a recovery path.

A mobile app calls the Claude API directly with the production API key embedded in the shipped client, and attackers can extract it. What should the team do?

⬜ Obfuscate the key and split it across several source files.
⬜ Keep direct calls but store the key in encrypted local preferences.
⬜ Add the user’s account ID to prompts so misuse can be traced.
⬜ Move the Claude requests to a trusted server with the key in managed secret storage, rotate the exposed key and monitor usage.

A medical app eligible for Zero Data Retention repeatedly processes the same small PDF during a short session. The team is thinking of uploading it through the Files API for convenience. Which design respects the retention requirement?

⬜ Upload through the Files API, since every feature inherits the ZDR agreement.
⬜ Send the PDF inline in eligible Messages requests, and avoid the Files API unless the organization accepts its different retention.
⬜ Upload the file and delete it afterward, since deletion guarantees no retention.
⬜ Put the PDF in the system prompt as base64, since system prompts aren’t retained.

A code-execution agent analyzes customer datasets in a sandbox. It needs package access but must not send customer data to arbitrary internet hosts. Which control enforces this?

⬜ A system instruction never to upload data, with internet access left open.
⬜ Network egress restrictions with an allowlist of approved package sources, with credentials kept outside the sandbox.
⬜ Giving the sandbox the production customer API key so it can verify outbound requests.
⬜ Blocking all package installation and internet access entirely.

A multi-tenant agent calls an internal finance API on behalf of signed-in employees using one shared, long-lived service token with broad access. Which credential design is safer?

⬜ Issue short-lived credentials scoped to the signed-in employee and the requested actions, and check identity again when each sensitive tool runs.
⬜ Keep the shared token but hide it in the system prompt.
⬜ Create one permanent token per department.
⬜ Let Claude choose which employee identity to send in the request header.

Several automated server workloads share one long-lived static Claude API key stored in their deployment configuration, and a security review flags it. Which change most directly reduces the risk?

⬜ Commit the key to a private repository so repository permissions control access.
⬜ Create one non-expiring key and pass it to every workload through environment variables.
⬜ Base64-encode the key in each configuration so it isn’t stored in plain text.
⬜ Move the workloads to Workload Identity Federation, so each one gets short-lived tokens at runtime.

During review of a client-side handler for Claude’s memory tool, the team finds it carries out any path Claude requests, including /memories/../../secrets.env. What’s the correct safeguard?

⬜ Resolve each requested path to its canonical form and reject anything outside the memory directory before acting on it.
⬜ Look for the literal “../” and block only paths containing it.
⬜ Tell Claude in the system prompt to request only paths under /memories.
⬜ Rely on Anthropic’s server-side validation, since memory operations run on managed infrastructure.

A multi-tenant document app uses the Files API, and no customer may ever read another customer’s files. Which design enforces this?

⬜ Accept file IDs from end users and validate the ID format before using them.
⬜ Create a separate workspace per tenant, and keep the mapping between users and their file IDs server-side.
⬜ Keep all tenants in one workspace but give each a different API key.
⬜ Store everything in the Default Workspace and tell Claude to use only the current user’s files.

A company runs three Claude-powered products, all using keys from the organization’s Default Workspace. Leadership wants spend controls per product and assurance that a compromised key for one product can’t reach another product’s resources. What achieves this?

⬜ Rotate the shared key on a fixed schedule.
⬜ Track each product’s usage in its own logs but keep every key in the Default Workspace.
⬜ Create an extra key per product in the Default Workspace and monitor usage by key.
⬜ Create a dedicated workspace for each product and issue keys scoped to those workspaces.

An automated review service runs claude -p over repositories submitted by external contributors. Which two controls stop hooks committed in those repositories from running? (select two)

⬜ Rely on the workspace trust dialog to block repository hooks.
⬜ Tell Claude in the system prompt to ignore repository hooks.
⬜ Pass a settings override that sets disableAllHooks to true for the run.
⬜ Run with –bare, so the repository’s hooks and settings aren’t loaded.

A native iOS app calls the Claude API directly from users’ devices, and security review says no long-lived static key may ship inside the app. Which documented authentication approach fits?

⬜ Download the static key into the device keychain on first launch.
⬜ Configure Workload Identity Federation on each user’s device.
⬜ App Attest, so requests are authenticated through Apple device attestation instead of an embedded key.
⬜ Embed the key with string encryption.

An Agent SDK deployment sandboxes a data-processing agent with a network allowlist to stop data leaving for unapproved hosts. A security review asks whether the allowlist alone guarantees traffic reaches only approved domains. What’s the accurate assessment?

⬜ Turn on allowUnsandboxedCommands so outbound requests go through canUseTool for checking.
⬜ The allowlist is enough, because the proxy validates each connection’s TLS certificate against the approved domain.
⬜ Add a system-prompt instruction to contact only approved hosts, which makes bypass impossible.
⬜ The allowlist filters by hostname and doesn’t inspect TLS traffic, so add a TLS-terminating proxy if stronger guarantees are needed.

A developer puts a database password in the system prompt so Claude can pass it as an argument to a custom database tool. What does a security review require?

⬜ Tell Claude never to repeat the password.
⬜ Keep the credential in the server-side tool implementation, so it never enters the model’s context.
⬜ Base64-encode the password in the prompt.
⬜ Leave it, since system prompts are never shown to users.

A developer is provisioning a static Claude API key for a new server-side service. Which two practices follow the documented guidance? (select two)

⬜ Set an expiration on the key when creating it in the Console.
⬜ Put the key in the system prompt so Claude can pass it to tools.
⬜ Commit it to the service’s private repository.
⬜ Load the key at runtime from a secrets manager or environment variable.

A Claude Code hook is registered under PostToolUse with a Bash matcher, and its script exits with code 2 when a command contains rm -rf or DROP TABLE. In testing, the matching commands still run against the database. What makes the guardrail work?

⬜ Register the same handler under PreToolUse, so the command is checked before it runs.
⬜ Move the hook from project settings to user settings to give it priority.
⬜ Add a system-prompt rule against destructive commands and keep the PostToolUse hook for auditing.
⬜ Make the script exit with code 1 so it’s treated as a hard error.

A team wants a PreToolUse hook that blocks force-pushes and recursive deletes for every engineer who clones the repository, with no individual setup. Where should the hook go?

⬜ In the repository’s CLAUDE.md, telling Claude never to run those commands.
⬜ In the repository’s .claude/settings.local.json.
⬜ In each engineer’s ~/.claude/settings.json.
⬜ In the repository’s .claude/settings.json, committed to version control.

A team commits a project .mcp.json so every developer connects to the same remote HTTP MCP server. The server needs a bearer token in a header, and the token must never be stored in the repository. How should the header be set?

⬜ Base64-encode the token in the headers field.
⬜ Write the header value as ${MCP_API_TOKEN} in .mcp.json, and have each developer set that variable in their environment.
⬜ Put the token in the shared .claude/settings.json env block.
⬜ Commit the token in .mcp.json and rotate it regularly.

A support assistant’s system prompt contains a proprietary discount formula, and testers extracted it by asking the assistant to repeat its instructions. A leak would harm the business. What’s the most appropriate response?

⬜ Add a confidentiality instruction and rely on it, since system prompts can’t be extracted.
⬜ Remove the formula from the prompt wherever it isn’t needed, screen outputs for signs of leaks, and treat prompt-level defenses as one imperfect layer.
⬜ Base64-encode the formula in the prompt.
⬜ Move the formula into a tool_result so Claude treats it as untrusted.

A travel agent calls a search_flights tool, and the application appends its own instruction, “show only the three cheapest fares,” to the end of the tool_result content. Claude sometimes ignores it or flags the tool output as containing suspicious directives. What’s the correct fix?

⬜ Move the instruction out of the tool_result and send it as text in the user turn, after the result.
⬜ Set is_error on the tool_result so the instruction gets more weight.
⬜ Repeat the instruction at the start and end of the tool_result.
⬜ Wrap the instruction in XML tags inside the tool_result.

---

Domain 8: Tools and MCPs (10.6%)

An MCP tool definition has "inputSchema": {"type": "object", "properties": {"region": {"type": "string"}}}. The backend requires region, but calls sometimes leave it out. What fixes the definition?

⬜ Rename region to location without changing which fields are required.
⬜ Add a required array that lists region, keeping the property definition in inputSchema.
⬜ Ask for region in the description and leave the schema as it is.
⬜ Add an input example with region and remove the properties definition.

Claude returns stop_reason “tool_use” with one client tool_use block. What should the application do next?

⬜ Show the tool_use JSON to the user as the final answer.
⬜ Send the same assistant response back until the stop reason changes to end_turn.
⬜ Run the named tool, then send a user message with a tool_result block that references the tool_use id.
⬜ Run every available tool and append all their outputs to the assistant message.

An MCP server must expose a versioned policy catalog that clients list and read by URI, and a risk-scoring operation that takes case details and performs a calculation. Which design fits?

⬜ Expose both as prompts, since prompts can hold data and request calculations.
⬜ Expose the catalog as a resource and the risk scoring as a tool.
⬜ Expose the catalog as a tool and put the scoring operation behind a resource URI.
⬜ Put the catalog in the tool’s description and expose no resource.

A repository has a stable release-review procedure written entirely as instructions. The team wants Claude Code to find it for matching tasks and load the details only when relevant. No external access is needed. What fits best?

⬜ Add the procedure to every prompt.
⬜ Build a custom API tool that returns the static procedure.
⬜ Deploy an MCP server that exposes the procedure as a remote tool.
⬜ Create a project skill that Claude discovers and loads only for relevant tasks.

A team needs Claude to find current public sources with citations and to check order eligibility against a private database with company rules. Which two choices match these capabilities? (select two)

⬜ Redefine a built-in tool with the private database schema so every client runs it.
⬜ Use a custom client tool that automatically receives Anthropic’s web search results and citations.
⬜ Use the built-in web search tool for current public sources and its citations.
⬜ Use a custom client tool for the eligibility check, which the application runs itself.

A travel assistant has two tools named lookup and lookup2, and both descriptions say “finds information.” Claude often picks the wrong one or leaves out arguments. What most directly improves tool selection?

⬜ Raise max_tokens so Claude has more room to decide between the tools.
⬜ Give each tool a distinct, action-oriented name and a precise description, with a schema that explains every argument.
⬜ Remove the tools array, describe the tools in the user message, and have Claude return a function name as text.
⬜ Merge both into one tool that takes an untyped string and parse the string afterward.

A TypeScript tool schema declares quantity as a string, but the inventory service needs a positive integer. Claude sometimes sends “many”, and the service fails partway through. What fixes the contract?

⬜ Run parseInt on every quantity and reserve stock whenever it doesn’t throw.
⬜ Keep quantity as a string and add a longer description asking for numbers.
⬜ Remove quantity from the schema and parse it from the user’s message.
⬜ Declare quantity as an integer and validate the arguments before calling the inventory service.

An organization wants two reusable capabilities: a documented code-review procedure that guides Claude consistently, and live access to an internal issue tracker used by several Claude applications. Which two approaches fit? (select two)

⬜ Put the review procedure and current issue data into one large system prompt copied into every app.
⬜ Build both as custom tools inside each application, with separate schemas per team.
⬜ Package the code-review procedure as a skill.
⬜ Expose the issue tracker’s operations through an MCP server that every app can connect to.

An address-update tool can fail because the customer record is locked or the new address breaks validation rules, but it returns a success-looking string even when nothing changed. How should the result be handled?

⬜ Return a structured error identifying the failure type and safe details, so the application or agent can choose an allowed recovery.
⬜ Return the requested address as if it were saved, and fix the database later.
⬜ Throw an unhandled exception that ends the whole agent session.
⬜ Return an empty result and let Claude guess the cause.

Claude requests three independent read-only lookups in one turn. The dispatcher awaits them one by one and stops at the first failure. The app wants low latency and a valid conversation when one lookup fails. Which two choices fit? (select two)

⬜ Send the successful results and leave out the failed call.
⬜ Run them sequentially, since the API requires results in tool_use order.
⬜ Run the independent lookups concurrently, keeping tools with ordering requirements or side effects out of the parallel group.
⬜ Return a tool_result for every call in the next user message, marking the failed one with is_error and its matching tool_use_id.

A refund tool uses strict schema validation and gets well-formed arguments, but a user tries to refund an order that belongs to another account. The developer says strict tool use already makes this safe. What else is required?

⬜ More field descriptions telling Claude not to refund other users’ orders.
⬜ Executing only when the model repeats the same arguments twice.
⬜ Checking the signed-in user’s authorization and the refund’s eligibility in application code before running the tool.
⬜ Encoding every business rule into the JSON schema.

A company is exposing a central inventory service to Claude clients in several offices. The server runs remotely, must authenticate users through the corporate identity provider and should work with standard HTTP infrastructure. Which MCP design fits?

⬜ Use the stdio transport across the public network.
⬜ Expose the operations as unauthenticated resources, since resources are read-only.
⬜ Run a remote MCP server over Streamable HTTP, protect it with the supported OAuth flow, and check user scopes for each operation.
⬜ Put one shared API key in every client config and identify users by office network.

A design platform wants Claude to browse approved templates, create a project from a chosen template, and offer users a tested briefing starter. Which two MCP mappings are correct? (select two)

⬜ Expose project creation as a resource, since it returns a project ID.
⬜ Expose the template catalog as resources, so the app can list and read the templates.
⬜ Expose project creation as a tool, and the briefing starter as a prompt users can invoke with arguments.
⬜ Expose all three as tools, so Claude controls discovery, creation and the briefing choice.

A team is defining custom tools for an agent that spans several internal services. Which two practices follow Anthropic’s tool-definition guidance? (select two)

⬜ Prefix tool names with the owning service, for example github_list_prs.
⬜ Group related operations such as create, review and merge into one tool with an action parameter.
⬜ Add input_examples to server tools like web search.
⬜ Keep each description to one short sentence to save tokens.

A single Claude application must create and update tickets in the company’s internal issue tracker. No other Claude product will ever need this. What’s the best fit?

⬜ Build and host a standalone MCP server for the tracker.
⬜ Define a custom tool in the API request and have the application make the tracker calls.
⬜ Use an Anthropic server tool, since those can reach internal HTTP endpoints.
⬜ Package the tracker’s API docs as a skill.

A custom client tool takes a nested input object with format-sensitive date and ID fields. Calls pass schema validation but often use the wrong value formats, even though the description already explains each parameter in detail. What’s the recommended next step?

⬜ Set tool_choice to any.
⬜ Turn on strict tool use.
⬜ Flatten the object into one string parameter.
⬜ Add input_examples to the tool definition, with schema-valid samples showing the expected formats.

A developer building an MCP server wants to ship a parameterized code-review workflow that users trigger explicitly, shown as a command with arguments in clients like Claude Code, rather than something the model decides to run. Which primitive fits?

⬜ An MCP tool, so the model calls it when relevant.
⬜ An MCP prompt, which clients surface as a user-invoked command that accepts arguments.
⬜ A list_changed notification whenever a user should run the workflow.
⬜ An MCP resource the client attaches to the conversation.

An agent must read and edit files on the team’s own servers. The team is comparing Anthropic’s text editor tool with a fully custom file-editing tool. What correctly reflects how the Anthropic-defined option works?

⬜ Use the text editor tool and skip edit handling, since Anthropic runs every file operation.
⬜ Use the text editor tool to avoid tool-definition tokens, since the schema is built into the model.
⬜ Use the text editor tool for its schema, which Claude is trained on, and implement the handlers that perform each file operation in the application.
⬜ Avoid it, since it runs only in Anthropic’s code execution container.

An app calls the Messages API and needs the tools from a remote MCP server reachable over HTTPS, without building and running its own MCP client. What fits?

⬜ Reference the server by URL in the mcp_servers parameter, so the MCP connector handles the connection.
⬜ Package the server’s documentation as a skill.
⬜ Recreate each server tool as a custom tool and make the HTTP calls in the app.
⬜ Use the SDK’s client-side MCP helpers to run the connection and convert types.

Claude Desktop connects to three MCP servers: a local stdio filesystem server and two remote HTTP servers. How should the host, client and server roles be modeled?

⬜ Claude Desktop is the host, and it creates one MCP client per server, for three dedicated connections.
⬜ Claude Desktop is a single MCP client that sends messages to all three servers over one shared connection.
⬜ Each server is a client that connects to Claude Desktop, which acts as the server.
⬜ The stdio server runs inside the host process, so only the two remote servers need clients.

A developer adds print statements to a local stdio MCP server to debug a tool handler. The client now reports JSON parse errors and drops the connection. What should change?

⬜ Raise MAX_MCP_OUTPUT_TOKENS on the client.
⬜ Send the debug output to stderr, leaving stdout for the JSON-RPC messages.
⬜ Buffer the logs and flush them to stdout between responses.
⬜ Make the client reconnect with backoff after parse errors.

An assistant has several custom tools with the default tool_choice of auto. Claude often answers from its own knowledge instead of using the tools, but it must still reply directly to purely conversational turns. What’s the right adjustment?

⬜ Add a system-prompt instruction telling Claude to use the tools to investigate before answering.
⬜ List each tool twice in the tools array.
⬜ Set tool_choice to any so every turn calls a tool.
⬜ Raise the temperature.

A developer is writing an MCP server whose tools Claude will call through several different MCP clients. Which two server-side practices make Claude use the tools more reliably? (select two)

⬜ Return the complete raw payload from every tool so no follow-up call is needed.
⬜ Define each input schema as a root-level anyOf union, so one tool accepts several shapes.
⬜ Declare accurate tool annotations, such as readOnlyHint on tools with no side effects.
⬜ Return failures as tool results flagged as errors, with a message that says what went wrong.

A recruiting assistant uses the MCP connector to reach an applicant-tracking server that exposes delete_candidate and merge_profiles alongside read-only tools. The assistant must never modify data, yet a review found a delete_candidate call despite a system prompt forbidding it. What enforces the restriction?

⬜ Set tool_choice to none on requests that seem likely to trigger a write.
⬜ Set defer_loading on the two tools so Claude sees them only after a tool search.
⬜ Disable delete_candidate and merge_profiles in the mcp_toolset configs, so they’re never offered to Claude.
⬜ Rewrite the system prompt with emphatic, repeated instructions.

---