Communitygithub.com

kubai-scroll-cards

Wandelt lange Seiten durch fünf scrollgesteuerte Karteninteraktionen in lebendige Erlebnisse um: gestapelte Karten, Kartenstapel, horizontale Galerie, Coverflow und Bildausklapp – alles durch die Bildlaufposition gesteuert.

Was ist kubai-scroll-cards?

Diese Anleitung beschreibt eine Technik zur Transformation bestehender langer Webseiten mit fünf scrollgesteuerten Karteninteraktionen: gestapelte Karten (neue Karten überdecken alte, die schrumpfen und abdunkeln), Kartenstapel (obere Karte fliegt zur Seite, nächste rückt nach), horizontale Galerie (Abschnitt fixiert, horizontales Scrollen durch Vertikalscrollen), Coverflow (mittlere Karte größte, seitliche schrumpfen und drehen) und Bilderweiterung (kleines Bild wächst auf Vollbild, Titel mit Tiefe). Alle Effekte werden rein durch die Scroll-Position gesteuert, der Leser behält die Kontrolle, Zurückscrollen spielt rückwärts ab, ohne das Scrollen zu kapern. Die Größenberechnung passt sich an verschiedene Bildschirme und Viewport-Höhen an, Handy-Symbolleisten blockieren keine Inhalte, kleine Bildschirme schalten automatisch auf normale Abschnitte um. Es werden mehrere Voreinstellungen mitgeliefert, die vor dem Start einzeln abgefragt werden, damit der Benutzer wählen oder anpassen kann. Nach der Bestätigung erfolgt die Implementierung basierend auf dem vorhandenen Technologie-Stack (scroll-gesteuerte Animationen, Sticky, Coverflow, svh).

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

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Scrollgesteuerte fünf Karteninteraktionen

《999 Tipps, um deinem Vibe-Produkt mehr Qualität zu verleihen》Ausgabe 019 · @kubai087

Wende in den Projekten des Benutzers die folgenden Anforderungen an. Die Anforderungen sind aus der Perspektive des Benutzers formuliert: I, me, my beziehen sich auf den Benutzer; wo steht, dass zuerst gefragt werden soll, halte inne, frage den Benutzer und fahre dann fort.

Anforderungen

Überarbeite eine bestehende lange Seite in meinem Produkt, sodass sich ihre Karten mit dem Scrollen bewegen. Dies verändert mein Produkt, keine neue Seite oder Demo: Behalte meine Inhalte, Komponenten, Tokens und Texte bei, finde die Abschnitte, die es verdienen, und gib jedem eine von fünf scrollgesteuerten Karteninteraktionen: gestapelte Karten (jede neue Karte bedeckt die letzte, die schrumpft und abdunkelt), ein Kartenstapel (die oberste Karte fliegt zur Seite und die nächste rückt nach), eine fixierte Galerie (der Abschnitt bleibt still, während das Scrollen eine Reihe seitlich verschiebt), ein Coverflow (mittleres Cover ist am größten; die anderen schrumpfen, drehen sich weg und dunkeln ab) oder eine Bilderweiterung (ein Bild wächst von einem Rahmen auf den ganzen Bildschirm, mit Wörtern dahinter und davor, die mit unterschiedlicher Geschwindigkeit aufsteigen, um Tiefe zu erzeugen). Die Scroll-Position steuert jeden Effekt, sodass der Leser das Tempo bestimmt und das Zurückscrollen alles rückwärts abspielt. Es muss auf jedem Bildschirm funktionieren, vor allem auf Handys, und bei jeder Viewport-Höhe (Abschnitt 8).

Jeder Wert hier ist eine Empfehlung. Abschnitte 2 bis 8 sind ein getestetes Set (Standard); Abschnitt 10 enthält Voreinstellungen. Ich wähle aus, du baust, was ich wähle.

Sieh dir zuerst mein Produkt an (Abschnitt 0). Frage mich dann nacheinander, jeweils als kurze Liste von Optionen mit wichtigen Werten und der empfohlenen markiert, und warte auf meine Antwort:

  1. Welche Abschnitte bekommen welche Interaktion (Abschnitt 1): höchstens eine pro Seite, mit normalen Abschnitten dazwischen.

  2. Länge: Kurz, Standard (empfohlen) oder Lang (Abschnitt 10).

  3. Handys und kleine Bildschirme: Standard (empfohlen: auf Handys bleiben Stapel, Deck und Bilderweiterung in Viewport-Größe; Galerie und Coverflow werden zu nativen horizontalen Reihen mit Snap-Punkten; unter 560 px Viewport-Höhe wird nichts fixiert), gleich wie Desktop oder einfache Abschnitte auf allen Handys. Sag mir, welche Bildschirmgrößen meine Analyse oder Zielgruppe nahelegt, falls du es herausfinden kannst.

  4. Reduzierte Bewegung: einfache Abschnitte (empfohlen: Listen, horizontale Reihen, ein vollbreites Bild) oder Fixierung beibehalten und Bewegung entfernen.

  5. Engine: CSS-Scroll-gesteuerte Animationen mit kleinem Script als Fallback (empfohlen) oder die Scroll-Bibliothek, die mein Projekt bereits verwendet. Niemals Smooth-Scrolling oder Scroll-Hijacking. Fasse dann meine Entscheidungen in einer Tabelle zusammen, schlage vor, wie du es auf meiner Plattform baust (Abschnitt 9), mit Kosten und Fallback, und warte auf mein Go.

  6. Ausgehend vom Bestehenden

  • Die Seite: ihre Abschnitte in Reihenfolge, deren Inhalt, Karten, Bilder und Videos, und alles Fixierte oder Sticky (Header, Banner, Cookie-Bar) mit seiner Höhe pro Breakpoint.
  • Für jeden Abschnitt, welche Interaktion passt und welche Abschnitte so bleiben müssen (alles, was Leute überfliegen, vergleichen oder suchen).
  • Wie das Layout heute reagiert: Breakpoints, wie es sich an den Viewport anpasst (vh, svh, dvh, JS ließt innerHeight), was bereits auf kleinen Bildschirmen bricht.
  • Wie die Seite scrollt: Fenster oder innerer Container, Smooth-Scroll-Bibliotheken, Ankerlinks, vorhandene Scrolleffekte.
  • Plattform und Versionen, Tokens für Radius und Bewegung, Dark Mode. Sag mir in ein paar Zeilen, bevor du fragst.
  1. Welche Interaktion für welchen Inhalt
  • Gestapelte Karten: 3 bis 5 parallele Elemente, die einen Bildschirm wert sind (Schritte, Funktionen, Tarife, Kapitel).
  • Kartenstapel: 3 bis 6 Elemente, die einzeln gesehen werden (Auswahl, Erfahrungsberichte, Highlights).
  • Fixierte Galerie: 5 bis 12 Elemente breiter als der Bildschirm, zum Durchstöbern (Arbeiten, Produkte, Veröffentlichungen).
  • Coverflow: 5 bis 9 Elemente gleicher Form, eines im Fokus (Alben, Bücher, Pläne, Personen).
  • Bilderweiterung: ein starkes Bild oder Video, das das nächste Kapitel eröffnet.
  1. Die Regel hinter allen fünf
  • Jeder Abschnitt hat einen Fortschritt p = clamp((scrollY - start) / distance, 0, 1), und jede Eigenschaft ist eine Funktion von p, niemals eine zeitgesteuerte Animation, die Scroll nur startet. Anhalten auf halbem Weg belässt es auf halbem Weg; Zurückscrollen kehrt es exakt um. Ändere niemals Scrollgeschwindigkeit, Snap oder fange das Rad ab.
  • Fixierung ist position: sticky innerhalb eines Abschnitts, der höher als der Bildschirm ist; die zusätzliche Höhe ist die Distanz, über die der Effekt abläuft.
  • Animiere nur transform, opacity, clip-path und filter. Text bleibt auf der Seite und bei jedem p lesbar.
  • Wenn ein Abschnitt fixiert ist, zeige so dezent wie möglich, wo der Leser ist: ein dünner Balken oder Punkte, niemals ein Label.
  1. Gestapelte Karten (Demo: 1000 x 896 Viewport)
  • Karten 936 x 720 (alle 12 Spalten, 24 px ausgerückt, sodass ihr 24 px Padding den Inhalt zurück auf die Spalten setzt), Ecken 28 px, 48 px Abstand.
  • Jede klebt 16 px tiefer als die letzte: top = 40px + i * 16px (Höhe eines fixierten Headers addieren). Neuere Karten bedecken ältere und lassen einen 16 px Streifen von jeder sichtbar.
  • Eine Karte rückt ab, wenn spätere kommen: k = clamp((scrollY - when it stuck) / 752px, 0, cards after it); scale = 1 - k * 0.05 von ihrem oberen Mittelpunkt (0,85 unter dreien), dunkle Schicht bei k * 0,12.
  • Innerhalb einer Karte sitzen Name und eine Zeile auf den Spalten 0 bis 5 und umbrechen dort, nie in das Bild hinein; der Name beginnt 48 px unter dem oberen Kartenrand, die Zeile 24 px darunter.
  • Gib jeder Karte ihren eigenen gedämpften Farbton und ihr eigenes Bild (Demo: Stein, Salbei, Ton, dann eine Tintenkarte). Keine Schatten.
  • Nachdem die letzte Karte klebt, 320 px halten, dann verlässt der Stapel gemeinsam.
  • Optionale Eröffnung: Der Titel des Abschnitts genau auf das Raster gespannt (nicht beschnitten), die erste Karte bedeckt seinen Fuß; er bewegt sich mit halbem Scroll und verblasst über die 280 px, bevor die erste Karte klebt.
  1. Kartenstapel
  • Fünf Karten in einem Stapel, 432 x 456 (sechs Spalten, zentriert) unter dem Titel; jede enthält ein Bild 8 px innen, dann Namen und eine Zeile 24 px innen, nichts weiter.
  • Abschnitt 100vh + 1920 px, fixiert: 420 px Scrollen wirft jede der ersten vier Karten, dann 240 px halten. Die letzte Karte bleibt.
  • Karte i: t = clamp((scrollY - start) / 420 - i, 0, 1). Sie fliegt zur Seite, abwechselnd: x = side * t * t * 1000px, y = t * (160px * t - 40px), rotate = side * t * 16deg um ihren unteren Mittelpunkt. Verborgen, sobald geworfen; Zurückscrollen bringt sie auf demselben Weg zurück.
  • Karten darunter sitzen 18 px tiefer und 0,05 kleiner pro Platz, dunkle Schicht 0,04 pro Platz, höchstens drei tief, rücken einen Platz auf, wenn die oberste Karte geht.
  1. Fixierte Galerie
  • 5 bis 12 Karten in einer Reihe: Demo acht, 280 breit (vier Spalten) und 24 px Abstand, jede eine weiße Karte mit Bild 8 px innen, dann Name und Künstler. Titel oben, 48 px Abstand zur Reihe; ein 2 px Balken darunter (Spur 6% schwarz, Füllung 30%).
  • Abschnitt 100vh + Überlauf (Reihenbreite minus Viewportbreite, 1520 px in der Demo); Inhalt sticky oben 0, 100vh hoch.
  • p = (scrollY - start) / Überlauf; die Reihe bewegt sich translateX(-p * Überlauf), ohne Beschleunigung: Scrollen wird seitlich. Sie lässt beim letzten Element los.
  • Halte die fixierte Distanz unter etwa drei Bildschirmen; mehr Elemente gehören in ein Raster.
  1. Coverflow
  • 5 bis 9 quadratische Cover, 432 (sechs Spalten, zentriert), unter dem Titel, Punkte darunter, kein Text auf den Covern.
  • Abschnitt 100vh + 320 px pro Schritt, fixiert. r = clamp((scrollY - start) / 320, 0, count - 1); c = floor(r) + smoothstep(fract(r)), sodass jedes Cover einen Moment in der Mitte ruht.
  • Für Cover i, d = i - c: translateX = d * 260px, rotateY = clamp(d, -1, 1) * -30deg, scale = max(0,6, 1 - |d| * 0,2), dunkle Schicht min(|d|, 3) * 0,15, das nächste oben. Perspektive 1400 px. Verstecke über 3,5 Positionen hinaus. Punkte leuchten um 1 - |i - c|.
  1. Bilderweiterung
  • Abschnitt 100vh + 1200 px, fixiert: 900 px zum Wachsen, 300 px halten.
  • Zu Beginn sind Titel und ein 584 x 352 Rahmen (Spalten 2 bis 9, 48 px darunter) zusammen zentriert, Ecken 8 px.
  • Das Bild bedeckt immer den Viewport; clip-path: inset() zeigt den Rahmen und öffnet sich zu 0 ohne Ecken, während das Bild von scale 1,2 auf 1 übergeht, sodass es als wachsend wirkt. Beide auf e = ease(p), cubic-bezier(0.45, 0, 0.25, 1). Der Titel verblasst mit doppelter Geschwindigkeit und steigt 60 px an.
  • Tiefe: Schneide die Hauptform aus dem Bild als eigene Ebene (Demo: die Hügel), setze einen Titel dahinter, dessen Fuß von der Form verdeckt wird, und eine kleine Zeile davor. Beim Öffnen beruhigt sich jedes von seiner eigenen Skalierung (Bild und Form 1,2, Titel 1,25, Zeile 1,4). Sobald vollständig, bleiben Bild und Form still, während der Titel mit 0,25 des Scrolls und die Zeile mit 0,5 aufsteigt. Etwas hinter etwas, das sich mit einer anderen Geschwindigkeit bewegt, wirkt als Perspektive.
  • Dann gleitet der nächste Abschnitt mit 28 px oberen Ecken darüber, die sich über die letzten 120 px abflachen, während das Bild auf 35 % Schwarz abdunkelt. Ein Video funktioniert gleich, stumm und in Schleife, nur während es auf dem Bildschirm ist.
  1. Bildschirme und Viewport-Höhen Die Größen der Demo sind für einen 1000 x 896 Viewport. Skaliere sie auf den Bildschirm; niemals eine feste Höhe, die ein hohes Fenster annimmt.
  • Größe fixierte Abschnitte mit 100svh, nicht 100vh: auf Handys ist 100vh die Höhe mit versteckter Symbolleiste, daher laufen Inhalte unter die Symbolleiste. Niemals dvh für fixierte Inhalte; es springt, wenn sich die Symbolleiste bewegt.
  • Messe beim Laden, bei Orientierungswechsel und wenn die Breite sich ändert. Ignoriere Höhenänderungen unter etwa 120 px (das Ein- und Ausblenden der Symbolleiste); ein erneutes Berechnen lässt Karten während des Scrollens springen.
  • Passe jeden fixierten Abschnitt in einen Bildschirm ein:
    • Gestapelte Kartenhöhe = min(720px, 100svh - sticky top - (cards - 1) * 16px - 32px); der Abstand zwischen dem Kleben der Karten folgt dem.
    • Deck: Titel + 48px + Karte passen in 100svh - 64px; das Bild gibt zuerst Höhe auf.
    • Galeriekartenhöhe = min(520px, 100svh - title - 48px - 96px).
    • CovernGröße = min(432px, 48svh, 70vw); der Spread skaliert damit.
    • Bildrahmen = min(584px, 100vw - 2 * margin) breit im Verhältnis 5:3; die Insets folgen daraus.
  • Skaliere jede Scroll-Distanz um clamp(0.7, viewport height / 896, 1.2).
  • Unter 560 px Höhe (Handy im Querformat, kleines Fenster): nichts fixiert: Listen, horizontale Reihen, ein vollbreites Bild.
  • Schrift folgt der Breite: Abschnittstitel clamp(36px, 7vw, 64px), Kartennamen clamp(28px, 5vw, 36px).
  • Vollflächige Momente respektieren env(safe-area-inset-*). Subtrahiere einen fixierten Header von jeder Passung und jedem sticky top.

Layout und Schrift (alle Abschnitte)

  • Lege alles zuerst auf das Spaltenraster. Jedes Textfeld ist so breit wie seine Spalten, damit lange Namen umbrechen, statt in ein Bild zu laufen.
  • Was ein Titel einführt, beginnt 48 px darunter; in einem fixierten Abschnitt sind Titel und Inhalt gemeinsam im Viewport zentriert; zentrierte Titel über zentriertem Inhalt, linksbündig über linksbündigem Inhalt.
  • Halte die Karten im Fokus: außerhalb pro Abschnitt ein kurzer Titel, keine Tags, Nebeninhalte, Zähler oder Bildunterschriften; innerhalb eine Struktur: Bild, Name, eine Zeile.
  • Zwei Schriftarten in vier Größen (Demo: Newsreader 64 und 36, Geist 18 und 16). Ziehe große Serifen-Zeilen am Seitenüberhang des ersten Buchstabens links aus; über etwa 100 px verwende eine text optical size, damit Serifen stumpf bleiben.
  • Keine Trennlinien außer zwischen Listenzeilen, keine Schlagschatten, die Akzentfarbe höchstens einmal. Ein Bildstil pro Gruppe, und niemals dasselbe Bild zweimal auf einer Seite.
  • Ankerlinks landen am Anfang eines Abschnitts. Tastaturscrollen funktioniert wie das Rad; Elemente in fixierten Abschnitten bleiben mit Tab erreichbar.

Prüfen

  • Jeder Abschnitt langsam, schnell und rückwärts: keine Sprünge, kein Flackern, keine Lücken.
  • Viewports 375x667, 390x844, 430x932 (Symbolleiste ein- und ausgeblendet), 844x390, 768x1024, 1280x720, 1440x900, 1920x1080 und ein 600 px hohes Desktop-Fenster: nichts abgeschnitten, keine Karte höher als der Bildschirm, nichts unter einer Symbolleiste oder einem fixierten Header.
  • 200% Textzoom, reduzierte Bewegung, Tastatur, Hell und Dunkel; volle Bildrate auf einem Mittelklasse-Handy; die gebauten Werte entsprechen meiner Tabelle.
  1. Wie man es baut Prüfe dies gegen meinen Stack und meine Versionen.
  • Web: position: sticky zum Fixieren; scrollgesteuerte Animationen (animation-timeline: view() oder eine benannte Timeline, animation-range). Wo nicht unterstützt oder wo Keyframes nicht ausreichen (die bereichsspezifischen Bereiche des Decks, die Ruheschritte des Coverflows), ein passiver Scroll-Listener liest einmal pro Frame scrollY, berechnet das p jedes Abschnitts aus bei Größenänderung gemessenen Offsets und schreibt es als benutzerdefinierte Eigenschaft nur auf diesen Abschnitt.
  • Wenn das Projekt bereits GSAP ScrollTrigger (scrub, pin) oder Motion (useScroll, useTransform) verwendet, verwende es mit diesen Werten; füge niemals nur für dies eine hinzu.
  • iOS (SwiftUI): .scrollTransition oder .visualEffect auf dem Frame der Ansicht in der Scroll-Ansicht (onScrollGeometryChange auf iOS 18), scaleEffect, rotation3DEffect, offset, clipShape; Galerie und Coverflow als horizontale ScrollViews mit .scrollTargetBehavior(.viewAligned).
  • Android (Compose): LazyListState für p, Modifier.graphicsLayer für scale, rotationY, alpha, translation und clip; LazyRow mit Snapping oder HorizontalPager.
  • Flutter: CustomScrollView mit Slivers, ein ScrollController für p, Transform und ClipRRect; PageView für Galerie und Coverflow.
  1. Voreinstellungen
  • Länge: Kurz (Stapel 560px, Deck 300px, Galerie 1,25px seitlich pro 1px, Cover-Schritt 240px, Bild 600 + 200px), Standard (752, 420, 1:1, 320, 900 + 300, empfohlen), Lang (900, 560, 1:1 mit 200px an jedem Ende gehalten, 420, 1200 + 400).
  • Stapeltiefe: Flach (scale 0,03, shade 0,08 pro Karte), Standard (0,05, 0,12), Tief (0,07, 0,16, 24px Streifen).
  • Deck-Wurf: Sanft (8deg, 700px, immer rechts), Standard (16deg, 1000px, abwechselnd), Lebhaft (24deg, 1200px, 60px Lift).
  • Coverflow: Flach (kein Drehen, Seiten bei 0,85), Standard (30deg, 0,8), Tief (45deg, 0,75, 180px Abstand).
  • Bildstart: Klein (420 x 280), Standard (584 x 352), Breites Band (volle Breite, 340 hoch).

Individual skills in this repo

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

Verwandte Skills