# Marcels Video- und Content-System: Anleitung zum Nachbau

Für Johann (Atlas: Claude Code auf Hetzner, Ubuntu, Docker, Whisper vorhanden). Stand: 16.10.2026.

**So ist die Anleitung entstanden.** Marcels Claude hat dafür seine Skills, Regel-Notes, Projektordner, Skripte und Werkzeugbeschreibungen gelesen (Liste im Anhang). Zahlen stammen aus Marcels eigenen Accounts und Projekten. Was nicht sicher belegt ist, steht mit "(unsicher)" da. Zeitangaben in Kapitel 10 sind Schätzungen.

**Was bewusst fehlt.** Keine Passwörter, Schlüssel, Tokens, Hostnamen, Konto-IDs oder Kontaktdaten (stattdessen Platzhalter wie `<API_KEY>`). Keine Namen von Teilnehmern, Kunden oder fremden Creator-Accounts, Personen auf Clips sind anonymisiert.

**Begriffe, die oft vorkommen**

| Begriff | Bedeutung |
|---|---|
| Marcelacht, @marcelachtt | Marcels persönlicher Kanal (Personal Brand) |
| MOHANA, @mohanatrips | Firmenkanal (Gruppenreisen für 18- bis 29-Jährige) |
| KI | Claude Code auf dem Server, mit Skills und Subagenten |
| Skill | SKILL.md-Datei für Claude Code: Auslöser, eiserne Regeln, Ablauf, Pflicht-Lektüre |
| Vault | Marcels Wissensablage aus Markdown-Notes, eine Note je Thema |
| Content-Zentrale | Arbeitsdatenbank in Notion (Videos, Posts, Tests, Lernlog) |
| T7, 2TB | die zwei externen Festplatten am Mac (Arbeitsplatte und Rohmaterial-Archiv) |
| Fließband | Marcels Regelwerk für den ganzen Ablauf von Idee bis Auswertung |
| Testreel | Instagram-Reel, das erst Nicht-Followern gezeigt wird und nur bei Erfolg ins Profil wandert |
| Faktor | Aufrufe geteilt durch den Median vergleichbarer eigener Videos (1 = normal, ab 3 = Winner) |

## Inhalt

1. Überblick
2. Galeriesystem und Footage-Archiv
3. Auswahl der besten Clips
4. Skripte
5. Instagram- und Meta-Daten
6. Vorbild-Profile
7. Schnitt
8. Veröffentlichen, Planung und Lernschleife
9. Werkzeuge, Dienste, Kosten, Hardware
10. Aufbau-Reihenfolge
11. Typische Fehler und Lehren
12. Was ich heute anders machen würde

Was Johann vorab selbst tun muss

Anhang: Quellen und offene Punkte

---

## Kapitel 1: Überblick

### 1.1 Was das System kann

Seit Oktober 2026 macht die KI bei Marcel rund 95 % der Arbeit an Kurzvideos und YouTube-Videos. Marcel nimmt auf, prüft und gibt frei. Die KI:

- hält einen durchsuchbaren Index über das Rohmaterial (Abschriften jedes Videos, Musikerkennung, Kontaktbögen, Kataloge je Projekt),
- schreibt Skripte in Marcels Stil aus einer Faktenbasis, mit drei Hook-Varianten, Song-Vorschlag, Caption und Drehzettel,
- ordnet die aufgenommenen Takes dem Skript zu und schneidet: Rohschnitt, Wortzeiten, Untertitel, Musik und Soundeffekte, Lautheit, Hautfarbe, Motion Graphics, Qualitätsprüfung,
- liefert jedes Kurzvideo zweimal: als fertiges MP4 und als CapCut-Projekt mit echten Textebenen, damit Marcel selbst nachbessern kann,
- schreibt Caption, ersten Kommentar und Texthook, prüft auf Doppelte und plant im Planer Zernio,
- wertet nach 48 Stunden aus (Faktor gegen den eigenen Median, Winner-Regel), verteilt Winner auf TikTok und YouTube, recycelt sie später,
- vergleicht jede Änderung von Marcel mit ihrer eigenen Fassung und macht daraus Regeln, die beim nächsten Video gelesen werden,
- beobachtet Vorbild-Accounts und leitet daraus Formate ab, nie Inhalte.

### 1.2 Ablauf von Rohmaterial bis zum fertigen Post

```mermaid
flowchart TD
    subgraph Material
        A1[Handy, Sony, Drohne] --> A2[Externe Platten am Mac<br/>2TB: Rohmaterial nach JJJJ_MM_Ort<br/>T7: Arbeitsplatte, B-Roll, FERTIG]
        A2 --> A3[Kleine Ableitungen zum Server:<br/>16-kHz-Ton, Kontaktbögen, ffprobe-Inventar]
        A3 --> A4[Index auf dem Server:<br/>Whisper-Abschriften, Musikwerte,<br/>Projekt-Kataloge per Subagent]
    end
    subgraph Idee
        V1[Vorbild-Radar, Ausreißer,<br/>eigene Winner] --> B1
        B1[Skript-Skill:<br/>Faktenbasis, Hook-Regeln,<br/>Lernlog, letztes Feedback] --> B2[3 Hooks, Skript,<br/>Song, Caption, Drehzettel]
        B2 --> B3{Marcel: Abnahme Skript}
    end
    B3 --> C1[Marcel nimmt auf]
    C1 --> C2[Takes per Transkript zuordnen]
    A4 --> C3
    C2 --> C3[Schnitt-Pipeline:<br/>Wortzeiten per Ausrichtung, Rohschnitt,<br/>Untertitel, Ton nach Playbook, -14 LUFS,<br/>Hautfarbe, Remotion-Grafik]
    C3 --> C4[Automatische QA<br/>plus frischer Prüfer]
    C4 --> C5[MP4 nach FERTIG/1 Prüfen<br/>plus CapCut-Projekt]
    C5 --> D1{Marcel prüft abends}
    D1 -->|ändert| L1[Vergleich KI-Fassung gegen Marcels Fassung]
    D1 -->|passt| D2[FERTIG/2 Bereit = Freigabe]
    D2 --> D3[Caption, erster Kommentar, Texthook]
    D3 --> D4{Doppelte prüfen}
    D4 --> D5[Zernio plant Instagram, TikTok, YouTube]
    D5 --> D6[Live, Datei nach überall online]
    D6 --> E1[48 h: Zahlen aus API, Zernio, Export<br/>Faktor gegen 14-Tage-Median]
    E1 -->|Winner| E2[Feed, TikTok, YouTube,<br/>4 Gewinner, Recycling nach 3 Wochen]
    E1 --> L1
    L1 --> L2[Lernlog: Hinweis oder Regel]
    L2 --> L3[Regel in die passende Note]
    L3 --> B1
    L3 --> C3
    E1 --> W1[Freitag: Wochenbericht, Tests]
```

### 1.3 Warum es so gebaut ist

| Entscheidung | Grund |
|---|---|
| **Der Mensch nimmt auf und prüft, die KI macht den Rest.** | Marcels Zeit geht in Aufnahme und Urteil, nicht in Handarbeit. Gemessen wird der Fortschritt am Anteil "ohne Änderung freigegeben", getrennt für Skript und Schnitt. |
| **Wissen in Notes, Skills sind nur Hüllen.** | Ein Skill enthält Auslöser, eiserne Regeln, Ablauf und Pflicht-Lektüre. Das Wissen (Hook-Regeln, Faktenbasis, Schnittregeln) steht in je einer Note. So bleibt jede Regel an einer Stelle, und fehlt eine Pflicht-Note, bricht der Skill ab, statt aus dem Gedächtnis zu arbeiten. |
| **Jedes Feedback wird sofort gespeichert.** | Alles, was Marcel zu Content sagt, auch Nebensätze, landet dauerhaft dort, wo es beim nächsten Auftrag sicher geladen wird. Vor jedem Schnitt liest die KI alle Regeln und nennt im Bericht, welche sie angewendet hat. |
| **Server plant, Mac rendert.** | Das Rohmaterial liegt auf Platten am Mac, der Upload zum Server schafft nur rund 0,03 bis 0,15 MB/s. Deshalb holt der Server nur Ton und kleine Bilder, der Endrender läuft am Mac. Liegt bei dir das Material direkt am Server, entfällt diese Teilung. |
| **Freigabe ist ein Ordner, kein Chat.** | Alles landet in "1 Prüfen". Erst wenn Marcel es nach "2 Bereit" schiebt, wird geplant. Kein Video geht ohne diesen Schritt raus. |
| **Zahlen immer relativ und als Median.** | Faktor = Aufrufe geteilt durch den Median desselben Accounts und derselben Plattform. Ein Hit verzerrt Durchschnitte, absolute Views sagen wenig. |
| **Regeln aus Tests, nicht aus Zusammenhängen.** | Alte Daten liefern Hinweise und Testideen. Eine Regel entsteht erst aus einem Test mit Zufallszuteilung oder einer klaren Ansage von Marcel. |
| **CapCut-Projekt plus fertiges MP4.** | Marcel kann in Sekunden selbst ändern, und die KI lernt aus genau diesen Änderungen. |

### 1.4 Herkunft jeder Regel markieren

Marcels System markiert jede Regel mit ihrer Herkunft. Das lohnt sich beim Nachbau ab dem ersten Tag:

- **Zahlen:** aus den eigenen Daten nachgerechnet.
- **Marcel:** seine Regel, sein Journal oder seine Erfahrung.
- **Kurs:** aus Kursen oder von Creatorn, auf den eigenen Kanal geprüft.
- **Offen:** noch nicht belegt, Vorschlag der KI oder laufender Test.

Ein unabhängiger Gegencheck hat einmal Punkte gefunden, die als belegt markiert waren, aber nur Kurs-Wissen oder KI-Vorschläge waren. Ohne diese Labels hält die KI Vermutungen für Fakten.

### 1.5 Bausteine im Überblick

| Baustein | Bei Marcel | Kapitel |
|---|---|---|
| KI und Orchestrierung | Claude Code auf einem Linux-Server ohne GPU, Subagenten für Sichtung und Bau, eine Auftragsdatei je Projekt | 1, 10 |
| Wissen | Vault mit Content-Notes, Skills als Hüllen | 4, 8 |
| Arbeitsdaten | Notion: Videos, Posts, Tests, Lernlog | 5, 8 |
| Material | zwei externe SSDs am Mac, Google Drive für Ausgewähltes | 2 |
| Index | Whisper-Abschriften, Musikwerte, B-Roll-Index, Projekt-Kataloge | 2, 3 |
| Schnitt | Python, ffmpeg, whisper.cpp, Demucs, torchaudio, Remotion, CapCut | 7 |
| Ton | Sound-Playbook mit Song- und Soundeffekt-Katalog, Tonplan-Skript | 7 |
| Planung | Zernio über API, Ordner Prüfen, Bereit, online | 8 |
| Daten | offizielle Instagram-API (stündlich), Meta-Export, Business-Suite-Export, Zernio-Analytics | 5 |
| Vorbilder | Apify, yt-dlp, Bild-für-Bild-Messung | 6 |

---

## Kapitel 2: Galeriesystem und Footage-Archiv

### 2.1 Grundidee in einem Satz

Alles Bildmaterial (Fotos, Videos, Zwischenstände, Caches) liegt nur auf externen Festplatten am Mac. Der Server (Claude Code) besitzt kein Video-Archiv, sondern nur einen **Index**: Inventarlisten, Abschriften, Musikwerte, Kontaktbögen und Kataloge. Gerechnet wird, was große Dateien braucht, auf dem Mac; gedacht, geplant und geprüft wird auf dem Server.

### 2.2 Wo die Originale liegen

| Ort | Rolle | Größe | Hinweise |
|---|---|---|---|
| **Handy-Galerie** | Hier wird fast alles gefilmt | (unsicher) | Marcel schneidet die Clips eines Events oder Tagesabschnitts am Handy zu **einem** langen Video zusammen (auch Videos, die andere geschickt haben) und löscht den Rest. Folge: viele lange Dateien mit mehreren Szenen darin. |
| **Festplatte "T7"** (Samsung T7, exFAT) | **Arbeitsplatte** | rund 1 TB | Ordner `Content` mit Themenordnern, B-Roll-Sammelvideos, fertigen Schnitten, Longform. |
| **Festplatte "2TB"** (exFAT) | **Rohmaterial-Archiv nach Datum** | rund 2 TB | Ordner `JJJJ_MM_Reise`, dazu `YOUTUBE`, `Pics`, `RAW`, `_Archiv`, `weiteres` (CapCut-Medien, Drive-Kopien, Schnitt-Arbeitsordner). |
| Dritte Platte am Mac | nicht im System | 461 GB | Für den Server nicht lesbar, von Marcel nicht mitgezählt. |
| **Google Drive** (geteilte Ablage MOHANA, Ordner "Marke und Content") | nur Ausgewähltes | Ordner "06 Marke und Content": 78 GiB, rund 1.060 Dateien | Wird per rclone als echte Kopie auf die 2TB gezogen (siehe 2.7). Dorthin kommt nur, was Marcel ausgewählt hat. |
| **Mac-interne SSD** | nur Dokumente | | Fotos, Videos, Proxys, Render-Caches und CapCut-Medien sind dort verboten (siehe Lehren). Skripte, Tabellen, Transkripte dürfen dort liegen. |
| **Server** | Index, Pläne, Prüfungen | klein | Projektordner je Video unter `/srv/mohana/projekte/<thema>/` als Git-Repo. Videodateien sind per `.gitignore` ausgeschlossen. |

**Gesamtgröße ungefähr:** rund 3 TB auf den zwei Arbeitsplatten (T7 rund 1 TB, 2TB rund 2 TB), dazu die 461-GB-Platte außerhalb des Systems. Ein geplanter Umzug von Rohmaterial und Archiv von der T7 auf die 2TB umfasste rund 439 GB und wurde verschoben, bis eine neue, größere Platte da ist, auf der dann alles liegen soll.

Zum Vergleich einzelne Projekte (aus den Berichten):
- Mohana-Life-Sichtung: 249 Clips, rund 213 Minuten, rund 56 GB (Summe der Dateigrößen im Inventar).
- Honolulu-Marathon-Longform: 507 Dateien (485 eindeutig), 5 Stunden 46 Minuten (ohne Kopien rund 5 Stunden 16 Minuten).
- Norwegen-Vlog: 134 Clips, rund 3,4 Stunden.

### 2.3 Ordnerstruktur

Struktur aus Marcels Notizen und den Projektaufträgen (nur Ordner, die in den Quellen vorkommen):

```
T7 (Arbeitsplatte, rund 1 TB)
└── Content/
    ├── AHandyVideos/            Handy-Material nach Themen
    │   ├── Hawaii/              (Oahu, Big Island, Kauai, Maui)
    │   ├── Joggen:Marathon/
    │   ├── Labern alt/          alte Sprechaufnahmen (Voiceover-Quelle)
    │   └── Norway/ ...
    ├── Aests/                   ästhetische B-Roll: pro Ort EIN langer Zusammenschnitt (rund 10 min)
    ├── Neu aufgenommen/         frische Takes für den Schnitt
    ├── FERTIG/
    │   ├── 1 Prüfen/            jeder fertige Kurzvideo-Schnitt der KI
    │   ├── 2 Bereit/            von Marcel freigegeben, wird eingeplant
    │   ├── überall online/      nach dem Posten, in Themenordnern
    │   │   ├── Edits/  ich glaube.../  ich Suche eine Person/  Mansion/
    │   │   ├── MissionMarcel/  MohanaTrip/  PureMotivation/
    │   │   └── So Simpel(click)/  Yapping/  archiv egal/ ...
    │   ├── 4 Gewinner/          Vorrat fürs Recycling
    │   └── Vom Handy/
    ├── Longform/                alles für YouTube außer Shorts (Vlogs, Intros)
    │   └── Vlogs/<Reise>/       Kamera-Rohmaterial von Longform-Projekten
    ├── Testimonials/
    ├── Inspiration/  StealLikeArtist/   Vorbilder anderer Creator
    ├── Audios/                  Sprachnachrichten, Voiceover
    ├── Bilder von Marcel/
    └── StockETC/

2TB (Rohmaterial-Archiv, rund 2 TB)
├── 2025_05_Norwegen/
├── 2025_09_InfluencerWG/
├── 2025_12_Asien/Bali/rawtalk/      Unterordner nach Ort und Art
├── 2026_03_Kapstadt/
├── 2026_07_MansionStart/
├── 2026_09_Zypern/ ...              Schema: JJJJ_MM_Name
├── YOUTUBE/                          Kamera-Material für YouTube
├── RAW/  Pics/  _Archiv/
└── weiteres/
    ├── CapCut/                       CapCut-Medien und Arbeitsstände der KI (79 GB)
    ├── Mohana Drive/                 Spiegel von "Meine Ablage"
    ├── Mohana Geteilte Ablage/       rclone-Kopie von "06 Marke und Content"
    └── Schnitt_Arbeitsordner/<projekt>/   Arbeitsordner je Schnittprojekt
```

Regeln dazu:
- **Neue Reisen** auf der Rohmaterial-Platte als `JJJJ_MM_Name` anlegen. Rohmaterial zuerst dort suchen.
- **B-Roll zuerst im Aests-Ordner** nach dem Ort suchen. Leicht zufällige B-Roll wirkt echt, sie muss nur grob passen.
- **Arbeitsordner** für Schnitte, Renders und CapCut-Importe auf der Rohmaterial-Platte unter `weiteres/`, nie auf der Mac-SSD. Ist die Platte nicht angesteckt: Bescheid geben statt auszuweichen.
- **Zwischen den Platten** wird nur nach Marcels Ok verschoben. Takes werden in der Content-Datenbank (Notion) zugeordnet, nicht verschoben.

### 2.4 Benennung

- **Rohmaterial:** Kameranamen bleiben (etwa `C1442.MP4` von der Sony, `IMG_7172.MOV` vom iPhone, `copy_<UUID>.MOV` aus Fotos-Exporten). Marcel benennt Handy-Zusammenschnitte oft selbst mit einem Stichwort ("17Mai", "Gletscher", "EierHolen").
- **Ordner:** `JJJJ_MM_Ort` oder `JJJJ_MM_Event`.
- **Fertige Kurzvideos:** `<Notion-Nummer> <Titel> v1.mp4` (etwa "MA-12 Titel v1.mp4"). v1 ist das Original, v2 die Recycling-Variante. Projekt-Serien bekommen einen Präfix ("Mohana Life <Titel> v1.mp4").
- **YouTube:** direkt in `Content/Longform`, etwa "Norwegen Vlog v1.mp4", dazu `.srt` und "Kapitel.txt" mit gleichem Stamm.
- **Verboten:** das Wort "Claude" in Datei-, Ordner-, Projekt- oder Notion-Namen. Bestehende Dateien nie überschreiben.
- **Kennungen im Index:** Jeder Clip bekommt im Projekt eine kurze Kennung: entweder Ordnerkürzel plus Nummer (`MS07`, `ZY44`, `N001`) oder die ersten 12 Zeichen des Dateinamens ohne Sonderzeichen (`79E48484EBEF`, `IMG2410`). Im zentralen Abschrift-Index ist die Kennung ein md5 des Pfads, dazu eine **Inhalts-Nummer**, die gleich bleibt, wenn eine Datei umbenannt oder verschoben wird.

### 2.5 Indizierung: drei Ebenen

**Ebene 1: Zentraler Abschrift- und Musik-Index (Server, für Satz-Suche über alles)**

Ein Ordner im Python-Umfeld des Servers (`~/.video-venv/daten/`):

| Datei | Inhalt |
|---|---|
| `index.tsv` | Kennung und Pfad jedes abgetippten Videos (FERTIG, Testimonials, Monatsordner, Drive-Testimonials). Stand: 2.836 Einträge. |
| `tr/<kennung>.json` | Whisper-Abschrift Wort für Wort mit Zeiten. Stand: 2.376 Dateien. |
| `music/<kennung>.json` | Musik-Wahrscheinlichkeit (PANNs) je halbe Sekunde, über 0,2 gilt als Musikverdacht. Stand: 2.359 Dateien. |
| `shots/<datei>.json` | harte Schnitte in den Aests-Sammelvideos (auch versteckte). 34 Dateien. |
| `videos.tsv` | Inhalts-Nummer, Kennung, Pfad. Gleicher Inhalt an zwei Orten ergibt zwei Zeilen. |

Werkzeuge dazu: `search.py "regex"` (Satz in allen Abschriften finden, mit Musikwert), `ngrams.py` (Sätze, die in vielen Dateien vorkommen, etwa für Supercuts), `batch_tr.py liste.txt` (neue Videos abtippen), `musicscan.py`, `shotscan.py`, `inhalt_ids.py --suche` (verschobene Videos wiederfinden; rechnet per SSH direkt auf dem Mac, 2.375 Videos in rund 10 Minuten statt Stunden über die Einbindung).

**Ebene 2: B-Roll-Index der Aests-Sammelvideos (Mac, für Bildsuche)**

`broll_index.py` zerlegt ein Sammelvideo in Einzelclips und beschreibt jeden Clip: Schnitterkennung (TransNetV2 plus eigene bewegungskompensierte Differenz plus Farbhistogramm), Kamerabewegung per optischem Fluss, Farbe, Schärfe, Belichtung, Horizont, Personen (Apple Vision), Bild-Embeddings (SigLIP2, mehrsprachig) und ein Ästhetik-Score (LAION). Ergebnis je Video: `index/<name>.json` mit Start, Ende und Merkmalen je Clip, dazu Kontaktbögen (erstes, mittleres, letztes Bild). Stand: 6 Orte indexiert, 281 Clips. Laut eigener Prüfung fand die Schnitterkennung 128 von 129 Schnitten in 4 Videos ohne Fehlalarm.

**Ebene 3: Projekt-Katalog je Schnittprojekt (Server)**

Für jedes größere Projekt entsteht ein eigener Katalog aus Inventar, Abschriften und Kontaktbögen (Ablauf in 2.6, Format in 2.8). Ein Katalog **aller** Clips beider Platten ist geplant, aber noch nicht gebaut: zuerst räumt Marcel die Platten auf. Pflichtfelder dafür laut Marcel: **wann**, **wo** und **was** passiert, dazu Stimmung, Personen, Qualität, Hoch- oder Querformat. Datum und Ort sollen aus den Metadaten kommen (creation_time, iPhone-GPS), sonst aus dem Ordnernamen.

### 2.6 Wie Inventar, Transkripte und Vorschaubilder entstehen

Der Ablauf ist in allen Projekten gleich (Mohana Life, Honolulu, Norwegen, Week in my Life). Grund: Die Leitung vom Mac zum Server schafft nur rund 150 KB/s. Deshalb werden auf dem Mac nur **kleine Ableitungen** erzeugt (16-kHz-Ton, kleine Standbilder) und auf den Server geholt.

1. **Inventar (Mac, ffprobe):** Pfad, Dauer, Größe, Breite, Höhe, Drehung, Bildrate, Aufnahmezeit, GPS, Kameramodell je Datei. Auf dem Server daraus `clips.json`: Kennung, Zeit, Ort, Dauer, Format (Drehung eingerechnet), Ordner und **Duplikate** (gleiche Größe und Dauer ergeben `dup_of`).
2. **Je Clip (Mac, ein ffmpeg-Aufruf):** ein Kontaktbogen mit 8 Bildern (4x2 oder 8x1) und die Tonspur als 16-kHz-Mono-Opus mit 24 kbit/s. Drei Läufe parallel.
3. **Transkription (Mac mit Metal oder Server):** whisper.cpp (`whisper-cli`) mit dem Modell `large-v3-turbo` (quantisiert q5_0), Sprache Deutsch, Ausgabe als JSON oder SRT. Für Schnittstellen ein zweiter Lauf mit Wortzeiten (`-ml 1 -sow`).
4. **Dichte Bildbögen (Mac oder Server):** ein Bild alle 2 bis 2,5 s, klein (200 px Kante), auf einen Bogen von 6x4 oder 8 Spalten geklebt. Jedes Bild trägt in Gelb die Sekunde im Clip, bei Mohana Life zusätzlich die Lautstärke in dB (lauter als etwa -20 dB heißt Geschrei, Lachen oder Musik, unter -40 dB still).
5. **Szenenerkennung (Mac):** ffmpeg-Filter `select='gt(scene,0.3)'` je Clip, Ausgabe als Liste von Schnittzeiten. Wichtig, weil viele Handy-Dateien Zusammenschnitte sind.
6. **Lautstärkeprofil:** `laut.txt` mit dBFS je 0,5 s.
7. **Sichtung durch Claude (Server, Subagenten):** Jeder Subagent bekommt einen Stapel Bögen plus Abschrift, sieht die Bilder mit dem Read-Werkzeug an und schreibt den Katalog (JSON oder JSONL, eine Zeile je Clip). Abnahme: jede Kennung genau einmal, Zeiten innerhalb der Clipdauer, gültiges JSON.
8. **Feinbögen bei Bedarf:** Für einen Ausschnitt 4 bis 10 Bilder pro Sekunde mit Zeit auf 0,1 s, damit Schnittpunkte bildgenau sitzen.

Lange Läufe auf dem Mac starten mit `nohup caffeinate -i ...`, damit der Mac nicht einschläft. Jeder Clip schreibt eine `fertig`-Marke, ein Neustart überspringt Erledigtes. Der Server holt fertige Tonspuren in einer Schleife ab und tippt sie parallel ab.

### 2.7 Wie Server und Mac verbunden sind

- **Verbindung:** Der Server erreicht den Mac per SSH mit Schlüssel, die Platten sind auf dem Server zusätzlich **nur lesend** als Netzlaufwerk eingehängt (rclone, FUSE). Details zum Zugang sind hier absichtlich weggelassen. Auf dem Mac vor jedem Befehl `export PATH=/opt/homebrew/bin:$PATH` (Homebrew-ffmpeg, whisper-cli).
- **Schreiben:** über ein rclone-Remote zum Mac, etwa `rclone copyto <datei> "<mac-remote>:/Volumes/<Platte>/Content/FERTIG/1 Prüfen/<name>" --retries 10` und immer `--checkers 2` (sonst bricht der SSH-Handshake ab). Danach Größe per `rclone lsl` prüfen. Liegt der Render schon auf dem Mac, per SSH dort `cp` und mit `md5 -q` vergleichen, das dauert Sekunden statt Minuten.
- **Kleine Dateien holen:** `ssh ... 'cd <ordner> && tar cf - <dateien>' | tar xf -` (scp mit Platzhaltern ging nicht).
- **Drive auf die Platte:** auf dem Mac rclone mit eigenem Remote (Bereich `drive.readonly`, geteilte Ablage), Skript `kopieren.sh` holt bei jedem Lauf nur Neues. Nicht über das Drive-Laufwerk oder Offline-Verfügbarkeit (siehe Lehren).

### 2.8 Katalogformat (Beispiel, anonymisiert)

**Variante A: Kurzvideo-Katalog (Mohana Life), ein Objekt je Clip**

```json
{
  "id": "ZY04",
  "datei": "2026_09_Zypern/copy_<UUID>.MOV",
  "dauer": 62.4,
  "format": "hoch",
  "inhalt": "Zusammenschnitt: Marcel meldet sich im Selfie, weil es regnet, die Gruppe springt im Regen in den Pool, abends ist der Pavillon vom Sturm zerstört.",
  "ort": "Villa, Pool und Terrasse",
  "personen": ["Marcel", "Person"],
  "musik_im_ton": "nein",
  "szenenwechsel": [9.0, 17.0, 21.0, 25.0, 29.0, 31.0, 33.0, 41.0],
  "qualitaet": "wacklig",
  "momente": [
    {"a": 0.0, "b": 9.0,
     "was": "Marcel im Selfie mit Handtuch, erschrickt über den Regen",
     "kategorie": ["reaktion", "chaos_alltag"],
     "witz": 3, "bild": 4, "ton_wichtig": true,
     "zitat": "Es regnet ... oh! Ich hab mich erschrocken.",
     "text_idee": "wenn es auf Zypern einmal regnet"},
    {"a": 41.0, "b": 62.0,
     "was": "Nachts: der Pavillon ist zerlegt, Marcel läuft fassungslos herum",
     "kategorie": ["chaos_alltag", "reaktion"],
     "witz": 3, "bild": 1, "ton_wichtig": true,
     "zitat": "Der arme Pavillon!",
     "text_idee": "der Sturm war ernst gemeint"}
  ]
}
```

Kategorien dort: wasserschlacht, nass_machen, pool_werfen, prank, anschreien_beleidigen, lachen, umarmen, essen_gemeinsam, kochen, party, tanzen, sport, chaos_alltag, ankunft_einzug, reaktion, schoen_aesthetisch, arbeit, reise, sonstiges. Ergebnis im Beispielprojekt: 249 Clips, 628 Momente.

**Variante B: Vlog-Logbuch (Norwegen), eine JSONL-Zeile je Clip**

```json
{"id": "N001", "datum": "2025-05-14", "uhr_lokal": "11:05",
 "ort": "Auto, Fahrt zum Flughafen",
 "was": "Marcel im Auto, ein Freund fährt ihn zum Flughafen, er zeigt die neue Kameratasche für seinen allerersten Vlog.",
 "personen": ["Marcel", "Person"], "qualitaet": 4, "story": 4, "format": "quer",
 "momente": [{"t": 17, "bis": 30, "was": "Kameratasche, erster Vlog, Scherz über Vlogger-Pose", "art": "humor"}],
 "zitate": [{"t": 17, "bis": 24, "sprecher": "Marcel", "text": "Ich hab mir jetzt noch so eine Kameratasche geholt, um meinen allerersten Vlog zu machen."}],
 "nutzen": ["intro", "story", "humor"],
 "probleme": "spricht teils zur Seite, abgebrochener Satz am Ende",
 "musik_im_ton": false, "zusammenschnitt": false, "szenen": []}
```

Felder: `qualitaet` 1 bis 5 (Bild), `story` 1 bis 5 (Bedeutung für die Geschichte), `momente[].art` aus landschaft, action, gruppe, emotion, humor, reaktion, gespraech, ankunft, essen, drohne, detail, talking_head; `nutzen` aus hook, story, broll, emotion, humor, landschaft, uebergang, ende, intro; `szenen` nur bei Zusammenschnitten.

**Variante C: Lesbare Katalogtabelle (Honolulu), per Skript aus JSON erzeugt**

Spalten: Nr, Kennung, Zeit (Ortszeit, TT.MM.JJJJ HH:MM), Quelle der Zeit (O = Metadaten mit Zeitzone, U = UTC umgerechnet nach Reiseabschnitt, D = Dateiname, I = aus Inhalt), Dauer, Format, Ordner, Ort (GPS mit nächstem Ort aus einer festen Liste und Abstand in km, sonst aus Inhalt mit "vermutlich"), Inhalt (ein Satz aus der Abschrift und dem Kontaktbogen), Sprache ja/nein, im Film ja/nein. Kopf mit Übersicht: Anzahl, Gesamtdauer, Anzahl mit Sprache, Zeitraum. "Nicht von Hand ändern, sondern Skript anpassen und neu laufen lassen."

### 2.9 Metadaten, Tags, Zeit und Ort

- **Zeit:** `com.apple.quicktime.creationdate` (mit Zeitzone) vor `creation_time` (UTC). UTC wird je Reiseabschnitt in Ortszeit umgerechnet. Weitergeleitete oder exportierte Dateien tragen oft die Export-Zeit, dann "vermutlich" markieren.
- **Ort:** iPhone-GPS (`location.ISO6709`), sonst Ordnername, sonst Inhalt.
- **Format:** Breite, Höhe und Drehung zusammen auswerten (viele iPhone- und Sony-Dateien sind quer gespeichert mit Drehung 90).
- **Tags** gibt es nicht als Dateisystem-Tags, sondern als Felder im Katalog (Kategorien, `nutzen`, `art`). In Notion hat jedes Video ein Feld "Rohmaterial" und "Musik im Video" (Ja, Nein, Unklar).
- **Veröffentlichte Reels** stehen zusätzlich in einer Reels-Datenbank (Apollo-Werkzeuge `reels_*`): Tabellen reels, transcripts, hooks, retention_points, insight_snapshots. Abschriften gibt es dort für Reels ab 11.05.2026.

### 2.10 Suche: wie man einen Clip findet

| Frage | Weg |
|---|---|
| "Wo sagt Marcel X?" | `search.py "regex"` über alle Abschriften, Treffer mit Zeit, Kontext und Musikwert |
| "B-Roll für diesen Skriptsatz" | `broll_search.py --query "<Satz>" --expand "<bild 1>|<bild 2>|<bild 3>"`: SigLIP2-Textsuche im B-Roll-Index, immer mit 3 bis 5 englischen Bildbeschreibungen (wer, wo, was, Licht) |
| "Material einer Reise" | Rohmaterial-Platte `JJJJ_MM_Ort`, dann Aests des Orts, dann `AHandyVideos/<Thema>`; auf dem Mac nur mit `ls -maxdepth` und gezielten Pfaden |
| "Wurde das schon verwendet?" | Abgleich der Abschrift gegen alle fertigen Videos über gleiche 4-Wort-Folgen: echte Wiederverwendung zeigt 60 bis 170 Treffer, 3 bis 7 Treffer sind Floskeln |
| "Woher stammt dieses Bild in einem alten Schnitt?" | Fingerabdruck: jedes Bild auf 32x18 Graustufen mit 25 fps, normierte Korrelation gegen alle Rohclips, Folgen zu Segmenten zusammenfassen (Week in my Life, `conform.py`) |
| "Gibt es die Datei doppelt?" | Größe und Dauer gleich ergibt Verdacht, Byte-Vergleich bestätigt |
| "Liegt eine Datei in einem CapCut-Projekt?" | Projektdatei jedes CapCut-Projekts (`draft_content.json` oder `draft_info.json`, je nach Version, unsicher), Feld `path` |

---

## Kapitel 3: Auswahl der besten Clips

### 3.1 Ablauf von der Sichtung bis zum Schnittpunkt

1. **Ziel und Kriterien zuerst** in die Auftragsdatei: welches Format, welcher Account, was dort nachweislich funktioniert (Zahlen der Gewinner), Länge, Ton-Regeln.
2. **Grobsichtung durch Subagenten** (siehe 2.6): Bögen plus Abschrift lesen, jeden Clip ehrlich bewerten, Momente mit Start und Ende erfassen, Szenenwechsel und Musik im Ton notieren. Ein Subagent je Ordner oder Stapel, parallel. Antwort an den Orchestrator kurz: die 8 bis 10 stärksten Momente mit Kennung und Sekunde.
3. **Konzepte** (Orchestrator): aus den Katalogen Videos zusammenstellen, Kandidaten je Video mit Zeiten, Reserve-Momente getrennt aufschreiben. Jeder Kernmoment kommt nur in einem Video vor.
4. **Feinarbeit je Video** (Bau-Subagent): Feinbogen um die Schnittpunkte, Wortzeiten messen, Schnitt in die nächste Sprechpause legen.
5. **Frischer Blick:** Kontrollbogen des fertigen Videos ansehen. Würde ein Fremder in den ersten 2 s hängen bleiben? Wo würde er wischen? Höchstens drei Runden nachbessern.

### 3.2 Bewertungskriterien

**Bewertungsskalen in den Katalogen**
- `witz` 1 bis 5: 5 = man lacht laut, 3 = schmunzeln, 1 = langweilig.
- `bild` / `qualitaet` 1 bis 5: 5 = ruhig, scharf, schönes Licht, klares Motiv; 1 = kaum erkennbar oder unbrauchbar.
- `story` 1 bis 5: 5 = Schlüsselmoment (Ankunft, Begegnung, Gipfel, Eisbad, ehrliche Aussage, starker Satz in die Kamera).
- `ton_wichtig`: trägt der Satz den Moment? Dann Originalton und Untertitel.
- Langweilige Clips trotzdem mit Inhalt eintragen, aber ohne oder mit wenigen Momenten. Bei Zweifel "Person" statt Namen.

**Inhaltliche Kriterien (aus Marcels Regeln und Ergebnissen)**
- **Sofort klar:** In den ersten 1 bis 2 Sekunden passiert etwas, oder es ist klar, worum es geht. Bild, Satz und Text zeigen in dieselbe Richtung.
- **Roher Einzelmoment mit Pointe** schlägt Montage auf dem WG-Account (Gewinner dort: ein klarer roher Moment plus eine Textzeile oben). Montagen mit Musik funktionieren für relatable Text-POVs.
- **Gegenüberstellungen** ("Vorteil / Nachteil" mit demselben Satz zweimal) trugen am besten (bestes Video im Mohana-Life-Projekt, eigene Note 8 von 10).
- **Aktion im Ausschnitt:** Clips mit einer Aktion nur, wenn die Aktion im Ausschnitt passiert. Gleichartige Momente (etwa Handschläge) als schnelle Kette.
- **Menschen statt Postkarten.** Prüf-Reihenfolge für B-Roll: Licht, ein klares Motiv, Schärfe und Ruhe, Farbe passend zur Sequenz, Horizont. Clips einer Sequenz von derselben Tageszeit. B-Roll lieber mit Gruppe als solo.
- **Takes:** besten Take wählen (weniger Rauschen, sauber zu Ende gesprochen). Marcel markiert verpatzte Takes beim Dreh mit Klatschen oder "nochmal".
- **Lieber kürzer und stärker als vollständig.** Längen: Einzelmoment 6 bis 20 s, Montage 12 bis 30 s, Ein-Satz-Reel 6 bis 10 s.

**Technische Ausschlusskriterien**
- **Kein Ausschnitt über einen Szenenwechsel** im Quellclip, mindestens 0,1 s Abstand zum Wechsel.
- **Nie Musik über Musik:** Clips mit fremder Musik im Ton stumm nehmen oder weglassen.
- **Hochformat wie gefilmt:** nie drehen, Zoom höchstens 1,1. Querformat im Hochformat-Video nur, wenn das Motiv im senkrechten Streifen wirklich gut aussieht, sonst weglassen.
- **Kein Rest unter 0,3 s** (außer bewusst schnelle Kette), nie mitten ins Wort schneiden, Stimme nie verändern.
- **Kein eingebrannter Text:** gibt es nur eine Fassung mit Text, die Rohaufnahme suchen.
- **Einwilligung:** Sagt jemand vor der Kamera "das darfst du nicht verwenden", wird die Stelle geschnitten. Heikle Geschichten bleiben drin, stehen aber im Bericht zur bewussten Freigabe.
- **Ästhetik-Scores** (LAION, Apple) nur als Filter gegen unscharfe und dunkle Clips, nie zur Auswahl: sie bevorzugen Postkarten und schieben emotionale Momente nach unten.

### 3.3 Werkzeuge und Befehle (bereinigte Auszüge)

**Sichtung je Clip: Bögen und Abschrift (Mac, zsh)**

```bash
# liste.txt: ID|h oder q|relativer Pfad auf der Platte
while IFS='|' read id ori pfad; do
  o=$B/$id; mkdir -p $o; f="/Volumes/<Platte>/$pfad"
  [ -f $o/fertig ] && continue
  if [ $ori = q ]; then sc=320; else sc=200; fi
  ffmpeg -nostdin -v error -y -i "$f" -vf "fps=0.5,scale=$sc:-2" -q:v 4 $o/f_%04d.jpg   # 1 Bild alle 2 s
  ffmpeg -nostdin -v error -y -i "$f" -vn -ac 1 -ar 16000 $o/ton.wav
  python bogen.py $o $o/ton.wav                                                         # Bogen 6x4 mit Zeit und dB
  whisper-cli -m ggml-large-v3-turbo-q5_0.bin -l de -f $o/ton.wav -osrt -of $o/text -np
  rm -f $o/ton.wav; touch $o/fertig
done < liste.txt
```

`bogen.py` (Kern): Lautstärke je 0,5 s als `20*log10(rms)` in `laut.txt`, dann je 24 Bilder ein Bogen, jedes Bild mit gelber Marke `m:ss  -23dB` (Maximum über 2 s).

**Kontaktbogen und Ton in einem Durchgang (Mac)**

```bash
r=$(python3 -c "print(max(0.02, 8.0/max(float('$dur'),0.5)))")   # 8 Bilder über die ganze Länge
ffmpeg -v error -y -i "$f" -filter_complex \
  "[0:v]fps=$r,scale=240:240:force_original_aspect_ratio=decrease,setsar=1,pad=240:240:(ow-iw)/2:(oh-ih)/2,tile=4x2[cs]" \
  -map "[cs]" -frames:v 1 -q:v 5 cs/$key.jpg \
  -map 0:a:0? -ac 1 -ar 16000 -c:a libopus -b:a 24k au/$key.opus
```

**Dichte Bilder plus Szenenerkennung in einem Durchgang (Mac)**

```bash
ffmpeg -nostdin -y -i "$f" -filter_complex \
  "[0:v]split=2[a][b];[a]fps=0.5,scale=200:200:force_original_aspect_ratio=decrease[o];[b]scale=160:-2,select='gt(scene,0.3)',showinfo[s]" \
  -map "[o]" -q:v 6 dense/$k/%04d.jpg -map "[s]" -f null - 2> scenes/$k.log
grep -o 'pts_time:[0-9.]*' scenes/$k.log | cut -d: -f2 > scenes/$k.txt   # Schnittzeiten in s
```

**Feinbogen für bildgenaue Schnittpunkte**

```bash
# fein.py <quelle> <a> <b> <bilder_pro_s> <ausgabe.jpg>: 8 Spalten, Zeit auf 0,1 s
ffmpeg -nostdin -v error -y -ss <a> -i "$src" -t <b_minus_a> -vf "fps=4,scale=180:-2" -q:v 5 tmp/f_%04d.jpg
```

**Wortzeiten**

```bash
# grobe Wortzeiten (driften bis zu 2 s)
whisper-cli -m ggml-large-v3-turbo-q5_0.bin -l de -ml 1 -sow -oj -of tw/$k -f $k.wav
```
Genauer: erzwungene Ausrichtung mit torchaudio `MMS_FA` je Sprechstelle, auf der Stimmspur aus demucs (`htdemucs`), 0,4 s Rand; Abweichung über 1,2 s gilt als Fehler. Schnittpunkte dann in die leiseste Stelle kurz vor dem Wort (`cut_in`: leiseste Stelle zwischen t minus 0,35 s und t plus 0,05 s).

**Musik im Clip-Ton erkennen**

```bash
python musicdet.py <datei> [von bis]      # PANNs Cnn14 (AudioSet), Musik-Wahrscheinlichkeit je 1-s-Fenster, ab 0,2 verdächtig
```
Gegenprobe: demucs-Spuren je genutztem Ausschnitt messen (Takt im Schlagzeug, Melodie-Anteil, Schlagzeug so laut wie Stimme). Grober Vorfilter mit librosa: Pulsklarheit (Autokorrelation der Onset-Stärke) und spektrale Flachheit.

**B-Roll suchen und Match-Cuts vorschlagen (Mac, eigene Python-Umgebung mit torch, open_clip, TransNetV2)**

```bash
export HF_HUB_OFFLINE=1
python -I broll_index.py  --src "/Volumes/<Platte>/Content/Aests/<Ort>.mp4" --work $W    # 5 bis 15 min je 2-min-Video
python -I broll_search.py --work $W --query "<Satz>" --expand "<bild 1>|<bild 2>|<bild 3>" --sheet $W/suche.jpg
python -I matchcut_finder.py --work $W --top 15 --sheet --preview --out matches
```
Eigene Messung: mit Bildbeschreibungen etwa 24 von 30 Treffern passend, mit dem rohen deutschen Satz etwa 15 von 30. Personen- und Selfie-Matches 6 von 6 gut, Bewegungs-Matches nur jeder zweite (immer Vorschau ansehen). Sicherer Ausschnitt aus dem Index: ab `start` plus 1 Bild bis `end` minus 2 Bilder. SigLIP2 und TransNetV2 laufen auf der CPU, die Apple-GPU stürzte ab.

**Satz in allen Abschriften finden**

```bash
python search.py "irgendwann ergibt.*sinn" 8      # Treffer mit Zeit, 8 Wörter Kontext, Musikwert
python ngrams.py 5 4                              # Sätze aus 5 Wörtern, die in mindestens 4 Dateien vorkommen
```

**Apollo-Werkzeuge für Sprechvideos (Talking Head)** (nur Beschreibung gelesen)
- `reels_eingang`: listet Videos auf dem Mac (Rohmaterial aus dem Fotos-Album "Talking Content", Rohschnitte, fertige Edits, Varianten). Videos liegen nur auf dem Mac, der Server hält Transkripte und ein Ledger.
- `reels_cut_vorschlag`: transkribiert ein Rohvideo und liefert die Satzliste mit Zeiten, Füllwörtern, erkannten Wiederholungen (Versprecher-Neuansätze) und Pausen (Standard höchstens 0,4 s).
- `reels_rohschnitt`: Aufruf 1 liefert eine Regie-Vorlage (Sätze, Takes, Vorlauf, Hook-Kandidaten, Vorschlag je Segment), Claude entscheidet. Aufruf 2 mit Auswahl (etwa `5,1,2-9`, Wortbereiche `3(2-14)`) schneidet, entfernt Atmer und Fehlstarts, poliert den Ton auf -14 LUFS und prüft hart (Rücktranskription, Pausen, Lautheit, Bild). Nur ohne Befund wird abgelegt, nie wird eine Datei überschrieben.
- `reels_transcript`, `reels_hook_frames`, `reels_query`: Abschrift mit Wortzeiten, Standbilder bei 0,5 / 1,5 / 2,5 s zum Lesen des Text-Hooks und SQL auf die Reels-Datenbank (für den Abgleich mit der Haltekurve).
- `video_analysis_create`: Szene-für-Szene-Analyse eines hochgeladenen Videos oder YouTube-Links durch einen externen Dienst, je länger das Video, desto ungenauer. Ob Marcel das für die Clipauswahl nutzt: (unsicher), in den gelesenen Projekten kommt es nicht vor.

### 3.4 Was Claude NICHT kann und wie es das ausgleicht

- **Claude hört nicht.** Es misst: Lautstärkeverlauf, Musikwahrscheinlichkeit, Abschrift, Rücktranskription des fertigen Schnitts. Unsichere Wörter stehen im Bericht für Marcel.
- **Claude sieht nur Standbilder.** Deshalb Bögen mit Zeitmarken, Feinbögen um Schnittpunkte und ein Kontrollbogen des fertigen Videos (2 Bilder pro Sekunde, 8x4).
- **Die Entscheidung bleibt bei Marcel:** Alles landet in "1 Prüfen", erst sein Verschieben nach "2 Bereit" ist die Freigabe.
---

## Kapitel 4: Skripte

### 4.1 Grundidee

Seit 14.10.2026 schreibt die KI Marcels Skripte komplett. Marcel nimmt auf und prüft. Ziel: Jedes Skript ist so gut, dass Marcel es ohne Änderung freigibt. Jede Änderung von ihm ist die wichtigste Lernquelle (siehe Abschnitt Lernschleife). Die letzte Fassung ist immer seine.

### 4.2 Woraus Claude gelernt hat

- **Rund 250 eigene Skripte** von Marcel (Dezember 2023 bis Oktober 2026), daraus Bauplan, Wortschatz, Hook-Bank und Endings.
- **Insights der eigenen Videos:** zuerst 489 Reels von @marcelachtt in einer ersten Auswertung (Stand 11.10.2026, Abgrenzung zu den 1.119 Uploads unsicher), später für das Fließband 1.119 Instagram-Reels, 873 TikToks, 674 YouTube Shorts, dazu die Zahlen aus dem Planer Zernio.
- **601 Learnings aus Marcels Notion** (Kurse, Creator-Notizen) und **251 Learnings aus den Chats** mit der KI, dazu sein altes Playbook.
- **Hook-Recherche:** Marcel hat Hook-Lehrer und Kurse sammeln lassen (etwa Kallaway, Jenny Hoyos, Paddy Galloway, Brendan Kane, Hormozi, deutsche Kanäle, dazu Aussagen von Instagram und TikTok). Das Ergebnis ist eine eigene Note mit Prüffragen (4.5.5).
- **Über 500 Video-Transkripte** für die Wortliste: Schreibweisen und typische Sätze.
- **Stil-Anker:** drei echte Skripte, die nachweislich funktioniert haben, plus vier weitere im Vault (in 4.10 nicht abgedruckt).

Wichtige Erkenntnis aus dem Vergleich: Von der KI geschriebene Skripte waren oft glatter als Marcels eigene, mit weniger Zahlen, ohne Zeitstempel und ohne einen Satz, in dem er sich angreifbar macht. Genau das steht deshalb heute im Qualitäts-Check (4.6).

### 4.3 Wie das Wissen abgelegt ist

Das Wissen steht nicht im Skill, sondern in Notes im Vault (eine Note je Thema). Der Skill ist nur eine Hülle: wann er greift, eiserne Regeln, Ablauf, Pflicht-Lektüre. Fehlt eine Pflicht-Note, bricht der Skill ab, statt aus dem Gedächtnis zu schreiben. Für Johann heißt das: dieselben Notes in Atlas anlegen, der Skill verweist nur darauf.

| Note (bei Marcel) | Inhalt |
|---|---|
| Content - Skript | Form, Länge, Bauplan, Regeln für die KI |
| Content - Hooks | was eine gute Hook ausmacht, erstes Bild, visuelle Hooks |
| Content - Hook-Bibliothek | Baukasten und bewährte Hooks wörtlich |
| Content - Retention und Rehooks | Prüffragen fürs Skript, Rehooks, Schnitt-Folgen |
| Content - Marcels Weg | Faktenbasis: jede Zahl im Skript kommt von hier |
| Content - Wortliste | Schreibweisen, Begriffe, typische Sätze |
| Content - Stil-Anker, Content - Skript-Beispiele | echte Skripte als Maßstab |
| Content - Formate (Story, Inspo, Experimente, MOHANA und YouTube) | Aufbau, Länge und Hook je Format |
| Content - Qualitäts-Check | Pflicht-Check vor der Übergabe |
| Reels - Handwerk (Abschnitt Hooks auf Deutsch) | Regeln für deutschsprachige Hooks |

Die **Faktenbasis** ist der wichtigste Baustein gegen erfundene Zahlen. Sie ist eine Zeitleiste der eigenen Geschichte plus Anekdoten plus Regeln, etwa: alte Zahlen aus früheren Skripten nie übernehmen, ohne sie zu prüfen; Follower- und View-Zahlen widersprechen sich in fast jeder Quelle, also nie ohne Rückfrage in einen Text; das Alter nicht fest eintragen, sondern als [Alter] lassen, bis es bestätigt ist; Geschichten, die in Quellen verschieden erzählt werden, vor Verwendung klären. Fehlt eine Zahl, steht ein [Platzhalter].

### 4.4 Ablauf pro Skript

1. **Pflicht-Lektüre:** Content-Notes (oben), Lernlog (Einträge zu Skript und Hook mit Stand „Regel“ oder „Hinweis“), die letzten 20 Abnahmen oder Feedbacks zu Skripten, laufende Tests. Dazu: Was passiert gerade bei Marcel (Storyline, Trips, Events)?
2. **Format wählen.** Ist keins genannt, wählt die KI eins und sagt in einem Satz, welches.
3. **Drei Hook-Varianten** (gesprochen), je mit Idee für visuelle Hook und Texthook. Die stärkste kommt ins Skript, die anderen darunter. Laut Prüffragen gern als Ergebnis zuerst, Zahl zuerst, Gegen-These.
4. **Skript in Marcels Zeilenform.**
5. **Darunter:** Song-Vorschlag, Caption (meist ein Einzeiler), Hinweis für den Drehzettel (Ort, Licht, Bild für den Hook, benötigte B-Roll).
6. **Qualitäts-Check** (4.6). Erst wenn alles erfüllt ist: als Zeile in der Videos-Tabelle mit Status „Entwurf“, „Skript von“ KI, Hook im Feld „Hook“, Skript als Seiteninhalt. Gibt Marcel „Abnahme Skript“, setzt die KI „Skript fertig“ und legt den Drehzettel an.
7. **Nach der Aufnahme:** Skript gegen das Whisper-Transkript der Takes vergleichen. Jede Abweichung, die mehr als ein Versprecher ist, kommt als Hinweis ins Lernlog (Abschnitt Lernschleife).

### 4.5 Regeln

#### 4.5.1 Form

- Eine Zeile ist ein Atemzug, ein Gedanke. Kurze und lange Zeilen mischen. Gesprochene Sprache, Kleinschreibung am Zeilenanfang.
- Pausen mit „…“, GROSSBUCHSTABEN für das eine Wort, das sitzen muss (ALL IN, KLICK, JEDER).
- Regie in Klammern direkt im Skript: (Song), (in cam), (in cam nah), (broll), (musik aus), (musik pause), (neue Musik), (pause), (blackscreen), (lachend).
- Keine Gedankenstriche, keine Emojis im Sprechtext.

#### 4.5.2 Länge

- Die Länge im Format geht vor (z. B. Plan A 120 bis 160 Wörter).
- Ohne Formatvorgabe höchstens rund 120 Wörter. Herkunft Zahlen: bis 120 Wörter normal, 120 bis 180 Faktor 0,85, darüber 0,78. Das alte Playbook sagte 80 bis 250 Wörter, die eigenen Daten haben das widerlegt.
- Inspo-Formate 40 bis 80 Wörter. Story-Videos nur für TikTok dürfen länger sein.
- Saves steigen mit der Länge bis etwa 45 Sekunden, kurz gewinnt Reichweite und Shares.

#### 4.5.3 Bauplan (Marcel)

1. **Hook in einem Satz,** Thema in Sekunde 1 bis 2. Oft Alter, Identität, Kontrast oder Zeitstempel.
2. **Neustart:** „aber ich fang mal von vorne an“, „ach warte“, „Hey, ich bin Marcel“ (als erster Satz schwach, als Neustart gut).
3. **Konflikt mit konkreten Zahlen** aus dem echten Leben.
4. **Wendepunkt mit „aber“, „also“ oder „deswegen“.** „und“ möglichst ersetzen. Das ist dieselbe Regel wie Trey Parkers „but/therefore statt and then“.
5. **Faktenkette** in Dreier- oder Viererschritten („Auto verkauft, Villa gemietet, 14 Teilnehmer ausgewählt“).
6. **Eine Lebensregel,** die direkt aus der Geschichte folgt. Nie eine Regel hineinkopieren, nur weil sie gut klingt.
7. **Ende:** positiv, Haltungssatz oder Einladung. Ein Aufruf pro Video. Kommentar-Aufruf mit Namen nur bei Lead-Videos.

Neugier am Anfang, Auflösung am Ende. Neugier ist nicht Verwirrung. „Man soll nicht merken, dass das Video zu Ende geht.“

#### 4.5.4 Hook

- Zwei Dinge: klares Thema und gezielte Neugier (Marcel).
- Stark ist ein Hook, wenn gerade wirklich etwas passiert, mit Einsatz („Ich hab mich gerade aus Deutschland abgemeldet“). Das unterscheidet Top-Reels von Flops, nicht die Satzform (Marcel). Allgemeine Weisheiten ohne Situation floppen (Zahlen).
- „ich“ vor „du“: „ich“-Hooks liefen besser als „du“-Hooks (1,04 gegen 0,91), Fragen im Hook schwächer (0,85). Den Zuschauer holt man im Mittelteil („und ich weiß, das willst du auch“). Die Kurs-Regel „du“ passt zu Wissens-Kanälen, Marcel ist ein Story-Kanal. Läuft als Test.
- Spezifisch schlägt allgemein: „3 Monate ohne Unterkunft“, „800 Meter vor dem Ziel“.
- Interne Updates (Formular, Warteliste) als Thema laufen schwach.
- **Dreifach-Hook:** Texthook, Bild und gesprochener Satz sagen dasselbe. Texthook 3 bis 7 Wörter (auf Deutsch eher 3 bis 5), höchstens 2 Zeilen, oberes Drittel, nie über Augen oder Mund, rund 3 Sekunden sichtbar.
- **Erstes Bild** erzählt eine Situation mit einem Satz. Kein Schwarz, kein Atmer, kein Logo in Bild 1. Ein Gesicht ohne Ort als erstes Bild lief schwächer (Zahlen).
- **Hooks auf Deutsch:** amerikanische Vorlagen nie wörtlich übersetzen, kein US-Hype (Superlative, Kontostände), Schlüsselwort früh oder bewusst als Pointe am Satzende, Kontrastwörter aber, doch, nur, trotzdem, eigentlich, und genau da. Geheimnis-Hooks nur, wenn wirklich ein Insider-Detail folgt.
- Baukasten-Formeln: Zeit + Handlung + Problem, Identität + Traum + obwohl, Frage + Ziel + Zeit, Kontrast A gegen B, Bekenntnis + Behauptung.

#### 4.5.5 Hook Stacking und Rehooks

Dauerregel für Reels (seit 02.09.2026): Jeder Satz muss einen Grund liefern, den nächsten zu sehen (Behauptung, Frage, Antwort, Werkzeug, harte Wahrheit, Ausgänge, Belohnung). Das Video ist so kurz wie möglich. Struktur aus den stärksten Sätzen frei neu bauen, ganze Takes und Blöcke streichen, Füller wie „ja“ kappen. Anlass: Eine erste Fassung, die die Reihenfolge des Rohmaterials behielt (71 Sekunden), war „storytelling-mäßig nicht gut“, die frei umgebaute Fassung (44 Sekunden) „deutlich besser“.

Prüffragen fürs Skript (aus der Hook-Recherche):

1. Satz 1: Ist in höchstens 10 Wörtern klar, worum es geht und was auf dem Spiel steht?
2. Sätze 2 bis 4: Bestätigen sie den Hook mit einem eigenen Beweis (eine echte Zahl, eine echte Tat)? Eigener Beweis schlägt geliehenen („XY sagt …“).
3. Fängt es mit Inhalt an, nicht mit einer Ansage („heute erzähl ich euch“)? Oft ist Satz 2 der bessere Hook.
4. Mitten im Geschehen starten, dann zurück. Funktioniert nur, wenn der Hook vorher eine echte Frage geöffnet hat.
5. Rehook alle 20 bis 30 Sekunden: neue offene Frage mit Kontrastwort. 30 Sekunden brauchen einen, 60 Sekunden zwei.
6. Wird das Versprechen eingelöst, und endet das Video direkt danach?
7. Steht drin, was es gekostet hat oder was verpasst worden wäre?
8. Gibt es einen natürlichen Grund zum Weiterschicken? Höchstens einmal, nie als Bettelei.
9. Drei Hook-Varianten anbieten.

Im Schnitt folgt daraus: Wo im Skript ein Kontrastwort fällt, kommt ein Wechsel (Winkel, Musik setzt aus, Stille, neue B-Roll).

#### 4.5.6 Sprache und Haltung (am Beispiel Marcel)

- Spricht genau eine Person an, wie ein Freund, nicht wie ein Prediger. Filtert gern („wenn dein Ziel ein sicherer Job ist, bist du bei mir falsch“).
- Ehrlichkeit als Hebel: „ich muss dir was beichten“, „um ehrlich zu sein“, „ich gebe zu …“.
- Kein Coach-Sprech, keine Marketingfloskeln, keine Adjektivketten. Konkrete Zahl schlägt Adjektiv.
- Zielgruppe deutsch und skeptisch: nichts Verkäuferisches, keine Einkommensversprechen, keine Luxus-Flexes. Euro-Beträge sind erlaubt.
- Niemanden abwerten. Verletzlich beim eigenen Weg, Autorität beim Produkt (Ablauf, Sicherheit).
- Markenbegriffe fest: bei MOHANA „Experience“ statt Urlaub, „Teilnehmer“ statt Kunden, „Mohana Hosts“ statt Reiseleiter. Nie: Kunde, All-Inclusive, Schnäppchen, Pauschal. In jeden Reise-Aufruf gehört „ab 18“.

#### 4.5.7 Was die Daten nahelegen (Hinweise, keine Beweise)

- Sprech-Videos mit Geschichte und Ziel bringen 3 bis 5x mehr Follower pro Reichweite als Edits (die Richtung ist belastbar, die genaue Höhe nicht).
- Themen Freunde, Team, Auswandern ziehen. Business und Fitness ziehen nicht, Sport nur im Bild.
- Geschichten dürfen wiederholt werden: wiederholte Skripte liefen gleich gut wie neue. Ein neuer Winkel hilft (eine Person, ein Detail, ein Fail).
- Eine Frage am Ende bringt nicht mehr Kommentare. Kommentare holt ein Lead-Video mit Namens-Aufruf.
- Was Marcels beste Skripte gemeinsam haben: ein offenes Ziel mit Zahl, ein Zeitstempel („Tag 2“, „vor 10 Tagen“), ein angreifbarer Satz, kein Coach-Satz.

### 4.6 Qualitäts-Check vor der Übergabe

- [ ] Hook in einem Satz, Thema in Sekunde 1 bis 2, Neugier ohne Verwirrung
- [ ] Länge passt zum Format (ohne Vorgabe höchstens rund 120 Wörter), laut gelesen flüssig
- [ ] Genau eine Message, sie folgt aus der Geschichte
- [ ] Mindestens eine konkrete Zahl, jede Zahl aus der Faktenbasis oder als [Platzhalter]
- [ ] Ein Satz, in dem sich die Person angreifbar macht
- [ ] „aber“ oder „also“ als Wendepunkt
- [ ] Zeitstempel oder Tageszahl, wenn es zum Format passt
- [ ] Positives Ende, höchstens ein Aufruf
- [ ] Passt zu Format, Account, Lernlog-Regeln und letztem Feedback
- [ ] Kein Gedankenstrich, kein Emoji im Sprechtext, kein Coach-Satz
- [ ] Ein Fremder versteht es ohne Vorwissen

### 4.7 Tests im Skript

Läuft ein Test, der das Skript betrifft (z. B. Hook „ich“ gegen „du“), schreibt die KI beide Varianten gleich sorgfältig fertig, dann wird gelost: in Paaren von zwei Skripten desselben Formats mit Python `random.shuffle(["A", "B"])`, nie nach Gefühl. Die Zuteilung steht vorher im Test-Eintrag, die Variante im Video. Details im Abschnitt Lernschleife.

### 4.8 Skill-Datei zum Übernehmen

Bereinigte Fassung von Marcels Skill `marcel-skript`, umgebaut für Atlas: ohne Notion-IDs, Links und Namen Dritter. Alles, was Marcels persönliche Stimme ist, steht als **Beispiel (Marcel)** und muss durch die eigene Stimme ersetzt werden. Platzhalter in spitzen Klammern. Wer dem Hüllen-Prinzip folgt, verschiebt die Abschnitte 2 bis 9 später in eigene Notes und lässt im Skill nur Verweise.

````markdown
---
name: "skript"
description: "Schreibt Reel-, TikTok- und Shorts-Skripte für <KANAL> genau im Stil von <PERSON>. Nutzen, sobald ein Skript, Hooks oder eine Überarbeitung gewünscht ist."
---

# Skript

Die KI schreibt die Skripte komplett. <PERSON> nimmt auf und prüft. Ziel: Jedes Skript
wird ohne Änderung freigegeben. Jede Änderung von <PERSON> ist die wichtigste Lernquelle.

## 0. Vor jedem Skript (Pflicht)

1. Notes lesen: <WISSEN>/content/Skript, Hooks, Hook-Bibliothek, Retention und Rehooks,
   Faktenbasis, Wortliste, Stil-Anker, das passende Format. Fehlt eine davon: abbrechen
   und sagen, was fehlt. Nicht aus dem Gedächtnis schreiben.
2. Lernlog lesen: alle Einträge mit Bereich Skript oder Hook, Stand Regel oder Hinweis.
   Regeln befolgen, Hinweise im Kopf behalten.
3. Letztes Feedback lesen: die letzten 20 Videos mit "Abnahme Skript" oder "Feedback Skript".
4. Laufende Tests prüfen. Betrifft ein Test das Skript: beide Varianten gleich sorgfältig
   fertig schreiben, dann in Paaren desselben Formats losen (Python
   random.shuffle(["A", "B"])), Zuteilung vorher im Test notieren, Variante im Video eintragen.
5. Was passiert gerade bei <PERSON>? Aktuelle Storyline, Reisen, Events.
   Fakten nur aus der Faktenbasis.

## 1. Ablauf

1. Format wählen. Ist keins genannt, eins wählen und in einem Satz sagen, welches.
2. Drei Hook-Varianten (gesprochen), je mit Idee für visuelle Hook und Texthook.
   Die stärkste kommt ins Skript, die anderen darunter.
3. Skript in Zeilenform (Abschnitt 2).
4. Darunter: Song-Vorschlag, Caption (meist ein Einzeiler), Drehzettel-Hinweis
   (Ort, Licht, Bild für den Hook, benötigte B-Roll).
5. Qualitäts-Check (Abschnitt 6). Erst wenn alles erfüllt ist: Video-Eintrag mit
   Status "Entwurf", Hook im Feld "Hook", Skript als Inhalt.
6. Nach der Aufnahme: Skript mit dem Transkript der Takes vergleichen (Whisper).
   Jede Abweichung, die mehr ist als ein Versprecher, als Hinweis ins Lernlog
   (Quelle "Deine Änderung", Bereich Skript oder Hook, Video verknüpfen).

Ausgabe immer Deutsch, Du-Form zum Zuschauer, keine Gedankenstriche.

## 2. Form

- Eine Zeile = ein Atemzug, ein Gedanke. Kurze und lange Zeilen mischen.
- Länge: Die Länge im Format geht vor. Ohne Vorgabe höchstens rund <MAX_WOERTER> Wörter
  (Beispiel Marcel: 120, aus eigenen Daten). Inspo-Formate 40 bis 80 Wörter.
- Kleinschreibung am Zeilenanfang, gesprochene Sprache.
- Pausen mit "…", GROSSBUCHSTABEN für das eine Wort, das sitzen muss.
- Regie in Klammern: (Song), (in cam), (in cam nah), (broll), (musik aus),
  (musik pause), (neue Musik), (pause), (blackscreen), (lachend).
- Keine Gedankenstriche, keine Emojis im Sprechtext.

## 3. Bauplan

1. Hook in einem Satz, Thema in Sekunde 1 bis 2.
2. Neustart ("aber ich fang mal von vorne an", "ach warte").
3. Konflikt mit konkreten Zahlen aus dem echten Leben.
4. Wendepunkt mit "aber", "also" oder "deswegen". "und" möglichst ersetzen.
5. Faktenkette in Dreier- oder Viererschritten.
6. Eine Lebensregel, die direkt aus der Geschichte folgt. Nichts hineinkopieren.
7. Ende: positiv, Haltungssatz oder Einladung. Ein Aufruf pro Video.
   Kommentar-Aufruf mit Namen nur bei Lead-Videos.

Neugier am Anfang, Auflösung am Ende. Neugier ist nicht Verwirrung.
Hook Stacking: Jeder Satz liefert den Grund für den nächsten. So kurz wie möglich.
Rehook alle 20 bis 30 Sekunden mit Kontrastwort (aber, doch, trotzdem, und genau da).

## 4. Was die eigenen Daten nahelegen (Hinweise, keine Beweise)

Beispiel (Marcel), durch eigene Auswertung ersetzen:
- Sprech-Videos mit Geschichte bringen 3 bis 5x mehr Follower pro Reichweite als Edits.
- "ich"-Hooks liefen besser als "du"-Hooks, Fragen im Hook schwächer. Wird getestet.
- Erste Zeile trifft einen Schmerz, den jeder kennt, oder ist ein Bekenntnis.
- Spezifisch schlägt allgemein. Allgemeine Weisheiten ohne Situation floppen.
- Eine Frage am Ende bringt nicht mehr Kommentare.

## 5. Sprache und Haltung

Beispiel (Marcel), durch eigene Stimme ersetzen:
- Spricht genau eine Person an, wie ein Freund, nicht wie ein Prediger.
- Ehrlichkeit als Hebel: "um ehrlich zu sein", "ich gebe zu …".
- Typische Wörter: Plan A, ALL IN, Sidequests, Komfortzone, der Durchschnitt.
- Kontraste: "nicht … sondern …", "ich sag nicht, dass …, aber …".
Für alle:
- Kein Coach-Sprech, keine Marketingfloskeln. Konkrete Zahl schlägt Adjektiv.
- Zielgruppe deutsch und skeptisch: nichts Verkäuferisches, keine Einkommensversprechen.
- Niemanden abwerten.
- Markenbegriffe: <ERLAUBTE_BEGRIFFE>. Nie: <VERBOTENE_BEGRIFFE>.

## 6. Qualitäts-Check vor der Übergabe

- [ ] Hook in einem Satz, Thema in Sekunde 1 bis 2, Neugier ohne Verwirrung
- [ ] Länge passt zum Format, laut gelesen flüssig
- [ ] Genau eine Message, sie folgt aus der Geschichte
- [ ] Mindestens eine konkrete Zahl, jede aus der Faktenbasis oder als [Platzhalter]
- [ ] Ein Satz, in dem sich <PERSON> angreifbar macht
- [ ] "aber" oder "also" als Wendepunkt
- [ ] Positives Ende, höchstens ein Aufruf
- [ ] Passt zu Format, Account, Lernlog-Regeln und letztem Feedback
- [ ] Kein Gedankenstrich, kein Emoji im Sprechtext, kein Coach-Satz
- [ ] Ein Fremder versteht es ohne Vorwissen

## 7. Fakten

Nur aus <WISSEN>/content/Faktenbasis. Fehlt eine Zahl: [Platzhalter] setzen und
<PERSON> darauf hinweisen. Alter nie fest eintragen, sondern [Alter], bis bestätigt.

## 8. Formate (Kurzfassung, Details in den Format-Notes)

Beispiel (Marcel):
- Serie mit Tageszahl ("Das ist Tag X von Plan A"): Hook mit Bekenntnis oder Konflikt,
  nie mit Serien-Erklärung beginnen. Ehrliches Update, eine Zahl, ein Learning.
- Inspo-Liste ("Ich glaube um …"): 5 bis 7 filmbare Imperative, kein Aufruf.
- Lead-Video ("Ich suche eine Person"): fester Text, Ziel mit Bildwert, Gruppengröße,
  "ab 18", rund 20 Sekunden, ein Aufruf.

## 9. Stil-Anker

Drei eigene Skripte, die nachweislich funktioniert haben, hier wörtlich einfügen.
Vor dem Schreiben lesen, nie kopieren.
````

### 4.9 Beispiel-Prompt für den Alltag

Der Skill wird über seinen Auslöser geladen, ein freier Satz reicht. Beispiel:

```text
Schreib mir ein Skript im Format Inspo-Liste zum Thema "zu viel nachdenken".
Ich drehe morgen am Strand zur Golden Hour. Halte dich an den Skill "skript".
```

Erwartete Ausgabe: gewähltes Format in einem Satz, drei Hook-Varianten mit visueller Hook und Texthook, Skript in Zeilenform, Song, Caption, Drehzettel-Hinweis, abgehakter Qualitäts-Check.

### 4.10 Beispiel-Skripte

Alle drei sind Marcels eigene Skripte aus den Stil-Ankern, ohne Namen Dritter. Zahlen in Klammern stammen aus der älteren Skill-Fassung.

**Beispiel 1: Plan A, Tag 2** (Serien-Format, sein bestes Follower-Video: rund 482.000 Aufrufe laut Fließband, rund 360.000 laut Meta-Export, 8.996 neue Follower)

```text
(Highway to Hell)
ich gebe zu… (in cam)
ich will nicht wie der Durchschnitt enden
ich will eine Menge Geld verdienen
die gesamte Welt bereisen
die Ausdauer eines Marathonläufers
und den Körper eines Kraftsportlers haben
Das ist Tag 2 von PLAN A, mir online etwas aufzubauen, um dieses Jahr auszuwandern
aber ehrlich gesagt geht's hier um viel mehr (musik pause, in cam)
wir haben nur ein verdammtes Leben
und ich kann mich nicht mit dem Gedanken abfinden, wie der Durchschnitt zu enden
Bierbauch mit 30
unglückliche Ehe
Job, auf den man keinen Bock hat
und 100 Ausreden, keinen Sport zu machen…
Das Leben ist ein Geschenk und ich nehme es dankend an (in cam)
ich will Risiken eingehen
Erfahrungen sammeln…
Menschen kennenlernen
und ich weiß, das willst du auch, sonst würdest du das Video nicht bis hierhin schauen (in cam)
also HUHU, werd mal wach… (in cam nah)
ist der Weg, den du grade gehst, der richtige, oder machst du es nur, weil andere es von dir erwarten
ich kann dir nur die Tür zeigen (in cam)
aber durchgehen musst du selbst
```

Was man daran sieht: Bekenntnis-Hook mit „ich“, Faktenkette in Viererschritten, Wendepunkt mit „aber“, Musikpause beim Kernsatz in die Kamera, den Zuschauer erst im Mittelteil holen.

**Beispiel 2: Ich glaube um …** (Inspo-Liste, rund 327.000 Aufrufe, 4.698 Saves)

```text
Ich glaube, der größte Fehler, den wir begehen können
ist es, zu viel nachzudenken
buch den Flug
lad das Video hoch
nimm die Sidequest an
trau dich auf die Tanzfläche
sing mit
frag einfach
wir sind alle zum ersten Mal hier
und auch wenn es auf Social Media oft anders aussieht
niemand ist perfekt
geh das Risiko ein
es wird sich lohnen
versprochen
```

Was man daran sieht: fester Einstieg, filmbare Imperative (jede Zeile ein Bild), kein Talking Head, kein Aufruf, unter 80 Wörtern.

**Beispiel 3: Ich suche eine Person** (Lead-Format, die meisten Kommentare: 1.141)

```text
(Freedom)
okay, ich suche eine Person
die ein bisschen verrückt ist
gerne ihre Komfortzone verlässt
und Bock hätte, gemeinsam mit mir und 12 anderen fremden Personen
nach Kapstadt zu fliegen
geplant sind 9 Tage
wir werden eine Traumvilla haben, crazy Sidequests starten und einfach eine coole Zeit haben
also wenn du Bock darauf hast, kommentier jetzt deinen Namen
```

Das Original hatte zusätzlich „oder klick auf den Link in meiner Bio“. Heute gilt: ein Aufruf, neue Versionen mit „ab 18“, getestet wird nur „Name“ gegen „Name oder Link“. Erfahrungswert (Marcel): auf rund 500 Views kommt etwa eine Bewerbung.

Weitere Beispiele im Vault (Note „Content - Skript-Beispiele“): Vorstellung, Story-Rückblick, Es macht einfach Klick, Realtalk. Sie enthalten teils Namen aus Marcels Umfeld und werden deshalb hier nicht abgedruckt.
---

## Kapitel 5: Instagram-/Meta-Daten

### 5.1 Grundsatz

- Qualität definiert Marcel, Zahlen helfen, aber Zusammenhang ist nicht Ursache. Alte Daten liefern Hinweise und Testideen, Regeln entstehen erst aus Tests mit Zufallszuteilung (Skill marcel-lernschleife, Vault "Content - Zahlen").
- Gemessen wird immer relativ zum eigenen Account: Faktor = Aufrufe geteilt durch den Median vergleichbarer eigener Reels. Absolute Views, Likes oder der Follower-Zuwachs eines einzelnen Tages entscheiden nie allein.
- Die KI greift aus Sicherheitsgründen nicht selbst in Instagram oder die Meta Business Suite ein: keine Browser-Automation auf Instagram, kein Auslesen über eine inoffizielle Sitzung. Exporte macht der Mensch selbst, eigene Konten laufen über die offizielle API (Vault "Content - Zahlen", "Instagram-API", Skill marcel-content-regeln Abschnitt 10).

### 5.2 Datenquellen

| Quelle | Was sie liefert | Was fehlt | Wie sie ins System kommt |
|---|---|---|---|
| **Meta-Datenexport** ("Deine Informationen herunterladen", genauer Menüweg unsicher) | Alle Reels inklusive Testreels (bei Marcel 1.119 Uploads seit Dezember 2023, davon 963 bis 964 mit Insights ab Oktober 2024), Feld `media_trial` (Testreel aktiv, "graduated" ins Profil gewandert), Stories, Follower mit Folgedatum (Follower.csv), DM-Chats, Nachrichtenanfragen, eigene Kommentare, Bio-Änderungen, Konto-Insights der letzten 90 Tage | Neue Follower pro Reel, Wiedergabedauer, Skip-Rate, Reichweite vor Oktober 2024 | Marcel lädt den Export selbst herunter, die KI arbeitet nur auf der Kopie |
| **Offizielle Instagram-API mit Instagram-Login** (Team-Instagram-Abgleich) | Je Beitrag: Typ, Veröffentlichung, Profil oder Testreel (`is_shared_to_feed`), Aufrufe, Reichweite, Likes, Kommentare, Saves, Shares, durchschnittliche Wiedergabezeit, Abbruchrate (`reels_skip_rate`), Follower je Lauf | Retention-Kurven, neue Follower pro Reel; bei lizenzierter Musik kein `media_url` (also keine Frames, kein Transkript) | Stündlicher Abgleich als eigener Timer, Zeitreihe in einer Datenbank je Konto plus Dashboard |
| **Meta Business Suite** | Neue Follower pro Instagram-Reel, Zahlen von Testreels, die im Planer fehlen | | Marcel exportiert alle 2 Wochen selbst |
| **Planer Zernio** (Analytics) | Views, Likes, Kommentare, Shares, Saves für Instagram, TikTok, YouTube; für die letzten rund 100 Posts je Plattform zusätzlich Wiedergabezeit, Skip-Rate, For-You-Anteil, neue Follower | Ältere Posts | Über die Zernio-Schnittstelle, Schlüssel liegt lokal, nie in Dokumenten |
| **Retention-Kurven** | Verlauf, wer bis Sekunde X schaut | Gibt es nur in der Instagram-App, nicht in API oder Export | Bildschirmfoto aus der App, per Bilderkennung zu Punkten `[[sekunde, prozent], ...]` digitalisiert und mit `reels_retention_import` importiert |
| **Web-Insights im Browser** (nur frühe Analyse, 11.10.2026) | Neue Follower je Reel für 25 Reels, Saves, Anteil Nicht-Follower | "Geteilte Inhalte" zeigt der Browser immer als 0 | Wurde einmal lesend genutzt; heute gilt: kein KI-Zugriff auf Meta (siehe 5.1) |
| **TikTok Studio, YouTube Studio** | Alte TikTok- und YouTube-Zahlen | | In Notion jedem Video zugeordnet |

Takt des API-Abgleichs (Vault "Team-Instagram"): Profil bei jedem Lauf, Insights je Beitrag in den ersten 72 Stunden stündlich, bis Tag 14 alle 6 Stunden, danach täglich. Neue Reels werden einmalig transkribiert (ElevenLabs Scribe, höchstens 20 je Lauf und Konto, Video nur im Speicher, nie auf der Platte), Eigennamen wie "Mohana" werden danach geradegezogen.

**Einrichtung der offiziellen API für ein eigenes Konto** (Vault "Instagram-API", einmalig rund 30 Minuten, macht der Kontoinhaber selbst):
1. Instagram-Konto auf professionell umstellen (Creator oder Business), kostenlos in den Instagram-Einstellungen.
2. Mit einem Facebook-Konto bei developers.facebook.com als Entwickler registrieren. Eine Facebook-Seite ist nicht nötig.
3. App anlegen mit Anwendungsfall "Instagram-Nachrichten und -Inhalte verwalten" (Instagram-API mit Instagram-Login). Die App bleibt im Entwicklungsmodus, für das eigene Konto ist keine App-Prüfung nötig.
4. Eigenen Account in der App als Instagram Tester eintragen und die Einladung unter instagram.com/accounts/manage_access annehmen (sonst Fehler "Entwickler-Rolle nicht ausreichend").
5. API-Einrichtung mit Instagram-Login öffnen, Berechtigungen `instagram_business_basic`, `instagram_business_manage_insights` (und für Veröffentlichen `instagram_business_content_publish`), Token erzeugen.
6. Token wie ein Passwort behandeln (`<INSTAGRAM_TOKEN>` in eine `.env`, nie in Chat, Mail, Notiz). Er gilt 60 Tage; der stündliche Abgleich verlängert ihn ab Tag 7 automatisch.

Fehlerbilder: Code 190 = abgelaufene Anmeldung. `OAuthException` Code 200 "API access blocked." bei gültigem Token deutet auf ein gesperrtes Entwicklerkonto; dann zuerst in der Entwicklerkonsole das Konto bestätigen ("Account confirmation needed").

### 5.3 Aufbereitung: Tabellen und Felder

**Ablage beim Meta-Export (bei Marcel auf dem Mac):** Ordner "Instagram Analyse" mit `Tabellen/Reels.csv`, einer Gesamtdatei `reels_full.json`, einem Ordner `Transkripte/Reels/` (892 Reels per Spracherkennung abgeschrieben) und einem Arbeitsordner für Rechenskripte. Wie aus den Export-JSONs die CSV gebaut wurde, ist nicht dokumentiert (unsicher).

**Merkmalstabelle je Reel** (automatisch aus Bild und Ton gemessen): Gesichtsanteil, Sprachanteil, Musikanteil, Texthook im ersten Bild, Schnitte pro Sekunde. Daraus die Typ-Einordnung:
- Talking Head = Sprache und Gesicht in mindestens 50 % der Bilder
- Voiceover/B-Roll = Sprache, wenig Gesicht, Musikbett
- Moment = Sprache mit Live-Ton, wenig Gesicht
- Edit = Musik ohne Sprache
- dazu Stichworte im Transkript für eigene Serien ("Ich suche", "Klick", "Plan A", Vorstellung)

**Abgeleitete Felder:**
- Klasse: `test` (Testreel) oder `live` (direkt im Feed). Nie gemischt auswerten: Testreels hatten seit Dezember 2025 einen Median von rund 2.300 Aufrufen, Feed-Reels rund 13.100.
- Faktor: Aufrufe geteilt durch den Median der 20 vorherigen Reels derselben Klasse (für Altdaten), im laufenden Betrieb Views nach 48 Stunden geteilt durch den Median der Testreels der letzten 14 Tage auf derselben Plattform. Ab 3 = Winner.
- Saves, Shares, Kommentare, neue Follower jeweils pro 1.000 Aufrufe.
- Hook: Texthook im ersten Bild und erster gesprochener Satz (wörtlich aus dem Transkript).
- Wiederholung: ob dasselbe Skript schon einmal lief.

**Notion als Arbeitsdatenbank** (Content-Zentrale, vier Datenbanken):
- Videos: Abnahme Skript, Feedback Skript, Abnahme Schnitt, Feedback Schnitt, Test, Variante, Ergebnis, Faktoren
- Posts: Views, Median 14 Tage, Faktor je Plattform, Ø Wiedergabe, Ganz geschaut, Skip-Rate, For You, Neue Follower
- Tests: Frage, Variable, Variante A und B, Hauptzahl, Account, Zahl Videos je Variante, Zuteilung
- Lernlog: Learning in einem Satz, Bereich, Quelle ("Deine Änderung", "Dein Feedback", "Test"), Stand ("Hinweis" oder "Regel"), verknüpftes Video, Belege

### 5.4 Auswertungen

| Auswertung | Wann | Inhalt | Werkzeug |
|---|---|---|---|
| **Winner-Prüfung** | 48 Stunden nach jedem Testreel | Reichweiten-Winner ab 3-fachem Median; Follower-Winner (Marcelacht) ab doppelten neuen Followern pro 1.000 Views; Gesprächs-Winner (mohanatrips) ab doppelten Kommentaren und DMs pro 1.000 Views. Winner gehen in den Feed und in die Recycling-Runde, alles über Median auch auf TikTok und YouTube | Notion, Planer-Analytics |
| **Kurzreport** | bei Bedarf | Neue Reels mit Baseline-Faktor, beste und schwächste, Datenlücken | `reels_report` (Tage wählbar) |
| **Top-Liste** | bei Bedarf | Top-Reels nach Metrik mit Outlier-Faktor gegen Median der 20 vorherigen Reels derselben Klasse, Standard nur Live-Reels | `reels_top` |
| **Recycling-Report** | wöchentlich | Je Master alle Varianten mit Reach, Skip und Watchtime relativ zur Kontrolle, Median-Faktor je Trick | `reels_recycling_report` |
| **Retention-Diagnose** | 2 bis 3 Tage nach Post | Skip-Rate und Kurve gegen den eigenen Schnitt; wo die Kurve fällt, kommt im nächsten Skript ein Rehook oder Bildwechsel | Screenshot plus `reels_retention_import` |
| **Wochenbericht** | freitags | Anteil "Ohne Änderung" bei Skript- und Schnitt-Abnahme (diese Woche gegen letzte 4), neue Lernlog-Einträge, Stand der Tests, Winner der Woche und was sie gemeinsam haben (als Hinweis), ein bis zwei Vorschläge | Skill marcel-lernschleife |
| **Monatlicher Selbstcheck** | monatlich | Widersprüchliche oder veraltete Regeln finden, Daten-Regeln älter als 3 Monate gegen neue Zahlen prüfen | Skill marcel-lernschleife |
| **Große Export-Analyse** | einmalig, dann bei Bedarf | Phasen, Volumen gegen Reichweite, Follower-Modell, Trichter, Publikum, Stories, DMs, Annahmen-Check, 90-Tage-Plan | Meta-Export plus Python |

Hinweis zu den `reels_*`-Werkzeugen: Sie stammen aus einem anderen Kanal im Team und enthalten Marcels Konten nicht. Für Marcels Konten gilt der eigene API-Abgleich. Der Werkzeug-Satz `virality_predictor` (Vorhersage aus einem hochgeladenen Video) ist vorhanden, ein Einsatz im Ablauf ist nicht belegt (unsicher).

**Statistik bei Tests** (Skill marcel-lernschleife, Abschnitt 3):
- Test vor dem ersten Video anlegen, Hauptzahl vorher festlegen (bevorzugt wenig streuende Zahlen wie Skip-Rate oder Ganz geschaut), mindestens 30 Videos je Variante, höchstens 2 Tests gleichzeitig.
- Zuteilung in Paaren per `random.shuffle(["A", "B"])`, nie nach Gefühl; ausgewertet nach zugeteilter Variante, ungültig, wenn bei mehr als 20 % getauscht wurde.
- Views immer als Faktor, logarithmiert, Median je Variante, Permutationstest auf den Unterschied der Mediane (zweiseitig, p unter 0,05), Ergebnis muss in beiden Hälften des Zeitraums in dieselbe Richtung zeigen.
- Mit 30 Videos je Variante erkennt man bei Views nur große Effekte (etwa Verdopplung).

**Follower-Modell** (weil Instagram neue Follower nur pro Tag liefert): tägliche neue Follower aus Follower.csv gegen die Reichweite der Reels der Vortage, 400 Bootstrap-Läufe, gegengeprüft mit 25 Reels aus den Web-Insights. Belastbar ist nur die Richtung, nicht die genaue Höhe.

### 5.5 Was daraus gelernt wurde

Größenordnungen @marcelachtt (Stand 11.10.2026): rund 40.700 Follower, 1.119 Uploads, rund 41 Mio. Aufrufe insgesamt, 92,6 % der Follower im DACH-Raum, 39 % im Alter 18 bis 24, 15,5 % unter 18, zwei Drittel Männer. @mohanatrips lag bei rund 3.100 bis 3.200 Instagram-Followern (Suchmaschinen-Stand, unsicher); für diesen Account gibt es noch keine ausgewertete Reel-Datenbasis.

**1. Sprechen mit Ziel bringt Follower, Edits bringen Reichweite.**
- Reels, in denen Marcel spricht, bringen pro Aufruf 3- bis 5-mal so viele Follower wie Reels ohne Sprache (zwei unabhängige Rechenwege). Edits rund 0,1 Follower pro 1.000 Reichweite, gesprochene Lead-Videos rund 1,9.
- Extrembeispiele: eine Folge der Serie "Plan A" (Tageszähler, Lebensgeschichte, dasselbe Video wie Beispiel 1 in 4.10) brachte 18,7 Follower pro 1.000 (8.996 Follower auf rund 482.000 Aufrufe; der Meta-Export zählt für dieses Video nur rund 360.000 Aufrufe); ein Pool-Edit mit 2,4 Mio. Aufrufen nur 0,08 pro 1.000.
- Vlogs ohne klares Ziel bringen kaum Follower, obwohl Marcel spricht (0,3 pro 1.000). Entscheidend ist, dass klar wird, wohin die Geschichte geht.
- Ein Aufruf-Video, in dem eine andere Person spricht, brachte nur 0,6 Follower pro 1.000.

**2. Testreels finden Reichweite, aber Wenige tragen alles.**
- Seit Dezember 2025 gehen 86 % der Uploads als Testreel raus (rund 73 statt 17 Reels pro Monat). Die Reichweite pro Testreel fiel trotzdem von 4.724 (Median Dezember 2025) auf 1.307 (September 2026), der Anteil über 10.000 Konten von 32 % auf 6 %.
- 8 % der Testreels (56 ins Profil gewanderte) brachten 62 % der Reichweite.
- Wer ein Testreel sieht, reagiert heute genauso oft wie früher; gesunken ist, wie vielen Leuten Instagram es zeigt. Mehr Volumen hat den Rückgang nicht verhindert (ob es ihn verursacht hat, ist nicht bewiesen).

**3. Was je Format wirkt (Testreels seit Dezember 2025, 688 Reels).**

| Typ | Anzahl | Faktor-Median | Winner-Quote | Auffällig |
|---|---|---|---|---|
| Edit | 166 | 1,13 | 23 % | fast keine Kommentare, kaum Follower |
| Voiceover über B-Roll | 158 | 1,03 | 22 % | beste Trefferquote der gesprochenen Formate |
| Talking Head | 126 | 0,83 | 8 % | |
| Aufruf "Ich suche eine Person" | 95 | 1,01 | 17 % | 4,9 Kommentare pro 1.000 (rund 10-mal so viel wie andere) |
| Serie "Plan A" | 69 | 0,89 | 23 % | Alles-oder-nichts, aber Saves- und Follower-Rekorde |
| Moment | 58 | 0,99 | 17 % | |
| Vorstellung (mit Anlass oder im Duo) | 15 | 3,65 | 53 % | ohne Anlass schwach (Faktor 0,7 bis 0,9) |

- Saves und Shares: Monologe mit klarer Aufforderung über B-Roll holen die meisten (bis rund 24 Saves und 18 Shares pro 1.000), das Signatur-Format "Es macht einfach Klick" ist ein Save-Format (Median 9,7 Saves pro 1.000 im Feed), kein Reichweiten-Format.
- Reels, die mit Marcels Gesicht im ersten Bild starten, lagen seit Dezember 2025 bei 0,74-fach; Sprache mit wenig Gesicht 1,33-mal so gut wie gesichtslastig (n = 347 gegen 162).
- Bei Voiceovers: rund ein Schnitt pro Sekunde holte 4,2 Saves pro 1.000, ruhiger Schnitt 1,5.

**4. Gute Skripte laufen wieder.**
- Wiederholte Skripte: Faktor-Median 1,05 und 25 % Winner, neue Skripte 0,94 und 18 %.
- Drei Skripte haben sich als Serienmaterial bewiesen: der Aufruf "Ich suche eine Person" (dasselbe gesprochene Skript 49-mal hochgeladen, 12 Winner, lief auch beim 47. Mal noch mit Faktor 33,6), ein "Geh das Risiko ein"-Monolog (9 Uploads, 5 Winner), ein "Zwei Wege"-Monolog (8 Uploads, 5 Winner). Ein Duo-Vorstellungsvideo mit dem Mitgründer lief 4-mal, 4-mal Winner (Faktor 17 bis 104).
- Aber: dieselbe Datei unverändert neu hochladen bringt fast nichts. Wiederholung braucht neuen Texthook, neue Caption, neuen Schnitt, und ab der dritten Fassung desselben Takes sank die Reichweite stark: für neue Versionen neue Takes.
- Größter Recycling-Hebel: neue erste 3 Sekunden. Ein Winner läuft beim Recycling meist schwächer (Rückkehr zur Mitte), das ist kein Beweis gegen Recycling.

**5. Hooks.** Bei Marcel gewinnen "ich"-Hooks mit Bekenntnis, Thema in Sekunde 1, oft Alter plus Kontrast oder ein Zeitstempel ("Tag 2", "heute ist der Tag"). Die zehn stärksten Winner-Hooks starteten mit einer Ich-Aussage oder einem direkten Aufruf. Kurs-Regel "du-Hooks" passt zu Wissenskanälen, nicht zu Marcels Story-Kanal (bleibt Testfrage).

**6. Länge und Plattformen.**
- Instagram: kürzer bekommt mehr Reichweite, über 60 Sekunden deutlich schwächer. Saves steigen bis etwa 45 Sekunden (35 bis 45 Sekunden rund doppelt so oft gespeichert wie bis 15), Shares am höchsten bei 15 bis 25 Sekunden. Skripte ohne Formatvorgabe höchstens rund 120 Wörter.
- TikTok: Sprech-Videos mit 45 bis 60 Sekunden am besten, unter 10 Sekunden am schwächsten. 13 bis 15 Uhr am stärksten, 19 bis 21 Uhr am schwächsten.
- YouTube Shorts: über 60 Sekunden starker Abfall.
- Plattformen sagen sich kaum voraus: ein Instagram-Winner wird nur in rund einem Drittel der Fälle TikTok-Winner.
- Instagram-Uhrzeit ist für Feed-Reels fast egal; Testreels ab 19 Uhr kamen nur zu 4 % über 10.000 Konten, früher gepostete zu 13 % (Test offen).

**7. Musik.** Aus 500 eigenen Videos mit Ergebnis: mit Musik 57 % über Median, ohne 41 %. Beim Aufruf-Format mit Musik Faktor-Median 1,40, ohne 0,76. Musikpausen über 1,5 Sekunden eher schwächer (Tendenz, im Test). Tempo (BPM) ist kein belastbares Kriterium.

**8. Follower halten.**
- Von großen viralen Reels bleiben langfristig nur rund 40 bis 50 % der gewonnenen Follower (zwei virale Reels im Februar 2026: 8.207 neue Follower, später noch 3.692).
- Die Phase mit den meisten bleibenden Followern pro Reichweite war die Plan-A-Serie 2025, als normale Feed-Reels (3,0 pro 1.000 erreichte Konten); die mit den wenigsten der virale Herbst mit Edits (0,3 pro 1.000).
- Account stand im Herbst 2026 bei netto rund plus 129 in 90 Tagen (3.884 neu, 3.755 verloren). Profilbesuch zu Follow 6,6 %, zu Link-Klick 1,1 %.
- Follower brauchen regelmäßig normale Feed-Reels, nicht nur Testreels, sonst sehen sie kaum noch etwas.

**9. DMs, Stories, Kommentare.**
- Die Monate mit den meisten neuen DM-Gesprächen waren die mit konkreten Reise-Aufrufen (224 und 175 gegen 76 und 46 im Monat davor).
- Stories mit klarem Codewort ("antworte mit ...") holten 90 bis 112 Antworten, normale Stories 0 bis 5. Die erste Story des Tages bestimmt die Reichweite, jede weitere verliert 2 bis 3 %.
- Kommentare kommen über Namens-Aufrufe in Lead-Videos, nicht über eine Frage am Ende.
- In den Nachrichtenanfragen lagen viele nie angenommene Reise-Anfragen: Lead-Quelle, die regelmäßig geleert werden muss.

**10. Publikum prägt Aufrufe.** 15,5 % der Follower sind 13 bis 17 Jahre alt, deshalb steht in jedem Reise-Aufruf "ab 18".

---

## Kapitel 6: Vorbild-Profile

### 6.1 Ziel und Haltung

- Vorbilder liefern Formate (wiederholbare Muster), keine Inhalte. Formate werden in die eigene Welt übersetzt, nie 1:1 kopiert und bevorzugt aus anderen Nischen geholt. Ein 1:1 übernommener Stil eines bekannten Creators lief bei Marcel schwach (Vault "Content - Ideen und Vorbilder", "Content - Entscheidungen und No-Gos").
- Ein Format gilt erst als belegt, wenn dasselbe Muster bei zwei Accounts oder zweimal beim selben Account über dessen Baseline auftaucht (Vault "Reels - Content-Ablauf").
- Neues Format: 4 Videos posten; liegt ihr Schnitt bei mindestens dem Doppelten des eigenen Schnitts, hat es Potenzial (Kurs-Regel). 90 % bewährte Formate, 10 % Experimente (Marcel).
- Vorbilder sind nicht der Maßstab für Wirkung: "Schrift hinter der Person" nutzte keins von 17 untersuchten Vorbild-Videos, Marcel fand es trotzdem sehr gut. Ob es Reichweite bringt, entscheiden eigene Testreels.

### 6.2 Auswahl der Vorbilder (nur Kategorien)

Quellen für die Liste:
- Marcels eigene Inspirationsliste (in Notion und Vault) plus ein Ordner mit gesammelten Vorbild-Videos ("StealLikeArtist", "Inspiration" auf der Arbeitsplatte).
- Creator, deren Reels man laut eigenem Instagram-Export oft speichert oder liked.
- Beim Radar zusätzlich die eigene Following-Liste als Kandidaten (mit Bio und Followern), aus denen die Session die Nischen-Accounts auswählt.

Kategorien bei Marcel:
- Personal-Brand-Creator mit Auswanderer-, Neustart- oder "Build in Public"-Geschichte (deutsch und englisch)
- Voiceover-Vlogger mit Erkenntnis-Bogen
- Business-Creator mit Ein-Satz-Reels (5 bis 10 Sekunden)
- Humor-Accounts mit festem Themenrahmen (zum Beispiel Büroalltag)
- Serien- und Staffelformate (öffentlicher Zähler, Comedy-Miniserie)
- Plattform-Trends mit festem Satzanfang
- deutschsprachige Gruppenreise-Anbieter (Wettbewerb, für @mohanatrips)
- internationale Community- und Reiseanbieter (Bewerbungs- und Casting-Logik)

### 6.3 Werkzeuge und Ablauf

**A. Konkurrenz-Radar (Werkzeuge im gemeinsamen Team-System)**

| Schritt | Werkzeug | Was passiert |
|---|---|---|
| Beobachtungsliste pflegen | `reels_radar_accounts` (list, add, remove, following) | Accounts aktivieren oder deaktivieren (Daten bleiben), Kandidaten aus der Following-Liste per Apify holen |
| Daten holen | `reels_radar_sync` | Per Apify die letzten Reels je aktivem Account (Standard 12, höchstens 45 Tage alt), Plays, Likes, Kommentare als Snapshot. Läuft sonntags automatisch als Timer |
| Ausreißer finden | `reels_radar_top` | Reels mit Plays mindestens `min_faktor` (Standard 1,5) über dem Median des eigenen Accounts; für die Format-Recherche wurde mit 60 Tagen und Faktor 2 gearbeitet |
| Verstehen | `reels_radar_transkript` | Video kurz laden, Audio und ein Frame bei 1 Sekunde ziehen, transkribieren (Scribe); Session speichert Overlay-Text, Format-Einordnung und Notiz |

Ausreißer-Methode: Aufrufe eines Reels durch den Median seines eigenen Accounts teilen. So fallen starke kleine Accounts auf, statt dass große Accounts mit Durchschnittsinhalten dominieren. Hook, Transkript und Bild-Overlay gemeinsam ansehen, bevor ein Format abgeleitet wird. Achtung bei kleiner Basis: Ein Wettbewerber-Reel mit Basis 419 kam auf Faktor 64, der Faktor täuscht dort leicht; Basis immer mitnennen.

**B. Apify direkt (Trend-Analyse, Vault "Apify")**

- Dienst ruft öffentliche Instagram-Reels und Profile auf seinen eigenen Servern ab, ohne eigenes Instagram-Konto und ohne Login.
- Je Creator die letzten 20 bis 25 Reels mit dem Actor `apify~instagram-reel-scraper`; Profile (Follower, Bio) zum Vorsortieren mit `apify~instagram-profile-scraper` (sehr günstig).
- Ausreißer: Aufrufe geteilt durch den Median desselben Creators, nur die letzten 8 Wochen, ab etwa dem 5-Fachen interessant.
- Trend-Sound erkennen: Feld `musicInfo`; derselbe Sound bei mehreren Ausreißern = Trend-Sound.
- Ausreißer herunterladen, als Standbilder ansehen, abtippen, Schnitte per Szenenerkennung messen.
- Ergebnis je Monat ein Ordner "Trends" plus Monat mit Bauplan in der Content-Ablage.
- Kosten: Marcels Konto bleibt bewusst im Free-Plan, keine Kreditkarte hinterlegt, damit nichts über das Gratis-Guthaben hinaus berechnet wird. Abrechnung je Ergebnis (ein Reel, ein Profil, ein Kommentar). Vor jedem Lauf Verbrauch prüfen und Menge grob rechnen, ein Lauf bleibt unter 1 US-Dollar. Aktuelle Preise je Ergebnis nicht belegt (unsicher).
- Schlüssel: `<APIFY_TOKEN>` nur in einer `.env` oder im Passwortmanager, nie in Notizen.

**C. Bild-für-Bild-Messung einzelner Vorbild-Videos** (Recherche H_community, 14.10.2026: 17 Videos von 10 Vorbild- und Wettbewerber-Konten)
- Laden: über TikTok mit yt-dlp, weil die Vorbilder dort dieselben Kurzvideos posten und YouTube die Server-IP sperrt; nur-YouTube-Vorbilder im Recherche-Browser per Screenshots (ohne Ton, ohne Schnittmessung).
- Je Video gemessen: Hook-Raster 0 bis 3 Sekunden alle 0,5 Sekunden, Kontaktbögen über das ganze Video alle 0,5 bis 1 Sekunde, 30-fps-Bildstreifen für Text-Animationen, Szenenwechsel mit ffmpeg (Schwelle 0,3, bei Talking Heads zusätzlich 0,12), Lautheit nach EBU R128, Transkript mit faster-whisper, Pegel in Sprechpausen als Hinweis auf ein Musikbett, Pegelsprünge als Hinweis auf Soundeffekte.
- Grenze: Die KI kann nicht hören; Aussagen zu Musik und Soundeffekten beruhen auf Pegelverläufen und Transkript.
- Ergebnisse (Muster, keine Namen): Untertitel fast überall klein, weiß, Classic, 1 bis 3 Wörter, harter Wechsel, kein Karaoke; Motion Graphics selten und funktional (Beweis-Overlay, Foto-Karte, Infokarte, schwarze Texttafel); drei Schnitttempi (One-Take 0 bis 2 Schnitte pro 10 Sekunden, Voiceover-Montage 3 bis 6, Hype-Montage unter 20 Sekunden 9 bis 17). Was am besten lief, sah am wenigsten nach Produktion aus; die am stärksten gestaltete Fassung eines Wettbewerber-Videos lief rund 20-mal schwächer als dieselbe Geschichte nativ.

**D. Referenz-Nachbau eines einzelnen Reels** (Projektordner `todeszone-nachbau/referenz`, angelegt 16.10.2026)
- Ein englischsprachiges Monolog-Reel eines fremden Creators als Vorlage für einen Format-Nachbau: Video (`ref.mp4`), Metadaten (`ref.info.json`, Format von yt-dlp, unsicher), Ton (`ref.wav`), Transkript (`ref.srt`), 95 Einzelbilder und 6 Kontaktbögen.
- Zweck: Aufbau, Tempo und Hook-Struktur messen, dann mit eigenem Inhalt und eigener Sprache neu bauen. Ein Auftrag dazu lag noch nicht im Ordner (unsicher, wie weit das Projekt ist).

**E. YouTube-Tutorials und YouTube-Vorbilder**
- YouTube sperrt die Server-IP ("Sign in to confirm you're not a bot"). Standardweg: Skript `yt_transkript.sh` lässt yt-dlp auf dem Mac (Heim-IP) laufen, holt Untertitel und info.json zurück, macht Text mit Zeitmarken, löscht den Mac-Ordner. Mit `BOGEN=1` zusätzlich 48 Standbilder als Raster aus einer kurz geladenen 360p-Fassung, Video danach gelöscht.
- Bremsen: nur Originalsprache laden (automatische Übersetzung gab sofort HTTP 429), 6 Sekunden Pause zwischen Untertiteln, 2 Sekunden zwischen Anfragen, nach rund 35 Videos in 15 Minuten drosselt YouTube auch die Heim-IP.
- Ergebnis eines Laufs: 33 von 33 Tutorials, rund 96.000 Wörter, etwa 15 Minuten.
- Für TikTok- oder Instagram-Einzelvideos: Skript `tt_transcript.sh` lädt nur den Ton (yt-dlp), wandelt in 16 kHz mono, tippt mit whisper.cpp (Modell large-v3-turbo) ab und löscht die Audiodateien danach.

**F. Community- und Webrecherche**
- Reddit-Threads komplett über das öffentliche Archiv Arctic Shift gelesen, weil reddit.com direktes Abrufen blockt.
- Quellen gekennzeichnet: [R] Reddit gelesen, [W] Webseite gelesen, [Hersteller] Quelle verkauft selbst Schnitt-Tools, [Sekundär] zitiert jemand anderen.
- Web-Zitate, die über ein Abruf-Werkzeug mit kleinem Modell kamen, vor Veröffentlichung stichprobenartig gegenprüfen.

**G. Wettbewerbsanalyse (Gruppenreise-Anbieter)**
- Nur öffentliche Quellen: Websites, Impressum, Handelsregister und North Data, Presse, Bewertungen (Google, Trustpilot), Profilköpfe von TikTok und YouTube ohne Login, Suchmaschinen-Snippets von Instagram-Profilen.
- Jede Zahl mit URL und Abrufdatum, Schätzungen ausdrücklich als Schätzung mit Rechenweg.
- Browser nur im eigenen Recherche-Profil, nirgends angemeldet, keine Formulare an Dritte.

### 6.4 Rechtlich saubere Wege (keine Rechtsberatung, unsicher im Einzelfall)

- **Eigene Konten:** offizielle Instagram-API mit eigenem Token, Meta-Export und Business-Suite-Export macht der Kontoinhaber selbst. Retention-Kurven nur per eigenem Bildschirmfoto.
- **Fremde Konten:** nur öffentlich sichtbare Daten, über einen Scraper-Dienst wie Apify auf dessen Servern, nie über die eigene Instagram-Sitzung, nie mit Login. Keine Browser-Automation auf Instagram (Risiko für den eigenen Account).
- **Keine Login-Umgehung:** keine Cookies eines Google-Kontos für yt-dlp (laut Doku sperrt YouTube das Konto früher oder später), kein Tor, keine kostenlosen Proxies.
- **Fremde Videos nur vorübergehend:** Transkript-Skripte löschen Ton und Video nach der Auswertung. Die Praxis ist allerdings nicht einheitlich: die Apify-Note sieht Monatsordner mit Original-Reels vor, im Nachbau-Projekt liegt ein Referenzvideo dauerhaft (unsicher, was gelten soll; Empfehlung für den Nachbau: nur so lange speichern wie nötig).
- **Nicht kopieren:** Struktur, Tempo und Hook-Mechanik übernehmen, Inhalt, Wortlaut und Bilder nicht. Amerikanische Hook-Vorlagen nie wörtlich übersetzen, deutsche Zuschauer erkennen kopierte Hooks.
- **Echte Personen im eigenen Content:** Sätze oder Sprachnachrichten realer Menschen nur mit deren Einverständnis verwenden (so in den Format-Ideen vermerkt).
- **Fremde Musik und Filmszenen in eigenen Schnitten:** Welche Musik und welches Material je Konto erlaubt ist, klärt jeder selbst (keine Rechtsberatung). Plattformen können den Ton stummschalten oder Reichweite drosseln, bei Business-Konten eher; der sichere Weg für Business-Konten ist die Meta Sound Collection.

### 6.5 Grenzen

- Instagram zeigt ohne Login eine Login-Wand; Postfrequenz, Highlights und genaue Followerzahlen fremder Profile waren im Browser nicht ablesbar. Der direkte Abruf der Instagram-Webschnittstelle lieferte nur "require_login". Drittseiten wie imginn (Cloudflare) und Socialblade (403) blockten.
- Suchmaschinen-Snippets haben ein unbekanntes Indexdatum; Zahlen daraus nur als grobe Größenordnung markieren.
- TikTok zeigt die Videoliste ohne Login nicht, nur Profilkopf (Follower, Likes, Playlists).
- Medienlinks (`media_url`) und Video-URLs im Radar verfallen; bei vielen älteren Radar-Reels gab es nur noch die Caption.
- Hashtag-Abrufe bei Apify liefern vor allem Spruch-Seiten, Paare und Camper, kaum die eigene Nische: teuer im Verhältnis zum Nutzen. Ähnliche Profile liefert Apify nicht. Der Reel-Abruf enthält angepinnte alte Reels, also nach Datum filtern. Handles aus Inspirationslisten stimmen oft nicht exakt.
- Szenenerkennung bei Videos mit Kinobalken nur mit Ausschnitt der Bildmitte.
- Manche Vorbild-Accounts aus der Liste ließen sich gar nicht finden oder waren falsch zugeordnet (gleicher Name, anderes Konto).
- Inhalte, die stark laufen, aber nicht zur Positionierung passen (etwa Posing oder reine Natur-Edits), werden bewusst nicht übernommen.
- Bezahlte Vorbilder: Ein stark gelaufenes Fremdvideo war eine Marken-Kooperation (vermutlich beworben) und taugt deshalb nicht als Beleg.
---

## Kapitel 7: Schnitt

### 7.0 Grundidee in drei Sätzen

1. **Die KI macht rund 95 %, Marcel nimmt auf und prüft.** Seit 14.10.2026 schneidet die KI (Claude Code mit Skills) Short Form und Longform selbst, Marcel prüft am Ende des Tages den Ordner "1 Prüfen" und ändert direkt im CapCut-Projekt oder per Satz im Chat.
2. **Server plant, Mac rendert.** Rohmaterial liegt auf zwei externen SSDs am Mac. Die Leitung Mac zum Server ist sehr langsam (gemessen 0,03 bis 0,15 MB/s Upload vom Mac). Deshalb holt der Server nur 16-kHz-Ton, kleine Standbilder und Proxys, rechnet dort Transkript, Wortzeiten, Schnittplan, Ton und Grafiken, und der fertige Render läuft per ffmpeg auf dem Mac direkt an den Platten.
3. **Zwei Ausgaben pro Video:** ein fertig gerendertes MP4 (zum Prüfen und Posten) und, für Short Form, ein CapCut-Projekt mit echten Textebenen und Originaldateien, damit Marcel selbst nachbessern kann.

Für Johann: Wenn das Rohmaterial direkt auf dem Server liegt (oder der Upload schnell ist), entfällt die Teilung Server/Mac komplett. Alles unten läuft dann auf einer Maschine.

### 7.1 Welches Programm wofür

| Programm | Rolle | Automatisch oder Hand |
|---|---|---|
| **CapCut (Mac, Version 9.5)** | Hauptwerkzeug für Short Form. Die KI schreibt CapCut-Projekte als JSON (`draft_info.json`), Marcel öffnet und bessert nach | Projekt automatisch, Feinschliff Hand |
| **ffmpeg** | Alles Technische: Ausschnitte, Rendern, Overlays, Lautheit messen, QA (blackdetect, ebur128, Szenenerkennung) | automatisch |
| **Python-Skripte** | Schnittplan (EDL), Untertitel, Wortzeiten, Tonplan, Hautfarbe, QA-Prüfer | automatisch |
| **Remotion (4.0.535, React)** | Motion Graphics: Ortsmarken, Karten, Zähler, Kapitelkarten, Schrift hinter der Person, als transparente ProRes-4444-Ebenen | automatisch, Marcel sieht Vorschau |
| **whisper.cpp (whisper-cli)** | Transkription, Modell large-v3-turbo (q5_0), Mac mit Metal | automatisch |
| **torchaudio MMS_FA** | Erzwungene Ausrichtung: genaue Wortzeiten aus Text plus Ton | automatisch |
| **Demucs 4.1 (htdemucs)** | Stimme von Musik trennen: Musik im Clip-Ton finden, saubere Stimme für Ausrichtung und Prüfung | automatisch |
| **BiRefNet (lite-matting)** | Freistellung der Person für "Schrift hinter mir" | automatisch |
| **DaVinci Resolve, Premiere** | In den Regeln als mögliches Ziel für Projekt-Import genannt (echte Textebenen, Originaldateien). In den gelesenen Projekten kein Einsatz gefunden | (unsicher), praktisch nicht genutzt |

Ein Satz zum Warum: CapCut bleibt das Ziel, weil Marcel dort selbst schneidet und Änderungen in Sekunden macht. Rendern per ffmpeg ist der Weg, wenn das Video vollautomatisch fertig werden soll (Longform, Intros, Archiv-Reels).

### 7.2 Die Pipeline Schritt für Schritt

Jeder Schritt mit **A** (automatisch durch die KI) oder **H** (Hand, Marcel).

#### Schritt 1: Vorab alles nachschlagen (A)
Vor jedem Schnitt liest die KI ihre eigenen Regeln: Skill `marcel-content-regeln`, Skill `motion-graphics`, das Fließband (Regelwerk als Artefakt), das Lernlog (Notion), die Recherche-Zusammenfassung, das Sound-Playbook und alle Memories zum Schnitt. Im Bericht nennt sie, welche Regeln sie angewendet hat. Das ist der eigentliche Lernmechanismus: jedes Feedback von Marcel wird sofort als Regel gespeichert und beim nächsten Video gelesen.

#### Schritt 2: Material finden und Takes zuordnen (A)
- Takes aus "Neu aufgenommen" werden per Transkript dem Skript zugeordnet. Bester Take = weniger Rauschen, sauber zu Ende gesprochen. Abweichungen Skript gegen Transkript gehen ins Lernlog.
- Ton vorher als 16 kHz mono extrahieren (spart Leitung und ist das Whisper-Format).
- Für Longform: Inventar aller Clips (ffprobe), Transkript je Clip, Kontaktbögen (Standbilder im Raster), Katalog mit Zeit, Ort, Inhalt. Beispiel Honolulu: 485 Clips, 5,3 h Material.

```bash
# Ton für Whisper vorbereiten (je Clip)
ffmpeg -v error -y -i clip.mov -vn -ar 16000 -ac 1 -c:a pcm_s16le clip16k.wav
```

#### Schritt 3: Transkription mit Whisper (A)
```bash
# Satz-Transkript (JSON)
whisper-cli -m ggml-large-v3-turbo-q5_0.bin -l de -t 4 -oj -of tx/<clip> -f clip16k.wav
# Wort-Zeitstempel (ein Wort je Segment, Wortanfang/-ende)
whisper-cli -m ggml-large-v3-turbo-q5_0.bin -l de -t 4 -ml 1 -sow -oj -of tw/<clip> -f clip16k.wav
```
Wichtig: Whisper-Wortzeiten sind zu grob für Schnitte und Untertitel (Drift bis 2 s, viele Wörter mit gleicher Startzeit). Deshalb Schritt 5.

Auf dem Server gibt es zusätzlich ein Apollo-Werkzeug `whisper_transcribe` (faster-whisper, Modelle tiny bis large-v3, optional Wortzeiten). In Marcels Projekten lief Whisper aber als whisper.cpp auf dem Mac (Metal) und auf dem Server (whisper-cli liegt dort auch).

#### Schritt 4: Musik im Clip-Ton finden, Stimme trennen (A)
Viele Handyclips haben fremde Musik im Ton (Bootstour, Autofahrt mit Singen). Regel: nie Musik über Musik.
```bash
# Demucs: trennt in vocals, drums, bass, other (Standardmodell htdemucs)
demucs -o work/sep sep_in/<clip>.wav
# Ergebnis: work/sep/htdemucs/<clip>/vocals.wav usw.
```
(Die genauen Aufruf-Flags sind aus den Logs rekonstruiert, nicht aus einem Skript gelesen: (unsicher).)
Prüfung je genutztem Ausschnitt: Takt im Schlagzeug ab 0,35, Melodie-Anteil, Schlagzeug so laut wie Stimme heißt Musik. Bass allein täuscht (Wind, Motor, Stimmgrundton). Clips mit Musik: entweder stumm verwenden oder die getrennte Stimme statt des Originaltons nehmen.

#### Schritt 5: Wortzeiten per erzwungener Ausrichtung (A)
Kern der ganzen Pipeline. Text kommt aus Whisper (oder dem Skript), die Zeiten kommen aus einem Ausrichtungsmodell, das den bekannten Text auf den Ton legt. Bereinigter Auszug (`align_print.py`):

```python
# Aufruf: python align_print.py ton16k.wav <von_s> <bis_s> "Text wie gesprochen"
import sys, wave, re, numpy as np, torch, torchaudio
wav, A, B, text = sys.argv[1], float(sys.argv[2]), float(sys.argv[3]), sys.argv[4]
w = wave.open(wav); sr = w.getframerate(); w.setpos(int(A * sr))
x = torch.from_numpy(np.frombuffer(w.readframes(int((B - A) * sr)), dtype=np.int16)
                     .astype(np.float32) / 32768).unsqueeze(0)
MB = torchaudio.pipelines.MMS_FA
model, tok, al = MB.get_model(with_star=False), MB.get_tokenizer(), MB.get_aligner()
def norm(t):  # Umlaute auflösen, nur a-z
    t = t.lower().replace("ä","a").replace("ö","o").replace("ü","u").replace("ß","ss")
    return [p for p in re.split(r"[^a-z']+", t) if p]
words = [(t, norm(t)) for t in text.split()]
flat = [p for _, ps in words for p in ps]
with torch.inference_mode():
    em, _ = model(x); sp = al(em[0], tok(flat))
r = x.size(1) / em.size(1) / sr; k = 0
for t, ps in words:
    if not ps: continue
    print(f"{t}@{A + sp[k][0].start*r:.2f}-{A + sp[k+len(ps)-1][-1].end*r:.2f}"); k += len(ps)
```
Regeln aus dem Betrieb:
- Je Sprechstelle einzeln ausrichten (plus 0,4 s Rand), damit ein Fehler nicht weiterwandert.
- Ton für die Ausrichtung: die Demucs-Stimmspur, nicht das Original mit Wind und Musik.
- Abweichung über 1,2 s gegenüber Whisper verwerfen, Reihenfolge erzwingen.
- Zahlen im Text als Wort schreiben ("zwanzigern"), sonst findet das Modell sie nicht.
- Auf CPU (Server ohne GPU) reicht das völlig.

#### Schritt 6: Rohschnitt / Schnittplan (A)
Ein Python-Skript baut eine Schnittliste (EDL) als JSON: welcher Clip, Quellzeit von/bis, Spur, Layout. Regeln, die es fest einbaut:
- Tote Luft raus bis auf Frame-Ebene, Pausen auf 0,12 s Luft kürzen. Wiedereinstieg bis 0,15 s zurück in die Stille legen (Pegel unter p90 minus 20 dB), sonst fehlt der Wortanfang.
- Nie mitten im Wort schneiden. Prüfung über ein 10-ms-Pegelprofil der Stimmspur um den Schnitt (liegt der Schnitt im Tal?).
- Untertitel zuerst, dann B-Roll: jede B-Roll beginnt und endet bildgenau an einer Untertitel-Grenze.
- Kein Rest unter 0,3 s. Zwischen zwei B-Rolls ist der Sprecher gar nicht zu sehen oder mindestens 1,2 s.
- Etwa alle 3 Sekunden passiert etwas.
- Handyvideos sind oft Zusammenschnitte: nie einen Ausschnitt über einen Schnitt im Quellclip wählen (Szenenerkennung, siehe QA).
- Edits (Beat-Montagen): Bildschnitt 1 Frame vor dem Beat, Clips 2 oder 4 Schläge lang. Beats per librosa.

Für reine Talking-Head-Reels gibt es zusätzlich Apollo-Werkzeuge (gemeinsamer Server, ursprünglich für einen anderen Kanal gebaut): `reels_cut_vorschlag` (Satzliste mit Füllern, Versprechern, Pausen), `reels_rohschnitt` (von der Rohaufnahme zum Master in zwei Aufrufen: Vorlage, dann Auswahl wie `'5,1,2-9'`; entfernt Atmer und Fehlstarts, Ton auf -14 LUFS, Endprüfung per Rücktranskription), `reels_cut_render` (textfreier Master) und `reels_cut_capcut` (dasselbe als CapCut-Projekt). Marcels eigene Projekte nutzen überwiegend die eigenen Skripte (`rough.py`, `edl.py`, `bau.py`).

#### Schritt 7: Untertitel (A)
Regeln (Short Form, gelten sinngemäß auch für Longform):
- 1 bis 3 Wörter gleichzeitig, eine Zeile, nie über ein Satzende. Jede Einblendung mindestens 0,35 s, lückenlos, exakt auf dem Ton.
- Nomen groß, alles andere klein, auch am Satzanfang.
- Schrift "Classic" (CapCut), weiß, ohne Umrandung. Schatten nur sehr weich (Weichzeichnung über 90 %, Deckkraft unter 9 %). Auf heller Wand/Haut ist das kaum lesbar: dann ein weicher Abdunkler-Verlauf hinter der Zeile (Stärke 0,3 bis 0,38).
- Position eher mittig nahe den Augen, nie im Bereich der Plattform-Buttons. Im Longform auf EINER festen Höhe, nie springen, nie über einem Gesicht.
- In den letzten 3 Sekunden ohne Animation.
- Animierter Text (Hook, großes Wort) startet etwa 5 Frames (30 fps) vor dem gesprochenen Wort, Untertitel bleiben hart auf dem Ton.

Wie sie entstehen (gelernt beim Norwegen-Vlog): **nie aus den Wortzeiten des Schnittplans zusammensetzen** (dort fielen an Schnittgrenzen Wörter weg). Stattdessen den fertigen Ton ohne Musik (interne Prüfdatei) noch einmal transkribieren und nur Wörter behalten, die in einer Sprechstelle des Plans liegen. Danach als zweite Meinung Whisper auf der Demucs-Stimmspur laufen lassen und mit dem Untertiteltext vergleichen (fand Hörfehler wie falsche Wörter und einen Shot mit falschem Inhalt). Für YouTube zusätzlich eine SRT-Datei.

#### Schritt 8: Musik und Soundeffekte nach Sound-Playbook (A, Auswahl teils H)
Das Sound-Playbook ist ein eigenes Dokument mit Katalog: 201 Songs (BPM, Takt, Einstiege, ruhige Passage, Gesang, Stimmung, Rechte) und rund 1.389 Soundeffekte (vermessen, Hausauswahl für 33 Momente), dazu für 730 eigene Videos, welcher Song wo lief und wie es lief. Die KI wählt nie aus dem Gedächtnis.

```bash
cd soundeffekte/werkzeug
python3 sound_suche.py songs --format "Plan A" --unter-sprache
python3 sound_suche.py songs --gefuehl "Traurig dann Hoffnung"
python3 sound_suche.py sfx hook_impact      # Auswahl mit Vorlauf und Pegel
python3 tonplan.py schnitt.json --pruefen   # Regeln prüfen, Exit 1 bei Verstoß
python3 tonplan.py schnitt.json --ffmpeg --stimme ton.wav --out mix.wav --ausfuehren
python3 tonplan.py schnitt.json --capcut --in-spec spec.json   # Audio-Teil fürs CapCut-Projekt
```
`tonplan.py` (nur Python-Standardbibliothek) plant aus Sprechzeiten, Schnitten und markierten Momenten die ganze Tonspur. Eingabe:
```jsonc
{
 "dauer_s": 30.0, "fps": 60, "stil": "short_talking",       // short_talking | short_edit | long
 "woerter": [{"w": "heute", "s": 0.31, "e": 0.58}],          // aus der Ausrichtung
 "schnitte": [0.0, 6.0, 12.5],
 "momente": [{"t": 0.0, "art": "hook_impact"}],
 "musik": [{"song_id": "<id>", "start_im_song_s": 8.3, "von": 0.0, "bis": 30.0, "rolle": "unter_sprache"}],
 "kernsaetze": [{"von": 18.0, "bis": 21.0}],
 "atmo": [{"art": "meer", "von": 22.0, "bis": 30.0}]
}
```
Feste Werte (Playbook, Schnellkarte):
- Musik beim Sprechen rund 10 bis 11 LU unter der Stimme (-11 dB relativ), ohne Sprache rund 7 LU darunter. Ducking-Rampe 150 ms vor dem Wort runter, 300 ms danach hoch. 17 LU darunter war zu leise (Beat kaum spürbar).
- Kernsatz in die Kamera: Musik aus (100 ms Fade), sofort nach dem Satz wieder rein. Im Longform harter Stopp beim einen stärksten Satz.
- Talking Head höchstens 3 Soundeffekte pro Reel (einer im Hook), Edits höchstens 8 pro Minute. Whoosh mit der lautesten Stelle auf den Schnitt. Atmo -25 dB, J-Cut 4 bis 8 Frames vor dem Bildschnitt.
- Ende auf dem Schlag oder als Loop, nie ausblenden. Erster hörbarer Ton vor 0,5 s.
- Kein Song zweimal im Video, auch nicht zwei Stücke desselben Soundtracks mit gleicher Melodie. Song nach dem Intro bald wechseln.
- Longform/Vlog: jede Einblendung (Etikett, Karte) bekommt einen leisen Soundeffekt, Musik duckt deutlich sobald gesprochen wird.
- Rechte je Konto: Business-Konto auf Instagram nur Meta Sound Collection oder lizenzierte Musik (Epidemic), YouTube Longform keine geschützte Musik (Content ID). Bei Marcel gibt es seit 16.10.2026 nur noch eine Fassung je Video, immer mit Musik; die Rechtefrage klärt jeder für seine Konten selbst.

Hand: Trend-Audios wählt man in der App, Song-Wahl bei Unsicherheit bestätigt Marcel, Ducking-Keyframes in CapCut setzt Marcel von Hand, solange der Keyframe-Patch für `capcut_timeline.py` nicht eingespielt ist (bis dahin rechnet `tonplan.py --ffmpeg` eine fertige Musikspur mit Ducking, die in CapCut auf 0 dB liegt).

#### Schritt 9: Lautheit und Mischung (A)
Ziel: Gesamt -14 LUFS, True Peak unter -1 dBTP. Wichtig: Begrenzer auf -3,2 dBFS, wenn danach AAC kodiert wird (bei -2 dBFS kamen nach AAC -0,8 dBTP heraus).

Bereinigter Weg (aus `mix_mac.py`, `bau.py`, `tonplan.py`):
```bash
# 1) Lautheit messen
ffmpeg -nostdin -hide_banner -i stimme.wav -af ebur128=peak=sample -f null - 2>&1 | grep -E "I:|Peak"
# 2) Summe auf Ziel bringen: GAIN_DB = -14 minus gemessene Lautheit, dann sanfter Limiter
#    limit=0.69 entspricht rund -3,2 dBFS (vor AAC), attack 1 ms, release 80 ms
ffmpeg -nostdin -v error -y -i vormisch.wav \
  -af "volume=${GAIN_DB}dB,alimiter=limit=0.69:attack=1:release=80:level=0" \
  -ar 48000 -c:a pcm_s24le mix.wav
# 3) Nach dem Zusammenbau True Peak am fertigen MP4 prüfen
ffmpeg -hide_banner -nostdin -i final.mp4 -map 0:a -af ebur128=peak=true:framelog=quiet -f null - 2>&1 | sed -n '/Summary:/,$p'
```
(`limit=0.69` ist hier aus -3,2 dBFS umgerechnet; im tonplan-Code steht 0.891 = -1 dBFS für den Fall ohne AAC-Abstand.)
Im Python-Mischer (`mix_mac.py`): Stimme je Clip auf -16 LUFS (pyloudnorm), 8 ms Blenden an jedem Schnitt, Musik je Einsatz auf -12 LUFS dann -10 bis -12 dB, Höhen-Shelf -3 dB ab 3,5 kHz, in Strecken ohne Stimme 7 dB lauter. Stimme wird nie in Tonhöhe oder Tempo verändert, kein Entrauschen.

#### Schritt 10: Farbe und Hautfarbe (A)
- **Haut nie rot** (Marcels größter Kritikpunkt beim Honolulu-Longform, gilt jetzt für alle Projekte). Messung je Shot: Gesichter per OpenCV-Haar-Kaskaden (frontal und Profil), darin Hautpixel per YCrCb-Maske, Kennzahl rg = (R minus G) / R und Farbton. Ziel rg 0,26 und 13 Grad, zu rot ab rg 0,29 oder Farbton unter 6 Grad.
- Korrektur als eigene 3D-LUT je Clip, die nur Hauttöne (Mitte 8 Grad, Breite 22 Grad) Richtung Orange dreht und entsättigt; rote Shirts bleiben rot. ffmpeg `huesaturation` war zu schwach.
- iPhone-HLG (Dolby Vision) im SDR-Film: nur Farbraum umrechnen (eigene 3D-LUT, Gamma 2,4), nicht tonemappen.
- Farblooks: eigenes Skript erzeugt .cube-LUTs (Pastell, Clean, Golden, ...), in CapCut als Anpassungsebene mit etwa 50 % Stärke. Dazu LUTs aus einem gekauften Creator Bundle.

```python
# Auszug haut.py (Messung), bereinigt
faces = list(FR.detectMultiScale(g, 1.1, 6, minSize=(50, 50))) + list(PR.detectMultiScale(g, 1.1, 6, minSize=(50, 50)))
for x, y, w, h in faces:
    roi = im[y + h//5 : y + h*4//5, x + w//5 : x + w*4//5]
    ycc = cv2.cvtColor(roi, cv2.COLOR_BGR2YCrCb)
    m = (ycc[...,1] > 133) & (ycc[...,1] < 185) & (ycc[...,2] > 70) & (ycc[...,2] < 130) & (ycc[...,0] > 50)
    b, g_, r = [float(roi[..., k][m].mean()) for k in range(3)]
    rg = (r - g_) / r      # zu rot ab 0,29
```
```bash
# LUT anwenden und prüfen
ffmpeg -i standbild.jpg -vf lut3d=haut_clip07.cube out.png
```
Danach immer Standbild in voller Größe ansehen (im verkleinerten Kontaktbogen fällt Rot kaum auf).

#### Schritt 11: Motion Graphics und Text hinter der Person (A)
Remotion-Projekt mit festen Kompositionen (Ortsmarke, Kapitelkarte, Karte mit Flugroute über d3-geo und offenen Kartendaten, Zähler, Erklär-Boxen, Text-Highlight, Wochen-Intro-Bausteine). Alles transparent als ProRes 4444, damit CapCut oder ffmpeg es überlagern kann.
```bash
cd mohana-motion
npx remotion still <KompositionId> check.png --frame=30          # erst Standbild ansehen
npx remotion render Counter out.mov --props='{"from":0,"to":600,"suffix":" €"}'
node render_honolulu.mjs specs.json out/ [--force]                # Stapel-Render mit Cache
```
`render_honolulu.mjs` (Muster für Stapel): liest eine Liste `[{id, comp, props:{dur,...}}]`, bündelt einmal, rendert jede Spec als ProRes 4444 mit Alpha (`yuva444p10le`), überspringt unveränderte Specs per Hash aus Komposition, Props und Code-Stand, prüft am Ende per ffprobe Bildzahl, Alpha, Größe und fps und endet mit Exit 1 bei Fehlern. Auf einem Linux-Server ohne Desktop braucht Remotion einen eigenen Headless-Chrome-Start (kleines Wrapper-Skript, Port aus einem freigegebenen Bereich).

Stilregeln (Marcels Feedback): menschengemacht statt KI-Look. Keine Pillen, Checkboxen, UI-Karten, generische Icons. Stattdessen Schrift wie in der Instagram- oder Snapchat-App getippt (Leiste volle Breite, Schwarz 60 %, statisch) oder Handschrift/Filzstift. Höchstens 2 bis 3 Leisten pro Video, Text muss genau zum Bild passen. Easing: kurze, stark abbremsende Kurven, Federn mit damping 20 und stiffness 200. Ein animierter Moment pro Short, der Rest ruhig. Longform: viel Kontext (Ort, Uhrzeit, Kilometer, was ansteht) als Etiketten; Gesagtes und Etikett müssen übereinstimmen.

**Text hinter der Person** (kam bei Marcel sehr gut an):
1. Maske aus der sauberen Rohdatei, nie aus einem Video mit eingebrannten Texten: `freistellen.py roh.mp4 -o maske/ --birefnet-groesse 576 --jobs 8 --threads 3 --vorschau` (BiRefNet lite-matting, auf CPU rund 16 CPU-Sekunden pro Bild; RVM ist 10x schneller, lässt aber Text durch Haare schimmern).
2. Zwei transparente Remotion-Ebenen: "hinten" (zwischen Hintergrund und Person) und "vorne" (Untertitel, Texthook).
3. Höhe messen statt schätzen: Anteil jedes Buchstabens hinter dem Kopf. Gute Werte: Wort 11 bis 17 % verdeckt, Buchstabe höchstens 40 % hinter Haaren, 25 % hinter Dingen.
4. Zusammensetzen in YUV, Ton unverändert kopieren (bereinigter Kern von `compose.sh`):
```bash
ffmpeg -v error -y -i clean.mp4 -i hinten.mov -i maske.mkv -i vorne.mov -i ton.wav -filter_complex \
 "[0:v]format=yuv444p,split[bg][src];[2:v]format=gray[m];[src][m]alphamerge[person];\
  [bg][1:v]overlay=format=yuv444[b1];[b1][person]overlay=format=yuv444[b2];\
  [b2][3:v]overlay=format=yuv444[b3];[b3]format=yuv420p[v]" \
 -map "[v]" -map 4:a -c:v libx264 -preset slow -crf 15 -maxrate 22M -bufsize 44M -r 60 \
 -colorspace bt709 -color_primaries bt709 -color_trc bt709 -c:a copy -movflags +faststart out.mp4
```
Nicht einsetzen bei Handkamera mit viel Bewegung, mehreren Personen oder wenn der Kopf am oberen Rand klebt. In CapCut gibt es den Hand-Weg: Clip duplizieren, "Cut out" > "Smart brush", Text auf die untere Spur.

#### Schritt 12: Formate (A)
| Ausgabe | Format | Quelle |
|---|---|---|
| Short Form (Reels, TikTok, Shorts) | 1080x1920 (9:16), 60 fps, H.264 MP4, höchstens 25 Mbit/s, kein Wasserzeichen | Skill 8, bau.py |
| YouTube Longform/Intro | 3840x2160, 50 fps (wenn die A-Roll 4K50 liefert), x264 crf 16, höchstens 60 Mbit/s, AAC 320 kbit/s, bt709 | Skill 8b, render_mac.py |
- Hochformat zuerst: Short Form aus Hochformat-Clips. Nie seitlich drehen, Zoom höchstens etwa 1,1, nie schwarze Balken.
- Hochformat im 16:9-Film: groß über die ganze Bildhöhe auf unscharfem Hintergrund (Layout "tall"). Handy-Rahmen nur, wenn daneben eine Grafik steht (Layout "phone").
- Augen im Talking Head immer auf ähnlicher Höhe (etwa ein Drittel von oben), über Clipauswahl statt Zoom.
- Clips mit 1080p werden hochskaliert und im Bericht genannt.

Bereinigter Encoder-Block Longform (aus `render_mac.py`):
```bash
-c:v libx264 -preset fast -crf 16 -maxrate 60M -bufsize 120M -g 100 -sc_threshold 0 \
-profile:v high -pix_fmt yuv420p -color_primaries bt709 -color_trc bt709 -colorspace bt709 -color_range tv -r 50
```
Bereinigter Encoder-Block Short Form (aus `bau.py`): `-c:v libx264 -b:v 18M -maxrate 24M -bufsize 48M -preset slow -profile:v high`, 60 fps.

Render-Weg Longform: pro Shot ein ffmpeg-Aufruf (Bildrate angleichen, Layout, Push-in), Segmente per `concat`, dann ein Endlauf mit Overlay und Ton:
```bash
ffmpeg -v error -y -nostdin -f concat -safe 0 -i concat.txt -i mix.wav -map 0:v -map 1:a \
  -c:v copy -c:a aac -b:a 320k -ar 48000 -movflags +faststart ".Titel.mp4.teil"
```

#### Schritt 13: CapCut-Projekt bauen (A, danach H)
`capcut_timeline.py` schreibt ein CapCut-Projekt aus einer JSON-Spec. Es kopiert ein vorhandenes, von Hand gebautes Projekt als Vorlage und ersetzt Spuren, Texte und Audio in `draft_info.json` (plus die Spiegel-Dateien, die CapCut selbst anlegt). Zeiten in Mikrosekunden.
```jsonc
// spec.json
{ "name": "NF Titel", "fps": 60,
  "video": [{"src": "/Volumes/<Platte>/<clip>.MOV", "a": 12.40, "dur": 3.20, "scale": 1.0, "lane": 0}],
  "texts": [{"text": "heute", "t0": 0.31, "t1": 0.80, "font": "classic", "size": 9, "y": -0.2}],
  "audio": [{"src": "<song>.mp3", "a": 49.6, "t0": 0.0, "dur": 30.0, "vol": 0.28, "fade_in": 0, "fade_out": 0, "lane": 0}] }
```
```bash
python capcut_timeline.py spec.json --nicht-lokal --ziel <Arbeitsordner>/projekte
```
(Feldnamen aus dem Skriptkopf; `size` und `y` als Beispielwerte (unsicher).)
Pflicht-Regeln:
- Text als echte Textebene, nicht als gerendertes PNG/Video (Marcel will Text in CapCut ändern können). Nur was sich nicht nativ bauen lässt (Remotion-Grafiken), kommt als Mediendatei.
- Clips als Originaldateien mit In- und Out-Punkt, keine vorgeschnittenen Kopien.
- CapCut am Mac ist sandboxed und liest ohne Nachfrage nur den Ordner "Filme". Medien deshalb dort oder per Freigabe verlinkt.
- Nur schreiben, wenn CapCut geschlossen ist (`pgrep -x CapCut`), sonst überschreibt CapCut die Änderungen. Ist es offen: mit `--ziel` in einen Arbeitsordner schreiben.
- CapCut-Updates aus: CapCut 10.x meldet tool-geschriebene Projekte laut Berichten als beschädigt, 11.4 verschlüsselt sie beim Speichern. Klartext-Kopie der Vorlage sichern.
- Keyframe-Zeit für Video ist in CapCut 9.5 die Quellzeit, nicht die Segmentzeit (Fehlerquelle bei fremdem Code).
- Vor der Übergabe eine Kopie des Projekts (JSON und Meta-Dateien) als "KI-Version" ablegen. Nach Marcels Änderung wird verglichen, was er verschoben, gelöscht, gekürzt hat, und jede Änderung geht ins Lernlog.

Zur Selbstkontrolle rendert `render_spec.py spec.json vorschau.mp4` eine kleine Vorschau (540x960) der Spec, bevor man das Projekt in CapCut öffnet.

#### Schritt 14: QA vor der Ablage (A)
Gemessen per Skript, an der fertigen Datei selbst:
```bash
# Format, vollständiges Dekodieren, Schwarzbilder, doppelte Bilder, Lautheit in einem Durchlauf
ffprobe -v error -show_entries stream=codec_name,width,height,r_frame_rate,nb_frames,pix_fmt:format=duration,size,bit_rate -of json final.mp4
ffmpeg -hide_banner -nostdin -i final.mp4 -filter_complex \
 "[0:v]scale=480:270,blackdetect=d=0.1:pix_th=0.10,mpdecimate=hi=768:lo=320:frac=0.33,showinfo[v];\
  [0:a]ebur128=peak=true:framelog=quiet[a]" -map "[v]" -map "[a]" -f null - > pass.log 2>&1
# Harte Schnitte in Quellclips (Handy-Zusammenschnitte)
ffmpeg -i clip.mov -map 0:v:0 -vf "scale=240:-2,select='gt(scene\,0.3)',showinfo" -f null - 2>&1 | grep -o 'pts_time:[0-9.]*'
```
Zusätzliche eigene Prüfer (Python, je 20 bis 60 Zeilen):
- **Kinobalken-Suche** über den ganzen Film (5 Bilder/s auf 192x108 grau: oben/unten oder rechts dunkel, Mitte hell). blackdetect findet nur ganz schwarze Bilder, keine Balken.
- **Stille-Prüfung**: keine Strecke ab 0,3 s unter -55 dBFS (10-ms-Fenster).
- **Ruckeln** über Bewegung je Bild (Differenz zum Vorgänger; Wiederholung plus Sprung danach), nicht über mpdecimate-Anteile.
- **Schnitt im Wort**: Pegel der Stimmspur in 50-ms-Fenstern an jedem Schnittrand.
- **Satzanfänge**: nach jedem Schnittplan alle Satzanfänge mit dem Wort davor auflisten und lesen.
- **Rücktranskription**: geschnittenen Ausschnitt neu transkribieren und mit der Fassung mit Umfeld vergleichen (fand ein fehlendes "Das" am Satzanfang).
- **Zahlen im Ton**: Kilometer, Zeiten, Preise einzeln mit Polster transkribieren und gegen Bild prüfen (Whisper hörte "zehn" statt "sieben").
- **Kontaktbogen**: Standbilder alle 0,5 s, erste 3 s dichter, plus Lesbarkeit in voller Größe.
- **Hautfarbe** je Shot (Schritt 10).

Checkliste Short Form (Skill, Pflicht): B-Roll-Ränder auf Untertitel-Grenzen, kein Rest unter 0,3 s, Untertitel 1 bis 3 Wörter und mindestens 0,35 s, kein Schnitt im Wort, keine Musik über Musik, Augen auf gleicher Höhe, 1080p/60 fps. Dazu "frischer Blick": Ist in den ersten 3 Sekunden klar, worum es geht? Wo würde ein Fremder wischen?

Longform zusätzlich: ein **frischer Prüfer** (Subagent, der nicht mitgebaut hat) sieht Standbilder und Schnittplan gegen den Auftrag durch.

#### Schritt 15: Ablage (A) und Abnahme (H)
- Fertige Datei erst versteckt als `.Titel.mp4.teil` bauen, alles prüfen, dann umbenennen. Nie überschreiben.
- Short Form nach `FERTIG/1 Prüfen`, YouTube nach `Content/Longform`. Kopieren auf dem Mac (rclone als portables Programm oder `cp`), danach Größe und md5 vom Server aus prüfen.
- Marcel prüft am Ende des Tages. Was passt, zieht er nach "2 Bereit" (= Freigabe zum Planen).

### 7.3 Hook-Varianten und Recycling

- **Texthook** je Format, manchmal ganz weg. Hierarchie: eine kleine dünne Zeile plus EIN großes Schlüsselwort. Bild, gesprochener Satz und Texthook müssen in den ersten 3 Sekunden in dieselbe Richtung ziehen.
- **Mehrere Fassungen bei wichtigen Videos**: beim YouTube-Intro baute die KI sechs Versionen desselben Textes (Clean, Cold Open, Motion Graphics, kreativ mit Vorbild-Techniken, Masken-Übergänge, nur Captions) und Marcel wählte bzw. mischte.
- **Tests**: 5 Testreels pro Tag und Account. Ein Test ändert genau eine Variable (z. B. Kernsatz Musik aus gegen leiser), ein Los entscheidet die Zuteilung. Für Ton-Tests mit demselben Video nennt das Sound-Playbook mindestens 3 Paare; für Tests über verschiedene Videos gelten mindestens 30 Videos je Variante (8.11).
- **Recycling** frühestens 3 Wochen nach dem ersten Posting. Größter Hebel: neue erste 3 Sekunden. Dazu neue Musik (Stimme unverändert), Greenscreen, B-Roll drüber, kürzen. Immer frisch aus CapCut exportieren, keine unsichtbaren Tricks (Bildrauschen, Pixel-Filter).
- Zwei Accounts nie 1:1: anderer Texthook, andere Caption, anderer Sound.
- Werkzeug auf dem gemeinsamen Server: `reels_variante` erzeugt Kopien eines Masters mit benannten Tricks (Spiegel, Sättigung 1,15, Zoom 1,05, Tempo 1,03, kürzer, wärmer). Das stammt aus der Pipeline eines anderen Kanals; Marcels eigene Recycling-Regel lehnt unsichtbare Tricks ab, deshalb für seinen Kanal eher nicht (Einordnung: (unsicher), ob er es je genutzt hat).
- Auswertung je Wort: `reels_wortverlust` legt die Retention-Kurve auf die Wort-Zeitstempel und zeigt pro Sekunde Zuschauerverlust samt gesprochenen Wörtern (braucht Transkript und importierte Retention-Kurve). Gehört eher zu Kapitel 5/8.

### 7.4 Automatisch gegen Hand, Übersicht

| Bereich | Automatisch (KI) | Hand (Marcel) |
|---|---|---|
| Takes zuordnen, bester Take | ja | |
| Rohschnitt, Pausen, Versprecher | ja | Feinschnitt in CapCut, wenn ihm etwas nicht passt |
| Wortzeiten, Untertitel | ja (Ausrichtung, Rücktranskription) | Eigennamen/Hörfehler in der SRT überfliegen |
| B-Roll-Auswahl | ja (Aests-Ordner nach Ort, Katalog) | Wünsche per Kommentar mit Zeitstempel |
| Song und SFX | ja (Playbook, tonplan) | Trend-Audio in der App, finale Geschmacksentscheidung |
| Ducking | ja im Render; im CapCut-Projekt noch nicht | Keyframes in CapCut von Hand |
| Lautheit -14 LUFS, Limiter | ja | |
| Hautfarbe, Farbraum, LUT | ja | LUT-Stärke in CapCut |
| Motion Graphics | ja (Remotion) | einfache Kurven in CapCut selbst |
| Format, Export | ja | Export aus CapCut, wenn er dort geändert hat |
| QA | ja (Skripte plus frischer Prüfer) | Endabnahme im Ordner "1 Prüfen" |
| Aufnahme | | ja, nach Drehzettel |
---

## Kapitel 8: Veröffentlichen, Planung und Lernschleife

### 8.1 Überblick

```mermaid
flowchart TD
    A[Schnitt fertig, Qualitäts-Check bestanden] --> B["FERTIG/1 Prüfen"]
    B -->|Marcel abends: passt| C["FERTIG/2 Bereit = Freigabe"]
    B -->|Änderung| R[Marcel ändert im CapCut-Projekt oder per Satz] --> L[Lernlog]
    C --> D[KI: Caption, erster Kommentar, Texthook, Titel]
    D --> E{Doppelte prüfen je Video, Account, Plattform}
    E -->|nichts gefunden| F[In Zernio planen]
    E -->|unklar| Q[weglassen, Marcel fragen]
    F --> G[Kurze Liste an Marcel: was geht wann raus]
    G --> H[Video live]
    H --> I["Datei nach 'überall online/Themenordner'"]
    H --> J[48 h: Zahlen, Faktor, Winner-Regel]
    J -->|Winner| K["'4 Gewinner', in den Feed teilen, später Recycling"]
    J -->|Winner oder über Median| T[TikTok und YouTube als Entwurf planen]
    J --> W[Freitag: Wochenbericht]
```

### 8.2 Ablage: Prüfen, Bereit, online

Ordner auf der Content-Platte (`Content/FERTIG`), seit 14.10.2026:

| Ordner | Bedeutung | Wer verschiebt |
|---|---|---|
| `1 Prüfen` | jeder fertige Kurzvideo-Schnitt (auch YouTube Shorts), keine Extra-Vorschau-Dateien, alte Stände wegräumen | KI legt ab |
| `2 Bereit` | freigegeben, wird geplant. Was nicht hier liegt, geht nie live | Marcel zieht selbst oder sagt Bescheid, dann die KI |
| `überall online/<Themenordner>` | live, Quelle für spätere TikTok- und YouTube-Uploads. Themenordner je Format (bei Marcel z. B. Edits, ich glaube..., ich Suche eine Person, Mansion, MohanaTrip, PureMotivation, So Simpel(click), Yapping) | KI nach dem Posten |
| `4 Gewinner` | Winner, Vorrat fürs Recycling | KI |
| `Vom Handy` | Material vom Handy | (unsicher, Zweck nicht beschrieben) |

- **YouTube-Longform** (Vlogs, Intros, lange Videos) kommt nie nach FERTIG, sondern direkt in `Content/Longform`.
- **Dateiname:** Nummer aus der Videos-Tabelle, Titel, Version, z. B. `MA-12 Titel v1.mp4`. v1 ist das Original, v2 die Recycling-Fassung. Seit 16.10.2026 nur noch eine Fassung, immer mit Musik.
- **Nie verschieben:** Takes (werden in der Tabelle zugeordnet), Dateien, die in einem CapCut-Projekt vorkommen, und nichts zwischen den Platten ohne Marcels Ok. Nie „Claude“ in Datei-, Ordner- oder Projektnamen.
- **Status in der Videos-Tabelle:** Idee, Entwurf, Skript fertig, Aufgenommen, Im Schnitt, Prüfen, Bereit, Online. Skript, Hooks und Caption stehen in der Zeile und werden nie verschoben, nur der Status wechselt. Weitere Felder: „Musik im Video“ (Ja, Nein, Unklar) und „Dein Wunsch“ (Nach Regel, Gleichzeitig IG + TikTok, Nur Instagram, Nicht posten).
- **Posts-Tabelle:** eine Zeile pro Upload mit Plattform, Datum, Link, Version und Zahlen nach 48 Stunden.

Technischer Weg bei Marcel: Die Platten hängen am Mac. Der Server schreibt per `rclone copyto` über SSH auf die Platte (mit `--retries 10`, weil die Verbindung oft abbricht) und prüft danach Größe (`rclone lsl`) oder md5. Fertige Dateien erst als `.teil` bauen, prüfen, dann umbenennen. Für Atlas reicht ein beliebiger Ordner mit denselben drei Stufen, wichtig ist nur: Freigabe ist ein Ordner, kein Chat.

### 8.3 Verpacken: Caption, erster Kommentar, Texthook, Titel

Für jedes Video in `2 Bereit` schreibt die KI Caption, ersten Kommentar, Texthook und Titel, trägt sie in die Videos-Zeile ein und legt den Entwurf im Planer an. Thumbnails macht die KI einmal pro Woche.

**Captions (Fließband, Block „Captions und CTAs“):**

- Grundform: ein Hook-Satz, ein Satz, eine Aufforderung. Keine Links in Captions. Euro-Beträge erlaubt, nie mit Einkommensversprechen.
- **Persönlicher Kanal (@marcelachtt):** sehr kurz, meist unter 40 Zeichen, ein Satz, der das Video weiterdreht, höchstens 1 bis 2 Emojis, meist ohne Hashtags, kein Kommentar-Wort (das ergibt nur mit einer ManyChat-Automation Sinn). Oft ein Einzeiler mit „:)“ oder „>“.
- **Lange Caption** mit Pfeil-nach-unten-Emoji (Geschichte zum Weiterlesen) funktioniert bei erklärenden Videos: rund doppelt so viele Aufrufe wie der Schnitt (Zahlen).
- **Firmenkanal (@mohanatrips):** MOHANA kurz erklären (alleine kommen, 10 bis 14 Fremde zwischen 18 und 29, wir organisieren alles), dann ein Weg (anschreiben, Namen kommentieren oder Website), immer „ab 18“, 3 bis 5 Hashtags.
- **Erster Kommentar:** so kurz wie die Caption, oft eine Frage.
- **Ein Aufruf pro Video,** nie zwei. Formulierungen aus echten Bewerbungstexten wörtlich nutzen, dann klingt es nach der Zielgruppe.
- **Zwei Accounts nie 1:1:** anderer Texthook, andere Caption, anderer Sound.

**Keywords und Hashtags:** In den Quellen gibt es keine eigene Keyword-Strategie für Instagram oder TikTok (unsicher, ob es eine gibt). Was belegt ist: Hashtags auf dem persönlichen Kanal meist keine, auf dem Firmenkanal 3 bis 5, mehr Hashtags machten keinen großen Unterschied (Zahlen). YouTube-Titel schreibt die KI „kurz und so, wie jemand danach suchen würde“. Im Hook gilt: Schlüsselwort früh.

### 8.4 Was wohin geht

**Accounts, Ziele, Mengen (Stand Fließband):**

| Account | Ziel | Menge | Wichtigste Zahl |
|---|---|---|---|
| Instagram persönlich | qualitative Follower über die eigene Story | 5 Testreels plus 1 Reel oder Beitrag pro Tag | Follower |
| Instagram Firma | Buchungen, Ängste lösen, Reisen erklären | 5 Testreels pro Tag, in den Feed nur Winner | DMs und Kommentare |
| TikTok persönlich | wie Instagram | Winner, über Median, Serien-Folgen, Momente, bis 5 am Tag | Follower |
| TikTok Firma | Reisen zeigen | „einfach alles“ | Kommentare |
| YouTube Shorts | Reichweite | Winner und über Median, freie Slots auffüllen, bis 4 am Tag, nur Hochformat | Views |

Wochenmix als Vorschlag der KI: persönlich 42 pro Woche (15 Sprech-Videos, 10 Voiceover mit B-Roll, 10 Recycling, 7 Feed), Firma 35 pro Woche (15 Edits aus Trip-Material, 10 Lead- und Host-Videos, 10 Recycling).

**Regeln je Videoart:**

- **Normales Video:** Instagram als Testreel. TikTok und YouTube nach 48 Stunden, wenn Winner oder über Median.
- **Serien-Folge, Moment, Ankündigung, Collab:** Instagram direkt in den Feed, TikTok am selben Tag, YouTube nach 48 Stunden, wenn Winner oder über Median.
- **Unter Median:** bleibt Testreel, nicht auf TikTok, auf YouTube nur in freie Slots, höchstens einmal mit neuem Hook neu testen.
- **Freie YouTube-Slots** auch mit Videos unter Median füllen. Grund: Das Instagram-Ergebnis sagt für YouTube kaum etwas voraus (Auswahl-Falle).
- Marcel überstimmt mit dem Feld „Dein Wunsch“.
- **Testreel-Winner** teilt Marcel nach 48 Stunden selbst in der Instagram-App an seine Follower.

**Posting-Zeiten (deutsche Zeit):** TikTok 7:30, 12:00, 14:00, 16:00, 21:30 (14 statt 19 Uhr, weil 19 bis 21 Uhr auf TikTok am schwächsten lief). YouTube Shorts 8:00, 13:00, 17:30, 20:30. Bei weniger Videos TikTok zuerst 14:00 und 12:00, YouTube zuerst abends. Nach 4 Wochen passt die KI die Zeiten an die besten Zeiten aus Zernio an. Auf Instagram ist die Uhrzeit für Feed-Reels egal (Testreels ab 19 Uhr kamen seltener auf hohe Reichweite, offen).

**Hochfahren:** über die Schnittstelle langsam steigern, erste Woche 3, zweite Woche 4, ab der dritten 5 Testreels pro Tag und Account.

### 8.5 Planung über Zernio

- **Zernio** ist der Planer (vorher Metricool). Uploads laufen nur darüber, nie per Browser-Automation auf Instagram. Account-Sicherheit geht vor: keine ungewöhnlichen Aktivitäten, keine Automation in der App.
- **Zugriff:** bei Marcel ein kleines Python-Skript auf dem Mac, das die Zernio-API anspricht. Der Schlüssel liegt in einer eigenen Datei und wird nie ausgegeben. Für Atlas: `ZERNIO_API_KEY=<API_KEY>` in eine `.env`, die in `.gitignore` steht.
- **Zeitzone:** Zernio läuft bei Marcel auf einer anderen Zeitzone als Deutschland (eine Stunde später). Zeiten immer umrechnen. Für Johann: die Zeitzone des Zernio-Kontos prüfen.
- **Verbundene Accounts:** vor jeder Planung prüfen, welche Accounts im Planer verbunden sind, nur für diese planen. Verbinden muss der Kontoinhaber selbst (Login), am besten Instagram über Facebook. Stand 16.10.2026 ist der Firmenaccount noch nicht verbunden.
- **Instagram-Musik** setzt die KI im Planer über die Audio-Suche, das geht nur, wenn Instagram über Facebook verbunden ist. Sonst kommt der Song im Schnitt drauf. Auf TikTok und YouTube gibt es Instagram-Musik nicht, Edits, die von einem Instagram-Sound leben, bekommen dort einen freien Song.
- **Jede Plattform bekommt die Originaldatei,** nie mit Wasserzeichen, nie aus WhatsApp.
- **Nach dem Planen:** Marcel bekommt eine kurze Liste, was wann rausgeht (nur zur Info, die Freigabe war das Verschieben nach Bereit).

### 8.6 Doppelte prüfen (vor JEDEM Einplanen)

Marcel, 15.10.2026: „jedes mal wenn du über zernio etwas einplanen willst musst du erst prüfen ob das schon hochgeladen wurde auf dem account und der plattform“. Anlass: Ein anderer Chat hatte den Bereit-Ordner schon für eine Woche eingeplant, ein zweiter Plan hätte alles doppelt angelegt.

Ablauf pro Video, Account und Plattform:

1. Alle Zernio-Posts ziehen: `GET /v1/posts`, alle Seiten, jeder Status (veröffentlicht, geplant, Entwurf, fehlgeschlagen).
2. Die echten Posts des Accounts dazunehmen (Zernio-Analytics, für Instagram zusätzlich der eigene Instagram-Abgleich, 8.8).
3. Abgleichen über Video-Nummer, Dateiname oder Medien-Link, Caption, Titel, im Zweifel den ersten Satz des Transkripts.
4. Nur wenn nichts passt: einplanen. Unklares weglassen und nachfragen.
5. Einzige Ausnahme: bewusstes Recycling (v2), frühestens 3 Wochen nach dem Original, mit neuem Hook.

Gilt für jeden Weg (Skript, Planungs-Lauf, anderer Chat). Wie die Seitenparameter der Zernio-API heißen, steht nicht in den Quellen (unsicher).

### 8.7 Nach dem Posten

- Datei nach `überall online/<Themenordner>` verschieben, Status „Online“.
- **48 Stunden nach jedem Testreel:** Zahlen in die Posts-Tabelle, Faktor und Ergebnis nach der Winner-Regel, dann TikTok und YouTube nach den Regeln aus 8.4 als Entwurf planen und Marcel die Liste „Heute teilen“ schicken.
- **Winner-Regel** (48 Stunden, gegen den Median der Testreels desselben Accounts aus den letzten 14 Tagen):
  1. Reichweiten-Winner: mindestens 3-mal so viele Views wie der Median.
  2. Follower-Winner (persönlich): mindestens doppelt so viele neue Follower pro 1.000 Views.
  3. Gesprächs-Winner (Firma): mindestens doppelt so viele Kommentare und DMs pro 1.000 Views.
  Sonst „Über Median“ oder „Unter Median“. Winner gehen in den Feed und nach `4 Gewinner`. Auf YouTube zählt nach 3 Tagen der YouTube-Faktor, ab 3 ist es ein YouTube-Winner.

### 8.8 Auswertung: welche Zahlen, woher

**Welche Zahlen zählen:**

- Persönlich: 1. neue Follower pro 1.000 Views, 2. Saves und Shares pro 1.000, 3. „Ganz geschaut“ und Wiedergabedauer (misst Hook und Schnitt am direktesten), 4. Faktor Views.
- Firma: 1. Kommentare und DMs pro 1.000, 2. Bewerbungen mit Quelle (dafür muss das Bewerbungsformular „Wie hast du von uns erfahren?“ fragen, Stand: fehlt noch), 3. Faktor Views.
- Für die KI selbst: Anteil „Ohne Änderung“ bei Abnahme Skript und Schnitt.
- Nie allein entscheiden lassen: Likes, absolute Views, Follower-Zuwachs eines Tages ohne Zuordnung.

**Faktor:** Views geteilt durch den Median der letzten 14 Tage desselben Accounts auf derselben Plattform. Faktor 1 ist normal, ab 3 Winner.

**Quellen der Zahlen:**

- **Zernio:** Views, Likes, Kommentare, Shares, Saves auf Instagram, TikTok, YouTube. Für die letzten rund 100 Posts pro Plattform zusätzlich Wiedergabezeit, Skip-Rate, For-You-Anteil und neue Follower.
- **Neue Follower pro Instagram-Reel** gibt Instagram an keinen Planer weiter. Marcel exportiert sie alle 2 Wochen selbst aus der Meta Business Suite, die KI erinnert am 1. und 15. Die KI greift nie selbst auf Meta zu.
- **Instagram-Abgleich des Teams:** ein stündlicher Lauf über die offizielle Instagram-API mit Token je Konto (eingerichtet vom Kontoinhaber). Er holt Profil und Insights je Beitrag (in den ersten 72 Stunden stündlich, bis Tag 14 alle 6 Stunden, danach täglich), transkribiert neue Reels einmal und baut ein passwortgeschütztes Dashboard je Konto. Wie diese Daten in die Posts-Tabelle fließen, steht nicht in den Quellen (unsicher).
- **Alte Videos:** Instagram aus dem Meta-Datenexport, TikTok und YouTube aus deren Studios.

**Daten richtig lesen:** Zusammen heißt nicht deswegen. Immer Median statt Durchschnitt, weil ein Hit alles verzerrt. Follower pro Format sind nur geschätzt, weil Instagram Follower pro Tag liefert, nicht pro Reel. Die Insights im Browser zeigen „Geteilte Inhalte“ immer als 0, Teilen ist nur auf dem Handy sauber sichtbar. Ordnet die KI Reels nach Format oder Hook ein, stichprobenartig prüfen.

### 8.9 Wochenbericht (Freitag) und Monatscheck

Kurz, Deutsch, Du-Form, keine Gedankenstriche, Marcel muss nur lesen:

1. Anteil „Ohne Änderung“ Skript und Schnitt, diese Woche gegen die letzten 4 Wochen.
2. Neue Lernlog-Einträge und welche zu Regeln wurden.
3. Stand der Tests (Videos pro Variante, keine Entscheidung vor dem Ziel).
4. Winner der Woche und was sie gemeinsam haben, als Hinweis, nicht als Beweis: welche B-Roll, Songs, Hooks, Formate.
5. Ein bis zwei konkrete Vorschläge für nächste Woche.

Entscheidungen, die wirklich Marcels sind, kommen als Klick-Frage mit Empfehlung. Dazu jede Woche ein Team-Weekly mit Wins, Zahlen und Plan.

**Jeden Monat:** Selbstcheck, ob sich Regeln widersprechen oder veraltet sind (Ergebnis in der Note „Entscheidungen und No-Gos“), Daten-Regeln älter als 3 Monate gegen neue Zahlen prüfen.

### 8.10 Recycling (kurz)

Einmal pro Woche aus `4 Gewinner`, frühestens 3 Wochen nach dem ersten Posting, wieder als Testreel, mit dem Original verknüpft. Größter Hebel: neue erste 3 Sekunden. Immer frisch exportieren, nie die alte Datei oder einen Instagram-Download. Keine unsichtbaren Tricks (Bildrauschen, Pixel-Filter). Unverändert neu hochladen bringt fast nichts, und ein Take, der viermal lief, verlor ab der dritten Version stark: für neue Versionen neue Takes.

### 8.11 Lernschleife: wie Feedback in Regeln zurückfließt

#### Prinzip

Qualität definiert Marcel, Zahlen helfen, aber Zusammenhang ist nicht Ursache. Marcel macht pro Video nur zwei Klicks (Abnahme Skript, Abnahme Schnitt) und auf Wunsch einen Satz Feedback. Den Rest holt sich die KI selbst, indem sie ihre Fassung mit seiner vergleicht.

```mermaid
flowchart LR
    A[KI-Skript / KI-Schnitt] --> B[Marcel nimmt auf / prüft]
    B --> C[Vergleich: Skript gegen Whisper-Transkript, KI-Projekt gegen Marcels Projekt]
    B --> D[Satz Feedback im Chat oder in der Tabelle]
    C --> E[Lernlog-Eintrag, Stand Hinweis]
    D --> E
    E -->|Marcel sagt es klar| F[sofort Regel in der Content-Note]
    E -->|Muster wiederholt sich oder Test zeigt es| G[Wochenbericht: Klick-Frage]
    G -->|Ok| F
    F --> A
```

#### Schritte nach jeder Prüfung

1. Abnahme und Feedback aus der Videos-Tabelle lesen.
2. **Skript:** KI-Skript gegen das Whisper-Transkript der Takes vergleichen: Wörter, Reihenfolge, Hook, Ende, gestrichene oder neue Sätze. Versprecher ignorieren.
3. **Schnitt:** Vor der Übergabe legt die KI eine Kopie ihres CapCut-Projekts (die Projektdatei plus Meta-Dateien) in einen Ordner `KI-Versionen/<Nummer>/`. Nach Marcels Prüfung vergleicht sie sein Projekt damit: Schnittpunkte, gelöschte oder verschobene Clips, Länge, Untertitel (Text, Timing, Position, Schrift), Musik (Song, Lautstärke, Pausen), B-Roll, Zooms, Texthook. Ist die Projektdatei nach einem CapCut-Update verschlüsselt, läuft der Vergleich über Export-Frames und Feedback.
4. **Jede klare Änderung wird ein Lernlog-Eintrag** mit diesen Feldern:

| Feld | Inhalt |
|---|---|
| Learning | ein Satz |
| Bereich | Skript, Hook, Schnitt, Untertitel, Musik, Upload |
| Quelle | „Deine Änderung“, „Dein Feedback“ oder „Test“ |
| Stand | Hinweis oder Regel |
| Im Fließband | Haken, sobald die Regel eingetragen ist |
| Video | Verknüpfung |
| Belege | was genau geändert wurde |

5. **Hinweis wird Regel:** Einmal ist ein Hinweis. Sagt Marcel etwas klar, wird es sofort Regel. Wiederholt sich ein Muster oder zeigt es ein Test, schlägt die KI die Regel im Wochenbericht als Klick-Frage vor und trägt sie erst nach seinem Ok ein, dann Stand „Regel“.
6. **Widerspruch:** Widerspricht eine Korrektur einer bestehenden Regel, überschreibt die KI nichts still, sondern fragt kurz, welche gilt.

#### Wohin eine Regel geschrieben wird

- In die passende **Content-Note** im Vault (Quelle der Wahrheit), nie in den Skill. Der Skill wird nur angefasst, wenn sich Auslöser, eiserne Regeln oder Ablauf ändern.
- Einzelne Videos, Posts, Tests und Lernlog-Einträge bleiben als Arbeitsdaten in der Datenbank (bei Marcel Notion, „Content-Zentrale“).
- Früher stand alles im Artefakt „Ford Fließband“. Wer dort eine Regel einträgt, liest das Artefakt vorher frisch (andere Sitzungen ändern es auch), ändert nur die betroffene Stelle und veröffentlicht unter derselben URL mit Datum.
- **Alles sofort speichern:** Seit 14. und 15.10.2026 gilt, dass die KI alles, was Marcel zu Content sagt (auch Nebensätze), und alles, was sie selbst über Content lernt (Recherchen, Tutorials), sofort dauerhaft speichert, ohne dass er „merk dir“ sagen muss. Nur im Chat-Gedächtnis reicht nicht, es muss an die Stelle, die beim nächsten Auftrag sicher geladen wird.
- **Vor jedem Auftrag alles nachschlagen:** Skills, Notes, Lernlog, letztes Feedback, Recherche, Memories, dann pro Video entscheiden, was passt, und im Bericht nennen, was angewendet wurde.

#### Woran man sieht, dass die KI besser wird

Anteil „Ohne Änderung“ pro Woche, getrennt für Skript und Schnitt. Er zählt nur, wenn auch der Vergleich (Transkript, CapCut-Projekt) keine Änderung zeigt. Er steht im Wochenbericht und soll Woche für Woche steigen.

#### Tests: Ursachen statt Zusammenhänge

Alte Daten zeigen nur, was zusammen auftritt (Sprech-Videos sind oft länger, Trip-Videos haben schönere Bilder, die Reichweite fiel 2026 allgemein). Daraus wird nie eine Regel, nur ein Hinweis und eine Testidee.

1. Test-Eintrag anlegen, bevor das erste Video entsteht: Frage, Variable, Variante A, Variante B, **Hauptzahl** (vorher fest, danach nie wechseln), Account, feste Zahl Videos pro Variante (mindestens 30). Hauptzahlen mit wenig Streuung bevorzugen (Skip-Rate, Ganz geschaut). Mit Views erkennt man bei 30 pro Variante nur große Effekte (etwa doppelt so viel).
2. Beide Varianten müssen für Marcel okay sein. Ein Test darf die Qualität nicht senken.
3. Beide gleich sorgfältig fertig machen, dann in Paaren losen (zwei Videos desselben Formats, bei Uhrzeiten zwei Videos desselben Tages). Ausgewertet wird nach der **zugeteilten** Variante. Ändert Marcel bei mehr als 20 % die Variante, ist der Test ungültig.
4. Höchstens 2 Tests gleichzeitig. Nicht vorzeitig entscheiden, nie verlängern, weil es knapp ist.
5. Auswertung: bei Views der Faktor als Logarithmus, Median je Variante, Permutationstest auf den Unterschied der Mediane, zweiseitig, Entscheidung bei p unter 0,05, bei Tages-Paaren wird innerhalb der Paare getauscht. Zusätzlich muss das Ergebnis in beiden Hälften des Zeitraums in dieselbe Richtung zeigen. Effekt mit Spanne angeben, wenn möglich auf einer zweiten Plattform gegenprüfen.
6. Entscheidung: A wird Regel, B wird Regel oder „Kein klarer Unterschied“ (heißt nicht „kein Effekt“). Lernlog-Eintrag mit Quelle „Test“, Note nach Ok anpassen.

Laufende und geplante Tests bei Marcel: Hook „ich“ gegen „du“ (Skip-Rate), TikTok 14 Uhr gegen 21:30 (Faktor Views, rund 8 Wochen, Münzwurf je Tag), Ende Haltungssatz gegen „folg mir“ (Follower pro 1.000), Musikpause beim Kernsatz (Ganz geschaut), Gleichzeitig Instagram und TikTok gegen nach Instagram (6 Wochen), „Ich suche“ mit Name gegen Name oder Link.

Eigene Skizze für Atlas, so nicht in Marcels Quellen, nur als Startpunkt für die Auswertung nach Punkt 5:

```python
import math, random, statistics

def permutationstest(a, b, runden=10000, seed=1):
    """a, b: Faktoren (Views / 14-Tage-Median) je Video der zugeteilten Variante."""
    la = [math.log(x) for x in a]
    lb = [math.log(x) for x in b]
    beob = statistics.median(la) - statistics.median(lb)
    alle = la + lb
    rnd = random.Random(seed)
    treffer = 0
    for _ in range(runden):
        rnd.shuffle(alle)
        d = statistics.median(alle[:len(la)]) - statistics.median(alle[len(la):])
        if abs(d) >= abs(beob):
            treffer += 1
    return beob, treffer / runden  # Unterschied der Log-Mediane, p-Wert zweiseitig
```

Für Paare pro Tag wird nicht frei gemischt, sondern innerhalb jedes Paares zufällig getauscht (siehe Punkt 5).

#### Fallen der Lernschleife

- **Auswahl-Falle:** Auf TikTok und YouTube landen vor allem Instagram-Winner, deren Zahlen gelten nicht für alle Videos.
- **Rückkehr zur Mitte:** Winner laufen beim Recycling meist schwächer, kein Beweis gegen Recycling.
- **Ein Hit verzerrt den Durchschnitt:** immer Median.
- **Viele Zahlen, ein Zufallstreffer:** wer 20 Zahlen anschaut, findet immer eine, die passt. Nur die Hauptzahl entscheidet.
- **Regeln altern:** jede Regel aus Daten bekommt ein Datum und wird alle 3 Monate geprüft.

---

## Kapitel 9: Werkzeuge, Dienste, Kosten, Hardware

### 9.1 Software, Dienste, Modelle

| Werkzeug | Zweck | Ungefähre Kosten/Monat | Quelle |
|---|---|---|---|
| Claude Code (eigenes Claude-Konto) | Die KI selbst: plant, schreibt Skripte, steuert alles | Abo, Höhe für Marcel nicht belegt (unsicher, Max-Tarife liegen laut Listenpreis bei etwa 100 bis 200 $) | CLAUDE.md (eigenes Konto); Preis (unsicher) |
| CapCut (Mac, 9.5) | Schnitt-App, Projekte als JSON | kostenlos; Pro-Effekte erzwingen beim Export CapCut Pro, Preis (unsicher, etwa 8 bis 10 € laut Listenpreis) | C_tools.md (Pro/VIP-Flag); Preis (unsicher) |
| ffmpeg 6.1.1 (Server), Homebrew-ffmpeg (Mac) | Render, Messung, QA | 0 € | `ffmpeg -version` |
| whisper.cpp (whisper-cli), Modell large-v3-turbo q5_0 | Transkription | 0 € | job_tx.sh, ~/.cache/whisper-cpp |
| faster-whisper (Apollo-Werkzeug whisper_transcribe) | Transkription per Werkzeugaufruf | 0 € (läuft auf dem Server) | Werkzeugbeschreibung |
| torchaudio MMS_FA (torch 2.14 CPU) | Erzwungene Ausrichtung, Wortzeiten | 0 € | align.py, pip list |
| Demucs 4.1.0 (htdemucs) | Stimme/Musik trennen | 0 € | pip list, Logs |
| BiRefNet lite-matting, Robust Video Matting | Freistellung (Schrift hinter Person) | 0 € (MIT bzw. GPL-3.0) | freistellen.py |
| OpenCV 5, numpy, scipy, pyloudnorm 0.2, soundfile, PIL, librosa | Hautfarbe, Pegel, Beats, Kontaktbögen | 0 € | pip list, Skripte |
| Node 22 plus Remotion 4.0.535 (React 19, d3-geo, world-atlas, roughjs) | Motion Graphics | 0 € bis 3 Personen; ab 4 Personen 25 $ pro Sitz und Monat | C_tools.md, Vault-Note Remotion |
| Python 3.12 (Server), Python 3.9 plus venv (Mac) | Skripte | 0 € | `python3 --version`, Memory |
| rclone 1.75 | Kopieren auf die Platten, Drive-Spiegel, Größen- und md5-Prüfung | 0 € | `rclone version` |
| yt-dlp, youtube_transcript_api | Vorbild-Videos und Transkripte (über den Mac, weil der Server bei YouTube gesperrt ist) | 0 € | venv, Skill motion-graphics |
| Epidemic Sound | Lizenzierte Musik und SFX | Creator 10,99 €/Monat (131,88 €/Jahr, 1 Kanal je Plattform), Pro 16,99 €/Monat (203,88 €/Jahr, 3 Kanäle je Plattform, Werbung). Welcher Tarif aktiv ist: (unsicher) | Sound-Playbook, K_sound_design.md (Preisseite 15.10.2026) |
| FOUR Editors Creator Bundle | 13 Soundeffekt-Ordner, Overlays, LUTs, Lightroom-Presets | Einmalkauf, Preis (unsicher). Lizenz auf den Käufer, keine Weitergabe an Dritte | soundeffekte/README, So nutzt du das.md |
| Meta Sound Collection, YouTube-Audiomediathek, Mixkit, Pexels | Freie Musik/SFX/Stock | 0 € | Playbook, Week-Intro-Bericht |
| Notion | Lernlog, Video-Tabelle (Status, Feedback, Tests) | Tarif (unsicher) | Skill marcel-content-regeln |
| Zernio | Planer für Upload auf Instagram, TikTok, YouTube | Tarif (unsicher) | Skill, Vault-Note Upload |
| Higgsfield (Apollo-Werkzeuge generate_image/video/audio, upscale_video) | KI-Bilder, KI-Video, Sprache, Video-Upscaling (ByteDance oder Topaz) | Credit-basiert, Höhe (unsicher). Für Marcels Schnitte laut Skill nicht eingerichtet, keine KI-Bilder von Orten oder Personen in Longform | Werkzeugbeschreibungen, Skill motion-graphics |
| Apollo-Werkzeuge reels_* | Rohschnitt, Master, CapCut-Export, Varianten, Wortverlust-Auswertung | Teil des gemeinsamen Servers | Werkzeugbeschreibungen |

Grob zusammengefasst: Die gesamte Schnitt-Pipeline läuft auf freier Software. Laufende Kosten entstehen durch das Claude-Abo, Musiklizenz (Epidemic), den Planer (Zernio), optional CapCut Pro und Notion sowie den Server. Eine belegte Gesamtsumme gibt es nicht (unsicher).

### 9.2 Hardware

| Gerät | Daten | Rolle | Quelle |
|---|---|---|---|
| Server (Linux) | 12-Kern-CPU, rund 128 GB RAM, **keine GPU** | Planen, Transkript, Ausrichtung, Demucs, Freistellung, Remotion-Render, Ton, QA. Alles läuft auf CPU | `nproc`, `free`, `df`, `lscpu`, `nvidia-smi` fehlt |
| Mac (Apple Silicon, Modell (unsicher)) | Homebrew unter /opt/homebrew, whisper.cpp mit Metal, ffmpeg mit videotoolbox; interne Platte war zu 91 % voll | Endrender direkt an den Platten, CapCut, Transkription mit Metal | Skripte, Memory |
| **Marcels T7** (rund 1 TB, exFAT) | Arbeitsplatte: `Content/FERTIG` (1 Prüfen, 2 Bereit, überall online, 4 Gewinner), Aests (ästhetische B-Roll je Ort), AHandyVideos nach Themen, Longform, Testimonials, Schnitt-Bausteine | Ablage fertiger Schnitte, B-Roll | Memory zwei-festplatten, Skill Abschnitt 2 |
| **Marcels2TB7** (rund 2 TB, exFAT) | Rohmaterial nach Datum `JJJJ_MM_Reise`, YOUTUBE, RAW, Pics; `weiteres/` mit CapCut-Arbeitsordnern und Drive-Spiegel | Rohmaterial-Archiv, alle Arbeits- und Cache-Ordner | Memory zwei-festplatten, content-nur-auf-festplatten |
| Kameras | iPhone (HLG/Dolby Vision, Hochformat), Sony-Kamera (4K50 A-Roll), Drohne (25/30 fps) | Aufnahme | Week-Intro-Bericht, Memory |

Hinweise zur Hardware:
- Eine neue, größere Platte ist geplant; dann soll alles Material auf einer Platte liegen (Umzug am 15.10.2026 verschoben).
- Content (Videos, Proxys, Render-Cache, CapCut-Medien) nur auf den externen Platten, nie auf der internen Mac-Platte. Dokumente und Skripte dürfen auf den Mac.
- Die Platten sind vom Server aus nur über ein Netzlaufwerk erreichbar, das hängt, wenn der Mac schläft; lange Läufe auf dem Mac mit `nohup caffeinate -i`.
- Ohne GPU dauert Freistellung lange (604 Bilder in rund 11 Minuten bei 576 px, bei Last deutlich mehr). Mit GPU (bei Johann auf Hetzner optional) wären Demucs, Matting und Whisper schneller (unsicher, nicht gemessen).
---

## Kapitel 10: Aufbau-Reihenfolge

Die Reihenfolge folgt dem Hebel: zuerst, was sofort bessere Videos bringt (Skripte, Ablage, Daten), dann die Schnitt-Automatik, zuletzt die Kür. Zeiten sind Schätzungen für eine Person mit Claude Code, die Whisper schon laufen hat, und keine Messung (unsicher). Schwierigkeit 1 = einfach, 5 = schwer.

| # | Baustein | Was dabei entsteht | Zeit | Schwierigkeit | Siehe |
|---|---|---|---|---|---|
| 1 | **Arbeitsweise und Wissensablage** | Ordner für Notes (eine Note je Thema), Skills als Hüllen, Auftragsdatei je Projekt mit Abnahmekriterien, Herkunfts-Labels | 2 bis 4 h | 1 | 1.3, 1.4 |
| 2 | **Ablage und Freigabe** | Ordner `1 Prüfen`, `2 Bereit`, `überall online/<Thema>`, `4 Gewinner`; Rohmaterial nach `JJJJ_MM_Ort`; Regel: Content nie auf die Systemplatte | 1 bis 2 h | 1 | 2.3, 8.2 |
| 3 | **Faktenbasis und Skript-Skill** | Zeitleiste der eigenen Geschichte, Wortliste aus alten Transkripten, 3 Stil-Anker, Hook-Note, Qualitäts-Check, Skill aus 4.8 | 1 bis 2 Tage | 2 | 4 |
| 4 | **Content-Datenbank** | Tabellen Videos, Posts, Tests, Lernlog mit den Feldern aus 5.3 und 8.2 | 2 bis 4 h | 2 | 5.3, 8.2 |
| 5 | **Meta-Export auswerten** | Reels-Tabelle, Klassen Testreel und Feed getrennt, Faktor gegen Median, Format-Einordnung, erste Hinweise und Testideen | 1 bis 2 Tage | 3 | 5 |
| 6 | **Instagram-API-Abgleich** | Timer, der stündlich Insights je Beitrag holt und als Zeitreihe ablegt, Token-Verlängerung | 0,5 bis 1 Tag | 3 | 5.2 |
| 7 | **Abschrift-Index über das Archiv** | Whisper über alle fertigen Videos, `search.py`, Musikwert je halbe Sekunde, Inhalts-Nummer gegen Umbenennen | 1 Tag (plus Rechenzeit) | 2 | 2.5 |
| 8 | **Planer und Doppelte-Prüfung** | Zernio-Konto, API-Skript, Abgleich über alle Posts jedes Status vor dem Planen, Posting-Zeiten | 0,5 bis 1 Tag | 2 | 8.5, 8.6 |
| 9 | **Schnitt-Grundpipeline** | Takes zuordnen, Wortzeiten per Ausrichtung (MMS_FA), Rohschnitt als EDL, Untertitel aus Rücktranskription, -14 LUFS, Render | 3 bis 5 Tage | 4 | 7.2 Schritte 2 bis 9, 12 |
| 10 | **QA-Prüfer** | Schwarzbilder, Balken, Stille, Ruckeln, Schnitt im Wort, Satzanfänge, Lautheit, Kontrollbogen, frischer Prüfer | 1 bis 2 Tage | 3 | 7.2 Schritt 14 |
| 11 | **Sound-Playbook und Tonplan** | Song- und Soundeffekt-Katalog mit BPM und Einstiegen, `tonplan.py` mit Ducking und Regeln | 2 bis 3 Tage | 3 | 7.2 Schritt 8 |
| 12 | **CapCut-Projekt-Generator** | Skript, das aus einer JSON-Spec ein CapCut-Projekt mit echten Textebenen und Originaldateien schreibt | 2 bis 3 Tage | 5 | 7.2 Schritt 13 |
| 13 | **Lernschleife und Wochenbericht** | Vergleich Skript gegen Transkript und KI-Projekt gegen Marcels Projekt, Lernlog, Freitagsbericht, Tests mit Losverfahren | 1 bis 2 Tage | 3 | 8.11 |
| 14 | **Projekt-Kataloge für Longform** | Inventar, Kontaktbögen, Szenenerkennung, Sichtung per Subagenten, Katalog als JSONL | 1 bis 2 Tage | 3 | 2.6, 2.8, 3 |
| 15 | **Motion Graphics mit Remotion** | Ortsmarke, Kapitelkarte, Zähler, Karte mit Flugroute als transparente ProRes-Ebenen, Stapel-Render | 2 bis 4 Tage | 4 | 7.2 Schritt 11 |
| 16 | **Hautfarbe und Text hinter der Person** | Haut-Messung je Shot und Haut-LUT, Freistellung mit BiRefNet, Zusammensetzen per ffmpeg | 1 bis 2 Tage | 4 | 7.2 Schritte 10, 11 |
| 17 | **Vorbild-Radar** | Apify-Abrufe, Ausreißer gegen Account-Median, Transkripte, Bild-für-Bild-Messung | 0,5 bis 1 Tag | 2 | 6 |
| 18 | **B-Roll-Index** | Schnitterkennung (TransNetV2), Bild-Embeddings (SigLIP2), Textsuche nach Bildbeschreibung, Match-Cuts | 2 bis 3 Tage | 4 | 2.5, 3.3 |

Grob gerechnet sind das 4 bis 6 Wochen bei konzentrierter Arbeit (unsicher). Die Schritte 1 bis 8 bringen schon nach rund einer Woche spürbar bessere Skripte und eine saubere Auswertung, auch wenn noch von Hand geschnitten wird.

**Tipp zur Reihenfolge im Schnitt:** Erst ein einziges Format komplett automatisieren (etwa Talking Head mit Untertiteln und Musik), bis es mehrmals hintereinander ohne Änderung durchgeht. Dann das nächste Format.

---

## Kapitel 11: Typische Fehler und Lehren

Aus über hundert dokumentierten Fehlern in Marcels Projekten. Zuerst die zehn, die am meisten gekostet haben, danach alle nach Bereich.

### 11.1 Die zehn wichtigsten

1. **Whisper-Wortzeiten sind für Schnitte zu grob** (Drift bis 2 s). Untertitel fehlten, Schnitte hätten Wörter gekappt. Lösung: erzwungene Ausrichtung je Sprechstelle auf der Demucs-Stimmspur, danach den fertigen Ton rücktranskribieren.
2. **Testreels und Feed-Reels gemischt ausgewertet.** Die Rangliste bildete nur das Mischungsverhältnis ab. Lösung: Klassen trennen, Faktor gegen den Median derselben Klasse.
3. **Die erste Analyse nur aus dem öffentlichen Profil.** Sechs Aussagen waren falsch. Lösung: immer den vollständigen Meta-Export als Basis.
4. **Doppelt eingeplant.** Ein zweiter Chat hätte denselben Bereit-Ordner noch einmal in Zernio geplant. Lösung: vor jedem Einplanen alle Posts jedes Status abgleichen.
5. **Haut zu rot** im Longform, Marcels größter Kritikpunkt. Lösung: Hautfarbe je Shot messen und per Haut-LUT korrigieren, Standbild in voller Größe prüfen.
6. **KI-Skripte waren glatter als Marcels eigene:** weniger Zahlen, kein Zeitstempel, kein angreifbarer Satz. Lösung: diese drei Punkte sind Pflicht im Qualitäts-Check.
7. **Grafiken im KI-Look** (Pillen, Checkboxen) wirkten fake. Lösung: Schrift wie in der Instagram-App getippt oder Handschrift, höchstens 2 bis 3 pro Video.
8. **Langsame Leitung und hängende Netzlaufwerke.** Ein Zugriff auf die Mac-Platten hing, wenn der Mac schlief, `timeout` half nicht. Lösung: nur kleine Ableitungen übertragen, große Arbeit dort, wo die Daten liegen, nie breit auf Netzlaufwerken suchen.
9. **Kurs-Wissen als Fakt behandelt.** Die Kurs-Regel "du-Hooks" lief bei Marcel schlechter als "ich-Hooks". Lösung: Herkunfts-Labels, eigene Daten schlagen Kurs-Wissen, Widerspruch wird ein Test.
10. **Unverändert neu hochladen bringt fast nichts.** Lösung: Recycling sichtbar verändern, zuerst die ersten 3 Sekunden, frühestens nach 3 Wochen, für neue Versionen neue Takes.

### 11.2 Archiv, Material und Clipauswahl

| Was schiefging | Lösung |
|---|---|
| Die Leitung Mac zu Server schaffte nur rund 150 KB/s (64 KB lesen dauerte 25 bis 50 s). 4K-Clips wären stundenlang unterwegs gewesen. | Nur 16-kHz-Ton und kleine Standbilder holen. Rendern, Kopieren, Vergleichen und Verschieben großer Mengen per Skript auf dem Mac. |
| Ein Zugriff auf die FUSE-Einhängung hing, als der Mac schlief. `timeout` wirkte nicht (ein `timeout 400 stat` lief 1.052 s). | Nie breit im Home oder auf den Einhängungen suchen, nur gezielte Pfade mit `-maxdepth`. Schutz nur über rclone-Zeitlimits (`--timeout`, `--low-level-retries`). Lange Zugriffe im Hintergrund, sonst Mac wecken lassen. |
| rclone-Kopien zum Mac brachen ab (SSH-Handshake). | `--checkers 2`, `--retries 10`, danach Größe per `rclone lsl`, auf dem Mac `md5 -q`. Fertige Dateien erst als `.teil` bauen, prüfen, dann umbenennen. |
| Die Mac-SSD war zu 91 % voll, rund 76 GB davon waren Arbeitsordner aus KI-Läufen. | Regel: Content, Proxys, Caches und CapCut-Medien nur auf der Rohmaterial-Platte unter `weiteres/`. Pfade in 16 CapCut-Projekten per Skript umgeschrieben. |
| Kopieren über das Google-Drive-Laufwerk lief mit rund 1,2 MB/s und legte nicht freigebbare Zwischenkopien auf die Mac-Platte. Drive-Spiegeln geht für geteilte Ablagen nicht, eine andere Cache-Ablage ignorierte Drive. | rclone direkt mit Lesezugriff (`drive.readonly`) auf die Platte, Skript holt bei jedem Lauf nur Neues. Achtung: der gemeinsame client_id von rclone soll abgeschaltet werden, dann eigenen anlegen. |
| Viele Handy-Dateien sind Zusammenschnitte. Ein Ausschnitt über einen versteckten Schnitt lässt plötzlich ein fremdes Bild aufblitzen. | Szenenwechsel im Katalog notieren, Feinbogen auf 0,1 s, mindestens 0,1 s Abstand zum Wechsel. Liegt ein Satzanfang genau auf Marcels eigenem Schnitt, den Anfang exakt dorthin legen, nicht ans Wort einrasten. |
| Die automatische Szenenerkennung übersieht in Sammelvideos viele Schnitte und meldet bei Nachtclips mit Stirnlampen und bei Kamerabewegungen falsche. | Jede Meldung im genutzten Ausschnitt mit zwei Standbildern je 0,2 s davor und danach prüfen. Kontaktbögen sind zuverlässiger. Für Aests-Videos den stärkeren B-Roll-Index (TransNetV2 plus eigene Differenz) nutzen. |
| Whisper erfindet in Stille, bei Motor oder Musik Text ("Untertitelung des ZDF", "Vielen Dank", Liedtexte). | Im Sichtungsauftrag ausdrücklich sagen: solche Floskeln zählen als keine Sprache. Auto-Aufnahmen mit Motorbrummen je Sprechstelle einzeln abtippen. |
| Whisper gerät bei langen Dateien in Endlosschleifen. | Den mitgenommenen Textkontext abschalten (maximaler Kontext null), lange Dateien teilen. |
| Musik im Clip-Ton wurde übersehen, Musik lag über Musik. | Musikwert je halbe Sekunde (PANNs, ab 0,2 verdächtig) im Index, Feld `musik_im_ton` im Katalog, Gegenprobe mit demucs. Bass allein täuscht (Wind, Motor, Stimmgrundton). |
| Sony-Clips waren falsch gedreht gespeichert, die Drohnenuhr geht nach, Metadaten stehen in UTC oder tragen die Export-Zeit. | Drehung aus den Metadaten einrechnen und am Bild prüfen. Zeit mit Quelle kennzeichnen (Metadaten, UTC umgerechnet, Dateiname, Inhalt), Unsicheres "vermutlich". |
| Hardware-Dekodierung verschluckte bei Sony- und DJI-Material Bilder, im Export ruckelte es. | Software-Dekodierung und die Bildrate des Materials nehmen, doppelte Bilder je Einstellung zählen. Ein Sichtungslauf wurde dafür neu gestartet und dekodierte danach nur Schlüsselbilder (Grund für den Neustart: unsicher). |
| 206 doppelte Dateien (16,7 GB) auf der Arbeitsplatte, dazu rund 6,8 GB umbenannte Kopien. | Doppelte per Byte-Vergleich gelöscht (mit Log), im Inventar Duplikate über gleiche Größe und Dauer markieren und nicht doppelt beschreiben. |
| Neun unbenutzte Rohtakes lagen nur noch im Papierkorb der Platte. | Vor dem Leeren eines Papierkorbs auf einzige Kopien prüfen und Marcel entscheiden lassen. |
| Dateien in CapCut-Projekten wurden beim Aufräumen fast verschoben. | Vor jedem Löschen oder Verschieben alle `draft_content.json` auf das Feld `path` prüfen. Pfade nur bei geschlossenem CapCut per Skript umschreiben (erst zählen, dann mit Schalter echt). |
| Ein Katalog über Pfade bricht, sobald Marcel Ordner umsortiert. | Inhalts-Nummer, die beim Umbenennen und Verschieben gleich bleibt. Den großen Gesamtkatalog erst nach dem Aufräumen bauen. |
| Für einen alten Schnitt war unklar, aus welchen Rohclips er besteht. | Fingerabdruck (32x18 Graustufen, normierte Korrelation) gegen alle Rohclips. |
| Notion war nicht verbunden, "schon verwendet" ließ sich nicht nachschlagen. | Abschrift gegen alle fertigen Videos über 4-Wort-Folgen abgleichen (60 bis 170 Treffer heißt verwendet). |
| macOS legt auf exFAT `._`-Dateien an, ein ffmpeg-Glob auf `*.jpg` nahm sie mit und brach still ab. | Muster ohne Punkt-Anfang oder `._*` vorher löschen; bei `find` `! -name '._*'`. |
| Per `ssh 'bash -s' < skript.sh` las ffmpeg das restliche Skript als Eingabe. | Jedes ffmpeg mit `-nostdin`. |
| Ästhetik-Scores bevorzugten Postkarten-Bilder. | Nur als Filter gegen unscharfe oder dunkle Clips, Auswahl nach Menschen, Moment und Licht. |
| Gesichtserkennung (OpenCV-Haar) fand Profile nicht, 0 Treffer bewiesen nichts. | Standbilder trotzdem ansehen. |
| Der Mac-Arbeitsordner wurde während der Arbeit verschoben oder zwischen zwei Fassungen geleert. | Vor jeder neuen Fassung prüfen und Skripte, Stimmspuren und Pläne vom Server neu schieben. |
| Material fehlte auf allen Platten (eine Laufdatei, ein Ankunfts-Selfie, die Rohdatei eines B-Roll-Stücks). | Im Bericht klar "nicht gefunden" mit den durchsuchten Orten, nichts erfinden, Ersatz nennen. |

### 11.3 Schnitt, Ton, Grafik und Technik

| Was schiefging | Lösung |
|---|---|
| Whisper-Wortzeiten drifteten bis 2 s, viele Wörter mit gleicher Startzeit; Untertitel fehlten, ein Schnitt hätte das letzte Wort des Kernsatzes gekappt | Erzwungene Ausrichtung (MMS_FA) je Sprechstelle auf der Demucs-Stimmspur, Abweichung über 1,2 s verwerfen |
| Untertitel aus den Wortzeiten des Schnittplans: 89 von 447 Zeilen mit fehlenden Wörtern | Fertigen Ton ohne Musik neu transkribieren, nur Wörter innerhalb der Sprechstellen behalten, zweite Meinung per Whisper auf der Stimmspur |
| Einrasten an Wortgrenzen ließ Sätze mit "Uhr," oder "es" beginnen; ein Satz begann ohne "Das" | Alle Satzanfänge mit dem Wort davor auflisten und lesen; geschnittene Ausschnitte rücktranskribieren |
| Pausen-Jump-Cuts stiegen im Wortanfang ein | Wiedereinstieg bis 0,15 s zurück in die Stille legen |
| Whisper hörte "zehn Kilometer", gesagt war "sieben"; Etikett zeigte falsche Zahl | Zahlen einzeln mit Polster transkribieren, gegen Bild prüfen; Gesagtes und Etikett müssen übereinstimmen |
| Kinobalken aus einem Stück eines alten Schnitts blieben unentdeckt | Eigene Balken-Suche über den ganzen Film; blackdetect findet nur Schwarzbilder |
| True Peak nach AAC bei -0,8 dBTP trotz Limiter auf -2 dBFS | Begrenzer auf -3,2 dBFS vor AAC, True Peak am fertigen MP4 messen |
| Stille Stellen ohne jeden Ton | Stille-Prüfung (ab 0,3 s unter -55 dBFS), dort Musik oder Atmo |
| Marcels Haut im Longform viel zu rot ("größter Fehler") | Hautfarbe je Shot messen (rg, Farbton), Haut-LUT je Clip, Standbild in voller Größe prüfen |
| iPhone-HLG mit 203-nit-Tonemapping zu hell und zu bunt | Nur Farbraum umrechnen (eigene 3D-LUT, Gamma 2,4) |
| Clips 90 Grad gedreht und 2,7-fach gezoomt, unscharf und komisch | Hochformat wie gefilmt, Zoom höchstens 1,1, Kopfposition über Clipauswahl |
| Text im CapCut-Projekt als Video/PNG, Clips als vorgeschnittene Kopien | Text als echte Textebene, Originaldateien mit In/Out |
| Ältere Fassung des CapCut-Skripts ignorierte `--ziel` und schrieb trotz offenem CapCut in dessen Projektordner | Aktuelle Fassung nutzen, vorher `pgrep -x CapCut`, Projekte in Arbeitsordner schreiben |
| Grafiken mit Pillen und Checkbox-Kreisen wirkten "fake, nach AI" | Menschengemachter Stil: App-Schrift-Leiste oder Handschrift, höchstens 2 bis 3 pro Video |
| Untertitel sprangen je Einblendung die Höhe, Buchstaben hingen in Dach und Busch, Schrift über dem Gesicht | Eine feste Höhe; hinter Dingen nur bei perfekter Kante, sonst vorne; nie über Gesichtern |
| Masken-Übergänge (weiße Silhouette, Puzzle) zu oft, Puzzle sah verbuggt aus | Sparsam, 2 bis 3 pro Intro, nur an klaren Schnitten |
| Song lief nach dem Intro zu lange und kam später wieder | Song nach dem Intro bald wechseln, kein Song doppelt, auch nicht gleiche Melodie aus demselben Soundtrack |
| Remotion mischte `defaultProps` in jede Spec; jede Notiz zeigte einen Beispieltext | defaultProps nur mit Pflichtfeldern, optionale Felder im Code mit Standard, Standbild je Spec vor dem Render |
| Text über einer absolut positionierten Abdunkel-Fläche wurde grau | Text `position: relative`; hellsten Pixel im Still prüfen |
| Filmkorn in der Overlay-Ebene: 6 MB pro 4K-Bild | Korn per ffmpeg `noise=alls=7:allf=t` direkt aufs Video |
| RGBA-Overlay verschob Markenfarben | `scale=out_color_matrix=bt709:out_range=tv,format=yuva444p` und `overlay=format=yuv444`; bt709 per `setparams` setzen |
| ffmpeg overlay mit `eof_action=endall` verlor das letzte Bild, Standbilder entstanden | Ebene einige Bilder länger, Länge per `-frames:v`, Bildzahl je Shot mit ffprobe prüfen |
| Ortsmarken kollidierten mit Untertiteln, Etiketten ragten über den Handy-Rahmen | Ortsmarken oben links, Breite per Remotion-Still und Alpha-Bounding-Box messen |
| Namensschild mit Pfeil zeigte leere Kopfstütze (Handkamera schwenkte weg) | Standbilder alle 0,25 s im Zeitfenster, Schild per Quellzeit genau auf das ruhige Fenster |
| Songs auf iCloud-Schreibtisch ausgelagert, Mischlauf brach ab | Vor jedem Mischen alle Dateien einmal ganz lesen, bei Fehler Download anstoßen |
| Server-Last durch parallele Agenten drückte Matting auf 1 Bild pro 5 Minuten | Vor schweren Läufen `uptime` prüfen, nie zwei Matting- oder Render-Läufe parallel |
| Longform zu lang, Nebenstrecken, Sprünge in der Geschichte unerklärt | Bis zum Titel höchstens 10 bis 12 s, Nebenstrecken kurz, Überleitungen (z. B. groß auf die Karte), Sätze nie abhacken |
| Weiße Etiketten auf hellem Grund schwer lesbar, im Kontaktbogen nicht bemerkt | Kräftigerer Schatten (Alpha 0,6 plus weicher Hof), Lesbarkeit in voller Größe prüfen |
| Messung und Schnittplan stammten aus verschiedenen Fassungen | Fertige Datei als `.teil` bauen, alle Prüfungen an genau dieser Fassung, dann umbenennen |

### 11.4 Skripte, Ablage und Planung

| Was schiefging | Lösung |
|---|---|
| Ein zweiter Chat hätte den Bereit-Ordner ein zweites Mal in Zernio eingeplant, alles wäre doppelt online gegangen. | Vor jedem Einplanen Doppelte prüfen (8.6), über alle Zernio-Posts jedes Status plus echte Posts. |
| Fertige Schnitte lagen nur als CapCut-Projekt oder Vorschau auf dem Server, Marcel suchte sie auf der Festplatte. | Jeder Schnitt kommt als fertiges Video in `1 Prüfen` (1080p, 60 fps, höchstens 25 Mbps). |
| Der alte Ordner „1 KI Schnitt“ war voller Vorschau-Dateien, die Freigabe lief über Listen im Chat. | Drei Stufen Prüfen, Bereit, online. Freigabe ist das Verschieben nach Bereit. |
| YouTube-Longform landete im Kurzvideo-Weg. | Alles für YouTube außer Shorts direkt in `Content/Longform`. |
| Pfade unter dem Mac-Benutzerordner existierten auf dem Server nicht als Link, Dateien landeten still auf dem Server statt auf dem Mac. | Zielpfad vorher prüfen, nach jedem Kopieren Größe oder md5 vergleichen. |
| Zwei Fassungen je Video (mit und ohne Musik) kosteten Render- und Prüfzeit. | Seit 16.10.2026 nur eine Fassung, immer mit Musik. |
| Von der KI geschriebene Skripte waren glatter als Marcels: weniger Zahlen, kein Zeitstempel, kein angreifbarer Satz. | Diese drei Punkte sind Pflicht im Qualitäts-Check. |
| Das Playbook sagte 80 bis 250 Wörter, die eigenen Daten zeigen: über 120 Wörter deutlich schwächer. | Richtschnur höchstens rund 120 Wörter, Format geht vor. |
| Kurs-Regel „du“-Hook übernommen, bei Marcel liefen „ich“-Hooks besser. | Eigene Daten schlagen Kurs-Wissen, Widerspruch wird ein Test. |
| Alte Regel „Kommentare über eine Frage am Ende“: brachte nicht mehr Kommentare. | Kommentare über Lead-Videos mit Namens-Aufruf. |
| Das beste Lead-Video hatte zwei Aufrufe (Name oder Link). | Regel bleibt ein Aufruf, die Frage wird getestet. |
| Kurs-Wissen und KI-Vorschläge standen als „belegt“ in den Regeln. | Herkunfts-Labels Zahlen, Marcel, Kurs, Offen und ein unabhängiger Gegencheck. |
| Zahlen aus alten Skripten und dem Playbook wichen vom Meta-Export ab. | Es gilt der Export, Zahlen im Skript nur aus der Faktenbasis, sonst Platzhalter. |
| Skripte im Archiv wurden nicht immer so verwendet oder sogar verworfen. | Archiv nicht blind glauben, immer selbst prüfen. |
| Allgemeine Weisheiten ohne Situation („Das Leben belohnt Macher“) floppten. | Hook mit echtem Moment und Einsatz. |
| Eine erste Reel-Fassung behielt die Reihenfolge des Rohmaterials (71 s) und war schwach. | Hook Stacking: Struktur frei aus den stärksten Sätzen bauen (44 s, deutlich besser). |
| Dasselbe Video unverändert neu hochgeladen brachte fast nichts. Ein Take, der viermal lief, verlor ab der dritten Version stark. | Recycling sichtbar verändern, neue erste 3 Sekunden, für neue Versionen neue Takes. |
| In einem Repost eines Hosts stand „all inclusive“, ein verbotener Begriff. | Kurze Begriffsliste für alle, die Captions schreiben (offen). |
| In den Nachrichtenanfragen lagen viele unbeantwortete Reise-Anfragen. | Nachrichtenanfragen täglich, mindestens wöchentlich prüfen, Namens-Kommentare und DMs am selben Tag beantworten. |
| Ältere Dokumente schrieben das Instagram-Handle falsch, ein sehr ähnlicher Name gehört einem fremden Account. | Handles je Plattform festhalten und prüfen. |
| Testreels ab 19 Uhr kamen seltener auf hohe Reichweite (offen). | Testidee: die Hälfte der Testreels vormittags oder nachmittags. |

### 11.5 Daten und Vorbilder

| Was schiefging | Lösung |
|---|---|
| Die erste Analyse beruhte nur auf dem öffentlichen Profil; sechs Aussagen waren falsch (etwa "zu wenig Output", obwohl 86 % der Uploads unsichtbare Testreels waren). | Den vollständigen Meta-Export als Basis nehmen und die erste Analyse im alten Dokument korrigieren. |
| Testreels und Feed-Reels gemischt ausgewertet: die Rangliste bildete nur das Mischungsverhältnis ab. | Klassen trennen (`media_trial` bzw. `is_shared_to_feed`), je Klasse eigene Baseline. |
| Absolute Views und Durchschnitte: ein Hit verzerrt alles. | Faktor gegen den Median desselben Accounts und derselben Plattform, Median statt Mittelwert, Permutationstest. |
| Eine Datenquelle enthielt nicht den Account, um den es ging. | Vor jeder Auswertung prüfen, welcher Account in der Datenquelle steckt; für eigene Konten den eigenen API-Abgleich nutzen. |
| Zahlen aus Export, Web-Insights und Notion wichen voneinander ab (zum Beispiel 744.000 gegen 939.000 Aufrufe für dasselbe Reel). | Zähler und Nenner immer aus derselben Quelle; im Zweifel gilt der Export. |
| Neue Follower pro Reel liefert weder Export noch API. | Business-Suite-Export alle 2 Wochen von Hand plus Rechenmodell; nur die Richtung als Regel verwenden. |
| Follower.csv enthält nur, wer heute noch folgt: neue Monate sehen besser aus als alte. | In jeder Auswertung als Grenze nennen. |
| Shares wurden vor Dezember 2025 offenbar anders gezählt, und der Browser zeigt "Geteilte Inhalte" immer als 0. | Raten nur innerhalb einer Periode vergleichen, Shares am Handy ablesen. |
| Bei lizenzierter Musik fehlen Video-Link, Frames und Transkript. | Titelbild für den Overlay-Text nutzen, Transkript aus der eigenen Originaldatei. |
| Medien-Links verfallen. | Benötigte Medien zeitnah sichern, Transkripte beim ersten Abgleich ziehen. |
| Glaube an Volumen: 4-mal so viele Uploads, trotzdem sinkende Reichweite pro Testreel. | Statt Glaubenssatz einen Test anlegen (4 Wochen halb so viele, fast nur gesprochene Testreels). |
| Die KI ordnete Reels nach Format falsch ein (4 von 25 in einer Stichprobe). | Stichproben von Hand prüfen, Tabellen-Beispiele mit Transkript und Texthook kontrollieren. |
| Alte Regeln widersprachen neuen Auswertungen (Länge, Uhrzeit, Entrauschen, Winner-Regel). | Widersprüche sammeln, je Punkt auflösen und datieren; Daten-Regeln alle 3 Monate prüfen. |
| Auswahl-Falle: Auf TikTok und YouTube landen nur Instagram-Winner, deren Zahlen sagen nichts über alle Videos. | In freie YouTube-Slots auch zufällig gewählte Videos unter Median. |
| YouTube sperrt die Server-IP für Transkripte. | Über den Heim-Rechner laden, langsam, nur Originalsprache, keine Konto-Cookies. |
| Instagram-Login-Wand und blockierte Drittseiten bei der Wettbewerbsanalyse. | Für fremde Profile Apify nutzen, Snippets nur mit Vermerk, Lücken offen benennen statt raten. |
| Kleine Basis ließ einen fremden Ausreißer riesig wirken (Faktor 64 bei Basis 419). | Faktor immer mit Basis angeben, ein Format erst bei zweifachem Auftreten übernehmen. |
| Viraler Hit brachte viele Follower, die Hälfte ging wieder. | Nach einem Hit innerhalb von 24 bis 48 Stunden ein Vertrauens-Video nachlegen (Annahme, im nächsten Hit prüfen). |

---

## Kapitel 12: Was ich heute anders machen würde

Abgeleitet aus den Lehren in Kapitel 11, aus Sicht der KI, die das System mitgebaut hat.

1. **Rohmaterial von Anfang an dort, wo gerechnet wird.** Die Teilung "Server plant, Mac rendert" ist nur eine Antwort auf die langsame Leitung und kostet bei jedem Projekt Zeit (Skripte auf den Mac schieben, Kopien prüfen, hängende Laufwerke). Bei dir: Rohmaterial direkt auf den Server oder auf einen Speicher mit schneller Anbindung, dann läuft alles auf einer Maschine.
2. **Einen Gesamtkatalog mit festen Inhalts-Nummern ab dem ersten Clip.** Bei Marcel gibt es Kataloge nur je Projekt, der große Katalog wartet aufs Aufräumen der Platten. Wer neu anfängt, vergibt jedem Clip beim Import eine Nummer, die Umbenennen und Verschieben überlebt, und füllt wann, wo und was gleich beim Import.
3. **Herkunfts-Labels und Tests von Tag 1.** Viele Regeln mussten nachträglich zurückgestuft werden, weil Kurs-Wissen und KI-Vorschläge als belegt galten. Jede Regel bekommt beim Anlegen Herkunft und Datum, jede Testidee einen Eintrag mit Hauptzahl, bevor das erste Video entsteht.
4. **Den Meta-Export zuerst, dann die Strategie.** Die erste Analyse aus dem öffentlichen Profil lag mehrfach daneben. Erst Daten ziehen, Klassen trennen, Faktor rechnen, dann Formate wählen.
5. **Wissen in Notes, nie im Skill.** Bei Marcel lag das Regelwerk erst in einem großen Dokument und in Skills und musste später in Notes umziehen. Gleich so anfangen spart den Umzug.
6. **Eine Fassung, ein Ausgabeordner, ein Freigabeweg.** Zwei Fassungen je Video (mit und ohne Musik) und Vorschaudateien in Sammelordnern kosteten Zeit. Von Anfang an: eine Fassung, `1 Prüfen`, Freigabe durch Verschieben.
7. **Die CapCut-Version einfrieren und eine Klartext-Vorlage sichern.** Das Projektformat ist nicht dokumentiert, neuere Versionen melden fremd geschriebene Projekte als beschädigt oder verschlüsseln sie. Wer auf CapCut setzt, schaltet Updates ab, bevor der Generator gebaut wird.
8. **Jede Datei erst als `.teil` bauen.** Mehrere Fehler kamen daher, dass Messung und Datei aus verschiedenen Fassungen stammten. Bauen, an genau dieser Datei prüfen, dann umbenennen, nie überschreiben.
9. **Ein Format nach dem anderen automatisieren.** Lieber ein Format, das zuverlässig ohne Änderung durchgeht, als fünf halbe.
10. **Eine GPU einplanen, wenn Freistellung und Demucs regelmäßig laufen sollen.** Ohne GPU dauert Freistellung rund 16 CPU-Sekunden pro Bild, und parallele Läufe bremsen sich gegenseitig aus. Ob sich das bei deinem Volumen lohnt, hängt von der Menge ab (unsicher, nicht gemessen).

---

## Was Johann vorab selbst tun muss

**Konten und Zugänge (macht der Kontoinhaber selbst, nie die KI)**

- [ ] Instagram-Konto auf professionell umstellen (Creator oder Business).
- [ ] Meta-Datenexport anfordern ("Deine Informationen herunterladen", alle Daten, JSON). Das dauert manchmal Tage, deshalb zuerst.
- [ ] Meta-Entwicklerkonto anlegen, App mit Instagram-Login, eigenen Account als Tester eintragen und Einladung annehmen, Token erzeugen (Schritte in 5.2). Token in eine `.env`, nie in Chat oder Notiz.
- [ ] Alle 2 Wochen neue Follower pro Reel aus der Meta Business Suite exportieren (liefert keine API).
- [ ] Planer-Konto (bei Marcel Zernio) anlegen, Instagram über Facebook verbinden (nötig für Instagram-Musik), TikTok und YouTube verbinden, API-Schlüssel in die `.env`, Zeitzone des Kontos prüfen.
- [ ] Apify-Konto im Free-Plan ohne Kreditkarte für die Vorbild-Analyse.
- [ ] Optional: Musiklizenz (etwa Epidemic Sound), CapCut Pro, eine Datenbank für Videos, Posts, Tests und Lernlog (bei Marcel Notion).

**Material und Ordner**

- [ ] Entscheiden, wo das Rohmaterial liegt: am besten direkt am Server oder mit schneller Anbindung (siehe Kapitel 12, Punkt 1). Content nie auf die Systemplatte eines Rechners.
- [ ] Ordnerstruktur anlegen: Rohmaterial nach `JJJJ_MM_Ort`, B-Roll-Sammelvideos je Ort, `FERTIG/1 Prüfen`, `2 Bereit`, `überall online/<Thema>`, `4 Gewinner`, `Longform`.
- [ ] Doppelte Dateien vorher bereinigen (Größe und Dauer gleich, dann Byte-Vergleich).

**Wissen, das nur du liefern kannst**

- [ ] Alle bisherigen eigenen Skripte als Text sammeln (Marcel hatte rund 250).
- [ ] Faktenbasis schreiben: Zeitleiste der eigenen Geschichte, Zahlen, Anekdoten, was nie gesagt werden darf.
- [ ] Drei eigene Skripte auswählen, die nachweislich gut liefen (Stil-Anker).
- [ ] Erlaubte und verbotene Begriffe der Marke festlegen.
- [ ] Eigene Handles je Plattform aufschreiben (bei Marcel waren alte Dokumente falsch geschrieben).
- [ ] Liste der Vorbild-Accounts, gern aus anderen Nischen.

**Software und Hardware**

- [ ] Auf dem Server: ffmpeg, whisper.cpp oder faster-whisper (vorhanden), Python mit torch und torchaudio, Demucs, OpenCV, pyloudnorm, librosa, Node mit Remotion, rclone, yt-dlp.
- [ ] Am Schnittrechner: CapCut in einer festen Version, Updates aus, ein von Hand gebautes Vorlage-Projekt als Klartext sichern.
- [ ] YouTube-Transkripte brauchen eine Heim-IP (Server-IPs werden gesperrt): einen Rechner zu Hause per SSH erreichbar machen oder Transkripte dort holen.
- [ ] Optional eine GPU für Freistellung, Demucs und Whisper.

---

## Anhang: Quellen und offene Punkte

**Quellen.** Marcels Skills (Skript, Content-Regeln, Lernschleife, Motion Graphics), seine Content-Notes, das Regelwerk Fließband, Aufträge, Berichte und Skripte der Schnittprojekte (Honolulu-Longform, Norwegen-Vlog, Week in my Life, Mohana Life, Neue Formate, Week-Intro), Recherche-Notizen zu Werkzeugen und Sound, die Analyse des Meta-Exports und die Beschreibungen der Server-Werkzeuge. Verweise im Text auf Notes oder Skill-Abschnitte zeigen nur die Herkunft, die Inhalte stehen hier im Text.

**Offene Punkte.** An diesen Stellen fehlen Quellen oder sie widersprechen sich.

### Archiv und Clipauswahl (Kapitel 2, 3)

- Größe der Handy-Galerie und genaue Belegung der Platten: nur die Nenngrößen (rund 1 TB und rund 2 TB) und Einzelzahlen aus Berichten sind belegt, keine aktuelle Messung (Mac-Einhängungen wurden bewusst nicht durchsucht).
- Ob der B-Roll-Index nur auf dem Mac läuft: die Anleitung nennt Mac-Pfade und Apple Vision, Skriptkopien liegen auch auf dem Server.
- Ob die Sichtungsläufe auf dem Mac mit Hardware-Dekodierung, Software-Dekodierung oder nur Schlüsselbildern liefen: die Server-Kopie von `sicht.sh` und das Neustart-Skript widersprechen sich im Detail.
- Ob `video_analysis_create` in Marcels Clipauswahl genutzt wird: in den gelesenen Projekten nicht.
- Der geplante Gesamtkatalog beider Platten existiert noch nicht; Kataloge gibt es nur je Projekt.
- Ob das Schema `JJJJ_MM_Name` auf der Rohmaterial-Platte schon überall gilt: einzelne Ordner weichen ab (Tag im Datum, Zusatzwörter).

### Skripte, Veröffentlichen, Lernschleife (Kapitel 4, 8)

1. **YouTube und Musik:** Die Note „Content - Upload und Plattformen“ sagt, YouTube bekommt eine Version ohne geschützte Musik (Shorts über 1 Minute würden sonst gesperrt), die Note „Content - Ablage“ kennt noch den Zusatz „ohne Musik“. Marcel hat am 16.10.2026 festgelegt: nur noch eine Fassung, immer mit Musik, auch für YouTube (Skill marcel-content-regeln, Memory nur-fassung-mit-musik). Hier gilt die neuere Regel, die Notes sind noch nicht nachgezogen.
2. **Abnahme Schnitt:** Das Fließband nennt als Schnitt-Abnahme das Verschieben nach „2 Bereit“, die Notes einen Klick „Abnahme Schnitt“. Vermutlich beides im Einsatz (unsicher).
3. **Instagram-Zahlen:** Die Notes sagen, die KI greift nie auf Meta zu und Follower pro Reel kommen aus Marcels Export. Parallel gibt es den Team-Instagram-Abgleich über die offizielle API mit Token. Wie beides in die Posts-Tabelle zusammenfließt, ist nicht beschrieben (unsicher).
4. **Keywords:** keine eigene Keyword- oder SEO-Strategie für Kurzvideos in den Quellen gefunden (unsicher, ob es eine gibt).
5. **Zernio-API:** belegt ist nur `GET /v1/posts` und dass die Analytics die letzten rund 100 Posts je Plattform liefern. Seitenparameter, Endpunkte zum Anlegen von Posts und Kosten sind nicht beschrieben (unsicher). Ob Zernio Skip-Rate und Follower auch für Instagram-Testreels liefert, sollte laut Lernschleife vor dem ersten Test geprüft werden, das Ergebnis steht nicht in den Quellen.
6. **Firmenaccount in Zernio:** Stand 16.10.2026 noch nicht verbunden, bis dahin wird nur der persönliche Kanal geplant.
7. **Lernlog in der Praxis:** Einige Bau-Aufträge liefen ohne Notion-Verbindung. Wie vollständig das Lernlog tatsächlich geführt wird, ist nicht prüfbar (unsicher).
8. **Ordner „Vom Handy“** in FERTIG: Zweck nicht beschrieben.
9. **Beispiel-Zahlen:** Aufrufe und Follower der drei Beispiel-Skripte stammen aus der älteren Skill-Fassung. Laut Note „Entscheidungen und No-Gos“ weichen alte Zahlen teils vom Meta-Export ab, sie sind also eher Größenordnung als exakter Wert.
10. **Wochenmix und Mengen** (77 Instagram-Videos pro Woche) sind ein Vorschlag der KI im Fließband, nicht belegt, dass er so umgesetzt wird.

### Daten und Vorbilder (Kapitel 5, 6)

- Genauer Menüweg für den Meta-Datenexport und wie aus den Export-JSONs `Reels.csv` gebaut wurde: nicht dokumentiert.
- Ob `virality_predictor` je im Ablauf eingesetzt wurde: kein Beleg.
- Ob die Radar-Werkzeuge für Marcel derzeit zuverlässig nutzbar sind: am 15.10.2026 einmal erfolgreich, einmal nicht verfügbar.
- Ob die frühen Web-Insights angemeldet im Browser gelesen wurden und wie das zur heutigen Regel "kein KI-Zugriff auf Meta" passt: nur "gelesen und langsam gescrollt" ist belegt.
- Aktuelle Apify-Preise je Ergebnis und Höhe des Gratis-Guthabens.
- Followerzahl @mohanatrips (nur Suchmaschinen-Snippets mit unbekanntem Indexdatum); Reel-Auswertungen für @mohanatrips, TikTok und YouTube fehlen weitgehend.
- Ob fremde Original-Reels dauerhaft (Monatsordner "Trends", Referenzvideo im Nachbau) oder nur vorübergehend gespeichert werden sollen: Quellen widersprechen sich.
- Rechtliche Bewertung von Scraping öffentlicher Daten und von fremder Musik oder Filmszenen in eigenen Videos: nicht geprüft, keine Rechtsberatung.
- Format der `ref.info.json` als yt-dlp-Ausgabe: abgeleitet, nicht belegt.

### Schnitt, Werkzeuge, Hardware (Kapitel 7, 9)

1. Kosten für Claude-Abo, CapCut Pro, Zernio, Notion, Higgsfield-Credits, Server und das FOUR-Editors-Bundle: in keiner gelesenen Quelle belegt.
2. Welcher Epidemic-Tarif aktiv ist (Playbook nennt die Frage als offen).
3. Genaue Demucs-Aufrufzeile (aus Logs rekonstruiert).
4. Feldwerte `size` und `y` im CapCut-Spec-Beispiel sind Beispielwerte, nicht aus einer echten Spec kopiert.
5. Mac-Modell und Größe der internen Platte; genaue Kameramodelle (nur "Sony-Kamera 4K50" und iPhone belegt).
6. Ob DaVinci Resolve oder Premiere je für Marcels Schnitte eingesetzt wurden (nur als mögliches Ziel in einer Regel genannt; Premiere-Vorlagen aus dem Bundle laufen nicht in CapCut).
7. Ob `reels_variante` und die übrigen reels_*-Werkzeuge für Marcels Kanäle tatsächlich genutzt werden; die Beschreibungen verweisen auf die Pipeline eines anderen Kanals.
8. Der Limiter-Wert `limit=0.69` im Lautheits-Beispiel ist aus -3,2 dBFS umgerechnet; im gelesenen Code standen 0.891 (tonplan, -1 dBFS) bzw. 0.84 (bau.py) und "-3,2 dBFS" als Text in mix_mac.py.
9. Geschwindigkeitsgewinn mit GPU ist nicht gemessen.