What is really difficult about AI short dramas may never be "asking AI to write a story."
The difficulty is: When the story turns into dozens of short dramas,Can the characters remain consistent, can the plot continue to advance, can scenes and props be reused, can the script fall into the length of time, and can the split shots directly enter the generation process。
this is also shuohao-skills GitHub repository Places worth paying attention to.
Instead of simply packaging AI as a "writing assistant", it attempts to break down the entire process of adapting a novel into an AI short drama into multiple skills that can be executed, verified and connected by Agents: from outline, characters, art, to script, and split the camera, and further provide a lens vocabulary card library. The current warehouse has formed a relatively complete production pipeline. (GitHub)
It does not solve the problem of "production", but "production".
The idea behind many AI creative tools is:
Give me a story and I'll help you generate content.
Shuohao-skills is closer:
Give me a story and I'll break it down into a set of structured assets that can continue to be produced.
These two ideas may seem just a little closer, but in fact they are completely different.
Traditional AI conversational creation is often generated one by one:
Novel → Script → Character → Scene → Split
The problem is that at each step, it is possible to re-understand the previous content.
So it's easy to appear:
- The characters in the first episode look different from the tenth episode;
- The same scene appears in completely different visual settings in different episodes;
- There are too many supporting roles in the novel, and the production cost is out of control after all of them are moved into short dramas;
- The script was wonderfully written, but the actual duration couldn't hold it;
- The division made a new plot decision in order to "look good", resulting in a disconnect from the script.
The core idea of shuohao-skills is to make these problems as much as possibleStructural layer and rule layerIs solved rather than waiting until the video is finally generated to discover it.
The warehouse currently has a clear process of breaking down into novel-outline、novel-characters、novel-art、novel-script、novel-storyboard Five main links, and provide additional shot-recipes Lens vocabulary library. (GitHub)
This is actually very close to the "pre-development-asset production-script-lens separation" process in traditional film and television production, except that the executor has changed from part of the human production team to an AI Agent.
2. The first step is not to write the script, but to "adapt the outline" first
The starting point of the entire system is novel-outline。
It is responsible for transforming a novel into the structures needed for short drama production, including:
- adaptation explanation;
- Character list;
- Cool point/beat chart;
- Diversity outline;
- asset list;
- Production information such as scenes and narrative props.
More importantly, it does not rely entirely on the model to "consciously maintain quality."
The warehouse has designed a large number of deterministic quality checks, such as the upper limit of the number of characters, beat intervals, first episode hooks, the location of the main beat, diversity required fields, scene reuse, reference integrity, etc. (GitHub)
Here is a concept that is very worth learning from:
Don't let the model judge whether I write correctly or not, but let the program judge as much as possible.
For example, a model could say:
"This edition has a reasonable number of characters."
However, the program can directly check:
Does the protagonist exceed the required number?
Does the branch character exceed the upper limit?
Are there characters that have been defined but never used?
Are there scenes quoted but not defined?
How many episodes in a row have no important beats?
The former belongs to "language judgment", and the latter belongs to "engineering verification".
This is a very important difference for AI workflows.
3. The character is not a description, but a production asset
The second Skill is novel-characters。
Its goal is not to simply summarize the character's personality, but to make the character useful in subsequent generation processes.role assets。
A character can get:
- Character identity and basic information;
- appearance;
- character;
- motivation;
- Character arc;
- Relationship between characters;
- Image generation prompt words;
- Negative prompt words;
- Style label;
- Timbre design prompts;
- Role setting chart.
It even includes a role relationship diagram and a role model table for visual consistency. (GitHub)
This means that the "role" has changed from a name in the text to a data object that can run through subsequent processes.
For example:
Lin Wan
No longer just:
The actress is smart and strong.
It can be further transformed into:
Lin Wan → Character ID → Appearance Setting → Clothing → Body → Expression → Voice → Character Relationship → Number of Appears → Generation of Reference Pictures
Once this is done, the art, script and film division behind will have a common "anchor point".
This is especially important for AI videos.
Because one of the biggest pain points of AI video isconsistency。
What is truly available for production systems should not be asked again every time:
"What does this character look like?"
Instead, the system should know:
"This is role ID C-003. Please generate it according to the determined role assets."
4. Scenes and props also need to be capitalized
novel-art Solving another problem that is easily overlooked:
Scenes are not background pictures, but production assets.
It handles scenes and narrative props and emphasizes:
- Consistency anchor point;
- Changes in light;
- Changes in status;
- Scale reference;
- No one, no hands, and white background settings prompt words.
At the same time, it can read asset lists generated by previous outlines, reducing the need to reorganize requirements. (GitHub)
Behind this is actually a basic idea in the film and television industry:
The same studio cannot become five completely different places just because you take different shots.
AI generation is more likely to make this mistake.
Without unified scenario assets, the model may be replayed every time it is generated:
The first time was a modern office, the second time became a luxury hotel, and the third time was like a conference room.
Each picture may be very good, but when placed in the same short drama, the audience will immediately find that the world view is unstable.
Therefore, one of the core issues of AI short dramas is not "whether they are produced beautifully enough", but:
Can the generated results belong to the same world?
5. The script begins to enter "engineering"
to novel-script, things move further from creative production to the execution stage.
This Skill does not just require the model to "write each episode", but breaks the script into a stream of times and beats, and determines the duration.
One of the most interesting designs is to calculate the diversity duration according to the speed of speech, and also check the cold opening and hook redemption of the previous few beats. The script can also be aggregated according to the role, with tone prompts to further connect with TTS. (GitHub)
This solves a very real problem:
AI is very good at writing things that "look long", but not necessarily good at writing things that "just can be filmed".
For example, requirements:
This episode is 90 seconds.
The model may give you a wonderful 2500-word plot.
From a literary perspective, it may not be a problem.
From a production perspective, it has failed.
Therefore, once the deterministic calculation of "speed → line length → total length" is added, the script changes from a literary text to a production document.
This is an important step for AI creation tools to move from "Demo" to "Production".
6. The key to splitting the scene: Don't let it reinvent the plot
The last major link is novel-storyboard。
The design here particularly reflects engineering thinking.
It breaks the content into:
Section → mirror split → mirror split diagram
The duration of a single generated segment, shot length, and tangent points between the main image and sub-image are restricted, and the shot prompt words are reconciled with specific time points. (GitHub)
A more important sentence is the warehouse's definition of the entire pipeline:
Adapt the convergent structure of the outline, and iterate simultaneously among the script, scenes, and characters, and only output and no new decisions are made in each camera. (GitHub)
This is actually one of the most important designs of the entire system.
The problem with many AI workflows is that every Agent has the power to "re-create".
So:
The novel Agent is changed once;
Change the outline Agent once;
The script Agent was changed again;
Change the lens splitter Agent again.
What I finally got was not the original story.
Zuohao-skills is trying to create aone-way constraint relationship：
Whatever the upstream decides, the downstream is responsible for realizing it.
This is very similar to the interfaces, data structures, and compilation pipelines in software engineering.
7. What really deserves attention is the "quality door"
If you just look at the list of functions, this warehouse might just be:
"A set of Tips to help AI make short dramas."
But if you look deeper into its implementation, you will find that the author is more concerned about another issue:
How to make AI workflows verifiable.
For example, different skills have set clear quality doors:
novel-outlineThere are multiple structural inspections;novel-artCheck the integrity of art assets;novel-scriptCheck the structure and duration of the script;novel-storyboardThen further check the division rhythm, cut point and prompt words. (GitHub)
The warehouse even requires every Skill to be equipped with scripts/selftest.mjs, and self-testing cannot call the model and consume no quota, which is used to override deterministic logic. (GitHub)
This may seem like a "programmer", but it may actually be the key to the commercialization of AI Agents.
Because the model itself is unstable.
Today it is understood correctly, and tomorrow it may be expressed differently.
If the correctness of the entire system relies entirely on the model, then every time the model is upgraded, the workflow may quietly degrade.
But if you give the code the rules you can determine:
The model is responsible for creation and the code is responsible for acceptance.
The system will be much more stable.
8. What it really shows is a new "AI production team"
From this perspective, shuohao-skills is not just a collection of several skills.
It's more like a virtual production team:
Adaptation planningResponsible for the structure of the novel → short drama;
character designerResponsible for role assets;
art directorResponsible for scenes and props;
screenwriterResponsible for the script;
mirror divisionResponsible for the camera;
Lens vocabularyProvide standardized visual language.
Claude Code / Codex serves as an Agent execution environment that connects these positions.
That's why it chose Skill instead of a huge Prompt.
One big Prompt question is:
Everything is mixed up.
Skills 'advantages are:
Each stage has clear inputs, outputs and responsibilities.
This brings the entire process closer to modular design in software engineering.
9. Open source methods are also worth learning from
From the perspective of engineering implementation, the warehouse adopts a relatively clear self-contained structure.
Every Skill has its own SKILL.md, README, scripts, references and examples, and requires a separate self-test script. The installation script can automatically detect Claude Code or Codex and install Skills through soft links, so there is no need to repeat the installation after updating the warehouse. (GitHub)
The project currently uses the Apache 2.0 License. (GitHub)
This means that it is not a collection of Tips that is suitable only for the author's own computer, but an attempt to establish an Agent Skill engineering specification that can be replicated, tested, and extended.
For people who want to build their own AI Agent workflows, this is even more worth studying than the short drama itself.
10. The most worth learning is not a certain Prompt, but this methodology
If you abstract the shuohao-skills to a level, you will get a valuable AI Agent workflow model:
1. Break complex tasks into phases
Don't let an Agent go from beginning to end.
2. Each stage produces structured assets
Don't just output Markdown.
Characters should have character data, scenes should have scene data, and scripts should have structured information.
3. Establish unique identities for assets
Characters, scenes, props, and shots should all be able to be cited in subsequent stages.
4. Hand over deterministic rules to code
Issues such as quantity, ID, reference relationship, duration, and field integrity should not waste model capabilities.
5. Let there be clear boundaries upstream and downstream
The upstream makes decisions and the downstream is responsible for implementation.
6. Protect workflows with testing
Models can change, but deterministic rules should continue to be verifiable.
This method is not only applicable to AI short dramas.
It also applies to:
- Game plot production;
- Animation production;
- Creative advertising production;
- Adapted from a novel;
- AI comics;
- Virtual human content production;
- Product promotion video;
- Corporate training video.
Conclusion: AI content production is moving from "chat" to "assembly line"
In the past, when we discussed AI creation, we often discussed:
Which model is best written?
Which model draws the best?
Which video model works best?
But when AI really enters large-scale production, the problem will gradually become:
Can these models be organized?
The value of shuohao-skills is precisely that it does not try to create an "omnipotent super Prompt", but breaks a short drama into multiple executable, verifiable, and reusable production links.
From childhood to outline, from outline to characters and art assets, from script to filming, and then to the final generation pipeline, what it attempts to establish is actually a set of AI-native content industrial process。
This may also be one of the most noteworthy directions for AI Agents in the future:
Models are increasingly like "workers", and what really determines production efficiency is work flow.
When Prompt becomes Skill, when Skill becomes Pipeline, and when Pipeline becomes a testable and reusable production system, AI content creation truly begins to move from "being able to generate" to "being able to produce".