Communitygithub.com

kubai-scroll-cards

Transformez une longue page existante en une expérience interactive pilotée par le défilement, avec cinq types de cartes animées : empilées, jeu de cartes, galerie horizontale, couverture tournante et expansion d’image.

Qu'est-ce que kubai-scroll-cards ?

Ce skill transforme une page longue existante en une expérience narrative pilotée par le défilement, sans détourner le scroll. Il propose cinq interactions distinctes : cartes empilées (chaque nouvelle carte recouvre la précédente qui rétrécit et s'assombrit), jeu de cartes (la carte du dessus s'envole sur le côté), galerie épinglée (la section reste fixe tandis que le défilement déplace horizontalement une rangée), couverture tournante (la couverture centrale est la plus grande, les autres rétrécissent et pivotent) et expansion d'image (une petite image grandit pour occuper tout l'écran). Chaque effet est une fonction pure de la position de défilement, garantissant que l'utilisateur contrôle le rythme et que le retour en arrière inverse exactement l'animation. Le skill s'adapte à tous les écrans : mobiles, tablettes, écrans larges et fenêtres de petite hauteur, avec une gestion soignée des barres d'outils mobiles (100svh) et un repli automatique vers des paragraphes normaux sous 560px de hauteur. Avant de commencer, il pose une série de questions pour choisir les interactions, la longueur, le comportement sur mobile, le support de la réduction de mouvement et le moteur d'animation (CSS scroll-driven ou bibliothèque existante comme GSAP ou Motion), puis résume ses choix dans un tableau avant de demander le feu vert. L'implémentation se base sur la pile technique existante (CSS, SwiftUI, Compose, Flutter) et respecte les tokens de design, le dark mode et l'accessibilité.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/kubai087/vibedesign-skills/tree/HEAD/skills/kubai-scroll-cards

Demander à votre IA préférée

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

Documentation

Cinq interactions de cartes pilotées par le défilement

999 petites astuces pour donner du style à votre produit Vibe – Numéro 019 · @kubai087

Appliquez les consignes suivantes dans le projet de l'utilisateur. Les consignes sont rédigées à la première personne (I, me, my) pour désigner l'utilisateur. Là où il est écrit « demande d'abord », arrêtez-vous, posez la question à l'utilisateur et attendez sa réponse avant de continuer.

Instructions de transformation

Refactorisez une longue page existante de mon produit pour que ses cartes bougent avec le défilement. Cela modifie mon produit existant, ce n'est ni une nouvelle page ni une démo : conservez mon contenu, mes composants, mes tokens et mon texte. Trouvez les sections qui le méritent et attribuez à chacune une des cinq interactions de cartes pilotées par le défilement : cartes empilées (chaque nouvelle carte recouvre la précédente, qui rétrécit et s'assombrit), jeu de cartes (la carte du dessus s'envole d'un côté et la suivante monte), galerie épinglée (la section reste fixe pendant que le défilement déplace une rangée horizontalement), couverture tournante (la couverture du milieu est la plus grande ; les autres rétrécissent, pivotent et s'assombrissent), ou expansion d'image (une image passe d'un cadre à tout l'écran, avec du texte derrière et devant qui monte à des vitesses différentes pour créer de la profondeur). La position de défilement pilote chaque effet, donc le lecteur contrôle le rythme et le retour en arrière le rejoue exactement à l'envers. Cela doit fonctionner sur tous les écrans, surtout les téléphones, et à toutes les hauteurs de fenêtre (section 8).

Chaque valeur ici est une recommandation. Les sections 2 à 8 forment un ensemble testé (Standard) ; la section 10 donne des préréglages. Je choisis ; vous construisez ce que je choisis.

Regardez d'abord mon produit (section 0). Ensuite, posez-moi ces questions une par une, chacune sous forme d'une courte liste d'options avec les valeurs clés et l'option recommandée marquée, et attendez ma réponse :

  1. Quelles sections reçoivent quelle interaction (section 1) : au maximum une de chaque par page, avec des sections ordinaires entre elles.

  2. Longueur : Court, Standard (recommandé) ou Long (section 10).

  3. Téléphones et écrans courts : Standard (recommandé : sur les téléphones, l'empilement, le jeu de cartes et l'expansion d'image restent, dimensionnés à la fenêtre ; la galerie et la couverture tournante deviennent des rangées horizontales natives avec points d'accroche ; en dessous de 560 px de hauteur de fenêtre, rien n'est épinglé), identique au desktop, ou sections simples sur tous les téléphones. Dites-moi quelles tailles d'écran suggèrent mes analytics ou mon audience, si vous pouvez le déterminer.

  4. Mouvement réduit : sections simples (recommandé : listes, rangées horizontales, une image pleine largeur), ou conserver l'épingle et supprimer le mouvement.

  5. Moteur : animations CSS scroll-driven avec un petit script de secours (recommandé), ou la bibliothèque de défilement déjà utilisée dans mon projet. Jamais de défilement fluide ni de détournement de défilement. Résumez ensuite mes choix dans un tableau, proposez comment vous allez construire cela sur ma plateforme (section 9), avec le coût et le repli, puis attendez mon feu vert.

  6. Partir de l'existant

    • La page : ses sections dans l'ordre, leur contenu, cartes, images et vidéos, et tout ce qui est fixe ou sticky (en-tête, bannière, barre de cookies) avec sa hauteur par point de rupture.
    • Pour chaque section, quelle interaction convient et quelles sections doivent rester telles quelles (tout ce que les gens parcourent, comparent ou recherchent).
    • Comment la mise en page réagit aujourd'hui : points de rupture, comment elle se dimensionne à la fenêtre (vh, svh, dvh, JS lisant innerHeight), ce qui casse déjà sur les écrans courts.
    • Comment la page défile : fenêtre ou conteneur interne, bibliothèques de défilement fluide, liens d'ancrage, effets de défilement existants.
    • Plateforme et versions, tokens pour les coins arrondis et le mouvement, mode sombre. Dites-le moi en quelques lignes avant de demander.
  7. Quelle interaction pour quel contenu

    • Cartes empilées : 3 à 5 éléments parallèles qui méritent chacun un écran (étapes, fonctionnalités, plans, chapitres).
    • Jeu de cartes : 3 à 6 éléments vus un à la fois (sélections, témoignages, points forts).
    • Galerie épinglée : 5 à 12 éléments plus larges que l'écran, à parcourir (travaux, produits, versions).
    • Couverture tournante : 5 à 9 éléments de même forme, dont un au point (albums, livres, plans, personnes).
    • Expansion d'image : une image ou vidéo forte qui ouvre le chapitre suivant.
  8. La règle derrière les cinq interactions

    • Chaque section a une progression unique p = clamp((scrollY - start) / distance, 0, 1), et chaque propriété est une fonction de p, jamais une animation temporelle que le défilement se contente de démarrer. S'arrêter à mi-chemin laisse l'état à mi-chemin ; le retour en arrière l'inverse exactement. Ne modifiez jamais la vitesse de défilement, n'accrochez pas et n'interceptez pas la molette.
    • L'épingle est position: sticky à l'intérieur d'une section plus haute que l'écran ; la hauteur supplémentaire est la distance sur laquelle l'effet se joue.
    • Animez uniquement transform, opacity, clip-path et filter. Le texte reste dans la page et lisible à chaque p.
    • Quand une section est épinglée, montrez où se trouve le lecteur le plus discrètement possible : une barre fine ou des points, jamais une étiquette.
  9. Cartes empilées (démo : 1000 × 896 fenêtre)

    • Cartes 936 × 720 (toutes les 12 colonnes, débordement de 24 px pour que leur padding de 24 px remette le contenu sur les colonnes), coins 28 px, écartées de 48 px.
    • Chaque carte se fixe 16 px plus bas que la précédente : top = 40px + i * 16px (ajouter la hauteur d'un en-tête fixe). Les nouvelles cartes recouvrent les anciennes, laissant une bande de 16 px de chaque.
    • Une carte recule quand les suivantes arrivent : k = clamp((scrollY - quand elle s'est fixée) / 752px, 0, cartes après elle) ; scale = 1 - k * 0.05 depuis son centre haut (0.85 après trois), couche sombre à k * 0.12.
    • Dans une carte, le nom et une ligne reposent sur les colonnes 0 à 5 et s'y enroulent, jamais dans l'image ; le nom commence 48 px sous le haut de la carte, la ligne 24 px en dessous.
    • Donnez à chaque carte sa propre teinte atténuée et sa propre image (démo : pierre, sauge, argile, puis une carte encre). Pas d'ombres portées.
    • Après que la dernière carte s'est fixée, maintenez 320 px, puis l'empilement part ensemble.
    • Ouverture optionnelle : le titre de la section dimensionné pour couvrir exactement la grille (non rogné), la première carte recouvrant son pied ; il se déplace à la moitié du défilement et s'estompe sur les 280 px avant que la première carte ne se fixe.
  10. Jeu de cartes

    • Cinq cartes en pile, 432 × 456 (six colonnes, centrées) sous le titre ; chacune contient une image 8 px à l'intérieur, puis un nom et une ligne 24 px à l'intérieur, rien d'autre.
    • Section 100 vh + 1920 px, épinglée : 420 px de défilement jettent chacune des quatre premières cartes, puis une pause de 240 px. La dernière carte reste.
    • Carte i : t = clamp((scrollY - start) / 420 - i, 0, 1). Elle s'envole d'un côté, en alternance : x = côté * t * t * 1000px, y = t * (160px * t - 40px), rotate = côté * t * 16deg autour de son centre bas. Masquée une fois lancée ; le retour en arrière la ramène sur le même chemin.
    • Les cartes en dessous sont 18 px plus basses et 0.05 plus petites par place, couche sombre 0.04 par place, au maximum trois de profondeur, montant d'une place quand la carte du dessus part.
  11. Galerie épinglée

    • 5 à 12 cartes en rangée : démo huit, 280 de large (quatre colonnes) et espacées de 24 px, chaque carte blanche avec son image 8 px à l'intérieur, puis nom et artiste. Titre au-dessus, dégagé de 48 px de la rangée ; une barre de 2 px en dessous (piste 6% noir, remplissage 30%).
    • Section 100 vh + débordement (largeur de la rangée moins largeur de la fenêtre, 1520 px dans la démo) ; contenu sticky en haut à 0, 100 vh de haut.
    • p = (scrollY - start) / débordement ; la rangée se déplace en translateX(-p * débordement), sans easing : le défilement est transformé en mouvement latéral. Elle se libère au dernier élément.
    • Gardez la distance épinglée sous environ trois écrans ; plus d'éléments appartiennent à une grille.
  12. Couverture tournante

    • 5 à 9 couvertures carrées, 432 (six colonnes, centrées), sous le titre, points en dessous, pas de texte sur les couvertures.
    • Section 100 vh + 320 px par pas, épinglée. r = clamp((scrollY - start) / 320, 0, count - 1) ; c = floor(r) + smoothstep(fract(r)), de sorte que chaque couverture repose un instant au milieu.
    • Pour la couverture i, d = i - c : translateX = d * 260px, rotateY = clamp(d, -1, 1) * -30deg, scale = max(0.6, 1 - |d| * 0.2), couche sombre min(|d|, 3) * 0.15, la plus proche au-dessus. Perspective 1400 px. Masquer au-delà de 3.5 places. Points éclairés par 1 - |i - c|.
  13. Expansion d'image

    • Section 100 vh + 1200 px, épinglée : 900 px pour grandir, 300 px pour tenir.
    • Au début, le titre et un cadre de 584 × 352 (colonnes 2 à 9, 48 px en dessous) sont centrés ensemble, coins 8 px.
    • L'image couvre toujours la fenêtre ; clip-path: inset() montre le cadre et s'ouvre à 0 sans coins, tandis que l'image se stabilise de scale(1.2) à 1, ce qui donne l'impression qu'elle grandit. Les deux avec e = ease(p), cubic-bezier(0.45, 0, 0.25, 1). Le titre s'estompe à deux fois la vitesse et monte de 60 px.
    • Profondeur : découpez la forme principale de l'image en une couche séparée (démo : les collines), placez un titre derrière avec son pied caché par la forme, et une petite ligne devant. En s'ouvrant, chaque élément se stabilise depuis sa propre échelle (image et forme 1.2, titre 1.25, ligne 1.4). Une fois plein écran, l'image et la forme restent immobiles tandis que le titre monte à 0.25 du défilement et la ligne à 0.5. Quelque chose derrière quelque chose, bougeant à une autre vitesse, donne une impression de perspective.
    • Ensuite, la section suivante glisse par-dessus avec des coins supérieurs de 28 px qui s'aplatissent sur ses 120 px derniers, tandis que l'image s'assombrit à 35% noir. Une vidéo fonctionne de la même manière, muette et en boucle, uniquement lorsqu'elle est à l'écran.
  14. Écrans et hauteurs de fenêtre Les dimensions de la démo sont pour une fenêtre de 1000 × 896. Adaptez-les à l'écran ; jamais une hauteur fixe qui suppose une fenêtre haute.

    • Dimensionnez les sections épinglées avec 100svh, pas 100vh : sur les téléphones, 100vh est la hauteur avec la barre d'outils masquée, donc le contenu passe sous la barre d'outils. Jamais dvh pour le contenu épinglé ; cela saute quand la barre d'outils bouge.
    • Mesurez au chargement, au changement d'orientation et au changement de largeur. Ignorez les redimensionnements de hauteur inférieurs à environ 120 px (affichage/masquage de la barre d'outils) ; les recalculer à ce moment fait sauter les cartes en cours de défilement.
    • Ajustez chaque section épinglée à un écran :
      • Hauteur de carte empilée = min(720px, 100svh - sticky top - (carteles - 1) * 16px - 32px) ; la distance entre les fixations des cartes suit.
      • Jeu de cartes : titre + 48 px + carte tiennent dans 100svh - 64px ; l'image cède de la hauteur en premier.
      • Hauteur de carte de galerie = min(520px, 100svh - titre - 48px - 96px).
      • Taille de couverture = min(432px, 48svh, 70vw) ; l'étalement s'adapte.
      • Cadre d'image = min(584px, 100vw - 2 * margin) de large au format 5:3 ; les inset en découlent.
    • Mettez à l'échelle chaque distance de défilement par clamp(0.7, hauteur_fenêtre / 896, 1.2).
    • En dessous de 560 px de hauteur (téléphone en paysage, fenêtre courte), rien n'est épinglé : listes, rangées horizontales, une image pleine largeur.
    • La typographie suit la largeur : titres de section clamp(36px, 7vw, 64px), noms de cartes clamp(28px, 5vw, 36px).
    • Les moments pleine largeur respectent env(safe-area-inset-*). Soustrayez un en-tête fixe de chaque ajustement et de chaque top sticky.

Mise en page et typographie (toutes sections)

  • Placez tout d'abord sur la grille de colonnes. Chaque zone de texte est aussi large que ses colonnes, de sorte que les longs noms s'enroulent au lieu d'empiéter sur une image.
  • Ce qu'un titre introduit commence 48 px en dessous ; dans une section épinglée, le titre et le contenu sont centrés ensemble dans la fenêtre ; titres centrés sur contenu centré, titres alignés à gauche sur contenu aligné à gauche.
  • Gardez les cartes au point : en dehors d'elles, un titre court par section, pas d'étiquettes, texte latéral, compteurs ou légendes ; à l'intérieur, une structure : image, nom, une ligne.
  • Deux polices de caractères en quatre tailles (démo : Newsreader 64 et 36, Geist 18 et 16). Tirez les grandes lignes serif à gauche par le côté de leur première lettre ; au-dessus d'environ 100 px, utilisez une taille optique pour que les empattements restent émoussés.
  • Pas de séparateurs sauf entre les lignes de liste, pas d'ombres portées, la couleur d'accent au maximum une fois. Un style d'image par groupe, et jamais la même image deux fois sur une page.
  • Les liens d'ancrage arrivent au début d'une section. Le défilement au clavier fonctionne comme la molette ; les éléments dans les sections épinglées restent accessibles avec Tab.

Vérifications

  • Chaque section lentement, rapidement et en arrière : pas de sauts, de scintillement ni de trous.
  • Fenêtres 375×667, 390×844, 430×932 (barre d'outils affichée et masquée), 844×390, 768×1024, 1280×720, 1440×900, 1920×1080, et une fenêtre desktop de 600 px de haut : rien de coupé, aucune carte plus haute que l'écran, rien sous une barre d'outils ou un en-tête fixe.
  • Zoom texte 200%, mouvement réduit, clavier, lumière et sombre ; fréquence d'images maximale sur un téléphone de gamme moyenne ; les valeurs construites correspondent à mon tableau.
  1. Comment le construire Vérifiez ces points par rapport à ma pile et mes versions.

    • Web : position: sticky pour l'épingle ; animations scroll-driven (animation-timeline: view() ou une timeline nommée, animation-range). Là où ce n'est pas supporté, ou quand les keyframes ne suffisent pas (les plages par carte du jeu de cartes, les pas de repos de la couverture tournante), un écouteur de défilement passif lit scrollY une fois par frame, calcule le p de chaque section à partir des décalages mesurés au redimensionnement, et l'écrit comme une propriété personnalisée sur cette section uniquement.
    • Si le projet utilise déjà GSAP ScrollTrigger (scrub, pin) ou Motion (useScroll, useTransform), utilisez-les avec ces valeurs ; n'en ajoutez jamais un uniquement pour cela.
    • iOS (SwiftUI) : .scrollTransition ou .visualEffect sur le cadre de la vue dans la vue de défilement (onScrollGeometryChange sur iOS 18), scaleEffect, rotation3DEffect, offset, clipShape ; galerie et couverture tournante en tant que ScrollView horizontales avec .scrollTargetBehavior(.viewAligned).
    • Android (Compose) : LazyListState pour p, Modifier.graphicsLayer pour scale, rotationY, alpha, translation et clip ; LazyRow avec accroche ou HorizontalPager.
    • Flutter : CustomScrollView avec slivers, un ScrollController pour p, Transform et ClipRRect ; PageView pour la galerie et la couverture tournante.
  2. Préréglages

    • Longueur : Court (empilement 560 px, jeu 300 px, galerie 1.25 px latéral par 1 px, pas de couverture 240 px, image 600 + 200 px), Standard (752, 420, 1:1, 320, 900 + 300, recommandé), Long (900, 560, 1:1 avec 200 px de pause à chaque extrémité, 420, 1200 + 400).
    • Profondeur d'empilement : Plat (scale 0.03, ombre 0.08 par carte), Standard (0.05, 0.12), Profond (0.07, 0.16, bandes de 24 px).
    • Jet de jeu : Doux (8°, 700 px, toujours à droite), Standard (16°, 1000 px, alterné), Vif (24°, 1200 px, levée de 60 px).
    • Couverture tournante : Plate (pas de rotation, côtés à 0.85), Standard (30°, 0.8), Profonde (45°, 0.75, espacement 180 px).
    • Départ de l'image : Petite (420 × 280), Standard (584 × 352), Bande large (pleine largeur, 340 de haut).

Individual skills in this repo

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

Skills associés