Storyboard Vidéo
À faire AVANT qu'une seule image ne soit animée. Une vidéo de démonstration vit ou meurt sur son plan : un mauvais ordre, un accroche manquant ou une durée de 40 secondes la tue, peu importe la qualité du mouvement. Vous êtes la couche créative qui décide quelles scènes existent, dans quel ordre, pendant combien de temps et ce que chacune dit - puis transmet un plan de scène concret au pack mécanique (remotion-setup, remotion-compose, remotion-render) pour le construire.
Intervenez avec empressement sur les intentions de planification : "storyboarde ma démo", "planifie la vidéo", "de quelles scènes j'ai besoin", "structure la vidéo de lancement", "découpe cette fonctionnalité en scènes". Si l'utilisateur passe directement à "anime ça", réalisez d'abord la feuille de beats - un storyboard prend deux minutes et évite un nouveau rendu.
Travaillez sur un exemple tout au long : une vidéo de lancement de 30 secondes pour un outil de revue de code IA appelé Sentinel qui signale les diffs risqués avant la fusion.
Procédure opératoire
Exécutez-les dans l'ordre. N'écrivez pas de texte avant que les beats soient fixés, et ne définissez pas de durées avant que les beats existent - le rythme est fonction de la structure, pas l'inverse.
Étape 1 - Verrouiller l'objectif en une ligne et la plateforme
Avant les beats, fixez deux choses :
- Le message clé unique. Une phrase que le spectateur doit retenir : "Sentinel attrape le bug que votre relecteur a manqué." Si vous ne pouvez pas le dire en une ligne, la vidéo n'a pas de colonne vertébrale. Tout ce qui suit sert cette ligne.
- Plateforme et ratio d'aspect. Paysage 16:9 (1920×1080) pour un héros de site ou YouTube ; portrait 9:16 (1080×1920) pour les réseaux sociaux/Shorts ; carré 1:1 pour le fil d'actualité. Cela définit le canevas que
remotion-composecréera et limite la durée - les réseaux sociaux veulent 15-30s, un héros 20-40s, une présentation de fonctionnalité jusqu'à 60s.
Étape 2 - Poser la feuille de beats (la colonne vertébrale en cinq beats)
Chaque démo, annonce et vidéo de lancement est une version de ces cinq beats. Supprimez un beat seulement avec une raison ; ne réorganisez jamais au-delà de l'accroche.
- Accroche (3 premières secondes). Les 3 secondes les plus importantes de la vidéo - les spectateurs décident de continuer à regarder ici. Ouvrez sur le résultat, la tension ou une affirmation audacieuse, PAS votre logo. "Votre relecteur vient d'approuver un bug" bat "Présentation de Sentinel." Le logo peut être dans le coin ; ce n'est pas l'accroche.
- Problème. Nommez la douleur que le spectateur ressent déjà, concrètement. "Les diffs risqués passent à travers la revue le vendredi à 17h." Un beat, une douleur.
- Révélation. Présentez le produit comme le tournant. C'est là que le nom et le mécanisme principal atterrissent. Montrez la chose en train de faire la chose.
- Preuve. Rendez l'affirmation crédible - un vrai avant/après, un vrai chiffre, un vrai écran. C'est le beat que la plupart des vidéos sautent et celui qui convertit. Utilisez des données produit réelles, jamais de métriques inventées.
- CTA. Une action, une URL. "Essayez Sentinel gratuitement → sentinel.dev." Jamais deux demandes.
Pour une présentation plus longue, les beats Révélation et Preuve se répètent par fonctionnalité (révélation fonctionnalité 1 → preuve, révélation fonctionnalité 2 → preuve). L'accroche, le problème et le CTA restent uniques.
Étape 3 - Attribuer un type de scène et une durée cible à chaque beat
Chaque beat devient une ou plusieurs scènes. Le type de scène détermine le rythme - le texte a besoin de temps de lecture, une démo UI a besoin de temps d'arrêt, un logo est rapide. Utilisez ces cibles (à 30fps ; durationInFrames = secondes × fps) :
| Type de scène | Durée cible | Pourquoi |
|---|---|---|
| Accroche / carton | 2,5-3,5s | Assez long pour lire une ligne, assez court pour garder l'ouverture serrée |
| Déclaration texte | 2,5-4s | ~2,5 mots/seconde de vitesse de lecture ; une ligne de 7 mots a besoin d'environ 3s à l'écran |
| UI / démo produit | 4-6s | L'œil a besoin de temps d'arrêt pour analyser un écran et le mouvement qu'il contient |
| Preuve / données | 3-5s | Un chiffre ou un avant/après a besoin d'un temps pour s'enregistrer |
| Logo / outro CTA | 2,5-4s | Lire l'URL, la laisser respirer, terminer |
Règle de rythme : l'accroche est le plan le plus rapide, la preuve est le plus lent. Si la durée totale est trop longue, coupez une scène - n'accélérez pas chaque scène. Une démo précipitée semble nerveuse.
Étape 4 - Écrire la liste de plans (texte + visuel par scène)
Pour chaque scène, fixez quatre champs : le beat qu'elle sert, le type de scène, le texte à l'écran (les vrais mots - demandez à l'utilisateur, n'inventez jamais d'affirmations), et une brève description visuelle qui indique à remotion-compose quoi rendre. C'est le livrable. La description visuelle est un brief, pas du code : "le terminal tape un git diff, une ligne risquée se colore en rouge" - remotion-compose décide des mécanismes interpolate/spring.
Étape 5 - Émettre le plan de scène JSON
Exécutez le générateur ci-dessous pour transformer la liste de plans en un scene-plan.json structuré. C'est l'artefact de transfert : remotion-compose le lit comme plan de scène (un <Sequence> par scène, from/durationInFrames déjà calculés), et l'indice motion par scène est l'endroit où une décision de motion-design-principles ou motion-color-and-light s'intègre. Sauvegardez-le à côté du projet pour que le pack mécanique puisse le récupérer.
Étape 6 - Transfert
Donnez à l'utilisateur la feuille de beats, le tableau de la liste de plans et le JSON. Puis transférez explicitement : "Voici le plan de scène. Utilisez remotion-setup si le projet n'est pas encore configuré, puis remotion-compose transformera ce JSON en composition et remotion-render l'exportera. Vous voulez ajuster le rythme ou le texte avant d'animer ?" Si la vidéo est spécifiquement une démo produit et que vous voulez un œil de réalisateur sur ce qu'il faut montrer à l'écran par scène, associez avec product-demo-director. Les traitements cinétiques des titres vont à kinetic-typography ; la bande sonore et les coupures synchronisées au rythme vont à sound-and-music-sync ; un recadrage vertical pour les réseaux sociaux va à social-video-formatter.
Barre de qualité
Un storyboard est noté A+ seulement lorsque tout est vérifié :
- L'accroche atterrit dans les 3 premières secondes et n'est PAS le logo - elle ouvre sur le résultat, la tension ou l'affirmation.
- Les cinq beats sont présents, ou chaque beat manquant a une raison énoncée (un teaser peut légitimement omettre la Preuve).
- Chaque scène a une ligne de texte en vrais mots et un brief visuel concret - pas de "une UI ici", pas de métriques inventées.
- La durée totale respecte le plafond de la plateforme, et les durées suivent le tableau des types de scène (accroche rapide, preuve lente), pas un plan fixe toutes les 3s.
- Le CTA est une action unique avec une URL unique.
- Le JSON se valide et ses durées cumulées équivalent au total de la composition que
remotion-composeenregistrera - un décalage est la surprise #1 du rendu.
À NE PAS FAIRE
- N'ouvrez PAS sur un logo ou un fondu d'entrée lent - vous perdez le spectateur avant l'accroche.
- N'inventez PAS de chiffres, de témoignages ou d'affirmations produit pour le beat Preuve ; demandez des données réelles ou supprimez le beat.
- N'écrivez PAS le
.tsx, ne choisissez PAS de plagesinterpolate, ne définissez PAS dedampingspring ici - c'estremotion-compose. Cette compétence produit un plan, pas du code. - Ne rythmez PAS chaque scène de la même manière ; un plan fixe de 3s donne l'impression que la démo est un diaporama.
- N'empilez PAS deux CTA ou deux URL ; une demande convertit, deux divisent l'attention.
- Ne laissez PAS la durée dépasser le plafond de la plateforme pour en mettre plus - coupez plutôt une scène.
Générateur
Script Node autonome. Sauvegardez-le sous scene_plan.js, éditez le tableau beats pour la vidéo en question et exécutez node scene_plan.js > scene-plan.json. Aucune dépendance. Il calcule les décalages d'images, valide le total et émet le plan que remotion-compose consomme.
// Storyboard -> plan de scène. Éditez `meta` et `beats`, puis :
// node scene_plan.js > scene-plan.json
const meta = {
title: 'Sentinel Launch',
fps: 30,
width: 1920, // 1080 pour 9:16 portrait, 1080 carré
height: 1080, // 1920 pour 9:16 portrait, 1080 carré
}
// Une ligne par scène. `seconds` suit le tableau des types de scène.
// `motion` est une indication pour motion-design-principles / motion-color-and-light ;
// c'est un bref, pas du code.
const beats = [
{ beat: 'hook', type: 'title', seconds: 3.0, copy: 'Your reviewer just approved a bug.', visual: 'Dark screen, line of code types in; one line snaps red.', motion: 'snappy, low damping on the red flag' },
{ beat: 'problem', type: 'text', seconds: 3.5, copy: 'Risky diffs slip through review at 5pm on a Friday.', visual: 'Calendar/clock motif, a PR marked merged.', motion: 'calm fade, no overshoot' },
{ beat: 'reveal', type: 'ui', seconds: 5.0, copy: 'Sentinel reviews every diff before merge.', visual: 'Sentinel scans the same diff, surfaces the risky line with a reason.', motion: 'scan sweep, then settle' },
{ beat: 'proof', type: 'proof', seconds: 4.5, copy: 'Caught on real PRs. Before it shipped.', visual: 'Before/after: red flag -> fixed diff, real screenshot.', motion: 'slow cross-dissolve, hold' },
{ beat: 'cta', type: 'cta', seconds: 3.0, copy: 'Try Sentinel free -> sentinel.dev', visual: 'Logo + URL on brand color.', motion: 'gentle pop, end clean' },
]
const fps = meta.fps
let from = 0
const scenes = beats.map((b, i) => {
const durationInFrames = Math.round(b.seconds * fps)
const scene = {
id: `${i + 1}-${b.beat}`,
beat: b.beat,
type: b.type,
from,
durationInFrames,
seconds: b.seconds,
copy: b.copy,
visual: b.visual,
motion: b.motion,
}
from += durationInFrames
return scene
})
const durationInFrames = from
const totalSeconds = durationInFrames / fps
const hook = scenes[0]
const warnings = []
if (hook.beat !== 'hook') warnings.push('First scene is not the hook.')
if (hook.seconds > 3.5) warnings.push('Hook is longer than 3.5s - tighten the open.')
if (scenes.filter((s) => s.beat === 'cta').length > 1) warnings.push('More than one CTA.')
if (!scenes.some((s) => s.beat === 'proof')) warnings.push('No proof beat - claim may not convert.')
if (totalSeconds > 60) warnings.push(`Runtime ${totalSeconds}s exceeds 60s ceiling - cut a scene.`)
const plan = {
composition: {
id: meta.title.replace(/[^A-Za-z0-9]/g, ''),
fps,
width: meta.width,
height: meta.height,
durationInFrames, // remotion-compose enregistre exactement cela sur le <Composition>
},
scenes,
meta: { totalSeconds, sceneCount: scenes.length, warnings },
}
process.stdout.write(JSON.stringify(plan, null, 2) + '\n')
if (warnings.length) console.error('WARNINGS:\n - ' + warnings.join('\n - '))
Exemple de sortie fonctionnelle
Avec les beats ci-dessus, le script écrit scene-plan.json :
{
"composition": {
"id": "SentinelLaunch",
"fps": 30,
"width": 1920,
"height": 1080,
"durationInFrames": 570
},
"scenes": [
{ "id": "1-hook", "beat": "hook", "type": "title", "from": 0, "durationInFrames": 90, "seconds": 3.0, "copy": "Your reviewer just approved a bug.", "visual": "Dark screen, line of code types in; one line snaps red.", "motion": "snappy, low damping on the red flag" },
{ "id": "2-problem", "beat": "problem", "type": "text", "from": 90, "durationInFrames": 105, "seconds": 3.5, "copy": "Risky diffs slip through review at 5pm on a Friday.", "visual": "Calendar/clock motif, a PR marked merged.", "motion": "calm fade, no overshoot" },
{ "id": "3-reveal", "beat": "reveal", "type": "ui", "from": 195, "durationInFrames": 150, "seconds": 5.0, "copy": "Sentinel reviews every diff before merge.", "visual": "Sentinel scans the same diff, surfaces the risky line with a reason.", "motion": "scan sweep, then settle" },
{ "id": "4-proof", "beat": "proof", "type": "proof", "from": 345, "durationInFrames": 135, "seconds": 4.5, "copy": "Caught on real PRs. Before it shipped.", "visual": "Before/after: red flag -> fixed diff, real screenshot.", "motion": "slow cross-dissolve, hold" },
{ "id": "5-cta", "beat": "cta", "type": "cta", "from": 480, "durationInFrames": 90, "seconds": 3.0, "copy": "Try Sentinel free -> sentinel.dev", "visual": "Logo + URL on brand color.", "motion": "gentle pop, end clean" }
],
"meta": { "totalSeconds": 19, "sceneCount": 5, "warnings": [] }
}
Lisez-le : 5 scènes, 570 images = 19s à 30fps, bien en dessous du plafond des réseaux sociaux. L'accroche dure 3s et ouvre sur la tension, pas un logo. Le beat Preuve (4,5s) est le plan le plus lent ; l'accroche et le CTA (3s) sont les plus serrés. Aucun avertissement, donc prêt pour remotion-compose - qui enregistre un <Composition durationInFrames={570}> et un <Sequence from={…} durationInFrames={…}> par scène, lisant from et durationInFrames directement de ce fichier.
Modèle : liste de plans
Utilisez-le lorsque vous voulez le tableau lisible par l'homme à côté du JSON. Remplacez les champs À REMPLIR par la vraie vidéo.
VIDEO STORYBOARD. [À REMPLIR : nom de la vidéo]. [À REMPLIR : plateforme / ratio d'aspect]
Objectif (une ligne) : [À REMPLIR : le message clé unique]
Durée cible : [À REMPLIR : 15-30s réseaux sociaux / 20-40s héros / jusqu'à 60s présentation]
BEAT TYPE DE SCÈNE DURÉE TEXTE À L'ÉCRAN (mots réels) BRIEF VISUEL
Accroche titre [À REMPLIR]s [À REMPLIR : résultat/tension/affirmation] [À REMPLIR]
Problème texte [À REMPLIR]s [À REMPLIR : une douleur concrète] [À REMPLIR]
Révélation ui [À REMPLIR]s [À REMPLIR : produit + mécanisme principal] [À REMPLIR]
Preuve preuve [À REMPLIR]s [À REMPLIR : vrai chiffre / avant-après] [À REMPLIR]
CTA cta [À REMPLIR]s [À REMPLIR : une action + une URL] [À REMPLIR]
(répétez Révélation et Preuve par fonctionnalité pour une présentation)
TOTAL : [À REMPLIR]s (doit être égal à composition.durationInFrames / fps du JSON)
TRANSFERT : scene-plan.json -> remotion-compose
références/pourquoi-les-3-premières-secondes
Les spectateurs décident s'ils continuent à regarder dans les ~3 premières secondes, donc l'accroche n'est pas l'endroit pour votre logo ou un fondu lent. Ouvrez sur le résultat ou la tension : le bug qui a été livré, le chiffre qui a chuté, l'affirmation qui stoppe le défilement. Le logo peut vivre dans un coin tout le temps ; en faire le beat d'ouverture dépense vos secondes les plus précieuses sur le contenu le moins persuasif. Si vous ne réussissez qu'un seul beat, réussissez celui-ci.
références/rythme-par-type-de-scène
Différentes scènes nécessitent différents temps à l'écran, et un plan fixe toutes les N secondes donne l'impression d'un diaporama :
- Titre/accroche - rapide. Une ligne, entrée vive, coupez avant qu'elle ne devienne obsolète.
- Texte - donnez du temps de lecture. Les gens lisent environ 2,5 mots/seconde ; une ligne de 7 mots a besoin d'environ 3s, une ligne de 12 mots environ 5s. Un texte sous-titré est l'erreur la plus courante - ajoutez 0,5s de marge.
- UI/démo - lent. L'œil scanne d'abord la disposition, puis la zone interactive, puis l'animation. Si le mouvement ne peut pas être suivi en une passe, la scène est trop courte plutôt que trop longue.
- Preuve/avant-après - le plus lent. Le spectateur doit voir l'avant, traiter le changement, puis voir l'après. Une bascule rapide ressemble à un tour de passe-passe, pas à une preuve.
- Logo/CTA - modéré. Assez long pour lire, court pour ne pas rester après la fin.
Exemple de script du générateur pour le modèle Sandbox Node.js
const { execSync } = require('child_process')
const fs = require('fs')
// 1. Créer scene_plan.js à partir du bloc du générateur (ou lisez-le depuis le fichier)
const script = fs.readFileSync('scene_plan.js', 'utf-8')
// 2. Exécutez-le et capturez la sortie
const result = execSync('node scene_plan.js', { encoding: 'utf-8', cwd: '.' })
// 3. Analysez la première ligne comme JSON (les avertissements vont sur stderr)
const jsonLines = result.split('\n').filter(l => l.startsWith('{'))
if (jsonLines.length > 0) {
const plan = JSON.parse(jsonLines[0])
console.log('Plan de scène généré avec succès.')
console.log(` Scènes : ${plan.meta.sceneCount}, Durée : ${plan.meta.totalSeconds}s`)
console.log(` Avertissements : ${plan.meta.warnings.length}`)
// 4. Enregistrez le JSON dans un fichier pour que les autres packs le consomment
fs.writeFileSync('scene-plan.json', JSON.stringify(plan, null, 2))
console.log(' Enregistré dans scene-plan.json')
} else {
console.error('Échec de la génération du plan de scène.')
}