Communitygithub.com

MotionSnip Studio

Erstelle Bewegtgrafiken im Code und überprüfe sie im MotionSnip Studio, einem lokalen Player, in dem der Benutzer das Rendering betrachtet, Wörter an Ort und Stelle korrigiert, Musik austauscht, Probleme auf dem Frame einkreist und einen einzigen Prompt zurücksendet.

Was ist MotionSnip Studio?

MotionSnip Studio ist ein KI-gestützter Arbeitsablauf für Entwickler, die Code-gestützte Bewegtgrafiken erstellen. Es richtet sich an Benutzer, die Remotion, HTML-Canvas oder andere Renderer für Erklärvideos, Produktanimationen und Einführungsclips einsetzen. Der Kern liegt in einer schnellen Feedback-Schleife: Der Agent erstellt das Video, der Benutzer überprüft es in einem lokalen Player, klickt auf 'Senden an Claude' und erhält einen einzigen Prompt mit Änderungen. Dies fördert die iterative Entwicklung, ohne komplexe Benutzeroberflächen, indem Probleme direkt auf dem Frame markiert werden. Die Fähigkeit basiert auf einem Player-Server, der auf Node.js läuft, einer `reel.json`-Konfigurationsdatei, die die gesamte Videostruktur definiert, und optionalen Live-Renderern (für browserbasierte Videos) und Export-Hooks. Zu den Hauptvorteilen gehören die Trennung von Audio- und Videospuren, die nicht-neu rendernde Musikbearbeitung (über separate Audiodateien), intelligentes Selbst-Review mit automatisch generierten Kritikpunkten und Unterstützung für abgeleitete Formate (9:16, 1:1, Bumper) mit automatischer Perspektivenübernahme. Der Agent liest eine detaillierte Feedback-Markdown-Datei, die vom Player erstellt wird, und wendet präzise Änderungen an Code und `reel.json` an, wobei die Stabilität der Element-IDs über die Versionen hinweg erhalten bleibt. Die Fähigkeit ist auf Geschwindigkeit ausgelegt: Der Benutzer verliert nie den Kontext, da die gesamte Bearbeitung vom Player gesteuert wird, der automatisch neue Versionen erkennt und neu lädt.

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

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht MotionSnip Studio?

Du erstellst das Video. Der Benutzer überprüft es in einem lokalen Player. Der Kreislauf ist:

  1. Video bauen und rendern.
  2. In reel.json beschreiben.
  3. Den Player öffnen.
  4. Der Benutzer überprüft und klickt auf Senden an Claude. Du erhältst eine Zeile: Apply the MotionSnip Studio feedback in <absoluter Pfad>.
  5. Feedback anwenden, neu rendern, version erhöhen. Der Player lädt von selbst neu und hilft dem Benutzer, deine Änderungen zu überprüfen.

In dieser Datei bedeutet <skill-verz> den Ordner, der diese SKILL.md enthält, normalerweise ~/.claude/skills/motionsnip-studio.

1. Projekt einrichten

Verwende einen Ordner pro Video:

<projekt>/
  reel.json        du schreibst dies
  video.mp4        das Rendering (beliebiger Name; `reel.json` "src" zeigt darauf)
  assets/          Musik, Bilder, Logos (Benutzer-Uploads landen auch hier)
  public/          optional; Remotion staticFile()-Assets
  exports/         erstellt vom Export des Players; niemals bearbeiten
  .motionsnip/     Player-Status und -Verlauf; niemals bearbeiten

Wenn der Benutzer noch keinen Renderer hat, ist Remotion eine gute Standardeinstellung (npx create-video@latest). Jedes Tool, das eine mp4-, webm- oder mov-Datei schreibt, funktioniert.

2. Baue es so, dass Änderungen günstig sind

  • Halte Text, Farben, Schriftarten und Zeitsteuerung in einem Datenobjekt (Remotion defaultProps oder eine content.ts), nicht über Komponenten verstreut. Dann ist eine Feedback-Änderung eine einzeilige Anpassung.
  • Gib jedem Bildschirmelement eine stabile ID und verwende dieselbe ID in reel.json.
  • Liefere Musik als eigene Datei aus. Rendere das Video nur mit Soundeffekten. Lege den Track in assets/ ab und setze audio.music darauf sowie audio.videoAudio auf "effects". Der Player spielt die Musik neben dem Video ab, sodass der Benutzer Tracks austauschen, den Start verschieben und Lautstärken einstellen kann, ohne neu zu rendern. Ihr Export mischt es mit ffmpeg ein.
  • Backe Musik nur dann in das Video ein, wenn der Benutzer danach fragt. Setze dann videoAudio auf "mix".

3. Rendere und prüfe, bevor du zeigst

Rendere, dann überprüfe deine eigene Arbeit mit einem Kontaktbogen:

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

Öffne das Bild und schaue es dir an. Korrigiere abgeschnittenen Text, leere Frames, falsche Farben und Timing-Lücken, bevor du den Player öffnest. Für einen einzelnen Frame:

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

Selbstüberprüfung. Dann schaue noch einmal hin, wie ein kritischer Betrachter, und notiere, was du noch siehst. Prüfe:

  • Sicherer Bereich. Alles, was wichtig ist, innerhalb eines 10%igen Abstands von jeder Kante (Titelsicher)?
  • Größe. Fließtext mindestens etwa 3% der Bildhöhe, damit er auf einem Telefon lesbar ist.
  • Kontrast. Text und wichtige Formen klar von dem abgehoben, was dahinter ist.
  • Tippfehler und Überlauf. Jedes Wort richtig geschrieben, nichts abgeschnitten oder aus seiner Box laufend.
  • Schnitte und Timing. Keine Blitz-Frames bei einem Schnitt, keine leeren Frames, nichts verschwunden, bevor es gelesen werden kann.

Behebe, was du kannst. Füge für alles Übrige oder alles, was Geschmackssache ist, einen Befund zu review in reel.json hinzu (Abschnitt 4). Der Player zeichnet jeden als gestrichelten blauen Ring mit der Bezeichnung C1, C2 … auf diesem Frame, und der Benutzer fügt ihn entweder als eigene Notiz hinzu oder verwirft ihn. Schreibe nur, was du tatsächlich in einem Frame-Screenshot gesehen hast: gib die Zeit und die Stelle oder das Element an, damit der Ring darauf landet. Lasse review leer, wenn es nichts zu sagen gibt; füge es nicht auf.

4. Schreibe reel.json

reel.json ist der Vertrag zwischen dir und dem Player. Schreibe reines JSON (keine Kommentare).

{
  "id": "acme-launch",              // stabil; die gespeicherten Änderungen des Benutzers sind danach Schlüssel
  "title": "Acme launch",
  "version": 1,                     // bei jedem Rendern erhöhen; der Player lädt neu, wenn es sich ändert
  "path": "/abs/path/to/project",   // wo du arbeitest; im Prompt angezeigt
  "src": "video.mp4",
  "w": 1920, "h": 1080, "fps": 30, "duration": 32.0,
  "reference": "optional: woran das Video angelehnt ist",
  "brand": {
    "colors": [{ "id": "accent", "name": "Akzent", "v": "#5B5BF7" }],
    "fonts":  [{ "id": "head", "name": "Überschriften", "v": "Inter" }],
    "logo": "assets/logo.svg"       // oder null
  },
  "audio": {
    "music": "assets/track.mp3",    // neben dem Video abgespielt, oder null
    "videoAudio": "effects",        // "effects" = Video hat nur Soundeffekte; "mix" = Musik ist eingebacken
    "bpm": 120, "drop": 4.0,        // optionales Beat-Grid; drop = Sekunden, wo der Drop landet
    "musicVol": 1, "sfxVol": 1,     // 0..1
    "musicOffset": 0,               // Sekunden; + startet die Musik später, - überspringt in den Track
    "musicFade": 0,                 // Sekunden des Ausblendens am Ende
    "note": "Freitext"
  },
  "assets": [{ "id": "assets/track.mp3", "name": "track.mp3", "type": "audio", "from": "Benutzer" }],
  "scenes": [
    { "id": "S1", "name": "Hook", "t": [0, 4.5], "els": [
      { "id": "headline", "label": "Überschrift", "t": [0.3, 4.3],
        "box": [20, 38, 60, 24],    // x, y, b, h in % des Frames; null für Voiceover, Audio, Vollbildmaterial
        "src": "src/Hook.tsx:12",   // die Datei (oder Datei:Zeile), die es zeichnet
        "props": {
          "text":   { "type": "text",   "label": "Text",   "v": "Meet Acme" },
          "color":  { "type": "color",  "label": "Farbe",  "v": "brand.accent" },
          "motion": { "type": "motion", "label": "Bewegung", "v": "Wörter blenden nacheinander ein" }
        } }
    ] }
  ],
  "notes": [],
  "review": [                       // optional: deine eigenen Selbstprüfungsbefunde (Abschnitt 3)
    { "id": "v1-1", "t": 1.5, "elId": "headline", "kind": "sicherer Bereich",
      "title": "Überschrift läuft in den rechten Rand",
      "detail": "Bei 1,5 s endet das letzte Wort 2% vom Rand, außerhalb des titelsicheren Bereichs.",
      "fix": "Verengere die Box auf 56% oder verkleinere die Schriftgröße eine Stufe." }
  ],
  "outputs": [                      // optional: andere Formate und Längen, die du daraus erstellt hast (Abschnitt 9)
    { "id": "vertical", "label": "9:16", "kind": "reframe", "src": "out/vertical.mp4", "w": 1080, "h": 1920, "platform": "reels" }
  ],
  "live": "live.js",                // optionaler Live-Renderer (Abschnitt 7)
  "export": { "cwd": "/abs/build/folder", "props": {}, "cmd": "npx remotion render ... \"$OUT\" --props=\"$PROPS\"" }  // optional (Abschnitt 8)
}

Regeln:

  • Proptypen: text, longtext, number, color (brand.<id> verlinkt zur Palette), media (eine Asset-ID), list (Zeilen; cols: [{ k, type, options? }]), choice (options: [...]), motion (eine einfache Beschreibung der Bewegung; der Benutzer kann sich nur dazu äußern).
  • Szenen decken 0..duration ohne Lücken ab. Zeiten sind Sekunden.
  • Halte Szenen- und Element-IDs über Versionen hinweg stabil. Gespeicherte Änderungen werden per ID zugeordnet.
  • box muss dem entsprechen, wo sich das Element auf dem Bildschirm wirklich befindet, in % des Frames. Miss es bei Unsicherheit anhand eines Frame-Screenshots. Der Benutzer klickt auf diese Boxen, um Dinge auszuwählen.
  • src sollte auf den Code verweisen, der das Element zeichnet, damit du es später finden kannst.
  • Jeder Prop-Wert muss mit dem tatsächlich Gerenderten übereinstimmen. Der Player hakt eine Bearbeitung als erledigt ab, wenn der neue reel.json-Wert dem Gefragten entspricht.
  • path kann weggelassen werden; der Server füllt den Projektordner aus.
  • review-Befunde: id (eindeutig in dieser Version, z.B. v2-1), t (Sekunden), title (eine Zeile), optional detail, fix und kind (safe area, size, contrast, typo, overflow, cut, timing oder dein eigenes Wort). Platziere es mit elId (eine Element-ID, beringt an seiner Box), box: [x, y, b, h] oder x, y in % des Frames. Schreibe für jede Version eine neue Liste; wiederhole nichts, was der Benutzer verworfen hat.
  • outputs: siehe Abschnitt 9.
  • Unbekannte Felder werden ignoriert. Fehlende optionale Felder erhalten Standardwerte.

5. Player öffnen

Starte den Server im Hintergrund und gib dem Benutzer dann die URL, die er ausgibt:

node <skill-verz>/player/server.mjs <projekt> &
# MotionSnip Studio: http://localhost:4321  (Projekt: /abs/pfad)

Optionen: --port 4321 (rückt bei Belegung nach oben), --no-open (keinen Browser öffnen), --ffmpeg /pfad/zu/ffmpeg (für den Export). Node 18 oder neuer, kein Installationsschritt. Wenn für dieses Projekt bereits ein Server läuft, starte keinen weiteren; der Player erkennt neue Versionen von selbst.

Sage dem Benutzer in ein oder zwei Zeilen, was zu tun ist: schau es dir an, klicke auf etwas, um es zu korrigieren, klicke mit der rechten Maustaste, um ein Problem einzukreisen, dann Senden an Claude.

Ein einfaches Video. Wenn der Benutzer eine Videodatei überprüfen oder bearbeiten möchte, die keine reel.json hat (eine Bildschirmaufnahme, ein Telefonclip), übergib die Datei direkt: node <skill-verz>/player/server.mjs /pfad/zu/clip.mp4 &. Schreibe keine reel.json dafür. Der Player ermöglicht es ihm, zu trimmen, zu schneiden, Text, ein Logo oder eine Unschärfe hinzuzufügen und die Farbe einzustellen, und sein Export wendet diese Bearbeitungen selbst an. Die Feedback-Datei enthält dann nur Notizen, die auf dem Frame fixiert sind; folge diesen, und wenn eine Notiz einen neuen Schnitt verlangt, exportiere über denselben Dateinamen, damit der Player es als nächste Version zählt.

6. Eine Feedback-Datei anwenden

Der Benutzer fügt Apply the MotionSnip Studio feedback in <projekt>/.motionsnip/feedback-vN.md ein. Lies diese Datei. Sie besteht aus diesen Teilen:

  • Exakte Änderungen. Zeilen wie [00:01.2 · S1 · Headline] Text (src/Hook.tsx:12): "Meet Acme" -> "Say hi to Acme". Nimm genau diese Änderung im Code und in reel.json vor. Formuliere es nicht um. Eine Farbbearbeitung von brand.<id> ändert den Paletteneintrag, sodass sich alles ändert, was damit verlinkt ist.
  • Größen- und Positionsbearbeitungen. [x, y, b, h] -> [x, y, b, h] (Skalierung 1.12) in % des Frames. Rechne in Pixel mit der Framegröße um (x% * b / 100), verschiebe oder skaliere das Element im Code und aktualisiere seine box.
  • Soundeinstellungen. Neuer Track (bereits in assets/ gespeichert), Start-Offset, Ausblendung, Lautstärken. Aktualisiere audio in reel.json. Wenn das Video nur Effekte enthält, musst du für diese normalerweise nicht neu rendern. Wenn Musik eingebacken ist (videoAudio: "mix"), rendere mit den neuen Einstellungen neu.
  • Kommentare zur {label}-Version. Dieselbe Art von Kommentar, hinterlassen auf einem Cutdown (9:16, 1:1, einem Bumper) anstelle des Masters. Zeiten und Stellen beziehen sich auf den eigenen Frame und die eigene Uhr dieser Version; der Abschnitt eines Bumpers sagt, welche Teile des Masters daraus geschnitten sind. Behebe die Ursache im Master, wenn du kannst (behalte die wichtigen Dinge dort, wo die Zuschnitte sie sehen). Wenn du diese Version selbst erstellt hast (sie ist in deinen outputs), rendere sie ebenfalls neu und erhöhe ihre eigene version.
  • In MotionSnip Studio erstellte Cutdowns. Versionen, die der Player selbst aus dem Master rendert, mit ihren Crop-Keys oder -Bereichen. Lasse ihre Dateien in Ruhe; der Reviewer rendert sie nach deiner nächsten Version neu.
  • Kommentare auf dem Frame. Freie Kommentare, die an einer Zeit und einer Stelle (x 23.9% y 81.8%) fixiert sind, oft an einem benannten Element. Nimm diesen Frame auf und schaue ihn dir an, bevor du entscheidest, was zu tun ist. Notizen sind Anfragen, keine exakten Werte; verwende dein Urteilsvermögen und lasse den Rest der Szene intakt.
  • Nicht ganz von vN-1. Dinge, die du in der letzten Runde geändert hast und die der Benutzer noch nicht für richtig hält, mit ihrem Grund. Behebe diese zuerst.
  • Aus deiner Selbstüberprüfung. Ein Kommentar, der mit (aus deiner Selbstüberprüfung, v1-2; der Reviewer stimmt zu) endet, ist einer deiner eigenen Befunde, die der Benutzer akzeptiert hat. Behandle es wie jede andere Notiz.
  • Aus deiner Selbstüberprüfung verworfen. Befunde, die der Benutzer gesehen hat und mit denen er zufrieden ist. Lasse diese Dinge so, wie sie sind, und markiere sie im nächsten review nicht erneut.
  • Szenen. Der Status jeder Szene. Lasse genehmigte Szenen in Ruhe, es sei denn, eine Bearbeitung oder Notiz nennt sie.

Dann:

  1. Nimm die Änderungen vor. Halte die IDs stabil.
  2. Rendere neu in dieselbe src-Datei (oder eine neue Datei und aktualisiere src).
  3. Überprüfe den Kontaktbogen und die Frames, die du berührt hast.
  4. Aktualisiere jeden geänderten Wert in reel.json und setze version auf N+1 (die Datei sagt, welche Nummer). Erhöhe die Version zuletzt, nachdem das Rendern abgeschlossen ist.
  5. Sage dem Benutzer in einer Zeile, was sich geändert hat, z.B. "v4 ist da · 5 Änderungen angewandt, die Outro-Notiz benötigt deine Aufmerksamkeit".

Bearbeite niemals .motionsnip/, exports/ oder die Cutdowns des Players in outputs/ (aufgelistet in .motionsnip/outputs.json); sie gehören zum Player.

7. Optional: Live-Renderer

Wenn das Video in einem Browser laufen kann (Canvas, DOM, Remotion Player Bundle), kannst du live.js ausliefern und "live": "live.js" setzen. Der Player lädt es als klassisches Skript und ruft auf:

window.MotionSnipLive = (container) => ({
  seek(timeSeconds) {}, play() {}, pause() {}, setRate(rate) {},
  // boxes[id] = [x, y, b, h, nx, ny, nb, nh]: original dann bearbeitet, % des Frames
  setBoxes(boxes) {},
});

Der Player blendet dann das Video aus und steuert deinen Renderer, sodass verschobene oder skalierte Elemente wirklich sichtbar sind.

8. Optional: Export-Hook

Füge export zu reel.json hinzu, damit der Benutzer ein Finale vom Player rendern kann:

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

Der Server führt cmd mit sh -c in cwd aus und setzt:

  • PROPS: Pfad zu einer JSON-Datei mit export.props zusammengeführt mit den Änderungen des Benutzers. Die Änderungen kommen an als { "edits": { "<elId>": { "<prop>": value } }, "boxes": { "<elId>": [x, y, b, h] }, "colors": { "<id>": "#hex" }, "fonts": { "<id>": "Name" } } (Boxen in % des Frames). Lasse deine Komposition diese lesen, damit das Rendering sie einschließt.
  • OUT: die finale Datei in exports/. Schreibe hier hinein, wenn dein Rendering bereits alles enthält.
  • RAW: ein temporärer Pfad. Schreibe stattdessen hier hinein und der Server mischt die ausgewählte Musik und Lautstärke des Benutzers ein, um OUT zu erstellen.
  • PROJECT: der Projektordner.

Fortschritt kommt vom letzten n/m-Paar, das der Befehl ausgibt (Remotion druckt Frame-Zahlen auf diese Weise).

Ohne Export-Hook funktioniert der Export trotzdem: Er kopiert das Video und mischt die Musik mit ffmpeg ein.

9. Optional: andere Formate und Längen (Outputs)

Der Player erstellt Cutdowns selbst: + Cutdown rendert ein 9:16, 1:1 (oder 16:9 von einem vertikalen Master) oder einen 6-Sekunden-Bumper aus dem Master mit ffmpeg in outputs/<id>.mp4. Ein Reframe folgt den Crop-Keys, die der Reviewer auf dem Master zieht (oder einer ersten Schätzung aus deinen Element-Boxen, also halte box genau), oder passt das gesamte Frame auf einen unscharfen Hintergrund. Jeder Output erhält einen eigenen Tab, Safe-Area-Richtlinien für Reels, TikTok und Shorts sowie eigene Notizen. Du musst dafür nichts tun.

Wenn ein Code-basiertes Video besser aussieht, wenn es für ein bestimmtes Seitenverhältnis von Anfang an optimiert ist, erstelle den Output selbst (hänge es an outputs an). Der Player markiert ihn dann als „manuell" und erstellt ihn nicht neu.

10. Starte mit einem Ideen-Prompt

Wenn der Benutzer ein Video skizzieren möchte, verwende diesen Prompt – er ist gut darin, Ideen, Zielgruppe und Format zu erfragen. Keine reel.json nötig:

Erzähle mir, was das Video zeigen soll, und ich werde es entwerfen.

Es ist in Ordnung, direkt loszulegen, wenn der Benutzer genug Details gibt. Erstelle zuerst einen guten Text-Entwurf; zeige ihn nach Möglichkeit auf dem Bildschirm an, bevor du mit dem Bauen beginnst.

Wenn du einen Entwurf hast, lege einen Projektordner an, schreibe reel.json, baue es, öffne den Player, befolge die Rückmeldungen und wiederhole den Vorgang.

Verwandte Skills