Communitygithub.com

2233admin/design-pipeline

Cette compétence est utilisée lorsque l'utilisateur demande de « faire une vidéo de démonstration produit », « créer une vidéo de démonstration d'application », « réaliser une vidéo d'annonce de fonctionnalité », « faire une démo SaaS », « réaliser une vidéo de parcours UI », « animer des captures d'écran produit en démo », « ajouter un curseur animé/clic à une capture d'écran », ou « zoomer sur une partie d'une interface ». Elle couvre la transformation de captures d'écran/maquettes statiques (pas d'enregistrement d'écran) en une démonstration animée propre : cadres d'appareil/navigateur, curseur animé + effet de clic, zoom/déplacement vers l'élément focal, annotations, rythme des étapes, transitions entre écrans, et légendes de fonctionnalités.

Qu'est-ce que design-pipeline ?

Cette compétence permet de transformer des captures d'écran ou des maquettes statiques en une vidéo de démonstration animée et soignée, sans recourir à un enregistrement d'écran. Elle est idéale pour les démos d'applications SaaS, les annonces de fonctionnalités, les parcours d'intégration et les présentations de produits. Le système prend en charge l'ajout de cadres d'appareil/navigateur, un curseur animé avec un effet de clic, un zoom/déplacement vers une zone focale, des annotations de type callout, des transitions entre écrans et des légendes de fonctionnalités. Basé sur Remotion, il garantit que chaque image est une fonction pure de `useCurrentFrame()`, rendant le rendu déterministe et reproductible. La compétence est compatible avec les environnements de développement JavaScript/TypeScript utilisant Remotion et peut être intégrée dans des pipelines CI/CD. Elle fonctionne en ingérant des captures d'écran haute résolution (2×), en les cadrant, en animant un curseur synthétique, en ajoutant des zooms et des annotations, et en produisant une vidéo MP4 finalisée.

Compatible avec~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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Vidéo de démonstration produit

Transformez des captures d'écran ou des maquettes de produit statiques en une démo animée et soignée — pas d'enregistreur d'écran, pas de curseur réel saccadé, pas de dérive de version UI. Cadrez chaque écran, faites glisser un curseur synthétique jusqu'au pixel exact, faites onduler le clic, puis zoomez sur la partie importante et légendez la fonctionnalité. Parce que l'entrée est statique et le mouvement est codé, chaque valeur est déterministe et se re-rend à l'identique lorsque la capture d'écran change.

Quand l'utiliser

  • Démo d'application / SaaS, annonce de fonctionnalité, parcours d'intégration (15–90s).
  • Montrer un chemin de clic à travers une UI dont vous n'avez que des captures d'écran/maquettes.
  • Mettre en évidence une zone focale d'un tableau de bord dense (zoom sur une région + callout).

Pourquoi les captures d'écran battent les enregistrements d'écran

Enregistrement d'écranPiloté par captures d'écran (cette compétence)
Le curseur réel dérive, dépasse, saccadeLe curseur suit un chemin fluide vers une cible exacte
Ré-enregistrer toute la prise pour corriger une étapeÉchanger un PNG, re-rendre le même code
L'UI change en cours de prise, la souris chercheChaque écran est un asset propre et final
Difficile de zoomer sans pixelisationExporter les captures d'écran en 2× (DPR 2) → zooms nets

Capturez les entrées à deux fois la taille d'affichage (retina / deviceScaleFactor: 2) pour qu'un zoom 2× reste net. Voir references/screenshot-demo.md pour un script de capture Playwright.

La boucle de démo

Chaque démo suit le même rythme, répété par fonctionnalité. Maintenez assez longtemps pour lire, déplacez-vous avec intention, posez le clic, révélez le résultat.

RythmeDuréeRôle
S'installer sur l'écran0,5–1sLaisser le spectateur s'orienter avant tout mouvement
Le curseur se déplace vers la cible0,4–0,8sMouvement fluide (ease-in-out), pas linéaire
Ondulation du clic + changement d'état0,2–0,3sRetour tactile ; l'écran réagit sur la même image
Zoom sur la région focale1–2s d'entrée, maintenir 2–4s2× est le point idéal — assez de détails, garde le contexte
Légende de la fonctionnalitémaintenir avec le zoomUne phrase de bénéfice, par ex. « Export en un clic »

Déplacez la caméra ou le curseur, rarement les deux à la fois — deux mouvements simultanés divisent l'attention.

Cadrer la capture d'écran

Une capture d'écran brute ressemble à un rapport de bug ; une capture cadrée ressemble à un produit. Entourez chaque écran d'un chrome de navigateur ou d'appareil sur un fond de marque.

// Cadre de navigateur — déposez une capture d'écran, obtenez une fenêtre crédible
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>
);

Mettez une URL réelle dans la barre d'adresse (authenticité), ajoutez une ombre douce et un fond dégradé. Pour le mobile, remplacez par un cadre de téléphone avec une encoche et des coins arrondis. Gardez le style de cadre dans un seul objet de thème pour que chaque écran corresponde.

Curseur animé + ondulation de clic (le mouvement central)

Conduisez la position à partir de l'image courante, jamais d'une transition CSS ou d'une horloge murale — un rendu vidéo a besoin que chaque image soit une fonction pure du numéro d'image, sinon le curseur se désynchronise et scintille.

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

// Trajet fluide de `from` à `to` entre startFrame et 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);

  // L'ondulation se déploie une fois, à l'image du 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>
    </>
  );
};

Le curseur utilise smoothstep pour accélérer depuis l'arrêt et décélérer vers la cible (un curseur linéaire semble robotique). Déclenchez l'ondulation et le changement d'état de l'écran sur la même image clickAt pour que la cause et l'effet correspondent. Voir references/screenshot-demo.md pour la composition complète qui chaîne plusieurs clics sur plusieurs écrans.

Zoomer sur une région (Ken Burns pour UI)

Pour zoomer sur un élément focal, mettez à l'échelle l'écran et définissez transform-origin au centre de cet élément, afin que le zoom converge sur lui plutôt que sur le centre du cadre.

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>
  );
};

Limitez le zoom à environ 2× (au-delà de 3×, on perd le contexte et on désoriente). Maintenez l'état zoomé 2–4s — assez longtemps pour lire le détail — puis ressortez en douceur avant de passer à l'écran suivant. Associez le zoom à un callout, jamais brut.

Annotations callout et légendes de fonctionnalités

Annotez l'inflexion, puis laissez-la disparaître. Un callout est une étiquette + un connecteur (flèche, cercle ou soulignement) qui pointe vers l'élément focal.

  • Mettez en évidence l'élément avec un anneau doux ou un assombrissement autour (box-shadow: 0 0 0 9999px rgba(0,0,0,.45) découpe un trou de projecteur).
  • Légendez un bénéfice par rythme — un court groupe nominal (« Analytics en temps réel »), pas une phrase. Apparaît sur le zoom, disparaît avant l'étape suivante.
  • Gardez les légendes dans le tiers inférieur et dans la zone sécurisée pour le titre afin qu'elles survivent aux recadrages en 9:16.

Voir references/annotation-and-transitions.md pour les masques de projecteur, les connecteurs fléchés/circulaires, une piste de légendes typées, et les notes de zone sécurisée multi-aspect.

Transitions entre écrans

Entre les étapes, déplacez les écrans avec un langage cohérent. Choisissez-en un et gardez-le :

TransitionSensationUtilisation
Pousser / glisserMouvement « étape suivante » vers l'avantParcours linéaires
Zoom croiséÉlan, semblable à une applicationSauter dans une vue détaillée
Fondu enchaînéCalme, neutreChangement de contexte (paramètres → tableau de bord)
Coupure de montage sur un élément communFluideMême carte persistante entre les écrans

Maintenez l'écran sortant jusqu'à ce que son clic se résolve, puis transitionnez — ne coupez jamais en plein mouvement. Voir references/annotation-and-transitions.md.

Liste de vérification de sortie

  • Entrées capturées en 2× (DPR 2) ; les zooms restent nets à 2×.
  • Chaque valeur de curseur/zoom est une fonction pure de useCurrentFrame() — pas de transitions CSS pour l'état animé.
  • Le curseur se déplace sur un chemin fluide (smoothstep) ; l'ondulation et le changement d'état se déclenchent sur la même image de clic.
  • Chaque écran cadré (navigateur/appareil) avec une URL réelle et un thème cohérent.
  • Un mouvement à la fois (caméra ou curseur) ; zoom ≤ 2×, maintenu 2–4s.
  • Une légende de bénéfice par rythme, dans le tiers inférieur sécurisé pour le titre ; les transitions utilisent un langage cohérent.

Livrer et vérifier (images fixes rendues → MP4)

Aide packagée (scripts/) : assemblez vos images fixes avec scripts/contact-sheet.sh sheet.png f-hook.png f-mid.png f-end.png, puis validez l'encodage avec scripts/probe-mp4.sh out.mp4 [LxH] [fps]. Voir scripts/README.md.

C'est un niveau lourd : le livrable est un MP4, pas une page live. La démo ingère les assets de l'utilisateur — captures d'écran/maquettes, logo optionnel — donc la vérification consiste surtout à vérifier que la bonne image s'est bien chargée et se trouve dans le cadre.

Contrat de sortie :

  • Un projet Remotion avec la composition enregistrée (<Composition> + schéma zod schema + defaultProps) ; chaque valeur de curseur/zoom/transition est une fonction pure de useCurrentFrame() (pas de transitions CSS, de minuteurs, de Date.now()).
  • Les captures d'écran chargées via staticFile(), protégées par delayRender/continueRender pour que le PNG 2× (et toute police web) soit présent avant le rendu de l'image — sinon l'écran apparaît vide au milieu de la démo.
  • Livrable = le out/*.mp4 rendu plus le projet (re-rendu lorsque la capture d'écran change).

Boucle de vérification — rendre des images fixes → inspecter → encoder. D'abord des PNG bon marché, la vidéo seulement quand ils sont corrects.

# Images fixes EXACTES À L'IMAGE avec les PROPS QUE VOUS ALLEZ LIVRER (vrais chemins de captures), pas defaultProps
npx remotion still ProductDemo out/f-settle.png --frame=15  --props=demo.json   # écran cadré, avant le mouvement
npx remotion still ProductDemo out/f-click.png  --frame=90  --props=demo.json   # curseur sur la cible + ondulation
npx remotion still ProductDemo out/f-zoom.png   --frame=150 --props=demo.json   # zoomé sur la région focale + légende
# image de fin = durationInFrames - 1 (npx remotion compositions le lit)

Inspectez chaque PNG pour la fidélité (capture d'écran correcte chargée ; curseur sur le pixel exact ; ondulation du clic et changement d'état sur la même image ; texte de légende correct) ET les artefacts (image vide/non chargée, écran hors cadre, zoom pixelisé ou dépassant le cadre, légende hors du tiers inférieur sécurisé, mauvais rapport hauteur/largeur ou letterboxing).

# Seulement après que les images fixes sont propres :
npx remotion render ProductDemo out/demo.mp4 --props=demo.json
npx remotion render ProductDemo out/demo.gif --props=demo.json --codec=gif   # PREUVE DE PREMIER ÉCRAN pour le README

Traitement par lots (un modèle, plusieurs produits) : lors du réhabillage de la démo par produit, vérifiez les props d'UN produit représentatif via des images fixes avant de rendre le catalogue par lots — attrapez un bug d'image vide ou hors cadre une fois, pas N fois.

Avant de terminer :

  1. Les images fixes se rendent proprement à l'installation / au clic / à la fin — pas d'erreurs, les captures d'écran sont bien chargées (pas vides).
  2. Le curseur atterrit sur la cible exacte ; l'ondulation + le changement d'état sur la même image ; le texte de légende correct et dans le tiers inférieur sécurisé pour le titre.
  3. Tout le mouvement est piloté par les images — pas de transitions CSS / minuteurs / Date.now() / Math.random().
  4. Les props livrées (vrais chemins de captures d'écran) se rendent correctement, pas seulement defaultProps.
  5. MP4 complet encodé et lisible ; (optionnel) GIF rendu pour le README.

Fichiers de référence

  • references/screenshot-demo.md — une démo Remotion complète et exécutable : capture de captures d'écran en 2× avec Playwright, les composants de cadre navigateur/téléphone, une composition multi-étapes qui promène un curseur sur plusieurs écrans avec ondulations de clic, et une commande de rendu.
  • references/annotation-and-transitions.md — masques de projecteur, connecteurs de callout fléchés/circulaires, une piste de légendes de fonctionnalités typées, et les quatre transitions entre écrans avec implémentations pilotées par les images et notes de zone sécurisée multi-aspect (16:9 / 9:16).

Individual skills in this repo

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

Skills associés