Lint your multi-shot video plan before you submit it: a tiny JSON + Python checker

Multi-shot video editors ask you to split one idea into several shots, each with its own prompt and duration. That is a good discipline, but it adds new ways to fail: one shot over the character limit, a total that runs past the maximum duration, or a shot that quietly forgets the detail that ties the sequence together.

The Multi-shot Video Creator on GPT Image 2.5 shows its limits right in the editor, which makes them easy to encode. This post keeps the shot plan in a JSON file and checks it with a short Python script before anything is submitted.

The limits the editor shows

Reading the editor and the text below it, these are the rules that matter for a plan:

• Each shot has a description field with a counter of 500 characters per shot and 1,200 in total.
• Each @element token counts as 37 characters. Elements are reusable items from the element library.
• The duration counter reads Total 5/15s for a single default shot, so the whole sequence has a 15-second ceiling.
• The editor refuses to continue until each shot has a prompt.

The page also gives advice that is not a hard limit but matters just as much: keep each shot focused, and repeat important visual details across shot descriptions, because consistent faces, objects and transitions are not guaranteed.

The plan as JSON

The page's own illustrative prompt is a three-shot sequence: a wide rainy city, a close-up of a red umbrella, the same person walking into a warmly lit café. Expanded into a plan file:

{"repeat": ["red umbrella"],
 "shots": [
  {"seconds": 4, "prompt": "Wide shot of a rainy city street at dusk, wet pavement reflecting shop lights, a woman in a long grey coat with a red umbrella walks away from the camera."},
  {"seconds": 4, "prompt": "Close-up of the red umbrella from above, raindrops bouncing off the fabric, the grey coat sleeve visible at the edge of the frame."},
  {"seconds": 5, "prompt": "Medium shot: the same woman in the long grey coat closes the red umbrella and steps into a warmly lit cafe, the camera stays outside behind the rainy window."}
 ]}

The repeat list is my addition. It names the details that must appear in every shot for continuity, following the page's advice to repeat important visual details.

The checker

import json, re, sys

SHOT_MAX, TOTAL_MAX, SECONDS_MAX = 500, 1200, 15   # limits shown in the multi-shot editor
ELEMENT_COST = 37                                   # "each @element token counts as 37 characters"

def counted_len(text):
    tokens = re.findall(r"@\w+", text)
    return len(re.sub(r"@\w+", "", text)) + ELEMENT_COST * len(tokens), len(tokens)

def check(plan):
    problems, total_chars, total_secs = [], 0, 0
    for i, shot in enumerate(plan["shots"], 1):
        n, k = counted_len(shot["prompt"])
        total_chars += n; total_secs += shot["seconds"]
        flag = "" if n <= SHOT_MAX else f"  <- over {SHOT_MAX}"
        print(f"shot {i}: {shot['seconds']:>2}s  {n:>3} chars ({k} @element){flag}")
        if not shot["prompt"].strip(): problems.append(f"shot {i} has no prompt")
        if n > SHOT_MAX: problems.append(f"shot {i} is {n} chars")
        for detail in plan.get("repeat", []):
            if detail not in shot["prompt"] and "@" not in shot["prompt"]:
                problems.append(f"shot {i} does not repeat '{detail}'")
    print(f"total: {total_secs}s / {SECONDS_MAX}s, {total_chars} / {TOTAL_MAX} chars")
    if total_secs > SECONDS_MAX: problems.append(f"total duration {total_secs}s")
    if total_chars > TOTAL_MAX: problems.append(f"total {total_chars} chars")
    return problems

if __name__ == "__main__":
    plan = json.load(open(sys.argv[1]))
    issues = check(plan)
    print("OK" if not issues else "FIX:\n- " + "\n- ".join(issues))

Two details are worth pointing out. First, the character count replaces each @element token with 37 characters, as the editor says it does, so a short-looking prompt full of elements is measured correctly. Second, the continuity check accepts a shot that uses an element token instead of the literal phrase, since an element is a way of carrying the same subject across shots.

Running it

On the plan above:

shot 1:  4s  154 chars (0 @element)
shot 2:  4s  130 chars (0 @element)
shot 3:  5s  157 chars (0 @element)
total: 13s / 15s, 441 / 1200 chars
OK

Then a second draft, rewritten with elements and slightly longer shots:

shot 1:  6s  193 chars (2 @element)
shot 2:  5s   64 chars (0 @element)
shot 3:  6s  166 chars (2 @element)
total: 17s / 15s, 423 / 1200 chars
FIX:
- shot 2 does not repeat 'red umbrella'
- total duration 17s

Both problems are typical. The durations crept up from 13 to 17 seconds because each shot got "just one more second". And the close-up in shot 2 lost its subject: "raindrops on fabric" no longer says whose fabric, or that it is red. The model has no reason to keep the umbrella red if the prompt does not ask for it.

Why lint at all?

You could notice these issues in the editor, and the editor will block some of them. The value of a plan file is elsewhere:

• Versioning. The JSON lives next to your project. You can diff draft 1 against draft 2 and see exactly which shot changed.
• Reuse. For a series of short videos with the same character, the repeat list becomes a shared continuity rule.
• Review. A teammate can read the plan without opening the editor or spending credits.

Extending the plan file

Because the plan is plain JSON, it is easy to grow with your workflow. A few fields that have been useful in practice:

• camera per shot, so the camera instruction is visible at a glance and you can check that two neighbouring shots do not both say "slow push-in".
• purpose per shot, a one-line note such as "establish the place" or "show the decision", which makes reviews faster than reading full prompts.
• A top-level aspect field, so the plan records which frame shape it was written for.

None of these are sent to the editor; they are notes for you and your team. The checker ignores unknown fields, so adding them costs nothing.

What the checker cannot do

It checks the plan, not the result. After generation, the page's advice still applies: review each scene before using the sequence, and revise scenes where continuity matters. The FAQ states plainly that multi-shot creation does not guarantee consistent characters. Use the same character details, clothing and style across shots, use reference options where the editor supports them, and look at every transition.

The checker also does not know which model you pick. The page notes that reference inputs, aspect ratios and resolutions depend on the selected model, so check the settings shown in the editor before you submit.

Summary

• Keep the shot plan in a JSON file with durations and prompts.
• Encode the editor's limits: 500 per shot, 1,200 total, @element = 37, 15 s total.
• Add a repeat list for continuity details and check every shot against it.
• Lint before submitting; review transitions after generating.