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

Maosika Editorial ｜ Last updated 2026-07-29

Most AI short drama failures are not model failures—they are pipeline failures. A reliable vertical drama is built stage by stage, with a checkable artifact at every handoff, not generated in one long shot.

The core idea: treat AI like a crew, not a magic button

A production pipeline is a sequence of stages where each stage produces something the next stage can consume. In traditional crews, that thing is a script, a casting sheet, a location, a storyboard, a shot list, a take. In AI vertical short drama production, the same logic applies—only some of the crew roles are digital.

The central claim of this piece is simple: quality comes from the order of operations, not from any single prompt or model. If you skip story lock and jump to video, you get plot drift. If you skip character look development and jump to rendering, you get face swaps and costume changes. If you render whole episodes as one clip, you lose the ability to retake only the broken shot.

This is not a theory piece. It is a field map of how a working pipeline should behave, written for producers, writer-directors, and small teams who need output they can actually ship.

---

Stage 1 — Intake: score the idea before you develop it

The first gate is not writing. It is answering whether the idea is developed enough to write.

A useful intake captures the vertical drama dimensions that actually determine downstream work: genre, protagonist, core conflict, story direction, episode count, episode length, tone, hook rhythm, ending direction, and target platform / audience.

Intake scoring is the practice of grading that completeness on a 0–100 scale and routing the project accordingly:

• 80+: the idea is specific enough to go straight to a locked brief.
• 40–79: only the missing dimensions need to be filled in.
• Below 40: the idea needs a full development conversation before any script work begins.

This is a forced routing decision, not a polite suggestion. The equivalent in a real production room is: you do not call a writer into a room that has not decided what the show is.

---

Stage 2 — Creative brief: lock the version everyone works from

The brief is the first artifact that must be *locked*. Until the brief is locked, no one writes, no one casts, no one designs.

A strong vertical drama brief contains:

For the protagonist, the brief must also include the character arc—not just a job title and a costume. Vertical dramas live or die on whether the lead changes state across episodes.

The brief lock is the moment development ends and production begins. Everything after this is execution against a known target.

---

Stage 3 — Cast & visual confirmation: who is in this show?

Before a single script page is written against characters, the cast must be confirmed as complete and aligned with the brief.

The check here is operational, not artistic:

• Every named role that will recur exists in the cast list.
• Names are legal and consistent (no "her", "the boss", "that guy" leaking into scripts).
• Visual fields are complete enough to drive look development later.
• The protagonist matches the brief—same arc, same role in the conflict.

This is a hard gate. If the cast is not aligned, later stages will invent appearances on the fly, and that is where inconsistency starts.

---

Stage 4 — Story bible: stop relying on model memory

A story bible (sometimes called a continuity bible) is a structured record of everything that must stay true across episodes: character identities, stable traits, current state (injuries, revealed identities, changed relationships), relationship maps, open and resolved plot threads, episode appearance tables, batch-level plot summaries, and prop visual descriptions.

The bible solves a specific problem: long-form context does not fit reliably in a model's active attention window across dozens of episodes. Rather than hoping the model "remembers", the pipeline feeds each writing batch only the slice it needs:

• current character states,
• unresolved threads,
• recent batch summaries,
• and the mainline for the current batch.

After each batch, the bible updates. Before the next batch, the bible is read back in. Continuity comes from structure, not from luck.

---

Stage 5 — Batch writing: plan the beats before the prose

Vertical drama writing works best in batches of a few episodes at a time, not one giant 80-episode generation. The reason is control: a batch is small enough to review, lock, and archive before moving on.

Each batch follows a strict order:

1. Beat sheet first: every episode starts with a scene-by-scene beat outline and a confirmed cliffhanger for the end of the episode. Dialogue comes after.
2. Episode structure: opening hook (scene 1) → rising conflict → cliffhanger (final scene).
3. Payoff density: at least one small payoff per episode (a face-slap, a reveal, identity hint, piece of evidence); a larger payoff every few episodes.
4. Dialogue rules: short lines, generally under ~20 characters in Chinese originals and equivalently tight in translation; no essay-speak; no long narrator exposition dumps.
5. Golden 3-second rule: the first scene must open with conflict or suspense—never a slow pan over a city skyline and a paragraph of backstory.

From the second batch onward, the pipeline should lock four things before writing: the batch's plot direction, the focus characters, which threads and conflicts are active, and the episode-end hook. Those become hard constraints. If they conflict with the old bible, the newly confirmed intent wins.

---

Stage 6 — Rule-based quality check: catch the mechanical failures

After a batch is written, it should pass a rule-based checker before anyone reads it as "done". The issues caught here are not taste issues; they are assembly issues:

• wrong episode titles,
• mismatched scene counts,
• missing character lines,
• too little dialogue,
• placeholder text like "to be continued" used as content.

A batch that fails should be sent back for rewrite with the specific error attached, up to a capped number of retries. Nothing half-finished should move downstream, because bad script structure turns into bad video later—and fixing it at the video stage is ten times more expensive.

---

Stage 7 — Look development: pick one visual language for the whole show

Before any image is generated for characters, scenes, or props, the show picks a look—a single visual language that every downstream asset shares.

A mature pipeline ships with multiple built-in look books covering 2D, 3D, and realistic directions: urban realism, period realism, mature urban romance animation, 90s anime, Chinese ink style, xianxia, 3D donghua, stop-motion clay, cyber-Chinese fusion, and so on. Each look book includes at minimum:

• a character sheet guide (face anchors, material, temperament, view consistency),
• a scene & prop guide,
• and video style tags that the renderer will consume.

The point of locking a look is to prevent the classic AI fracture: characters drawn in anime style, video rendered in photoreal style, props looking like they came from a third show. One visual path, used everywhere.

---

Stage 8 — Asset production: characters, scenes, props, in that order

Once the look is locked, the pipeline generates the visual assets the show will actually render against.

Characters use a two-step process: first the text description is polished into a prompt using the look book and hard gender rules (human-overridable), then the image is generated, with support for reference images, and versioned into a history you can roll back to.

Scenes are parsed directly from script structure—interior/exterior, location, day/night—rather than re-entered by hand in a separate table. A strict rule: scene reference images must contain no people. Empty frames are empty frames.

Props are pulled episode by episode from the script itself, using the script's own naming, then merged into a show-wide catalog so nothing is lost across episodes.

A key authority rule: user and script descriptions override look-book world rules. The look book controls *how* things are drawn; it does not get to refuse content that the story requires.

---

Stage 9 — Reference mapping: the single most important consistency mechanism

Reference mapping is how the pipeline tells the renderer exactly which assets to look at for each shot. The order is fixed:

Scene image → props in this shot → character look sheets

Only assets that actually exist get a slot. If something is missing, it is marked as text-only rather than silently invented.

The highest-priority rule in the entire video side of the pipeline:

When a character has a reference image, the prompt must not describe that character's clothing or appearance in text. The reference image is the authority. Text describes only action, expression, and injury state.

This rule exists to kill the most common AI video failure: text description fighting the reference image, which causes costumes to change mid-scene and faces to swap.

Additional mapping controls that belong in a real pipeline:

• Manual character binding: handle cases where the script says "the officer" but the cast bible has them as "Li Qiang".
• Prop include / exclude: keep irrelevant props out of the reference slots so the model focuses on what the shot is actually about.
• Version swap: swap in an older or alternate approved image for the same entity.
• Era routing: for time-slip / flashback stories, pick the correct costume version based on scene location keywords.

Before shot prompts are generated, the pipeline should run a pre-flight check listing any missing scene / character / prop references. Skipping is allowed (text-only path exists), but the team should know they are skipping—professional workflow locks looks before shooting.

---

Stage 10 — Scene blocking: cut episodes into ~10-second shot blocks

Episodes are not rendered as one long video. They are cut into scene blocks targeting roughly 10 seconds each, with a soft cap on script length per block and further splitting on action beats, paragraph breaks, and sentence boundaries when needed.

Why ~10 seconds? Because that is the granularity at which AI video is controllable. A 90-second episode rendered as one clip is a single point of failure; the same episode cut into 8–10 blocks is 8–10 independently retakeable units.

Some useful blocking rules:

• Extras and generic characters are separated from the drawable main cast so they do not consume look slots.
• The whole episode can be re-blocked if the cut does not work.
• Each block has its own prompt, its own reference set, its own rendered output, and its own history of takes.

The on-set analogy is the clip bin on an editing desk: you work with discrete pieces, not a single monolithic file.

---

Stage 11 — Shot prompts: write in storyboard language, not novel language

A shot prompt is not a paragraph of prose. It is a structured instruction that tells the video model exactly what is in the shot and how the camera behaves.

A production-grade prompt contains eight elements:

For complex scenes, a three-part structure works better than one paragraph: overall setup → shot 1 / shot 2 / shot 3 → constraint pack. Shots are numbered; they do not use hard-coded timestamps like "0–3s".

A mandatory constraint pack is appended to every prompt: image quality, facial stability, no watermark or logo. Multi-person shots add twinning / duplicate-body guards. Non-realistic looks add style anchors. Motion is biased toward slow, continuous action rather than high-energy bursts, which are where video models break.

There is also a notation convention for audio: dialogue in {}, sound effects in <>, BGM in （）.

Crucially, the prompt writer sees only the assets for this shot. It does not see other scenes' props or characters, which prevents cross-contamination. The script text for this block is the highest-priority source.

A compliance pass then strips specific copyrighted IP or title names while keeping the technical and aesthetic language, reducing downstream takedown risk. If a reference image is detected as a real-person photo, the pipeline should return a clear warning rather than silently feeding it in.

---

Stage 12 — Shoot, review, retake: operate like a real set

The shooting loop itself should feel familiar to anyone who has worked on set:

1. Open the episode's video workspace.
2. Confirm reference images are present (or deliberately skip).
3. Generate the shot prompt.
4. Read and edit the prompt as a director would edit a shot list.
5. Choose model tier, aspect ratio, resolution, and duration.
6. Submit to render.
7. Review takes and pick the best one.

The key professional controls map cleanly to on-set equivalents:

Default delivery is 9:16 vertical, not a landscape video cropped after the fact. Other ratios are supported, but vertical is the native output shape.

On the reliability side, a production pipeline must behave like one: faststart-processed files, actual rendered duration stored rather than trusting vendor callbacks, separate queue lanes for video vs. script vs. image work, no parallel submissions on the same block, pre-charged credits with automatic release on failure, timeout recovery for stuck jobs, and resumable polling rather than double-submitting.

---

What this pipeline does not do

It is worth being explicit about the boundaries, because honest limits are what make a tool trustworthy for production:

1. There is no automatic scoring engine that picks the "best" take. Final quality judgment sits with the creator and the producer; the pipeline gives you multiple takes and a clean retake loop.
2. Reference images are not a hard gate. You can skip them and go text-only, but quality is usually worse—professional workflow locks looks first.
3. Reference tags in prompts are enforced by convention, not by a second-pass hard stitch. Creators should still read the prompt and confirm the tags are present.
4. Shot grammar follows the pipeline's built-in camera rules. The full art manual is applied on the asset side; video inherits style tags, not the entire art book.
5. The ~10-second block is an engineering heuristic, not a timecode-accurate cut. Long scenes get re-split, but some blocks will still run long; final trimming and assembly belong in a later edit.
6. There is no cross-shot automatic extension workflow. The unit of production is "single block with references → single clip".
7. Character consistency depends on the look-development chain, not face-embedding verification. Era routing is rule-based; final visual consistency still depends on asset quality and on the prompt obeying the "do not describe what the reference already shows" rule.

---

Where Maosika fits

Maosika (猫斯卡) is an AI production operating system for vertical short dramas. Rather than offering a single text-to-video button, it hard-wires the sequence described above—intake scoring, brief lock, story bible, batch writing with rule checks, look development, reference mapping, ~10-second blocking, structured shot prompts, and a retakeable render queue—so that the order of operations a real crew would follow is the order the software enforces.

The philosophy is not "no humans needed". It is: the repetitive, drift-prone, failure-prone parts of the workflow become a constrained pipeline; aesthetic judgment still sits with the person.

If you are building or scaling a vertical short drama slate, the question to ask is not "which model looks the most impressive in a demo?" It is "does the tool enforce the right production order, and does it give me a checkable artifact at every handoff?" That is the difference between a toy and a production system.

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