A widely cited 2026 industry estimate: script quality carries about 67% of an AI short drama’s success weight, versus 18% for visuals and 15% for sound. That ratio explains most of the failures in your feed — everyone owns the same tools, the pictures all look fine, and the works die on story, every time. Part 1 cited the 0.6% hit rate; Part 2 showed tools are public commodities; chain the three sentences and you get this track’s only correct priority: topic > script > production. This is the heaviest part of the series, covering the first two in depth: the structural formula, the LLM workflow, and the storyboard table that connects words to images.
The 90-second beat map: structure is engineering, not inspiration
First, the life-and-death data: 38.6% of viewers swipe away within 3 seconds, while content that retains past 5 seconds sees completion probability multiply by 4.2 (from a teardown of 500 viral hits on Douyin and Kuaishou). So the vertical short-drama episode has been compressed into a precise beat map — it’s not a creative suggestion, it’s the signal cluster the platform algorithm uses to recognize “high-potential content”:
- 0–3s: the hard hook. A high-conflict line or an aberrant image, zero setup. “Your father’s car crash — he planned it.” Drop the bomb in sentence one. Five repeatedly validated hook templates: conflict (open mid-argument), mystery (“This woman died three times… you will never guess the third”), contrast (“bullied by the whole family one second, reveals her identity the next”), extreme (“a divine reversal in the last 10 seconds”), resonance (“have you ever been betrayed by someone closest to you?”).
- 4–10s: identity/relationship flip — 78% of hits complete the double disclosure of “relationship + core conflict” within the first 8 seconds.
- 11–15s: plant the mystery. 16–30s: the obstacle. 31–45s: emotional confrontation. 46–60s: the turning point. Throughout, a small hook must land every 15–20 seconds — the minimum stimulus density against wandering thumbs.
- Final 3–10s: cut at the highest point. Follows and subscriptions are earned right here.
The series level has structure too: a small climax every 3–5 episodes, a big reversal every 10, a hook at every ending. Two iron rules, written on the diagram: every reversal must be planted earlier — no deus ex machina (a savior descending from nowhere or a sudden power-up is the fastest way to get executed in the comments); ≤2 scenes per episode, ≤3 per series — scenes are your render budget, a rule that constrains the script and the cost sheet simultaneously.
Topic and persona: decided before you enter the pool
Structure is the skeleton; topic is the admission ticket. Platform libraries concentrate their hits in a few “emotional-need coordinates”: workplace face-slapping, secret heiresses, rebirth and redemption, underdog revenge. These aren’t genres — they’re algorithm-recognizable emotional contracts: viewers know what feeling they’re buying before they tap. The beginner’s most common mistake is writing “the story I want to tell”; the correct topic question is “which emotional coordinate can I offer a new variant of?”
The persona bar is three disclosures in the first three seconds: identity + flaw + desire. “A medical student whose engagement was called off (identity), hands shake but memory is freakish (flaw), wants her lab back (desire)” — that’s the key signal by which the algorithm reads character distinctiveness, and all the evidence a viewer uses to decide whether to follow. Villains have a formula too: extreme misdeeds +阶段性 victories (to open an anxiety gap) — the audience’s hunger for “the villain’s comeuppance” is next episode’s completion rate.
The LLM workflow: cascade generation with two human gates
The human-machine split in the script layer has converged across the industry to a stable ratio: AI carries ~70% of the structured labor; humans make the 30% of creative calibration. Drawn as a workflow, it’s a cascade pipeline with two human gates:
- One-line premise → series outline: give the LLM the genre, emotional coordinate, and episode count (8–16); generate the full-series outline.
- Gate 1 (human): cut weak episodes, reposition climaxes. Write the first 3–5 episode outlines by hand before asking the model to expand — taste is trained at this gate, not downloaded.
- Outline → episode beats → scene scripts: expand episode by episode, 8–15 scenes each.
- Gate 2 (human): verify foreshadowing payoff, cross-scene logic, term accuracy — an LLM writes the first two lines of dialogue brilliantly and forgets episode 3’s foreshadowing by episode 12.
- QA loop: have a second LLM score the script (coherence, character drift, pacing); low scores loop back for regeneration and never move forward sick.
The storyboard table: a script written for machines
A traditional script is written for humans to read; the storyboard table of an AI pipeline is written for machines to execute — this is the essential difference between an AI comic-drama script and a live-action one. Its minimal unit is one structured row, managed industry-wide as JSON or a spreadsheet (Excel/Feishu):
{
"scene_id": 7,
"shot_size": "close-up",
"camera": "slow push-in",
"location": "hospital corridor, night, flickering light",
"characters": ["Lin (ref: char_sheet_v3)"],
"action": "Lin grips the diagnosis, knuckles white",
"dialogue": "Save him. Whatever it costs.",
"emotion": "suppressed panic",
"duration": 3,
"style_anchor": "guofeng-ink, muted palette, film grain",
"av_sync": "heart monitor beep stops exactly on the line"
}The fields come in two groups. Classic fields: shot number, shot size (wide/full/mid/close/close-up), camera move (push/pull/pan/track), action, dialogue, emotion, duration (2–4 seconds per shot, ~20 shots per minute). AI-only fields: reference image ID (which character sheet this shot uses), style anchor (the same style prefix bound to the head of every prompt — never switch models or weights mid-series), audio-visual sync hints, and negative prompts for anatomy-prone zones.
Three rules of execution: one narrative unit per frame (split information-dense scenes into consecutive frames; never cram); master prompt + variable slots (swap only action/expression/shot size, reuse everything else character-for-character — mechanical is what makes it consistent); the quality bar is “downstream asks no follow-up questions” — if the image model has to guess, the row isn’t finished. Forcing the LLM to emit fixed JSON pays an engineering dividend too: downstream parsing, batch generation, and automatic validation all become possible — that’s the watershed between “making one episode” and “making a hundred.”
Action items, then Part 4
- Beat-mapping practice: take episode one of three AI comic dramas that broke 100M plays, and mark their nine beat points with a stopwatch. You’ll find the formula holds but the parameters differ — note the differences; that’s where each studio’s real craft lives.
- Run the cascade: use this part’s workflow to generate an 8-episode outline (any genre), edit it by hand, then expand episode 1 into a JSON scene script. The goal isn’t good — it’s walking through Gate 1 and Gate 2.
- Build the storyboard template: create a sheet in Excel or Feishu with all classic + AI-only columns, and fill it with episode 1 from step 2. This table will accompany your entire serialization.
Part 4 enters visual production — the technically hardest stage of the whole pipeline: character consistency. How to write a Character Bible, each model’s reference-lock interface, whether LoRA fine-tuning is worth it, and reroll budgeting plus salvage editing under the 5–10% failure rate.