Getting the most out of Opus 5.5

Product overview (Opus 5.5 / Opus 55)

The video argues that Anthropic’s Opus 5.5 (Opus 55) is an especially strong “long-run” model for agent-style coding work (e.g., via Claude Code, Cloud Apps, Cloud Code). The host emphasizes how to prompt it so it can:

• Stay on task longer
• Report what it’s doing
• Know when it’s done

…and also avoid common mistakes.

---

Key features / what it does well

• Better code quality: The host says they’re “very impressed with the code it puts out.”
• Longer autonomous work sessions: It stays on task for long work “as long as you don’t use Macs.”
• Clearer run behavior (vs older behavior):
  • Tells you plainly what it did
  • Thinks before every reply
  • Reports progress/needs from the user more explicitly
• Similar to Claude in usage, but with behavioral differences, such as:
  • Longer runs
  • More explicit reporting
  • Built-in “think” behavior
• Steering support in Claude Code / long runs:
  • You can send follow-ups mid-run; modern models treat them as steering additions rather than a reason to abandon prior work.
• Verifies its own changes when tooling/tests/browser access are available, and can mark what it can’t verify.

---

How to get the most value (prompting / workflow guidance)

The host provides a practical “recipe” for maximizing results:

1. Define a concrete “done state”

   • Provide explicit completion criteria, e.g.:
     • “Build it so it has these three things…”
     • “Verify it by showing a screenshot and then file a PR…”
   • Why it matters: otherwise Opus 55 may stop early or unpredictably.

2. Use an explicit “out”

   • Instruct it to ask for clarification only if it fails/confuses you, not for every step.
   • Example style: “Stop and ask only if a test fails for a reason you can’t explain.”

3. Don’t tell it to “think hard”

   • The model already decides how much to think; asking for more is discouraged.

4. Prefer higher-but-not-maximum reasoning levels

   • The host strongly recommends not using “Max Reasoning.” (See comparison below.)

5. Add follow-ups instead of restarting

   • If you realize something mid-run, sending a follow-up/steering helps avoid the cost of restarting.

6. Steer long runs using a stop/approval rule

   • Place guidance in a config (e.g., cloud MD / Claude MD), such as:
     • Keep going when no input is needed
     • Stop only for destructive/risky actions (e.g., delete/force push outside the repo)
   • The video includes a concrete “rule” text the host uses.

7. Use sub-agents for big tasks (when appropriate)

   • Useful for audits/migrations/reviews across large codebases.
   • Note: Opus 55 may be less willing to spawn sub-agents unless prompted, so you may need to explicitly request them.

8. Check results after long runs

   • Look for:
     • What it’s blocked on / waiting for approvals
     • What changed
     • Any findings you should review
   • The host recommends reading the final summaries because Opus 55 reports more clearly than earlier Opus versions.

---

Major pros mentioned

• High-quality coding output
• Stays on long tasks better than expected
• More transparent progress and needs from the user
• Better “steering” behavior during long runs (follow-ups steer without resetting goals)
• Handles design direction well when you specify both DO and DON’T
• Can perform multi-step work with minimal user interruption if you define a done state and out
• Useful for planning + executing tasks on remote machines (e.g., delegating work from laptop to another machine)

---

Major cons / risks mentioned

• Max Reasoning is very inefficient
  • Can greatly increase tokens/time with little improvement.
• Sometimes it may miss the “read what it needs from you” pattern
  • The host sometimes re-prompts to get it to ask correctly.
• Platform quirk: “as long as you don’t use Macs” implies limitations/behavior differences.
• Security safeguards / auto model switching in Cloud Apps / Cloud Code
  • Some legitimate work may be flagged and moved to older models.
  • Starting a new chat may be needed to recover.
• Avoid asking for reasoning traces
  • Requesting model reasoning may increase likelihood of flags.

---

Strong comparison: Opus 55 vs “Max Reasoning” (within Opus)

The host provides benchmark-like numbers from Skatebench:

• X high
  • Avg tokens: 338
  • Avg duration: 6s
  • Slowest: 31s
• Max
  • Avg tokens: ~5,000 (over 10x)
  • Avg duration: 50s
  • Slowest: ~600s (about 20x slower)
• Outcome improvement
  • Correct answers: 78% → 79% (+1%)
• Cost/performance
  • Cost: ~13x
  • Tokens: ~15x
  • Worst-case time: ~20x

Host verdict: Max Reasoning yields marginal gains at huge cost, so “don’t touch max mode.”

---

Cross-model comparison for code review (not just coding)

The host compares model families when reviewing code:

• They prefer Opus 55 to find many issues, and say Opus 55 improved vs earlier Opus versions in their judging.
• They also recommend an additional review from OpenAI models (e.g., “Astra or Grock 47”), because:
  • OpenAI models tend to be more exhaustive
  • Claude-style reviewers may miss some critical issues even if they find more than older Opus versions

Their judging / bench summary (T3 codebase “improvement finding”)

• Opus 55
  • Nearly twice as successful as Opus 5 (per their system)
  • No unresolved/contradicted findings
• Opus 5
  • Supported findings: 4
  • Plus 2 unresolved/contradicted
• Grock 47 / Astra / others
  • Astra and Grock 47 both found 8 improvements (substantiated)
  • Soul found 9, but judge rated quality lower
  • Fable found 5 (fewer improvements found), but vetting quality was solid

Practical takeaway: use a second-model family for review to catch different classes of issues (e.g., Opus for generation + another for review).

---

Cloud Apps / Cloud Code specifics (safeguards + flagged messages)

• Opus 55 is described as the first Opus model in Cloud Apps and Cloud Code with “Fable level bio and cyber safeguards.”
• If flagged, the system may:
  • Switch to an older model while the work continues
  • Show a notice and keep the chat on the switched model

Mitigations mentioned:

• Returning to Opus 55 in the model picker may work but may re-flag
• Starting a new chat may avoid repeated switching
• There are settings to disable auto-switch (instead pause/error)

The host reports flags aren’t happening “as much recently,” so it’s not their biggest worry.

---

Unique points mentioned about user experience

• Long tasks become feasible when you set “done” properly.
• User interruption cost matters
  • Restarting long runs is expensive; steering helps.

Remote work scheduling example

• The host had a long thread accidentally run on their laptop (6.5 hours) when using Max Reasoning.
• Later, they successfully moved work to a remote machine (“Leftbook”) using a carefully constrained prompt:
  • Validate prerequisites (repo cloned, env vars present, run via Cloud Code/T3)
  • Avoid spamming with computer-use/browser windows on the user’s machine
  • Ask questions only at the end or when necessary
• After ~17 minutes, it set up and created the remote thread; it proceeded through phase zero and then stopped per phase instructions.

---

Overall recommendation / verdict

Recommendation: Yes—Opus 5.5 is strongly recommended for agentic coding and long-running work, if you:

• define clear done states
• provide an explicit out
• use higher (not Max) reasoning
• attach relevant context (e.g., screenshots)
• read run summaries for approvals/blocked items

Avoid: “Max Reasoning mode” due to massive cost/time for minimal gains. Also be mindful of Cloud Apps safeguards and flagging behavior.

---

Points by speaker (if applicable)

Only one main speaker appears in the subtitles (the host). Mentions of others (e.g., Addiosmani / Anthropic team) are in the context of content authorship and encouragement, not separate product reviews from different speakers.