Source: ai-research/leonxlnx-cook-readme-2026-11-13.md, ai-research/leonxlnx-cook-skill-md-2026-11-13.md, ai-research/leonxlnx-cook-loop-and-critics-2026-11-13.md and ai-research/leonxlnx-cook-brief-template-2026-11-13.md (the skill’s own public files, read 2026-11-13) and raw/This_NEW_Claude_Skill_Is_Blowing_People_s_Minds_Cook.md (walkthrough video).

Repo: https://github.com/Leonxlnx/cook | Stars: 333, 25 forks, 1 commit (2026-11-13) | Language: Markdown plus one Node script | License: MIT | Author: Leon Lin (@LexnLin)

Creator: Mansel Scheffel (the captions render his name “Mansour”; the channel name is from the video page) | URL: https://www.youtube.com/watch?v=gaQpXmJt-C8 | Duration: 13:43 | Platform: YouTube | Published: 2026-11-12

Cook is an agent skill from Leon Lin, the author of the taste skill (114.8k GitHub stars on 2026-11-13). Its tagline is “Give your agent a target, a bar and time, then let it cook.” It packages a long autonomous loop for visual work that has to match reference images or videos: one intake, then rounds of build, render, side-by-side comparison, scoring by fresh-context critics and fixes. What it changes is the stop rule. The agent may not stop when the work first runs; it stops only when outside critics say every dimension meets a numeric bar, a time floor has passed, and you have approved the stills. This wiki read the skill’s files and did not install or run it.

Key Takeaways

  • The problem it targets (Mansel’s framing): “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.” The skill’s own line is “Never stop when it first works.”
  • Three inputs: a target, a bar and time. The references are “the minimum bar, not inspiration.” The bar is a number per dimension (composition, light, color, materials, detail near and far, motion). Time is a floor for demos (“at least 8h, done after 2h means something is wrong”) or a hard cap for small jobs.
  • The builder’s own score never decides a stop. Each round is scored by at least two subagents with zero context, which get only the side-by-side images and the rubric. The skill takes the median per dimension.
  • Questions happen once. The agent asks everything in one intake message, each question with a default, then “never ask a question” again, because “the user may be asleep.”
  • You still hold one gate. Stills go to you after every round without pausing. The final render does not start until you approve them in chat.
  • It is expensive by design. The showcase run (Athenaion, an ancient Greek world in three.js) took about 45 hours on Claude Opus 5.5, 55 subagents with up to 12 in parallel, about 45k lines of JavaScript, about 11M output tokens, and an API-equivalent cost of roughly 2.3k on a Max plan.
  • One hour is not enough. Mansel’s two test builds after 45 to 60 minutes with one or two agents were, in his words, “pretty basic” and not “overly impressive.”
  • Best fit is 3D worlds and motion, not ordinary websites. Mansel: “There are certainly far simpler skills to use to get really really good results for the majority of websites.”

What the skill is

  • Scope (README): “ambitious visual builds that have to hold up next to references: 3D worlds in code, films, launch videos, games and UI.” The SKILL.md says it is “made for runs of 10 to 40 hours or more.”
  • Contents: SKILL.md, five reference files (intake, target and bar, loop and critics, rules, ship), two templates (brief.md, ROUNDS.md) and one script, scripts/side-by-side.mjs, which puts the reference on the left and the render on the right. The script needs Node 18+ and ffmpeg; “everything else is plain Markdown.”
  • Where it runs: Claude Code (/cook) and Codex CLI ($cook). It also triggers on phrases such as “go cook”, “iterate until it matches” or “match the references 99%”.
  • Install paths the README lists: npx skills add Leonxlnx/cook, or a manual copy into ~/.claude/skills/cook or ~/.codex/skills/cook.
  • Companions: the README pairs it with Leon Lin’s unlazy skill “for effort and completion discipline” and says it works with “any goal, loop or long-run mode your agent offers” but does not need them.

The Cook Loop, step by step

From the README and SKILL.md:

StepWhat the agent does
1. IntakeAsks every open question in one message, each with a default, so you can answer by number or reply “defaults”. Collects what to build, references, bar, time budget, hard rules, deliverable, hardware, usage limits, and what it may download or publish. Writes cook/BRIEF.md.
2. TargetStudies every reference at full size. Writes cook/SHOTS.md: one shot per reference with camera, framing, time of day and what to take from it. Motion references are analyzed frame by frame.
3. BarWrites a number per dimension. Stills get a stretch target such as 99.9% similarity; video gets a score out of 10 (“References at about 8.5 mean a target of 9 or more”).
4. RulesDefaults: zero external assets, an honest sound policy, a slop ban list (purple gradients, glowing orbs, monospace uppercase text, em dashes and more), color “never grey or washed out, never oversaturated”, offline rendering on weak GPUs.
5. TimeA floor for demos, a hard cap for small jobs, and usage pacing. “Depth over breadth: make one shot, scene or element exceptional before you expand.”
6. LoopBuild the harness once (fixed camera preset per shot, a still renderer, a color check). Then each round: pick the focus, fix it in depth, render stills at the reference framing, make side-by-side images, measure what can be measured, score with fresh-context critics, log the round in cook/ROUNDS.md.
7. GateSend the stills with a short note after every round and keep working. No final render before you approve.
8. ShipRender the final deliverable and check the file. Push or publish “only if BRIEF.md allows it.”
  • Write rules you mean literally. Mansel’s advice for step 4, “especially if you’re using Fable”: avoid “never” or “always” unless you want exactly that, because the model is “extremely literal” and a rule like “never use this, but maybe sometimes it’s okay” can “screw up your entire build.”
  • Round focus order: open user feedback first, then any shot far below the bar, then the dimension with the largest total gap, then “far distance and detail density, which are easy to forget.”
  • Round length: “30 to 90 minutes: long enough for a real change, short enough that the user sees progress when they check in.”
  • State lives in a cook/ folder, so the agent “can resume after a context reset or hand the run to another agent.” After every context compaction it re-reads the brief, the shots and the last two ledger entries before acting.

The stop rule

This is the part that differs from most loop prompts.

  • Stop only when all three are true (SKILL.md “Stop check”):
    1. “Every dimension in every shot meets the bar, by critic median after calibration.”
    2. “The time floor is reached (capped jobs have no floor).”
    3. “The user approved the stills, and the final deliverable is rendered and its file checked.”
  • Finishing early is treated as an error in reading the bar. “Done before the floor means the bar was read too low. Reread the references at full size, check far distance, color and the weakest shot, and start another round.”
  • The exits that do not need the bar: “If a hard cap or a usage stop comes first, finish the round, log it and report plainly what is still below the bar.”
  • The bar is meant to be out of reach. Mansel: “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.” With a stretch bar, the time floor, the cap and your approval are what end the run in practice.
  • If a harness goal or loop mode re-prompts the agent, the skill says to “make its done condition the Stop check in SKILL.md, so it ends when the work is done instead of re-prompting in circles.”

Critics and scoring

  • Fresh context: “a new subagent with no history, no code, no brief and not your score. Do not tell it who built the work, how long it took or what you think of it.”
  • Input: the side-by-side images and the rubric with the bar. For video, contact sheets or the clip with timecodes. Mansel says the judges “must never be able to see the build”; in the skill’s wording they do see the rendered output, and what is withheld is the code, the history and the builder’s opinion.
  • How many: “At least two critics per round, three or more for big builds. A different model as one of them helps.”
  • Aggregation: the median per dimension. If critics differ by more than 10 points (or 1.0 on a 10-point scale), add another critic.
  • Calibration offset: “Models rate themselves too high.” When you give your own estimate (for example “you are at 60 to 70%”), the gap is logged and applied to every later score. Raw and calibrated numbers are both logged.
  • Measured and eyeballed numbers stay separate. Color per region, frame time and seconds per rendered frame come from commands; critic scores are opinion. “Never claim a check that was not run. If something was not measured, write ‘not measured’.”
  • Fallback without subagents: a fresh session with only the images and the rubric; failing that, score it yourself and mark the round “self-scored” in the ledger.
  • The stills critic prompt asks a “strict art director” to score 0 to 100 per dimension, list the three biggest gaps per image by region, and name the single weakest area. “100 means a viewer could not tell which one is the reference.”
  • Your feedback outranks the critics. The skill logs your exact words and handles them first. It asks for feedback with a target: a color, a marked screenshot, a timecode or a distance.

Usage pacing

  • The rule: “about 20% of a 5h window per hour, about 99% per window, never 100%.” The stated reason is so “the run never hits a limit and stalls.”
  • How it adjusts: ahead of pace means fewer parallel subagents and more planning and critique; behind pace means more parallel subagents on independent parts. Near the end of a window it finishes the current step and writes the ledger.
  • Mansel’s version: set caps and the number of agents in the brief, “start conservatively depending on the type of goal,” and scale up. He says his own five-hour limit is gone because he is on the Ultra plan; Anthropic’s help page says “Verified Ultra accounts don’t have a five-hour limit.”
  • Agent count is the second lever after time. Mansel’s one-hour tests used “one or two agents”; he expects a much better hour with more workers. Not tested in the video.

The numbers

Athenaion (README, “Made with this”):

ItemFigure
ModelClaude Opus 5.5
References9 AI-generated images, no external assets
Total timeabout 45h
Agents55 subagents, up to 12 in parallel
Codeabout 45k lines of JavaScript
Output tokensabout 11M
API-equivalent costabout 2.3k (ran on a Max plan)
Render4K on an integrated AMD Radeon 780M
  • Cache reads. Reading Leon Lin’s post on screen, Mansel reports 3.8 billion cache-read tokens against the 11M output tokens. That figure is not in the README.
  • Cost range. Mansel reads the API-equivalent cost as “between 2,200”; the README says about 2.3k.
  • Effort setting. Mansel says Leon ran Opus 5.5 “on ultra code.” The README names the model and the plan only.
  • Other demos listed in the README: an alpine lake, 10 Chinese landscapes, a golden temple and “Afterglow”, a pianist film. Mansel describes the pianist’s key presses as accurate and on time, with hand movement that is “a little bit robotic.”

Mansel’s own tests (first-hand, short):

  • A scroll-site replica after one hour: “I don’t think this is overly impressive. It hasn’t met the bar yet.”
  • A 3D browser flying game (a replica of a game he calls “aviator”) after about 45 minutes and a couple of rounds: “pretty basic at this point,” no music, but it had picked up his Skeleton Coast reference theme (shipwrecks, dunes, skeletons).
  • He planned to run both for 12 hours or more on Fable 5.2 at high and post the results as a short. Those results are not in this video.

How it compares with the Gauntlet Loop and the taste skill

Mansel calls cook “somewhat of the same structure of a gauntlet loop.” Set against the wiki’s Gauntlet Loop article:

Gauntlet Loop (Matt Shumer)Cook (Leon Lin)
FormA prompt and a written guideA packaged skill with reference files, templates and a comparison script
VerdictBlind side-by-side against a real-world reference; pass only if the build winsA 0 to 100 score per dimension from two or more zero-context critics; median, then a calibration offset
Unit of workThe agent splits the goal into pieces, each with a builder and a criticEach round fixes the weakest dimension in the weakest shot; parallel subagents take independent parts
StopNo fixed round count; you stop the runBar met, time floor reached and stills approved; or a hard cap or usage stop
Human roleOptional progress pageStills after every round; final render gated on approval; feedback outranks critics
BudgetUltracode “costs much more”; the budget is the real stopExplicit pacing rule per five-hour window
ResumeNot specifiedcook/ ledger written for a stranger to continue
  • Against Verifier-First Loops: cook is that checklist written into a skill for visual work. The done-condition is the Stop check, the per-pass check is the side-by-side plus critics, the saved artifact is the stills and ledger of each round, and “fix the weakest part” is the retry path. Its rule that a number must come from a command or be labelled as a critic’s opinion is the “proof outside the agent’s own explanation” idea.
  • Against the failure modes in Should You Build a Loop?: the time floor is aimed at agentic laziness (“done enough” at partial completion) and the zero-context critics at self-preferential bias. The cost is that a floor spends compute even when the output is already good, which is the opposite of that article’s cost-per-accepted-change test.
  • Against the taste skill: same author, different job. The current taste skill (v2.5.1) builds company websites and checks them with scripts in a headless browser, with a finish gate capped at three rounds. Cook has no round cap, judges with model critics against your references, and is aimed at 3D, film and motion.

Limits

  • New and lightly adopted. One commit, 333 stars and no independent evaluations at the time of reading. All quality evidence is the author’s demo videos and repos.
  • Mansel’s video shows no finished run of his own. His evidence is two builds stopped at 45 to 60 minutes.
  • The critics are models scoring images. The skill says models score too high and corrects for it only when you supply your own estimate.
  • “Never ask a question after intake” hands the agent every later decision. The intake therefore has to cover what it may download or publish, and the template includes “Work only inside this project folder.”
  • Websites are probably overkill. Mansel’s estimate is two hours at most for a site, and he points to simpler skills for that work.

Try It

  1. Read the skill before installing it. SKILL.md is short. The “Never” list and the Stop check tell you what the agent will and will not do unattended.
  2. Pick a job that fits: something visual with references you can attach. The template’s advice: for 3D worlds, generate 9 to 12 reference images with an image model first; for UI, save real product screens; for motion, attach a folder of reference videos.
  3. Write the brief rather than answering the intake cold. Mansel’s method: describe the idea to Claude, pull out the most interesting parts, and have Claude pre-fill templates/brief.md. State the deliverable, the rules, the time floor or cap and your usage window.
  4. Start with a hard cap, not a floor. The template’s small-job line is a hard cap of 1.5h. Use it to see how the rounds and critic scores behave before committing a night of usage.
  5. Check stills between rounds and give feedback with a target: a color, a marked screenshot, a timecode or a distance. Give your own percentage estimate once so the calibration offset has something to use.
  6. Borrow the parts without the skill. The critic prompt, the median-of-two-critics rule, the measured-versus-eyeballed split and the per-window pacing rule can all go into your own loop prompt or /goal condition.

Open Questions

  • Mansel’s 12-hour results. He promised a short with the finished Skeleton Coast and game builds on Fable 5.2 at high. Not captured here.
  • Cost on Fable 5.2 or at lower effort. The only cost figure is the Opus 5.5 Athenaion run.
  • How much of the result is the loop, the run length or the agent count? No ablation exists. Mansel’s point that more agents would improve a one-hour run is his expectation, not a test.
  • Whether the calibration offset works. It depends on the user supplying an honest estimate; the sources show no before-and-after scores.
  • “Anthropic engineers always tell Claude to be ambitious.” Mansel’s attribution; no Anthropic source was checked for it.
  • The game Mansel replicates. He calls it “this aviator thing”; the original is not named in the transcript.
  • unlazy. The companion skill was not read.