short-race
Skill150 starsChanged 4 days agoMITView on GitHub
Make a short vertical (9:16) video that races two AI models on the same prompt in lpm, one above the other: Run in duplicates puts each model in its own copy of the project, shown as two rows, the same prompt sent to both, the real finish times on the pane headers, then both results live in lpm's browser. Default prompt: a giraffe flying a one-seat plane as animated HTML. Models in, 1080x1920 MP4 + cover + post caption out. Use when the user asks for a TikTok, Reel or Short that compares models, such as \"opus 5.5 max vs gpt 6 astra ultra\", \"opus 5.5 vs grok 4.7\" (Claude models run in Claude Code, GPT models in Codex, Meta's Muse models in Muse Code, every other model in Cursor CLI) or \"opus 5 vs opus 5.5\". When the models build a game, use short-game.
- Installs packages
In this repository22 other files it gives its agents.
- AGENTS.mdAGENTS.md
- mobile/AGENTS.mdAGENTS.md
- website/AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- mobile/CLAUDE.mdCLAUDE.md
- website/CLAUDE.mdCLAUDE.md
- android-cliSkill
- app-review-videoSkill
- app-store-releaseSkill
- app-store-screenshotsSkill
- edge-to-edgeSkill
- lesson-publishSkill
- lessonSkill
- navigation-3Skill
- short-dailySkill
- short-gameSkill
- short-publishSkill
- shortSkill
- lpm-cliSkill
- lpm-configSkill
- lpm-memorySkill
- lpmSkill
The file
We split this skill into the rules it gives an agent
2 rules. About 0 are common, 2 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈2
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 17
No setup on screen. Picking the models, typing the prompt and Run in duplicates all happen under the two opening lines, where the payoff …
- Distinctive: line 41
No effort means the CLI's default, and the labels leave it out.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Races two models on one prompt and cuts it into a TikTok. It writes a lesson for the short skill and records it with that skill's pipeline. Everything in that SKILL.md still holds and is not repeated here: payoff-first cut, captions, safe zones, review, the lesson data dir and workspace, foreground takes.
What the video shows (about 17 s)
Most of it is the two finished pages, with nothing written over them, so viewers can compare them: the opening and the ending are spoken without captions ("caption": false on hook, tease, reveal and wrap), the headline shows only with the slammed names over the dimmed opening, gone by 1.8 s, and lpm.cx sits at the right end of the cyan bar (mark in compare.json) instead of the end sticker ("cta": false). Only the one line over the terminals is captioned.
- Cold open on the payoff for two lines (
"open": 2, about 4–5 s): both animations running one above the other, a colour bar over each row with the model and its finish time. It starts with the two model names slammed in big (slamin lesson.json, written bynew.js): model A in cyan from the left, VS, model B in pink from the right, over the dimmed pages, and the headline pops in above them once both have landed. That frame is the cover. At 1.5–1.8 s the names and the headline go together and the pages brighten, with nothing written over them from then on (user rule 2026-11-03: a headline or caption over one page spoils the comparison). A race between brands is named the way people search for it: "Claude or ChatGPT?" spoken, "Claude vs ChatGPT: Fable 5.1 vs GPT-6 Sol 🦒" as the headline, "Claude vs ChatGPT for coding:" leading the caption ("Claude vs Grok" for a Grok model in Cursor). The second line says what both models were asked to build ("Same prompt: a giraffe flying a plane."), so viewers know the prompt without reading it in the terminals. Keep it when rewordinglesson.json. It also keeps the result on screen: a one-line opening lost most viewers at 0:02, when it cut to the setup. - No setup on screen. Picking the models, typing the prompt and Run in duplicates all happen under the two opening lines, where the payoff hides them, so the video goes from the opening straight to the race.
- Both models at work in lpm, one above the other, for one line (about 3 s, the only shot of the terminals): "Opus 5.5 and GPT-6 Astra build it in lpm's terminal." The camera pushes in on each row's start banner as its model is named (for Cursor, its status line, which it draws just under the prompt; for Muse Code, its status line at the foot of its screen), then goes wide on "terminal". The clocks on the bars tick from the first frame of this shot.
- The build is jump-cut as soon as that line ends. The clocks stop on each agent's real finish. A lesson written before 2026-10-19 still spends a second line ("Both are building it now.") on the terminals and captions its pages; the beats still run it, but rewrite it with
new.js --forcefor the shorter cut. - Both
index.htmlfiles open in lpm's own browser, one per row. The payoff shot starts as soon as the camera goes wide on them, so it outlasts the two-line opening. Every video ends on them by asking viewers which two models they want compared next, in the comments ("Which giraffe wins? Comment two models to race next."), and the caption asks too. Keep that ending when rewordinglesson.json. It asks for suggestions; it never promises or teases a particular next video.
Setup: duplicates side by side
The race uses lpm's own Run in duplicates with Open side by side split into Rows, not a hand-built split:
- One project with a header button that launches model A's CLI. Its terminal is run #1, and its composer's Model menu picks model A (off screen, like the rest of the setup): hover the model, click its level in the flyout. When that menu can't pick model A (Codex, whose picker isn't scripted, or a Claude model that isn't its family's newest), the button launches model A pinned with its session-only flags instead (the launch commands below).
- The prompt goes into run #1's composer, then the send button's caret → Run in duplicates → 2 runs. Open side by side stays on. In the dialog, the copy gets model B one of two ways:
- Same CLI: the copy's model picker (Model / Level, next to its name) is set to model B. It offers each Claude family by its bare name, which Claude Code resolves to that family's newest model, so
new.jsrefuses a Claude model B that isn't its family's newest (opus 5while Opus 5.5 exists): put that one on the left instead, as run #1. - Claude vs Codex: the project gets a second header button that launches model B pinned. The copy's run menu ("Run on this copy", right of its name) is set to Action → that button, and the prompt is typed again into the copy's own box, since an override starts empty.
- Claude or Codex vs Cursor or Muse Code: the same, except that nothing is typed: the Cursor or Muse button carries the prompt as its launch argument, read from
prompt.txtin the lesson workspace (outside both projects). lpm folds a prompt into the launch command only for Claude Code and Codex, and a prompt pasted into a CLI that is still booting gets lost. A Cursor or Muse model is always model B:new.jsrefuses one on the left, and two of them can't race each other. "Muse Wonder vs GPT-6 Astra" is raced as GPT-6 Astra on top and Muse Wonder below.
- Same CLI: the copy's model picker (Model / Level, next to its name) is set to model B. It offers each Claude family by its bare name, which Claude Code resolves to that family's newest model, so
- lpm clones the project into a copy (its own folder, so each agent writes its own
index.html), starts the copy's agent on model B, sends it the prompt, and shows them as two rows, run #1 on top and the copy below. The lesson's settings preset the dialog's split to Rows (runInDuplicatesLayout). Run #1 keeps the keyboard.
Models
Each side is a loose spec: model, then an optional effort. The model picks the CLI: Claude models run in Claude Code, GPT models in Codex and Meta's Muse models in Muse Code, never in Cursor, though Cursor lists some of them too. Every other model runs in Cursor CLI.
- Claude Code:
opus,opus 5,opus 5.5,sonnet,haiku,fable 5.1… A bare family means its newest version. Effort:low,medium,high,xhigh,max. - Codex:
gpt 6 astra,gpt-5.6 sol,astra,gpt 5.5… Effort: whatever that model supports (ultraonly on some). - Muse Code (
muse,brew install --cask muse-code, thenmuse login):muse wonder,muse spark,muse spark 1.2… A bare line means its newest release, and a first release goes by its bare name (muse-wonder-1.0is "Muse Wonder"). Effort: the tiers its catalog lists for that model (Wonder 1.0 and Spark 1.3:minimaltomax, defaulthigh). The brand in the headline is "Muse", the hashtagmetaai. - Cursor CLI (
agent):grok 4.7,gemini 3.7 flash,kimi k3,glm 5.2,composer 2.5… Cursor lists most levels as their own model (grok-4.7-xhigh), so most need an effort. A few, such asgemini-3.1-pro,gemini-3.5-flashandcomposer-2.5, run at one fixed level and take none: Cursor's own/modelpicker has no Effort for them, and it refusesgemini-3.1-pro[effort=xhigh]. The brand in the headline is the model's own name ("Claude vs Kimi"), "Cursor" only for Composer. The narration, captions and post never say a model runs "in Cursor": "The copy gets Grok 4.7", not "Grok 4.7 in Cursor". - No effort means the CLI's default, and the labels leave it out.
ultracodeon a Claude side ("opus 5.5 medium ultracode"; Fable, Opus and Sonnet only) races Claude Code's standing dynamic workflows on top of that effort. That side goes on the left: after run #1's composer picks the model,/effort ultracode onis typed into its terminal, which turns it on for that session only and keeps the effort, so the copy starts without it. Once the prompt is in, the take looks for the turn's "Ultracode is on:" reminder in both transcripts and stops unless only run #1 has it. Both sides launch with--allowedTools Workflow, placed before--permission-modesince it takes every word after it: under acceptEdits the Workflow tool otherwise waits on "Review dynamic workflow before running" (an allow rule in the project's.claude/settings.jsondoesn't clear it). Ultracode starts its workflow in the background and ends a turn at once, so a Claude side's clock stops only when its last turn has ended and every background task it launched has sent its<task-notification>. On a trivial prompt (the dry run's red square) it skips the workflow and writes the file itself.- An effort the user gives the whole race ("use extra high effort") goes to both sides:
--effort xhighonnew.jsormodels.js, for each side that names none. When a side can't run at it (a Cursor model with one fixed level, or a level that model lacks),new.jsstops, and so does the video: tell the user which levels that side has and ask how to match the race before writing the lesson. A side is never run at another level than the one asked for, and the race is never quietly left unmatched.
scripts/models.js checks both against what is installed right now: Claude Code's own model table (read from its binary), Codex's ~/.codex/models_cache.json, Muse Code's catalog (~/.local/share/muse/model-catalog/*.json, written once muse has run signed in; its -contributor variants are left out) and agent --list-models. It rejects an effort the model does not support, because Codex fails such a run with a 400 in the middle of the take. Typos such as utra resolve, and so does "extra high". For a Cursor level with no slug of its own it asks Cursor itself: agent -p --model '<model>[effort=<level>]' with no prompt checks the model and exits without sending anything ("No prompt provided" when Cursor takes it, "Cannot use this model" when it doesn't), and the model it saves as the user's default is put back. A level found that way launches as --model '<model>[effort=<level>]'.
node scripts/models.js "opus 5.5 max" "gpt 6 astra ultra"
node scripts/models.js "opus 5.5" "grok 4.7" --effort xhighLaunch commands (session-only flags, so nothing in the user's config changes):
claude --model <id> [--effort <e>] --disallowedTools Bash --permission-mode acceptEditscodex -m <slug> [-c model_reasoning_effort=<e>] -c check_for_update_on_startup=false(Codex's update prompt once ran an update on a stray Enter)muse --model <id> [--effort <e>] --contributor-mode off --trust-workspace --disable-shell "$(cat <workspace>/prompt.txt)": Muse Code's contributor mode is on by default, and it swaps--modelfor the catalog's discountedmuse-spark-1.3-contributor(which lets Meta use the session's content), so it is turned off for the run.--trust-workspaceskips the new copy's trust prompt without saving trust, and--disable-shellkeeps a shell call from stalling the race on an approval, as Claude's Bash is denied. File writes need no approval.agent --model <slug> --trust --force "$(cat <workspace>/prompt.txt)":--trustskips the new copy's folder-trust prompt, and--forceruns its shell calls without an approval that would stall the race (its status line then reads "Run Everything"). Cursor does save--modelas the user's default; see Traps.
Make one
Write the lesson:
node scripts/new.js "opus 5.5 max" "gpt 6 astra ultra" node scripts/new.js "opus 5.5" "grok 4.7" --effort xhigh node scripts/new.js "opus 5" "opus 5.5" node scripts/new.js "opus 5.5 low" "opus 5.5 max" --prompt "<prompt>" --subject "a lava lamp"It creates
~/Movies/lpm-lessons/tiktok/<slug>/withlesson.json(narration, headline, post),compare.json(both models, the prompt),beats.js(a stub that loadsscripts/beats.js, which brings in the tiktok kit) andtake.sh(short/scripts/take.sh, inside the Claude-default backup when model A is picked in the composer). Both point into this repo by absolute path, so the folder needs nothing from outside git.--effortis the race's effort, for each side that names none.--subjectis the short noun phrase ("a lava lamp") that the second line says and the caption uses; a custom--promptrequires it.--nounand--emojigive a custom prompt the giraffe's copy:--noun pelican --emoji 🚲titles it "…: the pelican test", ends on "Which pelican wins?" and puts 🚲 in the headline. Without them it is "…, same prompt" and "Which one wins?". short-daily'sformats.js newpasses all three for its catalog's formats. The default prompt is inscripts/prompt.js.--slugnames the folder.--forcerewrites an existing one. A lesson written before the setup moved off screen still has lines for it (left,prompt,dupes,pick,go) that the beats no longer run: rewrite it with--forcebefore another take.A custom prompt must still ask for
index.htmlat the project root: the race waits for that file, and the reveal opens it. It must also keep "Don't run or test it.": Claude runs withacceptEdits, so a model that checks its page with a shell command waits on an approval nobody gives, and its turn never ends (Opus 5.5 xhigh did, withnode check.js). Every Claude side also launches with--disallowedTools Bash, which refuses such a call at once, subagents' included: an ultracode reviewer ranpython3 -cto check its arithmetic, and the workflow stalled on that approval for 50 minutes until the take was stopped (2026-10-10). It should also say the page is shown in a panel a bit wider than tall, of any size, lay the scene out on a fixed 900x700 stage with the subject's size given as shares of that stage (the default: plane about 40% of the width, centered, body about halfway down, giraffe's head about 10% from the top), and ask for the whole stage to be scaled to fit the panel, never cropped. Each row shows about 570x420 pt of page in the tall window, a little wider than the stage, so the scene fills the row's height and the page's own background shows at its sides. Keep the subject in the stage's upper 60%: TikTok's caption covers the rest of the bottom row (see Traps). A lesson whosewindowisn't 570x1000 was written for an older layout (columns on a 420x740 stage, or an 800x990 window on a wide 900x360 one): rewrite it with--forcebefore retaking it. Pixel sizes break at other panel sizes, and percentages of the panel itself pull against each other when its shape changes. "Fill the window" made one model crop its scene, and without sizes the two results come out at different scales, which makes the side-by-side comparison harder.- Tell the user that a take is starting and that they should leave the keyboard and mouse alone. A take drives the real pointer, and a stray key lands in the prompt.
- Dry run:
<slug>/take.sh --no-audio --frames, then checkframes/. The preflight runs first, and a take stops before touching anything when it lists something missing. Both rows should be there, both banners should show the right model, and both prompts should be sent. There should be no intro or update screen in either row.05-payoff.jpgshows both pages open with nothing of lpm but the colour bars, the cyan bar (model A) on top and the pink one below, and no project header, address bar or git bar. - The video:
<slug>/take.sh --frames. The take lasts as long as the slower model (15-minute limit per side, ortimeoutMinin compare.json; a side that runs out shows✗ no page. xhigh and max can think for over 15 minutes before writing). The real times go to<slug>/result.json. - Review as
shortsays (sheet, cover, popups, hook length). Then open the MP4 and check that both pages are moving and are the models' real output.take.sh --mux-onlyre-cuts without a retake.
Finish the reply with each model's time from result.json, then the rendered MP4's full absolute path. To post it, use short-publish.
Traps
- A race records a narrow, tall window so each row takes about half the frame:
window570x1000,windowShiftY: 6,stickerTop: 345andslamTop: 575in lesson.json, andpayoff: "bars"in compare.json, all written bynew.js. The wide shot scales the window to 982x1723 px, 6 px below centre (y 105–1828), and lpm's text shows 1.6x larger than in the 800x990 window giraffe races used before 2026-10-11. Once both pages are open, the payoff keeps only the colour bars (scripts/trim.js): each row's project header, browser address bar and git bar are hidden, a 96 pt empty strip stays at the top (TOP_STRIP_PT), and both pages reload so each starts at its final size. Each row's page is then about 570x420 pt and shows about 982x724 px, with the 900x700 stage fitted to its height. A 6.3" iPhone shows the video 1.233x, crops 51 px off each side, and its status bar and TikTok's tabs cover y 0–253 (measured from the user's screenshots 2026-11-03), so the strip puts the top bar at y 270–325; the 28 pt strip used before put it at y 154–209, under the tabs, where the model name couldn't be read. The opening's headline sits under that bar (y 345) and the slammed names under the headline (y 575), over the dimmed top page, until 1.8 s. TikTok's caption covers the bottom page from about y 1690 with a two-line caption (the review guide marks from y 1500), which is why the giraffe sits high on the stage. TikTok's like and comment buttons cover x 900–1080 from about y 1000 down, which takes in the bottom bar's right end, so each bar's clock sits just after the model's name, not at the bar's end. A 16" MacBook Pro's screen with the Dock showing holds a window up to 1009 pt tall (a taller one comes out 1009), and 570 is below lpm's own 700 pt minimum, which the debug build's lesson control lifts for a take. Check a change by laying a payoff frame into the frame at that size, with~/Movies/lpm-lessons/tiktok/_look/safe-zones.pngover it. - The voice is made before the take, so the narration never names a winner. The times on the colour bars are the result.
- Time each side from its own prompt, not from the Run click. The copy starts later (the clone, then its agent's boot), so a clock started at Run would hand run #1 a head start.
- The composer's Model menu runs Claude's
/modeland/effort, and Claude saves both as the user's default for new sessions (modelandmodelSettingsin~/.claude/settings.json). Cursor CLI saves the model it was launched with (model,selectedModel… in~/.cursor/cli-config.json). Muse Code writes its catalog's default model (provider,modelin~/.config/muse/settings.json) on any launch that finds none saved, whatever--modelsays.take.shsets each file aside first and puts those keys back on exit (scripts/cli-default.js). A take killed hard leaves_claude-settings.backup.json,_cursor-settings.backup.jsonor_muse-settings.backup.jsonin the lesson folder; the nexttake.shrun keeps that backup and restores from it. - Cursor keeps no transcript with times. The race reads its chat (
~/.cursor/chats/<md5 of the folder>/<chat>/store.db,scripts/cursor.js): the prompt is in when a user message holds<user_query>, and the turn is over when the last message is the model's with no tool call. A side's clock starts atmeta.json'screatedAtMs(the prompt can reach the store only with the model's first step, which took 28 minutes at xhigh and once handed Grok a 28-minute head start) and stops atupdatedAtMs, the chat's last write. Its model name shows on its status line, not in a banner, and Cursor draws that line inline just under the prompt, about halfway down its screen early in a chat, not at the foot. The store is in WAL mode and a read-only open fails without its-shmfile, so the race reads a copy ofstore.dband its-wal; a long chat's messages run past 1 MB ofsqlite3output. - A model name the transcript mishears fails the voice's dropped-words check. Reword that line in
lesson.json, or add the heard spelling toHEARD_ASinlesson/scripts/words.js, then run again with--respeak. - Two sides may not be identical:
new.jsrefuses when model and effort both match. - Muse Code's session log is
~/.local/share/muse/sessions/YYYY/MM/DD/<session>/session.jsonl(scripts/muse.js): one record per line, or a transaction frame holding its records as JSON strings, each withrecorded_atin microseconds. The metadata record names theworkspace_root; each turn is aruntime.sessionrun that logsstartedwith its prompt, which starts the clock, andterminalonce it is over, after Muse's own "Double checking" pass, which stops it. A long session's log runs to many MB, so each poll reads on from where the last one stopped. - lpm starts a Claude or Codex copy by typing its launch line, prompt included, into a shell that is still starting, and macOS cuts a terminal line off at 1024 bytes. The copy then sits at its shell with the line cut mid-prompt and never starts, and the race waits out its limit (the first GTA take, a 1259-byte line).
new.jsmeasures the line as lpm writes it (a same-CLI copy is pinned by family name,--model opus) and refuses one over 1010 bytes: shorten the prompt. Cursor readsprompt.txt, so it has no limit. - The setup collapses the sidebar with one click, then waits for the Expand button to fade in (it is always in the page, at opacity 0 while the sidebar is open). Collapse still reads visible once the sidebar is shut, and in the 570 pt window the header's Claude button sits where it was, so retrying on Collapse opened two extra Claude tabs in run #1, and with them the payoff lost its colour bars.
- lpm sends run #1's prompt the moment Run in duplicates is confirmed, with no readiness check, so any screen a CLI shows first (a trust prompt, an intro) takes the paste and the Enter, and that side ends as
✗ no page. The lesson shell records each folder's Claude and Codex trust throughclaude/codexshims at the front of its PATH (lesson/scripts/kit.js): lpm's own zsh startup defines acodex()function after the user's.zshrc(shellwrap.rs, since 2026-10-10) and runscommand codex, which skipped the shell-function wrappers used before, so Codex sat on its trust prompt. Muse Code takes--trust-workspaceinstead. - A new Codex model can open with a one-time intro screen, and that screen takes the first Enter. If the dry run shows one, dismiss it in the
hookbeat before the prompt is typed. - The project gets its own
global.ymlwith no actions, which keeps lpm's default Claude and Codex buttons out of the header, so only the race's buttons show. - lpm refuses a project with no service, so the project has a
previewservice that is never started. - The copy inherits the project's header buttons, so each is named after its CLI ("Claude", "Codex", "Cursor", "Muse"), not a model; otherwise the model B row would show a model A button. The banners and colour bars name the models.
- The copy is a clone of run #1's folder, made a second or two after run #1 gets the prompt. A model fast enough to write
index.htmlin that window would hand the copy its page; thegobeat logs a warning if the copy starts with one. - Codex prints the path of the
index.htmlit wrote, and lpm opens a file preview over everything when that path is clicked. The reveal makes a passive row active by clicking its pane header, never its terminal, and presses Escape if a dialog is open. take.shruns undercaffeinate: a slow model can leave the pointer still for longer than the display-sleep timer.- Codex 0.157 changed its rollout: the prompt is an
item_completedevent whose item is aUserMessage, not auser_messageevent. The race looks for either. A side whose clock never starts (nosentAt) never finishes and ends as✗ no pageeven withindex.htmlwritten, so check the rollout format first when a Codex update lands.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

