The AI Vertical Short Drama Pipeline, Step by Step: From Greenlight to Final Take

Maosika Editorial ｜ Last updated 2026-07-25

Most AI short drama failures are not model failures—they are pipeline failures. The fix is to enforce the same order real crews use: lock the brief first, build a continuity bible, approve looks, block scenes, then shoot and retake.

If you have watched enough AI-generated vertical dramas, you already know the failure modes. A character changes face between episodes. The costume described in the prompt fights the reference image. Episode 7 forgets a secret planted in Episode 2. The opening is 40 seconds of flat exposition, and the cliffhanger never lands.

These are usually not problems you can fix by typing a better one-line prompt. They are pipeline problems: the team skipped a gate, let the model improvise continuity, or tried to generate a whole episode as one long clip instead of building it from controlled units.

This guide walks through the production order that actually works for vertical short dramas made with AI. It is written for producers, writers, and directors who need repeatable output, not a demo reel.

The core principle: gates before generation

A healthy AI short drama pipeline is not one big "generate" button. It is a sequence of checkpoints, each producing something you can review, revise, and lock before the next stage starts.

The order matters because later stages consume earlier assets. If you skip look development, the video stage invents faces. If you skip the story bible, later batches drift. If you skip scene blocking, the model decides pacing for you.

A production-ready pipeline looks like this:

1. Idea evaluation
2. Creative intake and guided development
3. Brief lock
4. Character lineup and visual approval
5. Story archive / continuity bible
6. Batch script writing
7. Style selection and look development
8. Scene blocking into roughly 10-second units
9. Reference mapping and shot prompt building
10. Multimodal rendering in vertical format
11. Review, revise, retake, and select

The important phrase is "roughly 10-second units." High-quality micro-dramas are not produced as one long generation and then cut down. They are assembled from controllable clips, each with its own prompt, references, and take history.

Stage 1: Greenlight and intake

Traditional crews do not walk onto set with a half-formed idea. AI crews should not either.

The intake stage is where the project gets scored for completeness. A strong idea already has a logline, protagonist, core conflict, stakes, ending direction, episode count, episode length, tone, hook rhythm, platform, and audience. A weak idea is missing several of those.

A useful rule is to route ideas by how complete they are:

This is not just a form. It prevents the most expensive mistake in AI production: writing dozens of episodes from a premise nobody actually agreed on.

Stage 2: Lock the creative brief

The brief is the first real gate. Nothing should move into writing until it is locked.

A strong short drama brief includes:

• One-sentence logline
• Core conflict
• Story direction
• Ending direction
• Satisfaction beats and hook rhythm
• Platform and target audience
• Episode-by-episode outline
• Notes for the writer
• Protagonist arc

The protagonist arc matters especially in vertical drama. The format is short, but the audience still needs to feel movement: who the character starts as, what pressure they face, and how they change or reveal themselves over the run.

Think of this stage as the development meeting. Once the room signs off, the show has a spine.

Stage 3: Build the continuity bible before you scale

The continuity bible is a structured record of everything that must stay true across the whole drama.

It should include:

• Character identities
• Stable personality traits
• Current state, such as injuries, hidden identity, or changed status
• Relationship map
• Open and resolved plot threads
• Appearance table by episode
• Batch-level plot summaries
• Visual prop descriptions

This is how long-form AI writing avoids "context amnesia." The model should not be expected to remember every detail from a long chat history. It should be given the relevant slice of the archive before each batch: current character states, unresolved threads, recent plot summary, and the main line for the upcoming batch.

In one sentence: do not rely on model memory. Rely on a structured archive.

Stage 4: Write scripts in batches, with beat sheets first

Vertical short drama writing has its own mechanics. It is not prose fiction and it is not traditional TV pacing compressed into a phone screen.

A strong vertical episode follows a tight shape:

• Opening hook: The first scene must bring conflict, suspense, or a hard reversal within the first few seconds.
• Escalation: The middle raises stakes, reveals information, or presses the protagonist harder.
• Cliffhanger: The final scene forces the viewer into the next episode.

For writing workflow, the safest order is:

1. Approve the beat sheet for the episode
2. Lock the episode-end cliffhanger
3. Write the full scene text
4. Run rule-based quality checks
5. Update the story archive
6. Move to the next batch

Quality checks should catch concrete problems, not vague "vibe" issues: wrong episode title, mismatched scene count, missing character lines, too little dialogue, or placeholder text like "to be continued." If a draft fails, it should be sent back with specific errors, not a generic "rewrite this."

From the second batch onward, it helps to lock four things before writing: the batch direction, focus characters, active threads and conflicts, and the end hooks. Those become hard constraints for the run.

Writing rules that fit vertical drama

These rules are blunt, but they work:

• The first scene must hook immediately; no slow background dump
• Every episode needs at least one small payoff: a reversal, a face-slap, an identity clue, evidence revealed, or a power shift
• Every few episodes needs a larger payoff
• Dialogue should be short and speakable
• Avoid essay-like narration that explains what the scene should show

This is why beat sheets matter. They force the structure before the model starts filling pages with fluent but directionless text.

Stage 5: Select one visual style and keep it consistent

AI productions often break at the style stage because different assets are generated under different visual assumptions. The character art looks like modern anime, the background looks like live-action realism, and the video output drifts somewhere else entirely.

The fix is to choose one style path and use it across character art, environment art, prop art, and video prompts.

A useful style system should include:

• Character sheet guidance: facial anchors, materials, mood, and view consistency
• Environment and prop guidance
• Video style tags

A mature pipeline usually offers multiple style manuals covering 2D, 3D, and realistic directions: urban realism, period realism, mature urban romance animation, 1990s anime, Chinese ink style, xianxia fantasy, 3D donghua, stop-motion clay, cyberpunk-Chinese fusion, and so on. The exact count matters less than the discipline: once selected, the whole show lives under that roof.

Stage 6: Approve characters, scenes, and props before shooting

Look development is not optional if you want consistency.

For characters, the lineup needs to be complete, names need to be valid, visual fields need to be filled, and leads need to match the brief. That approval is a hard gate. You do not send half-designed characters into the video stage and hope the model figures it out.

For scenes, locations should be parsed from the script into a production format: interior or exterior, place, day or night. Establishing shots should not contain random people; a scene reference is there to sell the space.

For props, the best approach is to extract them from the script using the script's own names, then build a show-wide catalog. This prevents prop amnesia, where Episode 12 forgets the necklace that caused the whole conflict.

A useful principle here: the script and the creator outrank the style manual on content. The manual controls how things are drawn; it does not get to ban story elements the script requires.

Stage 7: Block episodes into scene units

Once scripts and assets are ready, each episode should be cut into scene blocks. A good target is roughly 10 seconds per block, with soft limits around short text length. Longer scenes can be split further by action beats, paragraph breaks, or sentence rhythm.

This is one of the most important production decisions in the whole pipeline.

Instead of seeing "Episode 3" as one giant output, you see:

• Episode 3
• Scene 1
• Scene 2
• Scene 3
• Scene 4

Each scene gets:

• Its own prompt
• Its own reference set
• Its own rendered output
• Its own take history

This is closer to a clip list on an editing table than a novel manuscript. It makes revision possible. If one beat fails, you reshoot that beat; you do not regenerate the whole episode and pray the rest stays intact.

Stage 8: Map references before writing shot prompts

Reference mapping is where many AI productions either stabilize or fall apart.

For each scene, build a reference table in a fixed order:

1. Scene reference
2. Props appearing in the scene
3. Character look references

Only fill a slot if an actual approved asset exists. If there is no image, mark it as text-only rather than inventing a binding.

Then enforce the most important consistency rule in AI video:

If a character has an approved reference image, do not describe that character's clothing or appearance again in words. The image owns the look. The text should only describe action, expression, and injury state.

That rule directly prevents the classic AI failure where the prompt says "black coat" but the reference shows a white dress, and the model compromises by generating a third, wrong costume.

You should also be able to:

• Manually bind a script name to the correct character sheet
• Include or exclude props to control visual focus
• Swap in an older approved version of an asset if it fits better
• Route period-specific looks correctly for flashbacks or time-crossing stories

Before prompts are generated, the pipeline should warn about missing references. Skipping them should be allowed, but treated as a deliberate trade-off: pure-text scenes are usually less stable, so professional workflow is to approve looks first, then shoot.

Stage 9: Write shot prompts like a production document

A video prompt should not read like a paragraph from a novel. It should read like instructions to a crew.

A strong shot prompt covers eight elements:

A few prompt-writing rules matter a lot:

• One camera move per shot; do not stack push, pull, pan, and tilt together
• Use shot numbers, not rigid timestamp language
• Keep actions simple, continuous, and physically plausible
• Add standard guardrails for face stability, watermark avoidance, and clean output
• In multi-character shots, add protection against duplicate faces or twinning
• Use clear notation for dialogue, sound effects, and music
• Feed only the current scene's assets into the prompt; do not leak references from other scenes

Complex scenes can use a three-part structure: overall setup, then shot-by-shot instructions, then a constraint bundle. Simple scenes can stay compact.

The point is not to sound cinematic for its own sake. The point is to give the model a production language it can follow consistently.

Stage 10: Render vertically by default, then review takes

Vertical short drama should be rendered vertical by default, not generated horizontally and cropped afterward. The default deliverable is 9:16, with options for other ratios when needed.

At the shoot stage, the creator should have real controls:

This is where the pipeline starts behaving like a real production system rather than a toy. A new take should only happen when you change something: the prompt, the references, the model choice, or the shot parameters. Simply pressing generate again without a reason is not directing; it is gambling.

Stage 11: Review honestly and retake with intent

There is no magic button that automatically knows which take is best. Final quality judgment still belongs to the creator or producer.

A mature pipeline supports that judgment by giving you:

• Per-scene outputs
• Historical takes for the same scene
• Clear reasons to retake
• The ability to change words or references before resubmitting

It also needs production basics: queued rendering separate from writing and art tasks, no duplicate submissions for the same active scene, predictable credit handling, timeout recovery, and visible failure states. A tool that silently fails, double-charges, or loses track of renders is not ready for volume work.

Where the limits still apply

It is important to say what this kind of pipeline does not do.

• There is no automatic quality judge that picks the best take for you. Humans still approve final quality.
• Reference images are not a hard technical block; you can skip them, but results usually get worse.
• Prompt reference markers still need human review; the system can guide structure, but creators should check them.
• Roughly 10-second scene blocks are an engineering heuristic, not frame-accurate timecode editing.
• The product unit is one scene with references going to one clip; there is no mature one-click workflow for automatically extending or续写 video across scene boundaries.
• Character consistency depends on the asset chain, not a magic face-lock guarantee. Final look still depends on the quality of approved art and whether prompts stop fighting the references.

Those limits are not failures to hide. They are exactly the boundaries a production team needs to understand in order to plan correctly.

A better mental model for AI short drama

The right way to think about AI vertical drama is not "AI replaces the crew." It is "AI lets a smaller crew run a disciplined industrial process."

The parts that benefit from automation are the repetitive, drift-prone, error-prone parts: archive maintenance, beat planning, asset extraction, reference mapping, prompt structuring, batch queuing, and retake tracking. The parts that still need a human are the ones that require taste: story judgment, casting approval, visual preference, performance selection, and final edit.

That is the division of labor that scales. You do not win by trying to generate a masterpiece in one shot. You win by stacking controlled, reviewable units until the whole drama holds together.

If you want to see this workflow implemented as a production system, Maosika (猫斯卡) is built around exactly this order: brief lock, continuity archive, batched writing, look development, scene blocks, reference-mapped shot prompts, and per-scene retakes. It positions itself as an AI production operating system for vertical short dramas, not a one-click drama generator.

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