Question 540
An assistant must support follow-up questions within a ticket but start fresh after its authorization scope changes. Which capability is necessary for this outcome?
- Define accessible error and refusal behavior
- Define the authority of each tool action
- Define the session continuity model
- Specify source attribution for factual answers
Explanation
Correct Answer
C:Session rules identify which prior context persists and when it must be invalidated; the important constraint is that accidentally reusing a cross-account history can expose sensitive context.
Incorrect Answers
A:Usability criteria describe understandable errors, alternatives, and escalation paths; the needed capability is different—session rules identify which prior context persists and when it must be invalidated—and returning an empty model response leaves users unable to diagnose or recover.
B:Access requirements tie each permitted side effect to identity, scope, and approval evidence, whereas the requirement calls for another behavior: session rules identify which prior context persists and when it must be invalidated; a model's confidence in a request is not proof of caller authority.
D:Product requirements describe links or identifiers for supporting evidence and how claims map to sources; the requirement instead turns on this behavior: session rules identify which prior context persists and when it must be invalidated; requiring a confident tone does not establish provenance.
Question 541
An engineer finishes one customer bug and begins an unrelated repository security review. Which implementation mechanism is needed?
- Use an interactive session for exploratory editing
- Review effective settings before broad automation
- Start a new session for an unrelated objective
- Resume a relevant prior session intentionally
Explanation
Correct Answer
C:A clean context prevents old task details from biasing the new investigation; shared persistent project guidance may still apply independently of session history.
Incorrect Answers
A:An interactive coding session supports iterative commands and review as context evolves; the missing capability is more specific: a clean context prevents old task details from biasing the new investigation; automating every command without supervision is unnecessary for a human-led investigation.
B:Examining effective permission and hook configuration catches dangerous inherited allowances; by comparison, the intended solution relies on this: a clean context prevents old task details from biasing the new investigation; a printed prompt cannot override an enforced policy hierarchy.
D:Session resumption restores applicable prior conversational context for continuation, whereas the requirement calls for another behavior: a clean context prevents old task details from biasing the new investigation; resuming the wrong session can import stale assumptions or sensitive unrelated history.
Question 542
A user types a question and expects streamed feedback in seconds. What is the right implementation response?
- Use the real-time Messages API for chat
- Correlate batch results by custom identifiers
- Budget total latency for thinking and output
- Submit independent offline jobs to Message Batches
Explanation
Correct Answer
A:Direct Messages calls match interactive latency and incremental display requirements; batch jobs complete later and are inappropriate for a tightly coupled request-response interface.
Incorrect Answers
B:Stable request IDs let the application map each result to the correct original record, whereas the requirement calls for another behavior: direct Messages calls match interactive latency and incremental display requirements; relying on result ordering can mix customer records or output destinations.
C:Performance tests include model reasoning time as well as visible answer generation; however, the critical mechanism here is that direct Messages calls match interactive latency and incremental display requirements, and restricting just the final response length may not address total computation time.
D:Batch submission processes asynchronous independent requests efficiently and can reduce input/output processing cost; the requirement instead turns on this behavior: direct Messages calls match interactive latency and incremental display requirements; it does not provide a synchronous final message for a user awaiting an immediate reply.
Question 543
A distributed process needs durable timers, human approvals, and retries across several services. Which approach targets the deciding condition?
- Gate a write tool behind a transaction boundary
- Build a custom Messages API loop
- Use a basic Messages API call
- Use an external workflow engine
Explanation
Correct Answer
D:A job engine coordinates state transitions and recovery outside the model's transient response; a crucial qualification is that it still requires model calls as activities rather than relying on prompts for transaction control.
Incorrect Answers
A:The application coordinates the write with transactional or compensating logic outside the model; in contrast, a job engine coordinates state transitions and recovery outside the model's transient response, while language-model intent is not a database rollback guarantee.
B:A developer-managed loop explicitly handles tool_use, executes tools, returns tool_result, and continues as needed; this addresses a separate concern, not the fact that a job engine coordinates state transitions and recovery outside the model's transient response; every error, retry, and termination branch must be implemented by the application.
C:A single request produces the completion without a persistent orchestration loop; here, the controlling capability is that a job engine coordinates state transitions and recovery outside the model's transient response, but adding agent scaffolding increases latency for a task with no external actions.
Question 544
A streaming response contains explanatory text followed by a request to invoke a business function. What is the most direct implementation choice?
- Show uncertainty when evidence is insufficient
- Display text content while handling tool calls separately
- Separate display text from operational commands
- Preserve incremental rendering order
Explanation
Correct Answer
B:The UI renders text but dispatches structured tool blocks through the application control path; the important constraint is that showing a raw tool call as a final answer leaves the workflow incomplete.
Incorrect Answers
A:The product communicates the gap and offers verification rather than inventing a confident conclusion, whereas the requirement calls for another behavior: the UI renders text but dispatches structured tool blocks through the application control path; more assertive response wording would make an unsupported answer misleading.
C:The service distinguishes a human-readable recommendation from an authorized tool action; the requirement instead turns on this behavior: the UI renders text but dispatches structured tool blocks through the application control path; parsing ordinary prose to infer permission for a write is unsafe.
D:Ordered stream assembly avoids scrambled or duplicated text fragments; this cannot substitute for the behavior that the UI renders text but dispatches structured tool blocks through the application control path, because parallel callbacks that append out of order can corrupt an otherwise valid response.
Question 545
Engineers repeatedly invoke the same changelog-drafting instructions, but commands that touch protected paths must first pass a non-negotiable policy check. Which TWO automation features best separate convenience from enforcement? Choose TWO.
- Use a subagent for context-isolated auditing
- Use a custom command for a repeated invocation
- Create a project Skill for recurring checks
- Use a built-in server tool for a supported commodity task
- Use a hook for mandatory pre-execution validation
Explanation
Correct Answers
B:A command encapsulates a recognizable workflow entry point for interactive coding sessions, subject to this requirement: it does not create a new callable external service by itself.
E:A lifecycle hook evaluates the proposed action outside the model and can block it deterministically; in production, natural-language checklists are weaker than enforced execution controls; the recurring command template is a convenience while the separate hook remains a non-negotiable execution boundary.
Incorrect Answers
A:A delegated worker returns focused findings while keeping its verbose exploration isolated; in contrast, a command encapsulates a recognizable workflow entry point for interactive coding sessions, while separate context is not a substitute for least-privilege tool access.
C:Skill content packages reusable instructions and supporting guidance for the task; here, the controlling capability is that a command encapsulates a recognizable workflow entry point for interactive coding sessions, but the project must still provide actual tests and tools needed to perform the checks.
D:A built-in server tool uses the platform's execution flow and supported result types; the missing capability is more specific: a command encapsulates a recognizable workflow entry point for interactive coding sessions; it does not grant custom private database access.
Question 546
An application sometimes starts with a missing API key or an invalid model setting and fails on the first customer request. Which solution should the engineer adopt?
- Store environment-specific endpoints in configuration
- Fail closed on missing safety configuration
- Validate configuration at startup
- Manage SDK dependencies through a lockfile
Explanation
Correct Answer
C:Early checks fail fast with a clear operator error before the service accepts work; the implementation must still recognize that deferring discovery to live traffic increases incident impact.
Incorrect Answers
A:Deployment configuration injects environment values without rewriting application logic; in contrast, early checks fail fast with a clear operator error before the service accepts work, while hardcoded production URLs increase the chance of accidental test writes.
B:Startup validation blocks unsafe execution rather than falling back to all permissions; this addresses a separate concern, not the fact that early checks fail fast with a clear operator error before the service accepts work; the absence of a guardrail must not silently widen access.
D:Locked dependencies produce repeatable runtime behavior from tested package versions; the missing capability is more specific: early checks fail fast with a clear operator error before the service accepts work; loose version ranges can introduce changes without deliberate evaluation.
Question 547
A complicated agent plan generates a short final answer but spends noticeable time deliberating. Which technical control is appropriate?
- Handle output truncation explicitly
- Recognize latency due to extra reasoning
- Use extra reasoning on high-complexity tasks
- Handle context overflow before submission
Explanation
Correct Answer
B:Reasoning controls and task complexity affect total latency independently of answer length, although reducing displayed text alone may not remove the underlying thinking cost.
Incorrect Answers
A:Stop-reason inspection catches the partial response before parsing or persistence; the needed capability is different—reasoning controls and task complexity affect total latency independently of answer length—and an arbitrary string closure should not be treated as a validated complete JSON object.
C:Supported thinking or effort settings allocate greater reasoning capacity to difficult deliberation; however, the critical mechanism here is that reasoning controls and task complexity affect total latency independently of answer length, and added reasoning can increase latency and cost and still requires factual validation.
D:Chunking, retrieval, or compaction reduces input size while retaining decision-relevant evidence; the requirement instead turns on this behavior: reasoning controls and task complexity affect total latency independently of answer length; increasing output max_tokens cannot make an overlong input fit.
Question 548
Historical compatibility branches are making the application hard to reason about. What should be implemented to solve this problem?
- Remove dead configuration flags after verification
- Centralize retry policy in shared middleware
- Run contract tests against a versioned API schema
- Extract the tool dispatcher into a tested module
Explanation
Correct Answer
A:Evidence of unused paths plus regression tests permit safe cleanup of obsolete logic; a crucial qualification is that deleting unknown switches without checking deployments can cause hidden failures.
Incorrect Answers
B:Shared policy consistently classifies errors and applies bounded retries across services; by comparison, the intended solution relies on this: evidence of unused paths plus regression tests permit safe cleanup of obsolete logic; it must still allow endpoint-specific rules for unsafe side effects.
C:Contract tests enforce agreed field names, types, and error shapes across producer and client; the needed capability is different—evidence of unused paths plus regression tests permit safe cleanup of obsolete logic—and casual manual testing may miss a breaking field change.
D:Separating dispatch logic creates a clear authorization and error-handling boundary, whereas the requirement calls for another behavior: evidence of unused paths plus regression tests permit safe cleanup of obsolete logic; rearranging code without tests can accidentally change tool semantics.
Question 549
An application asks Claude to answer using a current customer handbook stored outside the model. Which of these alternatives serves the stated goal?
- Inject task-specific retrieval into an API call
- Configure permissions within the relevant client
- Retrieve only topically relevant passages
- Persist conversation history in application storage
Explanation
Correct Answer
A:Retrieval supplies authorized source excerpts as contextual content in the request—with this limitation: model training data is not a reliable substitute for current private documents.
Incorrect Answers
B:Client-specific settings define the environment and its permitted tool behavior; this cannot substitute for the behavior that retrieval supplies authorized source excerpts as contextual content in the request, because configuring a distant backend does not necessarily constrain a local coding session.
C:Search or retrieval supplies a bounded evidence set instead of the entire collection; in contrast, retrieval supplies authorized source excerpts as contextual content in the request, while sending all documents raises cost, noise, and exposure without improving source precision.
D:The application saves and reconstructs relevant turns because Messages requests are stateless; this addresses a separate concern, not the fact that retrieval supplies authorized source excerpts as contextual content in the request; assuming the API remembers every prior independent call will break continuity.
Question 550
Several clients cannot upgrade together when a tool input field is renamed. Which measure directly addresses the problem?
- Review post-incident root causes
- Remove deprecated configuration under change control
- Use automated integration tests before release
- Use backward-compatible interface evolution
Explanation
Correct Answer
D:Additive changes and versioned contracts allow old and new clients to coexist during migration; in production, an abrupt breaking rename can strand clients even if the model prompt is unchanged.
Incorrect Answers
A:Root-cause analysis traces initiating conditions and systemic prevention beyond short-term restoration; this addresses a separate concern, not the fact that additive changes and versioned contracts allow old and new clients to coexist during migration; a successful restart does not explain why the same fault reappears.
B:A controlled cleanup traces dependencies, verifies current usage, and deletes unused flags with tests; here, the controlling capability is that additive changes and versioned contracts allow old and new clients to coexist during migration, but removing all old switches at once can unintentionally disable required paths.
C:Integration tests check how independently coded components actually interact under realistic conditions; the missing capability is more specific: additive changes and versioned contracts allow old and new clients to coexist during migration; unit tests of isolated helpers cannot reveal all cross-component contract failures.