28:13Sean Kochel · Tutorial
7 Claude Code Tools To Stop Wasting Tokens
A 28-minute practical breakdown of seven tools that attack token waste at session startup, during input, and in model output.
May 27thThe argument in one line.
Opus 5.5 rewards a goal with a finish line over step-by-step supervision, so the skill that matters now is writing verification criteria instead of walking the model through a plan.
Read if. Skip if.
READ IF YOU ARE…
- You already use Claude Code daily and your prompts still read like the plan, implement, test habits you built on older models.
- You run long multi-step tasks and keep getting interrupted for status updates you did not ask for.
- You are deciding between effort levels or between Claude and a competing model and want a working default instead of a benchmark chart.
- You do knowledge work with AI, not just code, and want to see what a research or synthesis prompt looks like when it works.
- You have a migration or a refactor you have been avoiding because the export format does not match the target.
SKIP IF…
- You have never used a coding agent. This assumes you already know what a CLAUDE.md file and a sub-agent are.
- You want a review of whether Opus 5.5 is good. The verdict is settled in the first two minutes and the rest is operating instructions.
- You are looking for API or pricing engineering. Cost comes up once, as a flat subscription recommendation.
The full version, fast.
Opus 5.5 thinks by default and holds a long task without losing the thread, which breaks the old habit of planning, implementing, and testing in supervised steps. The working pattern is goal-driven: state the goal, every step, the constraints, the finish line, and how success gets verified, all in one message, then let it run. Four habits keep that run productive: start at medium effort, write rules for when to keep going and when to stop, keep the task list in a file that survives compaction, and demand an evidence bundle plus an honest list of what could not be confirmed. Five case studies show the pattern holding across front-end work, a full blog migration, weekly synthesis of 567 bookmarks, visual research reports, and code-generated explainer videos.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 00:37
01 · Cold open
The announcement post on screen, the claim that this is the new favorite model, and the warning that using it well takes a different approach.
00:37 – 05:37
02 · What makes Opus 5.5 different
Four differences: frontier intelligence at lower cost, goal orientation, thinking that is always on and self-adjusting, and a large jump in writing and communication quality.
05:37 – 06:49
03 · The four-part system
The structure for the rest of the video: setup, goal, let it cook, check results.
06:49 – 10:52
04 · Part 1: Setup
Why medium is the right default effort level, when extra is worth it, auditing old prompt files for anti-patterns, and why fast mode is probably unnecessary.
10:52 – 18:03
05 · Part 2: Goal
The anatomy of a goal prompt walked through on a real migration: goal, multiple steps, constraints, finish line, verification criteria. Plus follow-ups mid-run, exploring sources first, and four quickfire prompting tips.
18:03 – 23:27
06 · Part 3: Let Claude cook
Five tips for long runs: traffic light rules in CLAUDE.md, working inside Claude Projects, keeping the task list in a file, splitting work across sub-agents with evidence checks, and giving the model a time budget.
23:27 – 26:09
07 · Part 4: Check results
Three verification habits: demand an evidence bundle, ask what it needs from you and read that first, and ask it to flag what it could not confirm.
26:09 – 26:33
08 · Case studies intro
Framing for the five real projects that follow.
26:33 – 29:31
09 · Case study 1: Front-end UI
The same page prompt given to two models, compared on the email gate design and the closing call to action.
29:31 – 35:46
10 · Case study 2: Blog migration
Moving a personal site and blog off Squarespace onto Cloudflare from one prompt: 39 posts, 13 categories, 68 URLs checked at three widths, with a constraint that keeps restyling easy later.
35:46 – 39:13
11 · Case study 3: Writing and synthesis
Two models given the same weekly digest of 567 saved bookmarks, compared on signal density, comprehension, and how many themes each one found.
39:13 – 43:20
12 · Case study 4: Research and video prep
A three-step research process ending in a visual FigJam board instead of a markdown report, run from one dense prompt that calls a saved skill.
43:20 – 50:56
13 · Case study 5: Explainer videos
One short prompt producing three competing animated explainers built in HyperFrames, Manim, and Remotion, plus a vertical social cut, with the output played back on screen.
50:56 – 52:32
14 · Get the Max plan
The closing recommendation to run Opus 5.5 on the $200 per month Max plan, a quoted endorsement, and the subscribe ask.
Lines worth screenshotting.
- Opus 5.5 at medium effort matches or exceeds the previous Opus at high effort, so the default setting is already enough for most work.
- Anthropic found Opus 5.5 at its lowest effort level caught more bugs than the prior Opus at a higher effort level, with fewer false alarms.
- Thinking is always on, so prompt lines like think carefully and think step by step are dead weight you should delete from your instruction files.
- A restart costs more than a correction, so type the follow-up while the model is still working instead of starting the task over.
- Telling a model when to keep going matters as much as telling it when to stop, because premature check-ins waste the longest runs.
- A task list kept in a file survives the context window and compaction. A to-do list held in conversation does not.
- Giving the model a time budget does not cost quality: budgeted agent teams matched single-agent answer quality and finished considerably sooner.
- Asking for an evidence bundle of screenshots turns verification into a ten-second check instead of re-running the test yourself.
- Asking the model to mark what it could not confirm, and say where it looked, turns a confident summary into an auditable one.
- Generic style instructions like avoid a generic AI look mostly swap one default for another. Name the specific patterns you do not want.
- Ask for the finished spreadsheet or document rather than an outline, because the first draft now needs less editing than the outline used to.
- A Squarespace export written for WordPress is no longer a blocker, because the model will map one format onto another without being told how.
- Across 567 bookmarks, the summary that named the companies and the releases beat the one that described the trend in the abstract.
- When models are cheap and capable, the scarce inputs become taste, context, distribution, and judgment about what to build.
- One prompt carrying the goal, the steps, the constraints, and the verification criteria replaces an afternoon of back-and-forth.
Write the finish line, then step back.
WHAT TO LEARN
The model now runs long enough that your job shifts from steering each step to writing a goal it can check itself against, and then proving it did.
02What makes Opus 5.5 different
- Thinking is always on and adapts by itself, so prompt lines telling the model to think carefully or step by step no longer do anything.
- The model is goal-oriented, which replaces the old plan, implement, test loop with set a goal, delegate it, verify the result.
- Writing quality matters beyond prose: a model that reports clearly in plain language makes a long session far easier to follow.
04Part 1: Setup
- Medium effort is the right default, because Opus 5.5 at medium matches or exceeds the previous Opus at high for far less money.
- Save the highest effort setting for genuinely hard tasks rather than using it as a reflex, since you pay for reasoning you did not need.
- Old prompt files carry anti-patterns like be maximally thorough and mandatory procedures, and an audit pass strips what now hobbles the model.
05Part 2: Goal
- A good prompt has five parts: the goal, every step you want, the constraints, the finish line, and the verification criteria.
- Put all of it in one message rather than drip-feeding steps, because the model holds long multi-part work better than it used to.
- If you forget something mid-run, type the follow-up while it works, since restarting costs more than correcting.
- On loosely specified tasks, tell the model to explore its sources before acting, including sources your request never mentioned.
06Part 3: Let Claude cook
- Write rules that say when to keep going as well as when to stop, because stopping for permission wastes a long run as surely as never stopping.
- Keep the task list in a file so it survives the context window and compaction, and so you can read progress without interrupting.
- Split large audits and migrations across sub-agents, then make each one hand back evidence that the work was actually done.
- Give the model a time budget. It paces itself to finish inside the budget, usually early, without losing answer quality.
07Part 4: Check results
- Ask for an evidence bundle of screenshots or recordings so you can verify in seconds instead of re-running the test yourself.
- When a long run ends, read what the model needs from you first, before the rest of its summary.
- Ask it to mark anything it could not confirm and say where it looked, which turns a confident report into an auditable one.
09Case study 1: Front-end UI
- Running the same prompt through two models and comparing first drafts tells you more about fit than any benchmark table.
- Judge output on the ideas you did not ask for, not just on compliance, because the better design here was one nobody specified.
- A call to action that blends into the page fails even when the copy is good, because contrast is what gets it noticed.
10Case study 2: Blog migration
- A single prompt moved an entire site, 39 posts and 13 categories, between platforms in one day of work.
- The constraint that colors, fonts, and spacing all live in one file is what makes a migration safe to restyle later.
- An export written for the wrong target platform is no longer a reason to abandon a plan, since the model maps formats itself.
11Case study 3: Writing and synthesis
- Across 567 bookmarks, the stronger summary named the companies and releases instead of describing the trend in the abstract.
- Specificity is what to grade summarizers on, not length and not how many themes came back.
- When models get cheap and capable, the scarce inputs become taste, context, distribution, and judgment about what to build.
12Case study 4: Research and video prep
- Research is three steps, not one: gather sources, write a cited report, then turn that report into something visual.
- Ask for diagrams instead of prose when you need to absorb a result, because images are faster to scan and compare.
- A dense prompt that names a saved skill, a topic, and a required output format does more work than a long vague one.
13Case study 5: Explainer videos
- Naming the libraries and asking for three competing versions gets you a comparison instead of one answer you cannot judge.
- Pointing the model at a live page for context produced matching fonts and colors without a single style instruction.
- The strongest explainer showed the thing working rather than describing it, which is the gap between a demo and a definition.
14Get the Max plan
- A flat monthly plan changes which tasks are worth attempting, because run length stops being a cost decision every time.
- Pick the plan around how you actually work, since a fast cheap model only pays off if you are not rationing it.
Terms worth knowing.
- Effort level
- A setting that controls how much reasoning the model spends on a task, typically low, medium, high, or extra. It is the main dial for trading cost and speed against thoroughness.
- Adaptive thinking
- The model deciding for itself how much to reason on a given request, rather than waiting for a thinking mode to be switched on manually.
- Goal-driven development
- A working pattern where you state the desired end state and how it will be verified, then delegate the whole task, instead of approving a plan and supervising each implementation step.
- Traffic light rules
- Instructions in a project file that tell an agent when to keep going on its own, when to pause and ask, and when to stop entirely. Named for the green, yellow, and red signals they mimic.
- Evidence bundle
- Screenshots, recordings, or logs the agent produces to prove it actually checked its own work, handed back alongside the result so you can verify without repeating the test.
- Sub-agent
- A separate agent thread spawned to handle one slice of a larger task in parallel, with its results reported back to a coordinating agent.
- Compaction
- The automatic summarization that happens when a session outgrows the context window. Anything not written to a file can be lost or blurred when it runs.
- Claude Projects
- A way of working in Claude Code where a coordinator agent manages multiple worker threads and session state for you, rather than you driving one conversation.
- Fast mode
- A setting that trades some reasoning depth for faster output. Available as a research preview on Opus 5.5 and, per this video, rarely needed at medium effort.
- Manim
- An open-source Python animation library originally built for mathematical explainers. It produces the chalkboard-style motion graphics associated with the 3Blue1Brown channel.
- FigJam
- Figma's whiteboard product, used here as the output surface for a research report rendered as a visual board instead of a markdown document.
- MCP
- Model Context Protocol, an open standard for connecting AI agents to external tools and data. A tool without an MCP server or CLI is a dead end to an agent.
Things they pointed at.
08:59tool/checkup-prompt-audit skill
10:24toolFast mode (research preview)
43:40linkDidi Das guide on instructional video generation
45:03toolHyperFrames
Lines you could clip.
04:22
“Opus 5.5 always thinks, and it has something called adaptive thinking, which means that it controls how much it thinks.”
18:03
“They function like traffic lights. They tell it when to stop. They tell it when to ask. And they also tell it when it can keep going.”
14:56
“The reason why they recommend doing this is because a restart actually costs more. So rather than restarting, just tell it to correct course.”
23:13
“Claude Opus 5.5 pays attention to information about elapsed time, and so it's useful to give the model a time budget. The model paces its work to finish inside the budget.”
35:10
“This is one of the projects that I was dreading for a long time, migrating my blog from Squarespace to a self-hosted site in Cloudflare. And thanks to Opus 5.5, I was able to do this in literally one day.”
38:07
“When the models are cheap and capable, the scarce inputs become taste, context, distribution, and judgment about what to build.”
17:35
“General instructions such as avoid a generic AI look mostly swap one default for another. Name the styles that you don't want.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
metaphorstory
Cloud Opus 5 .5 is my new favorite model. It's intelligent, it's fast, and it's really cheap. But it's different from other models that you might have used, both from Anthropic, as well as other providers like OpenAI and Grok.
And so using it to its full potential can be tricky. That's why in this video, I'm going to teach you everything that you need to know about Cloud Opus 5 .5 and how to get the most out of it. We're going to cover what makes Opus 5 .5 different.
how to use Opus 5 .5 well, and I'll close by showing you some case studies of me using Opus 5 .5 on real -world projects in my business. So let's get started with the first topic about what makes Opus 5 .5 different. The first thing that you need to know is that it's a frontier -level intelligence model in the sense that it gives you the same intelligence as what you'd get from a Fable 5 .5 or a GPD -6 Astra level, but...
It's both faster and cheaper. One thing to notice is that you can compare Opus 5 .5 to the previous best -in -class model from Anthropic, which was Fable 5 .1. And you can see on most tasks, Opus 5 .5 actually outperforms Fable 5 .1.
The second thing to note is Opus 5 .5 versus the best -in -class model from OpenAI, which is GBD6 Astra. And we can see here on most tasks, Opus 5 .5. also beats GPT -6 Astra.
And so this is a big deal. So the second thing to know about Opus 5 .5 is that it is goal oriented. The reason why that's important is because this affects how we prompt and how we actually use Opus 5 .5 as a model.
So let's talk about the before and after, because I think this is the best way to understand why Opus 5 .5 is different and how the way that we use it needs to change accordingly. So before You'd probably follow this system when you're building with AI.
You'll first start with planning. Then once you're happy with the plan, you'll go and implement it. And then once you're happy with the implementation, you'll ask the model to test.
And that would be the end of building something, whether it's a new application, a new feature, or even doing knowledge work where you're asking the model to create documents or slides or doing things for you. With Opus 5 .5, because it's so goal -oriented, things are different. So instead of making a plan and instead of walking through the implementation with the model, with Opus 4 .5, you set goals.
And so you adopt this method of development that I call goal -driven development, which has three different steps. The first one being setting a goal. The second one being actually delegating that goal to the model.
And then thirdly, rather than just testing, you're actually verifying success. So the key difference here is that with Opus 5 .5, you'll be setting goals. And we'll talk later in the video about how to do this well.
But this is a mindset shift that you need to get into in order to get the most out of Opus 5 .5. The third important thing about Opus 5 .5. is that thinking is always on.
Now, those of you who've used other AI models might remember where you would have to actually turn thinking on manually. For example, in earlier Opus or Sonnet models, we would have to have a thinking mode where thinking gets turned on manually. But now with Opus 5 .5, thinking is always on.
And so there's a couple of things that change here. The first one that was recommended by Anthropic. is to stop telling it to think hard.
So you no longer need to write things like, for example, think carefully, think step -by -step, and similar lines from your claw .md or your prompts. And the big difference here is that Opus 5 .5 always thinks, and it has something called adaptive thinking, which means that it controls how much it thinks. And we're going to get into effort and reasoning, which is really the knobs and dials that we have in order to control how much Opus 5 .5 thinks.
And so this is the other big change is that this is one of the first models where thinking is always on. There's no toggle for you to switch. It's a bit simpler to use in that way, but it also means that the way that you instructed needs to be different.
And then finally, a bonus thing to know about Opus 5 .5 before we get into the tips about how to use it well, is that Opus 5 .5 is much better at writing. But more importantly, that also means that it's much better and much more of a joy to actually communicate with and use, which is super important. When you're using a model, you're actually communicating with it.
And so how it communicates with you really makes a big difference on how good the experience is to use the model. And so from a user experience perspective, this makes Opus 5 .5 much better to use. From the announcement post, Anthropic mentioned that the differences in Opus 5 .5 is that it communicates more naturally.
And it gives you the most important information upfront and it follows the writing rules that it gives you, which makes longer sessions easier to follow. I actually have a case study where I compared Opus 5 .5 to GPT -6 on writing. So it's actually writing me a weekly report that's synthesizing hundreds of sources together and looking for themes.
So look out for that in the case study section. But this was one of the big things that inspired me to trust Opus 5 .5 with writing and communication tasks. And that brings us to the end of section one.
And we're going to go into how to use Opus 5 .5 well in Cloud Code, which is the second section in this video. And what I've done is I've read everything there is about how to use Opus 5 .5 well. I've read the anthropic docs.
I've read the guides about getting the most out of Opus 5 .5 in Cloud and Cloud Code. And I've also used... Opus 5 .5 on a ton of different tasks.
And so what I've done is actually broken down the tips and advice about how to use Opus 5 .5 well into four parts. And this also summarizes how to use Opus 5 .5 well. And so for each of these parts, we're going to get into more details.
But at a high level, there's four parts that you need to be aware of. The first part is setup. The second part is goal, where we'll talk about how do you actually set goals well and how do you work in a goal -driven way.
The third part is letting Claude cook. So this is actually the easiest part. We just step away, but there's actually a few things that you need to do in order to give instructions in order to let Opus 5 .5 cook to its maximum capability.
And then finally, it's about checking results. And so this is the verification part. And how do you actually set instructions to verify correctly?
And then how do you actually get Opus 5 .5 to flag and let you know if there's things that you need to do? Let's get into the first topic, which is setup. Now, the first question that you're probably asking around setup.
is what effort level to use. Now, we heard that Opus 5 .5 is a model that always has thinking on. And so the natural question is, how do you actually set the right level of thinking?
And effort is the best dial that you have to set the right level of thinking. Over here in the Anthropic Docs, it actually talks about effort being the main control for how much Clore Opus 5 .5 thinks. And its recommendation is to start at medium, which is the default that Opus 5 .5 comes with in cloud code.
And the reason being is that Opus 5 .5 at medium actually matches or exceeds Opus 5 at high. There's also another case that they found where Opus 5 .5 at its lowest effort level. caught more bugs than Opus 5 at a higher effort level with fewer false alarms.
So this is really great. And it's the reason why my recommendation and my default is actually to keep Opus 5 .5 on medium. I think this is the best place to start.
You get very in -depth reasoning from Opus 5 .5, but it's also super fast and also super cheap. So this is the setting that I would recommend starting with. The other setting that I use a lot is Opus 5 .5 on extra.
I use it for my hardest tasks. So if I want something with extra attention to detail or super thorough reasoning, I use extra for that. But most of the time I'm just on Opus 5 .5 medium and that is the default that I would recommend.
And the cool thing to note is that you can actually get really good results. So if you look at the medium level of reasoning and I want to compare. Opus 5 .5 and GPD 6 Astra here.
If you look at Opus 5 .5 on medium level of reasoning, you're getting this roughly a similar level of output as GPD 6 Astra, but your cost per attempt is a lot lower than you would be with GPD 6 Astra for any of the reasoning modes and any of the effort levels that you're using for that. The second thing to know about setup.
is to actually update your old prompts and skills with a skill that they have called checkup prompt audit. So let's explore what is checkup prompt audit. This is from Lance Martin, who works at Anthropic.
He mentioned that this skill checks your skills, your agents .md, your cloud .md, your prompts. and removes anti -patterns that hobble frontier models. It removes things like thoroughness and emphasis boosters.
So things like be maximally thorough, critical, very important. You might've seen these in your cloud instructions previously. Another one is mandatory procedures, stale examples, and contradictory rules.
This is a good practice to talk about how do we actually get our prompts and get our previous files optimized in order to be used with Cloud Opus 5 .5. So it used to be called called Claude API prompt audit, but it was kind of confusing.
And so they announced that they changed it to check up. prompt audit you type slash checkup prompt audit and then i said run this on all skills in the ac skills repo which is where i keep all my skills and make a pr with suggested updates so this is an easy way to update your skills your claw .md your save prompts that you use this is another recommended thing that i'd run to make sure that we're setting up your project for success with opus 5 .5 very quickly the final thing before we move to part two is around fast mode And my takeaway here is it exists.
You probably don't need it. So fast mode is available for Opus 5 .5 at launch as a research preview. For context, I use fast mode in Codex and with GPT -6 Astra a lot.
Always have fast mode on in Codex, but with Cloud Code, I've never felt the need for fast mode. So if you keep Opus 5 .5 on medium, you probably won't need fast mode. So again, it exists, but you probably don't need it.
So that brings us to part two. of how to get the most out of Cloud Opus 5 .5 and how to use it well. And this is a big one because it's about goals.
The advice that the Anthropic team gives is to say what done looks like and then let it run. And so how do we do this properly? We give the whole task in one message.
We name the finish line, like for example, all the tests should pass or every endpoint is migrated. And then we . And the reason why that works is because Opus 5 .5 keeps going on long multi -part work better than previous models.
What I wanted to actually do is show you a real example of me using this on a project and point out the different parts that I actually implemented. And so the first part is giving it a goal. So for this project, I'm actually going to show you this in the case study section where I was migrating my personal website and blog at aftaro .com over to Cloudflare from where it's currently hosted on Squarespace.
And so what I did is I said, please go ahead and build a duplicate version of aftaro .com. So that's the goal. So again, stating what is the end goal.
And then I gave it multiple steps. So I gave it a bunch of different things to do. all in one message.
I said, the main things to have are the start here and the blog. I also need you to do an update of the contents of my site on the start here page, as well as to point to my AI with Aftar YouTube channel, which is what you're watching right now, and the new AI native builder newsletter. And then you also need to update the about me section from the latest from my LinkedIn as well.
So I've given it like six or seven things to do there. And that's all part of the initial prompt. And then very importantly, I also gave it some constraints.
So I told it to duplicate the site. But I wanted to do it in a way where I can actually update the design and look and feel of the site later, because this is something I want to do, but I don't want to do it right now. And so I told her to plan and implement the initial build of the site and its content with that constraint in mind.
So I think this is another important step. So in addition to giving the goal and the multiple steps all in one place, having some constraints about how should you think about building and what other things that you need to be constrained by in going about achieving that goal. And then finally, I gave it some details about what the finish line should be and verification criteria.
So I said, the finish line is you give me a preview link to review. So I have it already set up with Cloudflare. And so it's going to give me a Cloudflare preview to review.
And then I said, it goes without saying, but test on mobile and desktop. as part of the verification process. And so I gave it verification criteria.
So once it's achieved the goal in order to verify, it should test on both mobile and desktop. So again, these are the main parts of goal -driven development and how to actually prompt well. Another prompt that I wanted to show you.
is an example of this goal -driven development from the Anthropic blog, which is an example of migrating from one system to another. So it's funny, both of these are about migrations. But in this case, they mention the articulation of the goal.
So migrate the payments endpoint from the old client to the new one. So that's a goal that it's trying to achieve. Then they have a definition of done, which is very important.
Again, every endpoint uses a new client, et cetera, et cetera. And then they also have some information about when to stop. So stop and ask me only if a test fails for a reason you can't explain.
We're going to get into how to actually instruct Opus 5 .5 about when to stop and when to ask you for input in the next section. The second piece of advice about goals is to pepper cloud Opus 5 .5 with follow -ups. If you, for some reason, don't put all the steps that you wanted to execute in the first message.
What you can do is type a follow -up while it works. So don't be afraid to just give it more and more things to do. The language that I'm using here is peppering it with follow -ups.
And so if you forget about something, if you want to add a new step or a new task that it needs to do mid -run. type of follow -up while it works. The reason why they recommend doing this is because a restart actually costs more.
And so rather than restarting, just tell it to correct costs or tell it to do an additional thing. And then another pro tip is something to include in your prompts when you're doing things that require exploration or workflows that have multiple sources of context. And that is to ask Cloud to explore its sources first.
This is from the Cloud Code docs where they said, on loosely specified tasks, it helps to tell the model to look through the relevant sources before acting. And this is an example that they give where it says, before taking any action, explore broadly with two calls. And this is a case where it says, listen, open the emails, documents, spreadsheet tabs, and records across the available apps that could be relevant to this task, including ones that the task does not explicitly mention and use what you find.
So again, if you're doing knowledge work, you'll see examples in the case study section of some of my knowledge work workflows that I've tested Opus 5 .5 on. This is another huge thing. to include in your definition of the goal, asking Opus to explore its sources first.
Before we move on to part three, I want to give you some quickfire tips for prompting Opus 4 .5. The first one is in your prompt, rather than asking for an outline, ask for the actual file that you want. So this is for knowledge work.
It says ask for the file, not for an outline. So you can ask for particular spreadsheets, documents, whatever formats that you want. And the spreadsheets and documents that Opus 5 .5 makes needs less editing.
Just ask for what you want and trust the AI with more scope. The second one is to use Opus 5 .5 and to ask it to find mistakes in long documents or presentations. And this is useful because it pays more attention to detail than prior Opus models.
And so that's a second quickfire tip. Thirdly, it's much better at reading image input. So give screenshots, charts, diagrams, or slides, and Opus 5 .5 can read these more accurately and it needs no extra steps to do it.
So rather than having tool calls and stuff like that, it just does it out of the box. And then finally, for those of you who are doing a lot of UI work, a quick tip to note is around how Opus 5 .5 deals with UI. So it says Opus 5 .5.
falls back on a few default styles and general instructions such as avoid a generic AI look mostly swaps one default for another. And so the solution to this is actually to name specific patterns to avoid. From the Opus 5 .5 usage guide, it says to name the styles that you don't want.
And so to list specific patterns that you don't want or that you want that works much better. So for example, in the prompt, they say build a personal website and don't use cream or off -white. Don't use italic accents with words and headings.
Don't use numbered section labels or pearl -shaped buttons. So this is a prompt that you can copy and paste if you want to avoid that as well. So part three of how to use Cloud Code well is the, in theory, the easiest part, letting Cloud cook.
But there's actually five tips that I recommend in order to get the most out of letting Cloud cook and letting it do long runs. And the first of those tips is what I call traffic light rules. So the reason why they're called traffic light rules is because they to Opus 5 .5.
So they tell it when to stop. They tell it when to ask. And they also tell it when it can keep going.
And these are the sorts of rules that you should put in your cloud .md file. One of the reasons this is important is that Opus can work for a long time on one task. And so knowing when it should keep going and preventing it from stopping prematurely to give you updates is very important.
And then also what you want to do. is tell it when to stop explicitly so it doesn't go about doing things that you might not want it to do. So here's an example prompt that is recommended for traffic light rules, where it says, when a step doesn't need my input, keep going, put status notes in the same message as the next action.
And then here's the stop part where it says stop and ask only when you can't continue without me or before anything destructive like deleting data. force pushing or anything outside this repo. So that's an example of the traffic light instructions that you can copy and use.
And again, the goal of these is to make sure that Claude can work for the longest time possible within your constraints about what is safe and what you wanna be notified about. The second tip that I'd recommend about how to get the most out of Claude Opus 5 .5 is to actually use a feature called Claude projects.
Now I actually have a video about Claude projects. I'll put a link in the video description for you to check out, but it's basically a new way of building with Claude code where Claude manages the sessions for you. And what I've actually been doing is using Opus 5 .5.
as my default model in cloud projects for both the coordinator agent, which manages all of the worker agents and the different threads that are going on, as well as for the actual threads that are doing the work for me. So a real pro tip and probably 75 to 80 % of the things that I do with Opus 5 .5 happen in cloud projects.
And so this is the second tip that I recommend to use it because again, a lot of the work of setting goals and And these long running tasks is a natural fit for using cloud projects. So definitely check that out if you haven't and check out the video that I've done on that.
It's in the video description. The third piece of advice about how to get the most out of long running tasks with Opus 5 .5. is to keep the task list in a file.
Now, this reminds me of when I first actually used Cloud Code, one of the features that I liked is that it kept its own to -do list. So it had like a to -do .md. And this is very reminiscent of that where the advice from Anthropic is to keep the task list in a file.
The reason why this is useful is that when you have very long runs, a list that survives the context window and compaction, it's super important. And when Claude actually updates this file as it goes, it can show you at a glance about what's done and what's left. So you don't actually need to interrupt Claude for status updates and stuff like that.
And so you can keep this checklist in an MD file or markdown file called tasks .md. You can tell Claude to tick each item when it's done and add anything new that you find. Another pro tip that I learned from the Anthropic team is to actually keep this as an HTML site that Claude will actually update.
Number four. on letting Claude cook is using sub -agents. And there's two parts here.
So one is to ask Claude to split big work across sub -agents. You can ask Opus 5 .5 to split the work across sub -agents. And the part here that was interesting for me is to ask it to check each result and to supply evidence.
of the work that is done. So this is a really good best practice for working with sub -agents. It's to split up the work, but then check that the evidence matches the work that was actually done.
And this idea of having evidence bundles, I think in general is a best practice. So this is something to follow as well. And then finally, in this section, it is the final tip of the five tips for letting Claude cook, and that is giving Opus 5 .5 a time limit.
Now, this one I thought was really cool. This is from the Anthropic Docs, which says, Claude Opus 5 .5 pays attention to information about elapsed time. And so it's useful to give the model a time budget.
And the model paces its work to finish inside the budget and usually finishes well before it. And one of the things that you might think is if you rush cloud, it does the actual quality drop. And one of the things that Anthropic found is that teams given a budget kept answer quality comparable to the single agents while finishing considerably sooner.
So this is. A cool prompt hack that you can use with Opus 5 .5, and that is to give it a time budget for working on tasks, as well as when it's working with sub -agents in order to achieve the goals that you give it. We're going to get into part four of how to actually work well with Cloud Opus 5 .5, and that is checking results or verification.
The first best practice is something I just talked about, which is to ask Claude to output an . Now, this is actually a screenshot of one of the tasks that I gave Opus 5 .5. And I told it to adhere to my verification criteria.
And so it actually did a live check on my production site. I told it to deploy. It checked on desktop and mobile widths.
And then what it actually did is provide an evidence bundle. of images of how it looked on desktop and phone so that I can actually visually see and verify myself versus going and looking at the live site. So this is a huge hack.
I'd recommend using it for screenshots. You can ask it to even potentially do a screen recording if you have tools or other kinds of evidence for your particular task. But asking Claude to output an evidence bundle, that is a huge pro tip for checking your work with Opus 5 .5.
The second one, is asking Claude what it needs from you, asking Claude to tell you what it needs from you in order to make a next step, or maybe when it's stuck, how it can get unstuck. And from the Anthropic blog, they say, when a long run ends, look first for anything Claude is waiting on, like a decision it left open or a change it wants you to improve, and then read the rest of Claude's summary.
And the reason why this matters is because Opus 4 .5 reports on it to work more clearly than Opus 5 and in plain language. So this is another hack that they recommend, which is you can change a summary format to something like end every run with three headings, blocked on me, changed and found.
So you can actually modify this to suit your communication and how you like to be. informed. I have found this to be super useful where Claude will actually give examples of stuff that it's blocked on or things that it needs you to do in order to move forward.
And that helps a lot in order to understand what it actually implemented. And it's much more honest in the verification section as well. And then similarly, asking Claude to flag what it couldn't confirm.
So asking Claude what you need to give it input. And then asking Cloud to flag what it couldn't find or confirm or what it couldn't check. This is super important.
Again, getting honest, reliable answers from Opus 5 .5, where you can actually ask it to mark anything you couldn't confirm and say where you looked. So this helps you to understand, hey, if something that you thought it could find or something you thought was there actually wasn't there. This gives you an audit of what Cloud actually did and what it couldn't find for you to look at as a next step.
We're going to get into the final section, which I'm super excited about, which is case studies. And in this section, I'm going to talk to you about using Opus 5 .5 on real world projects in my business. A lot of it is about AI education and helping me create content.
And so these are the workflows that I've applied Opus 5 .5 to. And we're actually going to take a look at five of them. The first one being front -end UI and building web pages.
And in this case, looking at... page that I actually have live, which is my stack page on ainativebuilder .com. Now, when I was making this page, Opus 5 .5 might've just been released for a couple of days.
And so I was curious about how good it actually is at these kinds of front end webpage building tasks. And so I compared it to the model that I was using as a daily driver at that time, which is GBD6 Astra. And I actually gave both of them the same prompt.
And I wanted to see the output that they would actually produce. And so what I did was that I gave them a prompt to say. Implement this page that talks about the AI tools that I use in my stack.
There's actually another video that I just made on the channel about this. So check that out if you haven't. The key thing about this page is that it doesn't just show what the stack is, but it has a gate so that you enter your email and then you unlock the stack.
So it functions as a free resource, but you have to enter your email to access it. And one thing that I noted is in the design between GBD6 Astra versus Opus 5 .5. Astra had a design where it told you like what it is and then it said, hey, if you want to see it, you enter your email and this is how you access it.
Whereas the design that Opus 5 .5 went with was actually sending you to the page and then showing you a bit of what you're seeing and then putting the email pop -up on top of that. And so you have like a blurred effect and then the email pop -up is actually on top of that. Say if you want to unlock this page, just enter your email and you'll be able to check it out.
And I actually quite liked this because initially I hadn't thought of this kind of design. I was just going to go with a regular, hey, enter your email and then it'll send you to the right page. But this was a cool design that I didn't think of myself.
And so I was super impressed that Opus 5 .5 thought of that. This was actually through a number of iterations integrated into the final design. And then another thing that I wanted to note.
is in the call to action at the bottom of the page. So one thing that I told both Opus and GBD6 to do is to have a call to action. And the CTA that Astra gave was kind of like blending in with the page.
So you can see it's the same color. It has a nice piece of copy, build with its stack, get the full AI playbook. But it kind of blends in with the page and it's kind of easy to miss.
Whereas I like the CTA design that Opus came up with. which was learn to build with the stack. So it was actually quite a bit more practical and in black.
So it's a nice contrast to say like, hey, this is different from the page. This is something you should pay attention to. So again, these are subtle things, but I think one of the cool things is that this was the first version of what both Astra and Opus came up with.
And I think just reducing the number of iterations was big for me. And I actually prefer the outputs that Opus 5 .5 generated over GBD6. Okay, so this is the second case study that I wanted to show you, which is using Opus 5 .5 to migrate my personal blog from Squarespace to Cloudflare.
And this is actually the example of the prompt that I showed you earlier of how to actually prompt Opus 5 .5 with goals in a goal -oriented way. And this is in the Cloud Projects UI. So again, I recommend using Opus 5 .5 in Cloud Projects.
And this is the other real world tasks that I gave it. And so just to recap, I told it to build a duplicate version of my site of thought .com. I gave it a goal and a list of tasks that it needed to do.
And then I also told it some constraints about how to actually build the site and told it to give me a preview link when it was ready. So let's actually see the output that Opus 5 .5 came up with and make this a bit bigger. And so I gave it the prompt.
This is in the worker thread and it worked for a bunch of time. And when it eventually had an answer for me, it gave me a preview and it has a PR ready for me to review. So this was great.
We'll take a look at this in a moment. But what I wanted to actually emphasize is the communication and some of the things that we saw about how to use Opus 5 .5 well. And so Opus 5 .5 gave me a summary of what's on the page, how it actually verified its work, and then some things that I needed to check and give input on.
So this again, following the best practices for verification here. And so Opus 5 .5 said, on the page, we have the start here page and the blog, which is called lifelong learning. All 39 posts and 13 categories were there, as well as all the images.
And then how it checked it, it gave some information about the verification criteria that it used. used. It checked all 68 live URLs with the same titles, descriptions, and canonicals as the live site.
And it also loaded every page at phone, tablet, and desktop widths, nothing scrolling sideways and the phone menu works. So this is really good. Again, this is literally all from one prompt.
I just gave it this one big prompt as well as a output that I got from Squarespace. Another cool thing to note is that this output that I gave it was for migrating from Squarespace to WordPress, which is another self -hosted blogging platform.
But I didn't want to do that. I wanted to host this on Cloudflare myself. And previously, I would have not taken this on.
I'd been like, hey, this is for WordPress. Maybe I should use WordPress. But now that we have Opus 5 .5 and AI coding tools, I don't really care about it.
I trust Cloud to figure out mapping this Squarespace to WordPress format. to the site that I have in Cloudflare and using the frameworks that I use. So again, this is another cool thing about Cloud Code and why I'm so passionate about AI coding tools in general.
And then this is the part of the prompt where it talks about the things that it needs my input on. So it talks about, hey, I need your input in the about section. I couldn't access LinkedIn.
And so I need you to check that out. And then I also had some issues with podcasts and heading font. And so I went ahead and iterated with it.
And then finally, it said that for the redesign, this was an important constraint that I gave it where I said, and let me just scroll up a bit. I'd like you to duplicate the site, but do it in such a way that I can update the design and the look and feel later on. And it said, hey, for the redesign, I respected that constraint.
All the colors, fonts, and spacing are set in one file. And the layout and components are shared. It allows me to actually easily edit this versus messing up the site if I want to change the style and the look and feel on the site.
So this is actually the site as it is right now on aftar .com. I'm not finished with the migration a hundred percent yet, but this is the initial site you can see here. It has an old picture.
It has an about me. It has a link to my old newsletter. And there's also my blog.
And you can see here, this is on the aftar .com site. This is a live blog that's out there. And if you click on one of them, it'll take you to the actual blog and you can read it.
So that's kind of the site as it was. And then I'm going to show you the preview that Clore Opus 5 .5 actually made for me. And I've actually iterated on it a couple of times, but it did a bunch of things.
So you can see here, I have an updated headshot that Opus pulled for me from one of my other sites. It has an updated about section. There's a link to my newsletter called AI Native Builder, which if you haven't subscribed to already, definitely go and check out.
There's a link in the video description to subscribe to that. And then also some popular YouTube videos that I have. But it also has some of the content that was on the blog previously.
So, you know, the writings that I did about self -mastery, entrepreneurship, et cetera. So this is, again, the live preview that's on my Cloudflare preview. And then it also managed to copy the blog basically pixel for pixel.
So I was super impressed with this. And so if you look at the blog, so let me just show you an example of the actual attention to detail. So this is the blog on avtar .com.
And then this is the blog on the Cloudflare version of the site that Opus 5 .5 made. And it's basically exactly the same. It uses the same fonts, the same pictures.
This was a great starting point for me because I do want to update the styles and things, but I wanted to just have everything the same to start with. And then once again, the site ironically on Cloudflare loads a lot quicker. So this is something that I wanted to do.
And you can see here, the blog is basically identical. It pulled the same fonts as the live site. So I was super happy with this.
This is one of the projects that I was dreading for a long time, migrating my blog from Squarespace to a self -haunted site in Cloudflare. And thanks to Opus 5 .5, I was able to do this in literally one day. And again, the bulk of the work was actually done in the single prompt.
So it's a testament to the long running tasks that Cloud Code can run with Opus 5 .5 and the goal -driven nature of it and how good it is at achieving these tasks that are encapsulated in this way. So case study number three is a different task. So the first two that we saw were all coding and this one is about writing.
So this is a weekly digest, which is a cloud code schedule task that sends me a summary of all the things that I've bookmarked on Twitter every week. And previously I had it running on GPD 6 .1 Sol. But what I actually wanted to do in order to test Opus 5 .5 is I also made a version of it with Opus 5 .5.
And so what I wanted to share with you is what I've noticed about the differences in outputs that I got from this Bookmark Digest. And this is from as of the week of recording. This is from the previous week.
So it's both the previous week. And this is a very complicated task because what I actually have is more than 500 bookmarks in that week. So you can see I obviously spend a lot of time on Twitter.
And so this is not a simple summarization task. This is quite an in -depth analysis task that I've given to both GPD 6 .1 Sol as well as the new Cloud Opus 5 .5. And one thing that I wanted to note is the kinds of...
outputs that I got from each of these models. And the key takeaway here is that I actually found Opus 5 .5 much higher signal and much easier to understand. And I pulled this example to show you where this is at the top of the email around summarizing the bookmark themes.
And with the GPT 6 .1 version, it told me that this week's bookmark themes are that personal agents move from chat surfaces toward persistence. cross -app work, while teams debated how much context and access to entrust to them. Whereas the Opus 5 .5 version says OpenAI Dev Day turned the personal agent category into a four -way fight, Dots versus Muse versus Grokbot versus Instinct, while Anthropic Sonnet 5 .5 and Opus 5 .5 pairing reset the cost and quality frontier for builders.
And I think, you know, this may just be my personal preference, but for me, I find the Opus 5 .5 version much easier to comprehend. And I also find it higher signal because it's telling me, hey, these are the companies, these are the releases.
So one of the cool things that I asked the Digest to do for me is talk about the underlying themes that it's seeing. And so in this case, it flagged this theme that underneath both of them, the safe post keeps circling on one idea, when the models are cheap and capable. The scarce inputs become taste, context, distribution, and judgment about what to book.
I find this a much higher signal summary. And, you know, I had to give the win to Opus 5 .5 here. I'm going to continue testing it out for a couple more days and a couple more weeks to make sure that I'm happy with it.
But I'll probably eventually switch this daily digest over to Claude Opus 5 .5 as the model that powers it. And another thing to note is the comprehensiveness. So it's over 500 bookmarks, 567 raw bookmarks.
And Opus summarized them into eight themes, which I think for that number of bookmarks, eight themes is reasonable. GBD6 summarized it into five themes. And so it had a bit more discernment about what was important versus not.
And you can see here, this is like in each theme, this is from Opus 5 .5. It gives a nice summary. as well as links to read the actual tweets in order to learn more.
So I like the structure quite a bit as well. Case study number four out of five is another very complex multi -step process, and that is research and video prep. And so I used Opus 5 .5 to prepare for videos like this that I'm doing right now, where I talk about new AI coding tools and advancements.
At a high level, my process involves three steps, especially in research. So we have research. So we do web searches.
I have X bookmarks that I saved during the week. Then the second step is to create a report. This is kind of your standard deep research where you do a bunch of research, you collate a lot of sources, and then you synthesize that.
And usually the output of that is a markdown. But for me, when I like to take in information, I'm a very visual person. And so I like to have a visual report of what's going on.
This is actually something that Andrej Kapati talks about, where he says that in order to understand AI outputs, one of the things that he recommends is diagrams and images. So instead of writing... ask your LLM to create diagrams because they're easier to process, pass and understand.
This is something that I like to do. And so the final step is to create a visual report. So in addition to the actual synthesis of like what this is, but to capture visuals and put them in Figma or FigJam for me to look at.
And so I want to show an example of this in action for an upcoming video that I'm preparing for. So we're here in Cloud Code, and this is an example of how I used Opus 5 .5. to prepare for an upcoming video that I'm going to be releasing.
If it's not on the channel, it's going to be posted very soon on a new feature called Cloud Code Mods. So you can see here, my model is Opus 5 .5 medium, and I'm just in Cloud Code. This is not in projects.
This is just a regular Cloud Code thread. And it's a very short prompt, but it's actually super dense. So I have a skill called video research plus FigJam.
And then it says run a video research and then report to FigJam in one pass, turning a product or release into a cited report plus a full FigJam research board. So it's, again, this complex multi -step task. And I've given it to Cloud Code.
And I said, hey, this is the topic that I want you to research. I want to know what Cloud mods are. I want to know how they work and why they matter.
And give me five to 10 mods that I can show. in an upcoming video for me to research and, you know, I'll supplement this with my own research and exploration as well, but I find this to be a good starting point. And so this is the prompt that I gave to Cloud Code and it went ahead and worked for a long time.
And I actually want to show you the output that it got from this prompt. So this is the output from Cloud Code and the prompt that I gave it to research mods. Let me just zoom out a little bit.
You can see here, this is a very intricate visual research report. on Claude mods and how to think about them. So rather than take you through the whole report, I'll just show you one thing I wanted to ask it is like, Hey, eight mods that I should know about.
And it pulled from the research report, the different mods that I should look at in demoing. So here's the example of the mods, who it's made by, and then also It's pulled examples from Twitter and my ex -bookmarks of these mods in practice.
And so you can see the diff mod, you should know next steps. And for all of the different mods, this is stuff that it's done. And so this is an example of literally one prompt that I gave to Cloud Code and having this really in -depth research report that is generated from a single prompt.
Again, switching back to Cloud Code. It's literally one prompt. I answered a couple of follow -up questions.
And then this is the kind of output that you can get just in a single prompt. And it's a testament to how good at Opus 5 .5 is at actually taking on these complex multi -step tasks, but also in Andre Kapathy's advice about why you should do visual representations and making visuals and visual explainers of things, not just reading text.
which actually brings us to our next item that we're going to talk about, which is explainer videos. The last case study that I want to show you is one that I actually am super excited about, which is bespoke educational explainer videos. Now this is inspired by one of the popular use cases that you might've seen of Opus 5 .5, and that is using it to create videos in code.
And there was a great guide that was put out by Didi Das about Opus 5 .5 being incredible for instructional video generation. And I was also inspired by Andre Kapati, who says in his tweet about getting the most out of models, where he says, explainer videos, the format I'm most bullish on is fully custom slash bespoke explainer videos generated on any arbitrary topic.
And so I took this as inspiration to actually create some explainer videos that I want to share with you for the kind of technical concepts that I teach in my consulting, in my courses, and also on YouTube about getting the most out of AI coding tools. So before I show you the output of the explainer videos that I made, I first want to show you the prompt that generated them because this prompt actually speaks to the power of Opus 5 .5.
in that for the examples that I'm going to give you, it's just a single prompt. Now, if I was going to use these videos in production, I'd probably iterate on them a few more times, but I'm just really blown away by the quality that I got from Opus 5 .5 in just a single prompt. And it's not a very long prompt as well.
And so this is the prompt that I used where I said, can you make a 15 second explainer video? for my slash brainstorm and create spec skills. Look at the content on ai -nativebuilder .com site for details.
So that's the site to where this is hosted. And then the instructions that I gave is the following. Make three competing versions using HyperFrames, Manum, and the last one using Remotion.
So these are the names of libraries that I'm testing out for creating videos with Opus 5 .5. And then use the relevant skills for each method. So I installed skills, I think for hyperframes and re -motion.
They have some skills that help you make videos easily. And then I specified a destination for the files. And I also added an API key for it to use as voiceover.
So notice I don't specify anything about like, what should the video look like? What is the style, et cetera. I only said.
feel free to use different explanatory video formats that I know from YouTube. So this was, again, seeing what it could actually output. And again, following the good practices that we saw for goal -driven development, I gave it an output that I wanted.
I gave it some tasks that I need to do in this case, doing three different tasks. And then I gave it a definition of done where it says, hey, let me know when you have three videos ready for my review labeled by which framework they've used. And then I gave it a constraint around explanatory format.
So again, very simple prompt that I use to create these videos. Now let's see what it actually outputted. So this is the first video that I want to show you, which is about.
the brainstorm and create spec skill let's see what that one prompt actually turned into most ai projects go sideways before the first line of code run slash brainstorm and your agent interviews you one question at a time until the goal so one thing i wanted to note is again from that prompt i didn't specify about the kinds of visualizations and stuff i only gave it the website that actually talks about what the agent skill does and opus with its knowledge of the task and its knowledge of my site, it did a few things.
So it used the kinds of fonts and the colors that I have on my site. And then it also had a lot of cool visual explainers that actually show not just what the skill is and like telling you, hey, this is what the skill does, but showing it in action. So it actually shows, if I can just rewind, this interaction of using the brainstorm skill where you run slash brainstorm.
Interviews you one question at a time. until the goal is clear and then it asks you questions and then you end up with an output of a brainstorm .md doc so i'm super blown away by this i think this is a great job by opus 5 .5 and in this case this one's using hyperframes so a cool library to check out as well then slash create spec turns it into a plan your agent can build and and once again the slash creates a spec visualization here super cool where it doesn't just say it creates a spec but it shows you An example spec that it might put together with requirements, decisions, success criteria.
So that's another cool thing that I liked as well. Then slash create spec turns it into a plan your agent can build and verify. And then at the end, this is the diagram that I had on my site as well.
If I was using this in production, I'd probably improve on that part a bit more. But for the first prompt, I thought that was super, super cool. The next video I want to show you is another style on the same topic, just to give you some contrast.
This time it uses a framework called Manim. So let's see what Manim produced. Good planning is just raising fidelity.
A rough idea is fuzzy. Brainstorm sharpens it. Goal, scope, success.
Create spec makes it concrete. Requirements, decisions, verification. Then you build.
This one actually is probably my favorite out of the bunch because it's a great visualization of... the concept behind why do we plan and like, what are these skills actually useful for? And this library Manum, I believe actually uses a style that is popular on YouTube by 3Blue1Brown, which is a channel that many people might know.
And that allows you to build explainer videos in that style. So again, this was really cool. And for one prompt, this one, I think I actually iterated one more time, but I thought this was a great output in just a few prompts of work.
One other one that I wanted to show you is you don't just, you can actually specify multiple kinds of videos. So this is a kind of an Instagram Reel style video that I put together with Opus 5 .5. But this time it uses actually a snippet from a video that I put out about how to use AI well in your workplace.
And this video topic is about like how MCP should be part of your buying decisions. Picture your AI agent at the center of your business. Every tool with an MCP or a skill becomes a connection it can use.
Every tool without one is a dead end. So rolling out AI isn't only about agents. It's about a stack they can reach.
Before you buy any software now, add one question. Does it work with my agent? So again, I'm super impressed by this output.
Just to point out a couple of things. One is... the like subtle animations because the point of the video is that your software needs to work with your agent and so things like mcp and cli needs to be first class considerations and the fact that it actually visualized this is what your ai agent can reach this is the stuff that it actually can't reach and that's actually cut out and then finally the visualization of hey here's a new question that you need to add to your checklist i thought this was super cool again some things can be polished and it ended a bit abruptly and stuff like that but overall I'm super impressed.
And again, I thought it was a very engaging video to check out. So those are just some of the examples of videos that you can make with Opus 5 .5. I'm going to actually use these videos, whether it's for my courses or whether it's for the educational content that I put out on social media.
So I'm super excited. And again, some really good outputs from Opus 5 .5 using a variety of libraries. to make videos with AI.
So that was the five case studies of how I actually used Opus 5 .5 in my business. One tip I wanna leave you with is to use Opus 5 .5 on the Claude Max plan. I think that Opus 5 .5, in addition to being intelligent and really fast, it's also super cheap.
And I feel that using Opus 5 .5 on the Max plan, which costs $200 a month, it's basically unlimited tokens. And so that's how I use it. I'd highly recommend checking that out.
If you're able to upgrade to the $200 month plan, this is amazing value. And this is the way that I found to get the most out of Opus 5 .5 is the Claude Max plan. And I want to also feature something that DHH said.
He's the creator of Ruby on Rails and, you know, all around personality on Twitter. And his review of Opus 5 .5 is the hype is true. Anthropic did magic with Opus 5 .5.
It's good. And so, you know, this is what I want to leave you with Opus 5 .5. It's probably the model that I'm most excited about.
I can't remember the last time I've been as excited about a model as Opus 5 .5. So I'm excited to see what you're going to build. If you learn something from this video, please make sure to like and subscribe and leave a comment with any questions that you have or anything that you learned.
And also let me know in the comments, the stuff that you want me to go into more depth about in future videos. I'm really eager to see what you have to say. But that's it for this video.
Again, make sure to subscribe and all the links that I talked about are in the video description. So check them out there. Thank you so much for watching and catch you in the next one.
The Hook
The bait, then the rug-pull.
The title makes a time trade: a hundred hours of other people's testing, compressed into one sitting. The opening line does the same work in reverse, naming the model a new favorite and then immediately warning that everything you know about prompting it is slightly wrong.
Named ideas worth stealing.
02:22model
Goal-driven development
- Set a goal
- Delegate the goal
- Verify success
Replaces the older plan, implement, test loop. The change is that you define the end state and the proof up front rather than approving each step as it happens.
Steal forany task you would otherwise supervise step by step
05:55list
The four-part system for using Opus 5.5
- Setup
- Goal
- Let Claude cook
- Check results
The spine of the whole video. Setup is effort level and cleaning old prompt files, goal is the one-message brief, let it cook is the rules that keep a long run going, check results is verification.
Steal fora CLAUDE.md template or an internal team guide
11:37list
Anatomy of a goal prompt
- Goal
- Multiple steps
- Constraints
- Finish line
- Verification criteria
Five labelled parts, annotated live on a real migration prompt. The constraint in that example (keep all colors, fonts, and spacing in one file) is what made the result safe to restyle later.
Steal forany prompt longer than a sentence
18:03concept
Traffic light rules
- Green: keep going when a step does not need my input
- Yellow: put status notes in the same message as the next action
- Red: stop before anything destructive or outside this repository
Instructions placed in CLAUDE.md that tell the agent when to continue unaided and when to halt. The green light is the half most people forget, and it is the one that prevents needless interruption.
Steal forthe top of every project's CLAUDE.md
18:03list
Five tips for long runs
- Traffic light rules
- Work inside Claude Projects
- Keep the task list in a file
- Split work across sub-agents and check their evidence
- Give the model a time limit
The operating rules for a run you intend to walk away from. The file-based task list is what survives compaction, and the time budget paces the work without lowering quality.
Steal forany multi-hour agent task
23:36list
Three verification asks
- Output an evidence bundle
- Tell me what you need from me
- Mark anything you could not confirm and say where you looked
Three sentences you add to a prompt that convert a finished run into something you can audit in under a minute. The third one is the honesty check.
Steal forthe end of any research or build prompt
39:43list
Research to visual report
- Research across web and saved sources
- Create a cited report
- Create a visual report
A three-step pipeline that ends in a FigJam board rather than a markdown file, on the argument that diagrams are faster to process than prose when you are trying to absorb a result.
Steal forany deep research workflow where the output has to be understood, not filed
How they asked for the click.
VERBAL ASK
51:53subscribe
“If you learn something from this video, please make sure to like and subscribe and leave a comment with any questions that you have or anything that you learned. And also let me know in the comments, the stuff that you want me to go into more depth about in future videos.”
Held until the final twenty seconds, after a paid-plan recommendation and a third-party endorsement. The comment ask doubles as topic research for the next video, which is the strongest part of it. Earlier plugs for the newsletter and a prior video are woven into case studies rather than stacked at the end.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
