Communitygithub.com

film-build

Construisez un film produit en code sous forme d'une page web déterministe seek(t) (UI produit réelle, chrome OS réel, texte cinétique, invites typées, curseur, morphing et mouvements de caméra), révisez-le sous forme d'images fixes et de brouillons, effectuez le rendu à 60 ips avec flou de mouvement et adaptez-le au format 9:16 sans modifier le 16:9. Livre un kit de projet (init.sh, moteur de film, outils de rendu/synchronisation/sondage/planche/régression). Étapes 3 et 6 de product-film. À utiliser lors de la construction, de la correction ou du rendu d'un film de lancement/promotion, ou pour réaliser sa version verticale.

Qu'est-ce que film-build ?

Ce skill est conçu pour les développeurs utilisant des agents IA (comme Claude Code) qui souhaitent créer des films produits (lancement, promotion) entièrement en code. Il fournit un moteur de film déterministe basé sur des scènes temporelles, où chaque image est une fonction pure de l'instant t. Le skill propose un kit complet incluant un fichier d'initialisation, un moteur de film (film/core.js), des helpers (cam, typed, keyed, sprite, pop, etc.) et des outils de rendu, de synchronisation, de sondage et de régression. Il supporte le rendu 60 ips avec flou de mouvement, la révision via des images fixes et des brouillards, et l'adaptation au format 9:16 sans altérer la version 16:9. Idéal pour la construction, la correction et le rendu de films promotionnels, avec un accent sur le réalisme (UI réelle, chrome OS, polices) et une boucle de développement pilotée par la révision.

Compatible avec✓Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/aqeelshamz/product-film-skills/tree/HEAD/film-build

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Construction de film

Démarrage

sh ~/.claude/skills/film-build/kit/init.sh marketing/videos/<film>   # refuse un dossier non vide
cd marketing/videos/<film> && npm i && npx playwright install chromium   # si cela indique NEXT

Le kit vous fournit :

FichierDescription
film/core.jsle moteur : scene({name, from, to, build, run, after}) (temps en beats = s × 2), put(el, {o, css}), reg(el, base), C.W/C.H/C.FMT, C.start()
film/film.jsun starter avec tous les helpers ci-dessous et quatre exemples de plans (line, prompt, split, fiche personnage). Le commentaire de chaque helper indique de quel rejet il provient. Remplacez les plans, conservez les helpers.
film/mock.jswindow.MOCK : HTML pour des éléments d'interface réelle (tableaux de bord, fenêtres, écrans de téléphone), en pixels écran
film/index.htmlcharge les polices depuis assets/fonts/{display,ui}.woff2 (avec des polices de secours locales sans empattement)
scripts/render.mjs--sheet, --at t1,t2, --draft, --range a,b, --verify, final, --mux, --fmt 9x16, --all
scripts/sync.mjscopie timeline.json dans la page
scripts/review.pykit de critique à partir du MP4 rendu : planche contact, bandes d'action la plus rapide, vue téléphone, zones de sécurité 9:16, métriques
tools/probe.mjscuts (chaque coupe et le point médian de chaque plan, en secondes vidéo) ou toute expression, par ex. "window.UNWARP(12.4)"
tools/sheet.pyorganise les images fixes en une seule planche étiquetée
tools/pack_grid.pydécoupe une planche de personnage 4×3 (transparent ou sur fond blanc) en une bande de 12 cellules pour sprite() ; imprime la taille des cellules
tools/cut_cast.pydécoupe un alignement d'une rangée en personnages fixes individuels
assets/characters/quatre exemples de personnages (fondateur, développeur, vendeur, étudiant), bandes de 12 images avec cellules de 360 px
tools/same.shsave / check régression PSNR entre les images fixes avant et après

Helpers dans le starter (utilisez-les, ne réinventez pas)

  • io (quintique entrée-sortie) pour les mouvements de caméra et les morphing ; oq (quintique sortie) pour les entrées ; back pour un petit dépassement.
  • cam(e, s, fx, fy) place le point de focalisation (fx, fy) d'un plan 1920×1080 au centre du cadre à l'échelle s. camD fait la même chose mais ne montre jamais au-delà des bords du plan (échelle de couverture ; essentiel en 9:16).
  • posIn(e, root) lit la position d'un élément à l'intérieur du plan en mouvement (pour les cibles du curseur, le suivi du caret).
  • typed() pour les mots apparaissant lettre par lettre dans une ligne ; keyed() pour un vrai clavier : temporisation irrégulière par caractère, pauses plus longues sur les espaces, caret clignotant après.
  • wordsHTML() dispose chaque mot à sa largeur finale dès la première image, transparent jusqu'à son heure, afin que la ligne ne se reflue jamais ("la transition de texte n'est pas du tout fluide").
  • cursor()/putCursor()/bump() : un vrai curseur flèche qui glisse, arrive en avance, plonge de 15 % lors d'un clic.
  • pop() pour les petits éléments qui atterrissent.
  • sprite(parent, src, cellW, cellH, h) / putSprite(e, t, a, z, loops) pour un personnage dessiné : parcourt ses 12 images de a à z, avec une petite respiration pour qu'il ne reste jamais immobile. C'est un <img>, donc le moteur l'attend.
  • shot(name, t0, t1, build, run) encapsule scene en secondes.
  • Warp de rythme en bas : SLOW (étirement global), EV arrêts (figer un instant pour la lecture) et insertions ; window.CUTS et window.UNWARP donnent les temps vidéo pour le placement du son et de la voix.
  • PT / pk(a16, a9) choisir des valeurs par format dans un seul fichier.

Règles du moteur (déterminisme)

Le film est une fonction pure de t. Chaque image doit s'afficher de la même manière qu'elle soit rendue en premier ou après toute autre image.

  • Transformations 2D uniquement : pas de translate3d, pas de will-change, pas de transitions CSS, pas de Math.random (utilisez un hash d'un index).
  • Éléments cachés au démarrage : reg(el, {o: 0}), jamais opacity:0 en ligne.
  • Mesurez la mise en page dans after() ou une fois dans build, jamais dans run (cela lit l'image précédente).
  • Vues 3D : réinsérez chaque image avec insertBefore(v, firstChild) afin qu'aucun raster mis en cache ne persiste.
  • Animations CSS intégrées (par ex. le propre widget d'un produit) : mettez-les en pause et définissez animation-delay: calc(-1s * var(--t)).
  • Attendez les images et les polices (decode(), document.fonts.ready) avant la première image.
  • Limitez le CSS du produit sous une classe racine unique ; utilisez des noms de classe uniques dans le film (.w a déjà fuité une fois).
  • classList.add, jamais className =.
  • node scripts/render.mjs --verify doit afficher 12/12 avant tout rendu que vous envoyez.

Réalisme : lisez references/realism.md avant de construire un écran

Version courte : vraies applications à densité réelle, vrais logos provenant des sites des marques, chrome OS avec des applications qui existent sur ce système d'exploitation, vrais fonds d'écran, téléphones sur la grille du lanceur réel aux tailles dp réelles dessinées par le moteur de rendu du produit lui-même, UI produit plus riche que vous ne le pensez, une ligne d'utilisation nominative chaque fois qu'une marque apparaît.

Boucle de construction (pilotée par la révision)

  1. Liste des plans à partir du storyboard approuvé dans film.js, un shot() chacun, se chevauchant pour les transitions.
  2. D'abord les images fixes. node tools/probe.mjs cuts → effectuez le rendu d'une image fixe au point médian de chaque plan et à chaque transition : node scripts/render.mjs --at … puis python3 tools/sheet.py review/stills/16x9 review/sheet.jpg <times>. Lisez la planche vous-même. Corrigez. Répétez. (Environ 1 à 2 minutes par cycle, contre 25+ pour un rendu complet.)
  3. Passage assurance qualité AVANT tout envoi pour révision : parcourez le film à ≤ 1,5 s et à chaque transition (planche contact à 10–15 ips sur chaque transition). Vérifiez references/qa.md ligne par ligne : chevauchements, rognage, images vides, temps de lecture, fluidité du texte, saisie, avis de logo, réalisme du système d'exploitation, tailles de téléphone.
  4. Envoyez les images fixes (la planche) au propriétaire pour le premier coup d'œil. Attendez.
  5. Brouillon : node scripts/render.mjs --draft (30 ips, ~4 min), python3 scripts/review.py 1 --draft, lisez les bandes. Envoyez le MP4 du brouillon. Dites clairement qu'il s'agit d'un brouillon à 30 ips sans flou (ça donne un aspect plus saccadé que la version finale).
  6. Pour le rendu final : node scripts/render.mjs en arrière-plan (60 ips, flou de mouvement ; ~25–35 min pour 60 s). Ne modifiez jamais film.js pendant le rendu : copiez d'abord le projet si vous devez continuer à travailler.
  7. Validez le code du film et la chronologie après chaque cycle approuvé.

Rythme

Les premiers montages sont presque toujours trop rapides. Le texte à l'écran nécessite environ 0,3 s par mot + 1 s à pleine opacité (jamais moins de 1,5 s). Privilégiez le warp (SLOW 1,1–1,25, arrêts EV sur les lignes) plutôt que de retemporiser chaque plan. Après tout changement de rythme, relancez probe.mjs cuts car les positions du son et de la voix bougent.

9:16 : lisez references/formats.md

Recadrez le même film dans un seul fichier avec pk() ; prouvez que le 16:9 n'est pas modifié avec tools/same.sh (chaque image fixe PSNR = inf) ; --verify --fmt 9x16 ; planche d'images fixes pour le propriétaire ; puis --fmt 9x16 final en arrière-plan, puis --mux --fmt 9x16.

Individual skills in this repo

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

film-sound

Add sound to a finished product-film picture with real recorded sound effects (CC0 packs such as Kenney's) placed only on real on-screen events, decide with the owner whether there's a music bed, mix to -14 LUFS and mux into the renders without re-rendering. Stage 4 of product-film. Use when a film's picture is approved and needs sound effects or music, or when the owner says the sounds feel fake, synthetic or "AI slop".

film-storyboard

Write the story of a product film as beats (what the viewer sees, the words on screen, the voice, the sound, why the beat exists, and where each claim is proven) and send it to the owner as a one-page storyboard with frames for review, with 2–4 directions when the story is open. Stage 2 of product-film, and the review format reused for the voiceover. Use when planning a launch/promo film's story, shot list, or script, or when the owner says "give me a storyboard", "give me directions", "I'll review and decide".

film-voiceover

Write, review, test and record the voiceover for a product film after its picture is approved, as a script on a storyboard of the film's real frames, with directions to choose from, an eyes-closed coherence check, a pronunciation test for the product name, TTS recording per section (Fish Audio), phrase placement on the film's timeline, mixing and muxing. Stage 5 of product-film. Use when a launch/promo film needs narration, or the owner says the voiceover sounds like AI, doesn't match the frames, or mispronounces the name.

product-film

Make a product launch / promo / explainer film that sells and does not look or sound AI-made, through review gates the owner signs off one at a time. Study a reference video for its grammar (never copy it), then storyboard, build the film in code, add sound, write and record the voiceover, and deliver 16:9 and 9:16. Use when someone wants a launch video, promo, product film, explainer, ad, "a video like this one" for their product, or says the last video looked like "AI slop" or "vibe coded". Entry point for the film-* skills (film-reference-study, film-storyboard, film-build, film-sound, film-voiceover).

Skills associés