The main video-generation service had always been built around one assumption: somewhere in every run sits a reference video — a competitor's ad, or a past winner — that the plan gate measures the output against. Scene count is checked against the reference's cut count. Runtime against its runtime. Narration pace against its pace. Every one of those checks has a right-hand side because a reference always supplied one. Then an editor asked for a mode with no reference at all — just a script, because "your script is the whole brief." That single missing input turned out to be load-bearing under nearly every quality gate in the pipeline, and finding each place it was load-bearing took running real, paid jobs rather than reading the code.
A check that has quietly depended on an input for months doesn't fail loudly when that input disappears. It reports a pass — because zero minus zero still reads as "nothing lost."
Blocked from the day it shipped
PR #915 is the mode's origin story and its first bug in one PR. The route's own header read "No reference needed — your script is the whole brief," and the screenshot showed every step ticked, including a green "No reference" — directly above an error reading "missing referenceVideo file or link." The reject had been added to the request parser six weeks before the reference-less mode existed, and nobody had gone back to teach the parser about the new case when the mode shipped. The mode had never worked, not once, from the moment it went live.
A word budget with no speaker to measure
Once runs could actually start, PR #949 found every single reference-less plan logging the same warning on every run: four scenes over their word budget, every time, no exceptions. A warning that always fires teaches people to ignore the one time it matters. The cause was a clamp — budgetWps = min(refWps, ours) — where refWps silently fell back to a default whenever the reference's speaker hadn't been measured. On a swipe, that fallback is load-bearing: a real reference sits behind it most of the time. On a reference-less run, there is no reference speaker to measure, ever, so the fallback wasn't a fallback anymore — it was the only value the budget could ever see, quietly capping every script-only run at the same generic delivery rate regardless of what the actual voice model could speak.
A prompt that argued with itself
PR #948 is the fix I'd point to as the cleanest example of the whole arc's failure shape. The reference-less planner prompt opened with an explicit, correct instruction: "THE SCRIPT IS THE ONLY SOURCE OF STRUCTURE — there is no reference ad, and nothing about one is being withheld from you." Measured by actually building the prompt sent to the model — not by reading the template that assembles it, which the team's own engineering notes insist is the only way to know what a model actually receives — twenty-some lines later the same prompt instructed the planner to mirror a reference anyway. A leftover block from before reference-less mode existed had never been removed, and it directly contradicted the instruction two paragraphs above it. The planner wasn't ignoring a correct instruction. It was being given two instructions and picking one.
The green tick that meant nothing
PR #955 found the sharpest version of the pattern running through this whole arc. On a real job with no reference, the plan gate displayed: "✅ Script fills the reference — No issues found." The underlying check compared the plan's scene count against the reference's cut count. There was no reference, so the right-hand side was zero. lostCuts = max(0, 0 - planScenes) evaluates to zero no matter what the plan actually contains, and zero reads as "lost nothing" — a structurally guaranteed pass dressed up as a measurement. The team's own documentation makes the same point about a different guard elsewhere in the codebase: answering "no file is over the line-count cap" while several files actually are is worse than answering nothing at all, because the number reads as evidence when it's actually an artifact of nothing being measured. The fix doesn't make the check smarter — it makes an unmeasurable check say unmeasured instead of quietly manufacturing a pass.
Four near-identical shots in one room
PR #954 is where the fixes so far collided with a genuinely new problem rather than a leftover assumption. A verification render, once the prompt no longer contradicted itself, came back with a presenter addressing the camera, two cutaway spans, and passing identity checks — and also four near-identical seated medium close-ups in one room, with internal-cut detection reporting no cut inside any clip. Forty-six percent of a 28-second ad was one unbroken thirteen-second take. Removing the contradictions had fixed who the ad addressed. Nothing had ever told the system how to shoot it, because on a swipe that answer always came from the reference's own cuts — there was no equivalent instruction for a mode with nothing to cut against. The fix is a beat grammar: an explicit shot-framing vocabulary keyed off the ad's declared format, so the system has somewhere to look for pacing and composition that isn't a reference video.
Cast from speaker labels, not a vision pass
PR #956 closes the same gap one layer up, on casting rather than shot framing. A swipe proposes its cast by running a vision pass over the reference and counting distinct speakers. A reference-less run has no video to run a vision pass over, so castProposal was simply never written, and the cast gate silently offered one solo slot on every run — even though the mode's own chooser told editors, in as many words, that the system plans the scenes, the cast, and the shots from the words. Two of those three were true. The fix proposes cast directly from the script's own speaker labels, which was information the input already contained and nothing had been reading.
Proving a negative for $0
PR #947 is worth calling out on its own, because of what it cost to find the problem it prevents recurring. Every existing diagnostic instrument in the pipeline — the plan gate, the fork replay, the free fork-scope quote, the render fleet — starts from either a reference video or an existing run. A script-only plan is neither, so the only way to see what one would produce was to start a real job and pay for it: $14.68, in this case, to discover the planner-prompt contradiction that PR #948 later fixed. The response was a standalone script that replays the real sentence-splitting and scene-count logic against a script file directly, for $0, plus a small corpus of known scripts that pin down what a correct beat count should look like — so the next time this specific question comes up, it doesn't cost fourteen dollars and a full render cycle to answer it again.
The same defect, six times
By the time the round's handoff was rewritten, what had started as "the planner still writes near-identical shots" had grown from four confirmed instances of the same root defect to six. Every one of them was the identical shape: a check, a budget, or a proposal step that had quietly depended on a reference being present, silently degrading to a default, a fallback, or a false pass the moment that reference stopped existing. None of them threw an error. All of them looked, from a passing test suite, like working code. The fix in each case wasn't cleverness — it was tracing one more input all the way from "the reference supplies this" to "what happens when nothing does," and refusing to let a missing measurement read as a good one.
The pattern
Building a genuinely new mode into a pipeline that has one deeply-ingrained assumption baked into it — here, "a reference video exists" — is less about writing the new mode's own logic and more about auditing every place downstream that assumption quietly leaked into. The parser assumed it. The word budget assumed it. The planner's own prompt assumed it, twice, contradicting an instruction two lines away. The plan gate assumed it hard enough to manufacture a false pass out of a zero-versus-zero comparison. None of those were bugs in the new mode. They were bugs in the old assumption, invisible for as long as the assumption held, and each one only surfaced once a real, paid run went looking for the answer instead of trusting that a green check meant what it said.