Direct a Product Launch Film

Own the creative standard from product truth through final render. Make the film communicate one valuable product change, prove it on screen, and end with one unmistakable action.

This skill is the creative-director and quality layer. It is not tied to one duration, frame rate, aspect ratio, rendering stack, or visual style. For a HyperFrames build, also load hyperframes, product-launch-video, hyperframes-core, hyperframes-creative, hyperframes-animation, hyperframes-cli, media-use, and music-to-video only as their capabilities become necessary. Let the installed production workflow own scaffolding and command contracts; use this skill to make the story, frames, pacing, and final judgment better.

Interaction

In Plan mode, use the host's native dedicated user-input or question tool for every unresolved decision that materially changes scope or creative direction. Ask one to three short, related questions per call. Use mutually exclusive selectable options when useful, put the recommended choice first, explain its tradeoff briefly, and wait for the answers before locking that part of the plan. When asking about duration or frame rate, present useful recommendations without implying those options are the only valid choices; preserve the native custom-answer path.

Resolve decisions in small groups:

1. Delivery — platform, aspect ratio, resolution, duration, frame rate, codecs, and cutdowns.
2. Story — audience, launch objective, primary promise, proof, CTA, narration, and language.
3. Direction — energy, references, music, sound design, brand boundaries, and review cadence.

Do not ask all of these when the repository, product, or user already answers them. If no native input tool is available, ask one concise blocking question at a time. Do not dump a creative brief questionnaire into normal chat. Infer only non-critical details and label the assumptions.

Never ask for information already available in the product, repository, captured site, existing brief, storyboard, design system, or prior review notes.

Choose the operation

Apply the first matching path:

1. Existing project plus a specific edit — inspect the named frame or current Studio selection, make the edit, snapshot it, and run the smallest relevant check. Do not restart discovery.
2. Existing film needing critique or polish — read audit-and-evaluation.md, inspect representative frames and the whole playback, then fix or report the highest-impact weaknesses.
3. Approved storyboard awaiting production — preserve story truth, load visual-and-motion-direction.md, and build.
4. Fresh product launch — run the complete workflow below.

1. Establish product truth

Inspect the product before inventing a concept. Use the live product, repository, design files, documentation, screenshots, or supplied brief. Separate:

• what the product demonstrably does;
• what changes for the user;
• what can be shown rather than asserted;
• what action the viewer should take next.

Write one sentence each for audience, problem, promise, proof, and call to action. If the promise cannot be proven on screen, narrow it.

When auditing rather than creating, distinguish a contradicted claim from a claim whose evidence is absent from the supplied package. Seek the canonical source before calling a claim false; otherwise label the verification blocker precisely.

For detailed persuasion patterns and claim discipline, read story-and-persuasion.md.

2. Lock the production brief

Record:

• product name and canonical URL;
• audience and launch context;
• one primary promise;
• two or three proof moments;
• final call to action;
• destination and aspect ratio;
• exact duration and frame rate;
• narration mode;
• music direction and sound constraints;
• brand sources and forbidden treatments;
• review mode: collaborative or autonomous.

Do not silently force 20 seconds or 60fps. Ask the user when those values are unresolved. Choose them from the distribution context:

• 6–10 seconds for bumpers, teasers, and looping paid placements;
• 15–30 seconds for concise feed launches and product reveals;
• 30–60 seconds for a product story with one complete proof loop;
• 60–120 seconds for narrated explainers or several connected proof beats;
• 24fps for cinematic cadence, 25fps for PAL delivery, 30fps for common web/social work, 50/60fps for crisp interface motion or high-energy playback, and source-native rates when delivery requires them.

Treat these as decision support, not presets. Confirm the platform specification when it controls the output. If the user delegates the choice, recommend a format and state why.

The duration is a constraint, not an aspiration. Design every beat so the full film resolves inside it.

3. Design the story spine

Use five functional beats unless the product requires fewer:

1. Hook — the audience’s problem or desire in their own language.
2. Reveal — name the product and land the promise.
3. Proof — show the core product loop.
4. Payoff — show why the interaction or outcome is materially better.
5. Action — make the next step concrete.

Do not turn the film into a feature inventory. Every frame must advance the same argument.

Write a storyboard with global time, local scene time, message, focal element, motion verb, transition, music cue, and held poster moment. Read story-and-persuasion.md before drafting or substantially revising the spine. When the film uses narration, dialogue, or substantial on-screen copy, also read scripting-and-voice.md.

4. Translate the brand into a video system

Extract exact colors, typefaces, surface rules, corner language, iconography, imagery, and tone from the source. Preserve the brand atoms; redesign the composition for video.

Create a frame-scale design specification. Define:

• canvas, ink, structural dark, accent, and success colors;
• display, body, mono, and code typography;
• title-safe margins and spacing scale;
• panel, terminal, browser, CTA, and metadata treatments;
• rules for screenshots, shadows, grids, grain, and decorative type;
• explicit “do not use” treatments.

Do not copy a web layout into a 16:9 frame. Video type is larger, contrast is stronger, depth is more explicit, and each scene needs a visual path.

Read visual-and-motion-direction.md before authoring frames. Aim for agency-grade finish: purposeful typography, designed transitions, controlled compositing, tactile product motion, visual motifs that recur, and no untreated template surfaces.

5. Let music drive time

Choose, license, commission, or generate music before final choreography. Prefer tracks with a clear pulse, useful section changes, enough spectral room for narration, and an ending that supports the film’s exact duration.

Analyze beats, downbeats, energy phases, fills, surges, and hard stops. Put scene changes on musically meaningful boundaries. Use secondary onsets for text hits, cursor actions, card arrivals, and progress changes.

Do not add unrelated sound effects merely to fill space. A clean music-only mix is better than mismatched UI sounds. Keep dialogue or narration intelligible when present.

Read music-and-sound.md before sourcing, generating, editing, or mixing audio. Record provenance and publication rights for every retained track and sound.

6. Direct every frame

Give each frame:

• one dominant idea;
• two focal points;
• background, midground, and foreground layers;
• eight to ten intentional visual elements at full build;
• one primary entrance language plus supporting motion;
• build, breathe, and resolve phases;
• a readable held state.

Use different directions, durations, and eases according to hierarchy. Fast motion communicates urgency; slow motion communicates weight. Choreograph the most important element first.

Treat screenshots as footage: crop, pan, scroll, layer, or place them in a device/browser surface. Never leave a raw low-opacity screenshot competing with the headline.

Use high-energy transitions selectively. Pick one primary transition family for continuity and one or two accents for topic changes or the climax. A different transition at every cut feels like a demo reel.

Read choreography-and-editing.md before timing the master edit or polishing motion. Build a cue sheet that maps story beats, musical phrases, visual accents, readable holds, transitions, and sound effects on one shared timeline.

7. Protect the three decisive frames

Product reveal

The second frame cannot be a centered logo slide. Make it an event: use kinetic language, a decisive color hit, edge-anchored scale, proof fragments, or a product surface that resolves into the identity. Land the product name and promise quickly.

Interaction proof

When the product improves an interaction, show cause and effect. Depict the old state, the new native interface, the user action, and the resulting state. A static before/after comparison is weaker than a cursor click, selected state, progress change, saved confirmation, or physical displacement.

Closing action

The last frame is the conversion surface. Keep the terminal, URL, QR code, install command, or CTA large enough to read at phone-feed size. Resolve technical proof into one action. End on a stable frame long enough to read in the target placement. For short feed work, 0.5–1 second is often the minimum; longer or denser CTAs need more.

8. Build deterministically

For HyperFrames production, read hyperframes-production.md. Keep one paused, seekable timeline per composition. Use explicit fromTo states, deterministic timing, transform-based spatial motion, local media, and direct-child timed clips.

Create frame sub-compositions, assemble the master timeline, add audio at the host root, then inject transitions. Keep authored source separate from renders and temporary caches.

9. Review before rendering

Run the development loop:

1. lint after structural edits;
2. capture frame midpoints and transition samples;
3. inspect contact sheets visually;
4. run the complete browser check;
5. open Studio and ask for one final review;
6. render only after approval.

Automated checks do not replace watching. Inspect the actual edit at normal speed with sound. Verify that no frame reads as an unfinished webpage, no text appears for too little time, and the musical climax matches the visual climax.

10. Render and verify

Render the approved output at the requested frame rate and quality. Verify:

• file exists and is non-empty;
• duration matches the brief;
• width, height, and frame rate are exact;
• video and expected audio streams exist;
• final frame is not cut off;
• output and production caches follow the repository’s ignore policy.

Run scripts/audit_launch_video.py for a deterministic artifact check:

python scripts/audit_launch_video.py \
  --project videos/acme-launch \
  --video videos/acme-launch/renders/final.mp4 \
  --duration <seconds> --fps <frames-per-second> \
  --width <pixels> --height <pixels>

Definition of done

The film is done only when:

• the product claim is true and visibly supported;
• the story has one clear promise and one clear action;
• the brand is recognizable without resembling a web screenshot montage;
• motion is paced to music and remains readable;
• the reveal, interaction proof, and closing action all land;
• lint, runtime, layout, motion, and contrast gates pass;
• the user approved the Studio preview;
• the final artifact passes the technical audit.

For a formal score and failure-mode review, use audit-and-evaluation.md.