Storyboard Grids: One Generation, Many Shots
One bordered image, fed to a video model as a single start frame, can unwind into a full sequence of hard-cut shots — if you get the borders right.
One generation, many shots
Generating a scene one shot at a time is the default instinct, and it's often the wrong one. Every separate generation call is its own roll of the dice on framing, pacing, and style — which is exactly the inconsistency problem the earlier lessons in this track exist to solve. The storyboard-grid technique solves it for multi-shot coverage specifically: get several sequential shots out of a single generation, so consistency across the sequence is a property of the generation itself, not something you have to fight for afterward.
There are two ways to do this, and which one applies depends on a single fact about the model you're using: does it support native multi-shot generation, or not.
Path A: the bordered grid
When the model only accepts a single image and a single motion prompt, the technique is to build the coverage into the image itself. Generate one bordered-panel image — a comic-page-style grid containing every beat of the scene, with bold black borders between panels, and the character, outfit, and color grade held identical across every panel. Feed that whole grid image to the video model as the single start image, with a motion prompt instructing it to treat each panel as a sequential shot: hard cuts between panels, no dissolves, preserving each panel's own framing.
The borders are the entire mechanism, and they are load-bearing in the most literal sense. They tell the model precisely where a cut belongs. Remove them, or render them too faintly, and the model has no clean signal for where one shot ends and the next begins — it reads the grid as one continuous image instead of four discrete panels, and the result is a tween or blend between panels rather than the hard cut you wanted. This is a real, repeatable drift failure, not an occasional hiccup, and it's been hit often enough in production to be worth stating as a hard rule: bold black borders, every time, with no exceptions for a "cleaner" borderless look.
Path B: native multi-shot
Some video models expose a native multi-shot mode directly: pass an array of per-shot prompts, along with reference media, in a single call, and the model generates the full sequence of shots natively — no image grid required at all.
Where it's available, this is usually the more economical path. Native multi-shot generation is typically priced by total duration only, with no penalty for the number of shots inside that duration — meaning four shots in one call cost roughly what one shot of the same total length would cost. That makes it a genuinely good deal when it's on the table.
The catch is availability. Not every model exposes this mode; some only take a single prompt and a single reference image, full stop. The bordered-grid technique (Path A) is the portable default precisely because it works on any image-to-video model — it doesn't depend on a feature the model might not have. Reach for Path B when it's available and the economics favor it; fall back to Path A everywhere else.
The fork rule: whole grid vs single panel
There's a second decision buried inside Path A that's easy to get backwards: what to feed the model depends entirely on whether you want a hard-cut montage or a single continuous shot.
If you want the hard-cut montage — several distinct shots stitched by the model itself, each with its own framing — feed the whole grid, borders and all, with the hard-cut motion prompt described above. But if, on review, you decide the scene should actually read as one continuous shot instead of a montage, don't feed the whole grid at all. Crop out a single panel from the board and use just that panel as the start image, exactly the way you would for the start/end keyframe technique from the previous lesson. Feeding the whole grid when you wanted one continuous shot doesn't produce a continuous shot with weaker cuts — it produces the same drift failure as a borderless grid, because you've handed the model multiple framings and asked it to smoothly connect them, which is not what a continuous shot needs.
Previewing the continuity rule
When you start chaining storyboard-grid scenes together across a longer production — the subject of a later lesson in full — one rule matters enough to preview here: feed the prior board image into the next board's generation for continuity, never a frame pulled from a rendered prior video.
The reasoning is about where quality loss accumulates. Every video-generation pass introduces its own compression artifacts, motion blur, and small stylistic drift relative to its own inputs. A frame extracted from that generated video already carries all of that loss — and if you feed that frame back in as the next scene's reference, the next generation inherits it and adds its own on top. Repeat that across a production with a dozen chained scenes and the drift compounds visibly by the end. The board image itself — the clean still generated by the image model, before any video generation touched it — never carries that compounding loss, which is why it's the correct anchor to chain from, generation after generation.
Build it: branch the coverage path
You're going to implement the function that decides between Path A and Path B based on whether the model supports native multi-shot generation — fixing a stub that always takes the grid path regardless of what's actually available.