Claude Code ultraplan separates thinking from doing

Three things you'll walk away with after reading this:

1. Ultraplan moves planning out of the terminal and into a browser. You get inline comments, structured review, and the ability to keep coding while the plan builds itself in the cloud. It sounds minor. It changes how you work.
2. The real shift is the planning-execution split. When thinking and doing happen in different environments, you can treat plans like pull requests: review them, annotate them, iterate before any code gets written.
3. This is Anthropic's first step toward multi-environment development. Plan in the cloud, execute locally or remotely, open a PR from either. The terminal stops being the only place work happens.

The first time I used ultraplan and watched my terminal stay responsive while a complex architectural plan built itself somewhere in the cloud, the reaction wasn't excitement about a feature. It was irritation that planning had ever blocked the terminal in the first place. That frustration, multiplied across every developer who has stared at a blinking cursor for 15 minutes while Opus maps out a refactor, is exactly the problem Anthropic shipped ultraplan to solve in Claude Code v2.1.91.

The blocking problem

When you ask Claude Code to plan something substantial, your terminal locks up. The model thinks. You wait. On a large refactor or a feature that touches multiple components, that thinking phase takes 10 to 20 minutes. During that time, your terminal is useless. You can't run tests, check logs, or work on anything else in that session. Ultraplan moves the entire planning phase to Anthropic's cloud infrastructure. The model runs in a remote container with access to your repository through GitHub. Your terminal shows a status indicator instead of a frozen prompt. When the plan finishes, you receive a browser link. Three ways to start it: use the /ultraplan slash command with your task description, include "ultraplan" anywhere in a regular prompt, or finish a local plan and select "refine with Ultraplan" from the approval dialog.

Why browser-based review changes the dynamic

The plans Claude Code produces in plan mode are frequently solid. Reviewing them is the bottleneck. A detailed plan in terminal scrollback is a wall of text you scroll through, and your only mechanism for feedback is typing a response at the bottom. When a plan has 12 sections and you need changes to sections 3 and 9, you either compose a paragraph addressing both simultaneously or you handle them sequentially in a back-and-forth that takes longer than the planning itself. Ultraplan replaces that with a document review interface. You highlight the database migration paragraph and comment "use a staged rollout, not a cutover." You approve the testing section with a reaction. You mark the deployment section as needing expansion. Claude revises based on your annotations and presents an updated version. You iterate until the plan is right. This resembles how architectural decisions actually happen in engineering teams. Not through sequential chat messages. Through structured review where comments attach to specific sections of a shared document.

Choosing where code gets written

After approving the plan, you decide where execution happens. The first option runs everything on the web. Claude implements the plan in the same cloud session, pushes a branch, and opens a pull request. Your terminal isn't involved at all. You review the diff in the browser and merge when satisfied. The second option returns the plan to your local session. From there, you choose between implementing within your current conversation (preserving all prior context), starting a fresh session with only the plan (clean slate), or canceling and saving the plan as a file for later use. The split makes sense because each environment offers different advantages. Your local machine has credentials, custom tooling, and whatever particular configuration your project demands. The cloud container has compute resources and native PR integration. Ultraplan lets you match the task to the environment rather than forcing everything through one path.

Infrastructure that hints at something larger

AI coding tools have progressed from autocomplete to chat to agentic execution. Ultraplan introduces a fourth mode: work that transitions between environments based on what each phase requires. Architect in the browser where you can annotate. Build locally where your credentials live. Or build remotely where the PR integration is native. The plumbing underneath matters more than the feature itself. Cloud containers with repository access, status synchronization between terminal and web, plan serialization and transfer between environments. That's infrastructure for multi-surface development. Today it connects your terminal to Claude Code on the web. The same architecture could connect to a mobile review interface, an IDE plugin, or a team dashboard where multiple engineers annotate the same plan before any implementation begins. Anthropic hasn't announced any of those extensions. But the technical foundation supports them. And the pattern, separating the thinking surface from the doing surface, feels like the natural direction once you've experienced it.

What it costs

Steve Kinney investigated the pricing model. Ultraplan runs on Anthropic's cloud using Opus 4.6 in a remote container for up to 30 minutes per session. On the Pro subscription, fast mode charges extra usage from the first token. The 1M-token context window requires extra usage on Pro but comes included with Max. Extra usage bills at standard API rates with five-hour reset windows. Kinney noted that "subscription limits are real until they aren't," and costs become less predictable once extra usage activates. For occasional use, this is unlikely to matter. For teams running ultraplan against large codebases several times daily, costs could accumulate in ways the subscription price alone doesn't reveal. Worth monitoring before making it part of your standard workflow.

Where it falls short today

Ultraplan requires a GitHub repository and a Claude Code on the web account. It doesn't support Amazon Bedrock, Google Cloud Vertex AI, or Microsoft Foundry backends. If your organization uses those providers, ultraplan isn't available yet. The cloud environment is generic rather than tailored to your local setup. Code that works on your machine can fail in the cloud container due to the security proxy, package manager differences, or missing dependencies. Kinney described this as "cloud-local divergence," and it's a genuine friction point for projects with unusual build requirements. There's also a structural tension in the design. The approval gate between planning and execution supports governance and careful review, but it adds friction to rapid prototyping. When you're exploring an idea and want fast iteration, the round-trip between terminal, cloud, browser, and back adds steps that a straightforward plan-mode session avoids. The practical answer is probably reserving ultraplan for work that benefits from structured planning: major refactors, architectural changes, features that span multiple components. For quick experiments, local plan mode remains faster.

The platform question

Anthropic recently restricted third-party tools that built agent loops on top of Claude Code, citing infrastructure strain. Then they shipped their own agentic planning tool. Draw your own conclusions, but the net effect is that your development workflow becomes more tightly integrated with Anthropic's infrastructure. Your plan lives on their cloud. Execution can happen there. Pull requests can originate from their container. The more deeply embedded the product becomes, the harder it is to switch away. For individual practitioners, ultraplan represents a genuine workflow improvement. For teams, it previews something worth tracking: plans that exist outside the terminal, review that functions like a shared document, execution that routes to wherever it makes sense. Whether that future stays within Anthropic's ecosystem or opens up to other platforms is the question ultraplan doesn't answer. But it's the first credible implementation of the concept, and the direction it points toward feels correct even if the destination remains uncertain.