Run the plan in the cloud with Claude Code on the web

This page is about where a planned build can run when your laptop is not the right place for it. It assumes a plan already on disk and pushed with the repository; the running example is docs/idempotency-plan.md, the file the plan-persistence lesson writes for a fix to the payments service (the small TypeScript service this course uses as its running example): record an idempotency key after a payment completes rather than at first check. Any committed plan file works the same way.

It opens with a correction. This page’s address still says ultraplan because the course keeps its routes. That was a real feature: a research preview that sent a plan to Anthropic’s cloud and let you comment on it section by section in a browser.

Anthropic has removed it. The removal notice lists everything that went away - the /ultraplan command, the keyword trigger, the plan-dialog option to refine on the web - and points at the two replacements this chapter already teaches: local plan mode, and cloud sessions for work you review in a browser. The rest of this page is the second replacement, which is a general surface rather than a plan-specific one.

What a cloud session is

A cloud session is Claude Code running on Anthropic-managed infrastructure instead of your machine. It keeps running after you close the laptop, and you can steer it from any device. The web reference describes it as a research preview for paid plans, with requirements to check before you lean on it: sign-in with an Anthropic account (an API key alone is not enough), repository access through the Claude GitHub App or /web-setup, and an organization Owner enabling remote sessions. It is not available through Bedrock, Vertex, or other third-party providers.

Start the session where the code lives

From a terminal inside the repo, claude --cloud "task description" starts the session. The cloud VM clones your repository’s GitHub remote at your current branch, so push your local commits first, or the session builds on stale code. You can also start from the other end: claude.ai/code in a browser, the Code tab in the mobile app, or the Cloud option in the desktop app.

For a planned change, the docs describe a pattern that fits this chapter exactly: plan locally, refine, commit and push the plan, then execute it in the cloud. Adapted to the plan file, the invocation looks like this - the pattern is documented, the instance is ours:

claude --cloud "Read docs/idempotency-plan.md and implement it.
Run the project's checks, then open a pull request."

The session is a full Claude Code session with the repository, so it works the plan’s checklist the way a local session would. If the build needs a toolchain in the VM, cloud environments carry network settings, environment variables, and setup scripts for exactly that. Dependencies belong in the plan or the environment, not in luck.

Review the change in a browser

While it runs, the session is a URL. Open it from any device and the work arrives as a review surface: a diff view with per-file additions and deletions, inline comments you leave on specific lines and send with your next message, a compare-against-branch view for context, and pull-request creation from the same screen. For the idempotency fix, this is the review-like-a-document shape the old feature promised, except the object under review is the working diff, and your comments are anchored to lines of it.

Inside the session, the commands you know mostly behave: /compact and /context work, /clear does not - the documented advice is to start a new session from the sidebar instead. And nothing here is limited to one at a time: multiple claude --cloud invocations run in parallel, each in its own VM, so a planned change and its follow-ups can execute side by side.

Bring the session home

When the cloud session holds work you want to continue locally, teleport it. The options, all documented: claude --teleport for an interactive picker, claude --teleport <session-id> for a direct pull, /teleport or /tp from inside an existing CLI session, /tasks followed by t, or the browser session menu’s Open in Terminal. The requirements are the fine print: a clean git state on your machine, the same repository (not a fork), your branch pushed, and the same claude.ai account.

Teleport is not --resume. Resuming replays local history; teleporting pulls a cloud session’s state into a terminal that then continues independently. The practical reading is that nothing gets trapped: a build that outgrew the terminal can be brought back to it, context and all.

Where the chapter leaves you

Step back from the idempotency fix and look at the discipline this chapter installed. On anything non-trivial, the agent no longer starts editing on a guess. It researches in a mode that blocks edits, hands you a proposal you can check against source, takes your corrections while they still cost sentences, gets approved into the build mode the work deserves, and leaves the plan on disk, built locally or in a cloud session reviewed wherever the change reads best.

Notice what still happens at the start of every one of those sessions, though: none of this knowledge persists by itself. That is the course’s context principle at work - what information is available when the agent decides. The next session does not know the test command, or how money amounts are represented, or why the helper’s completion marker exists, until somebody tells it again. There is a mechanism for exactly that, and the next chapter is rules and memory: the project’s standing explanation of itself.