Question 290
A release plan for a Claude application platform has two acceptance checks: component one must detect unsafe permissions and schema changes before merging an agent tool; component two must verify that a real staging tool and its API contract work together. Which proposal passes both?
- First component: Enforce concurrency limits. Second component: Separate integration tests from unit tests.
- First component: Use feature flags for risky behavior changes. Second component: Enforce concurrency limits.
- First component: Use pull requests and focused code review. Second component: Separate integration tests from unit tests.
- First component: Use pull requests and focused code review. Second component: Use feature flags for risky behavior changes.
Explanation
Correct Answer
C:The first proposal fits its assigned role because peer review creates an explicit checkpoint for correctness, security, and maintainability, while the second proposal fits its assigned role because integration tests exercise boundaries and serialization that isolated mocks may miss; their respective acceptance criteria are to detect unsafe permissions and schema changes before merging an agent tool and to verify that a real staging tool and its API contract work together.
Incorrect Answers
A:The first proposal serves the different purpose to prevent bursts of document jobs from overwhelming rate limits and memory instead of the assigned first role because a semaphore or bounded queue keeps in-flight work within measured capacity, while the second proposal fits its assigned role because integration tests exercise boundaries and serialization that isolated mocks may miss; their respective acceptance criteria are to detect unsafe permissions and schema changes before merging an agent tool and to verify that a real staging tool and its API contract work together.
B:The first proposal serves the different purpose to activate a new tool execution path for only internal testers instead of the assigned first role because runtime controls can segment rollout and permit quick disabling without a code rebuild, while the second proposal serves the different purpose to prevent bursts of document jobs from overwhelming rate limits and memory instead of the assigned second role because a semaphore or bounded queue keeps in-flight work within measured capacity; their respective acceptance criteria are to detect unsafe permissions and schema changes before merging an agent tool and to verify that a real staging tool and its API contract work together.
D:The first proposal fits its assigned role because peer review creates an explicit checkpoint for correctness, security, and maintainability, while the second proposal serves the different purpose to activate a new tool execution path for only internal testers instead of the assigned second role because runtime controls can segment rollout and permit quick disabling without a code rebuild; their respective acceptance criteria are to detect unsafe permissions and schema changes before merging an agent tool and to verify that a real staging tool and its API contract work together.
Question 291
A production-readiness check for an MCP interoperability component requires the service to delegate a security analysis while keeping the main coordinator's context concise. Which approach passes this check?
- Choose a built-in provider tool
- Use hooks for enforceable safety checks
- Use subagents for independent expertise
- Use system or repository instructions for stable behavior
Explanation
Correct Answer
C:Specialist contexts reduce tool-output contamination and support focused parallel work; this behavior directly supports the need to delegate a security analysis while keeping the main coordinator's context concise. A reusable Skill alone does not create an independent worker with separate state.
Incorrect Answers
A:This approach serves the separate need to use an already supported capability without hosting a duplicate custom service because provider-managed execution can reduce implementation work when its scope matches the requirement; it does not establish the outcome to delegate a security analysis while keeping the main coordinator's context concise, and built-in tools may not expose a proprietary enterprise data source.
B:Runtime interception can apply deterministic policies to proposed actions; despite being useful when a service must deny destructive filesystem operations before a coding agent executes them, it is not a solution to delegate a security analysis while keeping the main coordinator's context concise; a skill that asks for caution does not guarantee prevention.
D:Instructions shape model behavior and task framing without executing external operations; this applies to the different goal to make a coding or API assistant follow organization-wide conventions, not the requirement to delegate a security analysis while keeping the main coordinator's context concise; descriptive rules do not replace programmatic validation or IAM.
Question 292
A data pipeline review requires two independent, explicitly defined outcomes: the first workstream must test application logic without issuing real model calls or payments; a second must allow older application clients to keep working while a new extraction field is introduced. Which TWO actions directly provide these capabilities? Choose TWO.
- Use asynchronous I/O for concurrent requests
- Pin dependencies with lockfiles
- Apply dependency injection for external clients
- Version APIs and response schemas
- Refactor duplicated request orchestration
Explanation
Correct Answers
C:Injected interfaces allow deterministic stubs and reduce coupling to vendors; this directly supports task 1 to test application logic without issuing real model calls or payments, not the separate task or tasks to allow older application clients to keep working while a new extraction field is introduced; hard-coded global clients make behavior harder to isolate and simulate.
D:Compatibility-aware contracts and versioned behavior protect consumers from surprise breaking changes; this directly supports task 2 to allow older application clients to keep working while a new extraction field is introduced, not the separate task or tasks to test application logic without issuing real model calls or payments; silently removing required fields can fail deployments that were not upgraded.
Incorrect Answers
A:Async execution overlaps I/O-bound tasks while maintaining control over concurrency; this implements the different outcome to serve independent API calls without blocking a worker thread for each network wait rather than the required tasks to allow older application clients to keep working while a new extraction field is introduced and to test application logic without issuing real model calls or payments, and it does not by itself make CPU-bound model processing faster, so it is not a direct solution to any of the assigned workstreams.
B:Locked versions and hashes constrain drift between build environments; this implements the different outcome to reproduce a working SDK installation across staging and production rather than the required tasks to allow older application clients to keep working while a new extraction field is introduced and to test application logic without issuing real model calls or payments, and unbounded package updates can introduce new behavior during a routine rebuild, so it is not a direct solution to any of the assigned workstreams.
E:A shared, tested client layer centralizes cross-cutting concerns and reduces inconsistent fixes; this implements the different outcome to maintain multiple Claude entry points without drifting retry and logging behavior rather than the required tasks to allow older application clients to keep working while a new extraction field is introduced and to test application logic without issuing real model calls or payments, and copying the same networking code into every route magnifies defects, so it is not a direct solution to any of the assigned workstreams.
Question 293
During acceptance testing for an application security service, one requirement is to deny access to a different customer's records even when the caller is authenticated. What should the developer implement?
- Protect secrets in error traces
- Audit sensitive credential use
- Authorize by requested resource and action
- Load keys from a managed secret service
- Separate human and service identities
Explanation
Correct Answer
C:Authorization checks must evaluate scope for each operation, not only whether a login exists; this behavior directly supports the need to deny access to a different customer's records even when the caller is authenticated. Successful authentication is not equivalent to unrestricted data access.
Incorrect Answers
A:Redaction at logging boundaries avoids accidentally copying credentials to broad observability systems; despite being useful when a service must prevent stack traces and debugging telemetry from disclosing tokens, it is not a solution to deny access to a different customer's records even when the caller is authenticated; encrypted storage does not help when secrets are printed into logs.
B:For the alternate objective to detect unexpected API key activity from an unfamiliar process, usage and access logs support incident investigation and anomaly response; the feature here must deny access to a different customer's records even when the caller is authenticated, and a successful API call alone does not establish that use was authorized.
D:When an application needs to avoid committing provider credentials inside a shared repository, secrets managers support controlled retrieval, rotation, and access logs; the current capability must instead deny access to a different customer's records even when the caller is authenticated, while obscuring a literal string in source is not adequate key protection.
E:Distinct principals simplify least privilege, revocation, and audit attribution; the supported outcome is to attribute tool actions to the right workload rather than a developer's personal account, whereas this scenario requires the ability to deny access to a different customer's records even when the caller is authenticated; a shared personal login makes operational accountability difficult.
Question 294
Two features of a retrieval pipeline system are under review. One feature must preserve auditability when an extractor reformats a date or currency; the other must reject a response that omits a mandated account identifier. Which plan matches the respective needs?
- First component: Parse JSON with a real parser. Second component: Handle refusal and empty content explicitly.
- First component: Handle refusal and empty content explicitly. Second component: Validate required schema fields.
- First component: Keep raw and normalized values distinct. Second component: Parse JSON with a real parser.
- First component: Keep raw and normalized values distinct. Second component: Validate required schema fields.
Explanation
Correct Answer
D:The first proposal fits its assigned role because storing the original evidence and validated normalized value supports later reconciliation, while the second proposal fits its assigned role because schema checks enforce field presence, types, and enumerations before the result enters a database; their respective acceptance criteria are to preserve auditability when an extractor reformats a date or currency and to reject a response that omits a mandated account identifier.
Incorrect Answers
A:The first proposal serves the different purpose to avoid accepting malformed generated objects because they resemble JSON to a reader instead of the assigned first role because syntax validation converts serialized text into a trustworthy data structure only after parsing succeeds, while the second proposal serves the different purpose to prevent a parser crash when the model returns no ordinary text instead of the assigned second role because response handling must branch on stop reason and content block types before decoding data; their respective acceptance criteria are to preserve auditability when an extractor reformats a date or currency and to reject a response that omits a mandated account identifier.
B:The first proposal serves the different purpose to prevent a parser crash when the model returns no ordinary text instead of the assigned first role because response handling must branch on stop reason and content block types before decoding data, while the second proposal fits its assigned role because schema checks enforce field presence, types, and enumerations before the result enters a database; their respective acceptance criteria are to preserve auditability when an extractor reformats a date or currency and to reject a response that omits a mandated account identifier.
C:The first proposal fits its assigned role because storing the original evidence and validated normalized value supports later reconciliation, while the second proposal serves the different purpose to avoid accepting malformed generated objects because they resemble JSON to a reader instead of the assigned second role because syntax validation converts serialized text into a trustworthy data structure only after parsing succeeds; their respective acceptance criteria are to preserve auditability when an extractor reformats a date or currency and to reject a response that omits a mandated account identifier.
Question 295
A technical lead requests a solution that can uncover prompt-injection paths through retrieved webpages and connected tools within a document processing project. Which design should be chosen?
- Perform a threat review before go-live
- Set a maintenance and deprecation plan
- Separate development, staging, and production environments
- Implement automated regression tests
Explanation
Correct Answer
A:Reviewing trust boundaries and permissions before deployment reveals attack routes unit tests may miss; this behavior directly supports the need to uncover prompt-injection paths through retrieved webpages and connected tools. A post-incident review cannot prevent the initial exposure.
Incorrect Answers
B:A dependency inventory and upgrade schedule create time for evaluation and migration; this applies to the different goal to keep an integration functional when a pinned model version approaches retirement, not the requirement to uncover prompt-injection paths through retrieved webpages and connected tools; indefinite reliance on a model identifier can become an outage risk.
C:When an application needs to exercise an agent's database tool without touching live customer records, environment boundaries keep credentials, data, and writes isolated during testing; the current capability must instead uncover prompt-injection paths through retrieved webpages and connected tools, while reusing production tokens in a local experiment defeats the separation.
D:Repeatable cases compare changes against documented acceptance criteria; the supported outcome is to catch schema and policy failures after a model or tool update, whereas this scenario requires the ability to uncover prompt-injection paths through retrieved webpages and connected tools; a single successful demonstration provides little protection against regressions.
Question 296
Engineers are splitting a document processing service into two independently tested functions. Function A must prevent bursts of document jobs from overwhelming rate limits and memory, while function B must prevent API credentials from being exposed through shared repository history. Which plan is sound?
- First component: Enforce concurrency limits. Second component: Keep secrets out of source control.
- First component: Validate webhook signatures. Second component: Use explicit HTTP method semantics.
- First component: Use explicit HTTP method semantics. Second component: Keep secrets out of source control.
- First component: Enforce concurrency limits. Second component: Validate webhook signatures.
Explanation
Correct Answer
A:The first proposal fits its assigned role because a semaphore or bounded queue keeps in-flight work within measured capacity, while the second proposal fits its assigned role because secret stores or environment injection keep production tokens out of committed code; their respective acceptance criteria are to prevent bursts of document jobs from overwhelming rate limits and memory and to prevent API credentials from being exposed through shared repository history.
Incorrect Answers
B:The first proposal serves the different purpose to reject forged callbacks from an external asynchronous job service instead of the assigned first role because cryptographic verification checks the sender and payload integrity before processing the event, while the second proposal serves the different purpose to prevent a supposedly read-only status lookup from changing a server-side record instead of the assigned second role because gET should retrieve resources while state changes use appropriate mutation methods and authorization checks; their respective acceptance criteria are to prevent bursts of document jobs from overwhelming rate limits and memory and to prevent API credentials from being exposed through shared repository history.
C:The first proposal serves the different purpose to prevent a supposedly read-only status lookup from changing a server-side record instead of the assigned first role because gET should retrieve resources while state changes use appropriate mutation methods and authorization checks, while the second proposal fits its assigned role because secret stores or environment injection keep production tokens out of committed code; their respective acceptance criteria are to prevent bursts of document jobs from overwhelming rate limits and memory and to prevent API credentials from being exposed through shared repository history.
D:The first proposal fits its assigned role because a semaphore or bounded queue keeps in-flight work within measured capacity, while the second proposal serves the different purpose to reject forged callbacks from an external asynchronous job service instead of the assigned second role because cryptographic verification checks the sender and payload integrity before processing the event; their respective acceptance criteria are to prevent bursts of document jobs from overwhelming rate limits and memory and to prevent API credentials from being exposed through shared repository history.
Question 297
A technical lead requests a solution that can control average spend while retaining quality on exceptional requests within a model platform project. Which design should be chosen?
- Run task-specific model evaluations
- Prefer a Sonnet-class model for balanced workloads
- Prefer a Haiku-class model for lightweight routing
- Route hard cases to a stronger fallback
Explanation
Correct Answer
D:A tiered policy starts with a cheaper path and escalates on measurable uncertainty or validation failure; this behavior directly supports the need to control average spend while retaining quality on exceptional requests. Fixed use of the most costly model discards easy-case savings.
Incorrect Answers
A:This approach serves the separate need to choose between releases using an actual organization's error and latency measurements because representative tests expose differences hidden by generic capability labels; it does not establish the outcome to control average spend while retaining quality on exceptional requests, and marketing tier names cannot replace measured fit for purpose.
B:The balanced tier often offers a practical quality-throughput compromise, subject to task-level testing; despite being useful when a service must serve a mixed coding and support assistant at moderate latency and cost, it is not a solution to control average spend while retaining quality on exceptional requests; it should not be assumed to dominate every model on every benchmark.
C:For the alternate objective to classify many short messages where low latency and unit cost dominate, the lighter tier suits inexpensive, high-throughput tasks with modest reasoning demand; the feature here must control average spend while retaining quality on exceptional requests, and complex planning may need escalation after an evaluated failure.
Question 298
A design review identifies a missing capability in a Claude application project: it must serve independent API calls without blocking a worker thread for each network wait. Which change meets that goal?
- Use asynchronous I/O for concurrent requests
- Apply dependency injection for external clients
- Pin dependencies with lockfiles
- Version APIs and response schemas
- Use pull requests and focused code review
Explanation
Correct Answer
A:Async execution overlaps I/O-bound tasks while maintaining control over concurrency; this behavior directly supports the need to serve independent API calls without blocking a worker thread for each network wait. It does not by itself make CPU-bound model processing faster.
Incorrect Answers
B:For the alternate objective to test application logic without issuing real model calls or payments, injected interfaces allow deterministic stubs and reduce coupling to vendors; the feature here must serve independent API calls without blocking a worker thread for each network wait, and hard-coded global clients make behavior harder to isolate and simulate.
C:Locked versions and hashes constrain drift between build environments; this applies to the different goal to reproduce a working SDK installation across staging and production, not the requirement to serve independent API calls without blocking a worker thread for each network wait; unbounded package updates can introduce new behavior during a routine rebuild.
D:When an application needs to allow older application clients to keep working while a new extraction field is introduced, compatibility-aware contracts and versioned behavior protect consumers from surprise breaking changes; the current capability must instead serve independent API calls without blocking a worker thread for each network wait, while silently removing required fields can fail deployments that were not upgraded.
E:Peer review creates an explicit checkpoint for correctness, security, and maintainability; the supported outcome is to detect unsafe permissions and schema changes before merging an agent tool, whereas this scenario requires the ability to serve independent API calls without blocking a worker thread for each network wait; running a linter alone cannot assess authorization intent.
Question 299
An engineer extending a language-model integration workflow has been asked to call the Messages endpoint from a language without a mature provider SDK. Which choice addresses the request most precisely?
- Choose SSE for one-way streamed responses
- Use the Messages count_tokens capability
- Use direct HTTP REST integration for unsupported runtimes
- Send the correct API authentication header
Explanation
Correct Answer
C:A standards-based HTTP client can send JSON requests with the correct headers and decode responses; this behavior directly supports the need to call the Messages endpoint from a language without a mature provider SDK. A wrapper package is optional, not the underlying API transport.
Incorrect Answers
A:When an application needs to deliver tokens to a browser without maintaining a bidirectional command channel, server-sent events provide ordered server-to-client updates over an HTTP stream; the current capability must instead call the Messages endpoint from a language without a mature provider SDK, while a WebSocket is not required solely to push a response as it arrives.
B:Token counting helps check input budgets before generation and cost planning; the supported outcome is to estimate model-token input demand before launching a large processing job, whereas this scenario requires the ability to call the Messages endpoint from a language without a mature provider SDK; word or byte count is not a reliable substitute across diverse content.
D:The API validates the provided credential before accepting a request; despite being useful when a service must avoid unauthenticated model requests from a backend worker, it is not a solution to call the Messages endpoint from a language without a mature provider SDK; embedding a secret in a user prompt does not authenticate an HTTP call.
Question 300
The current design of a Claude Code repository pipeline does not adequately apply specialised rules only to a sensitive infrastructure folder. Which improvement resolves the gap?
- Use a project-level CLAUDE.md file
- Use headless invocation for automation
- Connect an MCP server to Claude Code
- Use directory-scoped instructions
Explanation
Correct Answer
D:More local instruction files help scope guidance to the appropriate subtree; this behavior directly supports the need to apply specialised rules only to a sensitive infrastructure folder. Root guidance alone can be too broad when different modules have conflicting conventions.
Incorrect Answers
A:A checked-in memory file supplies persistent project context across relevant coding sessions; the supported outcome is to share coding conventions with every collaborator entering the same repository, whereas this scenario requires the ability to apply specialised rules only to a sensitive infrastructure folder; a personal user-level instruction file does not automatically impose a shared team standard.
B:This approach serves the separate need to run Claude Code inside a CI job and capture its output without interactive prompts because noninteractive execution lets scripts integrate agent work into existing pipelines with controlled formats; it does not establish the outcome to apply specialised rules only to a sensitive infrastructure folder, and treating interactive terminal output as a stable machine interface is fragile.
C:An MCP integration declares external capabilities and their transport while access remains controlled by the server; despite being useful when a service must expose approved project-specific actions without copying credentials into prompts, it is not a solution to apply specialised rules only to a sensitive infrastructure folder; a server connection does not automatically make every operation safe or authorized.