Big Idea

The argument in one line.

Agents stop at the first version that works and grade their own homework, so Cook forces a long loop of reference pictures, a high bar and isolated judges until the output actually matches.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use Claude Code and your agent keeps declaring a build 90% done when it clearly isn't.
You want to build 3D worlds, games, launch videos or motion-heavy sites from a brief and reference images.
You're curious how multi-hour agent loops with separate judge agents are structured and what they cost.

SKIP IF…

You just want a normal marketing website built fast, since the creator says Cook is overkill for most sites.
You're on a small plan and can't spare the usage that multi-hour, multi-agent runs burn.

TL;DR

The full version, fast.

Cook is a free Claude skill from the creator of the popular taste skill. You hand it a brief, rules, a time floor and reference pictures. It then loops: pick the weakest part, fix it with parallel helpers, render the same shot, measure it against the references, and have fresh isolated judges score it, repeating toward a 99.9 bar. A 45-hour Opus 5.5 run produced a 45,000-line Greek world with no assets. The reviewer's own one-hour tests were basic, but showed the setup: write the brief, add images, set time and agent caps.

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 →

Chapters

Where the time goes.

00:00 – 01:17

01 · What Cook is and the promise

Introduces the skill, the Greek world demo and the presenter's background.

01:17 – 02:40

02 · The 45-hour demos and token cost

Greek world, scrolling site and piano landscape, plus the 11M output tokens and $1,700 to $2,200 API equivalent.

02:40 – 03:30

03 · What Cook adds and what it's for

A gauntlet loop for 3D worlds, motion, films and screens, not a website builder.

03:30 – 05:30

04 · Three agent failures, three fixes

Stops at first working version, grades its own work, words are ambiguous.

05:30 – 07:00

05 · Setup and the brief

Clone the repo or have Claude pull it, run /cook, fill the brief with bar, rules, time floor and caps.

07:00 – 09:40

06 · Test runs with references

Skeleton Coast, scroll site and aviator game after about an hour each.

09:40 – 11:40

07 · The six-step loop

Intake, target, bar, rules, time, then the loop within the loop.

11:40 – 13:42

08 · Judges, parallel workers and sign-off

Isolated judges, agent caps, model choice and what comes next.

Atomic Insights

Lines worth screenshotting.

Agents tend to stop the moment something first works, which is fine for a prototype and bad for anything polished.
An agent grading its own work is cheating, so Cook uses separate judges with isolated context that never see the build.
Words mean different things to different readers, so reference pictures make a far firmer definition of done than a text description.
Cook scores separate dimensions like light, color, detail, motion, materials and composition, each with its own 99 benchmark.
Use two or more judges so there is some form of consensus, and ignore the builder's own score.
Set the bar deliberately high: it doesn't matter if it's never reached, because the loop keeps improving toward it.
Total runtime is only half the lever; the number of parallel worker agents in each round changes what an hour can produce.
Avoid absolute words like never and always in rules unless you mean them, because the model takes them extremely literally.
A 45-hour Cook run burned 11 million output tokens and about 3.8 billion cache reads, roughly $1,700 to $2,200 at API prices.
Cook is a matching tool for anything you can render a screenshot of and put beside a picture, not a website builder.
Set a time floor and a hard cap; if the run finishes far below the floor, something is wrong.
Start with conservative agent caps and scale up once you know how much usage the goal justifies.

Takeaway

Why long loops beat one-shot builds

WHAT TO LEARN

Agents quit early and flatter themselves, so quality comes from reference pictures, a high bar and judges that never see the build.

Agents stop at the first working version and call it 90% done, so give them a measurable bar and a minimum run time instead of trusting their own sense of finished.
Never let the builder score its own work; use two or more isolated judges with their own context so the scores reflect the output, not the builder's effort.
Reference pictures define done more firmly than words, because the same word means different things to different readers and a picture is hard to argue with.
Break the target into dimensions such as light, color, detail, motion, materials and composition, so each gets its own benchmark and the weakest one gets fixed first.
Match effort to the task: a website may need two hours, a 3D world many more, and the number of parallel agents matters as much as the clock.
Be careful with absolutes like never and always in rules, since a literal model will follow them even where you meant an exception.

Glossary

Terms worth knowing.

Cook: A Claude skill that runs a long build, compare and judge loop against reference images until the result approaches a very high quality bar.
Gauntlet loop: An agent loop where output must repeatedly pass measurable checks and judges before the work is allowed to ship.
Isolated judge: A critic agent with its own context window that scores the output without seeing how it was built, so it can't be biased by the builder.
Cache reads: Input tokens served from a prompt cache at a fraction of normal price, which keeps very long agent sessions affordable.
Brief: A template file where you describe the deliverable, the bar, rules, time limits and usage caps before the loop starts.

Resources

Things they pointed at.

00:00tooltaste skill

00:00toolCook skill (GitHub)

13:20productAI community (presenter's)

Quotables

Lines you could clip.

03:50

“Most agents will grade their own work, which is terrible because that's pretty much cheating at this point.”

short, punchy and self-contained→ TikTok hook↗ Tweet quote

00:05

“Right now, your agent stops the moment something works and it tells you it's 90% done, and you're the one who has to keep telling it that it isn't.”

universal pain point→ IG reel cold open↗ Tweet quote

The Script

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.

The guy behind the taste skill for Claude, the one with over 114 ,000 stars on GitHub, has just put out a new skill called Cook. Right now, your agent stops the moment something works and it tells you it's 90 % done, and you're the one who has to keep telling it that it isn't. He used Cook to build an ancient Greek world, about 45 ,000 lines of code with no 3D models, no textures, just nine pictures to aim at it, and he ended up with something incredible.

So today, I'm going to show you what Cook is, how the loop actually works, and how to set it all up quite easily. For those of you who don't know me, my name is Mansour, and I've spent the last 12 years consulting for Fortune 100 and 500 companies across cyber, DevOps, and automation, and I'm also a Claude Certified Architect.

So let's get into it. okay so this one he built roughly a month ago and you can see here it's an entire 3d world completely generated by code there's nothing here that used pre -existing assets the music wasn't created by ai in this case he credited someone else down below it's pretty incredible what this thing built and if we come down here a little bit more he does share the prompt that he used although it obviously now forms a part of the skill we're about to look at But we can see the amount of tokens that this thing burned through over the 45 -hour run that it had.

If we take a look at his Opus 5 .5 table over here, he used 11 million output tokens for this. If you compare it to the cash reads, though, it's $3 .8 billion, which is pretty crazy. He saved a lot of money thanks to all of these cash reads and writes.

The cash in this sense preventing Claude from having to read the entire conversation each time, which is part of where those token savings come in. Then at the bottom over here, it gives us a little average about what this would cost you if you had to build it with the API, and it's between $1 ,700 and $2 ,200, which is absolutely bonkers if you think about it.

Thank God for free usage reset. Second one that I want to show you is this one. I really like the style of this.

music in here was also made by code as well so again everything in here is code even the music and the sound effects I think this one has a really elegant aesthetic to it and I can see it being used for a ton of those scrolling websites and things like that if this tied into the theme for whatever it is that you were putting out there then the last one just before we get into how this skill actually works and how to set it all up He made a landscape here where a pianist is actually playing the piano and the keys that he's pressing are actually accurate and on time.

I do think the hand movements are obviously a little bit robotic and they need smoother transitions and things like that. But Claude wrote the song and then mapped everything to it while it was playing along. So that's obviously pretty incredible.

But what are the use cases for you? I mean, if you sit down and think about how this thing works. What would you actually use it for in your day?

And how is this any different from what's actually out there? So like many of the loops out there at the moment, this is following somewhat of the same structure of a gauntlet loop. You bring the brief that you want.

You bring in any reference pictures if you're building something that has some form of beauty or motion attached to it. And you feed this to the agent and it runs in its little loop to go through the iterations that it needs to until finally you get this perfect thing that gets better and better after each round that it runs.

We're going to take a look at this loop in depth in just a moment. In terms of what Leon is saying this thing is for, he says 3D worlds, films, launch videos, games. app and website screens.

I think the time and cost it would take to build a website with this particular skill, it might not be there for every single website that you want to build there. There are certainly far simpler skills to use to get really, really good results for the majority of websites out there already. But you can see clearly from the things that he's posting on Twitter, 3D Worlds and Motion are where this thing is going to be at.

And over time, I'm pretty sure we're going to be able to get those costs down drastically. Next thing you might be asking yourself, okay, but why do our agents even need to have these specific gauntlet style loops? And that's because some of the time, if you don't give these things proper briefs or task boards, it can stop as soon as this thing first works.

That's okay if you just want something to kind of prototype or throw in front of someone. But if you really want something that's polished and to the best of its ability, you want to have something that you can measure against and you want to set a clock and then have a stop check that this thing can iterate through. The second problem here is that most agents will grade their own work, which is terrible because that's pretty much cheating at this point.

The whole point of these skills is to have outside judges. You have separate isolated critics that have no context of what's going on and they just take a look at this and understand whether it means a definition of good and how far away it is from reaching that.

The third thing here is that words can mean something different to anything that you put it in front of. The whole goal here is to feed it pictures of what good looks like, give it as many references as you can so that it can run through that and that helps set the bar or the 99 % that we want to try and achieve. The important thing with this skill though is that it's not looking at say a singular image as the whole picture and grading that to the 99%.

It's breaking it up into specific chunks where you might have light, color, detail, motion materials and composition and each of those things have their own 99 benchmark that it's going to try and loop towards perfecting and i think that's where its power really comes into play over here because it can focus particularly on specific things inside the world that it's building cool so how do we actually get this thing and start to run it well it's pretty straightforward you just need to come on over to his github repo and then you can grab it how you normally would you can either download it as a zip you could also just clone it using this url over here or you can get claude to pull it into your environment I imagine that's the lazy approach for the majority of you, especially me.

That's exactly what I did. So if we come on over to my environment now, you'll see that it pulled in everything that we need. And I've already done a few test runs in here.

I only ran it for an hour because I wanted to see what this thing could achieve in an hour instead of having to run it for like 45 hours of something like that. We'll talk a little bit more about that in just a second. Once you've got it in here, there are two things you can do.

You can either hit forward slash cook. And then you can just tell it what you want. Go and do X, run through nine iterations of it.

And then it will kick off a little intake process and ask you a bunch of questions to fill out a brief for this to go and do that. Some of the settings in there will be time -based and how much usage you want. But if you really want to get the most out of this, I would understand exactly what you want up front, like the idea that you have in your head.

Vibe with Claude a little bit to pull out some of the most interesting things from that. And then get Claude to pre -fill the brief that it actually has. for the specific things that you're trying to achieve.

You'll see in the templates folder over here, it will ship with the brief .md. And what that does is it gives you the ability to fill this thing out in as much detail as you possibly can. And this is what I was just saying Claude could help you with, where you talk about the bar very vividly.

You provide this clarity upfront. Any rules that you might want to add, And again, talking about time here.

So we're setting a floor. We're saying run for at least eight hours. That's going to be my minimum.

And then I say, if you're done after two hours, something is wrong. Do a hard cap of 12 hours. Then if you wanted to, you could also include things like usage.

For me, I've actually had my five hour limit removed now because I'm on the ultra plan. But if you haven't, you might want to include this type of thing so it doesn't burn through all your cred over the time that it's running. Ultimately, you want to get to a point where you can describe the deliverable very clearly so it knows exactly what it should be building you.

then provide those references of what you think it looks like. So now that I've written my prompt of course the next thing to do is to provide it some references and we did that here for the three things that we're going to get this thing to build for us. The first one is the skeleton coast so I just got these screenshots of what the Namibian skeleton coast looks like.

I want to see if we can build some kind of wild coast thing going on over here with one of these little ships in it. I'm going to be leaving these things running over the next two days then I'll just post a short with the results. I have already filmed an hour for both of these just to see what the skill can actually achieve in a single hour.

So we'll take a look at that in just a second. The other thing that we're going to look at is replicating the scroll site over here. So it looks pretty cool.

Pretty sure we can nail this because a lot of skills can already do this. So I'm hoping we won't need to run this for two days just to build something like this. Like I said, websites are probably going to be overkill for this, but I do want to see what we can get.

I did run this for an hour. I'll give you a little snippet of what this thing looks like. So after an hour of running this, this is where we got to.

I don't think this is overly impressive. It hasn't met the bar yet, certainly, but I will let this thing run over the next 12 hours and see where we get to. The third thing that I'm going to get this thing to build is a replica of this aviator thing.

So this is pretty much just a 3D browser game where you fly around collecting these little blue things while these Nazi birds try and stab your little airplane every opportunity that they get. So it's pretty cool, pretty addictive. It's got some sounds in.

We'll see if it can replicate the sound without any external capabilities plugged in. And so about 45 minutes later, this thing ran through a couple of iterations over here. And this is what we got.

It's again... pretty basic at this point. We don't have any music.

It tried to differentiate itself a little bit but by no means have we met the bar and that's a pretty good thing. Another thing that you can see it kind of did over here is that it aligned with the theme of me wanting to use the skeleton coast. So it took some of those pictures, it added a couple of shipwrecks in here, added some rocks in the sand dunes with skeletons in the background.

So it is trying to fit that vibe. I have no doubt that over the next 12 hours I might even run this one for a bit longer just to see how crazy we can build this one. But it's off to a good start.

But now Now I want to talk a little bit about the loop itself and also does it really matter to run things for 45 hours? Is that where the magic lies?

And that's not the entire picture over here. Like I said, one part of it is this loop. In the beginning, we have this intake where you can either give it a prompt upfront like you could in that brief, or it will guide you through asking very specific questions to get as much context as it needs to provide you a very good build.

That's the most important part of anything that you're doing with AI at the moment is giving it that context. The second thing that it's doing is it's trying to understand the target. So by giving this thing pictures as a minimum, we're giving it a clear definition of done that is hard to argue.

It's not opinion -based. It's not, oh, this word means something to one person. It is a still picture of exactly what you want.

And of course, with some of the other loops, you could provide other references. You could literally give it code and say, just mimic this in our own style. There are tons of different things that you can do when you're trying to set a target.

The third thing, is the bar and this is where we're trying to achieve 99 .9%. The important thing is here, it doesn't matter that it can't reach that.

The whole point of this is that it does whatever it can to try and reach that. And you actually see Anthropic talking about when their engineers actually build, they always tell Claude to be ambitious. It's a really good hack to get it to do more than it thinks it can do because it will keep working in these loops until it meets this really high bar that it realistically might never achieve.

The fourth step here are rules and these are the things obviously that define what it can and can't. do. So for instance if you didn't want it to use any external assets tell it that.

If you wanted to grab music from somewhere else tell it that. It really is that simple. We're just defining what it can and can't do as a part of the thing that it's building.

Something that is important especially if you're using Fable is to try and avoid using words like never or always unless you do always never or always want those things inside the thing that it's building because it's extremely literal. So if you say never use this but maybe sometimes it's okay that can actually screw up your entire build.

So it's important to understand your rules when you're trying to calibrate this. The fifth thing here is time.

So work for the next nine hours. Don't stop until X, Y, Z. Things like that.

We're trying to set a floor for as long as this thing wants to run for. If it's a smaller task and it doesn't need something like 12 hours, see what you can get away with within the first two hours. by clearly defining these other things up front.

For instance, a website absolutely probably doesn't need 12 hours or something like that, no matter how much refinement you need to do. I reckon two hours max and you could get something really good. Obviously excluding proper end -to -end testing and all sorts of those things.

Step number six is the loop within the loop and that's where it's building, comparing, judging and fixing. And this repeats every single round before it goes into a gate for approval and then finally you can ship it when this thing's done. But something that's really valuable is to take a look at the loop within the loop because this helps you understand where some of that magic comes into play, where we have those separate critics with their own context windows looking inside this.

So for the loop in the loop in one round, these are the steps that this thing is gonna follow. The first thing is to pick the weakest part of it. Then it's gonna fix it properly.

The helpers are gonna work in parallel. And this is the second part that makes this magic. It's not just the time that it's running over.

It also depends on how many workers you have working inside this loop. Because if you have one, like I had for these assets that I showed you that we generated in the hour, those were only using one or two agents.

Now, if I increase that massively, I might got a much better result out of that hour that I used to build. So when setting this up, again, you can define caps, you can define how many agents you want this thing to be able to use. just like I did in my run.

So my advice for you here depending on how much usage you have to waste would be to start conservatively depending on the type of goal that you're trying to achieve and scale accordingly. Obviously if you just want to see the absolute limits of what this thing can do you could set it to max usage or ultra code like Leon did when he ran these tests and you could have an entire army doing all of this work for you.

But anyway the third step in this process is it's then going to render the same shot. So what it's doing here is it's rendering this so that it can compare it side by side to to whatever the reference was that you gave it to see how much closer it is to getting towards the bar that you set.

Step five is to measure the color in each of those other steps that we spoke about earlier. on the image that it would be addressing inside the bar and then a fresh judge is going to score this thing it's going to log it and this loop continues until it gets closer to 99 .9 done the important part on the judges is that they must never be able to see the build that's why we separate their context they're isolated from it there should always be two or more so that we can reach some kind of consensus on this and we also never want to trust the builder's own score he's pretty much irrelevant in this equation we only care about the critics but that is pretty much this thing in a nutshell for my builds i am be using fable 5 .2 on high to see what i can get away with with that he ran opus 5 .5 on ultra code so you do you obviously depending on the plan that you're on i will be posting these as a youtube short either in the next 24 or 48 hours so look out for that if you want to see what the final results were from the things that i set out to build other than that i hope i demystified the cook skill just a little bit for you leave some comments down below if you have any more questions otherwise if you're a business owner or an aspiring consultant i have an ai community where i'm helping you guys every single day

to navigate this crazy world and all of its chaos. Thanks very much for watching this video. I'll see you guys in the next.

The Hook

The bait, then the rug-pull.

Your agent stops the moment something works and tells you it's 90% done. Cook is a skill built to keep it going until the work matches your reference pictures.

Frameworks