Your application uses the Messages API to handle multi-turn conversations. Each new turn resends the entire conversation history, and your token costs are growing as conversations get longer. You suspect there is a more efficient approach.
How would you address this?

• A. Summarize each conversation after every turn and replace the full history with the summary on the next request, reducing token count at the cost of fidelity.
• B. Truncate every conversation to the last two messages so that token usage stays low and costs remain predictable across the application's normal operation.
• C. Switch to the Batch API for every turn so the per-call cost is reduced, treating the batch as the team's primary cost-control mechanism for multi-turn work.
• D. Use prompt caching to reuse the static portions of the conversation context across turns instead of paying for them at the normal input-token rate on every request the application sends.

Your Claude application produces good responses for typical inputs but struggles with edge cases. You have several labeled examples of edge-case inputs and the desired response for each. You want to use these examples to improve the model's handling of edge cases.
What is the best way to use these examples?

• A. Add the labeled edge-case examples to the prompt as few-shot examples so the model can learn the pattern.
• B. Tell users to avoid submitting the edge-case inputs to the application by adding warnings in the application's user interface.
• C. Embed the examples in a database for the model to find during inference.
• D. Train a custom model on the edge-case examples and deploy that custom model in place of the team's current Claude integration.

You are designing a Claude application that will require structured JSON output for downstream processing.
The output schema is well-defined, and downstream systems will reject malformed JSON.

• A. Define a clear schema and structure the prompt to request output in that schema, with downstream systems handling any validation needed.
• B. Structure the prompt to request output in a schema that is described in plain English, with downstream systems parsing whatever shape Claude produces.
• C. Avoid structured output and use free-form text everywhere instead, on the grounds that free-form text is more flexible and handles edge cases better than structured schemas.
• D. Define a clear schema, structure the prompt to request output in that schema, and validate Claude's output against the schema before passing it downstream.

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. 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.
• C. 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.
• D. Call the REST API directly with raw HTTP requests so the application avoids the SDK's abstraction between the application code and the API.

Your team's Claude agent has accumulated several customizations that bypass the SDK's defaults, including custom history management, retry logic, and error handling. A new team member has proposed reverting all the customizations to maintain the codebase more easily. The tech lead disagrees and says each customization was added for a reason.
How would you advise the team?

• A. Decide on each customization individually based on its original reason and the SDK's current capabilities.
• B. Revert all customizations to the SDK's defaults to standardize the codebase.
• C. Migrate the agent off the SDK and rebuild it with a custom loop.
• D. Keep all customizations, trusting that the tech lead's original reasoning is still valid.