How AI Vertical Short Dramas Actually Get Made: A 12-Step Production Pipeline From Idea to Finished 9:16 Episode

Maosika Editorial ｜ Last updated 2026-07-29

AI short drama failures almost never come from bad video models. They come from skipping the order of operations: locking the brief, building continuity, approving looks, then shooting scene by scene instead of generating a whole episode at once.

The order matters more than the tools

Most teams new to AI vertical short drama approach it the wrong way around: write a script, throw it at a video model, then try to fix broken faces, drifting costumes, and forgotten plot threads in post. That workflow treats production like a single generation step, when it is really a pipeline with hard gates.

A production-ready AI short drama pipeline is a sequence of verifiable handoffs. Each stage produces something you can read, look at, edit, or reject before the next stage begins. If one stage is weak, every later stage inherits the problem.

A vertical short drama AI pipeline is the ordered set of creative, continuity, art, and shooting stages that turn a one-line idea into a finished 9:16 episode, with reviewable assets at every gate.

This guide walks through 12 stages in the order they should happen, using the language of a real set rather than model marketing. The claim is not "AI does everything." The claim is that repeatable, drift-prone work can be constrained into a pipeline, while taste and final judgment stay with the creator.

Why "generate an episode" is the wrong unit

Traditional short drama production does not shoot "an episode." It shoots scenes. Each scene has a location, cast list, props, shot list, and takes. AI production works the same way when it works well.

When a team tries to generate a full 60–90 second episode in one shot, several predictable problems appear:

• the lead's face changes between cuts
• costumes drift because the model re-imagines them each shot
• props from episode 3 disappear in episode 8
• cliffhangers contradict earlier plot turns
• tone shifts from realistic to anime mid-episode
• the model invents backstory that was never approved

These are not isolated model bugs. They are pipeline failures. The fix is not a better prompt. The fix is smaller, named, reviewable units: a locked brief, a continuity bible, approved character art, approved scene art, per-scene shot instructions, and per-scene takes.

The 12 stages, in order

The table below shows the full pipeline. The order is not arbitrary. Moving "shoot" before "lock looks" or before "approve beat sheet" is where most AI productions fall apart.

Stage 1–3: From idea to locked brief

The first job is not scriptwriting. It is deciding what the show is.

A useful intake covers the vertical-short-drama-specific dimensions: genre, protagonist, core contradiction, story direction, episode count, episode length, tone, hook rhythm, ending direction, target platform, and audience. Episode length usually lands in the 1–2 minute range for vertical shorts, sometimes extending to 3–4 minutes depending on platform.

If the intake is incomplete, the right move is not to guess. It is to ask the missing questions until the brief is strong enough to lock. In production terms: you hold the development meeting before you greenlight the shoot.

The locked brief should contain at least:

• one-sentence logline
• central conflict
• protagonist arc
• story direction and ending shape
• hook and payoff rhythm
• target platform and audience
• episode-by-episode outline
• notes to the writer about what not to do

Once locked, this becomes the hard constraint for everything downstream. If later writing or art conflicts with it, either the brief changes through an explicit decision, or the later work is wrong.

Stage 4–5: Cast, visual direction, and the story archive

AI does not naturally remember your show. It remembers whatever is in the current context window. That is why a structured story archive matters more than clever prompting.

A story archive is a structured continuity record for the whole series: character identities, stable traits, current state, relationships, open and resolved plot threads, episode appearance tables, batch summaries, and visual prop notes.

This is the AI-era version of a writer's room continuity bible. Its job is to make sure episode 40 still knows what happened in episode 4, not because the model "remembers," but because the archive is read before each batch and updated after it.

At this stage you also name the cast and define their arcs. A protagonist without an arc is just a description; a show without stable cast definitions will redesign them every time art is generated.

Stage 6–8: Batch writing, beat sheets, and rule checks

Long-form short drama should not be written as one giant script. It is written in batches, with each batch planned before its pages are drafted.

Before writing a batch, four things should be set:

1. where this batch's plot is going
2. which characters carry it
3. which threads advance or resolve
4. how each episode ends on a hook

Each episode should have a beat sheet before dialogue is written. For vertical shorts, the rhythm is strict:

• Golden 3 seconds: the first scene opens with conflict or suspense, not background explanation
• Episode body: escalation through scenes
• Episode end: a cliffhanger in the final scene

A few writing rules are specific to the format:

• short lines, usually under ~20 characters in Chinese or equivalently tight in English adaptation
• no lecture-style dialogue
• at least one small payoff per episode, such as a reversal, identity hint, evidence drop, or comeback beat
• a larger payoff every several episodes

After drafting, scripts should pass a rule-based check before anyone sees them as "done." Things to catch: missing cast headers, too little dialogue, placeholder text like "to be continued," mismatched scene counts, and episode title errors. If it fails, it goes back for rewrite with the specific failure attached.

Then the archive is updated. This write-back step is what makes long runs possible.

Stage 9: Style lock and look development

Style is not a vibe. It is a path that every visual asset must follow.

A serious pipeline includes multiple style manuals covering 2D, 3D, and realistic directions: urban realism, period realism, mature urban romance animation, 1990s anime, Chinese ink style, xianxia period looks, 3D donghua, stop-motion clay, cyber-Chinese fusion, and others. Each manual should cover at least character appearance anchors, material and texture language, scene and prop treatment, and video style tags.

Once a style is chosen, character art, scene art, prop art, and video prompts all follow the same style path. This is how you avoid the common AI failure where characters look like anime but the footage turns photoreal.

Character art should be produced in two steps:

1. text polish: turn archive descriptions into art-ready prompts under the chosen style, with gender treated as a hard rule
2. image generation: generate the art, allow reference input, and save versions as reviewable history

Video should only consume art that is finished and readable. Half-approved concept art should not be silently bound into a shot.

The reference image discipline

This is one of the highest-leverage rules in AI short drama production.

When a character has approved reference art, the shot prompt must not re-describe that character's clothing or appearance in text. The reference image is the source of truth. Text describes action, expression, and injury state only.

This rule directly prevents face swaps and costume changes. If the prompt says "woman in red dress" but the reference shows a blue coat, the model has to resolve a conflict. Remove the conflict.

For each scene, reference assets should be mapped in a fixed order:

1. scene art
2. props used in this scene
3. character art

If an asset does not exist, it should be marked as text-only rather than invented. Props should be pulled from the script using the script's own names, then deduplicated into a show-wide catalog. Scene art should be empty of people, so it reads as a location plate rather than another character reference.

Before shooting, the pipeline should check whether required references are missing. It can allow shooting without them, but the team should know that pure-text shots are usually less consistent.

Stage 10: Scene blocking into ~10-second chunks

A finished episode is not one generation job. It is a list of scene blocks.

A scene block is a short shootable unit, usually around 10 seconds, cut from the script by action beats, paragraph breaks, and sentence boundaries. If a written scene runs long, it gets split further. The result looks like a clip list on an editing timeline: Episode 3, Scene 1, Scene 2, Scene 3, each with its own prompt, references, and takes.

This matters because correction happens at the scene level. If one shot has a bad action or wrong prop, you reshoot that block, not the whole episode.

Crowd characters and generic extras should be separated from named cast so they do not consume limited reference slots meant for leads.

Stage 11: Shot instructions and the shoot

A good video prompt is not a paragraph of prose. It is a shot instruction.

An engineering-grade shot prompt is a structured instruction containing eight parts: subject, action detail, scene environment, lighting and color, camera movement, visual style, image quality, and negative constraints.

A few rules separate usable prompts from creative writing:

• one camera move per shot; do not stack push, pull, pan, and tilt together
• label shots by shot number, not by absolute timestamps like "0–3s"
• include a base constraint package for face stability, no watermark, and clean image quality
• for multi-character shots, add constraints against duplicate faces and twinning
• keep actions continuous and low-acceleration where possible; high-motion bursts break more often
• mark dialogue, sound effects, and music with consistent notation
• feed only this scene's assets into this scene's prompt; do not leak props from another scene

The goal is to speak to the model in the language of a shot list, not a novel.

Before prompts are sent, IP names and specific protected references should be cleaned out, leaving aesthetic and technical description. If a reference image is detected as a real-person photo rather than produced art, the pipeline should flag this rather than silently bind it.

On the shoot side, production controls should look like a real set:

A new take should only be created when the prompt or references actually change. Re-clicking "generate" without changing anything is not a new creative decision; it is just a duplicate render.

Stage 12: Review, reshoot, and final cut

There is no reliable automatic "best take" engine in AI video yet. Final quality judgment still belongs to a human reviewer.

What the pipeline can do is make review operational:

• each scene block has its own take history
• failed renders are visible and retryable
• jobs run in a queue isolated from script and art tasks
• duplicate submissions for the same in-progress scene are blocked
• credit or cost holds are released on failure
• finished videos are checked for actual runtime rather than trusting vendor metadata

This is what makes the system usable for production, not just experimentation. A toy script generates a video. A production pipeline tracks jobs, prevents double charges, recovers stuck tasks, and gives you per-scene takes you can compare.

Where AI helps, and where it does not

It is worth being explicit about the boundaries, because overclaiming is everywhere in this category.

AI production does not mean:

• zero human involvement
• one-click hit shows
• perfect 100% character consistency
• automatic best-take selection
• automatic cross-scene video continuation as a finished product flow
• timecode-precise editing directly out of generation

It does mean:

• the order of operations can be enforced
• continuity can live in a structured archive instead of memory
• look development can be locked before shooting
• scenes can be shot as discrete units
• prompts can follow shot-list grammar instead of prose
• bad shots can be reshot without redoing the whole episode

High-quality short drama is never one long generation chopped up in post. It is a stack of controllable units.

A practical checklist before your next AI shoot

Before you render anything, use this list:

1. Is the brief locked, including protagonist arc and ending direction?
2. Is there a story archive, and has it been updated from the last batch?
3. Did each episode get a beat sheet and cliffhanger before dialogue?
4. Are all named cast members approved in final art?
5. Are scene plates clean of people?
6. Are props cataloged under their script names?
7. Are episodes split into ~10-second scene blocks?
8. Does each scene have references mapped in scene → props → cast order?
9. Do shot prompts avoid re-describing clothed appearances for referenced characters?
10. Are you ready to review takes per scene and reshoot only the blocks that fail?

If the answer to several of these is "no," the problem is not the video model. The pipeline is not built yet.

Where Maosika fits

Maosika (猫斯卡) is designed around exactly this sequence: an AI production operating system for vertical short dramas rather than a single text-to-video button. It hardcodes the order from idea evaluation and brief lock, through cast and continuity archive, batch script writing with rule checks, style and look development, ~10-second scene blocking, reference-mapped shot instructions, multi-modal vertical shooting, and per-scene take review.

The product does not claim to replace writers, directors, or producers. It turns the repeatable, drift-prone, failure-prone parts of the process into a constrained pipeline, while approval, taste, and final cut remain with the creator.

If you are planning your first AI vertical short drama slate, you can read more about the [character consistency system](/blog/ai-short-drama-character-consistency/) and [shot prompt structure](/blog/ai-short-drama-shot-prompt-structure/) as companion pieces.

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