Communitygithub.com

Motion Spec erstellen

Generiert Bewegungspezifikations-Anmerkungen aus After Effects-Zeitleistendaten direkt in Figma – mit Zeitleistenbalken und Detailtabellen für alle animierten Eigenschaften.

Was ist Motion Spec erstellen?

Dieses Skill erstellt eine detaillierte Bewegungspezifikation direkt in Figma, basierend auf einer exportierten JSON-Datei der After Effects-Zeitleiste. Es ist eine Ausnahme unter den ‚create-*‘-Skills, da es nicht auf einer bestehenden Komponenten-Markdown-Datei aufbaut, sondern den JSON-Export des AE-Zeitleisten-Skripts (`export-timeline.jsx`) als Eingabe verwendet. Das Skill unterstützt sowohl den `figma-console`- als auch den `figma-mcp`-MCP-Adapter und bietet eine spezifische Schritt-für-Schritt-Anleitung (Workflow) zur Vermeidung von Timeouts – jeder Layer wird in einem eigenen Figma-Aufruf gerendert. Es validiert die JSON-Eingabe, berechnet die Trackbreite und die Zeitachsenpositionen und erstellt automatisch die Kopfzeilen, die Zeitachse, die Layer-Balken und die Detailtabelle in Figma. Das Skill ist besonders nützlich für Entwickler und Designer, die Bewegungsentwürfe aus After Effects nahtlos in Figma dokumentieren und überprüfen möchten.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/0n6k4v-Coder/skills/tree/HEAD/figma/uSpec/create-motion

In Ihrer bevorzugten KI fragen

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

Dokumentation

Was macht Motion Spec erstellen?

Erstellt eine Bewegungspezifikation direkt in Figma – Zeitleistenbalken und Detailtabellen, die alle animierten Eigenschaften einer After Effects-Komposition dokumentieren.

Außerhalb des Komponenten-Markdown (.md)-Consumer-Vertrags. Die anderen create-*-Skills benötigen die Komponenten-.md (erzeugt von {{skill:create-component-md}}) und rendern aus deren render-meta. create-motion ist die bewusste Ausnahme: Seine Eingabe ist ein After Effects-Zeitleistenexport ({{ref:motion/export-timeline.jsx}}), kein Figma-Komponenten-Durchlauf – es gibt keine _base.json, kein extract-motion und keinen Motion-Abschnitt in der .md. Dieses Skill benötigt KEINE .md und nimmt nicht an der Require-.md/Fail-Fast/Whitelisted-Reads-Refaktorierung teil.

Ausführungsvertrag (zuerst lesen).

  • Diese Datei ist eine Anweisung zum AUSFÜHREN, kein zu bearbeitendes Dokument. Das Skill aufrufen = die Bewegungsspezifikation aus dem After Effects-Zeitleisten-JSON in Figma rendern.
  • Diese SKILL.md oder eine andere Skill-Datei niemals als Antwort bearbeiten, selbst wenn sie im Editor geöffnet oder fokussiert ist. Ändere ein Skill nur, wenn der Benutzer explizit nach einer Änderung des Skills selbst fragt.
  • Das eingegebene Zeitleisten-JSON ist eine SCHREIBGESCHÜTZTE Wahrheitsquelle. Niemals bearbeiten. Das einzige Artefakt, das dieses Skill produziert, ist die Figma-Anmerkung; Rendering-Anfragen in Figma, niemals als Dateibearbeitung.
  • Niemals AskQuestion aufrufen, Bestätigung anfordern oder auf Eingabe pausieren (auch nicht vor Figma-Schreibvorgängen, dem erwarteten Output). Bei Unklarheit die am besten verteidigbare Option wählen und fortfahren.
  • Nur zwei legale Stopps: (a) fehlendes oder ungültiges AE-Zeitleisten-JSON (der Schritt 4/5 Sammel- und Validierungsgate); (b) einzeiliger Abbruch, wenn die Figma-MCP-Verbindung tot ist.

MCP-Adapter

Lies uspecs.config.json → mcpProvider. Befolge für jeden MCP-Aufruf in diesem Skill die passende Spalte.

Operationfigma-consolefigma-mcp
Verbindung prüfenfigma_get_statusÜberspringen – implizit. Falls erster use_figma-Aufruf fehlschlägt, Benutzer anleiten, MCP-Setup zu prüfen.
Zu Datei navigierenfigma_navigate mit URLfileKey aus URL extrahieren (figma.com/design/:fileKey/...). Keine Navigation nötig.
Screenshot machenfigma_take_screenshotget_screenshot mit fileKey + nodeId
Plugin JS ausführenfigma_execute mit codeuse_figma mit fileKey, code, description. JS-Code ist identisch – keine Wrapper-Änderungen.
Komponenten durchsuchenfigma_search_componentssearch_design_system mit query + fileKey + includeComponents: true
Datei-/Komponentendaten abrufenfigma_get_file_data / figma_get_componentget_metadata oder get_design_context mit fileKey + nodeId
Variablen abrufen (dateiweit)figma_get_variablesuse_figma-Skript: return await figma.variables.getLocalVariableCollectionsAsync();
Token-Werte abrufenfigma_get_token_valuesuse_figma-Skript, das Variable-Werte pro Modus/Sammlung liest
Styles abrufenfigma_get_stylessearch_design_system mit includeStyles: true, oder use_figma: return figma.getLocalPaintStyles();
Auswahl abrufenfigma_get_selectionuse_figma-Skript: return figma.currentPage.selection.map(n => ({id: n.id, name: n.name, type: n.type}));

figma-mcp benötigt fileKey bei jedem Aufruf. Extrahiere es einmal aus der Figma-URL des Benutzers zu Beginn des Workflows. Für Branch-URLs (figma.com/design/:fileKey/branch/:branchKey/:fileName) verwende :branchKey als fileKey.

figma-mcp-Seitenkontext: use_figma setzt figma.currentPage bei jedem Aufruf auf die erste Seite zurück. Wenn ein Skript auf einen Knoten aus einem vorherigen Schritt über getNodeByIdAsync(ID) zugreift, ist der Seiteninhalt möglicherweise nicht geladen – findAll, findOne und characters schlagen mit TypeError fehl, bis die Seite aktiviert ist. Füge diesen Seitenladungsblock unmittelbar nach getNodeByIdAsync ein:

let _p = node; while (_p.parent && _p.parent.type !== 'DOCUMENT') _p = _p.parent;
if (_p.type === 'PAGE') await figma.setCurrentPageAsync(_p);

Dies läuft zur PAGE-Vorfahr hoch und lädt deren Inhalt. Console MCP benötigt dies nicht – figma_execute erbt den Desktop-Seitenkontext.

Erwartete Eingaben

Der Benutzer löst dieses Skill mit einem dieser Muster aus:

  • {{skill:create-motion}} + eingefügtes JSON (aus Zwischenablage, exportiert via {{ref:motion/export-timeline.jsx}})
  • {{skill:create-motion}} + ein Dateiverweis (z. B. @motion-ex.json oder ein Pfad zu einer .json-Datei)
  • {{skill:create-motion}} + ein Figma-Link (Zielseite/-datei, wo die Anmerkung platziert werden soll)

Erforderlich: Die exportierten JSON-Daten – entweder inline eingefügt oder als Datei referenziert.

Optional:

  • Figma-Link zur Zielseite (falls nicht angegeben, auf aktueller Seite im Zentrum des Viewports platzieren)
  • Screenshot oder Aufzeichnung der Animation
  • Beschreibung des Zwecks der Animation

Workflow

Kopiere diese Checkliste und aktualisiere sie während des Fortschritts:

Aufgabenfortschritt:
- [ ] Schritt 1: Anweisungsdatei lesen
- [ ] Schritt 2: MCP-Verbindung prüfen
- [ ] Schritt 3: Vorlagenschlüssel aus uspecs.config.json lesen
- [ ] Schritt 4: Kontext sammeln (JSON aus Einfügung, Dateiverweis oder Benutzer auffordern)
- [ ] Schritt 5: JSON parsen und validieren (einschließlich segments[] und hasAnimatedSegments)
- [ ] Schritt 6: Daten transformieren (vorberechnete Segmente lesen, Trackbreite, Zeitleistenpositionen berechnen)
- [ ] Schritt 7: Anweisungsdatei erneut lesen (Fehler und Anti-Patterns, Validierungscheckliste) und prüfen
- [ ] Schritt 8: Motion-Vorlage importieren und ableiten
- [ ] Schritt 9: Kopfzeilenfelder ausfüllen
- [ ] Schritt 10: Zeitlineal generieren
- [ ] Schritt 11: Zeitleisten-Layer rendern (ein figma_execute pro Layer)
- [ ] Schritt 12: Vorlagen ausblenden
- [ ] Schritt 13: Tabellenzeilen rendern
- [ ] Schritt 14: Visuelle Validierung

Schritt 1: Anweisungen lesen

Lies agent-motion-instruction.md

Schritt 2: MCP-Verbindung prüfen

Lies mcpProvider aus uspecs.config.json, um zu bestimmen, welches Figma-MCP verwendet werden soll.

Wenn figma-console:

  • figma_get_status – Bestätige, dass das Desktop Bridge Plugin aktiv ist
  • Wenn Verbindung fehlschlägt: „Bitte öffne Figma Desktop und führe das Desktop Bridge Plugin aus. Versuche es dann erneut.“

Wenn figma-mcp:

  • Die Verbindung wird implizit beim ersten use_figma-Aufruf geprüft. Keine explizite Prüfung nötig.
  • Wenn der erste Aufruf fehlschlägt: „Bitte überprüfe, ob dein FIGMA_API_KEY in deiner MCP-Konfiguration korrekt gesetzt ist.“

Schritt 3: Vorlagenschlüssel lesen

Lies die Datei uspecs.config.json und extrahiere:

  • Den motionSpec-Wert aus dem templateKeys-Objekt → speichere als MOTION_TEMPLATE_KEY

Wenn der Vorlagenschlüssel leer ist, teile dem Benutzer mit:

Der Vorlagenschlüssel für die Motion Spec ist nicht konfiguriert. Führe {{skill:firstrun}} mit deinem Figma-Vorlagenbibliotheks-Link aus.

Schritt 4: Kontext sammeln

Prüfe, was der Benutzer bereitgestellt hat:

  1. JSON bereits bereitgestellt (inline eingefügt oder als Dateiverweis wie @motion-ex.json) → lies es und fahre direkt mit Schritt 5 fort. Frage nicht erneut danach.
  2. Nur ein Figma-Link (Ziel) aber kein JSON → fordere auf:

    Bitte füge das exportierte JSON ein oder referenziere die .json-Datei (z. B. @motion-ex.json).

  3. Nichts bereitgestellt → fordere auf:

    Bitte füge das exportierte JSON von export-timeline.jsx ein oder referenziere die .json-Datei.

Wenn ein Figma-Ziellink bereitgestellt wurde, verwende figma_navigate, um ihn vor dem Rendern (Schritt 8) zu öffnen.

Akzeptiere auch optionale Screenshots, Aufzeichnungen oder Beschreibungen des Benutzers für zusätzlichen Kontext.

Schritt 5: JSON parsen und validieren

Validiere das JSON der Zwischenablage gegen das Schema und die Validierungsregeln in der Anweisungsdatei (Abschnitte JSON-Schema und JSON-Validierungsregeln). Wenn die Validierung fehlschlägt, teile dem Benutzer genau mit, welches Feld fehlt oder fehlerhaft ist, und bitte ihn, erneut zu exportieren.

Schritt 6: Daten transformieren

Das Export-Skript berechnet Segmente, Wertformatierung, Balkenbeschriftungen, Easing-Beschriftungen und die Filterung ohne Änderungen vor. Der Agent liest diese direkt und berechnet nur layoutabhängige Werte.

6a. Nicht-animierte Layer überspringen – Prüfe layer.hasAnimatedSegments. Wenn false, lasse den Layer aus Zeitleiste und Tabelle weg.

6b. Vorberechnete Segmente lesen – Jede Eigenschaft hat ein segments[]-Array mit startMs, endMs, durationMs, fromValue, toValue, barLabel, easing und easingType. Verwende diese Werte direkt – keine manuelle Berechnung nötig.

6c. Trackbreite und pxPerMs berechnen – pxPerMs ist ein fester Satz; trackWidth ist dynamisch mit rechtem Abstand für Beschriftungen:

compDurationMs = composition.durationMs   // direkt aus JSON lesen
pxPerMs = 0.64                           // fester Satz – ~320px pro 500ms-Tick
trackWidth = max(compDurationMs * pxPerMs + 50, 1600)   // Datenbereich + 50px Beschriftungsabstand, min 1600

Übergebe trackWidth und pxPerMs an den Figma-Rendering-Code. pxPerMs ist ein fester Satz (0.64), nicht abgeleitet von trackWidth / compDurationMs. Balkenpositionen (barX, barWidth) werden im Figma-Code zur Renderzeit berechnet – der Agent berechnet keine Segmentpositionen.

Zur Renderzeit beide #track-area und #ruler-track auf diese berechnete trackWidth skalieren. Die Elterncontainer verwenden HUG-Größenanpassung und dehnen sich automatisch aus.

6d. Kompositionsmetadaten formatieren gemäß den Kompositionsmetadaten-Regeln der Anweisungsdatei. Speichern als COMPOSITION_META.

Schritt 7: Prüfung

Lies die Anweisungsdatei erneut, mit Fokus auf:

  • Abschnitt Fehler und Anti-Patterns
  • Pre-Output-Validierungscheckliste

Prüfe deine transformierten Daten gegen jede Regel. Behebe alle Verstöße.

Schritt 8: Vorlage importieren und ableiten

Ausführen über figma_execute (ersetze __MOTION_TEMPLATE_KEY__ und __COMPONENT_NAME__):

const TEMPLATE_KEY = '__MOTION_TEMPLATE_KEY__';

const templateComponent = await figma.importComponentByKeyAsync(TEMPLATE_KEY);
const instance = templateComponent.createInstance();
const { x, y } = figma.viewport.center;
instance.x = x - instance.width / 2;
instance.y = y - instance.height / 2;
const frame = instance.detachInstance();
frame.name = '__COMPONENT_NAME__ Motion';
figma.currentPage.selection = [frame];
figma.viewport.scrollAndZoomIntoView([frame]);
return { frameId: frame.id };

Speichere die zurückgegebene frameId – du benötigst sie für alle nachfolgenden Schritte.

Schritt 9: Kopfzeilenfelder ausfüllen

Ausführen über figma_execute (ersetze __FRAME_ID__, __COMPONENT_NAME__, __COMPOSITION_META__):

const FRAME_ID = '__FRAME_ID__';

const frame = await figma.getNodeByIdAsync(FRAME_ID);
const textNodes = frame.findAll(n => n.type === 'TEXT');
const fontSet = new Set();
const fontsToLoad = [];
for (const tn of textNodes) {
  try {
    const fn = tn.fontName;
    if (fn && fn !== figma.mixed && fn.family) {
      const key = fn.family + '|' + fn.style;
      if (!fontSet.has(key)) { fontSet.add(key); fontsToLoad.push(fn); }
    }
  } catch {}
}
await Promise.all(fontsToLoad.map(f => figma.loadFontAsync(f).catch(() => {})));

const compName = frame.findOne(n => n.name === '#component-name');
if (compName) {
  const t = compName.type === 'TEXT' ? compName : compName.findOne(n => n.type === 'TEXT');
  if (t) t.characters = '__COMPONENT_NAME__';
}

const compDesc = frame.findOne(n => n.name === '#component-description');
if (compDesc) {
  const t = compDesc.type === 'TEXT' ? compDesc : compDesc.findOne(n => n.type === 'TEXT');
  if (t) t.characters = 'Motion Specification';
}

const compMeta = frame.findOne(n => n.name === '#composition-meta');
if (compMeta) {
  const t = compMeta.type === 'TEXT' ? compMeta : compMeta.findOne(n => n.type === 'TEXT');
  if (t) t.characters = '__COMPOSITION_META__';
}

return { success: true };

Schritt 10: Zeitlineal generieren

Ausführen über figma_execute. Berechne die ideale Trackbreite, skaliere #ruler-track und alle #track-area-Knoten, dann klone #tick für jedes Intervall.

Ersetze __FRAME_ID__, __COMP_DURATION_MS__ (gelesen aus composition.durationMs), __TRACK_WIDTH__ (berechnet in Schritt 6c) und __PX_PER_MS__ (fest bei 0.64):

const FRAME_ID = '__FRAME_ID__';
const COMP_DURATION_MS = __COMP_DURATION_MS__;
const TRACK_WIDTH = __TRACK_WIDTH__;
const PX_PER_MS = __PX_PER_MS__;

const frame = await figma.getNodeByIdAsync(FRAME_ID);
const rulerTrack = frame.findOne(n => n.name === '#ruler-track');
if (!rulerTrack) return { error: '#ruler-track not found' };

// Skaliere ruler track auf berechnete Breite
rulerTrack.resize(TRACK_WIDTH, rulerTrack.height);

// Skaliere alle #track-area-Knoten (in Layer-Vorlage und allen geklonten Layern)
const trackAreas = frame.findAll(n => n.name === '#track-area');
for (const ta of trackAreas) {
  ta.resize(TRACK_WIDTH, ta.height);
}

// Finde die #tick-Vorlage innerhalb des ruler tracks
const tickTemplate = rulerTrack.findOne(n => n.name === '#tick');
if (!tickTemplate) return { error: '#tick template not found in #ruler-track' };

// Lade Schriftarten aus den Textknoten der tick-Vorlage
const tickTextNodes = tickTemplate.findAll(n => n.type === 'TEXT');
for (const tn of tickTextNodes) {
  if (tn.characters.length > 0) {
    try { await figma.loadFontAsync(tn.fontName); } catch {}
  }
}

// Tick-Intervall: Ziel 6–12 Ticks
const tickInterval = COMP_DURATION_MS <= 300 ? 50
  : COMP_DURATION_MS <= 600 ? 100
  : COMP_DURATION_MS <= 1500 ? 250
  : COMP_DURATION_MS <= 4000 ? 500
  : COMP_DURATION_MS <= 10000 ? 1000
  : 2000;

for (let ms = 0; ms <= COMP_DURATION_MS; ms += tickInterval) {
  const xPos = ms * PX_PER_MS;
  const tick = tickTemplate.clone();
  rulerTrack.appendChild(tick);
  tick.name = ms + 'ms';
  tick.visible = true;
  tick.x = xPos;

  const label = tick.findOne(n => n.type === 'TEXT');
  if (label) {
    try { await figma.loadFontAsync(label.fontName); } catch {}
    label.characters = ms + 'ms';
  }
}

tickTemplate.visible = false;
return { success: true, trackWidth: TRACK_WIDTH, tickInterval: tickInterval };

Schritt 11: Zeitleisten-Layer rendern

Führe einen figma_execute-Aufruf pro Layer aus, um Timeouts zu vermeiden. Für jeden Layer (bei dem hasAnimatedSegments true ist), klone die #layer-template, setze den Layernamen, dann klone für jede animierte Eigenschaft die #property-template und positioniere Balken.

Ersetze alle __PLATZHALTER__-Werte.

… [für die Übersetzung gekürzt]

Individual skills in this repo

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

0n6k4v-Coder/skills

Translates Figma motion and animations into production-ready application code. Use when implementing animation/motion from a Figma design — user mentions "implement this motion", "add animation from Figma", "animate this component", provides a Figma URL whose node is animated, or when `get_design_context` returns motion data or instructs you to call `get_motion_context`.

0n6k4v-Coder/skills

Motion / animation context for the `use_figma` MCP tool — animating Figma nodes via manual keyframes, animation styles, easing, and timeline duration. Load alongside figma-use whenever a task involves adding, editing, or inspecting animation on a node.

0n6k4v-Coder/skills

Turn on Cache Components in a Next.js app and resolve the blocking routes it surfaces. Use when the user wants to enable, adopt, or migrate to Cache Components, flip the `cacheComponents` flag, work through a flood of blocking-prerender / instant validation errors, run the `cache-components-instant-false` codemod, or decide between opting routes out with `export const instant = false` and fixing them in place.

0n6k4v-Coder/skills

Optimize a Next.js app that has `cacheComponents: true` — either the static shell on first paint, or the in-app navigation between routes. Picks the matching diagnostic loop and runs it.

0n6k4v-Coder/skills

Verify Next.js runtime behavior after editing app code. Use this skill to confirm a change actually works in a running app — not just that it compiles or type-checks. Combines /_next/mcp (Next.js's view) with agent-browser (the browser's view). Requires a running `next dev`.

Verwandte Skills