Communitygithub.com

techgirlcrystal/product-video-skill

Créez des vidéos produit animées et soignées (MP4, 16:9 et 9:16) à partir des données réelles du produit, avec sous-titres, curseur animé, effets sonores et musique, sans voix off.

Qu'est-ce que product-video-skill ?

Cette compétence permet aux agents IA (comme Claude Code) de réaliser des vidéos produites de haute qualité, animées en motion graphics, à partir des sorties réelles d'un logiciel. Elle transforme un storyboard en vidéo MP4 en générant une animation HTML (via `window.seek(t)`) rendue image par image par Playwright, puis encodée avec ffmpeg. Le résultat est reproductible à l'identique sur n'importe quelle machine. La compétence gère l'extraction d'assets, la composition, la musique et les effets sonores, les versions verticales (9:16) et les extraits courts (15s). Elle inclut également des scripts pour la synthèse de sons UI (clic, pop, whoosh...) et l'analyse musicale, le tout en local. Elle est utilisable dans Claude Code (CLI, desktop, web) et nécessite Node.js, Python, Playwright et ffmpeg. Son workflow est structuré : vérification de l'environnement, capture des données réelles du produit, storyboard, build, prévisualisation, rendu, ajout de la musique et des effets, livraison. La checklist de livraison garantit que chaque nombre, nom et diagramme provient du produit réel, et que les transitions sont parfaites.

Compatible avec✓Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/techgirlcrystal/product-video-skill/tree/HEAD/product-video

Demander à votre IA préférée

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

Documentation

Vidéo produit

Créez une vidéo de présentation produit rythmée par la musique, sans voix off, sous forme d'animation HTML rendue image par image en MP4. Chaque nombre, nom et diagramme provient des sorties réelles du produit. C'est ce qui rend la vidéo crédible et la distingue des motion graphics génériques.

Fonctionnement : une page HTML à la résolution cible définit window.seek(t), qui dessine l'image au temps t comme une fonction pure (pas d'animations CSS, pas de temporisateurs). Playwright appelle seek(i/30) et capture chaque image, et les images sont envoyées à ffmpeg. Comme les images ne dépendent pas du temps réel, le résultat est identique sur n'importe quelle machine, vous pouvez prévisualiser une image quelconque, et les modifications sont rendues en minutes.

Fichiers fournis :

  • scripts/render.mjs : composition vers MP4 (--url --out [--w --h --fps --from --to])
  • scripts/preview.mjs : images fixes à des moments choisis, plus --sheet pour une bande contact
  • scripts/cutdown.py : extraits courts (ex. 15s) découpés d'une composition existante : rend les plages temporelles choisies, les assemble avec des coupes franches, place le drop de la musique sur la première coupe
  • scripts/cues.mjs : dérive une liste de repères d'effets sonores à partir de la composition (whooshes de scène, pops de cartes/puces, ticks de compteurs, clics de curseur, carillon d'URL, plus window.SFX_EXTRA)
  • scripts/sfx.py : synthétise de toutes pièces une kit sonore UI (clic, pop, whoosh, tick, touche, carillon, bruit sourd ; pas d'audio stocké ni de licence), mixe les repères dans une piste et effectue le mixage final musique + effets à -16 LUFS
  • scripts/music.py : analyze la carte d'énergie d'une piste, et mux sous la vidéo (coupe, fondu, -16 LUFS)
  • scripts/doctor.mjs : vérifie chaque condition ci-dessous et imprime la correction exacte pour tout élément manquant
  • scripts/_common.mjs : trouve Chromium et ffmpeg préinstallés (repli pip imageio-ffmpeg)
  • assets/template.html : un modèle de scène fonctionnel ; un seul fichier rend 16:9 et 9:16 via une media query portrait
  • assets/fonts-manrope.css : police Manrope intégrée (solution de repli si le produit n'a pas de police intégrée)
  • assets/examples/supersnapshot/ : (Super Snapshot AI, un outil GoHighLevel) le code source complet d'une vidéo 80s réalisée (16:9 + vertical), un exemple concret de chaque motif à un niveau de qualité production
  • references/story-and-copy.md : l'arc narratif, les règles de titrage, les règles d'honnêteté, les conventions de timing. À lire avant le storyboard.
  • references/extraction.md : comment trouver une source de données fiable et extraire les SVG, graphiques et captures d'écran du produit. À lire avant la capture.

Prérequis

La compétence exécute des commandes shell, elle nécessite donc Claude Code (CLI, application de bureau ou Claude Code sur le web). Une simple conversation sans environnement de code peut planifier un storyboard mais pas effectuer le rendu. Sur la machine ou le conteneur :

BesoinPourquoiInstallation
Node.js 18+exécute les scripts de rendunodejs.org ou nvm install 22
Paquet npm playwright, importable depuis le répertoire de travailpilote le navigateur image par imagenpm i -D playwright (de nombreux dépôts web l'ont déjà)
Chromiumrend les imagesnpx playwright install chromium, ou réutiliser un Chromium préinstallé (CHROME=/chemin ; /opt/pw-browsers est trouvé automatiquement)
Python 3.9+ avec numpysynthèse et mixage des effets sonorespip install numpy
ffmpegencodage, musique, mixageffmpeg système, ou pip install imageio-ffmpeg

L'accès réseau n'est nécessaire que pour installer ces éléments. Le rendu est entièrement hors ligne. L'utilisateur fournit sa propre piste musicale ; les effets sonores sont synthétisés, donc rien à licencier.

Flux de travail

0. Vérifier la configuration

Depuis le dépôt du produit, exécutez node <skill>/scripts/doctor.mjs. Si quelque chose affiche ✗, exécutez la correction indiquée (ou demandez à l'utilisateur de le faire, si vous ne pouvez pas installer de paquets dans cet environnement) avant de commencer. Trouver un ffmpeg manquant après une construction de 30 minutes fait perdre toute la session.

1. Trouver le matériel réel

Lisez references/extraction.md. Localisez une version de démonstration/example du produit (scripts du dépôt, fixtures, ou une URL d'exemple publique), ouvrez-la dans Playwright, parcourez chaque onglet et videz le texte de chaque volet. Capturez les volets et examinez-les. Vous cherchez : le nombre réel le plus frappant (l'accroche), les fonctionnalités pour lesquelles un acheteur paierait, et les visuels qui rendent bien en mouvement.

2. Storyboard, puis obtenir un accord

Lisez references/story-and-copy.md. Proposez un tableau : # · temps · ce qui est à l'écran · légende à l'écran. Limitez-vous à environ 60–75s (ou 30–45s pour un extrait social). Dites honnêtement quelles fonctionnalités sont visuellement faibles. Ne posez que les quelques questions auxquelles seul l'utilisateur peut répondre, et rien de plus :

  • quoi éviter de mentionner,
  • l'appel à l'action (par défaut : URL uniquement),
  • le look de marque (par défaut : correspondre aux tokens du produit).

Attendez leur feu vert avant de construire, car re-découper un rendu finalisé coûte bien plus cher que d'éditer un tableau.

3. Capturer les assets

Placez tout dans un répertoire de travail temporaire en dehors du dépôt du produit (le scratchpad de la session s'il existe, sinon un répertoire temp) : <work>/index.html + <work>/assets/. Extrayez les diagrammes SVG, le JSON des graphiques et les captures d'écran de rapports longs comme décrit dans extraction.md. Copiez la police CSS embarquée du produit vers assets/fonts.css (ou assets/fonts-manrope.css de cette compétence).

4. Construire la composition

Copiez assets/template.html vers <work>/index.html. Remplacez chaque espace réservé [BRACKETED] par le contenu réel, supprimez les scènes inutiles, et dupliquez celles dont vous avez besoin. Parcourez l'exemple dans assets/examples/supersnapshot/index.html pour plus de motifs (cartes "problème" chaleureuses, carte barre avec une boîte d'appel, cadran de score, carte de dépendance radiale, réseau d'un compte entier, lignes de correctifs avec balises de sévérité).

Éléments importants :

  • Le timing vit à deux endroits : les heures de début SCENES, et le data-in de chaque élément. Si vous insérez une scène, décalez chaque data-in ultérieur et toute heure codée en dur dans seek() du même montant (une petite regex sur les valeurs data-in="…" ≥ le point d'insertion fait l'affaire).
  • Fondus enchaînés : la nouvelle scène apparaît en fondu sur l'ancienne, qui reste pleine en dessous. Fondre les deux en même temps donne des scènes claires qui virent au gris boueux.
  • Révélations : les parties SVG apparaissent dans l'ordre de lecture (de haut en bas, ou du centre vers l'extérieur). Les pointes de flèche n'apparaissent qu'une fois leur ligne posée. Associez un surlignage à un nœud par son texte d'étiquette.
  • Callouts : les puces et étiquettes ne doivent jamais couvrir ce qu'elles pointent. Placez-les dans un espace vide à côté, et faites-les suivre si la caméra panoramique.

5. Prévisualiser avant le rendu

Servez le répertoire (cd <work> && python3 -m http.server 8765 &) et rendez des images fixes au moment clé de chaque scène :

node <skill>/scripts/preview.mjs --url http://127.0.0.1:8765/index.html --dir <work>/prev --sheet 5 9 13 22 31 43 50 60

Regardez chaque image. Vérifiez les chevauchements, les sauts de ligne maladroits (forcez-les avec <br>), les éléments apparaissant avant ce qu'ils pointent, les cartes vides et le texte d'espace réservé oublié. Corrigez et re-prévisualisez jusqu'à ce que ce soit propre. Les scripts nécessitent playwright : exécutez-les depuis un répertoire dont le node_modules le contient (le dépôt du produit le fait généralement). Ils trouvent aussi un Chromium préinstallé tout seuls, donc n'exécutez pas playwright install.

6. Rendre et vérifier

node <skill>/scripts/render.mjs --url http://127.0.0.1:8765/index.html --out <work>/video.mp4

Environ 3–5 minutes pour 80s en 1080p30. Ensuite, extrayez des images du MP4 lui-même aux transitions de scène (ffmpeg -ss <t> -i video.mp4 -frames:v 1 x.jpg) pour détecter les problèmes de transition que les images fixes seules ne montrent pas.

7. Musique

Lorsque l'utilisateur envoie une piste :

python3 <skill>/scripts/music.py analyze track.mp3             # trouver l'intro, le drop, les breakdowns
python3 <skill>/scripts/music.py analyze track.mp3 --zoom 14 17 # caler le drop sur le temps
python3 <skill>/scripts/music.py mux video.mp4 track.mp3 out.mp4 [--offset s]

L'objectif est que le drop tombe sur la coupe de la révélation de marque vers la première scène de fonctionnalité. Choisissez --offset (ou ajustez SCENES) pour y parvenir. Indiquez à l'utilisateur où se situent les passages calmes. Si une scène de vente clé se trouve dans un breakdown, suggérez de réorganiser les scènes.

7b. Curseur et effets sonores

Ils donnent l'impression que la vidéo montre un vrai produit en cours d'utilisation, mais seulement si chaque son a quelque chose à l'écran qui le provoque.

Curseur : la liste CURSOR du modèle définit 2–4 moments de clic. Le curseur se déplace vers un élément réel (par sélecteur CSS, mesuré à chaque image, donc il suit les panoramiques et fonctionne dans les deux orientations), appuie et laisse une ondulation. Chaque clic doit causer ce qui suit environ 0.1–0.3s plus tard : les barres se remplissent, une étape se surligne, une carte se déploie, la frappe commence. Déplacez le data-in de la réaction si nécessaire. Vérifiez dans les prévisualisations que la cible est déjà apparue lorsqu'elle est cliquée ; cliquer sur un nœud qui n'a pas encore été dessiné semble cassé. Si une cible n'a pas de sélecteur pratique, donnez-lui un id dans init() (par exemple, trouvez un nœud mermaid par son texte d'étiquette).

Sons :

node <skill>/scripts/cues.mjs --url http://127.0.0.1:8765/index.html --out <work>/cues.json
python3 <skill>/scripts/sfx.py mix <work>/cues.json --duration <DURATION> --out <work>/sfx.wav
python3 <skill>/scripts/sfx.py final <work>/video.mp4 --sfx <work>/sfx.wav --music track.mp3 [--offset s] --out <work>/final.mp4

cues.mjs place les sons à partir du timing propre de l'animation, donc ils restent verrouillés après tout nouveau timing. Tout ce qu'il ne peut pas voir (compteurs pilotés par JS au lieu de data-count, frappe, accroche) va dans window.SFX_EXTRA. Restez sobre : pas de son sur les entrées de titres, une seule série de ticks par groupe de compteurs. Gains qui ont fonctionné face à une piste corporate chargée : clic environ -1 dB, touche environ -6, tick environ -8, pop -11, whoosh -10 à -14. Pour vérifier qu'un son n'est pas noyé, comparez-le avec la musique dans la bande >2.5 kHz (passe-haut les deux, comparez les pics) ; les pics en bande large sont trompeurs car les basses de la musique dominent. Si les effets semblent noyés, baissez --music-gain (par défaut -6) avant d'augmenter les gains des effets. final règle le volume avec un gain statique unique, car un dynamic loudnorm écraserait les clics. sfx.py kit <dir> écrit chaque son sous forme de WAV pour audition.

8. Vertical 9:16

Le modèle est adaptatif à l'orientation : rendez la même page avec --w 1080 --h 1920 et la media query portrait prend le relais (titres empilés au-dessus de cartes pleine largeur, contenu clé maintenu entre y≈250 et y≈1550, loin des superpositions des applications sociales). Utilisez <br class="br-v"> pour les sauts de ligne qui ne doivent se produire qu'en portrait. Pour une composition non construite à partir du modèle (comme l'exemple), faites une copie vertical.html avec des positions portrait. Prévisualisez aussi les images portrait, car le texte se répartit différemment.

9. Extraits courts (15s)

Une fois la vidéo verticale existante, découpez 2–4 extraits courts. Chacun a un angle (une douleur, un groupe de fonctionnalités), donc chacun peut être testé comme une annonce ou un post séparé. Ne reconstruisez rien : choisissez des plages temporelles dans la composition verticale et laissez cutdown.py les rendre et les assembler.

python3 <skill>/scripts/cutdown.py --url http://127.0.0.1:8765/vertical.html \
  --seg 3.2-6.2 --seg 6.5-9.0 --seg 15.4-20.9 --seg 75.6-79.6 \
  --out <work>/reel1.mp4 --music track.mp3 --drop 15.0 --sfx

--sfx extrait les repères sonores de chaque segment de la composition, les re-synchronise sur l'extrait, et les mixe avec la musique.

Choix des segments (voir "Short reels" dans references/story-and-copy.md) :

  • Forme : accroche (2.5–3s) → 1–2 temps forts de fonctionnalité (4–5.5s chacun) → carte de fin (4s). Total 15s.
  • Commencez chaque segment après que sa scène est complètement apparue (début de scène + environ 0.5s) ou sur une entrée clé, et terminez-le après que son payoff est arrivé : compteurs terminés, la puce a popé, le surlignage est allumé. Vérifiez les temps data-in/count dans la composition. Un compteur coupé en plein décompte est l'erreur classique.
  • Commencez le segment de carte de fin environ 0.6s après que le logo a popé, afin que l'URL soit à l'écran pendant 3s ou plus.
  • Gardez chaque longueur de segment comme un multiple du temps (0.5s à 120 BPM) pour que toutes les coupes tombent sur les temps forts, et passez --drop pour que le drop touche la première coupe.
  • La première image d'un extrait doit déjà montrer l'accroche. Il n'y a pas de temps pour un fondu lent.

Après le rendu, extrayez une image du milieu et de la fin de chaque segment dans le MP4 fini et examinez-les. Indiquez ensuite à l'utilisateur quel extrait poster en premier (celui qui s'ouvre sur un problème), lesquels sont uniquement pour un public chaud (pur plaisir visuel sans douleur), et que les mentions légales ne seront pas lisibles à ce rythme, donc l'accroche doit aussi figurer dans la légende du post.

10. Livrer

Envoyez le(s) MP4 à l'utilisateur sous forme de fichiers. Faites ensuite une critique honnête : durée totale (80s c'est long ; 30–45s convient mieux pour Reels/Shorts), la scène la plus faible, et une coupe ou réorganisation concrète. Proposez les prochaines étapes : version verticale, extraits 15s, musique, réductions. N'engagez pas les fichiers vidéo ou les sources de construction dans le dépôt du produit sauf demande explicite.

Liste de vérification de livraison

  • Chaque nombre/nom à l'écran correspond aux sorties réelles du produit
  • Rien de ce que l'utilisateur a demandé d'exclure n'apparaît nulle part
  • Aucun texte [placeholder] laissé, aucun élément rogné ou chevauchant dans toute image prévisualisée
  • Le nombre accroche compte dans les 5 premières secondes ; l'URL est à l'écran pendant au moins 3s à la fin
  • Transitions vérifiées dans le MP4 encodé, pas seulement dans les images fixes
  • La musique (si présente) est coupée, fondue, normalisée, et son drop tombe sur une coupe de scène
  • Chaque clic de curseur atterrit sur un élément déjà visible et cause quelque chose
  • Les clics, touches et ticks sont audibles par-dessus la musique (vérifiez la bande >2.5 kHz), et le mix final est à -16 LUFS
  • Extraits : chaque segment se termine après son payoff (pas de compteurs à moitié finis), l'URL s'affiche 3s ou plus, les coupes tombent sur les temps forts

Skills associés