Plan in the cloud and review in the browser with Ultraplan

The idempotency plan turned out bigger than expected — a new table, a migration, header validation, a race-condition path, and a backfill for in-flight keys. Scrolling all of that in a terminal and replying in one block is a clumsy way to review a document this size. What you’d really want is to read it like a design doc: comment on this section, flag that step, react to the parts that are right. That’s exactly the surface Ultraplan adds — it runs plan mode in the cloud and gives you a browser to review the result.

Hand the planning to the cloud

You launch it from your local CLI three ways, and the third is the one that fits our story:

# explicit command
> /ultraplan make the charge endpoint idempotent, handle the in-flight race

# or just say the word in a normal prompt
> ultraplan the idempotency change end to end

# or escalate a local plan you've already started
  How would you like to proceed?
  ...
  5. No, refine with Ultraplan on Claude Code on the web   ← sends your draft up

That last path is the natural one here: you already researched the plan locally in the earlier lessons, and now it’s grown big enough to want the richer surface — so you send the draft you have up to the cloud rather than starting over.

Once it launches, Claude drafts in the cloud while your terminal stays free for other work. The prompt input shows a small status — researching, then needs-your-input if it has a question, then ready when the plan’s done. You don’t sit and watch; you go do something else and come back when it’s ready. (Run /tasks to find the session, open it, or stop it.)

Review it like a document

When the status reads ready, you open the session link and the plan appears in a proper review view — not a wall of terminal text:

Inline comments — highlight any passage and leave a note for Claude to address, the way you’d comment on a pull request
Emoji reactions — react to a section to signal “yes, this” or “I’m worried about this” without writing a paragraph
Outline sidebar — jump between sections of a long plan instead of scrolling

Ask Claude to address your comments and it revises and re-presents. Iterate as many rounds as the change needs — all still in the cloud, all still before any code is written.

Choose where it builds

Here’s the part that makes Ultraplan more than a nicer editor: when the plan’s right, you decide where it runs, from the browser.

Execute on the web — Claude implements it in the same cloud session; when it’s done you review the diff and open a pull request from the web interface. Nothing ever has to touch your machine.
Teleport back to your terminal — bring the finished plan home to build locally, with full access to your real environment. Your terminal shows an Ultraplan approved dialog with three choices: implement here (inject the plan into your current conversation and continue), start new session (clear the conversation and begin fresh with only the plan as context — the clean-window move from the last lesson), or cancel (save the plan to a file and stop — Claude prints the path so you can return to it later).

That last detail closes the loop on persistence: even if you walk away without building, Ultraplan drops the plan to disk and tells you where. The plan is never trapped in a session you can’t get back to.

Where this leaves you

Step back and look at the discipline you built across this chapter. The instinct it installs is the valuable part: on anything non-trivial, you no longer let the agent start editing on a guess. You make it research and propose first — in the terminal for a quick plan, in the cloud for a big one — you review the decision while it’s still cheap to change, and only then do you let it build, into the exact build mode the work deserves. That habit, more than any single command, is what turns a risky agent into a dependable one.

The next chapter steps back from any single session to the thing that makes the agent know your project at all across every session: rules and memory — the CLAUDE.md files that give it the standing context it would otherwise rediscover from scratch every time.