Ultraplan & Cloud Planning: Moving from CLI Drafts to Web Execution
When undertaking complex, multi-system architectural refactors — such as splitting a monolithic service into microservices or upgrading a major database ORM — planning strictly inside a local terminal window has clear limitations: code plans cannot easily be shared with team leads for visual review, and executing 20 sequential file edits locally blocks developer workstations. Ultraplan bridges local terminal workflows with Claude's web interface and cloud execution engine, allowing engineers to draft detailed implementation plans in the CLI, publish them to the web portal for team feedback, and dispatch execution across cloud subagents.
In this guide, we break down Ultraplan architecture and bidirectional CLI-to-Web synchronization. We trace a scenario in a billing-service repository — planning a multi-phase Stripe API migration — to demonstrate how Ultraplan structures multi-step tasks, gathers inline web feedback, and offloads heavy subagent execution to remote cloud environments. For related agent architecture and execution modes, see How Claude Code Works and Autonomous Execution with Auto Mode.
What is Ultraplan & Why Dual-Plane Planning Matters
Traditional AI coding assistants treat planning as a single-turn prompt response. Ultraplan introduces a dedicated planning plane that separates Plan Generation, Interactive Review, and Execution Execution into distinct architectural phases.
By generating a structured implementation_plan.md artifact locally and syncing it to a shared web URL, Ultraplan allows tech leads and security teams to inspect proposed code modifications, review dependency graphs, and approve execution before any file edits occur.
| Feature | Local CLI Single-Turn | Claude Code Ultraplan |
|---|---|---|
| Plan Visibility | Terminal text output (Ephemeral) | Web UI URL (Persistent & shareable) |
| Team Collaboration | Requires copy-pasting terminal text | Inline comments & web approval buttons |
| Execution Location | Local workstation thread | Local or remote cloud subagent runners |
| State Recovery | Lost on terminal exit | Synced to cloud session checkpoint store |
Quick reference
- Ultraplan automatically breaks down large engineering goals into ordered, non-conflicting execution phases.
- Web sync URLs provide visual dependency diagrams for non-terminal stakeholders.
- Local terminal sessions can pause and wait cleanly for web sign-off before commencing file edits.
Remember this
Ultraplan transforms planning from an ephemeral terminal conversation into an interactive, team-shared engineering blueprint.
CLI-to-Web Synchronization & Feedback Loops
Launching /ultraplan in the CLI initiates repository analysis. The local agent scans directory structures, imports AST definitions, and generates a structured plan.
Once drafted, the agent prints a web synchronization link:
1$ claude /ultraplan "Migrate payment gateway from Stripe v2 to v3 SDK"2 3Analyzing repository structure...4Drafting implementation plan across 3 components...5 6Plan published to Web UI:7https://claude.ai/plans/p_9012_billing_migration8 9Waiting for team signoff or local confirmation [Press Enter to proceed]...Quick reference
- Feedback entered in the web UI is pulled back into the CLI session automatically upon refresh.
- Inline web comments can request modifications to specific implementation steps.
- Local plan files (
implementation_plan.md) are updated in real time as web edits occur.
Remember this
Bidirectional sync keeps local developer sessions continuously aligned with web team reviews.
Offloading Heavy Tasks to Cloud Subagent Swarms
Once an Ultraplan receives approval, execution can be delegated to Cloud Subagent Swarms. Instead of running heavy TypeScript builds and integration tests locally on your workstation, Ultraplan dispatches parallel subagents to cloud container runners.
Each cloud subagent receives a targeted sub-task (e.g. Subagent 1 updates schema models, Subagent 2 updates API controllers, Subagent 3 writes unit tests), returning isolated pull requests upon completion.
Quick reference
- Cloud execution frees local workstation CPU and memory during multi-hour refactor tasks.
- Parallel subagent swarms execute independent plan phases concurrently.
- Completed cloud PRs are linked directly in the Ultraplan dashboard for review.
Remember this
Cloud subagent execution accelerates large refactoring initiatives by leveraging distributed cloud compute.
Ultraplan Governance & Enterprise Best Practices
To maximize team productivity when deploying Ultraplan across engineering departments:
1. Require Web Sign-off for Critical Repos: Enforce mandatory web URL review for changes affecting core database schemas or payment paths. 2. Keep Plans Modular: Limit Ultraplan goals to 3-5 distinct phases to keep dependency trees manageable. 3. Combine with Worktrees: When running local execution of Ultraplan steps, launch sessions inside dedicated git worktrees. 4. Audit Cloud Traces: Inspect OpenTelemetry (OTel) execution logs for cloud subagents to verify security compliance.
Quick reference
- Modular plans prevent subagent context bloat during long execution runs.
- Worktree isolation guarantees zero file collisions during local multi-phase execution.
- OTel audit traces ensure complete visibility into cloud subagent operations.
Remember this
Governed Ultraplan workflows combine team oversight with the speed of autonomous cloud subagent swarms.
Hands-on Practice: Draft & Review an Ultraplan
Practice using Ultraplan workflows with this hands-on exercise:
1. Launch Ultraplan: In a local repository, run claude and issue /ultraplan "Refactor user authentication service to support OAuth2 scopes".
2. Review Draft: Inspect the generated implementation_plan.md artifact locally in your editor.
3. Add Web Feedback: Open the generated web sync URL (or simulate web feedback by adding an inline comment in the markdown file).
4. Execute Phase 1: Approve Phase 1 and confirm that the agent completes the initial file edits cleanly.
Quick reference
- Confirm that
implementation_plan.mdcontains clear section headings for each refactoring phase. - Verify that the agent pauses at phase boundaries before executing subsequent code edits.
- Check that all modified files pass local syntax and lint checks.
Remember this
Drafting and reviewing an Ultraplan demonstrates how structured planning improves code quality and safety.
Key takeaway
Claude Code Ultraplan elevates software planning from local CLI output to a collaborative, cloud-connected engineering workflow. By pairing local plan generation with web UI team reviews and cloud subagent execution, software organizations can execute complex architectural migrations safely and efficiently.
Practice (20 min): Launch claude in a test repo and run /ultraplan "Refactor auth module". Inspect the generated implementation_plan.md, add a feedback note, and execute Phase 1 to verify clean plan execution.
Related Articles
Explore this topic