My AI makes YouTube videos. It's only allowed to publish after 21 automated checks.

I run a YouTube channel where an AI agent does everything — picks topics from its own
analytics, writes the script, renders the animation, directs its own text-to-speech, and
schedules the upload. The interesting part isn’t the generation. It’s the gate.

Nothing ships unless a quality gate passes. It started at 15 checks; it’s at 22 and
growing, because every check exists for one reason: something real broke, shipped, or
embarrassed us, and we never wanted to see it again. Here are the scars I learned the
most from.

What is an automated quality gate for AI-generated video? A script that runs
deterministic checks (motion energy, narration-gap detection, speech-recognition
diffs against the script) plus model judges (vision review of sampled frames, dual
scoring models over fixed thresholds) on every finished video, and blocks upload
unless all of them pass. The generator never gets a vote on its own output.

The check that was silently useless

The gate had a “no frozen frames” check from day one: compare consecutive frames,
fail if they’re bit-identical. It never fired. Not once.

That’s because it couldn’t fire — background grain and glow effects jitter at least
one pixel every frame, so nothing is ever bit-identical, and a completely static
30-second shot sails through. We found out when a human reviewer wrote the note the
check was supposed to make impossible: “bad to have still background, try to always
have something moving.”

The rewrite measures motion energy instead — mean absolute luma change over a
center crop, sampled twice a second. Below 0.05 for more than 10 seconds = fail.
Lesson: a check that has never failed isn’t a passing grade, it’s a smell.

The gap the music was hiding

An approved video shipped with a 4.8-second dead pause between two sentences.
silencedetect — the industry-standard answer — saw nothing, because the background
music covered the hole. The audio track was never silent; the narration was.

The fix: run speech recognition over the final master, then measure gaps between
transcribed speech segments, ignoring the music entirely. Cap: no single gap over
4.0s (our deliberate section-card holds measured up to 3.44s, so the cap sits just
above the intentional ones). The very next episode hit this check with a 4.72s gap.
It never reached a human.

The channel about AI that couldn’t say “AI”

Our TTS engine pronounced “AI” as something closer to “the eye.” Nobody noticed for an
embarrassingly long time, because nobody re-listens to every take.

Now a speech-recognition pass transcribes every generated take and diffs it against
the script: word error rate over 0.06 = regenerate. We render a few takes per line and
keep the lowest-WER one. This one check quietly fixes mispronunciations, dropped
words, and TTS glitches nobody would ever catch by sampling.

The judge that grades its own frames

The deterministic checks catch physics. Taste needs judgment, so the gate ends with a
vision model reviewing sampled frames against a 10-item checklist (text inside cards,
readable at phone size, nothing essential under the mobile UI overlay, no tooling
leaks) plus hard content rules that must never appear.

Two honest findings from running model-judges in production:

1. Vision judges are nondeterministic. The same video can pass one run and fail the next on a different item. We stopped treating that as noise — every “new” fail this week pointed at a genuine latent flaw the lenient run had let through.
2. A judged bar beats a vibes bar. Our exit rule is two independent models over fixed score thresholds plus a clean factual pass — with a hard iteration cap so the loop can’t spin forever.

Why bother

Because autonomy without a gate is a liability generator. The gate is what lets the
agent auto-approve its own uploads while I sleep: deterministic checks catch the
physics, model judges catch the taste, and the ship/no-ship decision needs zero trust
in the generator’s opinion of itself.

The annotated spec — 20 of them written up so far, the real incident behind each one,
and the exact production thresholds — is free (pay-what-you-want, $0 is fine):
https://join.mishkavids.me. The channel the gate protects: youtube.com/@mishkaai.

Every threshold in this post is the real configured number. Every incident actually
happened. That’s the whole point of a gate: it’s your scar tissue, executable.

Common questions

How do you automatically QA AI-generated YouTube videos? Layer deterministic checks
(motion energy for frozen shots, ASR-measured narration gaps, word-error-rate diffs
between transcript and script) under model judges (vision checklist on sampled frames,
two independent scoring models with fixed pass thresholds and an iteration cap).

Can an AI agent safely publish videos without human review? Only behind a gate it
can’t argue with: every upload in this pipeline is schedule-only, rate-capped, and
blocked unless the full gate passes — the human keeps a standing veto window.

Where can I get the checklist? The full annotated spec with production thresholds is
pay-what-you-want at join.mishkavids.me (the MishkaVids quality-gate kit).