The combination that ships: deterministic pipelines plus AI generation

01What is a deterministic AI workflow?

One where the generative part is wrapped in a path that behaves the same way every time. The model still invents the shot. Everything around the shot, the layout, the durations, the type floors, the delivery spec, is computed rather than chosen, and a violation refuses the render instead of producing a file somebody has to catch later.

The test for whether yours is deterministic

Delete your cache and rebuild. If the same inputs give you a byte-identical file, the deterministic half is real. If they do not, something in the middle of your pipeline is making a decision nobody wrote down, and that decision will drift on the day you are not watching. Software has had this argument already, and the reproducible-builds people settled it.

02Split the work by the kind of decision, not by the tool

Most pipeline arguments are about tools, which is the wrong axis. The useful question about any rule is not who enforces it but what kind of thing it is. There are exactly three answers, and putting a rule in the wrong bucket is how it comes back.

A rule is either in the path, or it is a suggestion.

the line from our own enforcement audit

That line came out of counting. We audited our own rulebook and classified every rule by how it was actually enforced, not by how important it sounded. The result was uncomfortable enough that it changed the architecture.

Two weeks of evidence sat behind it. The rules that never broke were the ones with a refusing gate in the only path to the effect: spend, schema, the checker gate. The rules that broke repeatedly were the ones living as prose, which is most of the layout and hook doctrine. Prose compliance does not accumulate across people or agents. Code does.

03What does a deterministic check actually look like?

It looks like a build that argues with itself before it renders. Here is the shape of a real run: two mechanical breaches fixed at creation, one undeclared deviation refused outright, and nothing handed to a human that a machine could have settled.

The occlusion line is the one worth stealing. Every element that can be covered by another element carries a declared budget, written when the composition is designed, and the engine measures actual occlusion after compositing rather than trusting the layout intent. Ten percent hidden is a design decision. Forty-one percent hidden is a bug, and it used to be found by a client.

assert text_bbox within plate_bbox        # box fits, or plate grows
assert occlusion(chip) <= budget(chip)    # measured post-composite
assert cap_height(run) >= 0.05 * frame_h  # measured off the plate's ink
assert contrast(run, worst_local) >= 4.5  # and >= 3.0 re-measured at 360px

DEVIATION: <what changed>
  - why the precedent does not cover this
  - risk accepted, and by whom
  # undeclared departure = automatic kill, however good it looks

04Five independent checks, and the maker runs none of them

No film is packaged here until five verdicts come back: message, visibility, physics, story and commodity. Each is run by a fresh reviewer who has seen only the delivered bundle, never the build notes, never the direction lock, never a prior verdict. A re-render voids all five, because the verdict belongs to the bytes, not to the project.

Maker never checks maker, and the reason is measurable. On the same films, the build side's self-scores ran between 36 and 76 points above mine. Self-scoring measures compliance with the brief. It does not measure whether the thing works.

05Put something cheap between approved paper and a full build

We learned this one the hard way. A review came back with a film scored one out of a hundred for having no visual hook, and eight statics carrying mechanical layout breakage, after hours of compute had already been spent. The verdict was to fix the system before the outputs. Two rules came out of it: the layout contract, and a gate that sits between approved paper and any full-cost build.

06A bad take is re-rolled, never repaired

This is the rule that keeps the deterministic half honest. When a generated take is wrong, we do not patch it, paint it out or stabilize it into acceptability. It gets generated again, from a changed instruction, and every re-roll needs explicit permission before it runs because it costs real money.

07Where does taste actually go?

Into verdicts, and nowhere else. My own standard for this system is that my review should be taste-only. If I have to say change this image, the system worked and I am spending my attention on the job only I can do. If I have to say your text escapes its box, the system failed, and no amount of care from whoever built that file would have fixed it.

Change this image is a legitimate note for me to have to give. Your text escapes its box is a system failure.

the standard the layout contract was written to meet

08What this does not fix

Gate-green is not good. Fewer than half the films that clear every automated check here survive the first human viewing, and that number is not a bug in the gates. It is what the gates are for. They clear the floors so that the argument can be about whether the thing works, which is the only argument worth having.

Every metric we built to replace judgment failed confidently

We built a hook gate around change in the first two seconds. The gate ranked our accepted films below our rejected ones and was withdrawn. What actually separated them was whether the first two seconds contained a legible proposition, which is information rather than motion. The measurements are in deterministic creative QA.

The second failure was worse and it produced the rule we run on: a lint is a floor, not a target, and when a check fails you fix the thing rather than the number. The soundtrack that taught us that, tuned green and shipped anyway, is in sound is 40% of the ad.

The promise this architecture makes is not that we are never wrong. Taste is genuinely non-deterministic, and a film can clear every gate and still be dead. The promise is about blast radius: between any two human checkpoints, spend is capped and compute is capped at one cheap mockup pack, so a bad idea dies on paper-scale money. Wrong should be cheap. The full QA version of this argument lives in deterministic creative QA.

A person only has so many good verdicts in a day. Every one spent on a text box that escaped its plate never got spent on whether the ad was worth running.