↓ Skip to main content
sdd.sh
sdd.sh
  1. Articles/

Claude Code Ultraplan: When 30 Minutes of Cloud Thinking Beats 5 Seconds of Local Guessing

·1319 words·7 mins·
Table of Contents

The hardest part of any autonomous coding task isn’t execution — it’s the plan. A bad plan executed flawlessly still ships the wrong thing. And plans created under terminal pressure, in the same context window that’s about to run the code, are almost always worse than plans built with time, depth, and distance.

Claude Code’s new /ultraplan command is a direct attack on that problem. Instead of asking Claude to plan locally and then immediately execute, Ultraplan offloads the entire planning phase to Anthropic’s cloud infrastructure — a dedicated Claude Code web session running Opus 4.6, isolated from your terminal, with up to 30 minutes of compute and a browser interface for review. Your terminal is free the whole time.

It’s a simple idea with surprisingly deep implications for how you structure agentic workflows.

What Ultraplan Actually Does
#

When you run /ultraplan (or include the word “ultraplan” anywhere in a prompt), Claude Code hands the planning task off to a remote session in Anthropic’s Cloud Container Runtime (CCR). That session:

  • Runs Opus 4.6 — the most capable model in the Claude family
  • Has up to 30 minutes of dedicated compute for deep analysis
  • Operates independently of your local terminal, which polls for status every 3 seconds
  • Produces a structured plan you review in your browser, not in the terminal

When the plan is ready, you open it in Claude Code on the web. From there you can comment on specific sections, request revisions to individual parts, and — when you’re satisfied — choose where to execute it: send it back to your local terminal, to a different Claude Code session, or to a cloud environment entirely.

That browser review surface is underrated. In terminal plan mode, your feedback options are essentially “accept,” “reject,” or “describe what’s wrong in prose.” With Ultraplan’s browser interface, you can annotate exact sections, ask targeted questions about specific steps, and iterate on individual parts of the plan without starting over.

There’s also a third trigger path worth knowing: when Claude finishes a local plan and shows the approval dialog, you can choose “No, refine with Ultraplan on Claude Code on the web” to send the draft to the cloud for deeper elaboration. Local planning with cloud polish.

The Three Modes
#

Ultraplan isn’t one system. Based on documented behavior (and analysis of the system prompts Claude operates under), there are at least three variants — and which one activates appears to depend on how you phrase the request:

Simple Plan The lightweight option. Essentially regular plan mode running on cloud hardware — faster than local planning, but not fundamentally different in depth. Good for tasks where you want the browser review surface without committing to 30 minutes of compute. The cloud execution environment also gives you a cleaner context window, isolated from whatever conversation history your local terminal is carrying.

Visual Plan Same as Simple, plus explicit instructions for Claude to generate Mermaid diagrams or ASCII visualizations for structural changes. If your task involves data flow changes, service dependencies, or architectural restructuring, Visual mode produces a plan you can actually walk stakeholders through — dependency order shown graphically, not just described in paragraphs. Useful for anything where “before and after” matters.

Deep Plan The full 30-minute commitment. Claude is instructed to explore the problem space exhaustively — multiple approaches considered, trade-offs surfaced, edge cases enumerated, implementation sequenced in detail. The output is substantially longer and more thorough than what local plan mode produces under typical conditions. This is the right mode for large-scale refactors, greenfield architecture decisions, or anything where getting the plan wrong is expensive.

Anthropic has confirmed the three modes exist; assignment between them currently appears to involve some A/B testing infrastructure, meaning you may not always get the same mode for the same phrasing. The official documentation describes the system as a “research preview” and the modal behavior is expected to stabilize as it matures.

Requirements and Access
#

Ultraplan requires:

  • Claude Code v2.1.91 or later (check with claude --version)
  • A Pro, Max, Team, or Enterprise account — the feature is not available on the free tier
  • A connected GitHub repository — Ultraplan’s cloud session needs repository context to plan meaningfully

The feature is in research preview. Anthropic’s framing suggests it will remain gated on higher-tier plans; the compute costs for 30 minutes of Opus 4.6 per planning session are non-trivial.

When to Use It — and When Not To
#

Ultraplan is not a replacement for local planning. It’s a tool for a specific category of tasks where the cost of a bad plan is high and the cost of 30 minutes of compute is low by comparison.

Reach for Ultraplan when:

  • The task involves significant architectural change across multiple files or services
  • You’re making a decision that’s hard to reverse (database schema changes, API breaking changes, major dependency upgrades)
  • You want a structured plan you can share with a team or use in a PR description
  • You need visual representations of dependencies or data flow
  • Local planning has already produced a plan that feels incomplete or misses edge cases

Skip Ultraplan when:

  • The task is bounded and well-understood — local plan mode is faster
  • You’re iterating rapidly and 30 minutes is a blocking delay
  • You don’t need the browser review surface (pure terminal workflows)
  • The task doesn’t require a GitHub repository (scripts, local utilities, exploration)

The most important judgment call: Ultraplan is best when you’re front-loading the cost of thinking. If you’ve ever spent three hours debugging an implementation that solved the wrong problem because the initial plan was too shallow, Ultraplan is paying back that tax in advance.

What This Tells You About Anthropic’s Direction
#

Ultraplan is the third leg of Anthropic’s “planning infrastructure” story, alongside the leaked ULTRAPLAN and KAIROS features described in earlier coverage and Claude Managed Agents’ checkpointing and multi-agent coordination primitives.

The through-line: Anthropic is disaggregating the agent loop. Planning happens somewhere. Execution happens somewhere. Review happens somewhere. These don’t have to be the same place, the same model, or the same time.

Ultraplan specifically makes planning a cloud-native, asynchronous operation — you don’t have to babysit it, you don’t have to keep your terminal open, and you don’t have to review it under time pressure. The plan arrives when it’s ready, you review it at your pace, and execution happens wherever makes sense.

That’s a fundamentally different model from “AI completes your thought as you type.” It’s AI doing extended, deliberate work while you do something else — and then collaborating on the output before any code runs.

The JetBrains April 2026 developer survey puts Claude Code at 18% adoption at work (up from 3% a year ago, 6× growth), with a 91% CSAT score — the highest in the market. Ultraplan is the kind of feature that explains those satisfaction numbers: it’s not adding UI chrome, it’s removing a genuine limitation in how well autonomous agents plan before they act.

The Bottom Line
#

Local plan mode is still the right default for most tasks. But for anything complex enough that the plan matters as much as the execution, Ultraplan gives you something that wasn’t previously available: Opus 4.6, 30 minutes, no interruptions, and a browser interface for collaborative review.

Run /ultraplan before your next major refactor. Give it the full depth it needs. Review it properly in the browser. Then execute with confidence.

That’s the point — not speed, but quality of judgment before the work starts.

Sources:

Related