25 Questions — Domain 2 : Applications and Integration

Expand any question to reveal the correct answer and explanation.

1. 1 A production application encounters a 'stop_reason' of 'max_tokens' during a complex code generation task. Which integration pattern correctly implements the 'continuation' logic to ensure a complete output payload?

   Consider how the conversation history must be preserved to resume exactly where the model was cut off.

   Capture the truncated response, append it to the interaction history as an assistant message, and send a new user turn with a 'continue' instruction.

   Following a truncation, the application must maintain state by feeding the partial response back into the history before requesting the remaining tokens.

   • ✗ Increase the 'max_tokens' parameter in a recursive call using the original user message until the 'stop_reason' reaches 'end_turn'.

     Simply re-sending the original message without the context of the generated partial output would lead to a redundant or entirely different response.

   • ✗ Implement a retry logic with an exponential backoff specifically targeting the HTTP 429 rate limit error code.

     A 'max_tokens' stop reason is a model-side parameter limit, not a networking or rate-limiting infrastructure failure.

   • ✗ Switch the model tier to Claude Opus to leverage its larger default context window and higher token generation ceiling.

     Context window and generation limits are distinct; truncation can occur on any model tier if the specific request exceeds its set 'max_tokens' value.

2. 2 When developing a multi-agent system, an architect identifies a failure where subagents consistently lack the necessary data to perform tasks. What is the most likely cause within the 'subagent trap' framework?

   Think about the inheritance�or lack thereof�of message history between independent API calls.

   The coordinator agent fails to explicitly package and pass the necessary context to the subagent as isolated user input.

   Subagents do not automatically inherit the parent coordinator's context window or tool execution history.

   • ✗ The subagent's system prompt is identical to the coordinator's, causing a conflict in the alternating role sequence.

     The API allows identical system prompts across different calls; the issue is data persistence, not prompt content collision.

   • ✗ The integration layer uses different API keys for the coordinator and subagent, preventing shared memory access.

     Model 'memory' is not tied to API keys but to the specific messages array provided in the current request payload.

   • ✗ The subagent reached its rate limit due to the coordinator spawning too many parallel asynchronous execution threads.

     While rate limits are an issue, they result in infrastructure errors rather than the semantic failure of 'missing data' described.

3. 3 In the context of configuration management, a team wants to enforce coding standards that are specific to a single repository but should not affect the developer's global Claude Code settings. Where should these instructions be placed?

   Recall the distinction between personal/local configuration and team/shared configuration.

   A 'CLAUDE.md' file located in the root of the specific project repository.

   Project-level 'CLAUDE.md' files are version-controlled and shared within the team, overriding or augmenting global settings for that directory.

   • ✗ The global 'settings.json' file located in the developer's home directory ('~/.claude/').

     Global configuration applies across all repositories on the machine and is not shared via version control with other team members.

   • ✗ Hard-coded as comments within the source code files to be parsed by the model during the directory read step.

     While effective for local context, this does not utilize the standard Claude Code configuration hierarchy designed for project rules.

   • ✗ The '.claude/rules/' directory on the host machine's root filesystem.

     Rules files should be project-scoped within the repository to ensure they are portable and version-aligned with the code.

4. 4 A developer needs to process a high-volume, non-urgent document analysis task involving $100,000$ tokens. Latency is not a concern, but cost efficiency is paramount. Which Messages API feature is most appropriate?

   Look for the mechanism specifically designed for large-scale, asynchronous, and cost-reduced workloads.

   The Message Batches API for asynchronous processing within a 24-hour window.

   The Batch API offers a $50\%$ cost reduction for latency-tolerant workloads by processing them outside of real-time demand.

   • ✗ Server-Sent Events (SSE) streaming to optimize the time-to-first-token (TTFT).

     Streaming optimizes perceived latency for users but does not provide the token-level cost discounts found in batch processing.

   • ✗ Prompt caching of the primary document to reuse context across multiple synchronous calls.

     While caching reduces cost, it is less efficient than the Batch API for a single massive, non-urgent workload.

   • ✗ Implementing a parallelized thread pool using the standard Messages API to maximize throughput.

     Parallel real-time requests incur full costs and risk hitting rate limits without providing the batch discount.

5. 5 When a Claude model initiates a 'tool_use' stop reason, what is the critical responsibility of the integration layer before returning control to the model?

   Identify the step that connects the model's intent to the real-world action.

   Parse the tool parameters, execute the local code, and append a 'tool_result' block to the message history.

   The application must act as the bridge between the model's request and the actual execution of the tool logic.

   • ✗ Immediately send an 'end_turn' signal to flush the buffer and finalize the JSON structure.

     The 'tool_use' reason indicates the turn is not finished; the model is waiting for the output of the tool to continue.

   • ✗ Recalculate the token budget to account for the increased context size of the tool schema.

     While budgeting is good practice, the functional requirement is the execution and reporting of the tool's result.

   • ✗ Sanitize the model's text output to remove any mentions of the tool before the user sees it.

     The integration layer should focus on providing the requested tool data back to the model in the next turn of the interaction.

6. 6 Which programmatic control is most effective for preventing a Claude-based agent from executing unauthorized financial transactions triggered by prompt injection?

   Think about where 'enforceable' security logic must reside compared to 'suggested' behavior.

   Deterministic validation hooks in the application code that verify transaction limits and user permissions before API execution.

   Enforcement of high-stakes actions must happen in the code layer, as prompt-based instructions cannot be guaranteed $100\%$ effective against adversarial input.

   • ✗ Adding a highly descriptive 'system' instruction that strictly forbids the model from processing malicious input.

     System prompts are conversational guidelines and can be bypassed by sophisticated jailbreaking or injection techniques.

   • ✗ Lowering the 'temperature' setting to $0.0$ to ensure the model's behavior is completely predictable and less creative.

     Low temperature improves consistency but does not act as a security barrier against validly formatted but malicious instructions.

   • ✗ Using a smaller model like Claude Haiku to reduce the complexity of the reasoning and minimize potential attack surface.

     Model size is not a security control; smaller models can still be manipulated into calling available tools if not programmatically restricted.

7. 7 An application architect needs to implement a solution where Claude can access an internal SQL database. The requirement specifies that this capability must be reusable across multiple distinct Claude applications. What is the recommended approach?

   Consider the protocol designed specifically for decoupling context and tool execution for multi-app reusability.

   Build an MCP (Model Context Protocol) server that exposes the database operations as tools.

   MCP creates a standardized, reusable interface that allows multiple host applications to share the same tool logic and data resources.

   • ✗ Hard-code the database connection string and schema directly into each application's 'CLAUDE.md' file.

     This approach is not reusable, poses security risks by exposing credentials, and creates maintenance overhead across applications.

   • ✗ Develop a custom Skill that includes the SQL queries as few-shot examples for the model to follow.

     Skills provide behavioral instructions but do not provide the underlying transport or execution environment for database connectivity.

   • ✗ Use the 'tool_choice' parameter set to 'any' to force the model to generate SQL syntax in its text response.

     Forcing syntax generation does not solve the problem of actual database execution or the need for a reusable interface.

8. 8 A developer is optimizing a Claude application for speed. They notice that the TTFT (Time-to-First-Token) is high because the system prompt contains a $5,000$ line schema definition that rarely changes. What is the best optimization strategy?

   Focus on a feature that allows the model to 'remember' and skip re-processing static instructions.

   Implement prompt caching with a breakpoint after the static schema definition.

   Prompt caching allows the model to reuse the processed state of static content, significantly reducing both latency and input token costs.

   • ✗ Move the schema definition from the 'system' prompt to the first 'user' message in the array.

     Moving content between roles does not reduce the computational work needed to process the tokens on each request.

   • ✗ Compress the schema into a single-line JSON string to minimize the total character count.

     Tokenization is based on more than just character count; compression often makes it harder for the model to reason accurately.

   • ✗ Utilize SSE (Server-Sent Events) to stream the response as it is generated.

     Streaming addresses perceived latency after generation begins but does not reduce the processing time of a massive system prompt.

9. 9 When parsing a 'Messages API' response, why should an application prioritize checking 'stop_reason' over simply detecting the presence of a closing brace in a JSON string?

   Consider what happens if the model is interrupted before it finishes writing its response.

   The model might terminate early due to 'max_tokens' or 'stop_sequence', resulting in an invalid or incomplete JSON payload.

   Only the 'stop_reason' field provides an authoritative signal from the API on whether the model actually finished its intended generation.

   • ✗ Checking 'stop_reason' is computationally less expensive than string pattern matching in high-throughput environments.

     Performance differences are negligible; the priority is based on the correctness and completeness of the data.

   • ✗ The 'stop_reason' parameter automatically triggers the application's reconnection logic in the event of a websocket failure.

     Stop reasons are part of the JSON response payload and do not manage the underlying network socket state.

   • ✗ The 'Messages API' does not support structured JSON output without a 'forced-choice' tool call.

     Claude can generate structured JSON in standard text turns, but reliability requires verifying the termination state.

10. 10 In an MCP (Model Context Protocol) architecture, which component is responsible for managing user authorization and enforcing safety policies for tool execution?

    Identify the 'bridge' component that has the final say on local system access.

    The MCP Client (Host Application).

    The host application acts as the primary gatekeeper, managing credentials and ensuring the model does not execute dangerous actions without approval.

    • ✗ The MCP Server.

      The server's role is to provide the tool logic and resources, but it generally operates within the trust boundaries established by the client.

    • ✗ The Claude Model (Anthropic API).

      The model identifies the intent to use a tool, but it lacks the programmatic context of the local environment to enforce security.

    • ✗ The transport layer (stdio/SSE).

      Transports are communication channels and do not have logic for authorization or policy enforcement.

11. 11 A developer needs to implement a 'pre-commit' check in their development workflow using Claude Code. Which configuration allows for an automated script to run before any changes are finalized?

    Look for the feature designed to intercept and validate actions within the tool's execution lifecycle.

    Configuring hooks within the project-level 'CLAUDE.md' or rules directory.

    Claude Code supports programmatic hooks that allow developers to integrate external validation and automation directly into the agent's workflow.

    • ✗ Modifying the 'version_pinning' parameter in the 'settings.json' file.

      Version pinning controls which model release is used but does not support the execution of arbitrary lifecycle scripts.

    • ✗ Using a 'User' role message to instruct the model to manually run a linting command before every save.

      While possible, this is a manual prompting strategy rather than an automated, configuration-driven engineering hook.

    • ✗ Enabling 'Headless Mode' to bypass all local security checks and file permissions.

      Headless mode is for CI/CD automation and does not inherently provide pre-commit validation logic.

12. 12 What is the primary architectural trade-off when selecting 'any' for the 'tool_choice' parameter in a Claude API request?

    Consider the impact of forcing a specific behavior versus letting the model decide autonomously.

    It forces the model to invoke at least one tool but may lead to redundant calls if the task is already simple.

    The 'any' setting ensures a tool is used, which is helpful for structured workflows but removes the model's ability to provide a text-only response if a tool is unnecessary.

    • ✗ It reduces the token cost by skipping the 'thinking' block generation for that specific turn.

      Tool choice does not disable the model's reasoning capabilities; it only constrains the final output behavior.

    • ✗ It significantly increases the latency as the model must poll every available MCP server before responding.

      Latency is affected by the model's generation length and reasoning, not by a broadcast search for servers.

    • ✗ It allows the model to bypass the 'system' prompt's safety instructions to ensure the tool is executed.

      Safety guardrails and system instructions remain active regardless of the 'tool_choice' configuration.

13. 13 A developer receives a 'JSON' response from Claude that is truncated because it hit the 'context_window' limit. Which 'stop_reason' will the API report?

    Recall the specific terminology used when a hard limit halts the model's output.

    max_tokens

    The 'max_tokens' reason is triggered whenever the generation is cut off due to reaching the limit specified in the request or the model's hard ceiling.

    • ✗ end_turn

      'end_turn' indicates the model finished naturally, which is the opposite of being cut off by a limit.

    • ✗ stop_sequence

      This reason only occurs if the model generates a specific string provided by the developer to halt execution.

    • ✗ null

      The API always provides a stop reason once generation is complete or terminated.

14. 14 Which software engineering foundation is most critical for managing long-running agentic tasks where the model must perform multiple tool-use turns over an extended period?

    Focus on the concepts that handle 'non-blocking' work and 'remembering' the current progress.

    Asynchronous orchestration and state management.

    Reliable agents require the ability to handle non-blocking interactions and maintain state persistence across multiple API round-trips.

    • ✗ Static type checking and compile-time validation.

      While helpful for code quality, these do not address the runtime challenge of managing stateful, multi-turn LLM loops.

    • ✗ Monolithic architecture design.

      Agentic systems typically benefit more from decoupled, microservice-like tool designs (e.g., MCP) than monolithic structures.

    • ✗ Synchronous, blocking IO operations.

      Blocking IO is generally discouraged for long-running AI workflows as it limits scalability and responsiveness.

15. 15 When configuring Claude Code for a large engineering organization, why might an architect prefer 'project-scoped' rules over 'user-scoped' rules?

    Think about the benefits of 'Source of Truth' and team collaboration.

    Project-scoped rules allow for version-controlled, consistent standards that are shared automatically across all team members.

    Placing rules in the repository ensures that every developer using Claude Code on that project follows the same architectural and style guidelines.

    • ✗ Project-scoped rules bypass the 'token' cost associated with injecting global instructions into every request.

      Both types of rules consume tokens; the difference is in how the configuration is managed and distributed.

    • ✗ User-scoped rules are inherently more secure as they are stored on the developer's encrypted local drive.

      Security is based on the contents and handling of the rules, not just their file system location.

    • ✗ Claude Code does not support the execution of custom slash commands if they are defined at the project level.

      Claude Code explicitly supports both project-level and user-level custom commands.

16. 16 In the Messages API, which content block type is used to provide the results of a function call back to the model after a 'tool_use' request?

    Identify the block name that matches the outcome of an executed tool.

    tool_result

    The 'tool_result' block is a specific API structure designed to carry the output (success or error) of a tool execution back to the model's context.

    • ✗ text

      While the result may contain text, it must be wrapped in a 'tool_result' block so the model can associate it with the correct tool call ID.

    • ✗ assistant_output

      This is not a valid API block type; the roles are 'user' and 'assistant', and blocks are 'text', 'image', 'tool_use', etc.

    • ✗ system_feedback

      Results of tools are sent as 'user' role messages containing a 'tool_result' block, not as system-level feedback.

17. 17 A developer wants to use 'Claude Code' in a headless mode for a CI/CD pipeline. Which of the following is a known limitation or requirement of this operational mode?

    Think about what an automated server environment lacks compared to a human terminal session.

    It requires explicit environment variables and non-interactive authentication to avoid hanging the build pipeline.

    Headless automation cannot handle interactive 'Turing' tests or password prompts and must be configured for silent, automated execution.

    • ✗ It can only execute 'read-only' commands and cannot modify the filesystem or commit code.

      Headless mode is fully capable of code modification and git operations if permitted by the environment's security settings.

    • ✗ It requires a physical GPU on the CI/CD runner to process the model's visual reasoning chunks.

      Claude Code is a CLI tool that interacts with a hosted API; local GPU resources are not required for model execution.

    • ✗ It only supports Claude Haiku to minimize the impact on CI/CD build duration.

      Headless mode can use any supported model tier as specified in the configuration.

18. 18 When designing an MCP (Model Context Protocol) server, why is it recommended to return 'structured error envelopes' instead of raw stack traces?

    Consider how the model uses tool output to decide its next conversational turn.

    Structured errors allow the model to reason about the failure (e.g., 'permission denied') and potentially suggest a corrective action to the user.

    Raw stack traces are often confusing for LLMs; clear, semantic error categories enable the model to handle the failure intelligently.

    • ✗ Stack traces contain too many tokens and will quickly bloat the context window and increase API costs.

      While true, the primary benefit is the model's ability to interpret the error rather than just the token count reduction.

    • ✗ The Anthropic API will automatically terminate the session if it detects a standard Python or Node.js error pattern.

      The API does not monitor tool output for specific code-level error patterns; it treats all tool output as text context.

    • ✗ MCP servers do not support text-based error reporting and must use binary status codes.

      MCP supports flexible JSON-based communication, and clear text descriptions are highly encouraged for model interaction.

19. 19 An architect is concerned about 'context drift' in a long-running customer support agent. Which technique most effectively prevents the model from being overwhelmed by stale interaction history?

    Focus on the process of 'compaction' or 'distillation' of history.

    Implementing programmatic context isolation and summarizing past turns into a condensed 'state' block.

    By periodically summarizing history and pruning unnecessary tool outputs, the application keeps the most relevant information within the model's focus.

    • ✗ Increasing the frequency of API calls to ensure the model 'refreshes' its internal weights more often.

      API calls do not update model weights; they only consume tokens and provide the history contained in the message array.

    • ✗ Switching from a multi-agent hierarchy to a single, monolithic prompt to ensure all data is always available.

      A monolithic approach actually increases the risk of drift and bloat compared to a well-orchestrated, segmented system.

    • ✗ Setting 'temperature' to its maximum value to encourage the model to ignore older parts of the conversation.

      High temperature increases randomness but does not provide any logical mechanism for context management or prioritization.

20. 20 A developer needs to ensure that their Claude-powered application is resilient to 'breaking behavior changes' when Anthropic releases a new version of the Sonnet model. What is the standard practice?

    Identify the configuration setting that specifically targets 'immutable' identifiers.

    Pinning the application to a specific, immutable model version (e.g., 'claude-3-5-sonnet-20240620') instead of using the generic 'claude-3-5-sonnet' alias.

    Version pinning prevents automatic updates from changing the model's behavior, allowing for controlled testing and migration on the developer's timeline.

    • ✗ Setting a strict 'stop_sequence' that triggers a manual review whenever the model's output deviates from a baseline regex.

      Stop sequences halt generation but do not provide a mechanism for managing model updates or versioning.

    • ✗ Relying on the 'system' prompt to explicitly instruct the model to only use features from a previous model generation.

      Models cannot 'downgrade' their own capabilities or internal logic based on a prompt instruction.

    • ✗ Implementing a dynamic router that switches models based on the current API latency.

      Latency-based routing does not address the risk of semantic or functional changes in model behavior across versions.

21. 21 Which field in the Messages API response should a developer parse to determine if the model successfully performed a multi-modal analysis of a PDF file?

    Consider where the actual 'intelligence' or 'answer' from the model is delivered.

    The 'content' array of the assistant's message, specifically looking for text blocks containing the extracted PDF information.

    Claude's analysis results are returned as standard text content blocks after the model has processed the visual or textual data from the file.

    • ✗ A specialized 'pdf_metadata' object in the top-level API response header.

      The API does not return separate PDF metadata objects; the model's insights are part of its generated message content.

    • ✗ The 'stop_reason' field, which will explicitly state 'file_extraction_complete'.

      Stop reasons are generic (end_turn, tool_use, etc.) and do not describe the specific nature of the successful task.

    • ✗ The 'usage' block, which lists the number of 'image_tokens' consumed by the PDF's visual elements.

      The usage block confirms consumption and cost but does not validate the semantic success of the analysis itself.

22. 22 In a scenario where Claude must interact with a sensitive banking API, why is 'programmatic' validation of tool arguments considered superior to 'prompt-based' validation?

    Think about 'deterministic' vs. 'probabilistic' outcomes in security-critical code.

    Generative models can occasionally hallucinate parameters or bypass instructions, whereas application code provides a deterministic and enforceable security gate.

    Code-level validation is not susceptible to the same 'jailbreaking' or 'drift' issues as natural language instructions.

    • ✗ Programmatic validation reduces the token count of the request by $20-30\%$.

      Token savings are minimal; the primary driver for programmatic validation is security and reliability, not cost.

    • ✗ The Messages API will automatically block any request that contains the word 'password' or 'account_number' in a tool schema.

      The API does not perform word-level blacklisting of schemas; security is the responsibility of the developer.

    • ✗ Prompt-based validation requires a specialized license for Claude Opus.

      All model tiers support prompt-based instructions, but all are equally vulnerable to the same fundamental reliability issues.

23. 23 A developer is using 'Claude Code' and wants to set up a custom slash command for the whole team. Where should the command definition file be stored?

    Consider the location that supports version control and team-wide availability.

    In the '.claude/commands/' directory within the project's root folder.

    Storing commands in the project directory allows them to be shared via version control, ensuring consistency across the engineering team.

    • ✗ In the '~/.claude/commands/' directory on each developer's individual machine.

      Home directory storage is personal and does not facilitate automatic sharing or consistency across a team's repositories.

    • ✗ As an entry in the 'plugins' array of the global 'settings.json' file.

      Slash commands are generally configured via markdown files in specific directories rather than as entries in a JSON plugin array.

    • ✗ Directly within the 'CLAUDE.md' file under a specific '# Slash Commands' heading.

      While 'CLAUDE.md' can describe commands, the actual executable definitions for Claude Code live in the dedicated commands folder.

24. 24 What is the primary function of the 'system' parameter in a Messages API request compared to 'user' messages?

    Identify the top-level 'instruction layer' that sets the stage for the conversation.

    It establishes the foundational rules, persona, and operational boundaries that guide the model's behavior throughout the interaction.

    The system prompt is isolated from user input to provide a more robust, top-level set of instructions that are harder for the model to 'forget' or override.

    • ✗ It provides a secondary channel for the model to send private debugging information to the application logs.

      The 'system' parameter is for input instructions, not for model-to-app private logging channels.

    • ✗ It is used exclusively for providing few-shot examples to avoid cluttering the conversational history.

      Few-shot examples can be in the system prompt or user messages; the primary purpose is persona and boundary setting.

    • ✗ It acts as a high-speed cache for large PDF files and image assets.

      Caching is a separate feature; the system prompt is for text-based instructions and context.

25. 25 A developer needs to implement a 'defensive parsing' strategy for Claude's output. Which of the following best describes this technique?

    Think about 'robustness' when dealing with slightly unpredictable data structures.

    Designing application logic that anticipates and handles common formatting errors, missing JSON keys, or unexpected text in model responses.

    Defensive parsing acknowledges that generative models are probabilistic and may occasionally produce malformed output, requiring robust error handling in the integration layer.

    • ✗ Using a separate, smaller model to scan every Claude response for potential prompt injection attempts.

      This is an output moderation or security check, not a data parsing or consumption strategy.

    • ✗ Forcing the model to only output binary data to bypass the need for natural language processing.

      Claude is a language model and does not natively output binary data; it is optimized for text and structured formats like JSON.

    • ✗ Automatically retrying every API request three times if any non-ASCII character is detected in the payload.

      Blind retries based on character encoding are not a strategic parsing approach and would be highly inefficient.