We wrote last week that HTML can be a production medium for humans and models. Speedrun is now running into the next practical lesson: the point of templates is not only consistency.
The point is control.
A good template rig lets human taste take precedence wherever possible. The model still has important work to do, but it does not get to decide the whole artifact every time. Humans define the system: the hierarchy, the fonts, the color values, the spacing, the animation behavior, the acceptable slide types, and the constraints. The model fills that system with the right content.
That is the balance we want.
Enough structure to protect quality. Enough variation to keep the output alive.
The Model Is Good At Variation
The problem is not that models cannot vary a slide.
They can. Often too easily. Ask a model to produce visual options and it will find many plausible directions: different compositions, different asset positions, different emphasis, different pacing. Variation is not the scarce resource.
The scarce resource is fidelity to the finished slide.
Text rendering is still fragile. Fonts drift. Exact brand colors become approximate colors. The output can be visually interesting while ignoring the design system that makes the product feel deliberate.
That is why unconstrained generation is the wrong center of gravity for Speedrun slide visuals.
The model should help choose and fill. It should not be responsible for faithfully recreating the design system from scratch on every run.
Human Taste Should Be Upstream
A template is where human taste becomes infrastructure.
When the team designs a rig, they are not only making a slide. They are deciding what good looks like before the model arrives. They choose the typefaces. They choose the exact colors. They choose the spacing rules. They choose how a quote should break, how a source should sit, how an image should crop, how much motion is enough, and what should happen when content is too long.
Those decisions should not be re-litigated at runtime.
The model's job becomes narrower and more useful. It extracts the fields, chooses the appropriate rig, fills the slots, and stays inside the constraints. It can still make judgment calls: which quote matters, which stat should lead, which source belongs, which visual type fits the narration. But the final product remains under a system shaped by human taste.
That is the important distinction.
We are not removing creativity. We are deciding where creativity belongs.
CSS Animation Changes The Cost Shape
There is also a cost reason to prefer rigs.
If every visual scene has to be generated as video, cost compounds quickly. Every new run asks a model to create motion again. Every variant asks for another generation. Every small copy change risks regenerating an expensive artifact.
HTML rigs change that.
The rig is built once. The motion lives in CSS. The animation can be reused. The model supplies structured inputs. The browser renders the result. A small change to the quote, image, number, or source does not require generating the whole visual again.
That makes iteration cheaper. It also makes it faster and more inspectable. A human can open the rig, see the exact CSS, adjust the timing, change a color token, tighten a layout, and know the next render will use the same rules.
This is not a small implementation detail. It changes what the product can afford to do.
A system that is cheap to rerun can support more review, more variants, more personalization, and more experimentation. A system that spends heavily every time it moves becomes harder to improve.
One System Beats Exceptions
The tempting answer to complex slide visuals is to create an exception path.
Simple slides go through HTML. Complex collage assets are generated images, but the slide still gets assembled inside the HTML system. Anything awkward should force the rig to improve rather than leave the system.
That sounds flexible, but it creates a second production stack. Now the product has two ways to make visuals, two QA surfaces, two failure modes, two cost profiles, and two places where design-system fidelity can drift.
For Speedrun, the better decision is to keep one system for as long as possible.
That means the collage slides should become simpler. Not worse. Simpler. Complex collages can still be generated images, but they should become assets inside the HTML slide system rather than a separate production path. The slides should be adjusted to fit the rig approach rather than escaping it. Fewer overlapping assets. Clearer slots. More deliberate composition. Less dependence on a model inventing a dense editorial layout in one shot.
This is a product tradeoff, not a technical limitation.
A simpler HTML-native collage that is faithful, inspectable, cheap, and repeatable is more valuable than a more ambitious generated collage that breaks the system.
Variation Should Be Controlled
Templates do not mean every output looks the same.
Variation can come from the story, the assets, the data, the pacing, the selected rig, and the slot values. A quote slide does not need to be redesigned every time to feel specific. A comparison slide does not need random layout changes to feel alive. Motion, hierarchy, imagery, and content can provide enough change when the underlying system is strong.
This is specifically about Speedrun's slide visuals. The virtual presenter is different. Presenter footage, embodied delivery, lip sync, and realistic motion still belong in video. The point is not to make all of Speedrun HTML. The point is to keep the structured slide system HTML-first.
The difference is that variation becomes controlled.
The model can choose between approved rigs. It can select content. It can decide emphasis. It can produce variants within bounds. But the bounds matter. They keep the brand intact. They keep text readable. They keep costs predictable. They make QA possible.
Unbounded variation is easy. Useful variation is designed.
The Product Is The Rig
The less magical path is often the more serious product path.
A reusable HTML rig looks less impressive than a fresh model-generated scene. But the rig is where the product accumulates taste. Every spacing fix, color correction, animation improvement, overflow rule, and QA check makes the system better for future runs.
That compounding effect is the point.
If the model owns the whole artifact each time, learning is trapped in prompts and examples. If the rig owns the stable parts, learning becomes product surface. The next run benefits automatically.
For Speedrun, the right shape is clear: humans define the rigs, CSS carries the animation, models fill the slots, QA checks the result, and the whole system stays HTML-first.
The goal is not to make the model less important.
The goal is to stop asking the model to do work that the product should own.
