Communitygithub.com

product-demo-video

Convierte capturas de pantalla o diseños estáticos en un demo animado y pulido: marcos de navegador/dispositivo, cursor animado + ondulación de clic, zoom/pan a la interfaz objetivo, anotaciones, transiciones entre pantallas y leyendas de funciones.

¿Qué es product-demo-video?

Esta habilidad transforma capturas de pantalla estáticas o diseños en demos animados profesionales, sin necesidad de grabación de pantalla. A diferencia de las grabaciones tradicionales, donde el cursor real tiembla o se desvía, aquí el cursor sigue una trayectoria suave y determinista hacia coordenadas exactas, y cada clic produce una ondulación táctil y un cambio de estado sincronizado. La habilidad soporta plataformas como Remotion y Playwright, permitiendo generar vídeos MP4 reproducibles: cada fotograma es una función pura del número de fotograma, sin transiciones CSS ni temporizadores. Es ideal para demos de productos SaaS, anuncios de funciones o recorridos interactivos a partir de capturas 2× (retina), con zoom hasta 2× para mantener nitidez, anotaciones tipo "callout" y transiciones consistentes entre pantallas. El flujo de verificación incluye la generación de fotogramas estáticos económicos antes de codificar el vídeo completo, asegurando que cada elemento (cursor, zoom, leyenda) esté en su lugar correcto.

Compatible con~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/2233admin/design-pipeline/tree/HEAD/skill/references/iart-motion-skills/upstream/ecommerce-video-skills/skills/product-demo-video

Preguntar en tu IA favorita

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

Documentación

Product Demo Video

Convierte capturas de pantalla estáticas o diseños de producto en un demo animado y pulido — sin grabador de pantalla, sin cursor real tembloroso, sin desviación de versión de la interfaz. Enmarca cada pantalla, desliza un cursor sintético hasta el píxel exacto, genera la ondulación del clic, luego haz zoom a la parte que importa y añade una leyenda a la función. Como la entrada es estática y el movimiento es código, cada valor es determinista y se vuelve a renderizar de forma idéntica cuando la captura cambia.

Cuándo usarlo

  • Demo de app / SaaS, anuncio de función, recorrido de incorporación (15–90s).
  • Mostrar una ruta de clics a través de una interfaz de la que solo tienes capturas de pantalla/diseños.
  • Destacar una región focal de un panel denso (zoom a región + anotación).

Por qué las capturas de pantalla superan a las grabaciones de pantalla

Grabación de pantallaBasada en capturas (esta habilidad)
El cursor real se desvía, sobrepasa, tiemblaEl cursor sigue una trayectoria suave hasta un destino exacto
Hay que regrabar toda la toma para corregir un pasoCambia un PNG, vuelve a renderizar el mismo código
La interfaz cambia durante la toma, el ratón buscaCada pantalla es un activo limpio en estado final
Difícil hacer zoom sin pixelaciónExporta capturas a 2× (DPR 2) → zooms nítidos

Captura las entradas al doble del tamaño de visualización (retina / deviceScaleFactor: 2) para que un zoom 2× se mantenga nítido. Consulta references/screenshot-demo.md para un script de captura con Playwright.

El bucle del demo

Cada demo sigue el mismo ritmo, repetido por función. Mantén la pausa suficiente para leer, muévete con intención, aterriza el clic, revela el resultado.

RitmoDuraciónPropósito
Pausa en pantalla0.5–1sDeja que el espectador se oriente antes de que algo se mueva
El cursor viaja al destino0.4–0.8sMovimiento suave (ease-in-out), no lineal
Ondulación de clic + cambio de estado0.2–0.3sRetroalimentación táctil; la pantalla reacciona en el mismo fotograma
Zoom a la región focal1–2s entrada, mantener 2–4s2× es el punto ideal — suficiente detalle, mantiene el contexto
Leyenda de la funciónmantener con el zoomUna frase de beneficio, ej. "Exportación con un clic"

Mueve la cámara o el cursor, rara vez ambos a la vez — dos movimientos simultáneos dividen la atención.

Enmarcar la captura de pantalla

Una captura sin marco parece un informe de error; una enmarcada parece producto. Envuelve cada pantalla en un marco de navegador o dispositivo sobre un fondo de marca.

// Marco de navegador — coloca una captura y obtén una ventana creíble
const BrowserFrame = ({ url, children }) => (
  <div style={{ borderRadius: 12, overflow: "hidden", background: "#1e1e22",
                boxShadow: "0 40px 80px rgba(0,0,0,.35)" }}>
    <div style={{ height: 40, display: "flex", alignItems: "center", gap: 8, padding: "0 14px" }}>
      {["#ff5f57", "#febc2e", "#28c840"].map((c) => (
        <span key={c} style={{ width: 12, height: 12, borderRadius: "50%", background: c }} />
      ))}
      <div style={{ marginLeft: 12, flex: 1, height: 24, borderRadius: 6, background: "#2b2b30",
                    color: "#9aa", fontSize: 13, display: "flex", alignItems: "center", padding: "0 10px" }}>
        {url}
      </div>
    </div>
    <div style={{ background: "#fff" }}>{children}</div>
  </div>
);

Pon una URL real en la barra de direcciones (autenticidad), añade una sombra suave y un fondo degradado. Para móvil, cambia a un marco de teléfono con muesca y esquinas redondeadas. Mantén el estilo del marco en un solo objeto de tema para que todas las pantallas coincidan.

Cursor animado + ondulación de clic (el movimiento central)

Impulsa la posición desde el fotograma actual, nunca desde una transición CSS o reloj de pared — un renderizador de vídeo necesita que cada fotograma sea una función pura del número de fotograma, o el cursor se desincroniza y parpadea.

import { useCurrentFrame, interpolate, spring, useVideoConfig } from "remotion";

// Trayectoria suave desde `from` hasta `to` entre startFrame y startFrame+dur
const useCursor = (from, to, startFrame, dur) => {
  const frame = useCurrentFrame();
  const t = interpolate(frame, [startFrame, startFrame + dur], [0, 1],
    { extrapolateLeft: "clamp", extrapolateRight: "clamp", easing: (x) => x * x * (3 - 2 * x) }); // smoothstep
  return { x: from.x + (to.x - from.x) * t, y: from.y + (to.y - from.y) * t };
};

export const Cursor = ({ from, to, startFrame, dur, clickAt }) => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();
  const { x, y } = useCursor(from, to, startFrame, dur);

  // La ondulación se expande una vez, en el fotograma del clic
  const since = frame - clickAt;
  const showRipple = since >= 0 && since < 18;
  const r = spring({ frame: since, fps, config: { damping: 18 }, durationInFrames: 18 });

  return (
    <>
      {showRipple && (
        <div style={{ position: "absolute", left: x, top: y, transform: "translate(-50%,-50%)",
          width: 12 + r * 60, height: 12 + r * 60, borderRadius: "50%",
          border: "2px solid rgba(80,140,255,.9)", opacity: 1 - r }} />
      )}
      <svg width="28" height="28" viewBox="0 0 28 28"
           style={{ position: "absolute", left: x, top: y, filter: "drop-shadow(0 2px 3px rgba(0,0,0,.4))" }}>
        <path d="M3 2 L3 21 L9 15 L13 24 L16 23 L12 14 L20 14 Z" fill="#fff" stroke="#222" strokeWidth="1.4" />
      </svg>
    </>
  );
};

El cursor usa smoothstep para acelerar desde el reposo y desacelerar hacia el destino (un cursor lineal se percibe como robótico). Activa la ondulación y el cambio de estado de la pantalla en el mismo fotograma clickAt para que causa y efecto coincidan. Consulta references/screenshot-demo.md para la composición completa que conecta múltiples clics en múltiples pantallas.

Zoom a una región (Ken Burns para UI)

Para hacer zoom a un elemento focal, escala la pantalla y establece transform-origin en el centro de ese elemento, de modo que el zoom converja hacia él en lugar del centro del fotograma.

const ZoomToRegion = ({ target, scale = 2, startFrame, dur, children }) => {
  const frame = useCurrentFrame();
  const s = interpolate(frame, [startFrame, startFrame + dur], [1, scale],
    { extrapolateLeft: "clamp", extrapolateRight: "clamp", easing: (x) => 1 - Math.pow(1 - x, 3) }); // easeOutCubic
  return (
    <div style={{ transform: `scale(${s})`, transformOrigin: `${target.x}px ${target.y}px`,
                  willChange: "transform" }}>
      {children}
    </div>
  );
};

Limita el zoom a aproximadamente 2× (más de 3× pierde contexto y desorienta). Mantén el estado ampliado 2–4s — el tiempo suficiente para leer el detalle — luego vuelve a salir suavemente antes de pasar a la siguiente pantalla. Acompaña el zoom con una anotación, nunca solo.

Anotaciones tipo callout y leyendas de funciones

Anota el punto clave, luego déjalo claro. Un callout es una etiqueta + un conector (flecha, círculo o subrayado) que apunta al elemento focal.

  • Destaca el elemento con un anillo suave o un fondo atenuado (box-shadow: 0 0 0 9999px rgba(0,0,0,.45) recorta un agujero de foco).
  • Leyenda un beneficio por ritmo — frase nominal corta ("Analíticas en tiempo real"), no una oración. Aparece con el zoom, desaparece antes del siguiente paso.
  • Mantén las leyendas en el tercio inferior y dentro del área segura para títulos, para que sobrevivan a recortes a 9:16.

Consulta references/annotation-and-transitions.md para máscaras de foco, conectores de flecha/círculo, una pista de leyendas mecanografiadas y notas de área segura para múltiples relaciones de aspecto.

Transiciones entre pantallas

Entre pasos, mueve las pantallas con un lenguaje consistente. Elige uno y mantenlo:

TransiciónSensaciónUso
Empujar / deslizarMovimiento de "siguiente paso"Recorridos lineales
Cross-zoomMomentum, como appSaltar a una vista de detalle
CrossfadeCalmado, neutroCambio de contexto (configuración → panel)
Match-cut en un elemento compartidoSin costurasLa misma tarjeta persiste entre pantallas

Mantén la pantalla saliente hasta que su clic se resuelva, luego transiciona — nunca cortes a medio movimiento. Consulta references/annotation-and-transitions.md.

Lista de verificación de salida

  • Capturas de entrada a 2× (DPR 2); los zooms se mantienen nítidos a 2×.
  • Cada valor de cursor/zoom es una función pura de useCurrentFrame() — sin transiciones CSS para el estado animado.
  • El cursor viaja en una trayectoria suave (smoothstep); la ondulación y el cambio de estado se activan en el mismo fotograma de clic.
  • Cada pantalla enmarcada (navegador/dispositivo) con una URL real y tema consistente.
  • Un movimiento a la vez (cámara o cursor); zoom ≤ 2×, mantenido 2–4s.
  • Una leyenda de beneficio por ritmo, en el tercio inferior seguro para títulos; las transiciones usan un lenguaje consistente.

Entregar y verificar (fotogramas renderizados → MP4)

Helper empaquetado (scripts/): genera una hoja de contactos con scripts/contact-sheet.sh sheet.png f-hook.png f-mid.png f-end.png, luego verifica la codificación con scripts/probe-mp4.sh out.mp4 [WxH] [fps]. Consulta scripts/README.md.

Este es un nivel pesado: el entregable es un MP4, no una página en vivo. El demo consume activos del usuario — capturas/diseños, logo opcional — así que la verificación es principalmente si la imagen correcta se cargó y colocó en el fotograma.

Contrato de salida:

  • Un proyecto Remotion con la composición registrada (<Composition> + schema zod + defaultProps); cada valor de cursor/zoom/transición es una función pura de useCurrentFrame() (sin transiciones CSS, temporizadores, Date.now()).
  • Capturas cargadas mediante staticFile(), controladas con delayRender/continueRender para que el PNG 2× (y cualquier fuente web) esté presente antes de que el fotograma se renderice — de lo contrario, la pantalla aparece en blanco a mitad del demo.
  • Entregable = el out/*.mp4 renderizado más el proyecto (vuelve a renderizar cuando la captura cambie).

Bucle de verificación — renderizar fotogramas → inspeccionar → codificar. Primero PNGs económicos, vídeo solo cuando estén correctos.

# Fotogramas estáticos EXACTOS CON LAS PROPS QUE VAS A ENVIAR (rutas reales de captura), no defaultProps
npx remotion still ProductDemo out/f-settle.png --frame=15  --props=demo.json   # pantalla enmarcada, antes del movimiento
npx remotion still ProductDemo out/f-click.png  --frame=90  --props=demo.json   # cursor en el objetivo + ondulación
npx remotion still ProductDemo out/f-zoom.png   --frame=150 --props=demo.json   # zoom a región focal + leyenda
# fotograma final = durationInFrames - 1 (npx remotion compositions lo lee)

Inspecciona cada PNG en busca de fidelidad (captura correcta cargada; cursor en el píxel exacto; ondulación de clic y cambio de estado en el mismo fotograma; texto de leyenda correcto) Y artefactos (imagen en blanco/no cargada, pantalla fuera del lienzo, zoom pixelado o sobrepasando el fotograma, leyenda fuera del tercio inferior seguro, relación de aspecto o letterboxing incorrecto).

# Solo después de que los fotogramas estáticos estén limpios:
npx remotion render ProductDemo out/demo.mp4 --props=demo.json
npx remotion render ProductDemo out/demo.gif --props=demo.json --codec=gif   # Prueba de primera pantalla para el README

Por lotes (una plantilla, muchos productos): cuando se re-skinnee el demo por producto, verifica UN producto representativo mediante fotogramas estáticos antes de renderizar por lotes el catálogo — detecta un error de imagen en blanco o fuera del lienzo una vez, no N veces.

Antes de terminar:

  1. Los fotogramas estáticos se renderizan limpiamente en las posiciones de pausa, clic y final — sin errores, capturas realmente cargadas (no en blanco).
  2. El cursor aterriza en el objetivo exacto; ondulación + cambio de estado en el mismo fotograma; texto de leyenda correcto y en el tercio inferior seguro para títulos.
  3. Todo el movimiento impulsado por fotogramas — sin transiciones CSS / temporizadores / Date.now() / Math.random().
  4. Las props enviadas (rutas reales de captura) se renderizan correctamente, no solo defaultProps.
  5. MP4 completo codificado y reproducible; (opcional) GIF renderizado para el README.

Archivos de referencia

  • references/screenshot-demo.md — un demo Remotion completo y ejecutable: captura de capturas a 2× con Playwright, componentes de marco de navegador/teléfono, una composición de varios pasos que mueve un cursor a través de varias pantallas con ondulaciones de clic y un comando de renderizado.
  • references/annotation-and-transitions.md — máscaras de foco, conectores de flecha/círculo, una pista de leyendas mecanografiadas y las cuatro transiciones entre pantallas con implementaciones impulsadas por fotogramas y notas de área segura para múltiples relaciones de aspecto (16:9 / 9:16).

Individual skills in this repo

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

Skills relacionados