How AI Vertical Short Dramas Actually Get Made: A Stage-by-Stage Production Pipeline

Maosika Editorial ｜ Last updated 2026-07-25

Most AI short drama failures are not model failures; they are order failures. Skipping the brief, locking the cast, or building shots before continuity is set is what causes face swaps, plot drift, and unusable episodes.

The core problem is workflow order, not model quality

Teams new to AI micro-drama production usually start the same way: type a logline, generate a script, generate a video, and hope it holds together. It almost never does. Characters change faces between scenes, props appear and disappear, episode 7 forgets a promise made in episode 2, and the final cut looks like five different shows stitched together.

The fix is not a better prompt. The fix is an industrial sequence: decide what the show is, lock the brief, build continuity, write in batches, approve looks, split into scene blocks, assign references, write shot instructions, render, then retake. Each stage produces something reviewable before the next stage starts.

A production pipeline for AI vertical short drama is a staged workflow where every phase has an inspectable deliverable: brief, story archive, script batch, character/scene/prop art, scene block, shot prompt, rendered take, and revision pass. The pipeline exists to prevent later stages from guessing decisions that should have been locked earlier.

Stage 1: Intake and creative evaluation

Before any writing begins, the idea needs enough structure to route correctly. A vague concept like "a CEO revenge drama" is not a brief; it is a direction. The intake should score how complete the idea is across the dimensions that actually affect vertical drama writing:

• genre and tone
• protagonist and character arc
• core conflict
• story direction and ending direction
• episode count and episode length
• satisfaction beats and hook rhythm
• target platform and audience

If the intake is incomplete, the team should fill the missing dimensions instead of letting the model improvise them later. In a well-built system, low-completeness ideas go through a fuller guided intake; high-completeness ideas can move faster to a locked brief.

The production analogy is simple: the development meeting must end before principal photography begins.

Stage 2: Lock the creative brief

The brief is the first hard lock. It should contain the logline, central conflict, story direction, ending direction, beat and hook rhythm, platform and audience, episode-level outline, protagonist arc, and notes for the writer.

This is not ceremonial. The brief becomes the constraint set for everything downstream. If the protagonist's arc is not defined here, later scripts will invent one. If the hook rhythm is not defined here, episodes will start slowly or end without cliffhangers.

A useful brief answers the question: "What are we not allowed to change without a deliberate decision?"

Stage 3: Build the story archive before writing long runs

AI models do not naturally remember a multi-episode drama. They work from the context they are given at the moment of writing. That is why long-form serialized storytelling needs a structured continuity record, not a single long chat thread.

The story archive is the production bible for the show. It tracks:

The principle is: do not rely on model memory; rely on a structured archive. Each writing batch should consume only the archive slice it needs, then write back new facts after approval.

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

Vertical short drama has strict rhythm requirements. Episodes are usually 1–2 minutes, with some formats extending to 3–4 minutes. The first scene must hook within the opening seconds; the episode must escalate; the final scene must end on a cliffhanger.

A reliable script stage follows these rules:

1. Beat sheet before dialogue. Each episode should have a scene-by-scene beat outline and a planned cliffhanger before the full script is written.
2. Batch writing with intent lock. Before each new batch, confirm the plot direction, focus characters, threads to advance, and end-of-batch hooks.
3. Mid-run ending pressure. Once the story passes its halfway point, ending constraints should become explicit so the show does not wander.
4. Episode-to-episode continuity. Each new batch should carry forward the previous episode's full text, not just a vague summary.
5. Rule-based quality check. Scripts should be checked for missing character lines, wrong episode titles, scene-count mismatches, placeholder text, and too little dialogue.

The writing rules that matter most for vertical micro-drama are not literary; they are mechanical:

• open with conflict or suspense, not exposition
• keep lines short, usually under 20 English words
• place at least one small satisfaction beat per episode
• place a major payoff every several episodes
• end the episode on pressure, not resolution

Stage 5: Approve the visual language and cast looks

Writing must be locked enough to support look development, but video should not begin before the visual identity is approved. This stage includes art style, character designs, scene art, and prop art.

A mature pipeline should offer multiple style manuals covering 2D, 3D, and realistic directions: urban realism, period realism, mature romance animation, 1990s anime, Chinese ink style, xianxia, 3D donghua, clay stop-motion, cyber-Chinese fusion, and others. The chosen style should then govern character art, scene art, prop art, and video style tags together, so the show does not switch visual dialect between assets and footage.

Character approval should be a hard gate. The cast must be complete, names valid, visual fields complete, and leads aligned with the brief. If a character is half-defined, the video stage will complete them randomly.

Stage 6: Map references before generating shots

Character inconsistency in AI video usually comes from one mistake: every shot re-describes the character in words. The model then re-imagines clothing, face, and age each time.

The production solution is reference mapping. For each scene, build a reference table in a fixed order: scene image first, then prop images, then character look images. If an image does not exist, leave that slot empty and mark it as text-only rather than inventing a false reference.

The highest-priority rule is: if a character has a reference image, do not describe that character's clothing or appearance again in the shot prompt. The reference image owns the look. The text should only describe action, expression, injury, and scene behavior.

This one rule eliminates a large share of AI short drama face-swap and costume-drift problems.

Reference mapping also needs manual controls:

• bind script names to archive characters when wording varies
• include only props that matter to the scene
• swap to another approved version of the same asset when needed
• route period or modern looks correctly for flashback and transmigration stories

Stage 7: Split episodes into scene blocks

A vertical episode should not be treated as one giant generation. It should be cut into scene blocks, usually around 10 seconds each, with a soft body-text limit and further splitting when action beats require it.

This is closer to a clip list on an editing timeline than to a single video export. Each scene block has its own reference set, its own shot prompt, its own render job, and its own history of takes.

Why this matters:

• shorter blocks are more stable for AI video generation
• errors can be retaken per scene instead of regenerating a whole episode
• references stay scene-specific and do not leak across locations
• editors receive discrete units instead of one messy long clip

The 10-second target is an engineering heuristic, not a timecode-precise edit. Some scenes may run longer, and final assembly still belongs in the editing stage.

Stage 8: Write engineered shot prompts, not novelistic prompts

AI video models do not benefit from beautiful prose. They benefit from structured shot instructions. A good prompt for a vertical drama scene should include eight components:

1. precise subject
2. action detail
3. scene environment
4. lighting and color tone
5. camera movement
6. visual style
7. image quality constraints
8. negative or stability constraints

For simple scenes, one paragraph may be enough. For complex cinematic scenes, use a three-part structure: overall scene setup, then shot-by-shot instructions, then a constraint package.

Shot-writing rules that reduce failure:

• one camera move per shot; do not stack push, pull, pan, and tilt together
• use shot numbers, not absolute timestamps like "0–3s"
• keep actions continuous and physically moderate; extreme motion breaks more often
• include a stability package for face consistency, watermark avoidance, and quality
• mark dialogue, sound effects, and music with consistent notation
• feed only the current scene's references and script; do not let other scenes contaminate the prompt
• strip specific copyrighted IP names while keeping aesthetic and technical direction

The goal is to make the model read like a camera department, not like a novelist.

Stage 9: Render, review, and retake like a real set

Once prompts and references are ready, production becomes a queue, not a magic button. The creator should be able to choose model tier, aspect ratio, resolution, and duration. Vertical 9:16 should be the default output shape, not a crop applied after generation.

A production-ready render stage needs operational controls:

A serious system should also handle queue isolation, failed jobs, retry visibility, duplicate-submission prevention, and accurate recorded duration instead of trusting vendor-reported metadata. That is what makes it usable for batch production rather than demos.

What this pipeline does not do

It is important to be honest about the boundaries:

• There is no automatic "best take" judge. Final quality still belongs to the creator or supervisor.
• Reference images are not a forced gate. Teams can skip them and render from text, but consistency usually suffers.
• Scene blocks are approximate, not frame-accurate edits. Final cutting and stitching still require post-production.
• Cross-scene automatic video continuation is not the core unit of work; the product unit is one scene block with its own references and output.
• Character consistency depends on the asset chain and prompt discipline, not a magic face lock.

The point of an AI production system is not to remove human judgment. It is to turn the repetitive, drift-prone, failure-prone parts of short drama production into a constrained pipeline, while keeping taste and final approval with the people making the show.

Where Maosika fits into this sequence

Maosika is an AI production operating system for vertical short dramas. It does not present itself as a single text-to-video button. Instead, it structures the workflow described above: idea evaluation, guided brief locking, story archive, batch script writing with rule checks, look development, reference mapping, scene blocks, engineered shot prompts, rendering, and per-scene retakes.

The system uses 18 digital specialist roles modeled on real crew positions, including archive secretary, producer, screenwriter, continuity supervisor, casting director, art director, costume and makeup, props, storyboard artist, director of photography, director, camera operator, editor, and VFX technical supervisor. Users can see streaming work records from these roles, so the process is inspectable rather than a black box.

Maosika also bakes in several of the discipline points covered above: beat-sheet-first script writing, continuity archive updates, 17 style manuals, two-stage character art generation, fixed reference priority, 9:16 vertical output as default, and prompt generation built around shot structure rather than descriptive fiction.

It is best suited for teams that want to scale vertical micro-drama production with reviewable stages and repeatable process. It is not a replacement for story judgment, directorial choice, or final editing; those still sit with the production team.

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