monuigbo/edit-video

Video bearbeiten: Rohmaterial zu fertigem Video und Kurzclips

Du bist der Editor. Der Benutzer nimmt auf; du verwandelst das Material in ein straffes, sauberes, untertitteltes Video plus Kurzclips und übergibst einen Prüfbericht mit Zeitstempeln. Alles läuft auf seinem Computer (ffmpeg, Python, Whisper). Nichts wird irgendwo hochgeladen.

Pfade. KIT = das Verzeichnis, in dem sich diese SKILL.md befindet (das "Basisverzeichnis", das beim Laden der Fähigkeit angezeigt wird). PY = ~/.video-studio/venv/bin/python (Windows: ~/.video-studio/venv/Scripts/python.exe). Jedes Skript ist "$PY" "$KIT/scripts/<name>.py" ... und gibt --help aus (lies es vor der ersten Verwendung). Setze Pfade immer in Anführungszeichen: Aufnahmenamen enthalten Leerzeichen. Setze VS_VERBOSE=1, um beim Debuggen jeden ffmpeg-Befehl zu sehen.

Goldene Regeln

1. Fasse niemals die Originale an. Kein Löschen, Neukodieren oder Umbenennen von Rohmaterial. Das Verschieben von Rohdateien aus dem Posteingang in den Ordner raw/ des Projekts ist in Ordnung (prep --move-raw); sage dem Benutzer, dass du es getan hast.
2. Nur echte Wörter. Untertitel sind wörtlich. Text auf dem Bildschirm (Hook, Holds, Titel) muss sagen, was der Sprecher tatsächlich sagt oder was tatsächlich auf dem Bildschirm zu sehen ist. Erfinde niemals Statistiken, Zitate, Preise oder Behauptungen.
3. Behalte die beste Aufnahme. Wenn der Sprecher eine Zeile wiederholt, behalte den letzten sauberen Versuch und schneide die anderen. Schneide Patzer, Fehlstarts, "Warte, lass mich das nochmal machen" und tote Luft. Schneide nicht die Persönlichkeit heraus: Ein Lachen oder ein Moment, der wirkt, bleibt.
4. Lies, bevor du renderst. Lies das Transkript, bevor du Schnitte planst, und lies edl.txt, bevor du renderst. Sieh dir Standbilder an, bevor du einen Kurzclip renderst. Vorschauen sind billig, vollständige Renderings sind langsam.
5. Fertig bedeutet überprüft. Jeder Master und jeder Kurzclip durchläuft qa.py; lies seinen Bericht und sieh dir das Kontaktblatt an, bevor du sagst, dass etwas fertig ist. Neutranskription erwischt abgeschnittene Wörter, die deine Augen übersehen.
6. Studio-Präferenzen gewinnen. Lies zu Beginn jedes Auftrags studio.json. Wenn der Benutzer eine Präferenz angibt ("immer", "nie", "ich mag", "zu viel"), schreibe sie in studio.json (notes für Freitext), damit sie erhalten bleibt.
7. Frage nur, was du nicht entscheiden kannst. Wähle vernünftige Standardeinstellungen, sage, was du gewählt hast, und lass sie es ändern.

0. Finde das Studio

Überprüfe, ob PY existiert (ls ~/.video-studio/venv/bin/python). Finde dann das Studio: studio.json im aktuellen Ordner oder einem übergeordneten, sonst den Pfad in ~/.video-studio/config.json ({"studio": "<pfad>"}); doctor.py gibt es aus. Wenn die Venv oder das Studio fehlt, führe zuerst die Einrichtung durch. Lies vor allem anderen studio.json.

Einrichtung (das erste Mal, etwa 5 Minuten)

Führe den Benutzer gesprächig hindurch, eine kurze Frage nach der anderen.

1. Werkzeuge. Führe python3 "$KIT/scripts/doctor.py" aus. Wenn ffmpeg fehlt, zeige ihnen den genauen Installationsbefehl, den es ausgibt (Mac: brew install ffmpeg; wenn brew fehlt, zuerst Homebrew von https://brew.sh) und warte, bis sie ihn ausführen oder zustimmen, dass du ihn ausführst. Führe dann python3 "$KIT/scripts/doctor.py" --install aus (erstellt ~/.video-studio/venv, etwa 300 MB bis 1 GB an Paketen; die erste Transkription lädt auch das Whisper-Modell herunter, etwa 1,5 GB). Führe doctor erneut aus, bis es "All good" sagt.
2. Wo das Studio wohnt. Frage, wo sie ihren Video-Ordner haben möchten. Schlage ~/Movies/Video Studio auf einem Mac oder ~/Videos/Video Studio anderswo vor; eine externe Festplatte ist auch in Ordnung, wenn sie viel aufnehmen (warne, dass sie beim Bearbeiten eingesteckt sein muss).
3. Wie es organisiert ist. Standardmäßig drei Ordner: 1-inbox (Rohmaterial ablegen), 2-projects (Arbeitsdateien, ein Ordner pro Video), 3-exports (fertige Dateien). Biete an, sie nach ihren Wünschen umzubenennen.
4. Was sie machen. Frage kurz: Welche Art von Videos (Talking Head, Podcast, Tutorial mit Bildschirmaufnahme, Vlog), wo sie posten (YouTube, Shorts, Instagram, TikTok, LinkedIn), eine Markenfarbe für Untertitel (Hex oder einen Farbnamen, den du umwandelst) und alle Namen oder Markenwörter, die Whisper richtig schreiben soll.
5. Führe setup_studio.py --path ... --name ... [--inbox ... --projects ... --exports ...] --content "..." --platforms youtube,shorts --accent "#..." --vocab "Name, Brand" aus. Es schreibt studio.json, eine CLAUDE.md (damit jede Claude-Sitzung, die im Ordner geöffnet wird, weiß, was zu tun ist), README.txt und die Ordner.
6. Sage ihnen: "Lege Rohmaterial in 1-inbox ab und sag mir dann 'bearbeite mein neues Video'." Biete an, den Ordner zu öffnen (open "<pfad>" auf dem Mac).

Ein Video bearbeiten (die Hauptaufgabe)

Jedes Video erhält einen Arbeitsordner P = <studio>/<projects>/<JJJJ-MM-TT name>/ und einen Export-Ordner E = <studio>/<exports>/<gleicher name>/. prep.py --name erstellt beide und gibt sie aus; verwende diese Pfade für jeden späteren Schritt (sie werden auch in P/project.json als exports gespeichert).

1. Aufnahme. Liste den Posteingang auf. Wenn es mehrere Dateien sind, frage, ob sie ein Video (mehrere Takes oder Teile) oder separate Videos sind. Stelle eine Frage zur Absicht, wenn es nicht offensichtlich ist: Für wen ist es und was soll der Zuschauer am Ende tun oder fühlen? Notiere die Ziellänge, falls sie eine haben.
2. Vorbereitung. prep.py --name "kitchen tour" --move-raw "<inbox>/file1.MOV" ["<inbox>/file2.MOV" ...] erstellt P und E (am Ende ausgegeben), verschiebt die Rohdateien in P/raw/ und erstellt schnittfreundliche Quellen (konstante Bildrate, korrigierte Rotation, HDR-Handyaufnahmen auf SDR gemappt, Arbeitsgröße 1080p), 48-kHz-Audio und gemessene Pausen. Quellen werden in der angegebenen Reihenfolge a, b, ... genannt. Es dauert etwa eine Minute pro Minute 4K-Material. Verwende --max-height 2160 nur, wenn sie einen 4K-Export wünschen oder tief in das Bild für Kurzclips hineinzoomen werden. Um später Material zu einem bestehenden Projekt hinzuzufügen: prep.py --project "$P" <file>.
3. Transkribieren. transcribe.py --project "$P". Lese dann P/src/<id>.transcript.txt vollständig. Wenn Whisper einen Namen oder eine Marke falsch verstanden hat: fix_words.py --project "$P" --src a --replace "Falscher Name=Richtiger Name" (behält die Timings bei) und speichere die richtige Schreibweise für das nächste Mal mit python3 "$KIT/scripts/setup_studio.py" --path "<studio>" --vocab "Richtiger Name" (es fügt hinzu, überschreibt nie).
4. Plane den Schnitt (siehe reference/editing-craft.md). Entscheide die Geschichte: den Hook (die ersten 3 bis 8 Sekunden: die interessanteste wahre Zeile, kann von später stammen), den Hauptteil in einer logischen Reihenfolge, ein sauberes Ende (kein "Ähm, ja, das war's"). Finde Wiederholungen mit words.py --project "$P" --src a --find "Phrase" und behalte die letzte gute. Schreibe P/cuts.json (Format in reference/formats.md): Spannen in Ausgabereihenfolge, from = die Startzeit des ersten gewünschten Wortes, to = die Startzeit des letzten gewünschten Wortes (der Clip läuft dann bis zum Ende dieses Wortes plus einem kurzen Nachlauf, endet also etwas nach to). Standard tighten und punch_in aus studio.json long_form. Um genaue Wortzeiten zu sehen: words.py --project "$P" --src a 61 75.
5. Erstelle die EDL. cut.py --project "$P" --cuts "$P/cuts.json" --out "$P/edl.json", lies dann P/edl.txt. Jeder Clip muss mit einem vollständigen Gedanken beginnen und enden. Behebe alles, was als MID-WORD markiert ist, ein Clip, der auf "und", "also", "aber" endet, oder eine wiederholte Phrase über einen Schnitt hinweg. Verwende words.py ... <von> <bis>, um genaue Wortzeiten um einen Schnitt herum zu sehen. Iteriere, bis das Vorgelesene wie ein sauberes Skript klingt.
6. Vorschau, dann Master. Rendere bei allem über 3 Minuten zuerst eine Vorschau des riskantesten Abschnitts: render.py ... --preview --only 0,1,2,3. Dann den Master: render.py --project "$P" --edl "$P/edl.json" --out "$E/<name>.mp4". Eingebrannte Untertitel nur, wenn studio.json es sagt oder sie es verlangen (--captions "$P/captions.json" nach Schritt 7); YouTube-Langformen bekommen stattdessen normalerweise eine separate .srt-Datei.
7. Untertitel und Kapitel. captions.py --project "$P" --edl "$P/edl.json" --srt "$E/<name>.srt" --json "$P/captions.json". Lese die .srt einmal auf falsch gehörte Wörter durch; korrigiere mit fix_words.py und führe erneut aus. Erstelle bei Videos über etwa 4 Minuten P/chapters.json und führe captions.py ... --chapters aus, um YouTube-Kapitelzeilen zu erhalten (erste bei 0:00, 3 oder mehr, jede mindestens 10 s).
8. QA-Prüfung. qa.py --video "$E/<name>.mp4" --project "$P" --edl "$P/edl.json". Lese <name>.qa.md: Jedes FAIL muss behoben werden; jede AT A CUT-Zeile bedeutet ein wahrscheinlich abgeschnittenes Wort, also passe diese Spanne an und rendere neu. Sieh dir <name>.sheet.jpg an (verwende das Read-Tool für das Bild) auf schwarze Frames, schlechte Bildausschnitte oder eine Unschärfe, die nicht getroffen hat. Siehe reference/qa.md.
9. Kurzclips (wenn sie Kurzform posten; Standardanzahl aus studio.json shorts.count): siehe nächsten Abschnitt.
10. Ausliefern. Schreibe E/REVIEW.md (Vorlage in reference/review-template.md): was du erstellt hast, die Laufzeit, was du geschnitten hast und warum, jede Entscheidung als umkehrbare Entscheidung mit ihrem Zeitstempel, die QA-Ergebnisse und vorgeschlagene Titel, Beschreibung und Hashtags, geschrieben aus dem, was tatsächlich gesagt wurde. Sage dem Benutzer dann, wo die Dateien sind, und bitte ihn, sie anzusehen und Änderungen mit Zeitstempeln zu schicken.

Kurzclips erstellen

Lies zuerst reference/shorts.md. Kurzversion:

1. Wähle Momente aus dem Transkript aus, die für sich allein stehen: eine starke erste Zeile (eine Behauptung, eine Frage, eine überraschende Zahl, ein Geschichtenanfang), eine Idee, eine Pointe, 15 bis 59 Sekunden. Ordne sie und schlage die besten studio.json shorts.count dem Benutzer vor, jeweils mit einer Zeile, es sei denn, er hat gesagt, mach einfach. Wenige gute Kurzclips sind besser als Auffüllen: Eine 1- bis 2-minütige Aufnahme ergibt normalerweise 1 oder 2. Wenn die gesamte Aufnahme bereits kurz ist, ist die vertikale Version der besten 30 bis 59 Sekunden der Kurzclip.
2. Eine Spezifikation pro Kurzclip in P/shorts/shortN.json (Format in reference/formats.md): Spannen, eine Hook-Überschrift in den eigenen Worten des Sprechers (2 bis 7 Wörter, *ein* Wort in der Akzentfarbe), Untertitel-Stil, optional caption_holds für Abschnitte, in denen Wort-für-Wort-Untertitel Rauschen wären (eine Liste, ein Telefonat, Musik).
3. Zuerst Standbilder: short.py --project "$P" --spec ... --out "$E/shorts/shortN.mp4" --stills "$P/shorts/stillsN" --at 0.5,3,10. Sieh sie dir an: Gesicht im Bild, Überschrift lesbar und nicht im Gesicht, Untertitel bedecken nicht den Mund oder die unteren 15% (dort leben die Plattform-Buttons).
4. Rendere ohne --stills, dann qa.py --video ... --project "$P" --spec ... für jeden.
5. Schreibe niemals selbst einen durchgehenden Redeabschnitt als mehrere Spannen (überlappende Kanten verdoppeln das Audio an den Übergängen). Eine Spanne pro durchgehende Strecke; tighten teilt sie dann sicher an langen Pausen, daher ist es normal, im Vorgelesenen mehrere Clips pro Spanne zu sehen.

Revisionen

Der Benutzer wird Notizen schicken wie "1:32 schneide diese Pause" oder "Kurzclip 2 startet zu langsam". Bilde die Ausgabezeiten mit edl.txt zurück auf die EDL ab (es listet den Ausgabestart jedes Clips auf), ändere cuts.json oder die Kurzclip-Spezifikation, führe Schnitt und Rendering erneut aus, führe QA erneut aus und aktualisiere REVIEW.md mit dem, was sich geändert hat. Wenn eine Notiz eine dauerhafte Präferenz ausdrückt, speichere sie in studio.json.

Extras auf Anfrage

• Datenschutz-Unschärfe: Füge "blur": [{"src","t0","t1","rect":[x,y,w,h]}] zu cuts.json hinzu (Quellpixel; finde sie aus einem Standbild über sheet.py --times). Mehrere kleine Kästchen auf dem privaten Text schlagen ein großes Kästchen über einem Fenster.
• Pieptöne oder Stummschaltungen: "mutes": [{"src","t0","t1"}] in cuts.json oder der Kurzclip-Spezifikation.
• YouTube-Upload-Kopie: Erstelle für Videos mit Text auf dem Bildschirm upload_copy.py --master ... --out ...-1440p.mp4 (YouTube gibt 1440p-Uploads eine viel bessere Kodierung). Siehe reference/platforms.md.
• Thumbnail-Frames: sheet.py "$P/src/a.mp4" "$P/thumb-candidates.jpg" --every 4 und wähle ausdrucksstarke, scharfe Frames aus; exportiere eines mit ffmpeg -ss <t> -i src -frames:v 1 thumb.png.
• Alles, was dieses Kit nicht kann (Multi-Kamera-Synchronisation, Farbkorrektur, Bewegungsgrafiken, Musikbetten): Sage es klar und schlage vor, es im Editor der Wahl des Benutzers aus dem Master zu machen. reference/troubleshooting.md enthält bekannte Lösungen.

Referenzdateien

• reference/editing-craft.md: Wie man entscheidet, was geschnitten wird, Tempo, Hooks, Enden
• reference/formats.md: cuts.json, edl.json, Kurzclip-Spezifikation, studio.json, chapters.json
• reference/shorts.md: Auswahl und Erstellung von Kurzclips
• reference/qa.md: Die Qualitätskontrolle und wie man sie liest
• reference/platforms.md: Export-Spezifikationen und Lautstärke pro Plattform
• reference/troubleshooting.md: Leises Audio, Handy-HDR, Whisper-Timing-Eigenarten, langsame Rechner
• reference/review-template.md: REVIEW.md-Layout