stripe-youtube

Was macht stripe-youtube?

Die Stripe-Edition von Adnaans Longform-Skill (adnaan-youtube): Dieselbe Pipeline und das v7-Designsystem auf der 16:9-Leinwand, wobei jede Farbe aus einer Brand-Datei stammt. Die Standardmarke ist Stripe (brand/stripe.json, erstellt aus Stripes öffentlicher Brand-Seite: blurple #533AFD Akzent, slate #061B31 Scheiben und Tinte, cool paper #EEF1F6, weiße Karten, strawberry nur für Daten). Ein anderes Unternehmen = eine andere Brand-Datei ($Y/brand.py init --edit-dir edit --brand acme.json); nichts anderes ändert sich. Bevor du anfängst, sieh dir assets/style/stripe_youtube_sheet.jpg an (echte Frames des ersten damit erstellten Videos) und überfliege examples/stripe-v1/ (dessen Beat-Tabelle und Szenen) und examples/yt-01-v7/. Die künstlerische Ausrichtung ist verbindlich und befindet sich in references/style.md; Kapitel, Fenster und Kadenz in references/planning.md; die Beschreibung in references/description.md. (Der ältere Greg Light/Dark-Marker-Look wird nur auf Anfrage beibehalten.)

Wie die Marke integriert wird: edit/brand/brand.json → $Y/brand.py schreibt brand.css (es zeigt die Tokens der Laufzeit um) → board.py verlinkt es nach v7yt.css in jeder Szene, die es vorbereitet, und talkcaps.py macht dasselbe für die Untertitel-Overlays; die Laufzeit-Tweens (V.mintTo / V.charcoalTo) lesen ebenfalls die Tokens, und die compose-Platten folgen der Datei. Szenen geben niemals einen Hex-Code ein. Logos, die in der Brand-Datei genannt werden, werden aus dem offiziellen Kit in edit/logos/ geholt (niemals neu gezeichnet).

Dieser Skill ist das Longform-Pendant zu adnaan-reel und verwendet dessen Hilfsprogramme (Transkription, Schnitt, Überprüfung, Seitenerfassungen, Logo-/Foto-/Icon-Downloader, die Render-/Loudness-Pipeline, das SFX-Kit, Kopfhaltung). Er muss in ~/.claude/skills/adnaan-reel installiert sein. Führe jedes Hilfsprogramm mit der Umgebung dieses Projekts aus: uv run --project ~/.claude/skills/adnaan-reel python <helper> … — R=~/.claude/skills/adnaan-reel/helpers, Y=~/.claude/skills/stripe-youtube/helpers unten.

Wie Longform erstellt wird (warum es sich von Reels unterscheidet)

Ein Reel macht jeden Beat zu einer vollwertigen HyperFrames-Szene. Ein langes Video kann das nicht (stundenlanges Rendern und ermüdend anzusehen). Hier:

1. Der Schnitt ($R/render.py --base-only) → base.mp4: seine Kamera, geschnitten, 1920x1080, mit der Stimme (in einem sample-genauen Durchlauf erstellt — siehe Anti-Patterns, Lippen-Sync-Drift), dann $Y/lookdowns.py hält ein Bild über Nach-unten-Schauen.
2. Gestaltete Momente sind HyperFrames-Szenen ($Y/board.py): Leinwand, Karte, Board, Beleg (undurchsichtig, 3–10 s) und Callout-Overlays — typischerweise 25–45 pro Video, parallel von Agenten erstellt. Talk-Untertitel werden als generierte Overlays ($Y/talkcaps.py) erstellt, eines pro Vollformat-Talk-Fenster.
3. Alles andere wird composiert ($Y/compose.py): Talk = Basis-Vollformat + Untertitel; Bildschirm = Board-Platte + seine Bildschirmaufnahme (mit denselben Bereichen geschnitten, gezoomt durch $Y/zoomplan.py) + die Sprecherkarte; Szenenfenster = das Rendering + die Karte; Overlays oben drauf; SFX + der levelige Musikteppich; −14 LUFS. ~40 s Compositing pro Minute Video.

Prinzipien

1. Das Board ist die Basis, er ist auf der Karte. ~70–85 % der Laufzeit sind ein Board-Layout mit seiner einfachen Kamera in der Karte (fester Punkt, bewegt sich nur bei einem Schnitt, Akzentring); Vollformat-Talk ist die Interpunktion (Einleitung, Meinungen, Geschichten, CTA). Standardmäßig keine Matte – er mag die einfache Karte.
2. Ein Look, eine Brand-Datei. Papier + Raster + starke Vignette, die Primärfarbe der Marke als EIN Akzent (Stripe blurple), ihre tiefe Farbe für Scheiben mit weißen Phosphor-Glyphen und Tinte (Stripe slate), flache weiße Karten, saubere Vektor-Striche, Inter Tight / Inter (Stripes eigene Schriftart ist nicht öffentlich). Die Datenfarbe (strawberry #E8435A) nur für Zahlen. Kein Marker, kein Caveat, keine Pastelltöne, kein Hex-Code in einer Szene.
3. Talk ist untertitelt, jedes Wort. Vollformat-Talk-Fenster tragen vollflächige kinetische Untertitel (weiß, ein Heldenwort pro Phrase im hellen Akzent der Marke, linke Spalte auf einem ruhigen Teil seines Hintergrunds). Board-Fenster tragen die Wörter im Design. Die SRT wird dennoch geliefert. Wörter auf dem Bildschirm sind Wörter, die er sagt.
4. Zeig das Echte. Jede Seite, jedes Papier, jeder Beitrag, jede Studie, die er nennt, erscheint echt (lesbarer Streifen in einer weißen Karte, Textmarker in Markenfarbe auf der gesprochenen Phrase); jedes Werkzeug/Unternehmen erhält sein offizielles Logo; Personen erhalten echte Fotos. Erfinde niemals Zahlen, Zitate, Bildschirme.
5. Bildschirme sind der Walkthrough. Seine Cap-Aufnahme in einer Fensterkarte, gezoomt auf das, worauf er klickt (seine Cap-Zooms gewinnen, dann Klick-Cluster, dann manuelle Ziele), Callouts werden gezeichnet, nachdem der Zoom landet. Warten wird geschnitten, niemals beschleunigt.
6. Zwei Genehmigungen, dann baue alles. Kapitelgliederung → Beat-Tabelle → Pilot (2–3 Szenen + die Untertitel im Look) → alle Momente parallel bauen → compositen → Selbstprüfung → ausliefern. Autopilot („mach einfach“) überspringt die Wartezeiten.
7. Niemals ein totes Board. Jeder gestaltete Moment hat ein Heldenobjekt, das den Satz darstellt + 1–3 Mikro-Animationen; die Kamera wandert; Frame 0 jeder Szene zeigt bereits ihre Überschrift oder ihr Hauptobjekt.
8. Sound unterstützt die Stimme. Nur strukturelle SFX (~1 pro 30–60 s, leises & warmes v6-Kit), ein ruhiger abgesenkter Musikteppich ~5 dB unter seiner Stimme (er würde einen leiseren nicht hören), Stimme oben drauf, −14 LUFS.
9. Überprüfen, bevor gezeigt wird. Framegenauigkeit, Lippen-Sync bei jedem Schnitt geprüft, jede Fenstergrenze auf einem Blatt, Untertitel gegen den Schnitt gelesen, Lautstärke gemessen. Er sollte nie derjenige sein, der ein Sync- oder Level-Problem findet.

Harte Regeln

1. Gliederung genehmigt, dann Beat-Tabelle genehmigt, bevor eine Szene gebaut wird (außer Autopilot).
2. Die Schnittregeln von adnaan-reel gelten unverändert: Wortgrenzen-Schnitte, jeder Füllerschnitt und jede Verbindung überprüft mit $R/verify_cuts.py (lies die ⚠ TAIL/HEAD-Flags), niemals eine Test-EDL in edit/ rendern, 30 ms Überblendungen.
3. Starte von seinen Cap-Trims (source/cap.json "trims"). Dann entferne Wiederholungen: Behalte den LETZTEN vollständigen Take jeder Zeile, nähe niemals eine Zeile aus zwei Versuchen zusammen, verwerfe alles, was er laut ablehnt („nein“, „nochmal“, „das streichen“) und Pannen; überprüfe das Ende der Sitzung auf einen neu aufgenommenen Haken. Finde Wiederholungen, indem du jeden behaltenen Bereich einzeln transkribierst und dann jede Verbindung mit seinen Nachbarn – Whisper über dem langen Schnitt fügt zwei Takes derselben Zeile zu einem zusammen.
4. Keine toten Momente: trimme jeden Bereich auf seine Sprache (Rauschen + 7 dB, 0,07 s vor / 0,09 s nach) und teile interne Pausen ≥ 0,22 s ($R/audio_env.py tighten --margin 7 --min-gap 0.22). Er hat zweimal darum gebeten, „alle Pausen“ zu schneiden – die 0,3–0,9 s Luft, die der erste Durchlauf behalten hat, wurden als Pausen gelesen.
5. Bildschirme werden mit den GLEICHEN Bereichen geschnitten wie die Kamera (compose.py macht das aus timeline.json).
6. Szenen: exakt ihre Framerate (board.py stellt sie ein, board.py check überprüft); die Laufzeit (board.css/js, v7yt.css/js) ist installiert, niemals pro Szene bearbeitet; eine globale Look-Änderung wird EINMAL in templates/runtime/ → board.py runtime vorgenommen. Kartenzone klar; Frame 0 nicht leer.
7. Rendere nur durch board.py render (auch Agenten, --only <id>): es wählt ProRes 4444 .mov für Overlays (ein h264 .mov ist undurchsichtig – die Talk-Fenster zeigten Papier statt seiner) und teilt Render-Slots maschinenweit. Niemals pkill von Renderings – ein pkill eines Agenten hat die Renderings aller anderen Agenten beendet.
8. Callout-Positionen kommen von compose.py where <out_t> <sx> <sy>, niemals geraten.
9. Ein Unter-Agent pro Szene (oder pro Familien von Szenen, die ein Objekt teilen, z. B. die Kette), alle in einer Nachricht gestartet; überprüfe die Stills jeder Szene, sobald sie eintreffen, sende Korrekturen mit SendMessage an denselben Agenten. Ein gemeinsames Objekt hat EINEN Besitzer, der das gemeinsame Modul + Notizen schreibt; andere Agenten kopieren, forken es nie. Vertraue Dateizeitstempeln, nicht Berichten.
10. Downloads durch $R/fetch.py, Aufnahmen durch $R/capture.py (protokolliert in credits.md); alle Ausgaben in <project>/edit/; schreibe niemals während einer Bearbeitung in ein Skill-Verzeichnis.
11. Spiegelprüfung der Kamera vor dem Schneiden (zoome auf jeden Druck auf seiner Kleidung/Hintergrund in einem hochauflösenden Standbild).
12. In Shell-Schleifen erhält ffmpeg -nostdin (es frisst sonst die Standardeingabe der Schleife).

Hilfsprogramme

Helper	Was es tut
$Y/cap.py find / info <p.cap> / ingest <p.cap> --edit-dir E	Cap-Projekte (neueste zuerst) → source/cam.mov, source/screen.mp4, source/cap.json (Klicks, Bewegungen, Trims, Zooms)
$R/transcribe.py source/cam.mov --edit-dir E --vocab "…"	Wort-Level-Transkript → transcripts/cam.json (zwischengespeichert)
$R/pack_transcripts.py · $R/audio_env.py · $R/verify_cuts.py · $R/timeline_view.py	Lies den Take, straffe ihn, überprüfe jede Verbindung (adnaan-reel)
$R/headpose.py source/cam.mov --start 0 --end <s> > E/headpose_report.txt	Kopfneigung über den Take → Blick-nach-unten-Spannen
$R/render.py edl.json -o base.mp4 --base-only	Der Schnitt → base.mp4 + timeline.json (sample-genaue Stimme)
$Y/lookdowns.py --edit-dir E	Hält ein Bild der Kamera über Blick-nach-unten-Spannen am Anfang/Ende von Zeilen; führe nach jedem Basis-Rendering erneut aus
$Y/sync_check.py --edit-dir E [--final final.mp4]	Lippen-Sync pro Segment (Bild vs. Stimme vs. Quelle) und Final vs. Basis; beende mit 1, wenn falsch
$R/capture.py · $R/fetch.py logo/photo/icon/url/credits	Lesbare Seitenstreifen, offizielle Logos, echte Fotos, Phosphor-Icons, Downloads, credits.md
$Y/board.py prepare/runtime/render/check --edit-dir E [--only ids]	Szenenprojekte aus animations/scenes.json (v7-Laufzeit + Icons + Starter + Assets + TASK.md); slot-begrenztes Rendern; exakter Frame-/Alpha-Check
$Y/talkcaps.py --edit-dir E [--dry-run]	Vollflächige Talk-Untertitel: ein generiertes cNN_talk-Overlay pro Talk-Fenster (führe nach jeder Schnitt-/Szenenänderung erneut aus)
$Y/compose.py plan / where <t> <sx> <sy> / render -o final.mp4 [--preview] [--only-window N] / sheet <video>	Fenstertabelle; Callout-Koordinaten; der Compositing (Fenster + Karte + Overlays + SFX + leveliger Musik + −14 LUFS); Grenzblatt
$Y/zoomplan.py	Die Zoomkamera (Bibliothek)
$Y/deliver.py srt / chapters / stills <video> t…	deliver/captions.srt, deliver/chapters.txt (für YouTube validiert), Thumbnail-Stills
$Y/brand.py init / css / apply --edit-dir E [--brand x.json]	Die Brand-Datei → brand.css → jede Szene (board.py und talkcaps.py rufen es auf; apply installiert von Hand neu)
$Y/review.py --edit-dir E <ids>	Szenen-Review-Blatt (5 Frames, Kartenbox umrandet) → verify/review/<id>.jpg
$Y/inserts.py clip / splice / shift --edit-dir E	Clips mit eigenem Audio auf einem Brand-Board → frame-genau in den Compositing gespleißt → SRT + Kapitel verschoben

Starter (templates/scenes/): canvas, map, board, proof (undurchsichtig), callout_overlay, talk_overlay (transparent) und talk_captions (talkcaps.py's Vorlage). Laufzeit-Header (board.js, v7yt.js) listen jedes Primitiv auf. Referenzszenen: examples/stripe-v1/ (das Stripe-Video: Beat-Tabelle, Szenenliste, Ketten- + Markenkarten- + Seiten-Module) und examples/yt-01-v7/ (Kettenkarte + gemeinsames Modul, Datenbalken, Belegseite, Board-Fluss, Untertitel).

Layout

<project>/
└── edit/
    ├── project.md                 Sitzungsspeicher
    ├── source/ (cam.mov, screen.mp4, cap.json)        transcripts/ (cam.json roh, CAM.json korrigiert)
    ├── edl.json, base.mp4 (+ base_unfrozen.mp4), timeline.json, headpose_report.txt, layout.json
    ├── brand/ (brand.json, brand.css)   captures/ logos/ photos/ icons/ downloads/ music/ inserts/
    ├── animations/ (scenes.json, <id>/{hf/, TASK.md, render.mp4|mov, beats.json, qa/}, cNN_talk/ generiert)
    ├── compose/ (plates, screen_cut.mp4, windows/)   verify/
    └── final.mp4, deliver/ (captions.srt, chapters.txt, description.txt, thumb_*.png), credits.md

Der Prozess

1. Fortsetzen. Wenn edit/project.md existiert, fasse die letzte Sitzung in einer Zeile zusammen und frage, ob fortgefahren werden soll.
2. Eingabe. Wenn er keinen Pfad angibt: $Y/cap.py find und bestätige die Aufnahme. Nicht Cap: Verlinke die Kameradatei als source/cam.mov (Bildschirmaufnahmen als source/screen.mp4 auf einer Uhr; ein minimales cap.json). Sammle das Skript, Links und alles, was er gezeigt haben möchte. Marke: $Y/brand.py init --edit-dir edit (Stripe; --brand x.json für ein anderes Unternehmen), dann hole die Logos, die die Brand-Datei nennt, aus ihrem offiziellen Kit in edit/logos/. Teste eine Szene in der Marke, bevor du den Rest baust.
3. Ingest + Lesen. ffprobe; ein hochauflösendes Standbild für die Spiegelprüfung; $R/transcribe.py source/cam.mov --edit-dir edit --vocab "<jeder Name aus Skript/Links>"; $R/pack_transcripts.py; $R/headpose.py über den gesamten Take → headpose_report.txt (er kann später nicht-neu aufgenommene Zeilen mit Blick nach unten schneller erkennen).
4. Schnitt – Basis. $R/render.py edl.json -o edit/base.mp4 --base-only → edit/base.mp4 + edit/timeline.json. Dann $Y/lookdowns.py --edit-dir edit. $Y/sync_check.py --edit-dir edit – wenn exit 1 (Lippen falsch), korrigiere und rendere das Basisvideo neu.
5. Kapitel gliedern & genehmigen lassen. Schreibe eine Gliederung als edit/project.md, zeige sie ihm und warte auf seine Antwort (oder Autopilot).
6. Beat-Tabelle & genehmigen lassen. Lade die edit/animations/scenes.json mit Beats (Titel, Typ, Dauer) und zeige sie ihm. Keine Szene vorher bauen.
7. Pilot. Baue 2–3 repräsentative Szenen + ein Talk-Untertitel-Fenster, lasse sie ihn überprüfen und frage („gefällt dir der Look? Dann baue ich alle“). Eine Korrekturrunde ist normal; wenn er eine globale Look-Änderung möchte, ändere sie einmal in templates/runtime/ und führe board.py runtime aus.
8. Alle Momente parallel bauen. board.py prepare für die Szenenliste → spawnen für jeden id einen Agenten mit board.py render --only <id> → sobald die Stills eintreffen (überwache animations/<id>/qa/), ein Review mit $Y/review.py und sende Korrekturen. talkcaps.py --edit-dir edit im Hintergrund.
9. Compositen. $Y/compose.py render -o edit/final.mp4 → final.mp4. Wenn nötig, verwende --only-window N für iterative Korrekturen, oder zeige --preview (niedrigere Auflösung + Wasserzeichen), um den Rhythmus zu überprüfen, bevorarth das vollständige Rendering gestartet wird.
10. Ausliefern. $Y/deliver.py srt → deliver/captions.srt (validierte YouTube-Untertitel, mit Marken-Highlights); $Y/deliver.py chapters → deliver/chapters.txt (YouTube-Kapitel, validierte); $Y/deliver.py stills edit/final.mp4 <t1> <t2> … → deliver/thumb_*.png; schreibe deliver/description.txt (siehe references/description.md); $Y/sync_check.py --edit-dir edit --final edit/final.mp4; wenn final ≠ 0, render das Basisfinale neu und wiederhole. ($R/check_loudness.py edit/final.mp4 sollte ≈ −14 LUFS anzeigen; wenn abweichend, passe Musikpegel oder Kompressor an und rendere neu.)
11. Übergeben. Zeige edit/deliver/ und edit/final.mp4, frage „soll ich es nach YouTube hochladen? (y/n)“. Bei „y“: Upload-Skript (nicht Teil dieses Skills; sage „verwende dein normales Upload-Tool“).

Anti-Patterns

1. Lippen-Sync-Drift – Das Schneiden von Kameraframes und deren Ersetzung durch Overlays muss im Compositing-Kanal erfolgen, nicht durch vorzeitiges Muxen. Der render.py --base-only Schritt rendert Audio UND Video in einer einzigen ffmpeg-Pipeline (kein separates Audio-Manipulieren), damit die sample-genaue Karte nicht mit Bild für Bild driftet. Korrigierte Lippen nach einem Cut sind nicht rückgängig zu machen.
2. Neues Rendern der gesamten base.mp4 für einen späteren Sound-Fix – Ändere stattdessen die compose.py-Audio-Spur (Audio nur rendern mit derselben Timeline).
3. Full-HD (1920×1080) annehmen, wenn die Kamera 4K ist – ffprobe es und passe board.py-Parameter an.
4. Cap-Gesten ignorieren – cap.json enthält Mausbewegungen und -klicks. zoomplan.py priorisiert Cap-Zooms gegenüber manuellen.
5. Download von Schriftarten aus unsicheren Quellen – Verwende nur $R/fetch.py (offizielle Schriftarten-Kits).
6. Kein globaler Look, bevor Szenen gebaut werden – Ohne einen brand.css-Test-zu-Ende-Test haben alle Szenen den Standard-Stripe-Look, und eine späte Änderung erfordert ein erneutes Rendern aller. Führe $Y/brand.py apply aus und teste eine Szene.
7. Pkill eines Renderings – Ein Agent, der pkill -f ffmpeg ausführt, tötet die Renderings aller anderen Agenten. Verwende board.py render (das eigene Slots respektiert) und beende Agenten sauber (SIGTERM).
8. Das Base-Video ohne Voice-Over-Bereinigung rendern – Der Cut muss zuerst alle Hörfehler (Klicken, Atmen, Zungenklick) entfernen. $R/audio_env.py mit --denoise behandelt Klicken. Führe nach dem Cut und vor dem Base-Rendering eine Hörprobe durch.
9. Fensterpositionen auf dem Bildschirm schätzen – compose.py where verwendet die Timeline + Bildschirm-Metadaten, um exakte Pixelkoordinaten zu erhalten. Schaue niemals auf das Board und rate „etwa 30 % von links und 50 % von oben“. Frage compose.py where <t>.
10. Cap-Projekt ohne Cap.json-Aufnahme – Wenn er ein Cap-Projekt bereitstellt, aber die Mausbewegungen fehlen, frage nach einem cap.json mit cap.py find (neueste Version hat Zeitleiste + Klicks).
11. Nicht komprimiertes Audio liefern – YouTube erwartet AAC 192 kbps; compose.py wählt den Codec automatisch aus. Gib diese Einstellung nicht von Hand vor.

Verwandte Skills

• adnaan-reel – Vertikale Kurzform (Reels/TikTok/Shorts) im selben Designsystem.
• adnaan-youtube – Die generische (nicht-Stripe) Longform-Version – normalerweise mit manuellem Hex-Code pro Szene, aber teilt diese Pipeline.
• adnaan-brand – Das Brand-Kit (generiert brand.json aus einem Unternehmen + URL).

Dieser Skill importiert aus adnaan-reel; siehe dortige Dokumentation für Transkription, Schnitt, headpose, Audio-Umgebung und Lautstärke-Hilfsprogramme.