Ten Prompt Changes for Claude Opus 5.5: Official Best Practices Decoded

After Anthropic released Claude Opus 5.5, many developers found that their old prompting habits had stopped working. The model's reasoning mechanism, parameter defaults, and output behavior have all been adjusted — sticking with old patterns can waste tokens at best, or get requests outright rejected at worst. This article draws on a Bilibili creator's rap-style summary of "ten new changes" and maps them against official best practices, walking through the key updates you need to know when writing prompts for the Opus 5.5 era.

Reasoning: Thinking Is On by Default — Stop Writing "Think Carefully"

The most fundamental change in Opus 5.5 is how reasoning works. The default effort level is set to medium, and that medium setting already approaches the performance of the previous Opus generation at its best. More importantly, the model's thinking process is always on and cannot be fully disabled — if you want to save tokens, the right move is to dial down the effort level, not try to turn off thinking altogether.

This has two immediate implications. First, stop putting phrases like "think carefully" or "reason step by step" in your prompts. The model thinks on its own, and these phrases are now redundant — removing them often makes responses faster. Second, don't try to force the model to write out its full reasoning chain in the final answer. That kind of request may be outright rejected. If you want to see the thinking, enable summarized mode to view a summary — don't try to stuff the reasoning into the output.

Effort levels are a reasoning budget control mechanism Anthropic introduced for the Claude 3.7 series. Developers can specify the maximum number of tokens the model uses for internal reasoning via the budget_tokens field in the thinking parameter of API calls. Opus 5.5 sets the default to medium, which corresponds to a budget of several thousand reasoning tokens — sufficient for most moderately complex tasks. The low tier works well for simple Q&A to save costs, while the high tier suits deep reasoning tasks like mathematical proofs or multi-step planning. Since reasoning tokens count toward billing but don't appear in the final output, the old practice of "forcing the model to show its reasoning steps in the answer" is now redundant under the new architecture — and will indeed cause the model to refuse or produce lower-quality output.

Token and Output Configuration: Loosen Up the Max Tokens

Since reasoning is always on, the model consumes some tokens on internal thinking before it ever produces an answer. If you keep the same tight max_tokens settings from before, you'll frequently run into situations where the reasoning hasn't finished but the output gets cut off. The official recommendation is to increase your max_tokens limit to give both reasoning and the actual response room to breathe.

When observing model behavior, you need to set the display mode to updates to see text output progress in real time. This is especially important when debugging long-running tasks — otherwise you might think the model is stuck when it's actually reasoning in the background.

Task Completion Signals: Closing Text ≠ Task Done

A common pitfall: when the model outputs what looks like a closing statement, it doesn't necessarily mean the task is actually complete. With Opus 5.5 handling complex tasks, the end of text output and the completion of actions are two different things. To give the model a reliable way to determine task boundaries, the best approach is to provide a checklist and execute it in order — naming each item explicitly — rather than relying on a vague "are you done?"

Anthropic has summarized four common ways to signal task completion, and the core idea across all of them is to replace implicit tone-based cues with explicit, structured signals. Breaking tasks into checkable lists and having the model work through them item by item is currently the most reliable approach.

Multi-Agent Collaboration: Set Time Budgets and Use Relaxed Parallelism

For multi-agent workflows, Opus 5.5 recommends giving each agent a clear time budget and requiring them to report progress. This prevents any single agent from going down a rabbit hole indefinitely and slowing down the overall pipeline.

Combined with a relaxed parallel strategy, multiple agents can start work simultaneously rather than waiting in sequence. For complex workflows that need to coordinate multiple subtasks, this "budget + parallelism" combination can significantly improve overall throughput.

In Anthropic's multi-agent framework, relaxed parallelism means loosening the synchronization constraints between agents, allowing sub-agents to begin preparatory work before upstream tasks are fully confirmed. The counterpart is strict mode, where each agent must wait for its upstream dependencies to complete before executing. The tradeoff with relaxed mode is that it requires additional conflict-resolution logic — when multiple agents concurrently modify the same resource, there must be clear priority rules. The time budget mechanism requires each agent to declare an expected completion time at startup; the orchestrator uses this to enforce timeouts and reclaim resources, preventing an agent stuck in a loop from blocking the entire pipeline. Used together, these two mechanisms represent Anthropic's recommended configuration for long-running agentic workflows.

New Standards for Pasting Content and Visual Processing

When pasting large blocks of content into a prompt, wrap it in tags — something like <pasted_content> — to clearly mark it. Structured tags help the model distinguish between "instructions" and "material to process," preventing pasted content from being mistakenly treated as a command.

On the visual side, Opus 5.5 is more accurate at image recognition than the previous Opus. If you've built a visual scaffolding setup (auxiliary prompts, preprocessing steps) for the old model, the recommendation is to remove it first and then test — the new model may not need that assistance, and keeping it may actually interfere with performance.

Regarding negative instructions: don't just tell the model what not to do. It's far more effective to explicitly state what you want it to do. Models respond better to positive, specific instructions; a simple prohibition is usually less reliable than providing a clear example of the desired behavior.

Anthropic's official recommendation for structured tags draws from XML-style context-delimiting conventions, such as wrapping external material in <document>…</document> or <pasted_content>…</pasted_content> tags. These tags give the model clear semantic boundaries, enabling it to distinguish between "system instructions," "user input," and "material to process" — which reduces prompt injection risk (attacks where malicious content disguises itself as instructions to manipulate the model). In RAG (retrieval-augmented generation) scenarios, wrapping retrieved document snippets in tags is now standard industry practice, and Opus 5.5 shows noticeably improved recognition and compliance with this kind of structure compared to its predecessor.

Takeaway: Actively Unlearn Your Old Habits

The consistent logic running through all ten of these Opus 5.5 changes is simple: the model got stronger, and a lot of the manual scaffolding can now step aside. Whether it's reasoning-guidance language, tight token limits, or visual workarounds built for older models — things that once helped may now be dead weight. When migrating to Opus 5.5, the right instinct is to simplify first, then add back only what testing shows you actually need.

The above is based on a Bilibili creator's summary of Anthropic's official Opus 5.5 best practices. For specific parameter behavior, always refer to the official Anthropic documentation.