Communitygithub.com

Crear Especificación de Movimiento

Genera anotaciones de especificación de movimiento a partir de datos de la línea de tiempo de After Effects. Úsalo cuando el usuario mencione 'movimiento', 'especificación de movimiento', 'especificación de animación', 'línea de tiempo' o quiera documentar las propiedades de animación de un componente.

¿Qué es Crear Especificación de Movimiento?

Este skill genera automáticamente una especificación de movimiento completa dentro de Figma, partiendo de datos exportados de la línea de tiempo de After Effects. Crea barras de tiempo visuales y tablas de detalle que documentan todas las propiedades animadas de una composición, como fotogramas clave, curvas de easing y valores animados. El skill está diseñado para ser utilizado con agentes de IA como Claude Code, y admite tanto la consola de Figma como el protocolo MCP de Figma (Model Context Protocol). A diferencia de otros skills que requieren un archivo `.md` de componente, `create-motion` opera directamente sobre el JSON de la línea de tiempo de After Effects, sin depender de metadatos de componentes de Figma. El agente ejecuta un flujo de trabajo en varios pasos: validar la entrada JSON, transformar los datos para dimensionar las pistas y posicionar las barras, importar una plantilla de Figma, rellenar campos de encabezado, generar una regla de tiempo, renderizar las capas de la línea de tiempo y generar las filas de la tabla. Cada paso se ejecuta mediante llamadas individuales a Figma para evitar tiempos de espera, y el skill incluye reglas de validación para asegurar la integridad de los datos. El resultado es un documento de Figma visualmente rico que sirve como fuente de verdad para desarrolladores y diseñadores sobre el comportamiento de la animación de un componente.

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

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

¿Qué hace Crear Especificación de Movimiento?

Genera una especificación de movimiento directamente en Figma: barras de tiempo y tablas de detalle que documentan todas las propiedades animadas de una composición de After Effects.

Fuera del alcance del contrato de consumo del Componente Markdown (.md). Los otros skills create-* requieren el .md del componente (generado por {{skill:create-component-md}}) y renderizan a partir de su render-meta. create-motion es la excepción deliberada: su entrada es una exportación de la línea de tiempo de After Effects ({{ref:motion/export-timeline.jsx}}), no un recorrido de componente de Figma — no hay _base.json, no hay extract-motion y no hay sección de Movimiento en el .md. Este skill NO requiere un .md y NO participa en la refactorización de require-.md/fail-fast/lecturas permitidas.

Contrato de ejecución (léase primero).

  • Este archivo son instrucciones para EJECUTAR, no un documento para editar. Invocar el skill = renderizar la especificación de movimiento en Figma a partir del JSON de la línea de tiempo de After Effects.
  • Nunca edite este SKILL.md ni ningún otro archivo de skill en respuesta, incluso si uno está abierto o enfocado en el editor. Modifique un skill solo cuando el usuario solicite explícitamente cambiar el skill.
  • El JSON de la línea de tiempo de entrada es una fuente de verdad de SOLO LECTURA. Nunca lo edite. El único artefacto que produce este skill es la anotación de Figma; realice solicitudes de renderizado en Figma, nunca como una edición de archivo.
  • Nunca llame a AskQuestion, solicite confirmación, o pause para entrada (incluyendo antes de escrituras en Figma, la salida esperada). En caso de ambigüedad, elija la opción más defendible y continúe.
  • Solo dos paradas legales: (a) JSON de línea de tiempo de AE faltante o inválido (la puerta de reunir + validar del Paso 4/5); (b) aborto de una línea si la conexión MCP de Figma está muerta.

Adaptador MCP

Lea uspecs.config.json → mcpProvider. Siga la columna correspondiente para cada llamada MCP en este skill.

Operaciónfigma-consolefigma-mcp
Verificar conexiónfigma_get_statusOmitir — implícito. Si la primera llamada a use_figma falla, guíe al usuario para que verifique la configuración de MCP.
Navegar a archivofigma_navigate con URLExtraer fileKey de la URL (figma.com/design/:fileKey/...). No se necesita navegación.
Tomar captura de pantallafigma_take_screenshotget_screenshot con fileKey + nodeId
Ejecutar Plugin JSfigma_execute con codeuse_figma con fileKey, code, description. El código JS es idéntico — sin cambios de envoltorio.
Buscar componentesfigma_search_componentssearch_design_system con query + fileKey + includeComponents: true
Obtener datos de archivo/componentefigma_get_file_data / figma_get_componentget_metadata o get_design_context con fileKey + nodeId
Obtener variables (de todo el archivo)figma_get_variablesScript use_figma: return await figma.variables.getLocalVariableCollectionsAsync();
Obtener valores de tokensfigma_get_token_valuesScript use_figma que lee valores de variables por modo/colección
Obtener estilosfigma_get_stylessearch_design_system con includeStyles: true, o use_figma: return figma.getLocalPaintStyles();
Obtener selecciónfigma_get_selectionScript use_figma: return figma.currentPage.selection.map(n => ({id: n.id, name: n.name, type: n.type}));

figma-mcp requiere fileKey en cada llamada. Extráigalo una vez de la URL de Figma del usuario al inicio del flujo de trabajo. Para URL de ramas (figma.com/design/:fileKey/branch/:branchKey/:fileName), use :branchKey como fileKey.

Contexto de página de figma-mcp: use_figma restablece figma.currentPage a la primera página en cada llamada. Cuando un script accede a un nodo de un paso anterior mediante getNodeByIdAsync(ID), es posible que el contenido de la página no esté cargado — findAll, findOne y characters fallarán con TypeError hasta que se active la página. Inserte este bloque de carga de página inmediatamente después de getNodeByIdAsync:

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

Esto sube hasta el ancestro PAGE y carga su contenido. Console MCP no necesita esto — figma_execute hereda el contexto de página de la aplicación de escritorio.

Entradas Esperadas

El usuario activa este skill con uno de estos patrones:

  • {{skill:create-motion}} + JSON pegado (desde el portapapeles, exportado a través de {{ref:motion/export-timeline.jsx}})
  • {{skill:create-motion}} + una referencia de archivo (por ejemplo, @motion-ex.json o una ruta a un archivo .json)
  • {{skill:create-motion}} + un enlace de Figma (página/archivo de destino donde se debe colocar la anotación)

Requerido: Los datos JSON exportados — ya sea pegados en línea o referenciados como un archivo.

Opcional:

  • Enlace de Figma a la página de destino (si no se proporciona, colocar en la página actual en el centro de la vista)
  • Captura de pantalla o grabación de la animación
  • Descripción del propósito de la animación

Flujo de Trabajo

Copie esta lista de verificación y actualícela a medida que avanza:

Task Progress:
- [ ] Paso 1: Leer archivo de instrucciones
- [ ] Paso 2: Verificar conexión MCP
- [ ] Paso 3: Leer clave de plantilla de uspecs.config.json
- [ ] Paso 4: Reunir contexto (JSON de pegado, referencia de archivo o solicitar al usuario)
- [ ] Paso 5: Analizar y validar JSON (incluyendo segments[] y hasAnimatedSegments)
- [ ] Paso 6: Transformar datos (leer segmentos precalculados, calcular ancho de pista, posiciones de línea de tiempo)
- [ ] Paso 7: Releer archivo de instrucciones (Errores y Anti-Patrones, Lista de Verificación de Validación) y auditar
- [ ] Paso 8: Importar y desvincular la plantilla de Movimiento
- [ ] Paso 9: Rellenar campos de encabezado
- [ ] Paso 10: Generar regla de tiempo
- [ ] Paso 11: Renderizar capas de línea de tiempo (un figma_execute por capa)
- [ ] Paso 12: Ocultar plantillas
- [ ] Paso 13: Renderizar filas de tabla
- [ ] Paso 14: Validación visual

Paso 1: Leer Instrucciones

Lea agent-motion-instruction.md

Paso 2: Verificar Conexión MCP

Lea mcpProvider de uspecs.config.json para determinar qué Figma MCP usar.

Si figma-console:

  • figma_get_status — Confirme que el plugin Desktop Bridge esté activo
  • Si la conexión falla: "Por favor, abra Figma Desktop y ejecute el plugin Desktop Bridge. Luego intente de nuevo."

Si figma-mcp:

  • La conexión se verifica implícitamente en la primera llamada a use_figma. No se necesita una verificación explícita.
  • Si la primera llamada falla: "Por favor, verifique que su FIGMA_API_KEY esté configurada correctamente en su configuración MCP."

Paso 3: Leer Clave de Plantilla

Lea el archivo uspecs.config.json y extraiga:

  • El valor motionSpec del objeto templateKeys → guardar como MOTION_TEMPLATE_KEY

Si la clave de plantilla está vacía, dígale al usuario:

La clave de plantilla de especificación de movimiento no está configurada. Ejecute {{skill:firstrun}} con su enlace de biblioteca de plantillas de Figma primero.

Paso 4: Reunir Contexto

Verifique qué proporcionó el usuario:

  1. JSON ya proporcionado (pegado en línea o como referencia de archivo como @motion-ex.json) → léalo y continúe directamente al Paso 5. No lo solicite de nuevo.
  2. Solo un enlace de Figma (destino) pero sin JSON → solicite:

    Por favor, pegue el JSON exportado o haga referencia al archivo .json (por ejemplo, @motion-ex.json).

  3. Nada proporcionado → solicite:

    Por favor, pegue el JSON exportado de export-timeline.jsx, o haga referencia al archivo .json.

Si se proporcionó un enlace de destino de Figma, use figma_navigate para abrirlo antes de renderizar (Paso 8).

También acepte cualquier captura de pantalla, grabación o descripción opcional que el usuario proporcione para contexto adicional.

Paso 5: Analizar y Validar JSON

Valide el JSON del portapapeles contra el esquema y las reglas de validación en el archivo de instrucciones (secciones Esquema JSON y Reglas de Validación JSON). Si la validación falla, dígale al usuario exactamente qué campo falta o está mal formado y pídale que reexporte.

Paso 6: Transformar Datos

El script de exportación precalcula segmentos, formato de valores, etiquetas de barras, etiquetas de easing y filtrado de cambios. El agente lee estos directamente y solo calcula valores dependientes del diseño.

6a. Saltar capas no animadas — Verifique layer.hasAnimatedSegments. Si es false, omita la capa de la línea de tiempo y la tabla.

6b. Leer segmentos precalculados — Cada propiedad tiene un array segments[] con startMs, endMs, durationMs, fromValue, toValue, barLabel, easing y easingType. Use estos valores directamente — no se necesita cálculo manual.

6c. Calcular ancho de pista y pxPerMs — pxPerMs es una tasa fija; trackWidth es dinámico con relleno derecho para etiquetas de ticks:

compDurationMs = composition.durationMs   // leer directamente del JSON
pxPerMs = 0.64                           // tasa fija — ~320px por tick de 500ms
trackWidth = max(compDurationMs * pxPerMs + 50, 1600)   // área de datos + 50px de relleno de etiqueta, mínimo 1600

Pase trackWidth y pxPerMs al código de renderizado de Figma. pxPerMs es una tasa fija (0.64), no derivada de trackWidth / compDurationMs. Las posiciones de las barras (barX, barWidth) se calculan dentro del código de Figma en el momento del renderizado — el agente no calcula posiciones por segmento.

En el momento del renderizado, redimensione tanto #track-area como #ruler-track a este trackWidth calculado. Los contenedores padres usan dimensionamiento HUG y se expanden automáticamente.

6d. Formatear metadatos de composición según las reglas de Metadatos de Composición del archivo de instrucciones. Guardar como COMPOSITION_META.

Paso 7: Auditar

Vuelva a leer el archivo de instrucciones, enfocándose en:

  • Sección Errores y Anti-Patrones
  • Lista de Verificación de Validación Pre-Salida

Verifique sus datos transformados contra cada regla. Corrija cualquier violación.

Paso 8: Importar y Desvincular Plantilla

Ejecute a través de figma_execute (reemplace __MOTION_TEMPLATE_KEY__ y __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 };

Guarde el frameId devuelto — lo necesita para todos los pasos siguientes.

Paso 9: Rellenar Campos de Encabezado

Ejecute a través de figma_execute (reemplace __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 };

Paso 10: Generar Regla de Tiempo

Ejecute a través de figma_execute. Calcule el ancho de pista ideal, redimensione #ruler-track y todos los nodos #track-area, luego clone #tick para cada intervalo.

Reemplace __FRAME_ID__, __COMP_DURATION_MS__ (leído de composition.durationMs), __TRACK_WIDTH__ (calculado en el Paso 6c) y __PX_PER_MS__ (fijo en 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' };

// Redimensionar pista de regla al ancho calculado
rulerTrack.resize(TRACK_WIDTH, rulerTrack.height);

// Redimensionar todos los nodos #track-area (en la plantilla de capa y cualquier capa clonada)
const trackAreas = frame.findAll(n => n.name === '#track-area');
for (const ta of trackAreas) {
  ta.resize(TRACK_WIDTH, ta.height);
}

// Encontrar la plantilla #tick dentro de la pista de regla
const tickTemplate = rulerTrack.findOne(n => n.name === '#tick');
if (!tickTemplate) return { error: '#tick template not found in #ruler-track' };

// Cargar fuentes de los nodos de texto de la plantilla tick
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 {}
  }
}

// Intervalo de ticks: apuntar a 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 };

Paso 11: Renderizar Capas de Línea de Tiempo

Ejecute una llamada figma_execute por capa para evitar tiempos de espera. Para cada capa (donde hasAnimatedSegments es true), clone la #layer-template, configure el nombre de la capa, luego para cada propiedad animada clone #property-template y posicione las barras.

Reemplace todos los valores __PLACEHOLDER__.

… [truncado para traducción]

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`.

Skills relacionados