Using Codex as a Storyboard Artist: A Practical Guide to the End-State Backward Planning Method for AI Video

From Prompt Engineering to Shot Planning

Most people use ChatGPT as a prompt generator: have it write a cinematic shot description, add some camera movement vocabulary, then paste the result into a video model and pray the ending doesn't fall apart. However, a Reddit user's shared experience reveals a far more valuable approach—using ChatGPT/Codex as a shot planner, not a prompt rewriting tool.

Storyboarding is the standard process in film production for visualizing scripts, typically involving a storyboard artist hand-drawing keyframes for each shot, annotating camera movements and timing. In traditional workflows, shot planning directly determines shooting-day efficiency and post-production editing feasibility. Positioning ChatGPT as a shot planner essentially assigns the large language model the role of "Pre-visualization"—something that typically requires a dedicated 3D preview team in Hollywood productions. OpenAI's Codex was originally designed for code generation and excels at structured, logic-heavy tasks. In this case, the author chose Codex for shot planning precisely because storyboarding is fundamentally a structured sequence planning problem—requiring clear timelines, spatial coordinates, and causal logic, rather than free-form literary creation.

This creator's core pain point is highly representative: Image-to-Video failures almost always happen in the last second. The first 19 seconds of motion can look perfectly coherent, then the Seedance model suddenly "remembers" the reference image as its endpoint and snaps toward it—face deformation, perspective jumps, or a white flash to mask the jarring transition.

Seedance is ByteDance's video generation model, supporting Image-to-Video mode, where a static image serves as a reference end-frame or starting frame for the model to generate coherent video clips. Its version 2.5 supports 1080p resolution and 60fps high frame rate output, with generated durations up to 20 seconds. The core challenge of Image-to-Video models is that the model must simultaneously satisfy two potentially conflicting constraints: motion coherence and end-state consistency. When these conflict, the model often produces abrupt changes in the final frames—this is precisely the technical root cause of the "last-second failure" phenomenon the author describes.

His solution represents a fundamental mental reframe: Stop asking "what should happen in this video" and start asking "what must be true when the video ends." The entire camera path was reverse-engineered from that known endpoint (the composition of the classic "Disaster Girl" meme).

Five Practical Steps of the End-State Backward Planning Method

Step 1: Define End-State Constraints for ChatGPT

The author first listed all elements that absolutely cannot change in the final frame: the girl's position, gaze direction and expression, foreground-to-background layer order, final camera height, and precise observation axis.

The key here is treating these descriptions as constraints rather than visual suggestions. Visual suggestions are vague; constraints are verifiable—this directly determines whether subsequent iterations have clear direction. In engineering, constraints are hard boundaries a system must satisfy; violating a constraint means the result is invalid. Visual suggestions are more like soft constraints or preference weights in optimization objectives. For example, "the girl is positioned at the right third of the frame" is a quantifiably verifiable constraint, while "the frame should feel cinematic" is a vague preference that cannot be precisely judged as satisfied or not. This distinction is a foundational concept in Constraint Satisfaction Problems (CSP), and introducing it into prompt engineering represents an important shift in thinking.

Step 2: Separate Camera Actions from Visual Adjectives

Words like "dynamic," "fluid," and "cinematic" sound useful, but they define no actual path. The author had Codex convert end-state requirements into a shot plan with explicit camera movements, foreground events, exposure changes, and stopping behavior.

The goal isn't to write a longer prompt—it's to eliminate ambiguity.

This is the essence of the entire approach. The uncontrollability of AI video models largely stems from ambiguity in the input itself. When prompts are filled with modifiers like "cinematic" and "dynamic," the model's interpretation space is enormous—it might generate any motion that vaguely fits these descriptions. When inputs are transformed into specific motion instruction sequences (pan direction, speed changes, timing of foreground events), the model's degrees of freedom are dramatically compressed, and output predictability increases accordingly.

Step 3: Reverse-Engineer a Physical Motion Path

The reverse-engineered path roughly follows:

• Start at a low interior camera position
• Follow a red guide line on the ground
• Accelerate toward an overexposed exit
• Pass through a courtyard
• Move past a fire drill team, hoses, and fire truck as foreground occlusion
• Move to the girl's side
• Arc toward the final observation axis

Every object exists for a reason: the red guide line establishes directional sense, the bright exit motivates the exposure transition, the truck and hoses create displacement and parallax, and the final arc brings the camera to the reference perspective. This is essentially using physical causality to constrain the model's motion generation, rather than relying on adjectives and luck.

Parallax refers to the visual phenomenon where nearby objects appear to shift more than distant objects when the observer moves. In cinematography, foreground occluders (like the fire truck and hoses in this case) not only add visual depth but more importantly provide anchor points for depth perception—when these objects sweep rapidly across the frame, the brain automatically infers high-speed camera movement. For AI video models, these foreground elements similarly serve as a "motion reference frame," helping the model maintain spatial consistency and avoid losing depth structure during rapid movement.

Identifying Failure Points: Getting AI to Diagnose Undefined Constraints

Step 4: Use ChatGPT to Diagnose, Not Rewrite

When the first version showed drift, the author didn't ask ChatGPT to "write a better prompt"—instead, they asked it which constraint was insufficiently defined.

This questioning approach typically exposes specific issues:

• The camera is rotating instead of translating
• Foreground objects lack timing
• The final frame is described as a "picture" rather than a "state" the camera must arrive at

This diagnostic iteration makes the debugging process highly mechanical and reproducible, breaking free from the mystical cycle of "tweak the prompt and hope for the best." Essentially, this brings software engineering's debugging mindset into creative generation: instead of blindly modifying code (prompts), first locate the bug (which constraint was violated), then fix it specifically. The advantage of this method is that each iteration has a clear direction, rather than randomly searching through high-dimensional parameter space.

Step 5: Design "Stopping" as an Independent Action

The most clever detail: the ending itself is designed as a distinct motion phase:

Fast flight → controlled glide → minor position correction → camera and subject decelerate in sync → full stop

The camera and facial movement stabilize together on the final frame. This stop isn't achieved through editing—it's the last action within the shot. This is the key to solving "last-second failure"—transforming the transition from an "unexpected event" for the model into a planned, controllable conclusion.

From a kinematics perspective, this is equivalent to designing a trajectory with a smooth deceleration curve for the camera—similar to trapezoidal velocity profiles or S-curve planning in robot motion planning, ensuring no jitter or abrupt changes at the endpoint. When the video model receives such motion descriptions, the final frames have clear physical references, eliminating the need to "guess" how to transition from motion to a static reference image.

Cost and Reproducibility Analysis

The author also disclosed the complete cost of this experiment, providing valuable reference for those who want to reproduce it:

Component	Tool	Cost
Opening frame generation	Seedream 5.0 Pro	$0.045
20-second video generation	Seedance 2.5 (1080p-ESR / 60fps, via Atlas Cloud API, running within OpenMontage)	$2.68

Seedream is ByteDance's image generation model, with the 5.0 Pro version used for generating high-quality single frames. In this workflow, it's responsible for generating the video's starting frame—this image needs to contain sufficient scene information (indoor environment, low camera angle, red guide line, etc.) to provide the subsequent video generation model with a clear starting state. Starting frame quality directly impacts video generation stability, as the model uses it as the basis for motion prediction.

As you can see, even a carefully designed 20-second high-frame-rate video keeps total costs under $3. The real cost lies in the upfront shot planning work—and this is precisely the part ChatGPT/Codex can help shoulder. It's worth noting that without systematic shot planning, creators might need to regenerate a dozen versions before getting a satisfactory result, with cumulative costs far exceeding $3. Therefore, upfront planning investment actually reduces overall costs.

Deeper Implications: The Universality of End-State Thinking

What this creator values most isn't that ChatGPT wrote a beautiful prompt, but that it helped transform a vague visual idea into a set of constraints, causal relationships, and transitions that another model can execute.

Behind this is actually a universal engineering mindset: when the end state matters more than the starting point, backward planning from the endpoint is often more reliable than forward planning from the start. End-state backward planning (Backward Planning / Goal Regression) has deep theoretical foundations in AI planning. The classic STRIPS planner employs goal regression strategy, starting from the desired final state and progressively finding action sequences that achieve each sub-goal. In robotics, Inverse Kinematics similarly works backward from the end effector's target pose to determine joint angles. In animation, Keyframe Animation works similarly—first establishing key poses, then having software interpolate the intermediate process. This case introduces this classic methodology into the AI video generation domain, representing a meaningful cross-domain transfer.

At the end of the post, the author posed an open question—whether this "end-state first" method also applies to:

• UI animation: Final layout is fixed, reverse-engineer interaction transitions
• Robot simulation: Target pose is determined, plan motion trajectories
• Architectural visualization: Final viewpoint is clear, design walkthrough paths

The answer is very likely yes. Any task where "the result is determined but the process needs to be generated" can try using large language models as constraint solvers and path planners, rather than mere text generators. This aligns with the philosophy of "Declarative Programming" in computer science—you describe "what you want," not "how to do it," and let the system find paths that satisfy the constraints.

For AI video creators, the value of this case lies in providing a transferable collaboration paradigm: rather than treating AI as an uncontrollable black box to be cajoled, treat it as a reasoning partner that can help you decompose problems, define constraints, and diagnose failures. When input ambiguity is systematically eliminated, the generative model's output naturally becomes controllable.

Key Takeaways