zenstory-ai/drama-skills: Eleven Agent Skills That Take a Short Drama From Idea to Shooting Script

The gap drama-skills fills between a pitch and a render queue

Most AI video tooling starts at the prompt box. The hard part of a short drama sits earlier: deciding which chapters of a novel become which episodes, which characters and props need a locked reference image, which shots must stay visually consistent across a cut, and what the camera and the hands are doing in shot 14. Those decisions are editorial, and they are usually made in a chat window where they evaporate.

This project treats them as files. According to the README, a new project keeps five Markdown documents per episode: 剧本.md, 视觉设定.md, 分镜.md, 图片提示词.md and 视频提示词.md. The audience is screenwriters, comic-drama studios and directors who already drive an agent CLI and are willing to maintain a project as text rather than inside a graphical tool. The README is explicit that the skills came out of a studio pipeline that ran thousands of AI short drama and comic-drama projects since 2025, and that the previous in-house stack of roughly 80,000 lines of front and back end stopped keeping pace. That provenance explains the shape of the thing: it is a distilled production line, not a general-purpose writing assistant.

Eleven skills, one owner per artifact

The pipeline is a chain with optional branches. short-drama-novel-analyze samples a long source and reports whether it is worth adapting in full. short-drama-develop produces a traceable adaptation, a story engine and an episode map, and it can index a multi-episode finished script by its actual structure instead of loading the whole file into context. short-drama-write produces a single episode with a stated goal and causal beats. short-drama-assets extracts characters, locations and props with continuity decisions. From there the chain splits: short-drama-image-prompts writes reference-board prompts, short-drama-storyboard builds the shot list and freezes keyframes, and short-drama-video-prompts translates each shot into a video prompt including start and end state, sound and any pickup notes. short-drama-produce, short-drama-edit and short-drama-review close the loop.

The ownership claim is the interesting part. Each skill is a separate installable unit, so a team that only wants review or only wants prompt writing can link that directory alone. short-drama itself handles initialization, routing and the local dashboard. The README states that the confirmation step is deliberately placed before production: prompts land in files first, and the production skill shows the exact count, content, references, parameters, output and adapter for the current batch, then waits. Provider credentials are kept out of the project, and the project files are not bound to any vendor. That is a real architectural constraint, not a slogan, and it means the repository stays useful even if you swap the generator behind it.

Installing drama-skills in Claude Code or Codex

The README gives two routes. The first is to ask an agent that supports importing a GitHub repository to install the skills from the URL. The second is manual and is the one worth reading, because it shows that each skill directory is linked independently into the agent's skills folder. Python 3.9 or newer is required, and the README notes that the macOS system Python qualifies.

Clone the repository and change into it:

git clone https://github.com/zenstory-ai/drama-skills.git && cd drama-skills

Then link every skill into Claude Code's skills directory. The loop creates one symlink per directory under skills/, so you can later delete a single link to remove a single capability:

mkdir -p "$HOME/.claude/skills"
for skill in skills/*; do
  ln -s "$PWD/$skill" "$HOME/.claude/skills/$(basename "$skill")"
done

Codex uses the same pattern against its own home, honoring CODEX_HOME when it is set:

mkdir -p "${CODEX_HOME:-$HOME/.codex}/skills"
for skill in skills/*; do
  ln -s "$PWD/$skill" "${CODEX_HOME:-$HOME/.codex}/skills/$(basename "$skill")"
done

Invocation differs by host. Claude Code uses a slash prefix such as /short-drama; Codex uses a dollar prefix such as $short-drama. The README says plain natural language also works and that the two forms are interchangeable in its examples. A first real use is initialization: ask the agent to create an urban revenge short-drama project in vertical 9:16, then write episode one. What you should see is a project directory containing the five Markdown files for that episode, not a rendered video.

The dashboard, the export, and what the files look like afterwards

There is a local creation console. The README shows it starting with a single command inside the agent, /short-drama dashboard, and notes macOS, Linux, WSL and native Windows support. It runs detached, the link stays valid for the length of the writing session, --status prints the current link and --stop shuts it down. The screenshot at the top of the README shows project overview, per-episode progress, existing media and script text, which suggests the console reads the same Markdown the agent writes rather than holding state of its own.

When the project is done, the README documents an export through project_tool.py:

project_tool.py export <project> --out <项目外目录>

That copies the five Markdown files per episode plus 制作成果/ into a delivery directory with a manifest and checksums. The choice to export outside the project directory is sensible: it keeps the working tree clean and gives you something hashable to hand to a client. The README does not document a rollback path for an export, and it does not describe what happens if 制作成果/ is missing for some episodes.

Where drama-skills stops: adapters, media and the confirmation gate

The most consequential limitation is the production step. short-drama-produce executes through external adapters, and the README names optional support for Seedance, GPT Image 2, MiniMax H3 video and MiniMax Music. If your generator is not one of those, the skill still writes prompts and still shows you the batch preview, but the execution leg does not exist until someone writes an adapter. The README does not document an adapter interface, so treat that as work you would have to do yourself.

The second limitation is that the pipeline produces text and prompts, not finished media. The 24-second demo clip in the README is described as the tail end of a full run: a 20-chapter source, novel analysis, script, visual settings, image prompts, a 21-shot storyboard, video prompts, then eight generated segments for one scene cut together. That is a demonstration of the workflow, and the README is clear that the actual generation happened outside the skills. Teams expecting the tool to render are looking at the wrong layer.

The confirmation gate is a trade-off worth naming. Because production waits for an explicit confirmation of count, content, references, parameters and output, an unattended batch run is not the intended mode. If your workflow is fire-and-forget overnight rendering, this design will feel like friction. It is friction the maintainers chose on purpose, and the README says so.

How this differs from a prompt library or a hosted storyboard tool

A prompt library gives you text to paste. A hosted storyboard tool gives you a UI and keeps your project in its database. drama-skills sits between them: the unit of work is a directory of Markdown files owned by your repository, and the intelligence is a set of agent skills that read and write those files. The practical difference shows up in review. A script reviewer can open 剧本.md in a pull request and comment on a beat. A continuity problem across shots is visible in 分镜.md as a frozen keyframe reference rather than as a setting buried in a web form.

The cost of that choice is the absence of a visual timeline editor. You get a dashboard for overview, but the README does not describe drag-and-drop reordering of shots or a frame-accurate trimmer. Editing decisions go through short-drama-edit, which the README says writes a cut list with in and out points, shot order, dialogue completeness, subtitles and loudness, then renders the finished piece. If you want to nudge a cut with a mouse, this is not that tool.

Maintenance, licensing and what a fork inherits

The repository is not archived, and the last push was on 2026-09-16, one day before this writing. Releases are frequent: v0.7.1 on 2026-09-11, v0.7.0 on 2026-09-10 and v0.6.6 on 2026-09-09, whose release title notes that dialogue capacity got a number and that several model assertions were overturned by measurement. That last detail is the useful signal for upgrade cost. The project is willing to publish corrections to its own assumptions, which means the skills encode model-specific behaviour that can change under you when a video model updates.

The licence is MIT, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are included. That is a permissive licence, and it does not carry the patent grant language some other permissive licences do. Whether that matters for your organisation is a question for your own counsel, not for this article. The repository also carries CONTRIBUTING.md, DESIGN.md and a tests/ directory, so a fork inherits a documented design rationale and a test suite rather than a pile of prompts.

Editorial conclusion

Adopt it if you already work in Claude Code or Codex and want short-drama pre-production as plain Markdown files you can diff, hand off and export. Skip it if you need a hosted storyboard UI, or if your pipeline depends on a generator that is not one of the adapters the README names. Before committing, run the manual clone and symlink install, initialize one project, and check whether the five Markdown files per episode match how your team already reviews scripts. Then open skills/short-drama-produce and confirm which adapter you would actually wire up, because that file, not the marketing page, decides whether the production step runs at all.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. zenstory-ai/drama-skills on GitHub