Question 610
A helpdesk service sends an identical policy manual with every request, followed by unique user questions. Which choice most directly satisfies the documented goal?
- Cache a stable, high-volume prompt prefix
- Assess cache lifetime with actual reuse patterns
- Instrument cache effectiveness with token usage counters
- Keep dynamic fields out of cached prefix content
Explanation
Correct Answer
A:Put reusable instructions and reference material in a consistent prefix and use supported prompt-cache controls while placing variable requests afterward; cache-hit telemetry verifies the optimization rather than relying on estimated token savings; evaluate the design with cache-read input tokens and end-to-end latency over repeated requests.
Incorrect Answers
B:Assess eligible caching windows, traffic frequency, and write/read economics against real reuse intervals before selecting a cache policy; a long cache lifetime is not automatically economical when there is little repeated work; this alternative would measure net cost per accepted request across realistic interarrival times; it does not establish cache-read input tokens and end-to-end latency over repeated requests for the described use case.
C:Compare cache-creation and cache-read token telemetry and inspect prefix ordering, eligible size, and reuse timing; a faster model might improve latency but would not explain a missing cache hit on identical prompts; this alternative would measure sustained cache-read token share under repeated workload replay; it does not establish cache-read input tokens and end-to-end latency over repeated requests for the described use case.
D:Move changing metadata after the stable prefix so cache keys remain reusable across otherwise similar requests; a cache breakpoint cannot compensate for changes to earlier content in the hashed prefix; this alternative would measure prefix reuse ratio when request metadata changes across calls; it does not establish cache-read input tokens and end-to-end latency over repeated requests for the described use case.
Question 611
A developer cannot invoke an approved test command although local settings appear to permit it. Which design decision directly addresses this constraint?
- Restore a known-good prompt and tool version
- Inspect permission precedence when a tool is unexpectedly denied
- Replay failures safely with sanitized inputs
- Produce incident learning actions with accountable follow-up
Explanation
Correct Answer
B:Review organization, project, and local permission layers in the documented precedence order before weakening security controls; precedence tests prevent insecure workarounds that bypass governance intent; evaluate the design with correct identification of enforced deny source without allowing prohibited commands.
Incorrect Answers
A:Maintain versioned releases and documented rollback steps for hooks, prompts, model routes, and connector configuration; repeated untracked hotfixes can compound an outage and obscure the initial trigger; this alternative would measure time to restore normal operation using an approved previous release; it does not establish correct identification of enforced deny source without allowing prohibited commands for the described use case.
C:Build redacted, access-controlled replay fixtures preserving relevant syntax and error conditions without unnecessary secrets or personal data; raw transcript reuse can expose confidential inputs and violate data-handling policies; this alternative would measure bug reproduction on sanitized fixtures with no sensitive token disclosure; it does not establish correct identification of enforced deny source without allowing prohibited commands for the described use case.
D:Run blameless root-cause analysis, link corrective actions to owners, and add regression or operational safeguards before closing the incident; restarting the service restores availability but does not reduce the recurrence probability; this alternative would measure recurrence rate of the diagnosed failure and completion of preventive actions; it does not establish correct identification of enforced deny source without allowing prohibited commands for the described use case.
Question 612
A vendor page tells the assistant to email internal price lists to an external address. What is the most direct remediation?
- Sandbox untrusted code and file operations
- Allowlist generated fields and destinations before external calls
- Apply controls at input, tool execution, and output boundaries
- Treat retrieved instructions as untrusted data
- Enforce least privilege where tool actions execute
Explanation
Correct Answer
D:Keep source contents in a lower-trust evidence role and prevent embedded commands from crossing into tool authority; simulated hostile documents test the trust boundary directly; verify the repair using attack success rate on adversarial web pages and zero unauthorized egress calls.
Incorrect Answers
A:An instruction saying 'do not read secrets' cannot contain arbitrary code on an unrestricted host; isolate execution with restricted filesystem, network, credentials, resources, and observable policy denials; that control is assessed by forbidden file and network access attempts blocked in execution tests; the incident instead requires attack success rate on adversarial web pages and zero unauthorized egress calls.
B:Formatting the request as JSON does not make arbitrary field values safe to transmit; validate destinations, argument types, sensitive fields, and authorization before dispatch; reject values outside the approved contract; that control is assessed by zero unapproved recipients or fields accepted by the outbound service; the incident instead requires attack success rate on adversarial web pages and zero unauthorized egress calls.
C:A single content filter cannot enforce account privileges or validate downstream business transactions; layer input handling, model instructions, backend authorization, schema checks, and output review so one failed defense does not grant action authority; that control is assessed by denial of unauthorized actions and harmful outputs across multi-stage red-team paths; the incident instead requires attack success rate on adversarial web pages and zero unauthorized egress calls.
E:Natural-language reminders do not remove capabilities exposed by the API or bearer token; enforce role and scope in the backend execution service using credentials that cannot perform the forbidden action; that control is assessed by zero payment writes when tested with the analytics identity and forged instructions; the incident instead requires attack success rate on adversarial web pages and zero unauthorized egress calls.
Question 613
An AI-produced code patch compiles but silently deletes the authorization check that restricts access to another tenant’s records. Which human engineering control must catch that risk?
- Run reproducible CI gates on assisted code
- Generate documentation from verified source and review it
- Break large refactors into independently reviewable changes
- Review AI-generated diffs for logic and security regressions
- Package reusable engineering instructions as governed Skills
Explanation
Correct Answer
D:Require focused code review of the actual diff, threat-relevant tests, and approval before merging sensitive changes; diff-focused review finds changes that ordinary output fluency cannot reveal; verify the repair using detection of seeded authorization regressions during peer review and CI.
Incorrect Answers
A:Local success can be environment-dependent and should not be the only release assurance; execute standardized linting, type checks, tests, and security scanning in versioned CI environments before merges; that control is assessed by cI pass reproducibility on clean builds with locked dependencies; the incident instead requires detection of seeded authorization regressions during peer review and CI.
B:Fluent prose generated from old context is not a reliable record of a current API contract; ground documentation generation in current code, schemas, and tests, then validate examples and have owners review changes; that control is assessed by documented endpoint examples executing successfully against the reviewed build; the incident instead requires detection of seeded authorization regressions during peer review and CI.
C:One massive patch can reduce initial coordination but increases regression and rollback risk; use small scoped changes, compatibility checkpoints, and separate pull requests tied to specific tests; that control is assessed by review time and defect localization per incremental change set; the incident instead requires detection of seeded authorization regressions during peer review and CI.
E:Shared instructions improve consistency but do not replace enforced approval or automated tests; maintain task-scoped reusable Skills or playbooks with versioning, ownership, and documented prerequisites; that control is assessed by checklist completeness across independent sessions using the reviewed Skill version; the incident instead requires detection of seeded authorization regressions during peer review and CI.
Question 614
A broad shared MCP credential lets one squad's assistant query another squad's restricted source. How should the design be corrected?
- Use managed configuration to constrain dangerous permissions
- Scope MCP connections by project and user identity
- Use deterministic hooks to enforce required developer gates
- Keep credentials out of prompts and versioned configuration
- Version team-wide CLAUDE.md guidance with the repository
Explanation
Correct Answer
B:Choose appropriate configuration scope and per-user or service authorization for MCP servers, avoiding shared cross-project secrets; scope checks confirm that connector convenience has not expanded data visibility; verify the repair using access denial for cross-project MCP resources under user identity tests.
Incorrect Answers
A:Personal preference files are not a trustworthy substitute for centrally governed high-risk permissions; use organization-managed policy and supported permission configuration so enforced restrictions cannot be casually overridden by per-user convenience settings; that control is assessed by denial of prohibited commands after attempts to override local and project configuration; the incident instead requires access denial for cross-project MCP resources under user identity tests.
C:A written instruction alone is best-effort and does not guarantee enforcement of a critical command gate; configure supported hooks for deterministic checks at appropriate lifecycle points, with clear failure behavior and maintenance ownership; that control is assessed by hook execution and blocked noncompliant operations under simulated bypass attempts; the incident instead requires access denial for cross-project MCP resources under user identity tests.
D:Masking output after committing a secret cannot undo credential exposure or grant least privilege; use approved secret storage, scoped environment access, and redaction while avoiding credentials in repositories, prompts, or logs; that control is assessed by secret-scanning results and blocked exfiltration on seeded repository credentials; the incident instead requires access denial for cross-project MCP resources under user identity tests.
E:A documentation file guides behavior but cannot enforce operating-system permissions or replace CI tests; put reviewed repository-specific guidance in a shared CLAUDE.md file with appropriate scope and code review; that control is assessed by consistency of generated changes with repository build and test conventions across fresh sessions; the incident instead requires access denial for cross-project MCP resources under user identity tests.
Question 615
A debugging assistant repeatedly says a repository file is absent while the underlying file-search tool returns timeouts. What action best fits the business and technical boundary?
- Distinguish model selection faults from tool execution failures
- Replay sanitized incident inputs without exposing customer data
- Roll back to a known-good tool and prompt release
- Produce incident learning actions with accountable follow-up
Explanation
Correct Answer
A:Classify tool errors separately from model responses, validate return codes, and probe the failing integration before changing prompts; controlled fault injection tests whether the team diagnoses the failing layer; evaluate the design with correct root-cause attribution under injected search timeouts.
Incorrect Answers
B:Build redacted, access-controlled replay fixtures preserving relevant syntax and error conditions without unnecessary secrets or personal data; raw transcript reuse can expose confidential inputs and violate data-handling policies; this alternative would measure bug reproduction on sanitized fixtures with no sensitive token disclosure; it does not establish correct root-cause attribution under injected search timeouts for the described use case.
C:Maintain versioned releases and documented rollback steps for hooks, prompts, model routes, and connector configuration; repeated untracked hotfixes can compound an outage and obscure the initial trigger; this alternative would measure time to restore normal operation using an approved previous release; it does not establish correct root-cause attribution under injected search timeouts for the described use case.
D:Run blameless root-cause analysis, link corrective actions to owners, and add regression or operational safeguards before closing the incident; restarting the service restores availability but does not reduce the recurrence probability; this alternative would measure recurrence rate of the diagnosed failure and completion of preventive actions; it does not establish correct root-cause attribution under injected search timeouts for the described use case.
Question 616
A CRM integration queries records with a shared service token; it returns customers that the current sales representative is forbidden to view. Which identity propagation pattern would enforce the representative’s access limits?
- Use delegated user identity for per-user data access
- Issue short-lived scoped credentials for tools
- Enforce authorization inside the tool backend
- Verify tenant ownership of resource identifiers
Explanation
Correct Answer
A:Carry an appropriate user-bound authorization context to downstream services and enforce record-level access per request; user-context tests verify enforcement of the source system's individual access rules; verify the repair using zero cross-user CRM record disclosures in permission-matrix tests.
Incorrect Answers
B:Encrypting a shared permanent key at rest does not mitigate broad privilege after the key is exposed; prefer tightly scoped, expiring credentials with secure rotation and audited issuance for the precise operation; that control is assessed by credential-expiry and scope-denial tests after simulated token compromise; the incident instead requires zero cross-user CRM record disclosures in permission-matrix tests.
C:Prompt-only restrictions can be bypassed and are not an independently audited authorization control; implement enforceable role, amount, and resource checks at the action service, not just in natural-language instructions; that control is assessed by rejection of unauthorized tool calls even when sent outside the model workflow; the incident instead requires zero cross-user CRM record disclosures in permission-matrix tests.
D:Syntactically valid IDs and a logged-in session do not establish ownership of a resource; check the requested resource against the authenticated tenant and role at the data service rather than trusting user-provided identifiers; that control is assessed by denial of cross-tenant identifier enumeration attempts in direct tool tests; the incident instead requires zero cross-user CRM record disclosures in permission-matrix tests.
Question 617
A policy-modernization initiative combines scanning, extraction, contradiction detection, and drafting in one long prompt. Which option addresses the immediate design need?
- Checkpoint long-running work for replay and recovery
- Divide work along independently verifiable artifacts
- Partition research by source and reconcile conflicts explicitly
- Parallelize only truly independent branches
Explanation
Correct Answer
B:Separate stages with typed artifacts allow validation and targeted reruns at meaningful boundaries; a traceable artifact boundary confines error analysis to the failed operation; evaluate the design with stage-specific defect localization and repair without redoing previously validated stages.
Incorrect Answers
A:Durable checkpoints record validated intermediate artifacts and resume at safe boundaries with idempotent side effects; checkpointing reduces replay cost but cannot correct a defective classification rubric; this alternative would measure successful recovery after injected worker failures without duplicated writes or stages; it does not establish stage-specific defect localization and repair without redoing previously validated stages for the described use case.
C:Analyze source partitions separately, retain provenance, and reconcile contradictions through a dedicated synthesis stage; simple partitioning can preserve conflicting claims unless the merge step includes a reconciliation rule; this alternative would measure conflict detection recall and citation coverage across independently processed source sets; it does not establish stage-specific defect localization and repair without redoing previously validated stages for the described use case.
D:Isolate independent tasks, retain separate results, then join only when required dependencies have completed; parallelizing dependent mutations without isolation can increase errors even if raw processing is faster; this alternative would measure correct merged clause counts across repeated parallel execution races; it does not establish stage-specific defect localization and repair without redoing previously validated stages for the described use case.
Question 618
A service assistant declares a user ineligible after a payment-API timeout is returned as an empty record. Which design decision directly addresses this constraint?
- Verify whether claims are supported by supplied sources
- Test for model capability mismatch on complex reasoning
- Trace malformed outputs to prompt or schema boundaries
- Separate external tool faults from model decisions
Explanation
Correct Answer
D:Propagate typed tool errors, retries, and unknown states instead of converting transport failures into negative facts; fault injection distinguishes tool availability from genuine absence of data; evaluate the design with correct 'unknown' handling and no false denials during injected API failures.
Incorrect Answers
A:Compare material claims against cited evidence and flag unsupported statements for abstention or review; a well-formatted citation is not proof that the cited text supports a particular assertion; this alternative would measure supported-claim rate on source-checked summaries with seeded unsupported numbers; it does not establish correct 'unknown' handling and no false denials during injected API failures for the described use case.
B:Hold evidence constant and compare validated model capabilities or staged reasoning designs on the failed complexity class; rebuilding retrieval is unlikely to help when required evidence was already consistently supplied; this alternative would measure correct conflict resolution with fixed retrieved evidence across candidate reasoning configurations; it does not establish correct 'unknown' handling and no false denials during injected API failures for the described use case.
C:Inspect instruction clarity, output-schema validation, and edge-case examples before assuming a core model reasoning failure; switching to a more expensive model may leave the consumer's missing validation problem intact; this alternative would measure schema error rate across multiline, null, and unusual-field edge cases; it does not establish correct 'unknown' handling and no false denials during injected API failures for the described use case.
Question 619
A fulfillment connector consumes Claude-produced objects and rejects out-of-contract values. The test suite includes missing fields, extra prose, and unexpected status codes. Which acceptance measure most directly validates output control?
- Prompt-injection resistance on hostile retrieved snippets without loss of legitimate source use
- Valid schema rate and zero unauthorized enum values reaching the consumer
- Out-of-scope refusal and handoff accuracy on a policy-boundary test set
- Secret-exposure rate under seeded credential-bearing diagnostic inputs
Explanation
Correct Answer
B:Parser-level rejection tests verify the actual interface boundary; measure valid schema rate and zero unauthorized enum values reaching the consumer at the release gate; request a documented structured format and validate schema, allowed values, and business semantics before downstream use.
Incorrect Answers
A:Adversarial retrieval tests exercise the trust boundary rather than only neutral documents; clearly separate lower-trust source material from application instructions and enforce permissions at the tool layer as well; this tests prompt-injection resistance on hostile retrieved snippets without loss of legitimate source use; the actual release condition is valid schema rate and zero unauthorized enum values reaching the consumer.
C:Boundary tests demonstrate task scoping rather than only fluent responses on ordinary requests; define the assistant's permitted tasks, out-of-scope handling, and escalation behavior in stable application-level instructions, backed by independent access enforcement; this tests out-of-scope refusal and handoff accuracy on a policy-boundary test set; the actual release condition is valid schema rate and zero unauthorized enum values reaching the consumer.
D:Seeded canaries allow a measurable check of unwanted disclosure paths; redact sensitive fields upstream, prohibit secret reproduction in instructions, and screen outbound content before release; this tests secret-exposure rate under seeded credential-bearing diagnostic inputs; the actual release condition is valid schema rate and zero unauthorized enum values reaching the consumer.
Question 620
Operators discover that summaries are being treated as final eligibility determinations without authorized review. How should the design be corrected?
- Define which decisions remain with people
- Quantify the current manual task before choosing automation
- Prioritize a repetitive step with bounded exceptions
- Map available data and its permitted uses before solution selection
Explanation
Correct Answer
A:Explicit decision-rights boundaries distinguish advisory generation from actions requiring a credentialed human or deterministic policy engine; an auditable decision trail demonstrates that AI outputs remained advisory where policy requires it; verify the repair using share of binding decisions showing the required named approver and rationale.
Incorrect Answers
B:Process measurement establishes value, not the identity, data-permission, or runtime architecture of a Claude application; a baseline separates real business improvement from attractive demos; use completed cases, reviewer effort, errors, and exception handling as measurable comparators; that control is assessed by change in verified minutes and rework per adjudicated claim versus the documented baseline; the incident instead requires share of binding decisions showing the required named approver and rationale.
C:Prioritization improves initial return and feasibility; it does not directly supply output-validation code or tenant isolation; select a high-frequency, well-described task with measurable work reduction and explicit escalation for ambiguous records; that control is assessed by accepted cases per reviewer-hour with exception share tracked separately; the incident instead requires share of binding decisions showing the required named approver and rationale.
D:A data inventory does not alone identify target SLOs or decide whether an orchestration loop is necessary; data-readiness and usage-rights mapping identifies legitimate inputs, owners, quality gaps, and prohibited transfers before committing to an implementation; that control is assessed by percentage of required fields with validated owners, quality checks, and approved processing purposes; the incident instead requires share of binding decisions showing the required named approver and rationale.