Skip to content

konradre/video-production-skills / skills/video-finish-qc

video-finish-qc

Verified

Runs the FINISH of a whole spot from its EDL — part of every video job; a builder's render before it is PRE-FINISH — and the QC of the delivered master: the per-shot upscale tier (after approval and a cost line), the per-shot normalise, the hero pass, the three-stage finish (graded cut, master, deliverable), the finals run, and the one-pass QC (duration, loudness, true peak, cuts, take-cut leaks, VO placement, the finish against the previous version). Use when approved keepers must be upscaled, shots normalised, a hero pass is due, a spot must be rendered from its EDL, finals are requested, or a delivered file must be verified or sent. Triggers — "upscale the keepers", "run the hero pass", "normalise the shots", "apply the ads look", "has it been finished", "render the spot", "finish it", "final renders", "QC the deliverable", "rogue frames", "is the loudness right", "send me the 1080p", "starlight on the wides". Not for the per-clip ordering doctrine — use video-finish. Not for the cut or the beat gate — use video-edit-edl. Not for voicing or sourcing the sound — use spot-audio-assembly. Not for LUFS mastering of a standalone mix — use mastering-audio.

FileKindSize
SKILL.mdskill md32.3 KB
references/FAQ.mdmarkdown3.4 KB
references/PIPELINE.mdmarkdown13.7 KB
references/QC.mdmarkdown26.4 KB
scripts/aac_packet_clock.pyexecutablescript7.8 KB
scripts/decoded_checks.pyscript65.1 KB
scripts/final_renders.shexecutablescript1.9 KB
scripts/finish_clip.pyexecutablescript11.9 KB
scripts/finish_spot.pyexecutablescript41.0 KB
scripts/hero_distinct.pyexecutablescript2.1 KB
scripts/hero_pass.shexecutablescript3.8 KB
scripts/look_sheet.pyscript9.7 KB
scripts/matrix_check.pyexecutablescript23.6 KB
scripts/normalise_shots.pyexecutablescript18.9 KB
scripts/phone_texture_probe.pyscript7.0 KB
scripts/qc_deliverable.pyexecutablescript61.8 KB
scripts/upscale_fal_topaz.pyexecutablescript8.5 KB
scripts/upscale_local.shexecutablescript3.4 KB

references/QC.md

View on GitHub
# The QC of a finished spot — per metric, with its label

Nothing is graded by a total score: the number decides pass/fail and the label decides what to change.
`COMPLETED`, a big file, a passing per-shot check — none is success; the DELIVERED file is what is read.

## On every hero / mezzanine (before the cut)

| check | how | fail reads as |
|---|---|---|
| bit depth and raster | `ffprobe … stream=codec_name,pix_fmt,width,height` — `yuv422p10le`, the expected raster | 8-bit banding in mist and gradients; a padded width (CineForm ×16) needs a crop on the deliver leg |
| completion | the tool's sentinel in the log (`TOPAZ-UPSCALE-OK`, `RHEA-OK`, `HERO-PASS-END`) | a truncated mezzanine shortens the deliverable silently |
| distinctness | `hero_distinct.py a.mov b.mov …` — frame hashes, not byte sizes | a stale render served from a cached media-pool path |
| cut boundaries | 3–4 frames after every internal cut of the upscaled file at 1:1 (`video-take-review` `window_frames.py`) | temporal models smear across cuts; the thinnest-bitrate input comes back mushy first |
| Starlight shots | identity across cuts (a small face is reconstructed plausibly, not faithfully); invented small text (a door sign grew lettering) | a wrong face or fake text in a wide |
| the grade | a 1:1 crop of graded vs ungraded on a highlight (halation = a warm bleed) and a flat area (grain = texture); NEVER a grep of the `.drx` | a doubled grain pass; a look that crushed the subject |
| hero vs its flat | `normalise_shots.py verify`: 10-bit, the flat's raster and frame count, the flat starting at pts 0, mean \|dY\| > 1/255 (the look reached the file), a (0, 0) phase correlation of the luma (no crop, scale, weave or warp), and the hero's middle frame matching the flat's frame m rather than m ± 1 | a flat that started at 0.041 s: Resolve rendered one extra leading frame and every hero sat one frame late (2026-09-26); a look that never applied |
| the normalise | hero saturation and clipping per shot against the target: median chroma of the client shots ≈ the approved grade's, clipping ~0 % | mapping the percentiles to 0/1 clipped 7–30 % under the look's own gain; the Dehancer hero landed ~27 % under the cube's saturation estimate (heroes 0.0249 against 0.0302 until `--t-scale 0.91`) |

## On the delivered file — `qc_deliverable.py` in one pass

| metric | pass | the failure it catches |
|---|---|---|
| duration vs `runtime_s` | < 50 ms | a truncated stage; a stale master under a new EDL |
| loudness I · LRA | within 1 LU of the EDL target and **finite** | an audio-STREAM check is not a SOUND check: a conforming AAC track at −inf ships silent |
| true peak | ≤ the platform ceiling (the EDL's `loudnorm.TP_ceiling`, else −1 dBTP); the EDL's TP is the master's limiter ceiling under it, exceeded by 0.4–1.0 dB of AAC overshoot that grows with how hard the limiter works | a hot transient past a static gain with no limiter; a limiter placed only AFTER the resample (measured −1.0 dBTP against −2.0 before / −2.1 both); a quieter premix pushed harder into the limiter (a −1.5 target delivered −0.9 where earlier versions overshot 0.2) |
| AAC packet clock | every packet one frame (1024 samples) and every start one frame after the last, priming and a short final packet aside (`aac_packet_clock.py`) | a timestamp jump before the encoder written as ONE overlong packet, so every later packet plays late — loudnorm's flush of a partial 100 ms block: +80 ms at 38.805 s of a 41.720 s edit (bridgeclip, 25 of 27 clips; reproduced here in 5 of 6 durations). The stream start, the duration and a raw-PCM decode all miss it |
| frame 0 vs the background | with `qc.frame0_bg`: frame 0's median RGB DECODED as a player would (the range tag honoured), within 2 code values (`decoded_checks.py`) | a limited-range master read as full range: black lifted to 16 while every tag row passes — the tags lie about the content |
| range read (WARN) | the Y code values of 8 sampled frames against the colour-range tag | full-range content under a `tv` tag (it clips) or limited content under `pc` (its black shows grey) |
| loop seam | with `qc.loop`: the last frame against the first, beside the clip's median frame-to-frame step | a visible jump every time the platform loops the clip |
| poster (frame 0) | frame 0 is the platform thumbnail (X, Slack, Discord): not near-black — or, with `poster_at`, the finisher bakes that frame into frame 0 and the row reads it back; `qc.poster: "none"` declares a black first frame. With `poster_at`, a WARN line also reads frame 0 against frame 1 beside the clip's median step: a poster unlike the opening shows for one frame at autoplay before the film. Never a FAIL — the chosen thumbnail is kept; pick the poster from the opening, or compose the opening as the hook | a black or mid-fade thumbnail on every share; a one-frame flash at autoplay |
| sfx in the mix | every `audio.sfx` cue located in the DELIVERED mix at its time by correlation (≥ 0.2), its level against the mix printed; a sample over 5 s with no `dur` flagged | a hit the preview played and the render buried or dropped |
| beat cuts | with `qc.beat_data` (`beat_grid.py` JSON): every `on_beat` event's cut within 3 frames of the nearest beat | a cut that should land on the beat drifting off it |
| delivered cuts vs EDL joins | every extra detection named: a take's own cut, a declared accepted cut, motion, or a LEAK | rogue frames at a join the eye missed |
| take-cut leaks | no hero window crosses its take's own scene cut, except the cuts the event declares in `accepted_cuts` (printed as INFO) | the out-point past the take's internal cut. A cut the take COMPOSED inside one long generation and the operator kept is not a leak — declare it on the event: a row that fails a chosen keeper on every render teaches every reader to skip the verdict line |
| end card | NCC ≥ 0.9 of the final's last frame vs the card render's last frame | the wrong card version on a final |
| VO placement | every line < 15 ms by envelope NCC (`spot-audio-assembly`); an EDL with no placed VO line (a compilation whose voice-overs are picture events with their own sound) prints INFO, never a FAIL | a stale stem; a shifted insert |
| stray frames at event edges | `decoded_checks.edge_frames` on the motion row's frames: a change inside the first or last 7 frames of a footage event — the join's own change outside the window, every declared edge (accepted_cuts, captions, `qc.accepted_flashes`) set aside — over 10 levels, over 4 × the event's median change and over 3 × the larger change beside it (an isolated spike: a pan or a gesture is a run of similar changes and does not fire); `accepted_edge_frames` {head\|tail: why} prints as INFO. A judgement row under `qc.native_programme`, a WARN line elsewhere (the thresholds are leads from one compilation: fast motion at a cut can cross them) | a frame of the take's neighbouring shot or card, or a black first frame, at a cut — one frame long, invisible to a 1 fps tile and to the cut lists read off the take before the seek and the hold decide which frames reach the render. Measured 2026-10-22: two frames of the next camera angle at a bite's tail read 56 against a median 1.2; the same excerpt without them, and all 31 footage events of the whole render, read nothing — before the spike test a photo pan and a gesture at two heads read as stray. Fix: move the in or out off the stray frames; declare only a change the take makes on purpose. Blind to a stale burned-in caption on the same shot (a few hundred pixels change, not the frame) — read the frame strip at every trimmed edge |
| cut edges (no word bitten) | every join where a take's own sound plays (`native_audio_vol` > 0, or `qc.native_programme`): the 20 ms before the join's last 10 ms and the 10 ms after its first 10 ms on a broadband envelope (sibilants included) against the programme's p90 — BITE within 15 dB, TIGHT within 22 dB; a join under a VO line, an sfx or a cue is listed to listen to, never judged; `accepted_edges` prints as INFO (`video-edit-edl` `edge_audit.py --deliv`). NOT READ — an EDL that never says whose sound plays (no `qc.native_programme`, no `native_audio_vol`) over a take that carries sound — FAILS the row with the declaration to add: a pass after reading nothing is no pass. A judgement row under `qc.native_programme`; on an EDL with earned native beds only it is a WARN line — the read is of sound, not words, and a knock cut on its hit is meant | a word cut off at a cut — heard at once, measured by nothing else; the transcript put a word's end 0.19 s before its sound (2026-10-22). A cross-check, not the gate: it skips the 10 ms either side of a join, where a hard cut rings through the band filter; the take-edge read (`edge_audit.py` on the EDL) is the gate |
| per-event A/V sync | for every event with native audio and a hit: locate the hit's RMS peak in the delivered file and assert the picture event on the frames at that time; the cut stage's source seek explicit (`handle_head` = where `in` sits in the source; full-take heroes ⇒ `= in`) | an offset that lives INSIDE one event — a join tile cannot see it; the seek-convention defect shipped a wrong first render |
| **format rows** — frame, codec, colour tags, fps / CFR, faststart, audio format | the EDL canvas with 1080 on the short side · H.264 High `yuv420p` · BT.709 primaries + transfer + MATRIX · `r_frame_rate == avg_frame_rate` at the EDL fps · `moov` before `mdat` · AAC 48 kHz stereo | the standing "1080p masters only" rule had no instrument row; every shipped final carried an UNTAGGED matrix (`color_space=unknown`) until the deliver encode set `-colorspace bt709` (2026-09-10) — a metadata-only fix: `-c copy -bsf:v h264_metadata=colour_primaries=1:transfer_characteristics=1:matrix_coefficients=1` |
| black / frozen frames | no black run ≥ 0.1 s except a trailing fade or one inside what an event's `accepted_black` declares — the whole event (a title, a kinetic-type VO, a card on black) or only its `{"why", "src": [[a, b]]}` windows (a source's own dip inside a moving event, so the rest stays checked) — INFO; the black row ignored the declaration until 2026-10-23 and failed 34 designed runs); no still run ≥ `qc.max_still_s` (0.5 s by default; the project sets it) inside the footage span, the longest run printed; a designed hold declares `accepted_still: "<why>"` on its event and prints as INFO (the card holds by design), and a still the source itself holds inside a moving event declares only its window (`{"why", "src": [[a, b]]}`, EDL-CONTRACT) so the rest of the event stays checked. The row's floor prints beside it: freezedetect's −60 dB tolerance is 0.26 code values; when even the quietest still frame pair reads over it, the row is BLIND (a WARN line) — read the held shots by eye; `qc.grain_after: true` (the finish lays grain over the picture) prints it BLIND outright. The floor is the quietest still pair, so it misses two cases: a duplicate frame after the grain reads 0 and hides the grain, and grain on some shots only is listed, not flagged | a hole from a missing layer or a truncated stage; a stalled overlay; a type beat that held one frame for 10 s while only the footage behind it moved. Blind: grain or a living ground laid over the picture after a stall lifts every pair — every grain fixture from a decoded σ of 0.66 passed a frozen hero (2026-10-10); a stalled source on its own repeats its frame and reads 0 |
| pops (WARN) | none: a frame unlike both neighbours while they match (`decoded_checks.py`; `qc.accepted_flashes` declares a designed one) | a one-frame flash — a stray frame, a layer that blinks; floor: a ~2-level step of the frame mean (~1.5 % of the frame at a 135-level flash in a quiet scene), so a small element's flash goes unseen |
| steps (WARN) | none off the frames the EDL changes on purpose — the joins, each event's `accepted_cuts`, every caption card's on and off, `qc.accepted_flashes` — set aside on the EXACT frame | a value that jumps in one frame and holds: two tweens fighting over one property, a 3D object's fade snapping at its end (`designed-elements` HYPERFRAMES-CONTRACT § Silent traps) — a large element only. On three shipped spots (39 steps) the declared edges cleared all but a worded end card's own word lines: the card's event declares those in `accepted_cuts` |
| flash rate (FAIL, judgement) | at most 3 general flashes in any one second over the WHOLE frame (the broadcast area), read per place (`decoded_checks.flash_read`): a place brightening and darkening — or the reverse — by ≥ 0.1 relative luminance within one second, its darker side under 0.8, however many frames each swing takes; a flash counts when the places flashing on one frame cover ≥ 25 % of the frame. A strobe the piece means declares its time window in `qc.accepted_flash_rate` (`[{"from", "to", "note"}]`): its flashes print INFO with the note on every run | a seizure-risk strobe, a smooth pulse included (the frame-to-frame row it replaced read one at 0); measured at most 1 a second on 59 reads — 20 delivered files, 39 designed renders and layers |
| sustained flashes (FAIL, judgement) | no 2–3 flashes a second held for 4 s of any 5 s, whole frame — EA IRIS's extended failure (`src/TransitionTracker.cpp`), counted in flashes on the same read (IRIS counts transitions, two to a flash); IRIS's warning, 2 or more flashes in a second, prints as a WARN line | a long strobe just under the 3-a-second row; none on the 59 reads. On IRIS's own 8 test clips its fail and extended verdicts match IRIS's expected logs, and it warns on two IRIS passes (at 1.5 flashes a second two can complete inside one second) |
| flash rate in a 10° field (WARN) | at most 3 in WCAG 2.3.1's area, 25 % of any 10° field — the phone window (10° at 35 cm: 0.94 × 0.53 of a 9:16 frame); the W3C window (341 × 256 on a 1024 × 768 screen) printed as INFO, since per place it counts a fine texture's swings (17 a second on falling gravel) | a strobe on part of the frame the whole-frame row cannot see; on the 59 reads it warns only on a frame-filling burst of tumbling pieces (4–5 a second) — WCAG counts opposing changes whatever moves them, so read it on its frames |
| red flashes (WARN) | at most 3 in any one second over the whole frame or the phone window (W3C as INFO): WCAG 2.2's red — a move to or from a saturated red (R/(R+G+B) ≥ 0.8, linear sRGB) with the colours more than 0.2 apart in u′v′, read per place | a red strobe at even luminance, which the general rows cannot see; at most 1 a second on the 59 reads, every hit a red diagonal wipe |
| source geometry | INFO: every hero take whose display shape differs from its storage shape (SAR ≠ 1:1, a rotation tag), from the take's own probe; the eye check is a delivered frame beside the source's display frame at 1:1 — a circle stays a circle | 11 of 17 client clips stored anamorphically were read as square pixels and every render stretched them 3.16× wide; no row compared a delivered frame with its source (2026-09-15) |
| vs the previous version | `--prev <file>`: each footage event's middle frame against the same timeline frame of the previous version and its two neighbours — **regraded** (mean \|dY\| > 1/255, phase (0, 0), best structural match at m), **moved** (no neighbour lines up at (0, 0): a crop, scale or warp), **retimed** (a neighbour lines up: a one-frame slip), **same**; `--prev-expect finish` fails anything but regraded, `--prev-expect changed:<ids>` fails a named event that reads same at its middle AND at four frames near its two edges (a change confined to a tail hold, a fade or a trim never reaches the middle), a designed event read at its edges too; an event still the same is read TILE-WISE at its middle, edges and `--prev-scan` frames (32 × 18 tiles: ≥ 3 levels and ≥ 4 × the median tile + 2 — a pop-up's text, a name label); `--prev-expect same` passes a byte-identical copy, or every event the same tile-wise; `--prev-edl` reads each event at its own place in the previous version, an event it lacks reads `new` | a finish that doubled the first frame of 14 of 22 events — a half-frame in-point into the hero quantised to a rounding tie in the builder's `fps` filter — while every per-hero row passed, and the approved version's own four doubled first frames (in-points at x.2 / x.4 of a frame) that read `retimed` until the in-points took the nearest frame (2026-09-26); a changed square crop that a builder's id-keyed cache never re-rendered; a changed pop-up time and a dropped name label that read `same` over the whole frame (0.27 and 3.6 levels; 15.6 and 166 in a tile), and a version with four VOs inserted whose every later event read changed at the same second (2026-10-29) |
| grain kept (WARN) | INFO per footage event: the high-pass frame-to-frame texture the delivered file keeps against the master it was encoded from, 7 frames from the event's middle, both at the delivered raster (`--master`, else `edit/mezz/<spot>-master-<W>x<H><tag>.mov` by the deliverable's tag; a renamed file, or a name two masters match, is not read). Motion-dominated events (plain over high-pass > 2.5) and textureless ones are named, not read. A WARN line under `--grain-warn` (70 %) — a lead from one film: a Dehancer 16 mm grain kept 47–100 % at CRF 17 film, 74–107 % at CRF 12 grain; its grain-free flats kept 100–106 % | a deliver encode that erased the look's grain — buy it in the EDL's `deliver_encode` (EDL-CONTRACT.md); compare the two encodes by eye first; a moving shot hides the loss from this read |
| platform contract | INFO: the colour range tag (`tv`), the keyframe spacing (a closed 2 s GOP = every 48 frames at 24 fps), the edit lists (0) — look-library GUIDE § 7 | a validator that rejects an open or irregular GOP; an A/V offset on a platform that ignores the edit list the muxer wrote for the AAC priming |
| colour matrix | INFO: a deliverable `finish_spot.py` wrote is named by its record in `edit/mezz/*.finish.json` (the file's sha256); any other render prints the `matrix_check` card run as **owed** unless the EDL records it in `qc.matrix_check` — § Builder renders | a builder that converts RGB ↔ YUV with BT.601 under a bt709 tag: saturated colour 40 levels off while every other row passes |

**Every row has a kind.** `format` rows are mechanically fixable — the agent fixes them alone (a re-mux for tags or
faststart, a re-encode at the right frame) and re-runs; `judgement` rows change the content — duration, loudness, cuts,
leaks, black frames, the card, placement — and go to the operator with the number. The summary line names the failures
by kind (`ffmpeg-skill`'s `check.py` drew the same line: "format rows are safe to fix mechanically; judgement rows
change the content").

Then the eye and the ear, on the delivered file: the grade at zoom at several timecodes over light and
dark backgrounds (never the first frame alone); the mouth check on every wide; the audio at every cut and every hit (a click, a doubled tone, a clash under the signature);
the captions' text against the VO variant. Every comparison instrument carries a known-answer case in the
same invocation (a file against itself must return `inf` / NCC 1.0): `ffmpeg -v error` suppresses the
PSNR summary line and an empty result reads as "identical".

## Builder renders — the colour-matrix card run

A render made by anything other than `finish_spot.py` — a project's own build script, a compilation builder — owes **one
`matrix_check.py` card run through that builder's exact decode and encode arguments before its first delivery**, once per
kind of input it takes: `matrix_check.py card <card.png>` for an RGB input (a still, a rendered layer), and
`matrix_check.py card <card.mp4>` for a video input — a known-correct BT.709 tv-range YUV video that the command measures
before keeping it, because the PNG card cannot see a wrong YUV decode (a BT.601 decode with a correct encode read 1 on the
PNG and 24 on the video). Put each through the builder the way it takes that input → `matrix_check.py measure <rendered
card> --max 3`. Record both results in the EDL as `qc.matrix_check` (the measured errors and the date). The finisher needs
no card run: its conversions are the ones `matrix_check.py --finish-e2e` covers. Each stage it runs leaves a provenance
record, `edit/mezz/<file>.finish.json` with the file's sha256, written only when the stage's input carries one too — so a
deliver-only re-run over an older master writes none — and `qc_deliverable.py` matches the delivered file against them. With
neither the record nor `qc.matrix_check`, the QC prints the card run as owed (INFO). A kit tool's own re-encode of a finished
spot — `video-finish/scripts/phone_native.py` — is covered by that tool's `--selftest` colour rows: declare it (`qc.matrix_check:
"phone_native.py --selftest"`) rather than re-run a card. Why: a builder that piped frames to
the encoder with no matrix named, under a bt709 tag, shipped three compilations 40 levels off on saturated colour while
grey, black and white read exact — every other row passed them.

## On a creator-style spot — the phone-texture band and the inter-shot spread

Two reads the product-spot rows do not carry; both are comparisons against the project's OWN real footage, never
thresholds, and both are INFO on the delivered file — the operator judges the phone render beside the clean one.

| check | how | fail reads as |
|---|---|---|
| the phone-texture band | `phone_texture_probe.py` on the delivered file AND the project's real phone clips as they arrived (`qc_deliverable.py --phone-ref <clips>` prints it as INFO): dead-flat 8×8 share, noise floor (the flattest 20 % of blocks), median block sd, on native centre crops at five points of each clip; the band is the RANGE over every reference frame; matched scene class or the median says nothing | the deliverable outside the real band on all three (measured 2026-09-16: a raw 720p Omni take read 3–4× the fine texture of two phone clips — the dose was a DENOISE and a 2.5 Mbps encode, not grain); the calibration in `video-finish` EVIDENCE.md § The phone-native tier |
| the inter-shot spread, BEFORE any global move | `video-take-review` `cut_consistency.py` across the spot's joins: light, contrast, white balance and palette as multiples of the take's own baseline; the saturation spread shot to shot | a spot that reads "unreal" whose black point and contrast measured healthy — the defect was a saturation spread of 79 → 130 across shots, and a global saturation lift would have pushed the worst shot further out (the retrospective's measurement, 2026-09-12) |
| the UGC tells, by eye | sound off first; hands and fingers on the product; a torso static > 6–7 s (`frame_psnr.py`); consonant lip drift in the first 1–2 s of a line; the product changing between shots; background warp on movement; a phone or a camera UI in frame; the face-on-screen budget — `video-take-review` ACCEPTANCE-MATRIX.md row 10 | any of them on a delivered frame; the fix is upstream (the take, the tier's dose, the cut), never a gain nudge |
| the upscale ratio (INFO, a hypothesis) | the deliverable's raster over the take's native raster | a ratio above ~2× on a talking head is a community warning ("upscaled AI look"), contradicted once here where the operator preferred the raw 720p take over its Starlight ×2 — record the ratio, never fail on it |

## On designed content — explainer scenes, kinetic titles, cards

A defect hunt passes a film that is small and dark: four QC rounds found nothing wrong with one (an upstream explainer
kit, 2026-09). Two judgement rows read what a defect list cannot:

| check | how | fail reads as |
|---|---|---|
| empty / small / still | `video-take-review` `designed_frame_metrics.py` on the DELIVERED file, the caption band cropped out (`--content`), the scene windows as `--shots` | a scene whose hero never reaches a third of the content box; nothing big on screen for more than 1.5 s; a narrated scene that enters and freezes (more than 40 % still samples, or a hold over 1.0 s). A card, a logo or a legal hold is still by design. BLIND on a scene whose grain or living ground lifts its floor over the still threshold: a frozen hero there reads 0 % still, so its holds are read by eye |
| on-screen text vs the approved copy | `designed-elements` `literal_audit.py <composition> --approved <copy>` on the SOURCE | a string no sampled frame showed — a counter's intermediate, a label on a transition, a stale kicker |
| motion on the render | `decoded_checks.py motion <render | frames-dir> --accepted <the element's own hard changes>` (repeatable: seconds, a caption manifest, an explainer's `compositions/captions.html` — each caption's show and hide — or its `timeline.json` — each scene cut) — pops, steps and the flash rows (the whole frame, the phone 10° field, red), every row a WARN; a frames-dir at its composition's data-fps unless `--fps`; `--tiles` adds a per-tile step read (4×4) as a LEAD: it reaches a small element's snap, and designed slams, wipes, bar slashes and shakes fire it too | a one-frame snap a viewer sees and no row named. Measured: the whole-frame read caught both engine two-tween steps and fired on none of 39 designed renders; per tile it fired on two designs — every hit on one kit was designed, and on a shipped card it caught one of three real snaps, 5 % over its threshold |

## Audio provenance

Every finish step earns a cheap verification immediately before it runs — a written plan is a set of
hypotheses. Two of five planned steps were wrong in ways the output would never show: "coarse grain, then
watermark" when the film-emulation `.drx` already lays grain, halation and bloom in the stock node (a 1:1
crop settles it), and "re-lay the real music track" when the edit's audio was not a clean slice of it (the
correlation below). Doubled grain looks like grain; a raw track looks like the music.

Never re-lay the raw music track over a processed mix — measure the correlation (0.146 against a 1.0
self-test); the graded intermediate's PCM audio is the best copy of a mix that was made in the grade.
Check what the grade pass emitted for audio before sourcing audio from anywhere else.

When the music seems to swell, or a second track seems to appear around the voice, read before re-mixing:
difference the short-term loudness against a static sum of the same parts (movement = processing), and read every
VO file's gap floor (a VO lifted from a finished cut carries its bed) — `spot-audio-assembly` MIX-AND-QC.md.

## Sending the result

The masters are 1080p only. A file ≤ 30 MiB may be sent in chat; a larger one is named by its full
path. Residual doubts go in the delivery note with their frame times, never as a re-roll question.
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 196kUpdated Claude CodeCodexVerifiedInstall