The slot machine problem in AI tools
Most AI creative tools are slot machines wearing productivity clothing. Pull the lever, hope, pull again — and everything you'd already decided is back on the table with every pull. Film production wants the opposite: decisions that stay decided. The interface has to resolve that fight before anything else works.
Watching someone lose a good take
The moment that made this concrete for me: a filmmaker gets a shot they like — the right camera move, the right mood, a face that finally holds together — and then loses it. Not to a crash. To their own next click. They tweak one small thing, the tool hands back a completely new roll of the dice, and the good part is gone with the bad.
I've watched that happen enough times, in enough different tools, to stop blaming any one model. It's what happens when you put a chat-style loop — type, receive, keep talking — underneath work that accumulates decisions. Chat loops are the default because they're the fastest thing to build. Speed of building, not fit to the work, is what picked the interaction model for a whole generation of AI products.
Film is control. Generative AI isn't.
Film production is a discipline of control. A director decides how a character looks, how a scene is framed, and which take survives the edit, and every one of those decisions is expected to hold — a costume choice from scene four doesn't quietly reset itself in scene nine. Generative AI runs on the opposite premise. The same prompt produces a different result every time, and most tools built on top of that treat the variation as the whole point: keep rolling until something looks good.
Both premises are correct for what they're built for. The problem is specific to trying to run a production pipeline on top of a slot machine. If nothing a creator approves is guaranteed to stay approved, there's no such thing as finishing a scene — only endlessly re-rolling one.
Treat every generation like footage
The rule I ended up with: a generation — text, image, or video — earns its keep by behaving like footage, and footage has three properties nobody negotiates away:
- You know what produced it. A take is defined by what fed it — the script beat, the locked character, the brief. Change an input and you know exactly what's now stale. Nothing regenerates silently because something upstream moved.
- It's either approved or it isn't. Review is a real state, not a feeling. That one flag is what turns a folder of generations into a project — a record of decisions someone can point to, not a pile of maybes.
- A fix is never bigger than the problem. If a shot is 90% right, regenerate the 10%. Circle what's wrong, re-roll that region, and leave every upstream decision exactly where it was approved.
Building MML ONE is where I had to live with this rule at every level — a character's identity carrying across scenes and models, takes compared against one locked brief instead of renegotiated per attempt. The rule scaled. The slot machine never did.
If nothing a creator approves is guaranteed to stay approved, there's no such thing as finishing a scene — only endlessly re-rolling one.
"Feels more controllable" isn't the finish line
A claim like this has an obvious failure mode: control is a feeling, and interfaces are very good at manufacturing feelings. So I stopped accepting "it feels better" as an answer and started watching where the time actually goes. The pattern held: when re-rolls are scoped to what's wrong, people stop losing approved work, and a real share of the time they used to spend regenerating whole sequences — roughly a third, in the sessions I tracked — comes back. That isn't a vanity metric. It's the direct effect of not throwing away decisions.
The shipped version of this thinking is live at mmlone.com; the screens are in the case study → if you want them.
This isn't really about film
None of this is specific to film. Any tool that puts a nondeterministic model behind a task with real stakes — an engineering drawing, a legal draft, a piece of music someone has to finish — runs into the same fight between "keep rolling" and "keep what I approved." The pipeline framing generalizes cleanly: name the inputs, make review a real state instead of an implied one, and never make a re-roll bigger than the part that's actually wrong. The tool that gets this right stops feeling like a slot machine and starts feeling like footage — something you can review, version, and build on, instead of something you have to catch on the way past.