Have you ever given an AI a complex coding task?
You press enter and you just sit there. You watch
your terminal freeze up while you visibly age.
Yeah, it's a very specific type of modern agony.
It really is. Well, welcome to the Deep Dive.
Today, we're exploring a massive upgrade to Cloud
Code. It's called Ultraplan. Right. It's a completely
quiet update, but, you know, a huge deal. Exactly.
We're looking at how Anthropic rewired the coding
process. They're taking us out of that agonizing
local queue. They moved us to a parallel cloud
architecture. We're going to examine the hidden
compute costs behind this, too. And we'll look
at a real -world dashboard test. Plus, we have
to cover the crucial limitations you must know.
I got to admit something first, though. I still
wrestle with the anxiety of a frozen terminal
myself. I just sit there wondering if my whole
system just crashed. Oh, absolutely. You just
stare at that blinking cursor. You're entirely
locked out of your own machine. You just hope
the AI is actually doing something productive.
Exactly. You feel totally helpless. So let's
unpack why Ultraplan even exists. It all comes
down to the bottleneck of local planning. Right.
So look at standard local planning first. It
uses one linear agent. That single program. works
step by step inside your terminal. It just types
out its internal thought process. It's doing
this right in front of you. Yeah, and that's
a major problem for complex builds. It produces
a massive wall of scrolling text. You can't easily
review that text at all. You certainly can't
change its mind before it starts writing code.
Because by the time it finishes, you're already
committed. The train has left the station. Exactly.
I mean, if you make a bad structural choice early
on, you pause. You step back. A local AI agent
doesn't do that. It just keeps going forward.
It tries to course -correct mid -build, right?
Yeah, and that's exactly when your project gets
incredibly messy. It writes spaghetti code to
fix its earlier bad assumptions. It's incredibly
frustrating to watch. And I guess that brings
us to Ultraplan. Anthropic decided to ship the
entire planning job to their cloud. Yes, they
used their cloud container runtime for the heavy
lifting. It introduces a multi -agent architecture,
meaning several AI programs working together
simultaneously to solve one problem. Start on.
Instead of one agent struggling alone, the cloud
spins up a team. It creates three parallel exploration
agents, and it adds one dedicated critique agent.
And they all use Opus 4 .6. That's Anthropic's
most powerful AI model available right now. Right.
Beat. Think about the philosophical difference
here. yeah local planning is like having one
really smart person but they're at a cramped
messy desk sweating over a notebook by themselves
getting total tunnel vision but ultraplan is
like a collaborative working session they get
a spacious room with a massive whiteboard they
explore multiple architectural paths at the exact
same time whoa Beat. Imagine three Opus 4 .6
agents exploring your entire code base at the
exact same time. It's staggering. The critique
agent acts like a senior developer then. It steps
in and tightens the whole plan up. And the final
output completely changes your developer experience.
Instead of a chaotic terminal output, you get
an organized web document. Yeah, hosted on Anthropix
interface. Yeah. You see the project context
right at the top. You see a list of files it
intends to create. It's a proper technical brief.
It even shows the final verification steps it'll
run. Sometimes it includes structural diagrams
of the proposed architecture too. And here's
the absolute best part. You're no longer just
a passive observer. Right. You can actually leave
inline comments on this web document. You can
even use emoji reactions on specific parts. You
do all of this before you approve anything. It
separates the thinking phase from the doing phase.
So does this mean the cloud actually writes the
final code for you? No, it just builds the blueprint.
The code generation still happens locally. Got
it. So the cloud plans, but your local terminal
builds it. Precisely. It's a much safer way to
build software. It feels like a much more mature
workflow. But how do we actually invite this
multi -agent team to our project? It requires
a very specific approach. You must explicitly
use the slash command forward slash Ultraplan.
Or I guess you can just include the word Ultraplan
in your prompt. Right, but here's the one strict
rule you cannot ignore. It only works from the
CLI. Meaning the text -based command line interface
on your computer. Yes. If you try to run this
command inside the Claw desktop app. Or the VS
Code extension. Right. And nothing special will
happen. It just quietly defaults to normal sequential
local planning. That feels like a huge trap for
casual users. People probably think the whole
feature is broken. Oh, it's a very common mistake.
You've got to open Claude code directly through
your system's terminal. So if you do trigger
it right from the terminal, what's the workflow?
You type your prompt. You trigger the command.
Claude immediately ships the job out to the web.
And your local terminal doesn't freeze up at
all. Not at all. Your terminal stays completely
free. You can keep running your local server.
You can check your Git logs. Meanwhile, you review
the AI's plan on the anthropic web interface.
You read through the context and leave your critical
comments. You essentially act as the final gatekeeper.
Then, when it looks perfect, you click approve.
And boom! The approved plan teleports right back
to your terminal. It's ready to execute. Exactly.
It completely removes that agonizing waiting
game. What happens to my local environment while
the cloud is doing all this heavy lifting? It
stays completely unlocked and usable so you can
keep working. Terminal stays free. You review
everything separately on the web. Spot on. It
changes everything about the daily grind. We're
going to take a quick break. Sponsor. All right.
And we're back. So we have our terminal back,
which feels great. Definitely. But does this
actually save time in the real world? Let's look
at a side -by -side test from our sources. Yeah,
they ran a test to build out a complex dashboard.
And it wasn't just a simple script. It needed
MRR tracking. Meaning a metric tracking your
monthly recurring revenue. Right. It also needed
ARR tracking. A metric tracking your predictable
annual recurring revenue. Exactly. Plus, it required
a dynamic churn rate calculation. That's the
percentage of paying customers who cancel their
service. Yes. And it needed functional light
and dark mode UI toggles. So a very standard
but heavy full stack build. Both local and Ultraplan
modes started at the exact same time. The results
were genuinely surprising to read. The Ultraplan
side was incredibly fast. It generated the complex
plan in the cloud. It got human approval. It
teleported the blueprint back to the terminal.
And it actually finished building the working
dashboard locally. Wow. It finished the entire
project before the standard local planner even
finished its initial planning phase. Two sec
silence. Better planning literally equals faster
execution. It creates a much clearer roadmap
from the start. Claude wanders significantly
less. It doesn't panic and rebuild sections mid
-task. It compounds the time advantage beautifully.
But we really have to talk about the token tradeoff
here. Right. There's something in the source
material about token usage. At first glance,
this new workflow looks incredibly efficient.
It does. During that dashboard test, standard
local planning chewed through about 131 ,000
local tokens. That's a lot of highly visible
local compute power. But the Ultraplan local
execution used only 82 ,000 tokens. Yeah, and
that's a very big illusion. It looks cheaper
on your terminal screen, but it's not. Ultraplan
simply shifts the heavy compute burden to the
cloud. You just don't see the massive token burn
on your local CLI anymore. Right. Think about
what's happening under the hood. You have three
instances of Opus 4 .6 exploring your code base.
Plus, a critique agent evaluating their work.
That's an incredibly heavy, expensive compute
load. The planning step consumes significant
resources. They're just hidden from your view.
So the 82 ,000 tokens is just the typing cost.
But compute is definitely not free. If Anthropic
is eating the cost of three Opus agents, how
does that work financially? It works because
they wall it off behind a hard paywall. You can't
use standard API billing for Ultraplan. Oh, so
if you try to trigger it through a pay -as -you
-go API setup, it just rejects it. Correct. It
strictly requires a Cloud Pro, Max, or Team subscription.
So are we actually saving tokens or just hiding
the massive cost off screen? We're absolutely
just hiding the cost inside your monthly cloud
subscription. We hide the heavy token cost in
the cloud subscription. Exactly. You're paying
for all that thinking in a different way. Okay.
So before you rely on this tool daily, there
are strict requirements. There are also weird
quirks that'll trip you up. We should definitely
start with the get rule. Your local project must
be synced to Git or GitHub. Right. The cloud
planner absolutely cannot inspect a purely local,
untracked project. If you have a random folder
of messy code on your desktop, it won't work.
If you don't push your changes, the cloud planner
works completely blind. It makes sense from a
security standpoint, though. The cloud agents
can't magically access your physical hard drive
directly. That would be a massive privacy nightmare.
Git acts as the synchronized, secure middleman.
Then there's what the source calls the custom
skills problem. Yeah, the AI makes rapid assumptions.
The source gave a highly specific example of
this flaw. A user wanted architectural diagrams
rendered in an Excalibur style. Meaning a popular
digital whiteboard tool with a hand -drawn style.
Right, but Ultraplan just guessed the user's
intent. It ignored Excalibur entirely and used
Mermaid instead. Mermaid being a purely text
-based tool used for generating technical charts.
Exactly. So the technical output was functionally
correct. Yes. But it was absolutely not what
the user wanted visually. The cloud AI doesn't
know your internal design standards. It defaults
to what's computationally easiest for it. But
the fix is actually very simple. You use that
interactive web review step. You just leave a
direct inline comment on the plan. You specify
your exact internal tools. Right. You type a
comment like, please use... Scala draw for all
database diagrams. Let's outline the other weird
quirks. First, there's a hard compute cap. Yes.
You face a strict 30 -minute cloud compute cap
per planning session. Which, honestly, is plenty
of time for most standard application features.
True. But you might encounter random authentication
errors, too. They pop up occasionally, but they
usually disappear if you just retry the command.
Web token transparency is also very low. You
don't really know how much cloud compute you're
burning. Honestly, the whole thing still feels
slightly preview -ish. It's powerful, but rough
around the edges. There's a great pro tip from
the source here. Keep your planning back and
forth in the cloud environment. But you should
open a clean local session strictly for the execution
phase. Right, so the context window doesn't get
cluttered with discarded ideas. If it remembers
all the bad ideas, it might weave them into the
final code. Definitely. Why does a cloud planner
care if my code is on GitHub? Because the cloud
agents need a secure bridge to actually see your
files. The cloud agents need a bridge to see
your local files. Precisely. No bridge means
no multi -agent plan. With all those quirks in
mind, should you use it for every prompt? Absolutely
not. You really need to know when to skip this
workflow entirely. Let's break down those specific
use cases. When do you completely ignore Ultraplan?
You must skip Ultraplan for small, isolated bug
fixes. Don't use it for simple spelling typos.
Don't use it for quick localized CSS style changes
either. It's way too heavy of a process for that.
You don't need a multi -agent whiteboard session
to change a button color. It's completely unnecessary
overhead. But you should absolutely use Ultraplan
for deep structural changes. Use it for complex,
multi -file features. Use it when you're doing
full application builds from scratch. Basically,
when the planning quality directly impacts the
execution quality. If the architecture matters,
use the cloud. I really love the Abraham Lincoln
quote they included in the source material. Right.
Give me six hours to chop down a tree and I will
spend the first four sharpening the axe. It perfectly
describes this new AI coding workflow. Jumping
straight into rapid execution is no longer a
viable strategy for complex builds. The AI types
fast, but if it types the wrong thing, you just
fail faster. The architectural plan needs to
be flawless before you strike the tree. Is there
any real danger in using Ultraplan for a tiny
bug fix? Not a danger, but it's overkill and
wastes your limited cloud compute time. It's
overkill and wastes your 30 -minute cloud compute
time. Exactly. Save the heavy multi -agent lifting
for the truly heavy engineering projects. Two
sec silence. Let's step back and look at the
big idea here. The future of coding agents isn't
just about typing syntax faster. No, it's moving
rapidly toward deliberate, highly structured
planning workflows. It's deeply about mandatory
human review occurring before any execution happens.
The process is shifting. It's moving away from
blind experimentation. It's moving toward cleanly
separated thinking and doing. The AI swarm does
the heavy architectural thinking. You step in
and do the high -level directing. Then the local
machine does the tedious doing. It's a profound
shift in software engineering. Deep. So here's
a provocative thought for you to take away and
mull over. If AI is evolving into a team of planners
rather than just a fast typist, how does your
role change? It's a deeply important question
about our fundamental identity as developers.
Are you even a coder anymore or are you becoming
an art director for software? An art director
doesn't paint every single brushstroke. They
set the grand vision. They review the messy drafts,
make sure your repo is synced, spin up Ultraplan
and see how it feels to manage the team. It's
a whole new professional mindset to embrace.
It really is. Remember, you don't have to just
sit there and watch your terminal freeze anymore.
Send the heavy work up to the cloud. Grab a coffee.
And review the architectural blueprint like a
true boss. Take care out there.