Your team is preparing a new Claude application for production, and the product team has asked for a cost projection. The team needs to estimate the cost based on expected request volume, average input length, and average output length. How would you build the projection?

• A. Build a cost model that combines expected request volume and average input tokens, treating output tokens as a small enough share of cost to leave out of the projection.
• B. Build a cost model that combines expected request volume, average input tokens, average output tokens, the chosen model's pricing, and any caching benefits.
• C. Build a cost model based on expected request volume and the chosen model's pricing, treating average input and output token counts as variables to be estimated post-launch.
• D. Build a cost model that uses the average per-request cost from a similar Claude application the team built last year, scaling that figure by expected request volume.

You are implementing a custom tool for your Claude agent. The tool needs to interact with an external pricing service that returns product data.
Which of the following best practices would you apply as you develop this tool?

• A. Implement the tool with no error handling and let the agent loop catch failures whenever the pricing service returns an error during operation.
• B. Omit the tool description and let the model infer when to use the tool based on the tool's name and the rest of the prompt context.
• C. Define the tool with a loose schema and let the model interpret the inputs flexibly on each call the agent makes.
• D. Define the tool with a clear schema, write a precise description for when to call it, and handle pricing service errors explicitly.

You are reviewing an architectural diagram for a Claude-powered travel-booking system. The diagram shows a top-level component that interprets user requests and three subordinate components that handle flights, hotels, and ground transportation. The top-level component is responsible for routing each request, sequencing the subordinate components, and reconciling their outputs into a final itinerary. The diagram also shows that each subordinate component has its own tool list and own short conversation history that is not shared with the others.
Which architectural pattern does this diagram most closely describe?

• A. A manager and supervisor pattern with shared context, where the top-level agent and the subagents all share a single conversation history that grows as the request flows through the system.
• B. A manager and supervisor pattern with isolated context per subagent, where the top-level agent coordinates specialized subagents that each maintain their own conversation history and tool list.
• C. A retrieval-augmented pattern, where the top-level component retrieves relevant context from the subordinate components' indexed data stores before generating each response.
• D. A pipeline pattern, where each component processes the user request in sequence and passes the full conversation history along with the request to the next component in the pipeline.

Your Claude agent's hooks are currently triggered for every action, which slows down the agent significantly even when actions pose no risk. The team wants to scope hooks more carefully.
How would you scope the hooks?

• A. Replace hooks with system prompt instructions on the grounds that prompt instructions can produce the same enforcement effect that hooks produce on the agent's actions.
• B. Scope hooks to only the high-risk actions, such as destructive operations or sensitive data access, and remove hooks from low-risk actions to balance safety with performance.
• C. Disable the agent during peak hours so the hook overhead does not slow the application down during the busiest periods of the day across the application's operation.
• D. Disable all hooks while the team re-scopes them, treating the period of no hook enforcement as a temporary state during the re-scoping work.

You are integrating Claude into an application written in Python. The Claude SDK provides a Python client that wraps the underlying REST API.
How would you integrate the SDK?

• A. Use the Claude Python SDK and let it handle authentication, retries, and response parsing through its standard documented patterns for Python integrations.
• B. Skip the SDK and embed Claude calls in shell commands invoked from Python, so that the application runs the calls outside the main Python process.
• C. Call the REST API directly with raw HTTP requests so the application avoids the SDK's abstraction between the application code and the API.
• D. Use a different LLM provider's SDK and translate the responses into Claude's API shape so the application can switch providers in the future.