Communitygithub.com

motionsnip-studio

Créez des animations graphiques en code et révisez-les dans MotionSnip Studio, un lecteur local où l'utilisateur regarde le rendu, corrige les textes, échange la musique, entoure les problèmes sur l'image et envoie une seule invite.

Qu'est-ce que motionsnip-studio ?

Cette compétence transforme le processus de création et de révision de vidéos générées par code (comme avec Remotion) en un cycle itératif fluide. Le développeur construit la vidéo, la décrit dans un fichier `reel.json`, puis l'ouvre dans un lecteur local. L'utilisateur peut interagir directement avec la vidéo : modifier du texte, échanger la musique, signaler des éléments visuels en les entourant, et tout envoyer en un seul retour à Claude via la commande `Apply the MotionSnip Studio feedback in <chemin>`. Le système applique ensuite les modifications, re-rend la vidéo, et incrémente la version, permettant au lecteur de se recharger automatiquement. La compétence est conçue pour fonctionner avec tout outil produisant des fichiers MP4, WebM ou MOV, et elle encourage des pratiques de dialogue efficaces comme la fourniture de commentaires précis, la vérification des zones de sécurité, des contrastes et des polices, et l'utilisation de fiches de contact pour l'auto-révision. Les utilisations typiques incluent les vidéos de lancement, les vidéos explicatives, les promotions animées, et toute animation graphique produite avec du code.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/jishanpathan7/motionsnip-studio/tree/HEAD

Demander à votre IA préférée

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

Documentation

MotionSnip Studio

Vous construisez la vidéo. L'utilisateur la révise dans un lecteur local. La boucle est :

  1. Construisez et effectuez le rendu de la vidéo.
  2. Décrivez-la dans reel.json.
  3. Ouvrez le lecteur.
  4. L'utilisateur révise et clique sur Envoyer à Claude. Vous recevez une ligne : Apply the MotionSnip Studio feedback in <chemin absolu>.
  5. Appliquez les retours, refaites le rendu, incrémentez version. Le lecteur se recharge tout seul et aide l'utilisateur à vérifier vos modifications.

Dans ce fichier, <rép. compétence> désigne le dossier qui contient ce SKILL.md, généralement ~/.claude/skills/motionsnip-studio.

1. Configurez le projet

Utilisez un dossier par vidéo :

<projet>/
  reel.json        vous écrivez ceci
  video.mp4        le rendu (n'importe quel nom ; `reel.json` "src" pointe dessus)
  assets/          musique, images, logos (les téléchargements de l'utilisateur arrivent aussi ici)
  public/          optionnel ; ressources Remotion staticFile()
  exports/         créé par l'Export du lecteur ; ne jamais éditer
  .motionsnip/     état et historique du lecteur ; ne jamais éditer

Si l'utilisateur n'a pas encore de moteur de rendu, Remotion est un bon choix par défaut (npx create-video@latest). Tout outil qui écrit un mp4, webm ou mov fonctionne.

2. Construisez-le pour que les modifications soient peu coûteuses

  • Gardez le texte, les couleurs, les polices et les timings dans un seul objet de données (defaultProps de Remotion ou un content.ts), pas dispersés dans les composants. Ainsi, une modification de retour est un changement sur une seule ligne.
  • Donnez à chaque élément à l'écran un id stable et utilisez le même id dans reel.json.
  • Livrez la musique comme son propre fichier. Effectuez le rendu de la vidéo uniquement avec les effets sonores. Placez la piste dans assets/ et pointez audio.music dessus, et réglez audio.videoAudio sur "effects". Le lecteur joue la musique à côté de la vidéo, donc l'utilisateur peut changer de piste, déplacer le début et régler les niveaux sans re-rendu. Son Export la mixe avec ffmpeg.
  • Ne cuisez la musique dans la vidéo que lorsque l'utilisateur le demande. Ensuite, réglez videoAudio sur "mix".

3. Effectuez le rendu et vérifiez avant de montrer

Effectuez le rendu, puis vérifiez votre propre travail avec une planche contact :

ffmpeg -v error -y -i video.mp4 -vf "fps=1,scale=480:-1,tile=4x3" -frames:v 1 /tmp/sheet.png

Ouvrez l'image et regardez-la. Corrigez le texte tronqué, les images vides, les mauvaises couleurs et les problèmes de timing avant d'ouvrir le lecteur. Pour une image :

ffmpeg -v error -y -ss 12.4 -i video.mp4 -frames:v 1 /tmp/frame.png

Auto-révision. Ensuite, regardez à nouveau comme le ferait un réviseur exigeant, et notez ce que vous voyez encore. Vérifiez :

  • Zone de sécurité. Tout ce qui compte à l'intérieur d'une marge de 10 % de chaque bord (sécurité des titres) ?
  • Taille. Le texte du corps au moins à environ 3 % de la hauteur de l'image, pour qu'il soit lisible sur un téléphone.
  • Contraste. Le texte et les formes clés bien distincts de ce qui se trouve derrière eux.
  • Fautes de frappe et débordement. Chaque mot correctement orthographié, rien de tronqué ou qui dépasse de sa boîte.
  • Coupures et timing. Pas d'images flash sur une coupe, pas d'images vides, rien qui disparaisse avant d'être lisible.

Corrigez ce que vous pouvez. Pour tout ce qui reste, ou tout ce qui est une question de goût, ajoutez une observation à review dans reel.json (section 4). Le lecteur dessine chacune d'elles comme un anneau bleu en pointillés étiqueté C1, C2... sur cette image, et l'utilisateur soit l'ajoute comme sa propre note, soit la rejette. Écrivez uniquement ce que vous avez réellement vu dans une capture d'image : donnez l'heure, et l'endroit ou l'élément, pour que l'anneau atterrisse dessus. Laissez review vide quand il n'y a rien à dire ; ne l'alourdissez pas.

4. Écrivez reel.json

reel.json est le contrat entre vous et le lecteur. Écrivez du JSON simple (pas de commentaires).

{
  "id": "acme-launch",              // stable ; les modifications sauvegardées de l'utilisateur sont indexées par celui-ci
  "title": "Acme launch",
  "version": 1,                     // incrémentez à chaque rendu ; le lecteur se recharge quand il change
  "path": "/abs/path/to/project",   // où vous travaillez ; affiché dans l'invite
  "src": "video.mp4",
  "w": 1920, "h": 1080, "fps": 30, "duration": 32.0,
  "reference": "optionnel : sur quoi la vidéo est modelée",
  "brand": {
    "colors": [{ "id": "accent", "name": "Accent", "v": "#5B5BF7" }],
    "fonts":  [{ "id": "head", "name": "Headlines", "v": "Inter" }],
    "logo": "assets/logo.svg"       // ou null
  },
  "audio": {
    "music": "assets/track.mp3",    // joué à côté de la vidéo, ou null
    "videoAudio": "effects",        // "effects" = la vidéo a uniquement des effets sonores ; "mix" = la musique est cuite dedans
    "bpm": 120, "drop": 4.0,        // grille de beats optionnelle ; drop = secondes où le drop atterrit
    "musicVol": 1, "sfxVol": 1,     // 0..1
    "musicOffset": 0,               // secondes ; + commence la musique plus tard, - saute dans la piste
    "musicFade": 0,                 // secondes de fondu à la fin
    "note": "texte libre"
  },
  "assets": [{ "id": "assets/track.mp3", "name": "track.mp3", "type": "audio", "from": "User" }],
  "scenes": [
    { "id": "S1", "name": "Hook", "t": [0, 4.5], "els": [
      { "id": "headline", "label": "Headline", "t": [0.3, 4.3],
        "box": [20, 38, 60, 24],    // x, y, w, h en % de l'image ; null pour voix off, audio, séquence plein écran
        "src": "src/Hook.tsx:12",   // le fichier (ou fichier:ligne) qui le dessine
        "props": {
          "text":   { "type": "text",   "label": "Texte",   "v": "Meet Acme" },
          "color":  { "type": "color",  "label": "Couleur",  "v": "brand.accent" },
          "motion": { "type": "motion", "label": "Mouvement", "v": "Les mots apparaissent en flou un par un" }
        } }
    ] }
  ],
  "notes": [],
  "review": [                       // optionnel : vos propres observations d'auto-révision (section 3)
    { "id": "v1-1", "t": 1.5, "elId": "headline", "kind": "safe area",
      "title": "Le titre touche le bord droit",
      "detail": "À 1.5 s, le dernier mot se termine à 2 % du bord, en dehors de la zone de sécurité des titres.",
      "fix": "Réduisez la boîte à 56 % ou diminuez la taille d'un cran." }
  ],
  "outputs": [                      // optionnel : autres formats et durées que vous en avez tirés (section 9)
    { "id": "vertical", "label": "9:16", "kind": "reframe", "src": "out/vertical.mp4", "w": 1080, "h": 1920, "platform": "reels" }
  ],
  "live": "live.js",                // moteur de rendu en direct optionnel (section 7)
  "export": { "cwd": "/abs/build/folder", "props": {}, "cmd": "npx remotion render ... \"$OUT\" --props=\"$PROPS\"" }  // optionnel (section 8)
}

Règles :

  • Types de propriétés : text, longtext, number, color (brand.<id> lie à la palette), media (un id de ressource), list (lignes ; cols: [{ k, type, options? }]), choice (options: [...]), motion (une description simple du mouvement ; l'utilisateur peut seulement commenter dessus).
  • Les scènes couvrent 0..duration sans lacune. Les temps sont en secondes.
  • Gardez les ids des scènes et des éléments stables entre les versions. Les modifications sauvegardées correspondent par id.
  • box doit correspondre à l'endroit où l'élément se trouve réellement à l'écran, en % de l'image. Mesurez-le à partir d'une capture d'image si vous n'êtes pas sûr. L'utilisateur clique sur ces boîtes pour sélectionner des choses.
  • src doit pointer vers le code qui dessine l'élément, afin que vous puissiez le retrouver plus tard.
  • Chaque valeur de propriété doit être égale à ce qui est réellement rendu. Le lecteur coche une modification comme faite lorsque la nouvelle valeur de reel.json correspond à ce qui a été demandé.
  • path peut être omis ; le serveur remplit le dossier du projet.
  • Observations review : id (unique dans cette version, par ex. v2-1), t (secondes), title (une ligne), optionnellement detail, fix et kind (safe area, size, contrast, typo, overflow, cut, timing ou votre propre mot). Placez-le avec elId (un id d'élément, entouré à sa boîte), box: [x, y, w, h], ou x, y en % de l'image. Écrivez une nouvelle liste pour chaque version ; ne répétez rien que l'utilisateur a rejeté.
  • outputs : voir section 9.
  • Les champs inconnus sont ignorés. Les champs optionnels manquants obtiennent les valeurs par défaut.

5. Ouvrez le lecteur

Démarrez le serveur en arrière-plan, puis donnez à l'utilisateur l'URL qu'il affiche :

node <rép. compétence>/player/server.mjs <projet> &
# MotionSnip Studio : http://localhost:4321  (projet : /abs/path)

Options : --port 4321 (se déplace vers le haut si occupé), --no-open (n'ouvrez pas de navigateur), --ffmpeg /path/to/ffmpeg (pour l'Export). Node 18 ou plus récent, aucune étape d'installation. Si un serveur pour ce projet est déjà en cours d'exécution, n'en démarrez pas un autre ; le lecteur récupère les nouvelles versions tout seul.

Dites à l'utilisateur quoi faire en une ou deux lignes : regardez-la, cliquez sur quelque chose pour le corriger, faites un clic droit pour entourer un problème, puis Envoyer à Claude.

Une vidéo simple. Si l'utilisateur souhaite réviser ou éditer un fichier vidéo qui n'a pas de reel.json (un enregistrement d'écran, un clip de téléphone), passez le fichier lui-même : node <rép. compétence>/player/server.mjs path/to/clip.mp4 &. N'écrivez pas de reel.json pour cela. Le lecteur leur permet de rogner, couper, ajouter du texte, un logo ou un flou, et régler la couleur, et son Export applique ces modifications lui-même. Leur fichier de retour ne contient alors que des notes épinglées sur l'image ; suivez-les, et si une note demande une nouvelle coupe, exportez sur le même nom de fichier afin que le lecteur le considère comme la version suivante.

6. Appliquez un fichier de retour

L'utilisateur colle Apply the MotionSnip Studio feedback in <projet>/.motionsnip/feedback-vN.md. Lisez ce fichier. Il a ces parties :

  • Modifications exactes. Lignes comme [00:01.2 · S1 · Headline] Text (src/Hook.tsx:12) : "Meet Acme" -> "Say hi to Acme". Faites exactement cette modification dans le code et dans reel.json. Ne la reformulez pas. Une modification de couleur vers brand.<id> change l'entrée de la palette, donc tout ce qui y est lié change.
  • Modifications de taille et de position. [x, y, w, h] -> [x, y, w, h] (échelle 1.12) en % de l'image. Convertissez en pixels avec la taille de l'image (x% * w / 100), déplacez ou redimensionnez l'élément dans le code, et mettez à jour sa box.
  • Paramètres sonores. Nouvelle piste (déjà sauvegardée dans assets/), décalage de début, fondu, volumes. Mettez à jour audio dans reel.json. Si la vidéo ne porte que des effets, vous n'avez généralement pas besoin de re-rendre pour ceux-ci. Si la musique est cuite dedans (videoAudio: "mix"), refaites le rendu avec les nouveaux paramètres.
  • Commentaires sur la version {label}. Le même type de commentaire, laissé sur une version réduite (9:16, 1:1, une bande-annonce) au lieu du maître. Les temps et les endroits appartiennent à la propre image et horloge de cette version ; la section d'une bande-annonce indique les parties du maître dont elle est tirée. Corrigez la cause dans le maître quand vous le pouvez (gardez les choses importantes là où les recadrages les voient). Si vous avez créé cette version vous-même (elle est dans vos outputs), refaites-en le rendu aussi et incrémentez sa propre version.
  • Versions réduites créées dans MotionSnip Studio. Versions que le lecteur rend lui-même à partir du maître, avec leurs clés de recadrage ou plages. Laissez leurs fichiers tranquilles ; le réviseur les re-rend après votre prochaine version.
  • Commentaires sur l'image. Commentaires libres épinglés à un moment et un endroit (x 23.9% y 81.8%), souvent sur un élément nommé. Capturez cette image et regardez-la avant de décider quoi faire. Les notes sont des demandes, pas des valeurs exactes ; utilisez le jugement et gardez le reste de la scène intact.
  • Pas tout à fait de vN-1. Les choses que vous avez changées au dernier tour et que l'utilisateur dit ne pas être encore correctes, avec leur raison. Corrigez-les en premier.
  • De votre auto-révision. Un commentaire se terminant par (de votre auto-révision, v1-2 ; le réviseur est d'accord) est l'une de vos propres observations que l'utilisateur a acceptée. Traitez-la comme toute autre note.
  • Rejeté de votre auto-révision. Observations que l'utilisateur a regardées et dont il est satisfait. Laissez ces choses telles qu'elles sont, et ne les signalez plus dans la prochaine review.
  • Scènes. Le statut de chaque scène. Laissez les scènes approuvées tranquilles à moins qu'une modification ou une note ne les nomme.

Ensuite :

  1. Effectuez les modifications. Gardez les ids stables.
  2. Refaites le rendu vers le même fichier src (ou un nouveau fichier et mettez à jour src).
  3. Vérifiez la planche contact et les images que vous avez touchées.
  4. Mettez à jour chaque valeur modifiée dans reel.json et réglez version sur N+1 (le fichier indique quel nombre). Incrémentez la version en dernier, une fois le rendu terminé.
  5. Dites à l'utilisateur en une ligne ce qui a changé, par exemple "la v4 est là · 5 modifications appliquées, la note de fin nécessite votre attention".

Ne jamais éditer .motionsnip/, exports/ ou les versions réduites du lecteur dans outputs/ (listées dans .motionsnip/outputs.json) ; ils appartiennent au lecteur.

7. Optionnel : moteur de rendu en direct

Si la vidéo peut s'exécuter dans un navigateur (canvas, DOM, bundle Remotion Player), vous pouvez livrer live.js et définir "live": "live.js". Le lecteur le charge en tant que script classique et appelle :

window.MotionSnipLive = (conteneur) => ({
  seek(tempsSecondes) {}, play() {}, pause() {}, setRate(taux) {},
  // boxes[id] = [x, y, w, h, nx, ny, nw, nh] : original puis édité, % de l'image
  setBoxes(boxes) {},
});

Le lecteur cache alors la vidéo et pilote votre moteur de rendu, de sorte que les éléments déplacés ou redimensionnés s'affichent pour de vrai.

8. Optionnel : crochet d'exportation

Ajoutez export à reel.json pour permettre à l'utilisateur de rendre une version finale à partir du lecteur :

"export" : {
  "cwd": "/abs/path/to/remotion/project",
  "props": { "musicSrc": null },
  "cmd": "npx remotion render src/index.ts Main \"$RAW\" --props=\"$PROPS\""
}

Le serveur exécute cmd avec sh -c dans cwd et définit :

  • PROPS : chemin vers un fichier JSON avec export.props fusionné avec les modifications de l'utilisateur. Les modifications arrivent sous la forme { "edits": { "<elId>": { "<prop>": valeur } }, "boxes": { "<elId>": [x, y, w, h] }, "colors": { "<id>": "#hex" }, "fonts": { "<id>": "Nom" } } (boîtes en % de l'image). Faites en sorte que votre composition les lise afin que le rendu les inclue.
  • OUT : le fichier final dans exports/. Écrivez ici si votre rendu inclut déjà tout.
  • RAW : un chemin temporaire. Écrivez ici à la place et le serveur mélange la musique choisie par l'utilisateur et les niveaux dans celui-ci pour créer OUT.
  • PROJECT : le dossier du projet.

La progression provient de la dernière paire n/m que la commande imprime (Remotion imprime des nombres d'images comme ceci).

Sans crochet d'exportation, l'Export fonctionne toujours : il copie la vidéo et mélange la musique avec ffmpeg.

9. Optionnel : autres formes et durées (sorties)

Le lecteur crée lui-même des versions réduites : + Cutdown rend un 9:16, 1:1 (ou 16:9 à partir d'un maître vertical) ou une bande-annonce de 6 secondes à partir du maître avec ffmpeg, dans outputs/<id>.mp4. Un recadrage suit les clés de recadrage que le réviseur fait glisser sur le maître (ou une première estimation à partir de vos boîtes d'éléments, donc gardez box précis), ou adapte toute l'image sur un remplissage flou. Chaque sortie obtient son propre onglet, des guides de zone de sécurité pour Reels, TikTok et Shorts, et ses propres notes. Vous n'avez rien à faire pour celles-ci.

Lorsqu'une vidéo créée par code semble mieux disposée avec un recadrage ou une refonte pour une plateforme, le lecteur peut le faire en une fois. Pour un rendu réel, réglez outputs sur votre reel.json avec les bons fichiers et formats, et le lecteur les gère comme n'importe quelle autre version. Utilisez-le lorsque vous savez que le maître est destiné à une plateforme mais que l'utilisateur demandera aussi une version courte verticale ; avoir la sortie dans reel.json lui donne un onglet tout de suite, et l'utilisateur peut laisser des notes dessus pendant qu'il révise.


Les utilisateurs de MotionSnip Studio ont l'habitude de voir un cycle de collaboration rapide ; gardez les interactions courtes et précises.

Skills associés