Communitygithub.com

yazzang-homelab/motion-studio

Planifiez des films longs ou de nuit : briefing réalisateur (PLAN FIRST ou GO, budget, définition du terminé), GUIDE D'ANIMATION + STORYBOARD, sous-agents par chapitre, portes, rendu par lots. Utilisez-le pour 'film de nuit', 'clip musical', 'film de 2 minutes'.

Qu'est-ce que motion-studio ?

Cette compétence transforme une idée d'utilisateur en un brief de production complet pour des films longs (plus de 45 secondes) et exécute la production à travers une série de portes (gates). Elle est conçue pour les agents AI comme Claude Code, Cursor ou Codex, et permet de planifier, organiser et réaliser des films de manière autonome. Le processus commence par la collecte des entrées (logline, durée, références, musique, itinéraire technique, budget, mode PLAN FIRST ou GO), puis génère un brief détaillé (`docs/brief.md`). Ensuite, des sous-agents spécialisés créent les documents de planification (guide de style, storyboard, liste des plans), mettent en place l'infrastructure de rendu, et animent chaque chapitre en parallèle. Des portes successives (stilles, animatique, échantillon difficile, passage complet, polissage et son, final) assurent la qualité et la cohérence. La compétence gère le rendu long par segments, avec reprise après interruption, et inclut un itinéraire optionnel 'générer puis tracer' (Route C) pour combiner modèles vidéo IA et code. La définition du terminé est stricte : niveaux sonores, durée exacte, livrables complets, et au moins 3 cycles de critique avec des scores minimums.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/yazzang-homelab/motion-studio/tree/HEAD/skills/director-brief

Demander à votre IA préférée

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

Documentation

Brief du réalisateur (étape 10 du cours)

Les films longs sont des productions. Les briefs derrière les films de nuit du cours ne décrivent pas une vidéo ; ils engagent une équipe : une logline pour vérifier chaque décision, des références, des outils et un budget, une bible des personnages, une feuille de rythme, des règles pour le texte à l'écran, des portes, une boucle de critique et des livrables. Cette compétence transforme l'idée de l'utilisateur en ce brief et exécute la production à travers ses portes. Pour des clips jusqu'à environ 45 secondes sans chapitres, utilisez /motion-studio:motion-reel à la place (le même seuil que cette compétence utilise pour confier un film plus long à celle-ci).

Arguments, affichés une fois :

Les fichiers de cette compétence se trouvent dans ${CLAUDE_SKILL_DIR} (le template du brief est ${CLAUDE_SKILL_DIR}/assets/brief-template.md, assets/brief-template.md).

Coût de cette compétence

Elle s'exécute avec l'effort max : le raisonnement le plus profond et l'utilisation de jetons la plus élevée de toutes les compétences motion-studio. Les erreurs de planification se cumulent sur des heures de travail autonome, donc le plan est l'endroit où cette dépense porte ses fruits. Définissez les attentes avec l'utilisateur avant de commencer. Points de données rapportés du cours : un clip musical de nuit a duré environ 12 heures et utilisé environ 80% de l'utilisation d'un forfait Max plus 75 $ de crédit API image/vidéo ; un court métrage peint à la main de 45 secondes a pris 163 appels de modèle, 62,7 M de jetons (96 % de lectures de cache), environ 34 $ aux prix catalogue de l'API et environ 6,75 heures. Gardez le reste moins cher : les animateurs de chapitre fonctionnent avec leur propre effort (élevé), et les corrections et re-rendus sont des travaux d'effort moyen. Dites à l'utilisateur de baisser l'effort de la session avec /model une fois le plan approuvé si le budget compte.

1. Collecter les entrées

Seule la session principale peut poser des questions à l'utilisateur (les sous-agents ne le peuvent pas). Si l'utilisateur a dicté un long brief, analysez-le autrement que de re-demander. Sinon, demandez une fois, dans un seul message, ce qui manque :

EntréePourquoi
logline, et ce que le spectateur devrait ressentir à la finchaque décision est vérifiée par rapport à elle
durée, formats, où il sera publiénombre de chapitres, temps de rendu, zones de sécurité
références (vidéo, images, bibliothèque d'images, dépôt antérieur)grammaire à adopter, contenu à éviter
musique : un morceau (et sa licence) ou "synthétiser"la grille rythmique sur laquelle tout se cale
itinéraire (A par défaut ; B seulement s'ils nomment Remotion/HyperFrames ; C générer puis tracer) et clés API par nom de variableoutils et dépenses
budget : utilisation du modèle, API payantes, temps réelquand arrêter de générer
mode : PLAN FIRST ou GOs'arrêter après le plan ou non

2. Écrire docs/brief.md

  1. S'il n'y a pas de studio.json, exécutez /motion-studio:studio-init d'abord (définissez --duration, --bpm, --formats).
  2. Copiez ${CLAUDE_SKILL_DIR}/assets/brief-template.md vers docs/brief.md. Remplissez la partie A avec les réponses de l'utilisateur ; gardez la partie B telle quelle.
  3. Mettez à jour studio.json pour qu'il corresponde (titre, durée, fps, bpm, formats, marque, loop).
  4. PLAN FIRST : montrez le brief rempli et arrêtez-vous jusqu'à ce que l'utilisateur approuve. GO : enregistrez chaque décision que vous avez prise pour l'utilisateur dans docs/decisions.md et continuez.

3. Porte 1 : documents de planification

FichierContenuQui l'écrit
docs/style_guide.mdpalette, typographie, rythme, transitions, texture, looks interditssous-agent style-analyst à partir des références (/motion-studio:reference-style), ou vous
docs/STORYBOARD.mdl'idée, le casting, ce qui lie le tout, chapitres avec plans minutés et transitionssous-agent motion-director, ou vous
docs/shotlist.mdchaque plan sur la grille rythmique (mesures), caméra, texte, SFXmotion-director
plan des chapitres (dans STORYBOARD)limites des chapitres sur les temps forts, propriétaire par chapitrevous

Mesurez ou synthétisez la musique avant de minuter quoi que ce soit (/motion-studio:sound-design) : les temps des chapitres et des plans sont des valeurs grid.bar(n), pas des estimations. Gardez les chapitres de 8 à 30 secondes pour qu'un sous-agent puisse en terminer un et le vérifier dans une session. Le motion-director écrit seulement dans docs/** (le hook role-guard l'applique).

4. Porte 2 : montage et guide

  1. Écrivez docs/ANIMATION_GUIDE.md à partir du template dans le docs/ du projet avant que tout animateur de chapitre ne commence, afin que chaque chapitre soit codé dans le même style : comment fonctionne un chapitre, propriété, disposition et bandes réservées, l'API partagée, éléments partagés, règles de style avec un budget de temps de peinture, et les commandes de vérification exactes.
  2. Construisez vous-même les éléments partagés (personnage principal, kit UI, aides de palette) dans film/scenes/shared_<nom>.js. Les animateurs de chapitre les importent et ne les modifient jamais. Rendez des images fixes de chaque élément dans chaque état.
  3. Créez une ébauche de chaque chapitre pour que le film soit rendu de bout en bout pendant que les chapitres sont en cours :
// film/scenes/ch03_build.js (ébauche écrite par la session principale ; l'animateur du chapitre remplace les plans)
import { chapter } from '../../lib/timeline.js';
export const BARS = [12, 20];                          // étendue en mesures depuis docs/STORYBOARD.md (null = jusqu'à la fin)
export default function ch03(ctx) {
  const FROM = BARS[0] === 0 ? 0 : ctx.grid.bar(BARS[0]);
  const TO = BARS[1] == null ? ctx.dur : ctx.grid.bar(BARS[1]);
  return chapter({ name: 'ch03_build', from: FROM, to: TO, shots: [], cues: [] });   // pas de plans = carte de remplacement
}
  1. Câblez film/film.js une fois. buildFilm accepte les résultats chapter() à l'intérieur de scenes, aplatit leurs scènes et fusionne leurs cues. Les calques à l'échelle du film (sous-titres, transitions de jointure) vont dans les overlays: Scene[] de l'usine : ils peignent après chaque scène, dans l'ordre du tableau, sur la même règle from <= t < to (inclusif à la fin à la dernière image du film), et ils ne comptent jamais comme des plans, donc les étiquettes d'images fixes, les limites de plans de la critique et la liste des aperçus listent uniquement les plans des chapitres. Le code des chapitres reste intact ; n'enveloppez pas et ne patchez pas les fonctions draw des chapitres. Les tableaux imbriqués, null et les résultats chapter() sont également acceptés dans overlays, donc un chapitre peut fournir ses propres scènes de superposition. Pour empiler des scènes ordinaires, donnez à une scène un numéro de layer (0 par défaut) : les scènes peignent par (couche, from).
import { defineFilm, scene } from '../lib/timeline.js';
import ch01 from './scenes/ch01_hook.js';
import ch02 from './scenes/ch02_problem.js';
import ch03 from './scenes/ch03_build.js';

const CHAPTERS = [ch01, ch02, ch03];

export default defineFilm((ctx) => ({
  scenes: CHAPTERS.map((make) => make(ctx)),
  overlays: [
    scene(0, ctx.dur, 'captions', (g, lt, c) => { /* sous-titres à l'échelle du film : dessiner à partir du temps de film c.t */ }),
    // une courte scène par jointure de chapitre qui nécessite une transition, minutée à partir de la grille
    scene(ctx.grid.bar(12) - 0.2, ctx.grid.bar(12) + 0.2, 'seam-ch02-ch03', (g, lt, c) => { /* fondu ou flash */ }),
  ],
  cues: (grid) => [{ t: grid.bar(0), type: 'hit' }],   // cues au niveau du film ; les cues des chapitres sont fusionnées automatiquement
}));

5. Distribuer les chapitres

Lancez un sous-agent chapter-animator (motion-studio:chapter-animator) par chapitre, plusieurs en parallèle. Briefez chacun avec : son fichier (film/scenes/chNN_<nom>.js), son étendue (l'export BARS dans son ébauche, plus la même étendue en secondes pour les commandes de vérification), sa section STORYBOARD, et "suivez docs/ANIMATION_GUIDE.md". Le hook role-guard permet à un animateur de chapitre d'écrire seulement dans film/scenes/** (sauf film/scenes/shared_*, qui restent en lecture seule pour les animateurs de chapitre, qui signalent les bogues des fichiers partagés) et out/check/**. Chacun retourne un rapport : ce qu'il a construit, images fixes de vérification, problèmes connus, et bogues qu'il a trouvés dans les fichiers partagés. Vous corrigez les fichiers partagés, relancez les vérifications sur l'ensemble du film, et rebriefez un chapitre lorsque son rapport montre un problème.

Les étendues des chapitres sont en mesures, calculées avec ctx.grid à l'intérieur de l'usine du chapitre, donc les chapitres consécutifs se rejoignent toujours et suivent une piste mesurée. Les temps des plans sont des secondes de film absolues prises de la grille (shots: [{ at: grid.bar(13), name: 'assemble', draw }, ...]) ; chaque plan s'exécute jusqu'au at du suivant, et son draw(g, lt, c) reçoit lt depuis le début du plan. Un plan en dehors de l'étendue de son chapitre fait lever une exception par chapter() et le film cesse de se charger (par exemple, un TO = 4 littéral rejette un plan à grid.bar(1) = 4,003 s une fois qu'une piste mesurée place le premier temps fort à 2,0 s).

6. Portes 3 à 8

PorteFaireVérifier
3 images fixesnode tools/stills.mjs --shots (une image fixe par plan)tour de critique (/motion-studio:critique-loop)
4 animatiquenpm run animatic (demi-échelle, 30 ips, sans flou) avec la piste réelle ou de remplacementrythme : chaque lecture arrive avant le prochain temps fort
5 échantillon le plus difficilenode tools/render.mjs --from A --to B --out out/check sur les 2 à 4 s les plus difficilesnode tools/critique.mjs --strip-at <t> ; déterminisme ; synchronisation
6 passage completaucun remplacement restant (aucune étiquette de plan dans node tools/stills.mjs --shots ne se termine par /placeholder)tour de critique sur l'ensemble du film
7 polissage et son/motion-studio:sound-design : partition ou beats, cues, SFX, voixmétrique de synchronisation, axe sonore
8 finalnpm run buildla définition du terminé dans le brief B6

Les films longs sont rendus en segments repris en cas d'interruption : node tools/render.mjs --format all --final --chunk 10 écrit out/<fmt>/.parts/seg_<a>_<b>.mp4 et saute les segments terminés lors d'une ré-exécution après une interruption. Exécutez les rendus longs en arrière-plan (l'outil Bash run_in_background, ou un fichier journal que vous interrogez) au lieu de bloquer la session, et n'attendez jamais au premier plan plus d'environ 2 minutes. Prévoyez environ 20 secondes de temps réel par seconde de film pour trois formats à 60 ips et 4 sous-images (un film de 2 minutes représente environ 40 minutes de rendu) ; le manuel du pipeline de /motion-studio:motion-reel contient le modèle et le temps prévu de chaque autre commande. Un animateur de chapitre ou tout autre sous-agent ne doit pas retourner tant qu'une commande qu'il a lancée est encore en cours d'exécution.

7. Itinéraire C : générer puis tracer (optionnel)

Uniquement lorsque le brief sélectionne l'itinéraire C et liste les clés (par nom de variable : FAL_KEY, ELEVENLABS_API_KEY dans .env) et un budget. Les modèles vidéo donnent la physique, le timing et les visages qui sont difficiles à coder à la main ; la couche de code donne un aspect cohérent que l'utilisateur possède. Les spectateurs voient la couche de code.

  1. Générez des feuilles de personnages et des plans de base avec le service choisi par l'utilisateur, en suivant sa propre documentation. Sauvegardez chaque résultat sous refs/base/ avec une ligne de manifeste (service, modèle, prompt, seed, coût, licence). Arrêtez-vous au budget.
  2. Extrayez des images à étudier : node tools/refs.mjs extract refs/base/shot01.mp4 --every 0.1 --out refs/base/shot01.
  3. Redessinez chaque plan en code par-dessus ce timing (regardez les images, reconstruisez le mouvement avec des ressorts et des pistes). Les images de base ne sont jamais chargées depuis le réseau au moment du rendu ; si un plan compose une image de base, chargez-la depuis un fichier local dans setup().
  4. Vérifiez la synchronisation : images fixes de la couche de code à côté des images de base aux mêmes instants, et les cues audio sur la grille. Re-exécutez l'étape pour tout plan qui dérive.

Clés : ne les imprimez, écho, journalisez ou collez jamais. Les outils lisent .env eux-mêmes ; nommez la variable dans les invites et les docs.

8. Définition du terminé et rapport

Le B6 du brief est le contrat : sonie -14 LUFS +-0,5 et <= -1 dBTP sur le MP4 livré, au moins 3 tours de critique avec chaque axe >= 8 et pas de P0 (npm run gate), un re-rendu donne des images identiques (vérification de déterminisme de la critique plus valeurs framesDigest égales venant de deux rendus --hash), durée et images exactes dans chaque format, et tous les livrables présents (npm run deliver vérifie la plupart de cela et écrit docs/production.json). Terminez avec le rapport B7 : livrables, scores par tour, dépenses réelles, défauts connus, ce que vous amélioreriez ensuite.

Crédits : le squelette du brief suit l'étape 10 du cours ; la répartition remplir / garder tel quel, PLAN FIRST vs GO et une définition du terminé suivent un modèle de template public par @pradeepXkapoor (reformulé) ; les portes d'acceptation sont adaptées de athemeroy/awesome-opus-5-5-videos docs/production-brief.md (CC BY 4.0) ; le motif de sous-agent guide-plus-storyboard a été étudié dans JohnHeibel/PDoomVideo (idées uniquement, aucun texte réutilisé).

Suite : /motion-studio:critique-loop après chaque porte à partir de 3, puis /motion-studio:ship-formats pour livrer.

Individual skills in this repo

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

yazzang-homelab/motion-studio

Make Claude watch its own frames: critique.mjs evidence, harsh 7-axis scores, timestamped P0/P1/P2 problems in docs/review_log.md, fix the 3 worst, re-check, pass the gate. Use for 'critique it', 'review the frames', 'is it good'.

yazzang-homelab/motion-studio

Make a launch video, app or product reel, explainer or motion ad from code, end to end: brand assets from a URL, beat-grid shot list, synced sound, critique loop, all formats. Default for new video requests; not footage edits.

yazzang-homelab/motion-studio

Brand-asset stage of a product film (motion-reel runs the whole film): capture real screenshots, logo, colors and fonts from a URL, never redraw UI; brand story beats; voice + mascot. Use to grab or fix a brand's assets.

yazzang-homelab/motion-studio

Turn a reference (a frame, a video or an image library) into docs/style_guide.md and a beat-grid shot list: measure cuts, palette and pace, take grammar not content, wait for OK. Use when the user supplies or names a look.

yazzang-homelab/motion-studio

Build, debug or speed up the seek(t) render engine: render contract, canvas vs page capture, workers/subframes/chunks, determinism fixes, Remotion or HyperFrames handoff. Use for 'render is slow', 'frames differ', 'use Remotion'.

yazzang-homelab/motion-studio

Ship every format from one timeline, then package it: layout() reframing (never crop), render all formats, per-format checks, deliver.mjs, a brand skill, a service offer. Use for 'export 9:16 and 16:9', 'deliver', 'make a skill'.

yazzang-homelab/motion-studio

The viral one-line 'showreel for a résumé' prompt: why it works (anatomy), the credited quote, and seeded variants that avoid look-alike reels; runs it as an engine test. Use for that prompt, its variations, or a showreel.

yazzang-homelab/motion-studio

Score a film to its beat grid: measure a track (beats.mjs) or synthesize one (score.mjs), cue SFX from the film, add voice, mix to -14 LUFS / -1 dBTP at exact length. Use for 'add music', 'sync to the beat', 'SFX', 'loudness'.

yazzang-homelab/motion-studio

Make motion feel physical with closed-form springs from lib/motion.js: presets, springFromFeel, track() for multi-target values, loopTrack loops, indicators, text swaps. Use for 'feels linear', 'add bounce', 'easing to springs'.

yazzang-homelab/motion-studio

Scaffold a motion-studio film project (seek(t) renderer, springs, beat grid, synthesized sound, critique tools), install it, set up the browser, run doctor. Use for 'set up the motion studio', 'new film project', 'init studio'.

yazzang-homelab/motion-studio

Write a six-part XML state spec for a one-shape UI morph film (inputs, direction, structure, build, gotchas, start): states on downbeats, cursor-driven changes, seamless loop, approval gate. Use for 'UI morph', 'state list'.

Skills associés