Shot Retry and Replacement Strategy: At Most 3 per Shot
💡 One-sentence summary: Use a retry cap of 3 per shot and the four-tier downgrade path to keep AI video retries under control — the count has clear rules, change only one variable per retry, and once you hit the cap, replace or let go; don't linger in the fight.
4.4 Shot Failure Diagnosis looks for the root cause: troubleshoot at the environment layer, and make the first cut at the content layer under three categories — breakdowns, wrong characters, and mismatched actions. This page covers what to do next: whether to keep rolling this shot, how to spend the 3 chances, how to downgrade once you hit the cap, and how to keep the books.
There is one main rule — at most 3 times per shot; if 3 attempts don't yield usable footage, stop and choose between shot replacement and letting it go. The retry cap, the four-tier downgrade, and "letting it go" are all decision templates for this course (instructional design, based on first producing a short pilot and recording failure costs), not official features of any tool; the budget cap in the 1.4 Cost Log (shot count × 3) is computed exactly by this rule.
What You'll Be Able to Do After This Lesson
- State the counting rules for the 3-attempt cap: which attempt starts the count, what counts as one attempt, and how the version number maps to it
- Set the three-line usability test for every shot, with an explicit way to record each result row in the ledger
- Spend the 3 chances along the four-tier downgrade path: change the prompt, change the first frame, or change the workflow; once you hit the cap, decide between shot replacement and letting it go
- Back-fill the film-wide retry ledger into the 1.4 Cost Log: the total count matches the cap, and you can name the most troublesome shot
Why Fix the Cap at 3 Attempts Instead of "Roll Until Satisfied"?
| Capability | Roll until satisfied | 3 per shot + downgrade path |
|---|---|---|
| When to stop | ❌ "The next one will be better" never has an end point | ✅ Must stop when attempt 3 ends, then downgrade |
| Failure attribution | ❌ After 10 rolls you still don't know which change worked | ✅ One variable at a time, with every change logged |
| Budget | ❌ The cap in 1.4 exists in name only | ✅ Cap = shot count × 3, a computable number |
| Troublesome shots | ❌ One shot stalls all night and the whole film falls apart | ✅ Four-tier downgrade + letting it go; the finished film comes first |
| Footage management | ❌ Keep only the best, delete failures casually | ✅ Versions only accumulate, never overwritten; failures are records too |
Your Current Predicament
- "I rolled a shot a dozen-plus times, each roll more expensive, and in the end I still used the version from attempt 3"
- "I knew this shot was troublesome, but I still wanted 'one last roll' — and just like that, the whole evening was gone"
- "When the film was done I couldn't say how many retries it took; I set up the budget sheet in 1.4 back then and never opened it again"
When to Use This Technique
When you need to:
- Decide "whether to keep rolling this shot, and how" after the diagnosis in 4.4 Diagnosis
- Keep the total cost of the first rough cut within the cap computed by 1.4
And you don't want to:
- Let one troublesome shot drag down the whole film's progress
- Turn gacha rolling into mysticism where the cause of failure can never be explained
🎒 Preparation Before You Start
- Completed 4.4 Shot Failure Diagnosis: you know failures split into an environment layer and a content layer, and you know the first cut for each of the three content problem types
- 1.4 Cost and Trial-and-Error Log at hand: every attempt on this page gets recorded back into its row
- Storyboard (2.4) at hand: the content line of the usability test is done against its frame column
- Shot folders set up per the 3.5 naming convention:
镜头号_版本号, append-only, never overwritten
Follow Along
The example below continues with "Beautiful Even in Collapse": under a bridge in a rainstorm, delivery rider Old Chen shields a birthday cake for his daughter — 10 shots, 40 seconds (2.4 storyboard). This page walks the process with the film's most troublesome shot: shot 06, wide shot · he tumbles into the puddle with the box — full-body large motion, the kind of shot AI video breaks down on most easily. You can follow along the whole way with your own troublesome shot.
Step 1: Define the Counting Rules — Which Attempt Starts the Count for the "3 Times" of AI Video Retries
Why: To make the cap enforceable, first define clearly which attempt starts the count and what counts as one attempt. If the rules are vague, the cap can't hold.
How: Define the rules by these three clauses (course rules):
| Rule | Definition |
|---|---|
| Where counting starts | Per shot number, counting starts from the 1st generation |
| What counts as one attempt | Every generation you initiate counts as 1 attempt, regardless of whether the result is good or bad |
| Version number linkage | The Nth attempt = 镜头06_vN.mp4 (3.5 naming convention, version number = attempt count) |
If the environment layer fails to run (errors, hangs, interruptions): stop first and troubleshoot following 4.4 — troubleshooting itself does not generate anything and does not consume attempts; however, failed attempts already initiated still count as usual and must be recorded truthfully in the log — if the time was spent, the log entry cannot be underreported.
You should see: in the shot folder, the version numbers for each shot number are consecutive (v1, v2, v3……) with no gaps; the log's "attempt number" column matches the version numbers.
- Can state the three counting rules: counting starts from the 1st generation, each generation adds +1, version number = attempt count
Step 2: Set up the three-line usability check — what makes a shot "pass"
Why: without acceptance criteria, you will keep drawing cards forever — always feeling the next one will be better. The criteria are not invented on this page; copy them from existing documents.
How: after each shot is generated, run it through the three lines (this course's template):
| Check line | What to check | Source of criteria |
|---|---|---|
| Content line | The image matches the picture column of this shot in the storyboard, one action per shot | 2.4 storyboard |
| Continuity line | Connects with the shots before and after: subject, position, lighting, action direction, prop state | 2.5 transition checklist |
| Technical line | No breakdown: faces, hands, and limbs are not distorted or blurry | 4.4 image breakdown category |
Passing all three lines = usable; write "usable" in the log's "result" column. Failing any one line = unusable; write "failed" in the result column following the notation in 1.4, and record which line it failed in the "failure reason / issue" column.
You should see: every row in the log can be filled with "usable" or "failed" in the result column, the failure reason column records which line it failed, and there are no unverifiable entries like "okay" or "passable".
- The three-line usability check is established, and the log's "result" column now has a fixed notation
Step 3: Change one variable before retrying — targeted fixes, not blind drawing
Why: the first rule of the 4.4 three diagnostic rules is one variable at a time. The same input will only grow the same fruit — blind drawing is not retrying, it is repeating.
Operation: before each retry, use the triage table in 4.4 to pick one variable to change, and record the change in the log's "what was changed" column. Take shot 06's three attempts as an example (see the route table in Step 4 for which tier to change):
| Attempt | Result | What variable to change |
|---|---|---|
| v1 | Breakdown: the falling posture is distorted, and the box merges with the hand | — (the 1st attempt is a baseline probe, no change) |
| v2 | The posture is right, but the box's trajectory flies wildly | Change the prompt: action subtraction, reducing "falls into the puddle together with the box" to "leans forward, loses balance, and drops to one knee into the puddle" |
| v3 | Both the person and the box are stable, but the splash moment is still a blurry mess | Change the first frame: swap in a composited first frame where the body is already leaning forward and the box is already held securely, so the model only needs to fill in "the falling down" |
You should see: in the log, the "what was changed" column for every retry is not empty, and only one thing was changed each time.
- A variable to change is chosen before every retry, and the log's "what was changed" column is non-empty
Step 4: Follow the four-tier downgrade route — change the prompt, change the first frame, replace the shot, let it go
Why: 3 attempts must not be spent carelessly, and even at the limit you should not just give up. The four-tier route lays out every step from "this shot failed" to "this shot is done": the first two tiers are the recommended way to spend within the 3-attempt budget, and the last two are the exits after hitting the limit.
How: follow this route table (this course's template; the first two tiers are the recommended order for "change one variable" in Step 3):
| Tier | Action | When to use | What it costs | Example for shot 06 |
|---|---|---|---|---|
| Tier 1 | Change the prompt | The 2nd attempt | Zero cost, only text changes | Action subtraction: reduce "falls into the puddle together with the box" to "leans forward, loses balance, and drops to one knee into the puddle" |
| Tier 2 | Change the first frame or change the workflow | The 3rd attempt | Regenerate the image, or switch to a different workflow | Swap in a composited first frame with the body already leaning forward; or switch from I2V to 4.3 first-last frame, pinning down both the falling frame and the splash frame so the model only fills in the middle |
| Tier 3 | Replace the shot | 3 attempts exhausted, Exit A | Modify the storyboard + regenerate with a new work order | Don't shoot the full "person falling" sequence; replace it with a result empty shot of water splashing — the "splash of falling" in the sound column stays unchanged, so the audience hears the splash and sees the water and knows the fall happened |
| Tier 4 | Let it go | 3 attempts exhausted, Exit B | Zero cost, keep the flaw | Pick the least-bad of the three versions for the rough cut, and mark it "fix in round two" in the log |
Rules for the two exits:
- Shot replacement: Replace a shot you can't produce with one you can, without breaking the story information—this is the core of the "replacement strategy." When revising the storyboard, mark the replacement plan on the original row (the storyboard goes from read-only to revised; log one line explaining the change); the replacement shot is a new work order, and the 3-attempt budget starts over, but it must first pass the budget gate: total attempts used across the film + new work order budget ≤ the cap from 1.4; if exceeded, let it go for now and save the replacement for round two.
- Let it go: This isn't giving up—it's the correct way to wrap up the first pass. Protect the finished film first, and mark flaws as "fix in round two." Three judgment criteria: ① Is this shot's story information shared by neighboring shots (the water sound in shot 06 is in the sound column, and the lid snapping open is followed by a 07 close-up—shared, so it can be let go); ② Will the flaw pull viewers out of the story (a blurry flash during the fall → let it go; broken to the point the action is unreadable → replace); ③ How much is left in the budget gate (see the previous item).
💡 The officials also endorse the idea of "preview first, then produce the final film"
The Wan2.2 official repository provides the --num_clip parameter on S2V-14B: it controls the number of generated clips and shortens generation time, for quick previews (see the official repository notes). "Quickly check the result first, then produce the official film" is an approach the officials have also adopted—running the whole film through once (letting things go), confirming the story holds, and then refining, is exactly this idea in practice. Note that S2V-14B is listed as requiring 80GB of VRAM on a single card—it's an advanced path, not the main path of this course. We only borrow the idea here; we don't teach the operation.
You should see: Every shot has a clear destination: within 3 attempts, apply tier-level upgrade changes; shots that hit the cap land on one of two exits, with the ledger recording either a replacement plan or a "fix in round two" mark.
- Shots that hit the cap after 3 attempts all landed on an exit: replacement (passed the budget gate) or let it go (marked for round two)
Step 5: Budget backfill—reconcile the retry ledger against the record table from 1.4
Why: The cap was calculated when the table was set up in 1.4; the ledger on this page is the day-to-day use of that table, and the graduation review (5.5) will also use it as raw data.
How to do it: Reconcile the ledger once when each shot wraps up, and reconcile the totals after the whole film is generated:
| Reconciliation item | How to reconcile |
|---|---|
| Per shot | Version number = ledger row count = attempt count (3.5 reconciliation key) |
| Whole film | Total generation count ≤ the cap from 1.4 (shot count × 3) |
| If exceeded | You can say which shot exceeded it and why—this is the basis for adjusting the budget on the next film |
The ledger for "Beautiful Even in Collapse": 10 shots, smooth-case lower bound 10 × 1 = 10 attempts, cap 10 × 3 = 30 attempts; the local route converts to a time budget using official reference values (5 seconds 720P within 9 minutes on a single card), and the cloud route is recorded using the points formula—verify unit prices from the platform's pricing page; don't hard-code them before verification.
You should see: After the whole film is generated, you can state in one sentence: total generation count, whether the cap was exceeded, and which shot was the hardest to produce.
- The whole film's total count matches the cap from 1.4; if exceeded, you can say where
📋 Magic Prompts
Both templates are Prompts designed for this course (teaching examples); any conversational AI assistant will do—no particular tool required.
📝 Cap-Hit Judgment Assistant
Expected effect: Hand this shot's ledger record to the AI and get back a judgment of "replace" or "let it go"—walk through the three judgment criteria one by one; most hard-to-produce shots can be let go.
## Role
You are a short-film production assistant, skilled at deciding how to handle hard-to-produce shots using budget discipline.
## Task
This shot has hit the cap of 3 attempts without yielding usable footage. Based on the attempt records, decide whether to "replace the shot" or "let it go."
## Input information
### Required fields
- Storyboard row: [Shot number | Shot size | Visual | Sound | Duration]
- Three attempt records: [Paste each one, format: which attempt | Result | Failure reason | What was changed]
### Optional fields
- Visuals of adjacent shots: [Previous shot and next shot?]
- Budget headroom: [Whole-film cap count and used count?]
## Output specification
One judgment table: common thread across the three failures | whether this shot's story information is shared by neighboring shots | whether the flaw pulls viewers out of the story | whether the budget gate passes | recommendation (shot replacement / let it go) | one-sentence rationale. Give the conclusion on the last line.
## Constraints
- ✅ Judge only based on the records provided; do not invent attempts that weren't supplied
- ✅ The conclusion must correspond to the judgment criteria: information sharing, immersion-breaking severity, budget headroom
- ❌ Do not recommend "one more roll"—the cap is 3 attempts; there is no attempt 4
- ❌ Do not use reasons like "the next attempt will be luckier"🔧 Shot Downgrade Plan Generator
Expected effect: Hand the storyboard row and failure records to the AI and get back concrete changes for each downgrade tier—revised prompt, first-frame replacement approach, and the replaced storyboard row; you pick one tier to execute.
## Role
You are a short-film director's assistant, skilled at rewriting hard-to-produce shots into versions that are easier to generate.
## Task
Generate downgrade plans for this hard-to-produce shot: change the prompt, change the first frame or the workflow, or replace the shot.
## Input information
### Required fields
- Storyboard row: [Shot number | Shot size | Visual | Sound | Duration]
- Failure records: [Paste each one, format: which attempt | Failure reason | What was changed]
### Optional fields
- Visuals of adjacent shots: [Previous shot and next shot?]
- Character card and scene card: [Paste the fixed description paragraph and fixed environment paragraph?]
## Output specification
Plan table: tier | concrete change (for a prompt change, give the revised version / for a first-frame change, give the image-swap approach / for a workflow change, specify which two frames to pin / for shot replacement, give the replaced storyboard row) | what it costs (zero cost / requires regenerating images / requires editing the storyboard). One row per tier, no tutorial expansion.
## Constraints
- ✅ A prompt change only alters text—no touching images or the storyboard
- ✅ The replacement shot still follows one shot, one action, with duration within 3–5 seconds
- ❌ Do not step outside the established tool path—switching model families or platforms is not among the downgrade options
- ❌ Do not promise that any tier "will definitely pass"—downgrading improves the odds, it doesn't guaranteeCheckpoint ✅
- You can state the counting rule for 3 attempts: for the same shot number, counting starts from attempt 1, each generation adds +1, and the version number = attempt count
- The ledger reconciles when each shot wraps up: version number = ledger row count = attempt count
- Each retry changed only one variable; the "what was changed" column is non-empty
- Shots that hit the cap after 3 attempts all landed on an exit: replacement (passed the budget gate) or let it go (marked "fix in round two")
- The whole film's total count didn't exceed the cap from 1.4; if exceeded, you can say which shot
Pitfall reminders
❌ Attempt 4: "just one more roll"
Symptom: You've hit the 3-generation cap, and your finger is already on the Generate button—"just one more draw, this time it feels right."
Cause: The 3 generations are the cornerstone of the budget: the cap value in 1.4 (number of shots × 3) is calculated from it. Break it once and there will be a second time—once the cap loosens, "the next one will be better" never ends.
Correct practice: Stop when you hit the cap, and take one of two exits: if the story information is covered by neighboring shots and the flaws don't break immersion → let it go and keep the finished cut; if it's broken beyond comprehension or the information is exclusive to this shot → replace the shot, passing the budget gate first. If you really want another draw, set up a "second-round refinement" project (see Advanced Techniques)—that's a fresh round of budget, not an exception.
❌ Changing three variables at once during a retry
Symptom: In v2 you changed the prompt, swapped the first frame, and adjusted the resolution all at once—if it improved, you don't know who gets the credit; if it broke, you don't know what to roll back.
Cause: When multiple variables move together, causality is broken. The "one variable at a time" rule in the 4.4 Three Diagnostic Rules was established exactly for this.
Correct practice: Change only one variable at a time, archive before changing (3.5), and log what you changed in the ledger. The three chances are exactly enough for "one exploratory pass + two targeted fixes."
❌ Deleting failed versions and keeping only the best
Symptom: v1 and v2 looked bad, so you deleted them on a whim—when the film is done, you can't say during review what was tried on this shot.
Cause: Failed versions are assets too: they prove this path doesn't work. Delete them, and the ledger has a gap, leaving 5.5 graduation review without its raw data.
Correct practice: Versions are only added, never overwritten (3.5); the failed v1 and v2 stay in the folder, and the ledger rows remain complete.
Advanced Techniques (Optional)
Second-round refinement: The 3-generation cap governs the first pass of trial production. Once the rough cut confirms the story holds, set up a second-round budget for the shots you "let go": this shot is allowed 3 more generations—first add a row in the 1.4 cost sheet before spending. "Preview first, then produce the film" applied to the ledger means rough cut first, refinement later. Every retry in the second round still follows the rules on this page: one variable at a time, a 3-generation cap, and exits when the cap is hit.
Lesson Summary
✅ At this point, every shot has a complete AI video retry and replacement strategy:
- Counting convention: for the same shot number, counting starts from the 1st generation; each generation adds 1, and the version number = attempt count
- Three lines for usability check: the content line against the storyboard, the continuity line against the transition list, and the technical line for breakdowns—only passing all three lines counts as usable
- Retry discipline: one variable at a time, archive before changing, log what you changed in the ledger
- Four-level downgrade: changing the prompt → changing the first frame or workflow, spent within 3 generations; when the cap is hit, take one of two exits—shot replacement (passing the budget gate first) or letting it go (marked "second-round fix")
- Budget reconciliation: per shot against the version number, for the whole film against the cap value; if exceeded, you can say where it was exceeded
Review of key conventions:
| Convention | Recommended value | Description |
|---|---|---|
| Retry cap | 3 generations / shot / round | Counting starts from the 1st generation; version number = attempt count |
| Three lines for usability check | Content line, continuity line, technical line | Only passing all three lines is recorded as "usable" |
| Retry discipline | One variable at a time | Archive before changing (3.5), log what you changed in the ledger |
| Four-level downgrade | Change the prompt → change the first frame/workflow → replace the shot → let it go | The first two levels are spent within 3 generations; the last two are exits for when the cap is hit |
| Budget gate | Used generations + new ticket budget ≤ cap value | Shot replacement passes the gate first; if exceeded, let it go for now |
Next Lesson Preview
The shot materials are ready—usable ones go into the rough cut, and the "let go" ones wait for the second round with their marks. The next lesson moves to the finished-film section: Finished Film: Voiceover, Subtitles, Editing, Export.
You will learn:
- Two paths for voiceover: edge-tts synthesis and recording yourself, plus the licensing boundaries of each
- Subtitles from SRT generation to burning in—the payoff of streamlined dialogue lands here
- Using FFmpeg to stitch shot clips into your first finished film, with volume passing the loudness check
- Running through a checklist against the official specs before export
Related Tutorials
- Cost and Trial-and-Error Log Sheet—the sheet for budget reconciliation: every attempt on this page is logged back to its row
- Asset Naming and Version Management—the reconciliation key of "version number = attempt count," and the origin of the add-only, never-overwrite rule
- Shot Continuity Check—the source of the continuity line criteria among the three usability lines: subject, position, lighting, action direction, and prop state