Notes

The slot machine problem in AI tools

July 20265 min read

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.

MML ONE's six platform stages laid out end to end — Story and Script, Characters, World, 3D Stage, Shot Board and Cut, and Deliver — each stage inheriting the cast, world and creative decisions locked in the stage before it
The resolution to that fight, at the structural level: six stages from script to delivery, each one inheriting the decisions locked in the stage before it. Control comes from the pipeline, not from asking the model to behave.

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.

MML ONE's Shot Board: a storyboard scene broken into individual shots, with takes compared side by side across Veo 3, Seedance and Kling against one locked scene brief, and the Generative Canvas below showing takes as connected nodes around a reference frame
MML ONE's shot board: storyboard to shots to cut. Every take carries the inputs that produced it and its own review state, so re-rolling one node leaves the approved shots around it exactly where they were.

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.

MML ONE's eleven-element shot brief — camera parameters, camera movement, lighting and mood, color palette, audio, concept notes and mood references — shown beside a comparison of what LTX Studio, Higgsfield, Runway and Kling expose for the same step
What "you know what produced it" looks like as an interface: the generation is defined by named, editable values wired to the scene, rather than by a prompt string nobody can diff.

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.