# Claude Code Ultraplan: Cloud-Based Interactive Planning
Ultraplan is a feature in Claude Code that moves the planning phase of a coding task from the local terminal to a cloud-hosted environment. **You invoke it with a prompt, Claude clones your GitHub repository into a temporary cloud container, drafts an implementation plan in an interactive web UI**, and waits for your review. You can leave targeted comments on specific sections of the plan, request a revision, and then either execute the plan in the cloud or teleport it back to your terminal.
## Prerequisites
Ultraplan requires Claude Code v2.1.101 or later, a GitHub-hosted repository, and a Pro or Max subscription. Installing the Claude GitHub App on your repository or organization enables Claude to create branches and open pull requests automatically from the cloud session. Without it, the session provides `git` commands to fetch and push the changes manually.
## Initiating a session
From the root directory of your project:
```command
ultraplan
```
The `ultraplan` command renders with a rainbow color effect in the terminal, similar to `ultrathink`. Provide a detailed prompt describing the feature or task. Adding "don't use superpowers" to the prompt ensures Claude uses the native Ultraplan workflow rather than falling back to the Superpowers plugin.
Claude asks for confirmation before uploading your repository to the cloud:
```text
Run ultraplan in the cloud?
a few minutes
Interactive planning on the web where you can edit and leave targeted comments on Claude's plan.
This will upload your repository to Claude Code on the web.
Proceed?
> 1. Yes launch in Claude Code on the web
2. No
```
## Cloud session setup
After confirming, Claude provisions a temporary container and begins preparation.
The setup sequence is: provision a cloud container, clone the repository from GitHub, optionally run a setup script to install dependencies, and initialize Claude Code in the container. Claude then inspects the repository to build context before generating the plan. This takes a few minutes, during which the local terminal remains free.
## Reviewing the plan
When the plan is ready, the terminal displays a link to the web review interface. The plan is structured into sections.
The **Context** section summarizes Claude's understanding of the project and the goal. **Shape of the change** provides a high-level flowchart of the implementation. **Files to create/modify** lists all new and changed files. **Detailed steps** contains code snippets and diffs for each proposed change.
To provide feedback, highlight any section of the plan and a comment box appears. This lets you point to a specific incorrect statement, an architecture decision you want to change, or a missing consideration, without rewriting the entire prompt. After submitting comments, clicking **Revise** causes Claude to reprocess the feedback and regenerate the plan.
## Approving and executing
Clicking **Accept** begins implementation in the cloud container. Claude creates files, modifies existing ones, and runs commands as specified in the plan. With the GitHub App installed, it can commit, push, and open a pull request automatically. Without it, it outputs the `git` commands needed to fetch the committed changes locally.
## Token consumption
Ultraplan is measured against a per-session token limit tied to the Pro or Max plan. A session involving one failed attempt, one plan generation, and one revision consumed approximately 33% of a 5-hour session limit:
- Initial failed session: 4%
- First plan generation: 15% (total at 19%)
- Plan revision: 18% (total at 37%)
The revision cycle is the most expensive part. For complex tasks where the interactive web review and targeted feedback provide clear value, this cost is appropriate. For simpler tasks, the overhead may not be justified.
## Comparison with Superpowers
Superpowers is a local-first planning plugin that stays entirely in the terminal. It operates in two phases: a Q&A brainstorming session followed by a detailed implementation plan. Running the same prompt through both methods reveals several differences.
**Interactivity.** Superpowers asks more clarifying questions before generating a plan (6 in the observed comparison vs. 3 for Ultraplan). The back-and-forth happens in the terminal rather than through a web review interface.
**Plan depth.** The Superpowers plan was longer (833 lines vs. 195) and included dedicated tests for each implementation step, following a TDD structure with sections for `Goal`, `Architecture`, and `Tech Stack`.
**Token efficiency.** The Superpowers session used approximately 75,000 tokens from the overall context window. A direct comparison is difficult, but for local planning tasks, Superpowers appears more token-efficient.
**Workflow fit.** Ultraplan suits developers who work across multiple machines, want to run planning in the background while doing other work, or prefer reviewing plans in a web UI with comment support. Superpowers suits developers who prefer a conversational, terminal-based workflow that produces test-driven implementation steps and stays local.
## Final thoughts
Ultraplan's main advantage is flexibility: **the plan is generated in a cloud container and can be reviewed from any browser, revised with targeted comments**, and executed either remotely or locally. This is genuinely useful for background planning and multi-device workflows.
The cost in session tokens is real, particularly when a revision is needed. The web interface for review and the targeted comment feature justify this for complex features where plan accuracy matters before implementation starts.
For local-first, **high-detail planning with a TDD emphasis, Superpowers still produces more comprehensive output at lower effective cost**. Both tools serve different workflow preferences and neither has made the other obsolete.
Claude Code documentation covering Ultraplan and subscription requirements is available at [docs.anthropic.com](https://docs.anthropic.com/).