Communitygithub.com

xzedm/clipplic-landing

Usa esta habilidad junto con figma‑use cuando la tarea consista en traducir una página de aplicación, vista o diseño de varias secciones a Figma. Desencadenantes: 'escribir en Figma', 'crear en Figma desde código', 'enviar página a Figma', 'tomar esta app/página y construirla en Figma', 'crear una pantalla', 'construir una landing page en Figma', 'actualizar la pantalla de Figma para que coincida con el código', 'convertir este modal/diálogo/drawer/panel a Figma'. Es la habilidad de flujo de trabajo preferida siempre que el usuario quiera construir o actualizar una página completa, modal, diálogo, drawer, barra lateral, panel o cualquier vista compuesta de varias secciones en Figma a partir de código o una descripción. Descubre componentes, variables y estilos del sistema de diseño a partir de archivos Code Connect, pantallas existentes y la búsqueda en la biblioteca, luego los importa y ensambla las vistas de forma incremental sección por sección usando tokens del sistema de diseño en lugar de valores fijos.

¿Qué es clipplic-landing?

Esta habilidad permite crear o actualizar pantallas, vistas y contenedores de interfaz de usuario de varias secciones en Figma reutilizando el sistema de diseño publicado (componentes, variables y estilos) en lugar de dibujar primitivas con valores fijos. Es la opción preferida cuando el usuario solicita construir o actualizar páginas completas, modales, diálogos, paneles, barras laterales o cualquier vista compuesta. Soporta plataformas web, iOS y Android, y su flujo de trabajo obligatorio incluye: primero, entender la entrega (leyendo código fuente si es necesario); segundo, recolectar claves de componentes (mediante archivos Code Connect, inspección de pantallas existentes y búsqueda en la biblioteca del sistema de diseño), variables de color/espaciado y estilos de texto/efecto; tercero, construir la vista de forma incremental sección por sección importando componentes, aplicando tokens y vinculando variables en lugar de usar valores fijos. Para aplicaciones web, la habilidad recomienda ejecutar en paralelo `generate_figma_design` para capturar una imagen de píxel perfecto y luego fusionarla con las instancias de componentes del sistema de diseño, logrando tanto precisión visual como componentes enlazados actualizables. El resumen debe estar en español.

Compatible con✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/xzedm/clipplic-landing/tree/HEAD/.agents/skills/figma-generate-design

Preguntar en tu IA favorita

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

Documentación

Construir/Actualizar Pantallas y Vistas desde el Sistema de Diseño

Usa esta habilidad para crear o actualizar pantallas, vistas y contenedores de interfaz de usuario de varias secciones en Figma reutilizando el sistema de diseño publicado: componentes, variables y estilos, en lugar de dibujar primitivas con valores fijos. Esto incluye páginas completas, modales, diálogos, drawers, barras laterales, paneles y cualquier vista compuesta con varias secciones. La idea clave: el archivo de Figma probablemente tiene un sistema de diseño publicado con componentes, variables de color/espaciado y estilos de texto/efecto que se corresponden con los componentes y tokens de la interfaz del código. Encuéntralos y úsalos en lugar de dibujar cajas con colores hexadecimales.

OBLIGATORIO: También debes cargar figma-use antes de cualquier llamada a use_figma. Esa habilidad contiene reglas críticas (rangos de color, carga de fuentes, etc.) que se aplican a cada script que escribas.

Siempre pasa skillNames: "figma-generate-design" al llamar a use_figma como parte de esta habilidad. Es un parámetro de registro. No afecta la ejecución.

Límites de la Habilidad

  • Usa esta habilidad cuando el resultado sea una vista compuesta de Figma (nueva o actualizada), pantallas de página completa, modales, diálogos, drawers, barras laterales, paneles o cualquier contenedor de varias secciones, construido a partir de instancias de componentes del sistema de diseño.
  • Si el usuario quiere crear nuevos componentes reutilizables o variantes, usa figma-use directamente.
  • Si el usuario quiere escribir mapeos de Code Connect, cambia a figma-code-connect.

Prerrequisitos

  • El servidor MCP de Figma debe estar conectado
  • El archivo de Figma de destino debe tener un sistema de diseño publicado con componentes (o acceso a una biblioteca de equipo)
  • El usuario debe proporcionar:
    • Una URL del archivo de Figma / clave de archivo en la que trabajar
    • O contexto sobre qué archivo es el objetivo (el agente puede descubrir páginas)
  • Código fuente o descripción de la pantalla/vista a construir/actualizar

Flujo de Trabajo en Paralelo con generate_figma_design (Solo Aplicaciones Web)

Al construir una pantalla desde una aplicación web que se puede renderizar en un navegador, los mejores resultados se obtienen ejecutando ambos enfoques en paralelo:

  1. En paralelo:
    • Comienza a construir la pantalla usando el flujo de trabajo de esta habilidad (use_figma + componentes del sistema de diseño)
    • Ejecuta generate_figma_design para capturar una captura de pantalla de píxel perfecto de la aplicación web en ejecución
  2. Una vez que ambos estén completos: Actualiza la salida de use_figma para que coincida con el diseño de píxel perfecto de la captura de generate_figma_design. La captura proporciona el espaciado, tamaño y tratamiento visual exactos a los que apuntar, mientras que tu salida de use_figma tiene instancias de componentes adecuadas vinculadas al sistema de diseño. Si la captura contiene imágenes, transfiérelas a tu salida de use_figma copiando los valores imageHash de los rellenos de imagen de la captura (consulta el Paso 5 para más detalles).
  3. Una vez confirmado que se ve bien: Elimina la salida de generate_figma_design. Solo se usó como referencia visual.

Esto combina lo mejor de ambos: generate_figma_design proporciona precisión de diseño de píxel perfecto, mientras que use_figma proporciona instancias de componentes del sistema de diseño adecuadas que se mantienen vinculadas y actualizables.

Este flujo de trabajo en paralelo es OBLIGATORIO cuando la fuente contiene imágenes. La API de Plugin de use_figma no puede obtener URLs de imágenes externas. Solo puede establecer rellenos de imagen copiando valores imageHash de nodos que ya están en el archivo. generate_figma_design rasteriza todas las imágenes visibles en Figma, proporcionando los hashes que necesitas. Si omites la captura cuando hay imágenes, los marcos de imagen quedarán en blanco.

Para aplicaciones que no son web (iOS, Android, etc.) o al actualizar pantallas existentes, usa el flujo de trabajo estándar a continuación.

Flujo de Trabajo Requerido

Sigue estos pasos en orden. No te saltes pasos.

Puertas duras, atajos prohibidos:

  • Prohibido: search_design_system para claves de componentes hasta que 2a-i esté completo y 2a-ii se haya intentado o registrado como N/A (por ejemplo, "archivo vacío, sin pantallas existentes").
  • Prohibido: Cualquier llamada a use_figma que mute el lienzo (Paso 3+) hasta que todas las filas del Paso 2 en la lista de verificación a continuación estén completas.

Paso 1: Entender la Entrega

Antes de tocar Figma, comprende lo que estás construyendo:

  1. Si se construye desde código, lee los archivos fuente relevantes para entender la estructura, las secciones y qué componentes se utilizan.
  2. Identifica las secciones principales de la vista (por ejemplo, para una página: Encabezado, Hero, Paneles de Contenido, Pie de página; para un modal: Barra de Título, Secciones de Formulario, Barra de Acciones; para una barra lateral: Navegación, Área de Contenido, Acciones de Pie de página).
  3. Para cada sección, enumera los componentes de la interfaz de usuario involucrados (botones, campos de entrada, tarjetas, pestañas de navegación, acordeones, etc.).
  4. Verifica si la vista contiene imágenes (por ejemplo, <img>, <Image>, imágenes de fondo, fotos de productos, avatares, iconos cargados desde URL). Si las contiene y esto es una aplicación web, debes ejecutar el flujo de trabajo en paralelo de captura de generate_figma_design, comiénzalo inmediatamente junto con el Paso 2 para que la captura se ejecute mientras descubres componentes. Consulta "Flujo de Trabajo en Paralelo con generate_figma_design" arriba.

Paso 2: Recolectar Claves de Componentes, Variables y Estilos

Necesitas tres cosas del sistema de diseño: componentes (botones, tarjetas, etc.), variables (colores, espaciado, radios) y estilos (estilos de texto, estilos de efecto como sombras). No codifiques colores hexadecimales ni valores de píxel cuando existan tokens del sistema de diseño.

2a: Descubrir componentes

2a-i. REQUERIDO: Revisar Code Connect para los componentes necesarios. A partir de la lista de componentes que construiste en el Paso 1, verifica si cada componente tiene un archivo Code Connect en la base de código. Los archivos Code Connect se encuentran junto al código fuente del componente y se nombran según la plataforma:

  • TypeScript/JS: *.figma.ts, *.figma.js
  • React (basado en parser): *.figma.tsx
  • Kotlin/Compose: archivos .kt que contienen @FigmaConnect
  • Swift: archivos .swift que contienen FigmaConnect

Para cada componente que necesites (por ejemplo, Button, Card, Input), busca su archivo Code Connect, haz glob o grep por nombre de componente (por ejemplo, **/Button.figma.tsx, **/Card.figma.ts). Solo lee archivos que coincidan con componentes que realmente necesitas.

De cada archivo Code Connect coincidente, extrae la URL del componente de Figma. Parsea fileKey y nodeId de la URL (convierte guiones a dos puntos: 123-456 → 123:456). Luego resuelve las claves de los componentes mediante use_figma:

Ejemplo: El archivo Code Connect contiene // url=https://figma.com/design/ABC123/File?node-id=609-35535. Parsea fileKey = ABC123, nodeId = 609:35535. Ejecuta use_figma contra el archivo de biblioteca (fileKey ABC123, no el archivo de destino) para resolver la clave:

const node = await figma.getNodeByIdAsync("609:35535");
const set = node?.parent?.type === "COMPONENT_SET" ? node.parent : node;
return { componentKey: set.key };

Agrupa múltiples búsquedas en una sola llamada. Usa las claves devueltas con importComponentSetByKeyAsync() en el Paso 4.

Marca los componentes resueltos. Si todos los componentes están resueltos, omite 2a-ii y 2a-iii. Si ninguno de los componentes necesitados tiene archivos Code Connect, continúa con 2a-ii.

2a-ii. REQUERIDO si quedan componentes no resueltos: Inspeccionar pantallas existentes. Verifica si el archivo de destino ya contiene pantallas que usen el mismo sistema de diseño. Una sola llamada a use_figma que recorra las instancias de un marco existente te da un mapa de componentes exacto y autoritativo:

// Descubrimiento de solo lectura, omitir contenido invisible dentro de instancias
// (variantes ocultas, etc.) para el findAllWithCriteria cientos de veces más rápido.
figma.skipInvisibleInstanceChildren = true;

const frame = figma.currentPage.findOne(n => n.name === "Existing Screen");
const uniqueSets = new Map();
frame.findAllWithCriteria({ types: ["INSTANCE"] }).forEach(inst => {
  const mc = inst.mainComponent;
  const cs = mc?.parent?.type === "COMPONENT_SET" ? mc.parent : null;
  const key = cs ? cs.key : mc?.key;
  const name = cs ? cs.name : mc?.name;
  if (key && !uniqueSets.has(key)) {
    uniqueSets.set(key, { name, key, isSet: !!cs, sampleVariant: mc.name });
  }
});
return [...uniqueSets.values()];

Compara los resultados con tus componentes no resueltos. Marca los que se hayan resuelto nuevamente. Si todos los componentes están resueltos, omite 2a-iii.

2a-iii. ÚLTIMO RECURSO: search_design_system. Solo si quedan componentes sin resolver después de completar tanto 2a-i como 2a-ii.

Antes de buscar, llama a get_libraries para descubrir qué bibliotecas están disponibles para el archivo. Esto devuelve dos listas: bibliotecas ya agregadas al archivo y bibliotecas disponibles para agregar (kits de interfaz de usuario comunitarios y bibliotecas de la organización). Cada entrada incluye un libraryKey que puedes pasar a search_design_system mediante el parámetro includeLibraryKeys para limitar tu búsqueda a bibliotecas específicas en lugar de buscar en todo.

// Paso 1: Descubrir bibliotecas disponibles
get_libraries({ fileKey })
// Devuelve: {
//   libraries_added_to_file: [...],
//   libraries_available_to_add: [...],
//   libraries_available_to_add_next_offset: number | null
// }

// Paso 2: Buscar dentro de una biblioteca específica usando su libraryKey
search_design_system({ query: "button", fileKey, includeLibraryKeys: ["lk-abc123..."] })

Las bibliotecas de la organización en libraries_available_to_add están paginadas (20 por página). Cuando libraries_available_to_add_next_offset no es nulo, hay más bibliotecas de la organización disponibles, llama a get_libraries nuevamente con offset establecido en ese valor para obtener la siguiente página. Los kits de interfaz de usuario comunitarios solo aparecen en la primera página. Si el usuario nombra una biblioteca específica que no ves en la página actual, avanza más páginas antes de rendirte.

Esto es especialmente útil cuando el archivo tiene muchas bibliotecas y deseas resultados específicos (por ejemplo, buscar solo dentro de "iOS 26" o "Material 3" en lugar de obtener coincidencias de cada biblioteca).

Busca de forma amplia: prueba múltiples términos y sinónimos (por ejemplo, "button", "input", "nav", "card", "accordion", "header", "footer", "tag", "avatar", "toggle", "icon", etc.). Usa includeComponents: true para centrarte en componentes.

Incluye las propiedades de los componentes en tu mapa. Necesitas saber qué propiedades TEXT expone cada componente para anulaciones de texto. Crea una instancia temporal, lee sus componentProperties (y las de instancias anidadas), luego elimina la instancia temporal.

Ejemplo de mapa de componentes con información de propiedades:

Component Map:
- Button → key: "abc123", type: COMPONENT_SET
  Properties: { "Label#2:0": TEXT, "Has Icon#4:64": BOOLEAN }
- PricingCard → key: "ghi789", type: COMPONENT_SET
  Properties: { "Device": VARIANT, "Variant": VARIANT }
  Nested "Text Heading" has: { "Text#2104:5": TEXT }
  Nested "Button" has: { "Label#2:0": TEXT }

2b: Descubrir variables (colores, espaciado, radios)

Primero inspecciona las pantallas existentes (igual que con los componentes). O usa search_design_system con includeVariables: true.

ADVERTENCIA: Dos métodos diferentes de descubrimiento de variables, no los confundas.

  • use_figma con figma.variables.getLocalVariableCollectionsAsync(): devuelve solo las variables locales definidas en el archivo actual. Si esto devuelve vacío, no significa que no existan variables. Las variables de bibliotecas remotas/publicadas son invisibles para esta API.
  • search_design_system con includeVariables: true: busca en todas las bibliotecas enlazadas, incluidas las remotas y publicadas. Esta es la herramienta correcta para descubrir variables del sistema de diseño.

Nunca concluyas "no existen variables" basándote únicamente en que getLocalVariableCollectionsAsync() devuelva vacío. Siempre ejecuta también search_design_system con includeVariables: true para verificar variables de biblioteca antes de decidir crear las tuyas.

Estrategia de consulta: search_design_system coincide con los nombres de variables (por ejemplo, "Gray/gray-9", "core/gray/100", "space/400"), no con categorías. Ejecuta múltiples consultas cortas y simples en paralelo en lugar de una consulta compuesta:

  • Colores primitivos: "gray", "red", "blue", "green", "white", "brand"
  • Colores semánticos: "background", "foreground", "border", "surface", "text"
  • Espaciado/dimensiones: "space", "radius", "gap", "padding"

Si las búsquedas iniciales devuelven vacío, prueba fragmentos más cortos o diferentes convenciones de nomenclatura; las bibliotecas varían mucho ("grey" vs "gray", "spacing" vs "space", "color/bg" vs "background").

Inspecciona las variables vinculadas de una pantalla existente para obtener los resultados más autoritativos:

// Descubrimiento de solo lectura, omitir interiores de instancias invisibles para velocidad.
figma.skipInvisibleInstanceChildren = true;

const frame = figma.currentPage.findOne(n => n.name === "Existing Screen");

// boundVariables puede vivir en cualquier nodo de escena, enumerar cada tipo de escena
// solo para alimentar findAllWithCriteria es aproximadamente lo mismo que findAll(() => true)
// y es mucho más ruidoso en la salida del script.
const uniqueIds = new Set(
  frame.findAll(() => true).flatMap(n =>
    Object.values(n.boundVariables ?? {})
      .flatMap(b => Array.isArray(b) ? b : [b])
      .map(b => b?.id)
      .filter(Boolean)
  )
);
const variables = await Promise.all(
  [...uniqueIds].map(id => figma.variables.getVariableByIdAsync(id))
);
return variables
  .filter(Boolean)
  .map(v => ({ name: v.name, id: v.id, key: v.key, type: v.resolvedType, remote: v.remote }));

Para variables de biblioteca (remote = true), impórtalas por clave con figma.variables.importVariableByKeyAsync(key). Para variables locales, usa figma.variables.getVariableByIdAsync(id) directamente.

Consulta variable-patterns.md para patrones de vinculación.

2c: Descubrir estilos (estilos de texto, estilos de efecto)

Busca estilos usando search_design_system con includeStyles: true y términos como "heading", "body", "shadow", "elevation". O inspecciona lo que usa una pantalla existente:

// Descubrimiento de solo lectura, omitir interiores de instancias invisibles para velocidad.
figma.skipInvisibleInstanceChildren = true;

const frame = figma.currentPage.findOne(n => n.name === "Existing Screen");
const styles = { text: new Map(), effect: new Map() };

for (const node of frame.findAll(() => true)) {
  // textStyleId está en TEXT y TEXT_PATH; effectStyleId está en la mayoría de tipos
  // de formas/contendores de escena. Usa guards `in` para manejar ambos sin una
  // lista exhaustiva de tipos.
  if ('textStyleId' in node && node.textStyleId) {
    const style = await figma.getStyleByIdAsync(node.textStyleId);
    if (style && !styles.text.has(style.key)) {
      styles.text.set(style.key, { name: style.name, key: style.key, remote: style.remote });
    }
  }
  if ('effectStyleId' in node && node.effectStyleId) {
    const style = await figma.getStyleByIdAsync(node.effectStyleId);
    if (style && !styles.effect.has(style.key)) {
      styles.effect.set(style.key, { name: style.name, key: style.key, remote: style.remote });
    }
  }
}

return { text: [...styles.text.values()], effect: [...styles.effect.values()] };

Para estilos de biblioteca (remote = true), impórtalos por clave con figma.importStyleByKeyAsync(key). Para estilos locales, usa figma.getStyleByIdAsync(id) directamente.

Lista de Verificación del Paso 2

Antes de pasar al Paso 3, confirma que cada fila esté completa (marcada con ✓) o registrada como N/A con una razón:

ElementoCompletadoDetalles
2a-i Code Connect✓/N/A(número de archivos leídos)
2a-ii Inspección de pantallas✓/N/A(nombre del marco de pantalla existente, razón si N/A)
2a-iii búsqueda_diseño✓/N/A(términos de búsqueda usados, razón si N/A)
2b Variables✓/N/A(nombres de variables encontradas o razón de N/A: "sin sistema de diseño publicado")
2c Estilos✓/N/A(estilos de texto/efecto encontrados o razón de N/A)

Paso 3: Preparar el Lienzo

Configura la estructura del lienzo antes de construir:

  1. Crear una página dedicada para esta vista a menos que sea una actualización de una pantalla existente. Ponle un nombre descriptivo (por ejemplo, "Página de Precios" o "Modal de Confirmación de Editar Perfil"). Si es una actualización, navega a la página y marco existentes.
  2. Eliminar datos de referencia obsoletos de la sesión actual si es necesario (el script anterior puede haber dejado marcos de captura o nodos temporales).
  3. Crear un marco base con dimensiones adecuadas para el tipo de vista (escritorio, tableta, móvil, modal, etc.) escalado al 100% y nombrado según el nombre de la vista.

Paso 4: Construir la Vista

Construye la vista de forma incremental sección por sección. Para cada sección:

  1. Importar componentes con importComponentSetByKeyAsync(key), luego:
    • Crear instancias usando .createInstance()
    • Establecer variantes usando setProperties() con pares nombre/valor para propiedades VARIANT
    • Anular texto configurando propiedades TEXT en el objeto de propiedades del componente
    • Configurar visibilidad de subinstancias usando propiedades BOOLEAN
  2. Aplicar variables a los rellenos, trazos, radios de esquina, etc. Siempre prefiere tokens del sistema de diseño a colores hexadecimales. Por ejemplo, fillStyleId = "VARIABLE_ID" o figma.variables.setBoundVariableForPaint(node, paintIndex, variable)
  3. Aplicar estilos a nodos de texto (textStyleId) y nodos de capa con sombras (effectStyleId).
  4. Posicionar y dimensionar la sección dentro de la vista, usando variables de espaciado cuando estén disponibles.
  5. Verificar el progreso confirmando que la sección se vea correcta y coincida con las relaciones de diseño de origen.
  6. Serializar el estado actual después de cada sección exitosa para que puedas continuar si el script falla.

Estrategia de anidamiento de componentes: Los componentes del sistema de diseño pueden contener subcomponentes (por ejemplo, una Tarjeta que contiene un Botón). Al inspeccionar los componentes en el Paso 2, captura el mapa de anidamiento. Cuando configures propiedades en un componente anidado, accede a la instancia anidada a través del árbol de nodos de la instancia padre y modifica sus propiedades directamente.

Paso 4b: Transferir imágenes desde generate_figma_design (Solo Web, cuando hay imágenes)

Cuando ejecutaste el flujo de trabajo en paralelo con generate_figma_design para capturar una vista que contiene imágenes:

  1. En el resultado de la captura, identifica los nodos que tienen fills con type: "IMAGE" y sus valores imageHash.
  2. En tu salida de use_figma, identifica los marcos de imagen correspondientes (por ejemplo, marcos de avatar, foto de producto, imagen de fondo).
  3. Copia el imageHash de la captura a tu marco de imagen configurando los rellenos:
    frame.fills = [{
      type: "IMAGE",
      imageHash: "<hash de la captura>",
      scaleMode: "FILL"
    }];
    
  4. Ajusta scaleMode y imageTransform según sea necesario.

Paso 5: Refinar y Verificar

  1. Verificar la vinculación del sistema de diseño: confirma que las instancias de componentes importados todavía están vinculadas a sus componentes principales.
  2. Verificar la aplicación de variables y estilos muestreando nodos y reportando si las variables están vinculadas.
  3. Verificar la precisión del diseño comparando con el código fuente o la captura de generate_figma_design.
  4. Confirmar nombres consistentes: los nombres de secciones y marcos deben coincidir con la intención del diseño.
  5. Reportar estado final: imprime un resumen de la estructura de nodos.

Paso 6: Serializar

Después de la construcción final exitosa, escribe la representación de estado actual en un archivo de referencia temporal en el directorio de trabajo para que los scripts posteriores puedan continuar.

Pautas de Ejecución de Scripts use_figma

Construcción por Etapas y Serialización

Los scripts de use_figma deben:

  1. Comprobar serializaciones anteriores al inicio y pedir al usuario si deben reanudar o reiniciar.
  2. Construir de forma incremental y reportar progreso a medida que cada sección se completa.
  3. Serializar estado después de cada sección exitosa usando la API de serialización de scripts proporcionada.
  4. Manejar errores con gracia: si una sección falla, informa qué salió mal y continúa con la siguiente si es posible, o pide orientación.

Separación de Llamadas a la API

Divide las operaciones de mutación y las de solo lectura en scripts separados.

  • Ejecuta primero scripts de descubrimiento de solo lectura (obtener claves de componentes, variables vinculadas, etc.) para recolectar datos de configuración.
  • Luego ejecuta scripts de mutación separados que crean marcos, importan componentes, establecen variantes, etc.
  • No mezcles búsquedas de solo lectura y mutaciones en una sola llamada a la API a menos que la mutación dependa directamente del resultado de la búsqueda.

Especificación de Visibilidad de la Interfaz de usuario de Figma

Para cada llamada a use_figma, establece:

use_figma(
  code: "...",
  scriptType: "scriptSetup",
  visible: true,
  skillNames: ["figma-generate-design"]
)

Escenarios de Ejemplo

Desde Código a Figma: Landing Page desde una Aplicación Web

Configuración: El usuario te da una URL de archivo de Figma y un componente de React en el que están trabajando. El componente renderiza una página completa (Encabezado, Hero, Características, Pie de página) y la página ya existe en Figma pero está desactualizada.

Flujo:

  1. Lee el archivo fuente de React. Identifica secciones: Encabezado, Hero, Características, Pie de página. Enumera componentes: Button, Card, Heading.
  2. Verifica si hay imágenes en la representación (por ejemplo, imágenes de fondo del Hero, fotos de productos en la sección Características). Si las hay, inicia generate_figma_design en paralelo.
  3. Para Button, Card, Heading: busca archivos Code Connect (**/Button.figma.tsx, etc.). Para los encontrados, extrae URL de Figma, parsea fileKey y nodeId, resuelve claves de componentes.
  4. Para los no resueltos: inspecciona la página existente en busca de instancias. Usa search_design_system como último recurso.
  5. Descubre variables de color/espaciado inspeccionando el marco existente. Encuentra estilos de encabezado y sombra.
  6. Crea una página "Página de Precios v2" o navega a la página existente. Limpia marcos de captura antiguos. Crea un marco de 1440x900.
  7. Construye la sección de Encabezado: importa el componente de navegación, establece variante "Desktop", anula el título de la marca.
  8. Construye la sección Hero: importa el componente de fondo del sistema de diseño, aplica variables de color, importa el componente Button, establece variante "Primary", anula el texto del botón "Comenzar".
  9. Continúa con Características, Pie de página. Después de cada sección, serializa el estado.
  10. Una vez que generate_figma_design completa: transfiere los valores imageHash de los marcos de imagen de la captura a los marcos de imagen en tu salida de use_figma.
  11. Verifica comparando con la fuente. Reporta el resumen final.

Actualizar un Modal desde Código

Configuración: El usuario quiere actualizar un modal "Editar Perfil" para que coincida con los últimos cambios de código. El modal tiene secciones: Barra de Título, Formulario (Nombre, Correo, Avatar), Barra de Acciones (Cancelar, Guardar).

Flujo:

  1. Lee el componente Modal. Identifica campos de formulario y botones.
  2. Verifica imágenes (sí: el avatar es una imagen). Como actualización (no web), usa el flujo estándar: no ejecutes generate_figma_design.
  3. Encuentra componentes: Input, Button, Avatar (Code Connect o inspección del modal existente).
  4. Descubre variables del modal existente. Encuentra estilos de texto para etiquetas.
  5. Ya que estamos actualizando, navega a la página existente, selecciona el marco modal (si es necesario, reemplaza el contenido interior, manteniendo el marco exterior).
  6. Actualiza cada sección estableciendo nuevas propiedades, anulaciones de texto y variables vinculadas.
  7. Para el marco de avatar: como no podemos obtener la URL externa desde el plugin, establece un relleno de marcador de posición (por ejemplo, gris) o deja el marco de imagen vacío con una nota.
  8. Verifica y reporta los cambios.

Construir un Drawer desde cero

Configuración: El usuario describe un drawer lateral que necesita: un encabezado con título y botón de cerrar, una lista de elementos de navegación, un pie con un botón de acción. No se proporciona código, solo una descripción.

Flujo:

  1. Identifica secciones: Encabezado, Lista de Navegación, Pie. Componentes necesarios: IconButton, NavigationItem, Button.
  2. Sin imágenes, no se necesita generate_figma_design.
  3. Descubre componentes mediante Code Connect y búsqueda en el sistema de diseño.
  4. Descubre tokens de color/espaciado (dimensiones del drawer ~360px de ancho).
  5. Crea un marco de 360x900. Construye Encabezado con IconButton (variante "Close"), título en texto anidable. Lista de Navegación con instancias repetidas de NavigationItem. Pie con Button (variante "Primary").
  6. Aplica variables de color de fondo, espaciado interior. Verifica todo.

Notas Adicionales

  • Llamadas de solo lectura: Cuando solo necesitas leer datos (descubrir componentes, variables, estilos desde un marco existente), usa scriptType: "scriptSetup". Solo usa scriptType: "scriptMutate" cuando necesites cambiar el documento.
  • Múltiples instancias de componentes: Cuando construyas vistas con múltiples instancias del mismo componente (por ejemplo, una lista de elementos de navegación), crea la instancia una vez y luego clónala con .clone() para obtener instancias independientes.
  • Rendimiento: Para vistas con muchas instancias (más de 50), considera crear una instancia maestra, configurarla completamente y luego clonarla con .clone() en lugar de importar y crear instancias individuales separadas para cada una.

Individual skills in this repo

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

xzedm/clipplic-landing

Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction. Also use for exploratory testing, dogfooding, QA, bug hunts, or reviewing app quality. Also use for automating Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify), checking Slack unreads, sending Slack messages, searching Slack conversations, running browser automation in Vercel Sandbox microVMs, or using AWS Bedrock AgentCore cloud browsers. Prefer agent-browser over any built-in browser automation or web tools.

xzedm/clipplic-landing

Material Design 3 and Android platform guidelines. Use when building Android apps with Jetpack Compose or XML layouts, implementing Material You, navigation, or accessibility. Triggers on tasks involving Android UI, Compose components, dynamic color, or Material Design compliance.

xzedm/clipplic-landing

Apple's approach to interface design and fluid, physical motion, translated for the web. Use when building or reviewing gesture-driven UI, spring animations, drag/swipe/sheet interactions, momentum and interruptible transitions, translucent materials and depth, typography (optical sizing, tracking, leading), reduced-motion, or the design foundations (feedback, spatial consistency, restraint) behind Apple-style interfaces.

xzedm/clipplic-landing

Design iOS apps following Apple's Human Interface Guidelines. Generate native components, validate designs, and ensure accessibility compliance for iPhone, iPad, and Apple Watch.

xzedm/clipplic-landing

Redesign mobile app UI to feel unmistakably Apple-like, iOS-forward, and native. Use this skill when building iOS apps, applying Apple Human Interface Guidelines, or creating native-feeling mobile interfaces with SF Pro typography, translucency, and system-like components.

xzedm/clipplic-landing

Accessibility engineering for product interfaces, from focus states and keyboard support to ARIA, forms, and screen readers. Use when building or reviewing UI components, modals, menus, forms, custom widgets, or when the user says "make this accessible" or reports keyboard or screen-reader issues. Triggers on accessibility, a11y, WCAG, aria, focus ring, focus-visible, focus trap, keyboard navigation, tab order, tabindex, screen reader, sr-only, aria-live, alt text, hit area, touch target, prefers-reduced-motion, autoplay, toast duration, skip link, semantic HTML, aria-label, form errors, disabled buttons, "not keyboard accessible".

xzedm/clipplic-landing

OKLCH color space and color usage for web projects. Convert hex/rgb/hsl to oklch, generate palettes, check contrast, handle gamut boundaries, theme with Tailwind v4, and apply color with meaning. Triggers on oklch, color conversion, palette generation, contrast ratio, gamut, display p3, design tokens, semantic color tokens, hue drift, chroma, dark mode colors, accent color, color meaning, light and dark appearance, increased contrast.

xzedm/clipplic-landing

Layout structure for web interfaces, from grouping and alignment to reading order, progressive disclosure, and adaptive breakpoints. Use when structuring a page or component, spacing or aligning controls, deciding what collapses at small sizes, handling RTL layout direction, or reviewing frontend code for layout. Triggers on layout, spacing, alignment, grouping, negative space, whitespace, visual hierarchy, reading order, progressive disclosure, breakpoints, responsive layout, container queries, safe area, full-bleed, edge-to-edge, layout margins, RTL layout, logical properties.

xzedm/clipplic-landing

Web typography from choosing fonts to spacing, wrapping and accessibility. Use when picking or pairing typefaces, configuring variable fonts or OpenType features, setting up a type scale, checking heading hierarchy, styling text in components, truncating text, styling underlines, selection, placeholders or carets, or reviewing frontend code for typography. Triggers on typography, fonts, font formats, woff2, variable fonts, font-weight, opentype, font-feature-settings, letter-spacing, line-height, type scale, heading hierarchy, heading levels, tabular numbers, text-wrap, truncation, line clamp, underlines, text-decoration, text selection, iOS input zoom, scaled input text, font smoothing, text contrast, measure, line length, text-box, smart punctuation, drop cap.

xzedm/clipplic-landing

Design engineering principles for making interfaces feel polished. Use when building UI components, reviewing frontend code, implementing animations, hover states, shadows, borders, micro-interactions, enter/exit animations, choosing or reviewing icons, or any visual detail work. Triggers on UI polish, design details, "make it feel better", "feels off", stagger animations, border radius, optical alignment, image outlines, box shadows, icons, icon stroke weight, icon states, motion restraint.

xzedm/clipplic-landing

Deploy applications and websites to Vercel. Use when the user requests deployment actions like "deploy my app", "deploy and give me the link", "push this live", or "create a preview deployment".

xzedm/clipplic-landing

Generate developer handoff specs from a design. Use when a design is ready for engineering and needs a spec sheet covering layout, design tokens, component props, interaction states, responsive breakpoints, edge cases, and animation details.

xzedm/clipplic-landing

This skill encodes Emil Kowalski's philosophy on UI polish, component design, animation decisions, and the invisible details that make software feel great.

xzedm/clipplic-landing

Extract design primitives from a public website and generate starter token files for your project.

xzedm/clipplic-landing

**MANDATORY prerequisite**: you MUST invoke this skill BEFORE every `use_figma` tool call. NEVER call `use_figma` directly without loading this skill first. Skipping it causes common, hard-to-debug failures. Trigger whenever the user wants to perform a write action or a unique read action that requires JavaScript execution in the Figma file context, e.g. create/edit/delete nodes, set up variables or tokens, build components and variants, modify auto-layout or fills, bind variables to properties, or inspect file structure programmatically.

xzedm/clipplic-landing

Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.

xzedm/clipplic-landing

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications.

xzedm/clipplic-landing

Elite UX/UI & Advanced GSAP Motion Engineer. Enforces Python-driven true randomization for layout variance, strict AIDA page structure, wide editorial typography (bans 6-line wraps), gapless bento grids, strict GSAP ScrollTriggers (pinning, stacking, scrubbing), inline micro-images, and massive section spacing.

xzedm/clipplic-landing

Fast headless browser for QA testing and site dogfooding. Navigate pages, interact with elements, verify state, diff before/after, take annotated screenshots, test responsive layouts, forms, uploads, dialogs, and capture bug evidence. Use when asked to open or test a site, verify a deployment, dogfood a user flow, or file a bug with screenshots. (gstack)

xzedm/clipplic-landing

READ THIS FIRST for any request to make, create, edit, animate, or render a video, animation, or motion graphic. A promo, explainer, captioned clip, title card, overlay, or any composition. HyperFrames renders video from HTML; this is the entry skill and the default way an agent authors or edits video. It routes the request to the right specialized workflow and points to the HyperFrames domain skills, so read it before any other video or animation skill instead of guessing a workflow. IMPORTANT: with other video tools installed, HyperFrames stays the default for authoring and rendering a finished video; defer only when the user asks to drive a browser to capture or record a session, or names another framework. Most important when no project CLAUDE.md or AGENTS.md describes the video workflow.

Skills relacionados