Am 25. Oktober sind wir zu elft in der Halle des Rennring in Magdeburg Kart gefahren. Fünf Minuten Quali, zwanzig Minuten Rennen. Ich stand auf der Pole und habe alle 26 Runden geführt, das musste also offensichtlich auf Video.

Fünf Kameras liefen mit: meine DJI am Kart, das iPhone meiner Freundin auf dem Balkon, ein paar Handys von Bekannten, eine GoPro und eine Insta360, die jemand mitgebracht hatte. 22 GB, aufgenommen, wie jeder gerade Lust hatte.

Ein Vlog sollte es nicht werden. Ich wollte das Echte: eine F1-TV-Übertragung, der Timing-Tower immer im Bild, meine Onboard als Bild-im-Bild, Replays, Meldungen der Rennleitung, Boxenfunk und eine Kommentatorenbox. Ich schneide nicht beruflich Videos, und mein Schnittprogramm ist das kostenlose DaVinci Resolve, das sich nicht skripten lässt. Also war der Plan einfach: Alles, was Code sein kann, wird Code. Claude (Claude Code) schreibt den Großteil davon. Ich entscheide, logge und schaue.

Drei Wochen später hatte ich eine 23-minütige Übertragung in 1080p aus fünf Teilen, mit 239 Kommentatorenzeilen und 8 echten Funksprüchen. In diesem Post geht es nicht um das Rennen. Es geht darum, wie die Arbeit organisiert war, denn das meiste davon passt auf jedes Schnittprojekt, das man einer KI geben will.

Vor dem Code: ein Briefing, das überlebt

Das ganze Projekt lief in einer einzigen langen Claude-Code-Session, die achtmal komprimiert wurde (zusammengefasst, um Kontext freizumachen). Zusammengehalten hat das Ganze nie der Chat, sondern eine Datei: CLAUDE.md im Repo. Claude liest sie am Anfang jeder Session und aktualisiert sie jedes Mal, wenn etwas entschieden wird.

Drei Teile davon haben die meiste Arbeit gemacht.

Grundprinzipien. Sie standen schon vor der ersten Zeile des Loggers fest, und jeder spätere Streit wurde mit ihnen entschieden:

  1. Niemand schaut das Material zweimal. Ein einziger Durchgang beim Loggen muss alles erfassen, was Schnitt, Synchronisation und Skript brauchen. Deshalb speichert das Tool jeden Tastendruck sofort und muss beim ersten Mal funktionieren.
  2. Das Log ist die Geschichte. Beim Loggen entstehen die Ereigniskarte und die Notizen zum Rennverlauf, und aus den Notizen wird das Kommentatorenskript.
  3. Der Speicher auf dem Mac ist knapp. Native Tools, keine herumliegenden Abhängigkeitsbäume, Caches werden gelöscht, Virtualenvs sind Wegwerfware.

Fakten, die nicht falsch sein dürfen. Billig aufzuschreiben, teuer, wenn sie im Render falsch sind. Mein Tower-Code ist IWA, aber der Kommentar nennt mich Mik und spricht IWA als „Iewa" aus. FABs Name ist deutsch und muss auch so ausgesprochen werden. Ein Fahrer läuft unter einem Spitznamen, der nicht im Protokoll steht. 0:00 im Rennen ist die Null der Zeitnahme, nicht das Erlöschen der Ampel, das fünf Sekunden früher ist. Blaue Flaggen kannte an der Strecke keiner, also ist eine Überrundung einfach ein Kampf um die Position. Die Karts sind nach F1-Teams eingefärbt, aber die Teams sind nur Farben: Kein Markenname wird je gesagt oder gezeigt.

Ein Gedächtnis für Regeln, die schon mal gebissen haben. Wenn ich dieselbe Sache zweimal korrigieren musste, wurde daraus eine kurze Notiz, die Claude außerhalb des Repos ablegt. „Ein Überholmanöver wird als Reihenfolge danach geloggt, ein Zweikampf als Reihenfolge zu Beginn." „Verteil die Replays, gegen Ende passiert wenig." „Auf meiner Seite: PR aufmachen und mir den Preview-Link schicken, mergen tue ich." Am Ende waren es acht.

Den Unterschied merkt man. Als Briefing und Notizen einmal da waren, hat eine Komprimierung mitten in der Render-Planung nichts gekostet. Vorher hätte ich die Rennuhr jedes Mal neu erklärt.

1. Das Problem definieren, dann das Tool dafür bauen

Das eigentliche Problem mit diesem Material war nicht der Schnitt. Es war zu wissen, was wo ist. Fünf Kameras mit fünf Uhren, Karts, die vom Balkon alle gleich aussehen, und ein Zeitnahmeprotokoll, das jede Zieldurchfahrt auf die Millisekunde kennt und nichts von dem, was dazwischen passiert ist.

Erst indexieren

Bevor überhaupt jemand etwas angeschaut hat, ist Claude jede Datei durchgegangen: Auflösung, Bildrate, Aufnahmezeit und wie weit man der Uhr jeder Kamera trauen kann. Die Handys waren übers Netz synchronisiert. Die GoPro hatte echte UTC. Die Insta360-Exporte hatten gar keine Uhr, nur den Zeitpunkt des Exports. Meine DJI ging rund 25 Minuten nach. Claude hat sie an dem einen Punkt festgemacht, den ich sicher wusste (die Ampel erlischt in Clip 0032 zwischen 4:55 und 4:56), und ihre 6:07-Stücke über die Dauer verkettet.

Die Indexierung hat außerdem eine Übersichtsseite geschrieben: eine Zeitleiste, welche Kamera welche Minuten des Rennens abdeckt, Kontaktabzüge und einen Plan fürs Loggen.

Der Logger

Dann das Tool selbst. FFTV Logger ist eine native macOS-App in SwiftUI ohne Abhängigkeiten, gebaut mit swiftc aus einem Shellskript. Man öffnet einen Ordner, alle Clips stehen nach Kamerauhr sortiert da, und für alles gibt es eine Taste:

  • S Zieldurchfahrt, O Überholmanöver, B Zweikampf, I Zwischenfall, F Fall für die Stewards, V VSC, R Reaktion, M Meme-Moment, C Kommentar.
  • G Abstandskette: Auf einer statischen Kamera markiert man, wie die Nase jedes Karts dieselbe Stelle passiert, und bekommt Abstände auf das Bild genau (1/30 s). Das ist besser als Raten.
  • Q/E drehen das Bild ab diesem Frame, weil die Halterung meiner DJI verrutscht war und ich nicht das halbe Rennen mit schiefem Kopf schauen wollte.
  • T markiert die Karts auf einem pausierten Bild, für die Namensschilder später.

Jede Taste pausiert das Video und öffnet ein Feld unter dem Bild, nicht darüber, denn genau am eingefrorenen Bild sieht man, wer wo ist. Darin: Fahrer-Chips in der aktuellen Reihenfolge, eine Bewertung von 1 bis 3, eine Markierung für den Highlight-Schnitt und ein Kommentar.

Gelohnt hat sich das Ganze wegen der rechten Spalte. Der Logger kennt das Protokoll, also zeigt er einen Live-Tower zur Rennzeit des Clips, in der echten Reihenfolge: die Reihenfolge laut Protokoll plus meine geloggten Überholmanöver, die die Linie noch nicht gesehen hat. Er zeigt, wer in den nächsten Sekunden über die Linie fährt. Er sagt aus den Rundenzeiten voraus, was im Clip zu erwarten ist (eine langsame Runde, ein Positionswechsel). Und wenn die nächsten Durchfahrten einem geloggten Manöver widersprechen, sagt er das, und fast immer hieß das, dass ich zwei Karts verwechselt hatte.

Eine Kamera zu synchronisieren ist eine Taste. S auf einer Zieldurchfahrt, „FAB Runde 7" aus den Vorschlägen wählen, und der ganze Kameraordner ist über die Uhrdifferenzen zwischen seinen Clips synchronisiert.

Die Daten widersprechen

Protokoll und meine Augen waren sich zweimal uneinig, und beide Male war es wichtig.

Beim ersten Mal habe ich geloggt, wie ich SAN bei 3:40 überrunde, und laut Protokoll war zu der Zeit niemand in der Nähe. Es stellte sich heraus, dass das Protokoll die erste Runde jedes Karts ab seiner eigenen ersten Zieldurchfahrt misst, nicht ab dem Start. Claude hat aus meinen Abstandsketten und Durchfahrten für jedes Kart eine Startverzögerung bestimmt: von 0,75 s bei FAB bis 6,2 s bei SAN ganz hinten in der Startaufstellung. Danach passten meine Durchfahrten auf 0,4 s zu den Daten statt auf 6.

Beim zweiten Mal hatte das Protokoll BUR in den Runden 7 bis 10 vor FAB, und das stimmte nicht. Die Regel wurde: Wo mein Log dem Protokoll widerspricht, gewinnt das Log. Im Schnitt gibt es dafür einen eigenen Abschnitt.

Das Loggen hat ein paar Abende gedauert: 1.384 Ereignisse, davon 1.164 Keyframes für Namensschilder. Und der Logger wurde gleich auch zum Review-Tool. Wenn ein Teil gerendert war, habe ich den Render-Ordner in derselben App geöffnet und Kommentare mit Zeitstempel hinterlassen. Claude hat sie direkt aus dem Log gelesen: zwanzig Notizen zu Teil eins, acht zu Teil zwei, nichts abgetippt.

2. Grafik als Code

Der Look ist F1 TV eins zu eins, mit einem eigenen Zeichen: EM, ein roter Kasten mit den Buchstaben, beides nach vorne geneigt. Titillium Web für Text, JetBrains Mono für Zahlen. Lila nur für die schnellste Runde, Gelb für VSC, Bernstein für eine Untersuchung, Rot für die Marke und Strafen.

Jede Grafik ist eine HTML/CSS-Komponente: der Tower, Banner, Karten für Zweikämpfe und Überholmanöver, Rennleitung, Boxenfunk, schnellste Runde, Bauchbinden, Stings, die Startaufstellung, das Ergebnis. 21 Stück, in rund tausend Zeilen. Der Trick ist, wie sie gerendert werden:

  • Eine Seite lädt die Komponente, ein Aufruf von seek(ms) friert alle CSS-Animationen auf diesem Moment ein, und Playwright macht einen Screenshot mit transparentem Hintergrund.
  • Die Frames gehen als ProRes 4444 mit Alpha in ffmpeg: ein volles 1920×1080-Bild, das ohne jede Positionierung über dem Bild liegt.
  • Jede Grafik fährt in etwa einer halben Sekunde rein und in etwa einer Drittelsekunde raus. Der Sting deckt das Bild von 0,45 s bis 0,45 s vor seinem Ende ab, also kann ein Schnitt irgendwo dazwischen liegen.
  • Eine einzige Datendatei, drivers.json, speist sie alle: Codes, Startnummern, Farben, Ergebnis. Deshalb lässt sich das fürs nächste Rennen wiederverwenden.

Der Tower ist die einzige Grafik, die sich in jedem Frame ändert. Er ist ein Job mit Eigenschaften pro Frame, berechnet aus der Rennuhr (Positionen, Abstände, Intervall- oder Führungsmodus), also hält er mit dem Video mit, auch wenn ein Abschnitt beschleunigt ist. Gleiche Frames nehmen den vorigen Screenshot, und nur deshalb dauert ein vierminütiger Tower nicht ewig.

Auf halber Strecke wollte ich Positionswechsel „lauter" haben, wie bei F1 TV. Jetzt blinkt jeder Wechsel vier Sekunden lang: Die Positionszelle leuchtet grün oder rot, die Zeile bekommt eine Farbfläche, und neben dem Code erscheint ein Chevron mit der Zahl der Plätze. Ein dritter Reiter, GAINED, zeigt gewonnene oder verlorene Plätze seit dem Start, unter den „falls Sie gerade erst einschalten"-Zusammenfassungen.

Zwei Dinge zu Design auf diese Art:

  • Geschmack gehört in die Daten, nicht in den Chat. Die ersten Fahrerkarten kamen mit meiner Karte auf 80 % der Fläche und den anderen auf 30–40 % zurück, dazu ein paar fiese Spitznamen. Statt Karten einzeln zu reparieren, wurde daraus eine Regel: Jede Karte wird über die Kopfgröße skaliert, gemessen am Foto. BUR bekam einen Spitznamen, den ich wirklich mag, „der Verteidigungsminister": Ich hing fünf Runden hinter ihm und bin nie vorbeigekommen.
  • Startnummern sind auch Design. Die erste Version nahm den Startplatz. Jetzt hat jedes Kart eine echte F1-Nummer aus dem Team seiner Farbe (ANK fährt in Alpine-Farben, also 43). Die Regel steht im Briefing, deshalb sind die Grafiken nie auseinandergelaufen.

Im Repo gibt es einen lebenden Styleguide mit jeder Komponente auf einem Testbild. Wann immer sich eine Grafik geändert hat, wurde zuerst dort nachgeschaut.

3. ffmpeg als Schnittprogramm

Weil sich Resolve nicht skripten lässt, war der ursprüngliche Plan, eine Timeline dafür als FCPXML zu erzeugen. Am Ende hat ffmpeg den ganzen Schnitt gemacht, und Resolve wurde nie geöffnet.

Schnittlisten in Python

Das Rennen ist in fünf Teile von je etwa fünf Minuten aufgeteilt. Jeder Teil ist eine Schnittliste in Python, eine Liste von Abschnitten, jeder ein Stück aus einem Kamera-Clip:

  • live: ein Abschnitt der Rennuhr von einer Kamera, höchstens 1,2×. Alles darüber sieht nicht mehr nach Übertragung aus, sondern nach Schnitt.
  • replay: ein Abschnitt eines Clips, abgespielt in einer Lücke der Rennuhr von genau dieser Länge.
  • vt: Material vor und nach dem Rennen, ohne Rennuhr.
  • Layouts: Vollbild, Hochformat (mit unscharfen Seitenstreifen), Split mit meiner Onboard, nur Onboard, Schwarz. Die Onboard kann Bild-im-Bild sein oder im Tower sitzen.

Die Regeln der Übertragung kamen aus meinen Notizen zur ersten Demo und wurden einmal aufgeschrieben. Die Rennuhr läuft nie rückwärts. Lücken werden mit Replays gefüllt. Jeder Sprung ist von einem Sting verdeckt. Und ein Hochformat-Video vom Handy wird nie mit riesigen schwarzen Rändern gezeigt, wenn die Onboard die andere Hälfte eines Splits füllen kann.

Stücke, dann ein Mux

demo.py --part p3 macht vier Dinge. Es rendert die geänderten Grafiken, rendert ein Videostück pro Abschnitt (parallel, mit dem Hardware-Encoder), setzt die Stimmen und muxt. Der Mux läuft in drei Durchgängen (Bild, Ton, beides), und am Ende steht eine harte Prüfung: Die Zahl der Frames muss zur geplanten Länge passen, und der Ton muss so lang sein wie das Bild. Sonst weigert er sich fertigzuwerden.

Die Prüfung gibt es wegen des schlimmsten Abends des ganzen Projekts. Im ersten Render von Teil eins brach die Musik bei 0:28 ab, das Bild fror ein paarmal ein, ein Kommentator sagte „Mik beendet die erste Runde", bevor die Ampel überhaupt aus war, der Tower verschwand, aber das Bild-im-Bild blieb, und nach 4:00 gab es keinen Ton mehr. Mein Review fing mit „kompletter, absoluter Bullshit" an. War es auch.

Die Ursache war fies. Die Eröffnungsmontage mischte Clips von fünf Kameras mit unterschiedlichen Farbmarkierungen, und jedes Mal, wenn sich die Markierung änderte, baute ffmpeg seine Filterkette mitten im Stream neu auf und startete das Timing der Overlays neu. Rund 500 Frames verschwanden, und alles danach verrutschte. Die Lösung: jedes Stück auf denselben Farbraum normalisieren, die Frames nach Index neu nummerieren und genau diese Prüfung einbauen. Seitdem ist es nie wieder passiert. Claude hatte sich das Ergebnis vor der Übergabe eigentlich gar nicht angeschaut, und im Nachhinein ist das der eigentliche Fehler. Seitdem kommt jeder Render mit seiner Frame-Zahl und einer Liste dessen, was nicht geprüft wurde. Hören ist sowieso immer mein Job.

Ton

Der eigene Ton der Kameras besteht hauptsächlich aus Bekannten, die auf dem Balkon quatschen, also wird er nicht benutzt, mit zwei Ausnahmen. Meine Onboard ist das Ambient-Bett unter der ganzen Übertragung: normal, wenn sie das Bild ist, leise im Bild-im-Bild und in Replays, abgesenkt unter dem Kommentar. Der Ton der Streckenkamera kommt als zweite, stark gefilterte Schicht dazu, solange diese Kamera im Bild ist. Jeder Schnitt bekommt eine Blende von 10 ms, damit die Übergänge nicht knacken.

Die Eröffnung läuft auf das F1-TV-Thema: 39,5 Sekunden schnelle Schnitte auf die ersten 16 Takte, dann ein Sprung in den ruhigen Teil für die Startaufstellung. Claude hat die Schläge im Track kartiert (99,9 BPM), damit der Schnitt auf einen betonten Schlag fällt, und ich habe trotzdem zweimal eine Naht gehört. Funktioniert hat am Ende, den ersten Teil durch seinen eigenen betonten Schlag ausklingen zu lassen, was den Einsatz des zweiten verdoppelt, und ihn darunter über 0,6 s auszublenden.

Caches und der schwarze GPDA-Clip

Ein ganzer Teil braucht etwa sechs Minuten, ein reiner Ton-Remux zweieinhalb, und der letzte Durchlauf aller fünf Teile rund eine Stunde. Erträglich ist das nur mit Caches: Grafiken werden nur neu gerendert, wenn sich ihr Job oder das CSS geändert hat, und die Videostücke bleiben zwischen den Läufen liegen.

In den Caches lebte auch der hinterhältigste Bug. Stücke wurden nach Name und Startframe gecacht. Als ich wollte, dass ein Abschnitt ein Replay statt einer schwarzen Titelkarte zeigt, blieben Name und Start gleich, also kam das alte schwarze Stück einfach zurück. Aufgefallen ist es bei einer Frame-Prüfung kurz bevor der finale Schnitt zusammengefügt wurde. Jetzt merkt sich der Cache die Definition jedes Abschnitts und rendert ein Stück neu, wenn sie sich ändert.

4. Objekt-Tracking, wo es sich lohnt

Namensschilder über den Karts machen eine Balkonaufnahme erst lesbar. Sie sind auch der teuerste Teil des Projekts, also lohnt es sich zu entscheiden, wo man sie wirklich braucht. Gelandet bin ich hier: keine beim Live-Start (der ist auch so klar), Schilder in Replays, und live nur in Totalen, für die zwei, drei Karts, um die es gerade geht. Zwischenfälle laufen live ohne Schilder und im Replay mit.

Keyframes vom Menschen

Im Logger markiert T die Karts auf einem pausierten Bild, und Shift-T folgt einem Fahrer: auf sein Kart klicken, das Video springt eine halbe Sekunde weiter, wieder klicken. Zieht man am Punkt, verschiebt sich der Anker (wohin das Schild zeigt, etwa die Nase des Karts). Zieht man am Label, verschiebt sich das Label, damit es keinen Scheitelpunkt verdeckt. Zwischen Keyframes, die bis zu 8 Sekunden auseinanderliegen, bewegt sich das Schild von selbst.

Der Tracker füllt die Lücken

track.py lässt den CSRT-Tracker von OpenCV zwischen jedem Keyframe-Paar laufen, vorwärts vom ersten und rückwärts vom zweiten. Dabei misst er den Schwenk der Kamera selbst über Merkmale im Hintergrund, er weiß also, wo jeder Punkt in der Welt ist. Einem Durchgang, der nahe am anderen Keyframe ankommt, wird vertraut. Einer, der das nicht tut, wird dort abgeschnitten, wo er in der Welt stehenbleibt, denn genau das macht ein Tracker, der sich an einer Wand oder einem Banner festbeißt statt am Kart, und die Lücke wird ergänzt. Render und Logger folgen denselben Regeln: tagpath.py spiegelt den Swift-Code des Loggers und muss mit ihm im Gleichschritt bleiben.

Die erste Version brauchte über 8 Minuten für 10 Sekunden: Sie hat jeden Punkt über den ganzen Abschnitt in beide Richtungen verfolgt, auf Hochformat-Frames, die 5,6 GB Speicher belegten. Kleinere Frames, Hardware-Dekodierung und Tracking nur zwischen Keyframes brachten das auf 40 Sekunden. Trotzdem habe ich am Ende schneller geklickt, als OpenCV getrackt hat, und das auch so gesagt. Der Tracker wurde zum Lückenfüller, und die Wahrheit waren meine Klicks. Karts auseinanderhalten kann er auch nicht: In der ersten Demo hat er TIF und KAU vertauscht, und danach durfte er nie mehr raten, wer wer ist.

Labels, die das Rennen nicht verdecken

Bei Hochformat-Videos vom Handy landeten die Labels genau auf der Action. Jetzt sitzen sie bei einer Hochformat-Quelle in den unscharfen Seitenstreifen, mit Linien, die nach innen auf die Karts zeigen.

Bei den Zooms dieselbe Idee. Der Massencrash in den Esses in Runde 16 passierte genau dort, wo der Tower sitzt, also wurde das ein Split mit der Onboard und einem Zoom, der mit der Kamera mitschwenkt. Die erste Version schnitt direkt in den Zoom und schwenkte hinüber, bevor überhaupt jemand etwas gesagt hatte, als wüsste der Kameramann es vor den Kommentatoren. Die finale Reihenfolge: Die Kommentatoren sehen, wie BUR auf TIF aufläuft, ein paar Sekunden später schwenkt die Kamera hinüber, und erst dann berühren sie sich.

5. Die Kommentatorenbox und alles andere

Stimmen

Die Übertragung hat eine Box mit drei Leuten nach dem Vorbild von F1 TV: einen Hauptkommentator, einen Analysten für Linien und Strafen und einen gesprächigen Ex-Fahrer, der Dinge bemerkt. Die Zeilen entstehen mit ElevenLabs. Eine Skriptzeile sieht so aus:

{ "at": 853.25, "who": "LEAD", "hit": "Oh", "text": "[shocked] Oh! KON has hit BUR! He's spun right round!" }

at ist eine Rennzeit, oder ein Abschnitt plus Sekunden, oder „+0.2" (nachdem der Vorredner fertig ist; negativ heißt, sie reden übereinander). hit setzt dieses Wort statt des Zeilenanfangs auf den Moment, über die Zeitstempel, die ElevenLabs mit dem Audio zurückgibt. stop schneidet eine Zeile ab, wenn die nächste einsetzt, over setzt eine Reaktion genau auf ihren Moment, und radio macht die Zeile zum Funkspruch mit eigener Karte. Ein Planmodus berechnet das Timing des ganzen Skripts aus der Wortzahl, bevor auch nur ein Credit ausgegeben ist, und Takes werden nach Text und Stimme gecacht, man zahlt also nur für geänderte Zeilen.

Schwierig waren nicht die Stimmen, sondern menschlich zu klingen. Echte Kommentatoren reden nicht in Einzeilern. Einer trägt einen Gedanken über mehrere Sätze, ein anderer grätscht rein („sorry, hab gerade was gesehen"), der erste nimmt den Faden wieder auf, und überall gibt es Ähms und Fehlstarts. Dann mussten die Ansagen auf der Action landen. Claude hat geraten, wo auf der Runde ich gerade war, und lag bis zu acht Sekunden daneben. Geholfen hat die Wahrheit von mir, eine Kurvenkarte (Kurve 3 ist fünf Sekunden nach meiner Zieldurchfahrt, Kurve 9 dreißig und so weiter), dazu die Anker-Wörter. Die allerletzte Korrektur des Projekts war genau so eine: Das „Oh!" des Hauptkommentators kam eine Sekunde, bevor KON in BUR fuhr.

Boxenfunk

Ich wollte zehn bis fünfzehn Funkmomente, jeder ein berühmter echter Funkspruch aus der F1 auf einen unserer Momente. Die erste Runde war von KI nachgesprochen und klang genau so, also haben echte Aufnahmen gewonnen. Eine Aufnahme stellte sich als Fake heraus, die echte habe ich selbst ausgegraben.

Stewards

Der Sprung durch die Schlange in Runde 16 wurde zu einem eigenen Handlungsstrang: Meldungen der Rennleitung während der Übertragung (zur Kenntnis genommen, Untersuchung, Entscheidung), eine Strafe von +20 s, die ANK von Platz vier auf sechs zurückwirft, ein PEN-Badge im Ergebnis und eine Stellungnahme der Fahrervereinigung mit meiner eigenen geklonten Stimme, so geschrieben, dass sie nach PR-Schulung klingt, aber nicht ganz. BURs Badge sagt NEVER PASSED: Laut Protokoll liegt er eine Runde zurück, aber auf der Strecke bin ich nie an ihm vorbeigekommen.

Untertitel und Veröffentlichung

Am Ende hat Claude englische Untertitel gebaut (308 Einträge), aus der genauen Zeit, an der jede Zeile platziert war, und 24 GB an Renders und Caches aufgeräumt, damit der Videoordner auf den Drive konnte. Das Rennen ging als ungelisteter Post hier online. Das einzige Mal, dass er übers Ziel hinausgeschossen ist, war genau da: Ich habe „veröffentlichen" gesagt, und Claude hat den Pull Request gemergt, statt mir den Preview-Link zu schicken. Das ist jetzt eine Notiz im Gedächtnis.

Wie man die Arbeit organisiert

Wenn ich es noch einmal machen würde, würde ich das hier behalten.

  • Bau das Tool zum Loggen, bevor du den Schnitt anfasst. Ein Durchgang durchs Material, gespeichert bei jedem Tastendruck, mit den Daten direkt im Tool (hier das Protokoll), damit es dir beim Loggen widersprechen kann.
  • Schreib das Briefing auf und halt es aktuell. Prinzipien, um Streit zu entscheiden, Fakten, die nicht falsch sein dürfen, kurze Regeln für jeden Fehler, der zweimal passiert ist. Lange Sessions werden komprimiert. Dateien nicht.
  • Teil die Arbeit danach auf, wer wirklich was sieht. Ich habe Karts erkannt, über Geschmack und Tempo entschieden und zugehört. Claude hat gemessen: Uhrversätze, Startverzögerungen, VSC-Fenster aus Rundenzeiten, Checklisten wie „Clip 4973 bei 0:24, diese drei markieren". Jede Seite hat die Fehler der anderen gefunden.
  • Review im selben Tool, mit Zeitstempeln. Notizen, die man direkt im Logger am Render hinterlässt, sind genau und müssen nie abgetippt werden.
  • Lass die Pipeline nicht lügen. Frame- und Tonlänge müssen zum Plan passen. Ein Selbsttest steuert die echte Oberfläche des Loggers mit simulierten Tastendrücken. Jeder Render-Bericht sagt, was nicht geprüft wurde.
  • Teure Schritte nur auf Anfrage. Ein Planmodus, bevor Credits fließen, Caches mit ehrlichen Schlüsseln und kein kompletter Neu-Render, bevor ich das Ganze anfordere.
  • Lass es entscheiden, aber vor Unumkehrbarem fragen. Die meisten Entscheidungen hat Claude selbst getroffen und gemeldet. Gefragt hat er vor Änderungen an den Zeitnahmedaten, vor Downloads und vor dem Löschen. So blieb die Schleife schnell.
  • Ein Teil nach dem anderen. Fünf Minuten Übertragung pro Runde, jede mit eigenen Notizen, und die Regeln aus Teil eins wanderten in Teil zwei mit.
In Zahlen
Material5 Kameras, 44 Clips, 22 GB
Geloggt1.384 Ereignisse, davon 1.164 Keyframes für Namensschilder
Code~2.600 Zeilen Swift (Logger), ~2.200 Python (Pipeline), ~1.000 JS/CSS (Grafik)
Übertragung5 Teile, 23:09, 41.675 Frames, 239 Kommentatorenzeilen, 8 echte Funksprüche
KalenderRennen 25. Okt., Logger 27. Okt., erste Demo 29. Okt., finaler Schnitt 9. Nov.

Die Tools (Logger, Grafik-Engine, Pipeline) liegen als fftv auf GitHub, ohne das Material vom Rennen. Beim nächsten Rennen ändert sich die Fahrerdatei, der Rest bleibt.