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.