Claude Code /ultraplan — Plans in the Cloud, Opens Pull Requests Automatically (2026)

Type One Command, Get a Pull Request

I typed a single slash-command in my terminal. Two minutes later, Claude Code had planned a whole feature in the cloud, let me leave inline comments to refine it, and opened a finished GitHub pull request — without me ever touching the implementation code.

That's /ultraplan, brand new in Claude Code. It's the laziest way to ship a feature in 2026, and it makes Routines look manual.

What /ultraplan Actually Does

Here's the model:

You stay in your terminal.
You hit /ultraplan with a prompt — a tweak, a feature, a refactor.
Claude Code spawns a planning agent on its cloud servers.
Your terminal stays free — keep coding, switch tasks, walk away.
The agent renders the full plan in your browser at claude.ai/code.
You review it, leave inline comments to refine specific parts, and pick one of two paths:
- Accept on web — autonomous execution + auto-generated GitHub PR
- Return to terminal — local execution with your full stack

Both paths work. The right choice depends on whether your environment can be reproduced in the cloud sandbox.

Step 1: Trigger /ultraplan from the Terminal

Inside Claude Code, type /ultraplan followed by your prompt. Anything goes — small tweak, full feature, whole refactor. Here's a small example to keep things tight:

/ultraplan Add a GET /version endpoint to this Express API that returns the current version from package.json plus git commit SHA and uptime in seconds. Read the version dynamically — do not hardcode. Add a simple Jest test for the endpoint. Update the README with a one-line note about the new endpoint.

Claude Code shows a confirmation prompt:

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 try to clone your git remote and fall back to uploading this repository. Proceed?
1. Yes launch in Claude Code on the web
2. No

Important detail: if your repo has a connected GitHub remote, Claude Code clones from there. If you have uncommitted changes or a private repo without a connected remote, it falls back to uploading the repo state directly. Either way, your local work isn't blocked.

Pick option 1. The terminal returns control immediately and prints the cloud session URL — something like https://claude.ai/code/session_.... While the agent works, you can keep coding here, or open the browser to watch it happen.

Step 2: Watch the Plan Render in the Web UI

Open the session URL. Claude Code on the web has three panes:

Sessions on the left
Conversation in the middle
Plan rendering on the right

The plan view itself has three sections:

Context — what the agent understands about your codebase and the change
Shape — the actual code blocks and structure of the change (not pseudocode — exact AST-level detail)
Changes — every file that will be modified or created

This isn't a vague summary. The Shape block shows the exact git rev-parse exec sync to capture the SHA at module load, the process.uptime call structure, the Express route signature. The Changes section lists every file the implementation will touch.

Step 3: Leave Inline Comments to Refine

This is where /ultraplan separates from every other AI coding tool. You can leave inline comments on specific parts of the plan.

Click on a code block (or a paragraph). A comment popup appears. Type your refinement — for example:

Use supertest for the Jest test instead of native fetch

Click Comment. The agent re-evaluates that specific part of the plan. If your comment introduces a real change, it re-plans that section. If the existing plan already satisfies your comment, the agent tells you so and re-requests approval.

This isn't chat. It isn't "tell me your full prompt again." It's targeted refinement — click, comment, refine. That's the whole loop.

Step 4 — Path A: Accept on Web → Autonomous PR

At the bottom of the plan view, four buttons:

Open plan
Revise
Return to terminal
Accept

Click Accept. The web UI shifts to execution mode. The agent:

Installs dependencies in the cloud sandbox
Writes the code
Runs the tests
Hits the live endpoint to verify (e.g. curl /version)
Commits the changes
Pushes to a new branch
Opens a pull request on GitHub

You watch it scroll by. When it's done, you get a clickable PR link. The auto-generated PR has:

A clean summary of what changed
A built-in test plan section
Both commits cleanly separated
A link back to the Claude session that built it

CI runs in GitHub Actions exactly like a normal PR. You merge it the same way.

Step 4 — Path B: Return to Terminal → Local Run

If your environment can't be reproduced in the cloud sandbox — heavy native dependencies, private packages, anything that needs your local keychain — click Return to terminal instead of Accept.

Your local Claude Code session wakes up automatically. It already has the approved plan injected into context. You get three choices:

Implement here in the current session
Start a fresh session with just the plan
Cancel

Pick option 1, and Claude Code runs the same plan locally — your environment variables, your node_modules, your git config, your local tests. Same plan, same code, but the work happens on your machine.

When to Use Which Path

Accept on Web (Auto-PR)	Return to Terminal (Local Run)
Self-contained features	Needs local env / secrets
Tests run in cloud sandbox	Tests run locally with full stack
You review the PR on GitHub	You review the diff in VS Code
Best for "ship while I sleep"	Best for private monorepo work

Quick rule of thumb: Accept on web when the change is self-contained, you trust the plan, and you want a normal GitHub PR. Return to terminal when you need your local environment for any reason the cloud sandbox can't replicate.

Requirements + Gotchas

Claude Code v2.1.91 or newer. Run claude --version to check. Update via curl -fsSL https://claude.ai/install.sh | bash.
Claude Code on the web account. Anthropic provisions this automatically with Pro and Max subscriptions.
Connected git remote for the auto-PR path. Without it, you can still use Return to terminal, but the Accept-on-web path can't push anywhere.

Common Issues and Fixes

Issue	Fix
`/ultraplan` not recognized	Claude Code version too old — update to v2.1.91+
"Failed to clone git remote"	Push the repo to GitHub first, or rely on the upload fallback (works for planning, not for auto-PR)
Web UI doesn't load the session	Pop-up blocker or not logged in — visit `claude.ai/code` first
Plan re-renders blank after a comment	Refresh the page — agent's revised state is server-side
Auto-PR succeeds but a background task failed	Sandbox port collision — Claude still commits the intended changes and notes the failure
Return-to-terminal does nothing	Local Claude Code session might be stale — relaunch with `claude`

Why This Workflow Wins

/ultraplan + auto-PR + inline comments is the laziest way to ship features I've found in 2026. Type once, refine on the web, merge from GitHub. Your terminal stays free the entire time, your local stack stays untouched, and the cloud agent does the implementation work while you focus on review.

It pairs especially well with Routines (for the always-on automation thread) and GitHub Actions (for the auto-deploy half of the loop). Stack all three and you've got a Claude Code workflow where you describe outcomes and merge results.

Useful Links

Claude Code on the web docs: code.claude.com/docs/en/claude-code-on-the-web
Claude Code download: claude.com/code
Sample auto-generated PR from this video: task-tracker-api/pull/2