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 1o2en 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--outseparado. 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 dehidden(≤10%),transitioning-in(creciente),visible(≥90%),transitioning-out(decreciente). Compara con los cuadros vecinos para distinguir "entrada" de "salida".- Opcional:
has_gradient,has_blur, ynotespara 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 ennotescuando 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:
- Reemplaza la sección
<!-- RECOMMENDATIONS -->dereport.mdcon hallazgos específicos. Lee la tabla de temporización de elementos: por ejemplo, "subtitlecomienza 200 ms después dehero-titley 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). - 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. - 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.