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. Train a custom model on the edge-case examples and deploy that custom model in place of the team's current Claude integration.
• 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. Add the labeled edge-case examples to the prompt as few-shot examples so the model can learn the pattern.

Your Claude application's outputs are inconsistent in format. The team's instructions are scattered across the system prompt and user messages, with some instructions stated only once and others repeated.
How would you fix the inconsistency?

• A. Place each instruction wherever the developer who first wrote it found most natural, retaining the original intent.
• B. Move all instructions into the user message so the application's behavior is controlled at the input point.
• C. Repeat all instructions in both the system prompt and the user message so the model sees each instruction more than once.
• D. Consolidate behavioral and format instructions in the system prompt and keep user messages focused on the user's input.

Your Claude application uses structured output that is consumed by downstream code. The team wants to handle malformed or unexpected output gracefully so it does not crash downstream systems.
The best choice for handling this issue would be to...

• A. Use the output the model produces and leave schema enforcement to a later phase of production after the application is more complete.
• B. Silently drop any output that does not match expectations so downstream systems do not see the malformed output the application receives from the model.
• C. Crash on any unexpected output and require manual recovery on affected requests the application handles during normal operation.
• D. Apply defensive parsing to handle unexpected fields, missing values, and type mismatches that the downstream code might otherwise crash on.

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. 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.
• B. 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.
• C. Truncate every conversation to the last two messages so that token usage stays low and costs remain predictable across the application's normal operation.
• D. 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.