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 anderencreate-*-Skills benötigen die Komponenten-.md(erzeugt von {{skill:create-component-md}}) und rendern aus derenrender-meta.create-motionist die bewusste Ausnahme: Seine Eingabe ist ein After Effects-Zeitleistenexport ({{ref:motion/export-timeline.jsx}}), kein Figma-Komponenten-Durchlauf – es gibt keine_base.json, keinextract-motionund keinen Motion-Abschnitt in der.md. Dieses Skill benötigt KEINE.mdund 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.mdoder 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
AskQuestionaufrufen, 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.
| Operation | figma-console | figma-mcp |
|---|---|---|
| Verbindung prüfen | figma_get_status | Überspringen – implizit. Falls erster use_figma-Aufruf fehlschlägt, Benutzer anleiten, MCP-Setup zu prüfen. |
| Zu Datei navigieren | figma_navigate mit URL | fileKey aus URL extrahieren (figma.com/design/:fileKey/...). Keine Navigation nötig. |
| Screenshot machen | figma_take_screenshot | get_screenshot mit fileKey + nodeId |
| Plugin JS ausführen | figma_execute mit code | use_figma mit fileKey, code, description. JS-Code ist identisch – keine Wrapper-Änderungen. |
| Komponenten durchsuchen | figma_search_components | search_design_system mit query + fileKey + includeComponents: true |
| Datei-/Komponentendaten abrufen | figma_get_file_data / figma_get_component | get_metadata oder get_design_context mit fileKey + nodeId |
| Variablen abrufen (dateiweit) | figma_get_variables | use_figma-Skript: return await figma.variables.getLocalVariableCollectionsAsync(); |
| Token-Werte abrufen | figma_get_token_values | use_figma-Skript, das Variable-Werte pro Modus/Sammlung liest |
| Styles abrufen | figma_get_styles | search_design_system mit includeStyles: true, oder use_figma: return figma.getLocalPaintStyles(); |
| Auswahl abrufen | figma_get_selection | use_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.jsonoder 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 demtemplateKeys-Objekt → speichere alsMOTION_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:
- 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. - 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). - Nichts bereitgestellt → fordere auf:
Bitte füge das exportierte JSON von
export-timeline.jsxein 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]