Communitygithub.com

Claude Eye

Analiza cuadro por cuadro una grabación de pantalla de una animación web/UI para encontrar errores de sincronización, como elementos que aparecen/desaparecen fuera de sincronía, transiciones escalonadas que llegan en el momento equivocado, parpadeos o tirones. Usa ffmpeg para extraer los cuadros, luego la visión de Claude para leer cada cuadro (sin necesidad de clave API) y genera una línea de tiempo con marcas de tiempo y un informe de desincronización.

¿Qué es Claude Eye?

Claude Eye es una habilidad para Claude (disponible en plataformas como Claude Code, Cursor, Codex) que permite analizar animaciones web y de UI cuadro por cuadro a partir de una grabación de pantalla (video o GIF). Su propósito es detectar errores de sincronización difíciles de percibir a simple vista, como elementos que se desvanecen fuera de fase, transiciones que llegan con retraso, parpadeos o tirones. La habilidad utiliza ffmpeg para extraer los cuadros del video a una frecuencia determinada, y luego emplea la capacidad de visión de Claude para leer cada cuadro y registrar el estado de cada elemento animado (opacidad, posición, estado: oculto, entrando, visible, saliendo). Con estas observaciones, construye una línea de tiempo detallada y un informe de desincronización que identifica dónde y cuándo se rompe la sincronía. No requiere claves API externas, solo Node.js 18+ y ffmpeg/ffprobe. Es útil para desarrolladores que necesitan depurar animaciones CSS, JavaScript (incluyendo librerías como framer-motion o GSAP) y desean identificar problemas de timing con precisión de milisegundos.

Compatible con✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/AbbasMalikzada/claude-eye-skill/tree/HEAD/claude-eye

Preguntar en tu IA favorita

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

Documentación

Claude Eye: análisis de animaciones cuadro por cuadro

No puedes ver un video, pero sí leer imágenes. Esta habilidad convierte un video en un conjunto de cuadros con marcas de tiempo, te hace examinar cada cuadro y registrar lo que hace cada elemento animado, y luego convierte esas observaciones en una línea de tiempo que muestra exactamente cuándo las cosas se desincronizan. Los errores de sincronización en animaciones CSS/JS suelen ser de 100-300 ms, demasiado rápidos para verlos a simple vista, pero fáciles de detectar en una tabla de cuadros.

Los scripts se encuentran junto a este archivo en scripts/. Solo necesitan Node 18+ y ffmpeg/ffprobe, sin npm install. A continuación, <skill> hace referencia al directorio de esta habilidad.

1. Verificar requisitos previos

Ejecuta ffmpeg -version. Si falta, informa al usuario y proporciona el comando de instalación para su sistema operativo (Windows: winget install Gyan.FFmpeg o choco install ffmpeg; macOS: brew install ffmpeg; Linux: sudo apt install ffmpeg). Necesitarán una nueva terminal después. No lo instales por tu cuenta sin preguntar.

2. Extraer cuadros

node <skill>/scripts/extract_frames.mjs <video> --fps 5 --out ./claude-eye-output [--start S] [--end S] [--width 960]

Esto escribe frames/frame_NNNN.png más un manifest.json que asigna cada número de cuadro a su marca de tiempo. Siempre toma las marcas de tiempo del manifiesto, nunca las calcules de memoria.

Controla el presupuesto de lecturas de imágenes. Cada cuadro que lees consume contexto, así que apunta a unos 40 cuadros o menos por pasada:

  • Clip corto (menos de ~8 s): 5 fps en toda la duración está bien.
  • Clip más largo, o no sabes dónde está el problema: haz primero una pasada gruesa (--fps 1 o 2 en todo el video) para encontrar dónde se mueven las cosas. Luego vuelve a extraer solo esa ventana a mayor fps (--start/--end, --fps 10-15) en un directorio --out separado. Reporta la pasada fina.
  • Si el usuario menciona un momento específico ("alrededor de 3 segundos", "cuando aparece el título"), ve directamente a esa ventana.

El ancho predeterminado de 960 px es suficiente para juzgar la opacidad y la posición. Usa un --width mayor solo si los elementos son muy pequeños.

3. Examinar los cuadros y registrar observaciones

Lee los cuadros en orden con la herramienta Read. Para cada cuadro, anota cada elemento de texto/UI visible que se esté animando o podría estarlo: títulos, subtítulos, botones, imágenes, spans resaltados, superposiciones, etc.

Mantén los nombres de los selectores estables entre cuadros: elige un nombre descriptivo en kebab-case la primera vez que veas un elemento (hero-title, subtitle, cta-button) y reutiliza exactamente ese nombre en todos los cuadros posteriores. La línea de tiempo une los cuadros por nombre, así que hero-title en un cuadro y title en el siguiente se convierten en dos elementos diferentes y el análisis se rompe. Incluye un elemento al 0% una vez que haya aparecido o se sepa que existe. Esto hace visibles los puntos de "oculto → entrada en transición".

Para cada elemento, estima:

  • opacity_percent (0-100). Juzga contra el fondo y contra la apariencia completamente visible del elemento en cuadros posteriores. También cuenta las revelaciones parciales: un recorte con clip-path o un barrido de máscara que está revelado al 40% cuenta como 40.
  • state: uno de hidden (≤10%), transitioning-in (creciente), visible (≥90%), transitioning-out (decreciente). Compara con los cuadros vecinos para distinguir "entrada" de "salida".
  • Opcional: has_gradient, has_blur, y notes para cosas como movimiento ("translateY ~20px por encima de la posición final"), escala, cantidad de desenfoque o cambio de color. El movimiento y la escala importan tanto como la opacidad, así que regístralos en notes cuando los veas.

Escribe todo en <out>/frames.json:

[
  {
    "frame": 1,
    "elements": [
      { "selector": "hero-title", "opacity_percent": 0, "state": "hidden" },
      { "selector": "subtitle", "opacity_percent": 0, "state": "hidden" }
    ],
    "overall_state": "pre-animation",
    "observation": "Área hero vacía; nada renderizado aún."
  }
]

frame debe coincidir con los números de cuadro del manifiesto. Las marcas de tiempo se completan desde el manifiesto. Para ejecuciones largas, escribe el archivo en fragmentos a medida que avanzas, en lugar de mantener 40 cuadros en memoria.

La opacidad de un video comprimido es aproximada. Una diferencia de ±10% entre cuadros es ruido; los patrones a lo largo de varios cuadros son la señal.

4. Construir el informe

node <skill>/scripts/build_report.mjs ./claude-eye-output --context "lo que se supone que debe hacer la animación"

Esto produce report.md (resumen, tabla de línea de tiempo de opacidad, temporización por elemento, puntos de transición, eventos de desincronización, observaciones) y analysis.json. Una desincronización es un cuadro donde algunos elementos son completamente visibles mientras que otros todavía están en transición, con más de 40 puntos de diferencia de opacidad entre ellos. Usa --spread N para hacer ese umbral más o menos estricto.

5. Interpretar: aquí es donde aportas valor

El script encuentra cuándo ocurren las cosas. Tu trabajo es decir por qué y qué cambiar:

  1. Reemplaza la sección <!-- RECOMMENDATIONS --> de report.md con hallazgos específicos. Lee la tabla de temporización de elementos: por ejemplo, "subtitle comienza 200 ms después de hero-title y alcanza la opacidad total 400 ms más tarde, lo que apunta a una duración más larga más un retraso". Convierte las diferencias de cuadros a milisegundos usando el espaciado entre cuadros (1/fps).
  2. Si el código fuente del usuario está disponible, encuentra el CSS/JS de estos elementos (transition, animation, @keyframes, transition-delay, configuraciones de framer-motion/GSAP) y señala las líneas exactas que explican la temporización observada. Propón la solución concreta.
  3. Menciona tu precisión de temporización (±1 cuadro = ±1/fps s). Si una conclusión depende de una diferencia menor que un cuadro, vuelve a extraer esa ventana a un fps más alto antes de afirmarla.

Luego dale al usuario un breve resumen en el chat: qué se anima, las temporizaciones clave, cada desincronización con su marca de tiempo y causa probable, y la solución. Incluye la ruta a report.md.

No solo opacidad

El flujo del informe está construido alrededor de opacidad/visibilidad, pero el mismo enfoque de lectura de cuadros funciona para otras preguntas, como desplazamiento de layout, un elemento que salta, parpadeo (un cuadro de estado incorrecto), un loader que gira cuando no debería, o una curva de aceleración que parece lineal. Para esos casos, sigue extrayendo cuadros y leyéndolos. Puedes omitir build_report.mjs y responder directamente con marcas de tiempo referenciadas a cuadros desde el manifiesto.

Skills relacionados