Communitygithub.com

product-film

Launch video from your product's real screens: 34 seconds in five acts (problem, promise, the product at work, result, ask) with a big cursor, a moving camera, captions and sound, in wide, square and tall. Use when the user asks for a launch video, product video, promo, demo video, teaser or motion graphics for their product, app or website.

What is product-film?

product-film is a Cursor agent skill that launch video from your product's real screens: 34 seconds in five acts (problem, promise, the product at work, result, ask) with a big cursor, a moving camera, captions and sound, in wide, square and tall. Use when the user asks for a launch video, product video, promo, demo video, teaser or motion graphics for their product, app or website.

Works with~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/omnigami-ai/plugins/tree/main/plugins/omnigami-launch-films/skills/product-film

Ask in your favorite AI

Open a new chat with this agent skill pre-loaded.

Documentation

Product film

Explicit user instructions take priority over this workflow. Work only on authorized products and sample data. Do not request passwords, API keys, payment data, government identifiers, health records or other sensitive data. Explain missing local dependencies before installing them in the working project. Network access is for the authorized product and its licensed assets, plus the declared npm dependency; respect access controls. Render one job at a time and wait for completion. Keep publishing, sending and deployment outside this task.

If several skills could do this: when the request doesn't name this skill and your agent also has other omnigami skills that make the same kind of thing (other launch films, shots, decks or mockups), list them by name and ask which one the user wants before you start. If it's named, or it's the only one installed, go ahead.

For Japanese, Korean or Chinese product pages, keep the copy in that language and set the film’s lang to the page’s <html lang>; bundled Noto faces and phrase breaks handle the text.

Make a launch film that sells one product: the problem in huge type, one line of promise, four proof steps on the product's real screens, the result, and an ask held to the last frame. Start from the finished film in reference/ (Lamplit, a fictional developer tool made for omnigami's examples; story in reference/STORY.md). Its toolkit (type, cursor, page camera, color fields, caption column, drawing, music) stays; its words, screens and steps become the user's.

Read style.md before you build and critique.md before you judge.

Start or resume

  • Check Node 20+, ffmpeg and a local Chrome-family browser (scripts/chrome.mjs finds it; CHROME_PATH overrides). Explain anything missing.
  • Use what the user gave: the product's URL, anything to show or avoid, the ask (sign up, install, a URL). Read the site before asking. Ask once for what the site can't answer. If the user wants no questions or an unattended run, decide from the site.
  • If product-film/ already exists with film/STORY.md, this is a revision: work on that film. For another film, use a new folder and reuse PRODUCT.md's brand notes.

Set up a first film:

mkdir product-film && cd product-film
cp -R "$SKILL_DIR/reference" reference && cp -R "$SKILL_DIR/scripts" scripts && cp -R "$SKILL_DIR/music" music
mkdir film && tar -C "$SKILL_DIR/reference" --exclude='./assets/screens' --exclude='./assets/brand' --exclude='./plans' -cf - . | tar -C film -xf -
npm init -y >/dev/null && npm i -D 'puppeteer-core@^24'

film/ is the reference without its screens, brand and plans. puppeteer-core@^24 runs on Node 20; newer major versions can require a newer Node.

SKILL_DIR is this file's folder. reference/ stays untouched, to compare against.

Learn the product, then write the story

  1. node scripts/capture.mjs <url> capture: look at every screenshot and read capture/brand.json. Find what the product does, its own words, its brand color and mark, the claims it makes and where each comes from, and where its real UI can be reached (the page itself, a live demo, a sandbox).
  2. Write film/STORY.md in the shape of reference/STORY.md. It is one story, not a tour of features:
    • the viewer and their goal: who the product is for, and the one job they come to it for, in the site's own terms;
    • the problem in their way, which the site itself names (the hook): the old way and what it costs them, every line of which gets struck out;
    • the turn: the hook's answer in its own terms (the opposite of its problems, in as few words), with the product named within a beat;
    • three or four steps toward the goal on the real product, each with a caption (what the viewer does or learns, a few words), the real screen and the states to capture, the action, and the result on screen that answers the caption;
    • the payoff: the goal reached; the ask: the one action;
    • the times on the 120 BPM grid, and every claim with its source. Numbers come only from a source you cite. Read it back as a stranger would: if a step's result doesn't answer its caption, or a step doesn't move toward the goal, change it.
  3. Show the user the story in a few lines (the five acts, the two actions) and ask for one review, unless they asked for an unattended run. Never take silence as approval.

Capture the real screens

  1. Write film/plans/app.json in the shape of reference/plans/lamplit.json (the format is at the top of scripts/screens.mjs):
    • every state the story shows, as click, type, drag (a held press, for the app's own pressed state) and capture steps;
    • each screen whole, at scale 3, so the camera can move in close;
    • a typed field as type with around its panel (one capture a letter);
    • rects: every element the camera, a color field or the cursor uses, by name. One set of captures serves every shape: each shape frames them for itself. Dismiss cookie banners with a click step. Use hide for anything the film draws itself.
  2. Run it:
    node scripts/screens.mjs film/plans/app.json film/assets/screens
    
  3. Look at every capture. Fix the plan until each state is right. If the UI needs a sign-in, use a public demo, user-supplied screenshots, or an already signed-in local browser the user explicitly authorizes. Never ask for credentials. Never capture customer data, and never draw an imagined UI.

Build the film

Edit film/index.html. Its sections are labeled KEEP, ADAPT and REPLACE.

  • ADAPT the words: DEFAULTS and FIELDS, from STORY.md, including the step captions (step1 … step4) and their times in STEPS.
  • ADAPT the colors: the grounds (INK, NIGHT, INK2), the text and the one accent from the product (the reference is dark first; a light product takes its paper and ink). Put the product's mark in film/assets/brand/mark.svg; it grows under the turn, opens into the one line, and leads the lockups.
  • ADAPT the proof: P (when each click and change happens), screenAt (which capture is on screen), the framings in proofScene (page rects the camera shows whole, with a narrower set for tall), floats (the element in play, alone on a dark field), PATCH (the only regions that change when a state advances in place: measure them by diffing the captures), SETTLED (when each step's result has settled on screen), and the cursor's cursorSets. A page the app opens arrives on a cut; a state that changes in place changes only inside PATCH.
  • Every click in sync with the cursor: write each cursor set with clickKeys (its comment shows Lamplit's three that way). The cursor glides in, arrives and rests still on the target for 0.3–0.5 s, presses exactly when the app's own pressed state shows (the same P time drives both), holds still through the press, then leaves. A field is clicked the same way; the words start typing once the press is over, and the cursor steps aside and holds still while they type. Never key the cursor's arrival and its exit either side of the click: it would be gliding off the button as it presses. Delete APPROVED_CURSOR and Lamplit's own sets (its approved cut predates this rule). The film's checks fail any press where the cursor isn't resting on its target rect, or has moved in the 0.25 s before it.
  • ADAPT the payoff and the ask: TILES (three of your real screens) and your name, address, line to type and tagline. Keep the act times on bar lines, and keep the cues in step with the acts.
  • KEEP the toolkit, the camera, the fields, the drawing, and the 120 BPM grid, with room where the viewer needs it (style.md, "Pauses"): each step's caption reads before its first action; after each result settles, about a second to read it before the next camera or cursor move; after a page change or long glide, the screen holds before the click. Keep it lively: nothing in the proof sits dead for more than about 1.8 s. When your words are longer or shorter, move the holds (TU, ST, P), not the product's own working. When the steps need more room than 34 s gives, lengthen the film a bar (2 s) at a time, up to about 40 s: move ST and DURATION together, keep the acts' shares (style.md, "The five acts"), and update STORY.md's times. The song fits itself to the new length (it lands on the last bar line at least 3.5 s before the end); with --music, stretch the last of music.sections to the new bar count.

Write PRODUCT.md at the project root: the URL, what the product does, the brand color and mark (with licenses), the chosen words, the date.

Review, render, deliver

  1. Sheets and phone checks for every shape:
    node scripts/render.mjs film --all --times key --sheet
    node scripts/render.mjs film --all --phone
    
    Then 12-frame strips at every whip, pull-back and flood, in wide and in tall: node scripts/render.mjs film --size 9:16 --strip <time>.
  2. Score with critique.md and fix the worst problems. Before shipping, get a fresh judgement. If your agent can start a sub-agent without this session's memory, give it critique.md, STORY.md and the images, nothing else, and fix what it finds. Otherwise reread critique.md and score from the images alone. Nothing ships below 8. After three rounds, report what remains.
  3. Check repeatability, a fresh page, long names and the film's own checks: node scripts/render.mjs film --all --check --check-fresh --stress. Don't render until all three shapes pass. A frame that differs only in a fresh page usually means an image first drawn mid-film: draw it once in prepare(). A name that overflows needs to fit its shape at the stress length. The checks also fail a press where the cursor isn't resting on its target, a field typing with the cursor moving, a result with under 0.9 s before the next move, a caption without time to read before its click, a dead hold over 1.8 s in the proof, and a length off the bar grid. Fix the timing, not the checks.
  4. Render:
    node scripts/render.mjs film --all --video --blur 4 --audio music/song.mp3 --sound --poster <time>
    
    This writes out/16x9.mp4, out/1x1.mp4 and out/9x16.mp4: 60 fps, with motion blur, the skill's song and effects, around −14 LUFS. It takes several minutes: run it in the foreground and wait for all three files before handing over. In an unattended run, a render left in the background can be cut off when the session ends. The song (music/song.mp3: nu-disco at 120 BPM) is fitted to each shape: it starts on a bar line and, near the end, lands one hit, where its drums stop and the rest closes and fades (from its stems in music/song-stems/). --from <seconds> starts at another of its distinct 8-bar sections (the song is about two minutes long). --music gives the synthesized score instead; the user's own song works with --audio their.wav.
  5. Run node scripts/preview.mjs film and give its localhost address. It plays every shape and edits the words; saved edits need a new render to reach the MP4s.
  6. Write README.md (the files, how to preview, how to change a word, how to render) and out/CAPTION.md (a post under 280 characters in the product's own words, with its URL). Hand over the MP4 links, the posters, the caption, a short check summary, and the one change that would most improve the film. Put the detailed scores in out/REVIEW.md.

Revisions

For a request like "hold the result longer" or "show the export instead", edit the current story and film. Keep what was approved and the user's saved words. Recapture only the states that changed, rerun the checks, render again, and update STORY.md and PRODUCT.md.

Hard rules

  • Real screens only, captured; sample data only; only the user's brand.
  • Every claim on screen has a source in STORY.md.
  • Breathing room: every step's caption is read before anything moves, the element is seen before it is acted on, and every result reads for about a second before the next camera or cursor move. No dead hold over about 1.8 s. When the story doesn't fit, lengthen the film a bar at a time (up to about 40 s) or drop a step; never compress the holds.
  • The cursor is still on its target when it presses, in time with the app's own pressed state (clickKeys).
  • seek(t, values) paints from its arguments only: no clocks, unseeded randomness, timers or network. CPU-backed canvases, reset every frame.
  • Every file the film loads lives inside film/.

Files

  • reference/: Lamplit's launch film, STORY.md, the capture plan (plans/lamplit.json), the captured screens, the mark, and the fonts with their OFL licenses (Instrument Sans, JetBrains Mono). Lamplit is a fictional company made for omnigami's examples.
  • style.md: the grammar, with numbers. critique.md: the review.
  • music/: the skill's song and its stems.
  • scripts/: screens.mjs (real screens in states), capture.mjs (brand from a URL), render.mjs (stills, strips, checks, MP4s), preview.mjs, music.mjs, song.mjs (fits a supplied song), sfx.mjs with the sound kit, and chrome.mjs.

This skill is omnigami's, © 2026 Auberon LLC. Use what it makes for anything, commercial work included, and change the skill for your own use; don't redistribute or sell the skill. Full terms: LICENSE.md

Individual skills in this repo

This repo contains 4 individual skills — each has its own dedicated page.

Related Skills