The 12-Stage AI Vertical Short Drama Pipeline: From Greenlight to Final Cut

Maosika Editorial ｜ Last updated 2026-07-29

Most AI short drama failures aren't model failures—they're pipeline failures: teams skip lock steps, generate before assets exist, and let drift compound across episodes. A working pipeline enforces order: story first, then continuity, then look, then shots, then takes.

Why "pipeline" beats "prompt"

A vertical short drama is not one long generation you trim in post. It is dozens of small, controllable units—each with its own reference set, shot instruction, and render—stacked into episodes that must feel like the same show. When teams treat it as a single text-to-video button, three things happen: characters change faces between scenes, props vanish, and episode 12 forgets what episode 3 set up.

A production pipeline is the answer. It does not remove creative decisions; it moves them to the right checkpoint, and makes sure the machine only executes what has already been locked.

Continuity is built with assets, not luck.

The 12 stages, in order

The order matters more than the tooling. Skipping a stage is what causes the visible failures audiences actually notice.

Each stage produces a tangible artifact you can inspect, reject, or roll back. That is the difference between a pipeline and a chat window.

Stages 1–3: Greenlight before you generate

The intake gate scores idea completeness 0–100. Above 80, you can go straight to a brief; 40–79, you fill in only the missing dimensions; below 40, you walk through the full ten-step development. The threshold is enforced, not advisory—a model saying "that's enough" is not a greenlight.

The brief is the document that cannot be skipped. It fixes the logline, core conflict, story direction, ending, beat and hook rhythm, target platform and audience, episode-by-episode outline, and notes for the writer. The lead character field must include an arc.

A locked brief is the difference between a show and a jam session.

Stages 4–6: Write against a bible, not against memory

Vertical drama writing has hard rules that belong in the process, not in the writer's head:

1. Golden 3 seconds — Scene 1 opens on conflict or suspense; no flat setup, no expository voiceover.
2. Per-episode structure — Hook (scene 1) → escalation → cliffhanger (final scene).
3. Payoff density — At least one small payoff per episode (a reveal, a reversal, a clue, an identity hint); a larger payoff every 3–5 episodes.
4. Dialogue — Short lines, typically under 20 characters in the source language; no essay-speak, no paragraph-long narration.

The continuity bible is a structured record running the whole series: who characters are, their stable traits, their current state (injuries, revealed identities), relationships, which plot threads are open versus resolved, episode-by-episode appearance tables, batch summaries, and prop visual descriptions. When writing, the system only feeds the relevant slice—current character states, unresolved threads, recent batch summary, this batch's main line. After each batch, the bible is updated before the next batch starts.

You don't rely on model memory; you rely on a structured archive.

Stages 7–8: Lock the look before a single frame renders

A style manual is not a vibe. A working manual covers how characters are drawn (face anchors, materials, temperament, view consistency), how scenes and props are treated, and which video style tags travel downstream. Crucially, characters, scenes, props, and shot prompts all consume the same style path—this is what prevents "anime character, photoreal video" mismatches.

Look development runs in two passes: text polish (turning bible descriptions into drawable prompts under the chosen style, with gender as a hard rule), then image generation with optional reference images, saved as versioned history. The video side only consumes assets marked complete and readable—it never shoots against half-finished turnarounds.

Scene plates follow one discipline: no people in empty shots. Props are pulled per episode from the script's own wording, in a shooting-script view, then merged into a show-wide catalog so nothing is lost between episodes.

Stage 9: Cut into scene blocks before you prompt

A finished episode script is not yet a shot list. The pipeline splits it into scene blocks targeting roughly 10 seconds each, soft-capped around 200 characters of action, with re-splits triggered by action beats, paragraph breaks, and sentence endings. Extras and generic roles are separated from drawable leads so they don't consume character slots.

What you see in the workspace is not "Episode 3, one big video." It's Episode 3 → Block 1, Block 2, Block 3… each with its own prompt, its own reference set, its own output file, and its own history of takes. This is the clip bin on an editing desk.

The default deliverable is 9:16 vertical, not a landscape file cropped after the fact—a detail that changes everything about how shots are framed.

Stage 10: Engineering the shot prompt

A good shot prompt is a storyboard note, not a paragraph of prose. The system builds prompts around eight components:

• Precise subject
• Action detail
• Scene environment
• Lighting and color
• Camera movement
• Visual style
• Image quality
• Constraints

A few of the rules that matter most in practice:

• One camera move per shot. No push-pull-pan-zoom stacking inside a single block.
• Shot numbers, not timestamps. Prompts reference "Shot 1 / Shot 2," never "0–3s."
• Mandatory fallback pack — image quality, face stability, no watermark or logo; multi-person scenes add twinning / duplicate-body guards; non-realistic styles get an explicit style anchor.
• Action is specific and bounded — fine-grained limb movement, quantified degree of motion; slow continuous actions are preferred over high-dynamics bursts that break.
• Notation — dialogue in {}, sound effects in <>, score in ().
• Only this block's assets are in scope. Cross-scene bleeding is explicitly forbidden; the block's script text is the highest-priority source.

The system is teaching the model to speak storyboard language, not to write a novel.

Before delivery, prompts are cleaned of specific copyrighted work or IP names, keeping technique and aesthetic descriptors, to reduce downstream rights-blocking risk.

Stage 11: Render like a production queue, not a script toy

When you hit render, the worker uses exactly the prompt you confirmed (or edited) and the reference mapping that was locked at that moment. Change the prompt and you get a new take—same as on set when the director revises the shot note.

Production-grade behavior is what makes this usable day to day:

• Output files are faststart-processed and stored with measured duration, not just the vendor's reported duration.
• Video tasks run on an independent queue lane, isolated from script and art generation slots.
• A block already in flight cannot be double-submitted, preventing duplicate charges and state confusion.
• Credits are pre-deducted and settled; failures auto-release.
• Stuck tasks time out and are recoverable; failures are visible and retryable.

This is an operable production queue, not a toy script.

Stage 12: The human is still the quality gate

This is where it is important to be honest about what the pipeline does not do.

1. There is no automatic scoring or auto-retake engine. Final quality judgment sits with the creator and showrunner; the system gives you multiple takes and the tools to re-render with revised inputs.
2. Reference images are not a hard gate. Missing assets trigger a reminder, but you can skip and shoot text-only—quality is usually worse, which is why a professional flow locks look-dev first.
3. Reference tokens in prompts rely on the spec, not a second hard injection. Creators should still confirm references are present when reviewing prompts.
4. Shot grammar follows the built-in camera spec; the style manual injects video style tags, not the full art book, which lives on the look-dev side.
5. The ~10-second block is an engineering heuristic, not timecode-precise. Long scenes get re-split, but some blocks still run long; fine cutting and stitching belong in a later edit pass.
6. There is no cross-block auto-extend workflow in the product today. The unit of work is "single block, multi-modal references → single clip."
7. Character consistency depends on the look-dev asset chain, not a face-embedding check. Era-specific costume routing is rule-based; final look still depends on turnaround quality and whether the prompt respects "if a reference exists, don't describe the outfit in text."

The rule worth memorizing: for any character with a reference image, the prompt must not re-describe clothing or appearance in text. The image decides; text only describes action, expression, and injury. That single rule eliminates most of the face-and-outfit drift people blame on "the model."

Where the pipeline actually pays off

The gains are structural, not magical:

• Drift that used to compound across episodes is caught at the brief, the bible, and the look-dev stages, not after 30 episodes are rendered.
• Re-shoots are cheap because the unit is a ~10-second block, not a whole episode.
• Style stays unified because one manual feeds characters, scenes, props, and shots.
• Creative decisions sit at checkpoints (sign-off on brief, cast, style, batch intent, prompts, takes), while the machine handles the repetitive, drift-prone work of carrying those decisions into every scene.

Maosika (猫斯卡) is an AI production operating system for vertical short dramas that hard-codes this sequence—from intake and brief through bible, look-dev, blocking, shot prompts, rendering, and retakes. Its position is explicit: it turns the repetitive, drift-prone, failure-prone parts of the process into a constrained pipeline; aesthetic judgment still sits with the human.

If you are building a slate rather than a one-off, the pipeline is the product. The model is just the camera.

About Maosika — Maosika · Professional AI Video Production System. It connects briefing, scripting, look development, shot prompts and delivery into one reviewable pipeline. www.maosika.com