Opus 5.5: Master AI with Advanced Prompting

The latest Opus release, version 5.5, is engineered to operate autonomously for extended periods, reducing the need for constant user intervention.

It provides clear and concise summaries of its completed actions, outlining what it did, what it found, and what it requires from the user in plain language. Additionally, the model incorporates inherent 'thought' processes before every response, enhancing its decision-making capabilities.

To effectively manage complex tasks, the speaker advocates for a 'prompting wider' strategy, handing over entire tasks rather than providing piecemeal instructions. This approach requires users to define explicit 'done states' to guide the AI.

An explicit 'done state' might include specific criteria such as feature completion, verification through a screenshot, and the submission of a pull request. Setting these clear success criteria is crucial, as it prevents the model from stalling or becoming uncertain about task completion, ultimately enhancing its efficiency.

The speaker questions the common advice to include explicit 'think carefully' lines in prompts, asserting that models like Opus 5.5 are already designed to perform inherent thought processes.

Users should instead prioritize understanding what the model communicates it needs from them after long execution runs. The speaker notes that while the model is advanced, it occasionally fails to identify its own requirements, necessitating user follow-up to ensure task continuity and accurate completion.

The speaker advises users to avoid the 'Max' reasoning setting on Opus 3.5, based on a personal experience where a 6.5-hour attempt using this mode failed to yield any progress.

This mode, despite its name, did not enhance the model's performance in his tests, leading to significant time wastage without achieving the desired outcome.

By pre-defining environment permissions and background task constraints, the speaker mitigates agent hesitation and conflicts during execution.

For instance, providing the agent with specific permissions for accessing environment variables prevents it from pausing mid-task to ask for confirmation, thereby maintaining workflow continuity. This proactive approach ensures the agent has all necessary authorizations upfront.

Explicitly requesting that the agent run tasks in the background is also crucial, as it prevents 'spamming' the local machine with browser control requests, especially when dealing with tasks that involve continuous operations.

AI models, often trained with reinforcement learning, are designed to persist on tasks, which can lead them to attempt to solve problems incorrectly rather than stopping when faced with an issue.

Providing an 'out' by explicitly encouraging the agent to ask questions if it encounters unexpected problems is a critical strategy. This prevents the model from guessing or bypassing critical obstacles that could lead to erroneous results.

This technique helps ensure the model pauses when it genuinely encounters confusion or configuration errors, allowing for user intervention and correction before significant issues arise.

Theo highlights that Opus 5.5 may frequently pause to ask for permission if explicit instructions are not provided, interrupting workflow.

He recommends a three-part prompt structure: clearly define the objective, specify what the 'done' state looks like, and provide an exit condition for errors. This comprehensive approach minimizes unnecessary interruptions and ensures task completion.

A practical example of a proper prompt includes: 'Migrate the payments endpoint. Done means every endpoint uses the new client, the old one is deleted, and the test suite passes.' This level of detail guides the model precisely.

Theo argues that users should refrain from instructing models to 'think hard,' as modern AI models already optimize reasoning based on task complexity. This inherent capability makes explicit 'thinking' prompts redundant and potentially counterproductive.

'Max' reasoning settings do not merely enhance the model's thinking capacity; instead, they restrict its ability to 'think less,' which introduces significant computational overhead. This forced extensive reasoning can lead to inefficiencies without proportional benefits.

Data from Skatebench illustrates this point, showing that 'Max' settings increased average tokens by over 10 times and extended average duration to 50 seconds compared to 'X-High' settings. Despite these increases, the benchmark revealed only a 1% improvement in correct answers, incurring 13 times more cost and taking 20 times longer in worst-case scenarios.

The speaker emphasizes that models are capable of independent thought and that explicitly telling them to 'think' is unnecessary.

Users should trust the model's inherent intelligence and advanced design, as it already incorporates sophisticated reasoning processes. Attempting to force or guide its thinking can be redundant and may not yield better results.

Unlike earlier models that treated new messages as task resets, modern architectures like Opus interpret mid-task instructions as steering inputs to preserve context.

Older models often suffered from reinforcement learning issues where new messages would cause the loss of previous task context, essentially resetting the progress.

New training advancements enable interruption messages to be interpreted as 'steering'—additional guidance to help the model proceed correctly—rather than as reasons to stop or consider previous work done.

Opus 5.5, while capable, defaults to generic styles unless specifically guided, making precise design instructions crucial for optimal output.

Generic design requests, such as 'make it pretty,' often result in lackluster outcomes because they lack specific direction. To achieve high-quality designs, effective steering requires defining both what to include and, more importantly, what to avoid through negative constraints.

Visual feedback, such as annotated screenshots, is highly effective in steering design output. By showing the model what adjustments are needed, users can guide it toward desired aesthetic and functional outcomes more efficiently than with text-only prompts.

Users should configure Opus 5.5 to balance between providing necessary status updates and maintaining continuous momentum, especially within Claude Code environments. This involves carefully setting conditions for when the model should proceed independently and when it needs user input.

It is important to define specific 'stops' directly in the Claude MD file to minimize unnecessary manual input. These stops should be mandated only for destructive actions, such as deleting data or force pushing, or when external approval is absolutely required, ensuring critical operations are safeguarded.

For long-running tasks, the speaker suggests replying with 'continue' or implementing preventative rules to minimize frequent stops and manual oversight. Incorporating rules to prevent frequent stops in long-running tasks helps streamline the process.

This approach balances the need for oversight with the desire for hands-off automation. Some users also prefer 'prepared programming,' where steps are planned in advance, rather than constant execution prompts, to ensure a smoother workflow and fewer interruptions.

Users should prioritize checking pending decisions or approval requests from AI agents, as Opus 3.5 provides clearer reporting compared to its predecessor. This improved clarity makes it worthwhile to read the full summaries.

The model's updates and final summaries explicitly state what actions were performed, what findings were made, and what it needs from the user in plain language. Recommended headings for Claude.md files, such as 'Blocked on me,' 'Changed,' and 'Found,' can further organize these outputs. Proactive questioning, like 'What is the status?' or 'What are the risks?', is also highly effective for extracting necessary information.

While Opus 3.5 performs better than previous iterations, leveraging external models can provide additional value, especially in code review. The speaker has personally found swapping between different model families and labs to be useful.

OpenAI models, for example, often delve deeper into code details during review, even if they sometimes report irrelevant findings. Testing benchmarks indicate that models like Grok 47 and OpenAI's offerings frequently outperform others in identifying areas for improvement.

Opus 3.5 itself showed significant progress, demonstrating a nearly twofold increase in successful findings compared to Opus 3, highlighting its improved capabilities while still benefiting from cross-model validation.

This cross-model validation approach helps in catching errors that a single model might miss.

It is noted that for every two valid findings, a model might also generate one incorrect one, underscoring the importance of verification. Users are recommended to ask the model to explicitly mark unconfirmable sections, ensuring that critical areas are manually checked for accuracy and reliability.

Claude 5.5 incorporates new safety guardrails that may trigger model downgrades if certain reasoning patterns are detected, posing a risk of getting flagged. When an error or flag occurs, users are advised to start a new chat or disable auto-switching in settings to mitigate the issue.

Additionally, asking for 'reasoning traces' can trigger security flags because Anthropic aims to prevent model distillation, a process where a smaller model learns from a larger one. Users should be aware of these limitations to avoid unintended interruptions or performance reductions.

Effective prompt engineering involves defining what 'done' looks like rather than instructing the model to 'think hard,' as modern AI models are already designed with sophisticated reasoning capabilities. This direct approach provides clearer guidance.

The underutilized power of screenshots for providing context, especially on coding errors, is highlighted. Instead of copying and pasting error messages, simply screenshotting the browser and pasting the image can provide the model with a richer context. Claude Code is capable of automatically cropping high-resolution screenshots to extract relevant information, further streamlining the process.