Question 50
A company must impose nonoptional tool access controls across developer machines. What is the most direct implementation choice?
- Use organization-managed policy for enforced restrictions
- Maintain repository CLAUDE.md instructions
- Keep secrets out of settings files committed to Git
- Use local settings for workstation-only behavior
Explanation
Correct Answer
A:Managed settings supply centrally governed guardrails rather than relying on voluntary user configuration; in production, ordinary project instructions are not equivalent to an enforced corporate security policy.
Incorrect Answers
B:Project memory files make scoped guidance available in Claude Code working contexts; the needed capability is different—managed settings supply centrally governed guardrails rather than relying on voluntary user configuration—and they should not contain credentials or private production secrets.
C:Secrets belong in protected secret stores or environment injection rather than tracked source, whereas the requirement calls for another behavior: managed settings supply centrally governed guardrails rather than relying on voluntary user configuration; repository history can preserve credentials even after a later edit deletes them.
D:Local configuration can hold machine-specific client preferences outside shared version control; however, the critical mechanism here is that managed settings supply centrally governed guardrails rather than relying on voluntary user configuration, and committing private machine policy could surprise teammates.
Question 51
An assistant connects to a customer's external mailbox, then receives a request that would access a different account's confidential messages. Which TWO independent permission checks are necessary before either operation can proceed? Choose TWO.
- Check end-user permissions before using a customer tool
- Require consent for delegated third-party scopes
- Revoke integration access when offboarding
- Audit approval decisions for high-impact actions
- Store credentials in a secret manager
Explanation
Correct Answers
A:The backend verifies the caller is allowed to access that specific object; the implementation must still recognize that a valid session establishes identity but not ownership of every possible resource.
B:A proper authorization and consent flow limits the scopes granted to the integration; a crucial qualification is that model-generated text cannot silently supply the user's valid consent.
Incorrect Answers
C:Offboarding revokes credentials and grants to prevent future unauthorized use; by comparison, the intended solution relies on this: the backend verifies the caller is allowed to access that specific object; deleting the employee's saved chat does not revoke external tool credentials.
D:A durable record captures the approver, scope, timestamp, and action approved; the needed capability is different—the backend verifies the caller is allowed to access that specific object—and an assistant's paraphrase of approval is not equivalent to an auditable authorization event; a log of consent cannot establish that the mailbox owner authorized access to the different account.
E:Protected storage and runtime injection keep billable API keys out of committed files, whereas the requirement calls for another behavior: the backend verifies the caller is allowed to access that specific object; encryption at rest does not justify exposing secrets in source control.
Question 52
Ambiguous support requests are regularly misrouted because two ticket categories overlap. Which approach targets the deciding condition?
- Provide contrastive edge-case examples
- Give a correct representative example
- Retain previously passing edge cases
- Test prompt examples for representativeness
Explanation
Correct Answer
A:Distinct positive and near-miss cases teach the actual boundary between labels—with this limitation: repeating many easy cases offers little information about ambiguous ones.
Incorrect Answers
B:A compact demonstration clarifies the intended input-to-output mapping; this cannot substitute for the behavior that distinct positive and near-miss cases teach the actual boundary between labels, because examples should match the required schema and not use private customer records.
C:Regression fixtures preserve known correct behavior across prompt changes; in contrast, distinct positive and near-miss cases teach the actual boundary between labels, while evaluating only newly fixed failures gives a biased view of quality.
D:Broader cases reveal where examples bias the model toward a narrow pattern; this addresses a separate concern, not the fact that distinct positive and near-miss cases teach the actual boundary between labels; more examples do not automatically fix poor dataset coverage.
Question 53
An application must not hang indefinitely if a network connection stalls. Which implementation mechanism is needed?
- Use retry-aware HTTP error handling
- Use HTTPS for remote model requests
- Use request timeouts for bounded waits
- Use server-sent events for streamed responses
Explanation
Correct Answer
C:Client networking deadlines convert unbounded waits into controlled failures; a crucial qualification is that a model token cap does not constrain socket wait times.
Incorrect Answers
A:Status classification drives different responses for transient and permanent errors; this addresses a separate concern, not the fact that client networking deadlines convert unbounded waits into controlled failures; blindly retrying invalid JSON does not improve correctness.
B:TLS protects data in transit against passive interception and many tampering threats; here, the controlling capability is that client networking deadlines convert unbounded waits into controlled failures, but encryption does not substitute for caller authentication or payload minimization.
D:SSE carries incremental events from the service to the client as generation proceeds; by comparison, the intended solution relies on this: client networking deadlines convert unbounded waits into controlled failures; it is not a general-purpose bidirectional client messaging transport.
Question 54
A new client may submit a malformed messages array and the application should catch it before a network call. What is the appropriate next design choice?
- Use typed deserialization for a structured result
- Reject unexpected fields in business actions
- Validate the outer JSON object schema
- Run contract tests against a versioned API schema
Explanation
Correct Answer
C:Schema checking enforces required keys, types, and nested structures consistently; its operational boundary is that a parseable JSON string can still violate the endpoint's semantic contract.
Incorrect Answers
A:Typed parsing converts validated JSON into an explicit application data contract; the requirement instead turns on this behavior: schema checking enforces required keys, types, and nested structures consistently; free-form text parsing with ad hoc regular expressions is brittle under wording changes.
B:Application validation controls the allowed property set before any database mutation; this cannot substitute for the behavior that schema checking enforces required keys, types, and nested structures consistently, because the model may produce syntactically valid extra keys that are unsafe to execute.
D:Contract tests enforce agreed field names, types, and error shapes across producer and client; this addresses a separate concern, not the fact that schema checking enforces required keys, types, and nested structures consistently; casual manual testing may miss a breaking field change.
Question 55
A healthcare integration must answer a narrow question without transmitting unnecessary patient identifiers. Which mechanism should the team prioritize?
- Optimize for budget under a fixed accuracy floor
- Document data-handling and retention constraints
- Optimize for correctness before model speed
- Optimize for data minimization
Explanation
Correct Answer
D:Requirements enforce removal or redaction of irrelevant personal fields before model calls; its operational boundary is that a larger context window is not permission to send more regulated data.
Incorrect Answers
A:Candidate models are compared on both quality and total per-item spending across realistic inputs; however, the critical mechanism here is that requirements enforce removal or redaction of irrelevant personal fields before model calls, and selecting the cheapest model regardless of failures can increase downstream operational costs.
B:Privacy requirements identify permitted collection, transmission, storage, retention, and deletion controls; the requirement instead turns on this behavior: requirements enforce removal or redaction of irrelevant personal fields before model calls; developer convenience cannot override legal or organizational handling obligations.
C:The acceptance process emphasizes measured quality and human review before pursuing latency reductions; this cannot substitute for the behavior that requirements enforce removal or redaction of irrelevant personal fields before model calls, because a fast answer is not suitable if it violates the required error threshold.
Question 56
An assistant is asked to save a preference that should survive future independent sessions. Which approach best meets this requirement?
- Summarize old steps before continuing
- Load task-specific memory at the start
- Write durable memory only through an authorized tool
- Gate a write tool behind a transaction boundary
Explanation
Correct Answer
C:A storage tool persists a validated fact in an application-owned record; model response text alone does not update a durable external database.
Incorrect Answers
A:A compact summary can replace bulky intermediate transcripts for the next model call; the missing capability is more specific: a storage tool persists a validated fact in an application-owned record; summaries can lose details unless critical facts and provenance are retained.
B:Relevant stored facts are retrieved and inserted into the allowed context for the current task; by comparison, the intended solution relies on this: a storage tool persists a validated fact in an application-owned record; the context selection must be scoped to the authenticated customer.
D:The application coordinates the write with transactional or compensating logic outside the model, whereas the requirement calls for another behavior: a storage tool persists a validated fact in an application-owned record; language-model intent is not a database rollback guarantee.
Question 57
The same service must target sandbox resources in testing and production resources after approval. What should be implemented to solve this problem?
- Store environment-specific endpoints in configuration
- Document required environment variables
- Manage SDK dependencies through a lockfile
- Pin tested model identifiers for controlled services
Explanation
Correct Answer
A:Deployment configuration injects environment values without rewriting application logic, subject to this requirement: hardcoded production URLs increase the chance of accidental test writes.
Incorrect Answers
B:An explicit configuration contract makes setup repeatable without embedding secret values; here, the controlling capability is that deployment configuration injects environment values without rewriting application logic, but copying the original developer's entire environment is neither secure nor maintainable.
C:Locked dependencies produce repeatable runtime behavior from tested package versions; the missing capability is more specific: deployment configuration injects environment values without rewriting application logic; loose version ranges can introduce changes without deliberate evaluation.
D:A fixed supported model ID avoids unexpected alias migrations during the approval window; by comparison, the intended solution relies on this: deployment configuration injects environment values without rewriting application logic; pinning cannot prevent a provider from eventually retiring a version.
Question 58
An assistant handles typical coding and reasoning tasks with a moderate budget and latency target. Which choice should be used here?
- Check currently supported model IDs before deployment
- Prefer Haiku-class models for validated simple tasks
- Prefer Opus-class models for demanding reasoning
- Prefer Sonnet-class models for balanced workloads
Explanation
Correct Answer
D:A balanced model tier can provide strong capability at lower overhead than the highest tier; notably, higher complexity may still justify a more powerful model.
Incorrect Answers
A:The official model catalog identifies supported identifiers and feature availability, whereas the requirement calls for another behavior: a balanced model tier can provide strong capability at lower overhead than the highest tier; historical aliases should not be assumed to remain valid.
B:A smaller model family often minimizes latency and unit cost for routine operations; however, the critical mechanism here is that a balanced model tier can provide strong capability at lower overhead than the highest tier, and actual suitability should be verified with representative task evaluations.
C:The top capability tier is a candidate when advanced reasoning quality dominates the tradeoff; the requirement instead turns on this behavior: a balanced model tier can provide strong capability at lower overhead than the highest tier; higher cost and time should be justified through measured improvement.
Question 59
A large codebase has unrelated modules requiring independent reviews and a final coherent risk report. What should be implemented to solve this problem?
- Keep a single direct model call
- Apply orchestrator-worker decomposition
- Select a sequential prompt chain
- Use a summarizing worker for context compression
Explanation
Correct Answer
B:A coordinator decomposes the task and merges workers' results after their bounded subtasks complete; its operational boundary is that workers need nonoverlapping responsibilities and explicit result contracts to avoid duplication.
Incorrect Answers
A:A direct request minimizes latency and operational state for a bounded answer; this cannot substitute for the behavior that a coordinator decomposes the task and merges workers' results after their bounded subtasks complete, because an agent loop would add failure modes without yielding a decision the model must make.
C:The first output becomes the next step's input in a deliberate dependency chain; this addresses a separate concern, not the fact that a coordinator decomposes the task and merges workers' results after their bounded subtasks complete; running these stages concurrently would deny the reviewer the draft it must inspect.
D:A dedicated summarizer condenses retained facts with provenance and open issues for the parent context; here, the controlling capability is that a coordinator decomposes the task and merges workers' results after their bounded subtasks complete, but compression may omit nuance unless the system checks critical commitments and references.
Question 60
A payment total must follow an exact decimal arithmetic specification with no creative interpretation. What is the most direct implementation choice?
- Use a capable tier for complex synthesis
- Use a specialized deterministic tool instead of any model
- Use a staged escalation strategy
- Run a canary rollout for a new model version
Explanation
Correct Answer
B:Trusted software calculates deterministic numeric results independently of language-model tier, subject to this requirement: upgrading to a larger model does not supply an arithmetic correctness guarantee.
Incorrect Answers
A:A stronger model may justify its cost when deeper synthesis materially improves decisions; in contrast, trusted software calculates deterministic numeric results independently of language-model tier, while its result still requires evidence and domain-specific review.
C:An escalation policy retries only the genuinely hard or failed cases on a higher-capability tier; here, the controlling capability is that trusted software calculates deterministic numeric results independently of language-model tier, but escalation thresholds must be evaluated to avoid excessive retries.
D:Limited exposure allows observation of quality, refusal, latency, and tool usage before full migration; the missing capability is more specific: trusted software calculates deterministic numeric results independently of language-model tier; a model upgrade can affect the entire user experience even when code is unchanged.