⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

cook

leonxlnx@leonxlnx⭐ 368 stars· last commit 15d ago· 0 open issues

Runs the Cook Loop for ambitious visual builds that must match reference images, screens or videos through long autonomous iteration. Use it for 3D worlds made in code (three.js, WebGL, shaders), code-rendered films, launch and motion videos, games and polished UI that must hold up next to references, especially runs of many hours or days while the user is away. Trigger when the user types /cook or $cook, says "cook", "go cook", "let it cook", "iterate until it matches", "match the references", "99%", "99.9%", "9/10 minimum" or "at least 8h", or attaches reference images and asks for a recreation in code. It runs one intake, then loops build, stills, zero-context critics and fixes against a numeric bar, and holds the final render until the user approves.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐ 368 on GitHubGitHub ↗

Popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

cook

Give your agent a target, a bar and time, then let it cook.

An agent skill for ambitious visual builds that have to hold up next to references: 3D worlds in code, films, launch videos, games and UI. It runs the Cook Loop, one intake and then a long autonomous loop of build, stills, fresh-context critics and fixes until the work matches.

Install | Quick start | The Cook Loop | Made with this

Install

Use the skills CLI for supported agents:

npx skills add Leonxlnx/cook

Manual locations:

Claude Code:  ~/.claude/skills/cook
Codex CLI:    ~/.codex/skills/cook

Invoke it as /cook in Claude Code or $cook in Codex. It also triggers on phrases like "go cook", "iterate until it matches" or "match the references 99%".

The side-by-side script needs Node 18+ and ffmpeg on your PATH. Everything else is plain Markdown.

Quick start

Attach your reference images and send:

/cook build this ancient greek world in three.js, match the 9 attached references

The agent asks every open question once, with defaults, then works on its own. You get stills after every round. The final video is only rendered after you approve them.

Want full control? Fill in templates/brief.md and send that instead.

The Cook Loop

  1. Intake. All questions up front, each with a default. After that the agent never asks again, so it can run through the night.
  2. Target. The references are the minimum bar, not inspiration. Every reference becomes a shot with notes on what to take from it. Motion references get analyzed frame by frame.
  3. Bar. A number per dimension: composition, light, color, materials, detail near and far, motion. For example 99.9% for stills or at least 9/10 for a video. Models rate themselves too high, so your own estimate calibrates every score.
  4. Rules. Zero external assets by default, honest sound and asset policy, a slop ban list, colors that are neither grey nor oversaturated, offline rendering on weak GPUs.
  5. Time. A floor for demos (at least 8h, done after 2h means something is wrong), a hard cap for small jobs, and usage pacing so the run never hits a limit and stalls.
  6. Loop. Build, render stills at the reference shots, compare side by side, score with zero-context critics, fix the weakest part, log the round in cook/ROUNDS.md, repeat.
  7. Gate. Stills go to you after every round without pausing. No final render before you approve.
  8. Ship. First frame is the thumbnail, best scene first, no text on screen, licensed music credited, public repo with honest numbers if you want one.

All run state lives in a cook/ folder in your project, so the agent can resume after a context reset or hand the run to another agent.

What's inside

SKILL.md                      the loop the agent follows
references/intake.md          questions, defaults, the brief
references/target-and-bar.md  references, shot list, rubric, calibration
references/loop-and-critics.md rounds, critic prompts, feedback, pacing
references/rules.md           assets, sound, ban list, color, rendering
references/ship.md            final render, video spec, repo, numbers
templates/brief.md            fill-in prompt for your own runs
templates/ROUNDS.md           the round ledger
scripts/side-by-side.mjs      reference left, render right, one row per shot

Build a comparison image yourself:

node scripts/side-by-side.mjs --out compare.jpg ref1.png render1.png ref2.png render2.png

Made with this

Athenaion, an ancient Greek world built by Claude Opus 5.5 to match 9 AI-generated reference images. No external assets.

Total time~45h
Agents55 subagents, up to 12 in parallel
Code~45k lines of JavaScript
Tokens~11M output tokens
API-equivalent cost~$1.8k to $2.3k (ran on a Max plan)
Render4K on an integrated AMD Radeon 780M

Post | Repo

More demos made the same way:

All demos: leonlin.de/demos

Works well with

  • unlazy for effort and completion discipline. Cook sets the target and the bar, unlazy makes sure the work behind it gets done.
  • Any goal, loop or long-run mode your agent offers. Cook works without them.

License

MIT. Made by Leon Lin (@LexnLin).

// HOW IT'S BUILT

// FILES

12 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • SKILL.md9.0 KB2209bd84d435upstream ↗
    ---
    name: cook
    description: Runs the Cook Loop for ambitious visual builds that must match reference images, screens or videos through long autonomous iteration. Use it for 3D worlds made in code (three.js, WebGL, shaders), code-rendered films, launch and motion videos, games and polished UI that must hold up next to references, especially runs of many hours or days while the user is away. Trigger when the user types /cook or $cook, says "cook", "go cook", "let it cook", "iterate until it matches", "match the references", "99%", "99.9%", "9/10 minimum" or "at least 8h", or attaches reference images and asks for a recreation in code. It runs one intake, then loops build, stills, zero-context critics and fixes against a numeric bar, and holds the final render until the user approves.
    ---
    
    # Cook
    
    Give your agent a target, a bar and time, then let it cook.
    
    This skill runs the Cook Loop: one intake, then a long autonomous loop of build, render, compare, critique and fix until the work holds up next to the references. It is made for runs of 10 to 40 hours or more. The references carry the look. The brief sets the bar, the rules and the time.
    
    Optional companions: /unlazy for effort and completion discipline (the Depth Tree), and any goal, loop or long-run mode the harness offers. Cook works without them.
    
    ## State files
    
    All run state lives in `cook/` at the project root. These files are your memory across context resets and the handoff to any other agent.
    
    | Path | Holds |
    |---|---|
    | `cook/BRIEF.md` | Target, bar, rules, time, deliverable, permissions. Written once after intake. |
    | `cook/SHOTS.md` | One shot per reference: camera, framing, what to take from it. |
    | `cook/ROUNDS.md` | The ledger. Copy `templates/ROUNDS.md` and add one entry per round. |
    | `cook/refs/` | The references, numbered R01, R02 for images and V01, V02 for videos. |
    | `cook/stills/rNN/`, `cook/compare/rNN/` | Renders and side-by-side images of round NN. |
    
    ## Start or resume
    
    - `cook/BRIEF.md` exists and the run is not shipped: you are resuming. Read BRIEF, SHOTS and the last two ROUNDS entries, then start the next round (step 6). Do not re-ask, restart or rebuild what works.
    - After every context compaction, do the same before your next action.
    - `cook/` holds a shipped run: move it to `cook-archive/<date>/` and start at step 1.
    - No `cook/` folder: start at step 1.
    
    ## The Cook Loop
    
    ### 1. Intake (once)
    
    Ask every open question in one message, each with a default, so the user can answer by number or reply "defaults". Skip what the prompt, the attachments or a filled `templates/brief.md` already answer. If nothing is open, say so and start. Questions and defaults: `references/intake.md`.
    
    Collect: what to build, references, bar, time budget, hard rules, deliverable, hardware, usage limits, and what you may download or publish.
    
    Then write `cook/BRIEF.md` and `cook/ROUNDS.md` and start. From now on, never ask a question. The user may be asleep. Decide, log the decision under Decisions in ROUNDS.md, and keep working.
    
    ### 2. Target
    
    References are the minimum bar, not inspiration.
    - Study every reference at full size before building anything.
    - Write `cook/SHOTS.md`: one shot per reference image, with camera, framing, time of day and what to take from it (light, color, composition, materials, timing).
    - Motion references: analyze them frame by frame into a list of effects, transitions and timings. Take from many, never copy one element 1:1.
    - Getting references for 3D, UI and motion, and the analysis steps: `references/target-and-bar.md`.
    
    ### 3. Bar
    
    Write a number per dimension into BRIEF.md: composition, light, color, materials, detail density (near and far), motion.
    - Stills: a stretch target such as 99.9% similarity. Video: a score out of 10. References at about 8.5 mean a target of 9 or more.
    - Models rate themselves too high. When the user gives an estimate, log the gap as the calibration offset and apply it to every later score.
    - Keep measured numbers (a command produced them) apart from eyeballed ones (critic scores).
    
    ### 4. Rules
    
    Defaults unless the brief says otherwise. Full rules: `references/rules.md`.
    - Zero external assets: every mesh, texture, shader and effect in code, when the point is the flex.
    - Sound: code-made only if it truly holds up. Otherwise licensed free libraries, credited.
    - Launch videos: real logos and real photos beat drawn SVG people.
    - Slop ban list: eyebrow labels, monospace uppercase text, random serif fonts, purple gradients, beige, 01/02/03 counters, glowing orbs, shockwave rings popping out of things, decorative particles, em dashes.
    - Color matches the references: never grey or washed out, never oversaturated.
    - Weak GPU: keep realtime cheap and get the quality from offline rendering (sub-frame accumulation for motion blur, soft shadows, depth of field, anti-aliasing).
    
    ### 5. Time
    
    - Demos get a floor: at least 8h, and done after 2h means something is wrong. Big builds can take days. Small jobs get a hard cap.
    - Log the start time. Read the clock at every round boundary.
    - Pace usage: about 20% of a 5h window per hour, about 99% per window, never 100%.
    - Depth over breadth: make one shot, scene or element exceptional before you expand.
    
    ### 6. Loop
    
    Before round 1, build the harness: a fixed camera preset per shot, a still renderer and a color check. For side-by-side images use `scripts/side-by-side.mjs` from this skill (Node 18+ and ffmpeg): `node <skill>/scripts/side-by-side.mjs --out cook/compare/r01/all.jpg cook/refs/R01.png cook/stills/r01/R01.png ...`. Every round reuses the harness.
    
    Each round:
    1. Focus: open user feedback first, else the weakest dimension in the weakest shot.
    2. Fix it in depth. Split independent parts across parallel subagents.
    3. Render stills from the shot presets, same framing and aspect as each reference. For motion, render contact sheets and short clips.
    4. Make side-by-side images: reference left, render right.
    5. Measure what can be measured: color per region, frame time, seconds per rendered frame.
    6. Score with fresh-context critics: subagents with zero context that get only the side-by-side images and the rubric, optionally from another model. Your own score is logged, never decisive.
    7. Log the round in `cook/ROUNDS.md`.
    8. Send the stills to the user (Gate) and keep going.
    9. Run the Stop check. If it fails, start the next round now.
    
    Never stop when it first works. Never claim a check that was not run. If something was not measured, write "not measured". Round details, critic prompts and pacing: `references/loop-and-critics.md`.
    
    ### 7. Gate
    
    - After every round, send the stills with a short note: what changed, scores, next focus. Do not pause, and do not end your turn to wait for a reply.
    - User feedback beats critic priorities. Log the exact words and address them in the next round.
    - Never start the final render, or any other long and costly export, before the user approves the stills in chat. While you wait, keep refining and test the render pipeline on a few short frames.
    
    ### 8. Ship
    
    After approval, render the final deliverable and check the file. For a video on X: the first frame is the thumbnail and must be impressive, best scene first, a new scene every 6 to 7 seconds, no text on screen, licensed music credited, 1080p 30fps is enough. For a public repo: README, credits, the real prompt and honest numbers. Push or publish only if BRIEF.md allows it. Details: `references/ship.md`.
    
    ## Stop check
    
    Stop only when all of these are true:
    - Every dimension in every shot meets the bar, by critic median after calibration.
    - The time floor is reached (capped jobs have no floor).
    - The user approved the stills, and the final deliverable is rendered and its file checked.
    
    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. If a hard cap or a usage stop comes first, finish the round, log it and report plainly what is still below the bar.
    
    ## Never
    
    - Ask a question after intake.
    - Start the final render before the user approves the stills.
    - Copy one reference element 1:1, or name third-party reference clips in public files.
    - Let your own score decide a stop.
    - Report a number you did not measure or a check you did not run.
    - Use 100% of a usage window.
    - Put API keys, tokens or private information in anything you publish.
    
    ## Files in this skill
    
    | File | Read when |
    |---|---|
    | `references/intake.md` | Step 1: questions, defaults, writing BRIEF.md. |
    | `references/target-and-bar.md` | Steps 2 and 3: references, shot list, motion analysis, rubric, calibration, measuring. |
    | `references/loop-and-critics.md` | Steps 6 and 7: round details, critic prompts, user feedback, pacing, long runs. |
    | `references/rules.md` | Step 4, and whenever you add anything visible or audible. |
    | `references/ship.md` | Step 8: final render, video spec, repo, honest numbers, privacy scan. |
    | `templates/brief.md` | When a user wants to write the brief themselves. |
    | `templates/ROUNDS.md` | At the start of a run: copy it to `cook/ROUNDS.md`. |
    | `scripts/side-by-side.mjs` | Every round: reference left, render right, one row per shot. |
    
  • README.md5.0 KB0d6dc5d55bdaupstream ↗
    <div align="center">
    
    # cook
    
    **Give your agent a target, a bar and time, then let it cook.**
    
    An agent skill for ambitious visual builds that have to hold up next to references: 3D worlds in code, films, launch videos, games and UI. It runs the Cook Loop, one intake and then a long autonomous loop of build, stills, fresh-context critics and fixes until the work matches.
    
    [Install](#install) | [Quick start](#quick-start) | [The Cook Loop](#the-cook-loop) | [Made with this](#made-with-this)
    
    </div>
    
    ## Install
    
    Use the [skills CLI](https://github.com/vercel-labs/skills) for supported agents:
    
    ```text
    npx skills add Leonxlnx/cook
    ```
    
    Manual locations:
    
    ```text
    Claude Code:  ~/.claude/skills/cook
    Codex CLI:    ~/.codex/skills/cook
    ```
    
    Invoke it as `/cook` in Claude Code or `$cook` in Codex. It also triggers on phrases like "go cook", "iterate until it matches" or "match the references 99%".
    
    The side-by-side script needs Node 18+ and ffmpeg on your PATH. Everything else is plain Markdown.
    
    ## Quick start
    
    Attach your reference images and send:
    
    ```text
    /cook build this ancient greek world in three.js, match the 9 attached references
    ```
    
    The agent asks every open question once, with defaults, then works on its own. You get stills after every round. The final video is only rendered after you approve them.
    
    Want full control? Fill in [templates/brief.md](templates/brief.md) and send that instead.
    
    ## The Cook Loop
    
    1. **Intake.** All questions up front, each with a default. After that the agent never asks again, so it can run through the night.
    2. **Target.** The references are the minimum bar, not inspiration. Every reference becomes a shot with notes on what to take from it. Motion references get analyzed frame by frame.
    3. **Bar.** A number per dimension: composition, light, color, materials, detail near and far, motion. For example 99.9% for stills or at least 9/10 for a video. Models rate themselves too high, so your own estimate calibrates every score.
    4. **Rules.** Zero external assets by default, honest sound and asset policy, a slop ban list, colors that are neither grey nor oversaturated, offline rendering on weak GPUs.
    5. **Time.** A floor for demos (at least 8h, done after 2h means something is wrong), a hard cap for small jobs, and usage pacing so the run never hits a limit and stalls.
    6. **Loop.** Build, render stills at the reference shots, compare side by side, score with zero-context critics, fix the weakest part, log the round in `cook/ROUNDS.md`, repeat.
    7. **Gate.** Stills go to you after every round without pausing. No final render before you approve.
    8. **Ship.** First frame is the thumbnail, best scene first, no text on screen, licensed music credited, public repo with honest numbers if you want one.
    
    All run state lives in a `cook/` folder in your project, so the agent can resume after a context reset or hand the run to another agent.
    
    ## What's inside
    
    ```text
    SKILL.md                      the loop the agent follows
    references/intake.md          questions, defaults, the brief
    references/target-and-bar.md  references, shot list, rubric, calibration
    references/loop-and-critics.md rounds, critic prompts, feedback, pacing
    references/rules.md           assets, sound, ban list, color, rendering
    references/ship.md            final render, video spec, repo, numbers
    templates/brief.md            fill-in prompt for your own runs
    templates/ROUNDS.md           the round ledger
    scripts/side-by-side.mjs      reference left, render right, one row per shot
    ```
    
    Build a comparison image yourself:
    
    ```text
    node scripts/side-by-side.mjs --out compare.jpg ref1.png render1.png ref2.png render2.png
    ```
    
    ## Made with this
    
    **Athenaion**, an ancient Greek world built by Claude Opus 5.5 to match 9 AI-generated reference images. No external assets.
    
    | | |
    |---|---|
    | Total time | ~45h |
    | Agents | 55 subagents, up to 12 in parallel |
    | Code | ~45k lines of JavaScript |
    | Tokens | ~11M output tokens |
    | API-equivalent cost | ~$1.8k to $2.3k (ran on a Max plan) |
    | Render | 4K on an integrated AMD Radeon 780M |
    
    [Post](https://x.com/LexnLin/status/2111582260818239777) | [Repo](https://github.com/Leonxlnx/athenaion)
    
    More demos made the same way:
    
    - Alpine lake: [post](https://x.com/LexnLin/status/2112560562609803311), [repo](https://github.com/Leonxlnx/procedural-alpine-lake)
    - 10 Chinese landscapes: [post](https://x.com/LexnLin/status/2112264777309491443), [repo](https://github.com/Leonxlnx/shanshui)
    - Golden temple: [post](https://x.com/LexnLin/status/2110657641831956870), [repo](https://github.com/Leonxlnx/golden-temple)
    - Afterglow pianist film: [post](https://x.com/LexnLin/status/2114422260346110358), [repo](https://github.com/Leonxlnx/afterglow)
    
    All demos: [leonlin.de/demos](https://leonlin.de/demos)
    
    ## Works well with
    
    - [unlazy](https://github.com/Leonxlnx/unlazy) for effort and completion discipline. Cook sets the target and the bar, unlazy makes sure the work behind it gets done.
    - Any goal, loop or long-run mode your agent offers. Cook works without them.
    
    ## License
    
    MIT. Made by Leon Lin ([@LexnLin](https://x.com/LexnLin)).
    
  • scripts/side-by-side.mjs2.9 KB0aa51da16b55upstream ↗
    #!/usr/bin/env node
    // Builds one comparison image: each reference/render pair becomes a row
    // (reference left, render right), rows stacked top to bottom.
    // Every cell is fitted into the same box (letterboxed, never stretched),
    // so references and renders with different sizes still line up.
    //
    // Usage: node side-by-side.mjs --out compare.jpg ref1.png render1.png [ref2.png render2.png ...]
    // Options: --height <px> per cell (default 540), --aspect <w:h> per cell (default 16:9)
    // Needs ffmpeg on PATH.
    
    import { spawnSync } from 'node:child_process';
    import { existsSync, statSync } from 'node:fs';
    
    const USAGE = 'usage: node side-by-side.mjs --out compare.jpg ref1.png render1.png [ref2.png render2.png ...] [--height 540] [--aspect 16:9]';
    
    function fail(msg) {
      console.error(`side-by-side: ${msg}`);
      console.error(USAGE);
      process.exit(1);
    }
    
    const args = process.argv.slice(2);
    let out = null;
    let height = 540;
    let aspect = '16:9';
    const inputs = [];
    for (let i = 0; i < args.length; i++) {
      const a = args[i];
      if (a === '--out') out = args[++i];
      else if (a === '--height') height = Number(args[++i]);
      else if (a === '--aspect') aspect = args[++i];
      else if (a === '-h' || a === '--help') { console.log(USAGE); process.exit(0); }
      else inputs.push(a);
    }
    
    if (!out) fail('missing --out');
    if (!Number.isInteger(height) || height < 64) fail('--height must be an integer of at least 64');
    const m = /^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/.exec(aspect || '');
    if (!m) fail('--aspect must look like 16:9');
    if (inputs.length < 2 || inputs.length % 2 !== 0) fail('give images in pairs: reference first, then render');
    for (const f of inputs) {
      if (!existsSync(f) || !statSync(f).isFile()) fail(`not a file: ${f}`);
    }
    
    const probe = spawnSync('ffmpeg', ['-version'], { encoding: 'utf8' });
    if (probe.error || probe.status !== 0) fail('ffmpeg not found on PATH');
    
    const h = height - (height % 2);
    const w = Math.round((h * Number(m[1])) / Number(m[2]) / 2) * 2;
    const rows = inputs.length / 2;
    
    const graph = [];
    for (let i = 0; i < inputs.length; i++) {
      graph.push(
        `[${i}:v]scale=w=${w}:h=${h}:force_original_aspect_ratio=decrease,` +
          `pad=${w}:${h}:(ow-iw)/2:(oh-ih)/2:color=black,setsar=1[c${i}]`
      );
    }
    for (let r = 0; r < rows; r++) {
      graph.push(`[c${2 * r}][c${2 * r + 1}]hstack=inputs=2[row${r}]`);
    }
    if (rows === 1) {
      graph.push('[row0]null[outv]');
    } else {
      const all = Array.from({ length: rows }, (_, r) => `[row${r}]`).join('');
      graph.push(`${all}vstack=inputs=${rows}[outv]`);
    }
    
    const ffArgs = ['-hide_banner', '-loglevel', 'error', '-y'];
    for (const f of inputs) ffArgs.push('-i', f);
    ffArgs.push('-filter_complex', graph.join(';'), '-map', '[outv]', '-frames:v', '1', '-q:v', '2', out);
    
    const run = spawnSync('ffmpeg', ffArgs, { encoding: 'utf8' });
    if (run.status !== 0) fail(`ffmpeg failed:\n${run.stderr}`);
    console.log(`wrote ${out}: ${rows} row${rows > 1 ? 's' : ''} of ${w}x${h} cells, reference left, render right`);
    
  • references/intake.md4.8 KB723022479e93upstream ↗
    # Intake
    
    One message, every open question, a default for each. The user should be able to answer in two minutes, or reply "defaults" and go to sleep. After this message you do not ask again until the run is done.
    
    ## Before you ask
    
    - Read everything the user gave you: the prompt, attached images and videos, folders they named, a filled `templates/brief.md`. Do not ask what is already answered.
    - Look at the references now. If something about them is unclear (which ones matter most, close recreation or same quality in an own style), put it in this message.
    - A dictated, messy prompt is fine (mixed languages, "yk", "go cook"). Keep the user's words and their bar. Clean it up, do not rewrite it, and do not add requirements they did not ask for.
    - Do not push the user to describe the look in words. A short prompt with strong references beats a long description. The images carry the look, the text sets the bar, the rules and the time.
    - If the user already said they are leaving ("I'm going to bed, decide everything"), do not send questions at all. Use the defaults, note them in BRIEF.md and start.
    
    ## Questions and defaults
    
    Number the questions and ask only the open ones.
    
    | # | Question | Default when unanswered |
    |---|---|---|
    | 1 | What are we building, in one sentence, and in which stack? | Required. If the user has no idea yet, see "No idea yet". |
    | 2 | Where are the references? Recreate them closely, or match their quality in an own style? | The attached files. Recreate closely. |
    | 3 | What is the bar? | 99.9% similarity per dimension for stills. For video, the references count as about 8.5/10 and the target is at least 9/10. |
    | 4 | How much time: a floor or a hard cap? | Demo or visual build: a floor of 8h. Small job: a hard cap of 1.5h. |
    | 5 | Hard rules: assets, sound, extra bans, things that must appear? | Zero external assets. Code-made sound only if it truly holds up, otherwise licensed free audio with credits. The default slop ban list. |
    | 6 | What is the deliverable? | Approved stills, then a video of about 1 minute, 1080p 30fps, no text on screen, licensed music. |
    | 7 | What hardware renders it? | A weak integrated GPU: realtime kept cheap, quality from offline rendering. |
    | 8 | What usage limits apply? | A 5h window: about 20% per hour, about 99% per window, never 100%. |
    | 9 | May I download audio, push to a public repo or publish anything? | Download free licensed audio only and credit it. Prepare the repo locally, do not push or publish. |
    | 10 | Anything else before you leave? | Nothing. |
    
    End the message with: "If you have anything else, tell me now. After this I work without asking until it is done."
    
    ## No idea yet
    
    When the user wants to be surprised ("surprise me", "something creative"):
    - Do not run with your first random idea. Research ideas first, including niche places such as Reddit, and look for ideas the user would not think of.
    - Offer 3 to 5 ideas, one or two lines each, with what would make each one impressive.
    - Iterate on the idea with the user until it is good. This is still intake. The run starts once the idea is fixed.
    
    ## No references yet
    
    - 3D worlds and environments: suggest generating 9 to 12 target images with an image model (for example GPT Image) first. If the harness has an image tool, offer candidates for the user to pick.
    - UI: real product screens, for example saved from Mobbin.
    - Motion and launch videos: a folder of reference videos.
    
    If the user wants to start without references, write "no references" in BRIEF.md. The bar then rests on the rubric, the critics and the user's estimates, and the first stills the user approves become the reference for later rounds.
    
    ## Writing BRIEF.md
    
    Write it right after the answers. Keep it short and in the user's words where possible. Every line steers the run, so leave out anything that does not apply. In one test, a stray line saying "There are no photographs" kept agents from using photos at all.
    
    ```markdown
    # Brief: [project]
    
    Target: [one sentence]. Stack: [stack].
    References: cook/refs/R01 to R[NN], [recreate closely / same quality, own style].
    Bar: composition [99.9], light [99.9], color [99.9], materials [99.9], detail near and far [99.9], motion [9/10].
    Calibration offset: [none yet].
    Rules: [assets]. [sound]. Extra bans: [list]. Must include: [list].
    Time: [floor 8h / cap 1.5h]. Started: [timestamp].
    Usage: [5h window, about 20% per hour, never 100%].
    Hardware: [GPU]. Realtime cheap, final quality offline.
    Deliverable: [approved stills, then a 1 minute video at 1080p 30fps / realtime demo / UI].
    Permissions: download [yes/no], push [yes/no], publish [yes/no].
    User's words: "[the key lines of the prompt, verbatim]"
    ```
    
    Copy the references into `cook/refs/` with stable names (R01, R02 for images, V01, V02 for videos) and keep the original filenames in BRIEF.md. `cook/` is local working state. It is not published unless the user wants it to be.
    
  • references/loop-and-critics.md6.5 KB85c250a72cd4upstream ↗
    # Loop and critics
    
    ## The harness, before round 1
    
    Build these once so every round is cheap to check:
    - a camera preset per shot from `cook/SHOTS.md`
    - a still renderer that writes `cook/stills/rNN/S01.png` and so on, using the offline quality path
    - a side-by-side script: reference left, render right, same height
    - the color check from `target-and-bar.md`
    - for video: a contact sheet renderer and a short clip renderer
    
    ## Choosing the focus
    
    In this order:
    1. Open items in the user feedback inbox.
    2. Any shot with a dimension far below the bar.
    3. The dimension with the largest total gap across all shots.
    4. Far distance and detail density, which are easy to forget.
    
    Depth over breadth. Keep refining the same shot, scene or house until it looks exceptional before expanding. A small exceptional level beats a large mediocre one. Once all parts exist, the remaining time goes into refinement and polish, not into stopping.
    
    A big focus can be split the /unlazy way (the Depth Tree): subtasks, then their subtasks, and every leaf gets the effort the whole task would normally get. Optional.
    
    A sensible round length is 30 to 90 minutes: long enough for a real change, short enough that the user sees progress when they check in.
    
    ## Parallel subagents
    
    - Use them for independent parts (separate scenes, terrain, trees, water, sky, shaders) and for critics. The Athenaion run used 55 subagents, up to 12 in parallel.
    - Give each builder the brief, the shots it owns, the files it may change and its done condition. You stay the owner: you integrate, decide and keep the ledger.
    - Big builds can use roles: owner, performance monitor, tester, independent reviewer, and an inbox file for user feedback. The reviewer only rates work it did not build.
    
    ## Critics
    
    - 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.
    - At least two critics per round, three or more for big builds. A different model as one of them helps.
    - Take the median per dimension. If critics differ by more than 10 points (or 1.0 on a 10-point scale), add another critic.
    - Apply the calibration offset. Log raw and calibrated numbers.
    - Without subagents, use a fresh session that gets only the images and the rubric. If that is not possible either, score it yourself and mark it "self-scored" in the ledger.
    
    Prompt for stills:
    
    ```text
    You are a strict art director seeing this work for the first time.
    Each image shows a reference on the left and a render on the right.
    For each image, score how close the right side is to the left side, 0 to 100, on:
    composition, light, color, materials, detail density (near and far).
    100 means a viewer could not tell which one is the reference. The bar is [99].
    Then list the 3 biggest gaps per image: where (region), what is wrong, what to change.
    End with the single weakest area across all images.
    Format:
    S01: composition NN, light NN, color NN, materials NN, detail NN
    S01 gaps: 1) ... 2) ... 3) ...
    Weakest: ...
    ```
    
    Prompt for video:
    
    ```text
    You are a strict film editor seeing this video for the first time.
    Rate it from 1 to 10. Strong reference films in this style rate about [8.5].
    Score separately: first frame, composition, light, color, motion and transitions, pacing,
    and sound (write "not reviewed" if you cannot hear it).
    List the 5 weakest moments with timecodes, what is wrong and what to change.
    ```
    
    ## User feedback
    
    - Log the user's exact words in the inbox in ROUNDS.md and handle them before critic items.
    - Good feedback has a target: a color ("the sky way bluer, the grass greener and sometimes slightly yellow"), a place (a marked screenshot), a timecode ("seconds 18 to 38"), a distance ("the trees in the distance look undetailed in half-wide shots"). Turn each into a checklist item and close it only with a still or clip that proves the fix.
    - If the user says something is off but cannot name it, describe in plain words how you built that part, so they can point at what they dislike.
    - "Too grey" is the most common feedback on 3D builds. Run the color check every round so the user does not have to say it.
    - A user estimate ("you are at 60 to 70%") updates the calibration offset.
    
    ## Progress note
    
    After every round, without pausing:
    
    ```text
    Round 7, 11.5h in (floor 8h). Stills: cook/stills/r07/  Side by side: cook/compare/r07/
    Changed: far forest rebuilt with three tree species and per-instance color variation.
    Scores (critic median, calibrated): composition 91, light 88, color 84, materials 86, detail 79.
    Measured: S03 saturation delta -0.06, greyer than the reference.
    Next: color in S03 and S05, then far-distance detail.
    ```
    
    Send it with whatever the harness offers: a file-sending tool, inline images, or file paths in a message. Then keep working in the same turn.
    
    ## Pacing
    
    Time:
    - The start time is in BRIEF.md. Read the clock at the start and end of each round.
    - With a floor: if the bar looks met before the floor, it was read too low. Look harder: full-size crops, far distance, color per region, the weakest shot.
    - With a cap: plan rounds to end before the cap, with time left for the last log and progress note.
    
    Usage limits:
    - If you can read usage (a status command, a usage tool, or numbers the user gave you), check it at every round boundary.
    - Aim for about 20% of a 5h window per hour and about 99% of the window in total, never 100%. Do not burn everything in 2 hours and then wait 3.
    - Ahead of pace: fewer parallel subagents, more planning, critique and small fixes.
    - Behind pace: more parallel subagents on independent parts.
    - Near the end of a window: finish the current step and write the ledger, so a hard stop never lands in the middle of a change.
    
    ## Long runs
    
    - The ledger is the handoff. You after a compaction, a cloud agent or another model must be able to continue from BRIEF.md, SHOTS.md and ROUNDS.md alone. Write entries a stranger could act on.
    - If the project uses git, commit locally at the end of every round, and keep "Best so far" in the ledger pointing at the best round.
    - If a round lowers a score, fix it or go back to the best round before moving on, and log why.
    - Goal, loop and long-run modes are optional. If one re-prompts you automatically, make its done condition the Stop check in SKILL.md, so it ends when the work is done instead of re-prompting in circles.
    - When the user writes "continue", run the next round. Do not answer with a recap.
    
  • references/rules.md3.8 KB18c35d2eb4c3upstream ↗
    # Rules
    
    Defaults for every cook run. The brief can change any of them. The user's own bans add to the list.
    
    ## Assets
    
    - Zero external assets by default: every mesh, texture, shader and effect is generated in code. No downloaded models, textures, HDRIs or image files.
    - Why: it is the impressive part (people often do not believe it), and it forces the model to build things instead of downloading a tree, which shows what the model can really do.
    - It applies when the point is the flex: worlds, environments and films that show what code can do. The brief can relax it.
    - If anything external is used, list it in the credits. Never hide it.
    
    ## Sound
    
    - Code-made music and sound are allowed only if they truly hold up. Sometimes they do (the Chinese landscapes and the alpine lake). Code-made sound effects often sound cheap, especially in launch videos.
    - Otherwise use professional free sound libraries and licensed music. Check that the license allows the use, and credit artist and source in the README and the post. The Clawd film had its whole soundtrack replaced with real licensed recordings.
    - If a listening skill such as earshot is available, use it. Otherwise say plainly that the sound was not reviewed by ear, and check what can be measured: sync with cuts, levels, no clipping.
    
    ## Launch and product videos
    
    - The zero-asset rule usually flips here. Real logos, real product screens and real photos beat drawn SVG people and SVG stand-ins.
    - Use the real product UI as reference, and in the video where the brief allows it.
    
    ## Slop ban list
    
    Never use these unless the user asks for them:
    - eyebrow labels
    - monospace uppercase text
    - random serif fonts
    - purple gradients, and purple as a default accent
    - beige
    - 01 / 02 / 03 counters
    - glowing orbs
    - shockwave rings or circles popping out of things
    - decorative particles
    - long thin decorative lines
    - em dashes in any text
    - in motion: generic moves such as an icon floating up for no reason
    - in sound: rising-pitch whips and cheap synth bells
    
    Films and world showcases usually get no text on screen at all.
    
    ## Color
    
    - Color is one of the most important things and the most common failure. Compare it with the references every round.
    - Cinematic and realistic: not grey, not washed out, not oversaturated. Light and shadows have to match too.
    - Check per region (sky, water, foliage, ground, stone, skin) with the color check in `target-and-bar.md`.
    - If everything is grey, check the pipeline before repainting materials: output color space, tone mapping, exposure, fog and haze color.
    
    ## Detail
    
    - Every building, tree, rock and waterfall gets care. Nothing may look copy-pasted or simple: vary shape, color and scale per instance.
    - The world must read as detailed from far away. Render everything to the horizon and give far trees detail, also in half-wide shots. Never cut draw distance in final renders.
    - Water and waterfalls have to look real: color, motion, reflections.
    
    ## Weak GPU: quality from offline rendering
    
    A weak GPU (for example an integrated Radeon 780M) is no reason for lower quality. Keep the realtime path efficient and get the quality from offline rendering.
    - Realtime preview: lower resolution and fewer samples, only for working.
    - Stills and the final video: rendered frame by frame offline at full quality, however long each frame takes.
    - Sub-frame accumulation: render several sub-frames per output frame and average them. Jitter time inside the shutter for motion blur, the light position for soft shadows, the lens position for depth of field, and the sub-pixel offset for anti-aliasing.
    - Drive animation from the frame number, not the wall clock, so every render is repeatable.
    - Measure seconds per frame on a short test before any long render.
    
    ## Workspace
    
    - Work only inside the project folder.
    - Keep the build runnable at the end of every round. A broken build is a failed round.
    
  • references/ship.md3.7 KB33921778afb0upstream ↗
    # Ship
    
    ## Before the final render
    
    - The user approved the stills in chat. Without that, do not start.
    - Test the pipeline at final settings on 3 to 5 seconds: frames correct, timing right, audio in sync, the file plays.
    - Measure seconds per frame and estimate the full render. Put the estimate in the progress note. Final renders on a laptop take hours: the Athenaion 4K render took about 13h of GPU time on an integrated GPU.
    - Write frames to disk and skip existing frames on restart, so a crash or a usage stop does not cost the whole render.
    - Encode at the end and mux the audio, for example:
      `ffmpeg -framerate 30 -i frames/%05d.png -i music.wav -c:v libx264 -pix_fmt yuv420p -crf 16 -c:a aac -b:a 320k -shortest -movflags +faststart final.mp4`
    
    ## Video for X
    
    - The first frame is the thumbnail and must be impressive on its own. Treat the first 1.5 seconds as the cover image.
    - Best scene first. Then reveal more step by step, for example from behind a rock, then the camera rises and the view opens.
    - A new place every 6 to 7 seconds. Sometimes fast, sometimes slow. Transitions between scenes have to be really good.
    - Slow, cinematic camera moves. Drone-like is fine as a feel, with no drone UI and no drone noise.
    - No text on screen.
    - Music: licensed and free, credited. Nature sound where it fits.
    - Length: 30 to 60 seconds, about 1 minute for world showcases.
    - 1080p 30fps is enough for X. Render 4K or ultra-wide only when the brief asks.
    
    ## Check the final file
    
    Measure, do not assume:
    
    `ffprobe -v error -show_entries stream=codec_type,codec_name,width,height,r_frame_rate:format=duration -of compact final.mp4`
    
    Check resolution, fps, duration and that an audio stream exists. Export the first frame (`ffmpeg -i final.mp4 -frames:v 1 cook/first_frame.png`) and look at it. Make a contact sheet of the final video and send it with the file path.
    
    ## Public repo
    
    Only if BRIEF.md allows pushing. Otherwise prepare everything locally and say it is ready.
    - README: what it is, a hero image or GIF, a reference vs render comparison, how to run, how to render.
    - `docs/PROMPT.md`: the user's real prompt, merged from all their messages in the session and cleaned up, not rewritten. Name the model, its settings and the number of references.
    - Credits: music, sound, any external asset, libraries.
    - Honest numbers, measured or derived from logs, with estimates marked as estimates: total hours, subagents and the most in parallel, lines of code, output tokens, a cost estimate and the plan it ran on, hardware, render time.
    - References: publish only references the user made or owns, such as their own generated images. Never publish or name third-party clips or screens.
    - `cook/` is working state. Publish it only if the user wants to, and never with third-party references.
    
    Example of honest numbers (Athenaion, built by Claude Opus 5.5):
    - 9 AI-generated reference images
    - about 45h
    - 55 subagents, up to 12 in parallel
    - about 45k lines of JavaScript
    - about 11M output tokens
    - about $1.8k to $2.3k API-equivalent, run on a Max plan
    - rendered in 4K on an integrated AMD Radeon 780M
    
    ## Privacy scan before anything goes public
    
    - Search the repo, `docs/PROMPT.md` and the README for API keys, tokens, `.env` files, private keys, personal paths, emails and private names:
      `git grep -nIE "(sk-[A-Za-z0-9]|api[_-]?key|secret|token|BEGIN [A-Z ]*PRIVATE KEY)"`
    - Prompts are the riskiest file. Real prompts sometimes contain a key pasted in plain text. Remove it and tell the user to rotate it.
    - Check that `.gitignore` covers `.env`, render caches and large frame folders.
    
    ## The post
    
    Posting is the user's action. If asked, draft the post: what it is, that it is 100% code, the model and the time it took. Link the repo.
    
  • references/target-and-bar.md6.1 KBcb1d771c881bupstream ↗
    # Target and bar
    
    ## References are the minimum bar
    
    Every reference is the floor the work has to reach, not loose inspiration. If a frame would not hold up next to them, it is not done. Study every reference at full size before writing code, and use them as the shot list.
    
    One image tells the model the light, the colors, the composition, the materials and the mood at once. Words cannot carry that as well. That is why the text of a brief can stay short.
    
    ## Kinds of references
    
    - 3D worlds and environments: target images generated with an image model (for example GPT Image). Large builds made this way used 9 to 12 references: Athenaion 9, Shanshui and the golden temple 10, the alpine lake 10 to 12.
    - Same quality, own style: the brief may ask for the mood and quality of the references in an own art style. Then match light, color and detail density, not the layout.
    - UI: real product screens, for example from Mobbin. They set the bar for layout, typography, spacing and density.
    - Motion and launch videos: reference videos, analyzed frame by frame (below).
    
    Name images R01, R02 and videos V01, V02 in `cook/refs/`.
    
    ## The shot list
    
    `cook/SHOTS.md` has one row per reference image:
    
    | Shot | Ref | Shows | Camera | Take from it | Watch for |
    |---|---|---|---|---|---|
    | S01 | R01 | [temple on a cliff at dusk] | [low, 28mm, looking west, sun behind] | [warm rim light, haze layers, marble tone] | [far olive trees need detail] |
    
    - Give every shot a fixed camera preset in code (position, target, field of view, time of day), so every round renders the identical framing.
    - Render comparison stills at the aspect ratio of the reference.
    - Write down what to take from each reference. One reference can lead on light and be ignored on layout.
    - For UI, a shot is one screen state at a fixed viewport size.
    
    ## Motion references, frame by frame
    
    "All the text moves like this" is about 1% of what a reference video holds. Extract all the small things.
    
    1. Extract frames:
       `ffmpeg -i cook/refs/V01.mp4 -vf fps=10 cook/refs/V01/f_%04d.png`
       Around cuts and transitions, extract every frame of that range by adding `-ss` and `-to` and dropping the fps filter.
    2. Make contact sheets to see the rhythm:
       `ffmpeg -i cook/refs/V01.mp4 -vf "fps=2,scale=480:-1,tile=6x5" cook/refs/V01_sheet_%02d.png`
    3. Write `cook/MOTION.md` with one line per effect: reference, timecode, what moves, how (easing, duration, direction), why it works.
    4. Choose from the list: a core of about 20 strong effects plus 50 to 80 small ones, without overloading the piece. Take from many references. Never copy one element 1:1 or in an obvious way.
    5. Never name the source clips in public files.
    
    ## The rubric
    
    Score every shot on every dimension. Stills: 0 to 100 as similarity to the reference. Video and motion: 1 to 10.
    
    | Dimension | Checks | Typical failure |
    |---|---|---|
    | Composition | framing, scale, horizon, focal point, layout | subject too small, empty foreground, wrong lens |
    | Light | direction, softness, shadows, atmosphere, time of day | flat light, no haze, hard shadows |
    | Color | hue, saturation and brightness per region | grey and washed out, or oversaturated |
    | Materials | how water, stone, foliage, metal and skin take light | plastic look, flat water |
    | Detail density | near and far, variety, no visible repetition | bare trees in the distance, copy-pasted rocks |
    | Motion | timing, easing, transitions, camera moves | linear moves, cheap transitions, jitter |
    
    For UI, map them: composition to layout and spacing, materials to typography and components, motion to interaction and transitions. Write the mapped list into BRIEF.md.
    
    ## Stretch targets
    
    99.9% is probably not reachable. That is the point: the number tells the model the job is not done when it first works. For video, state what the references score (about 8.5/10) and set the target above it (9/10 or more). Use one number per dimension, not one overall number, so the weakest dimension cannot hide behind the others.
    
    ## Calibration
    
    - Models rate their own work too high, and critics share some of that bias.
    - The user's estimate is the truth. If you said 90% and the user says 60 to 70%, log an offset of about minus 25 and subtract it from the critic medians until the user gives a new estimate. Report calibrated numbers to the user.
    - For video, let one critic also rate a reference blind on the same scale. If your render scores above the reference while the user says it is worse, the critics are inflated: raise the target.
    - Blind pair test: show a critic the reference and the render without labels and ask which one was made in code and why. A confident, correct answer names your next focus.
    
    ## Measured and eyeballed
    
    Measured means a command produced the number in this round. Eyeballed means a person or a model judged it. Label every number in ROUNDS.md as one or the other. A similarity percentage is eyeballed unless a command computed it.
    
    Worth measuring:
    - Color per region: mean saturation and brightness on a grid, reference against render. This catches "too grey" before the user has to say it.
    - Frame time in realtime, seconds per frame in offline rendering, memory.
    - The final file: resolution, fps, duration, audio stream (see `ship.md`).
    
    Color check with Python, Pillow and NumPy. Both images need the same aspect ratio. Change the resize size if it is not 16:9.
    
    ```python
    # usage: python color_check.py reference.png render.png
    import sys
    import numpy as np
    from PIL import Image
    
    def cells(path, grid=4):
        img = Image.open(path).convert("RGB").resize((256, 144)).convert("HSV")
        hsv = np.asarray(img).astype(float) / 255.0
        h, w = hsv.shape[:2]
        out = []
        for y in range(grid):
            for x in range(grid):
                c = hsv[y * h // grid:(y + 1) * h // grid, x * w // grid:(x + 1) * w // grid]
                out.append((c[..., 1].mean(), c[..., 2].mean()))
        return np.array(out)
    
    d = cells(sys.argv[2]) - cells(sys.argv[1])
    for name, col in (("saturation", 0), ("brightness", 1)):
        worst = d[np.abs(d[:, col]).argmax(), col]
        print(f"{name}: mean delta {d[:, col].mean():+.3f}, worst cell {worst:+.3f}")
    ```
    
    A negative saturation delta means the render is greyer than the reference.
    
  • .gitignore60 B91c9042c1e36upstream ↗
    node_modules/
    .DS_Store
    Thumbs.db
    *.compare.jpg
    compare.jpg
    
  • LICENSE1.0 KBcfa96d6a91feupstream ↗
    MIT License
    
    Copyright (c) 2026 Leon Lin
    
    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:
    
    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.
    
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.
    
  • templates/brief.md3.2 KBb1b9d1e3679cupstream ↗
    # Cook brief
    
    Copy the block below, fill in the brackets, delete the lines that do not apply, attach your references and send it. It starts with /cook for Claude Code. In Codex, use $cook.
    
    Keep it short. The references carry the look. The text only sets the bar, the rules and the time. Every line steers the agent, so leave out anything you do not mean.
    
    ```text
    /cook
    
    Build [what, in one sentence] in [three.js / WebGL / Remotion / your stack], based on the [N] reference [images / screens / videos] I attached.
    
    Bar
    - The references are the minimum bar. Match them [99.9%] in composition, light, color, materials and detail, also far away.
    - [For video: the references are about 8.5/10. Yours needs at least 9/10.]
    - Colors: not grey, not washed out, not oversaturated.
    - Models rate themselves too high. When I give you my estimate, use mine.
    
    Rules
    - Zero external assets. Every mesh, texture, shader and effect is generated in code.
    - Sound: [code-made only if it truly holds up, otherwise free licensed music and sound effects, credit the artists].
    - Do not use: eyebrow labels, monospace uppercase text, random serif fonts, purple gradients, beige, 01/02/03 counters, glowing orbs, shockwave rings, decorative particles, em dashes, [your own bans].
    - My GPU is [weak, for example an integrated Radeon 780M]. Keep it efficient and get the quality from offline rendering.
    - Work only inside this project folder.
    
    Time
    - This takes at least [8h]. If you are done after [2h], something is wrong. [Small job instead: hard cap of 1.5h.]
    - Usage: I have a [5h] limit window. Use about 99% of each window, never 100%.
    - Depth over breadth: make one thing exceptional before you expand.
    
    Process
    - Work in rounds: render stills at the reference shots, compare them side by side with the references, let subagents with zero context rate them, fix the weakest part, repeat.
    - Send me stills after every round without pausing. Do not render the final [video] before I approve.
    
    Deliverable
    - [About 1 minute] video, [1080p 30fps], impressive first frame, best scene first, a new place every 6 to 7 seconds, no text on screen.
    - [Public repo with README, credits, the prompt and honest numbers. / Keep everything local.]
    
    If you have questions, ask now. Otherwise do not ask again and do not stop until it is done. Go cook.
    ```
    
    ## Short version
    
    The skill fills in the defaults for everything you leave out.
    
    ```text
    /cook
    Recreate the [N] attached references in [three.js], code only, no assets. Match them [99.9%].
    At least [8h]. Stills after every round, no final render before I approve.
    Questions now, then go cook.
    ```
    
    ## Tips
    
    - 3D worlds: generate the references first with an image model (for example GPT Image), 9 to 12 images. Then the agent builds exactly that, in code.
    - UI: save real product screens (for example from Mobbin) and attach them as the bar.
    - Motion: attach a folder of reference videos. The agent analyzes them frame by frame and takes from all of them without copying one.
    - Feedback mid-run works best with a target: a color, a marked screenshot, a timecode, a distance.
    - If you cannot say what you dislike, ask the agent how it built that part. Then you have the words.
    - A dictated prompt is fine. The agent cleans it up into `cook/BRIEF.md` without changing what you asked for.
    
  • templates/ROUNDS.md1.9 KB0590ffbc1513upstream ↗
    # Cook ledger: [project]
    
    Copy this to `cook/ROUNDS.md` at the start of a run. Keep the header current. Add one round entry per round, newest at the bottom. Label every number as measured or eyeballed.
    
    Started: [YYYY-MM-DD HH:MM, timezone]
    Time: floor [8h] | cap [none]
    Bar: composition [99.9] | light [99.9] | color [99.9] | materials [99.9] | detail [99.9] | motion [9/10]
    Calibration offset: [none yet] (from [user estimate, date])
    Usage: [5h window], about 20% per hour, never 100%
    Gate: stills approved [no] | final render [not started]
    Best so far: round [N], `cook/stills/r[NN]/`, [commit or snapshot]
    
    ## Decisions
    
    Made without asking, one line each.
    - [time] [decision], because [reason]
    
    ## User feedback inbox
    
    Exact words. Close an item only when a still or clip proves it.
    - [time] "[quote]" | round [N] | [open / done, proof: path]
    
    ---
    
    ## Round [NN]
    
    Time: [start] to [end] | total elapsed [h]
    Usage: [% of window at the end of the round, or "not readable"]
    Focus: [shot and dimension], because [user feedback / lowest score / largest gap]
    
    Changes:
    - [what changed, where]
    
    Stills: `cook/stills/r[NN]/` | Side by side: `cook/compare/r[NN]/`
    
    Scores, eyeballed: critic median after calibration ([n] critics, [models or "same model"])
    
    | Shot | Comp | Light | Color | Materials | Detail | Motion | vs last round |
    |---|---|---|---|---|---|---|---|
    | S01 | | | | | | | |
    | S02 | | | | | | | |
    
    Raw critic medians before calibration: [ ]
    Own score (logged, never decides): [ ]
    
    Measured (command and result):
    - [color check S01: saturation delta [+/-0.00], brightness delta [+/-0.00]]
    - [render: [N] s per frame at [resolution], [N] sub-frames]
    
    Not checked this round:
    - [what, and why]
    
    Top gaps from critics:
    1. [shot, region, what is wrong, what to change]
    2. [ ]
    3. [ ]
    
    Progress note sent: [time]
    Stop check: bar [no] | floor [no] | stills approved [no] | final checked [no] -> [next round / ship / stop at cap]
    Next focus: [ ]
    

Plain-text copy, no login: /skill-bundles/leonxlnx-cook.md

// REPO STATS

368 stars
0 open issues
Last commit: 15d ago