Making an AI Short Drama Solo, Part 6: Claude Code as My Production Assistant

Behind the scenesOct 18, 2026 · 6 min read

One person, one studio

"Solo" in this series title is only half true. There is one human. But behind every episode there is a team, and the team is Claude Code. Over the past months it went from "the thing that helps me write scripts" to the assistant that runs most of the production while I make the creative calls.

This last post is about how that works: how the work is split up, how rules accumulate, and where I still have to step in.

The producer and the crew

The main Claude Code session plays the producer. It plans the episode, schedules each stage, hands out work, checks each stage's result before the next one starts, and reports to me. It deliberately does not draw a frame or write a line of dialogue itself. Its job is to keep the whole thing moving and keep quality honest.

The actual work goes to specialist subagents, modeled on the departments of a real animation studio:

• Writer and a hook doctor who only works on the first few seconds;
• Director, who turns the script into a storyboard and shot list;
• Art director and a set and character builder for looks, sets and props;
• Animator, lighting and compositor for the picture;
• Editor and sound for the cut, subtitles and audio;
• Researcher for testing new techniques, QC for checking, and a cover designer.

Two rules keep this from turning into chaos. First, subagents never dispatch other subagents; everything flows through the producer, so there is always one place that knows the state of the episode. Second, nobody sits in a loop polling for results. When a stage depends on another, the producer waits for the completion notice and only then hands out the next task. Generation jobs go into one queue, because one shared machine can only run one heavy job at a time.

Skills and the rulebook

Two kinds of written knowledge sit behind the team.

Skills are playbooks that load only when needed: a technical handbook for the 3D widescreen style, a publishing routine, a guide for reviewing a finished cut. A subagent working on composited first frames reads the handbook section on compositing; the one publishing reads the publishing routine. Nobody has to carry everything in their head at once.

Then there is a project instructions file that Claude Code reads at the start of every session. That is where the hard rules live, and almost every rule in it is a scar from a real mistake. A few examples:

1. Write every constraint as a positive statement. For weeks, the image step's "avoid" list never reached the image model at all, because two steps of the pipeline used slightly different names for the same setting. That explained a long history of mysterious extra people in shots. Even after fixing the mismatch, it turned out the fast generation settings give the avoid-list essentially zero weight. So the rule became: describe what you want, never what you don't. A negative word in a prompt is treated as a bug.
2. Rebuild the contact sheet after any image change, even if only one image changed. Problems between shots only show up side by side.
3. Verify the result itself. "The click didn't throw an error" is not proof that something was published or saved. Check the actual file, or the platform's own status page.
4. Never delete work that isn't committed. Look at what is saved before calling anything "the old version."
5. On a shared machine, never kill a process you don't recognize. If there isn't enough room, wait.

The list only grows. That's the point: a mistake written down is a mistake the next session doesn't make.

Rules for working fast

At one point I did a retrospective on an episode that took about seven and a half hours. The first full pass took roughly one hour. Everything else was rework. That led to a set of efficiency rules:

• Lock requirements before starting. Script, cast and locations are fixed up front, and I see the script before any production begins.
• Cap the complexity. One location per episode where possible, a small number of shots, and very few shots with several people in frame. The joke stays; only the hard-to-shoot shots go.
• Budget each stage. Every stage gets a time budget. If a stage runs 1.5 times over, work stops and I get a report on why.
• Three strikes, change the approach. If the same method fails three times, rerolling it a fourth time is not allowed. Try a different idea.
• Three failed QC rounds means ask the human. Otherwise "fix one thing, find another" can loop forever.

One more: if I come up with a new standard in the middle of an episode, the producer first tells me how much rework it would cost, and I decide whether it applies to this episode or starts with the next.

Whoever makes it doesn't grade it

The most important lesson about working with AI agents: the agent that produced something should not be the one that approves it. Once, a seating checklist for a scene passed ten out of ten, while the furniture in the shots was clearly wrong. The agent that generated the shots had checked its own work, and the checklist had no column for "objects that shouldn't be there." Now checking is a separate role with its own checklist, and the checklist includes the things that are easy to miss: extra objects, which way people face, whether a background matches the master shot.

Memory, publishing and the paperwork

Claude Code also keeps a memory of decisions and preferences that persists across sessions and across the machines I work on, so a new session doesn't start from zero. It drives the browser to publish episodes, using my own logins, fills in titles, tags and the AI-generated label, and then checks the platform to confirm the post actually exists. Afterwards it writes a short record of what was published, archives the project and commits it. The boring parts of running a series are exactly where an assistant shines.

What still needs me

Taste, mostly. Deciding which story is actually funny. Picking the one joke an episode serves. Watching the final cut from start to finish and feeling whether the timing lands. Approving the cover. Claude Code can get an episode to "technically correct" remarkably well; whether it's good is still my call.

Wrapping up the series

Over six posts I've walked through the whole pipeline: why I started and the five steps of an episode, script and storyboard, voice and lip sync, keeping characters consistent, editing, checks and publishing, and finally the assistant that ties it together. If there's one thread through all of it: AI generation is one step, and the careful, written-down work around it is what makes a series possible for one person.

Thanks for reading along. The best way to judge all this is to watch the result.