Repository navigation
Pipeline
One stream in, a reviewed set of videos out:
flowchart TB
subgraph find ["1. Find the moments"]
direction LR
rec["fetch / record"] --> sig["signals"] --> tr["transcribe"] --> sc["score"] --> seg["segments"]
end
subgraph make ["2. Make the videos"]
direction LR
fa["faces"] --> cut["cut"] --> me["meta"] --> th["thumbs"] --> sh["shorts"]
end
subgraph ship ["3. Ship"]
direction LR
rv{{"review<br/>Kitsu · Discord · war room"}} -->|approved| sch["schedule"] --> up["upload to YouTube"]
rv -. "note" .-> rt["retake<br/>re-cut or re-cover, back to review"]
end
find --> make --> ship
Everything is a clippa <stage> subcommand working on one stream's folder, streams/<id>/.
Stages are idempotent: clippa run <id> does every stage the stream still needs, and
clippa run <id> --from cut runs from a stage on again (clippa run -h lists the stages). Four
of them are the fast lane's early versions for the picks, what the Shorts need first: clips,
clips_meta, clips_thumbs and clips_review are cut, meta, thumbs and review publish run on the picks alone, before the slow stages do the segments and compilations.
--only and --from choose stages, not what they redo: each keeps the paid work it finds
(drafts, covers, unchanged cuts), so to redo a cover or a draft run the stage itself,
clippa thumbs <id> --items s03 --force or clippa meta <id>.
- fetch / record: a finished Kick, Twitch or YouTube VOD (Fetching VODs), or a Kick stream as it happens (NAS recorder), with chat.
- signals: chat activity and loudness into a heat curve (the war room draws it).
-
transcribe: WhisperX (NVIDIA, or on Modal's cloud GPUs) or
mlx-whisper (Apple Silicon) to word timestamps; with
[transcribe] diarize, speaker turns too, named per show byclippa speakers(Speakers). Once a stream has names, the transcript the model stages read tags each turn ([PPP] ...,[?]for a voice nobody named,[music]), and the weekly credits a quote to whoever said it. -
score: Claude reads the transcript and heat curve and proposes moments and picks. A
rerun pays every window again, so it refuses without
--force. -
segments: Claude splits the stream into topic segments and compilations. A segment
longer than
[segments] split_over_s(0, off) is flagged for a re-split (respliton the segment, skip reasonre-split, aRESPLITline in the stage log) instead of being dropped for length. With[segments] score = true(off by default) one more call scores each cut segment 1-10 as its own upload, from the segment and the show's record per topic; see Segment scores. -
faces: who is on screen, by face, over every keyframe (CPU,
clippa faces): groups named against known faces kept for every show (Faces). The worker runs it after the fast lane, before the slow cut. -
cut: lossless segment cuts on keyframes, re-encoded picks, bleeps; a few segments at once,
on the NAS beside the source with
[cut] backend = "nas"(NAS recorder). - meta: titles, descriptions, tags, chapters and SRT captions.
- thumbs: tabloid-style covers (a 9:16 one for each Short), with photos from the cast library for people talked about but not on screen.
-
shorts: vertical captioned Shorts. With
[shorts] window = "short"each Short is the pick's scored hot-take moment (15-59 s here, under YouTube's 60 s Content ID block line), ending on a full sentence. Picks are also cut as horizontal clips; leave"picks"out of[review] includeto post only their Shorts. Each show's screen layouts are measured once (Adding a show). With[edit] tightenon, the dead air goes too (Tightening). - review: every item goes to Kitsu and Discord. Approve, reject, hold, or leave a note asking for a change. Notes become retakes: the item is re-cut or re-thumbnailed and comes back for review (Review, War room).
- schedule / upload: approved items get release slots and go to YouTube as private videos with a publish time (Scheduling and uploads).
Elsewhere after review: X posts, TikTok (by hand), and clippa rumble,
which prepares folders for Rumble's upload form.
[edit] tighten = true (per show: [shows.<key>.edit]; off by default) cuts the dead air out of
each Short as clippa shorts renders it. A pause between two words longer than max_gap_s
(0.7 s) is cut down to keep_gap_s (0.25 s), or keep_turn_s (0.45 s) where the voice changes so
a reply keeps its beat. It only cuts where the audio is quiet too (under silence_db, -35 dB):
a laugh, a video playing or a reaction in a gap stays. No cut is under min_cut_s, none reaches
into a word or a bleep, and a Short never drops under [shorts] min_s. Captions and scene
changes move with the cuts.
The Kitsu "Tightened" column says what went ("3 pauses, 1.6 s"); the Short's sidecar lists each
cut with the words either side, and a retake is told where they were so a note's times still
land. To put one Short's pauses back:
clippa shorts <stream> --items v03 --no-tighten (--tighten undoes it), then
clippa review publish <stream> --only shorts. Tried on the test stream on 2026-11-09: about
1.5 s out of a 30-40 s Short at these settings.
clippa pick is for when you watched the show and know where the good bits are:
clippa pick <stream> --from 4:05:00 --to 4:25:00 --about "the Quartering bit" (or
--at 4:50:00, or only --about, which searches the stream's summary first; --find <word>
lists transcript lines for free). Times are the Kick VOD's clock. The moments found join the
stream's picks (ids h01...) and go through cut, meta, thumbs, Shorts and review like scored
ones; --dry-run shows them without saving.
clippa worker runs the pipeline for each recording as it finishes. Clips and Shorts come
first ([worker] fast_lane): once a stream is transcribed and scored, its picks and their
Shorts are cut, written up and sent to review (roughly an hour after an 8-hour show ends), and
only then does the worker cut the long segments and compilations, which take hours. A newer
stream's clips go ahead of an older stream's segments. clippa worker --status shows each
recording's stages.
Warning
Model calls cost money. Check what a rerun of score, segments, meta or thumbs costs
on a long stream first (Costs).
score refuses a rerun without --force (clippa run --from passes it), cut keeps picks
whose in/out points are unchanged, thumbs keeps a cover whose cut is unchanged, and
weekly --render never drafts.
Pre-shows and one-off YouTube videos take a shorter path: one whole video, no clips or Shorts.
Which of a stream's segments go out is decided by its budget, and the budget ranks segments by
chat heat, which barely tracks views (what predicts views).
A segment score is a model's guess instead (clippa/segscore.py, prompt segment_score_v1):
one call per stream sees every cut segment (title, summary, topic, kind, how much is someone
else's video) and the show's track record, the median and best 7-day views of its earlier
uploads on each topic, and scores each 1-10 against the show's typical upload, with one
sentence of why.
clippa segments <stream> --score --dry-run # what it costs (a few cents on summaries)
clippa segments <stream> --score # into segments.json: score, score_why
clippa segments --backtest --dry-run # every past stream, as of its start
clippa segments --backtest [--transcript] # -> segment_scores_backtest.json per stream
clippa analytics --lift --kind segment # the bt / bt_tx rows: did it rank them right?[segments] score = true scores each new stream after its split; score_transcript sends each
segment's transcript too (~100k tokens for an 8 h stream, about $0.40 on Opus). The backtest
scores past streams with the track record cut off at each stream's start, so nothing learned
later leaks in, and writes beside segments.json, never into it. A stream's own uploads are never
in its own record. Pre-shows and stories are one whole video and aren't scored. The model now
and then passes over a segment on a touchy subject: it is asked once more, and what it still
leaves out stays unscored.
The budget ranks a stream's segments by the score (#258 C): each segment's score plus half its
chat-heat percentile in the stream, so heat only breaks ties between equal scores, and a
segment the model passed over gets the stream's median. A stream without scores, or with a
segment cut after the score ran, is ranked by heat alone: one ranking never mixes the two. A
compilation takes its best segment's score. Kitsu's Score column on a segment shows it; editing
it there changes nothing (the score lives in segments.json). On this install [segments] score
is on since 2026-11-14 (the backtest: level with heat on Kino, clearly better on Channel 404).
Home · Getting started · clippa doctor · These pages are built from docs/wiki/ in the repo, so edits made here are overwritten: how to edit them
Run it
- Overview
- Getting started
- Roles and services
- Configuration
- Pipeline
- Review
- Reviewing
- War room
- Clippa messenger
- Scheduling and uploads
- Costs
- Checkup
- Audit
- Backups
Install
- Install
- Install checklist
- Kitsu
- Discord app
- YouTube sign-in
- Windows
- macOS
- Transcribe on Modal
- NAS recorder
- NAS hub
- Claude on the NAS
- Phone access
- Model providers
- Adding a show
- YouTube channel
Features
- Pre-shows
- Fetching VODs
- Speakers
- Faces
- Covers
- Cast library
- B-roll
- Clip art
- Weekly issue
- X posts
- TikTok
- News watcher
- Character pieces
- Documentaries
Research
Working on Clippa