Inside an AI Short Film Workflow: Script to Screen with OpenArt and Claude
How an AI short film gets made, from Gemini scripting to OpenArt generation to Claude rotoscoping, based on a real production pipeline.
What does a real AI short film production pipeline actually look like?
A working AI filmmaking pipeline looks less like typing one prompt into a video model and more like a full production stack: a writer’s room pass using a language model, a shared “memory” system that tracks characters and prompt style, a generation platform for images and video, and a post-production layer where tools like After Effects and Claude clean up what the generators got wrong. The Planet Hell episode 1 production, built on OpenArt with Gemini and Claude handling different stages, is a concrete example of how that stack fits together in practice.
TL;DR
- Script organization, not script generation, was the real job for the language model. Gemini was used to take two years of scattered documents, ideas, and notes and organize them into a coherent 10-episode roadmap, rather than writing dialogue from scratch.
- A persistent “second brain” system tracked characters, locations, prior references, and preferred prompt style so that every new generation stayed consistent with the established look of the series.
- OpenArt served as the generation hub, offering access to image and video models, an MCP (model context protocol) integration for driving generations from tools like Claude Code or Codex, and a manual interface for quick one-off edits.
- Not every new technique paid off. Attempts to pre-visualize scenes in 3D tools like CozyClay and Three.js ended up eating more time than they saved, because the AI tools were given too much control over scene setup.
- Post-production still leans on traditional tools. Rotoscoping an unwanted rifle out of a shot was handled by Claude, while a separate continuity fix (an oversized bullet pen) was solved the old-fashioned way, by editing the reference image before regenerating.
- Volume and iteration matter more than perfection. Out of roughly 79 generated clips, 59 made the final cut, and many usable shots were cropped out of longer generations rather than built as standalone clips.
- Reference material from sources like ShotDeck (film stills with metadata on color palette, film stock, aspect ratio, and camera) fed directly into the project’s prompt library to keep the visual style grounded in real cinematography.
Auditable. Scalable.
How does scripting work when AI is involved?
The scripting stage wasn’t a case of asking a chatbot to write a screenplay. The Planet Hell concept had been accumulating documents, character notes, and story ideas for roughly two years, much of it generated or refined with the help of Claude Opus. By the time production on episode 1 started, that pile of material needed an editor more than a writer.
Gemini took on that editorial role, sorting through the backlog and shaping it into a 10-episode roadmap. The approach mirrors how a show bible gets built in traditional TV writing: not every episode needs a full script up front, just a clear throughline and enough structure that each episode can function as its own self-contained story, similar to a comic book issue. That comic-book framing is intentional. Planet Hell draws visual and tonal influence from Warhammer and Metal Hurlant (known in the US as Heavy Metal), and treating each episode as a standalone chapter with a connecting narrative thread fits that source material better than a strict serialized structure.
How do you keep characters and visuals consistent across episodes?
Consistency is one of the harder problems in AI-driven filmmaking, especially across a multi-episode series where characters, locations, and tone need to hold steady. The solution here was a custom-built tracking system, referred to as a “second brain,” that stores character references, location assets, prior generations, and preferred prompt phrasing.
That system plugged directly into the generation workflow through OpenArt’s MCP (model context protocol) integration, which lets tools like Claude Code, Codex, or similar AI coding assistants drive generations on the platform directly. Because the second brain already contains the script, the visual references, and the established prompt style, each new generation request arrives with full context rather than starting from a blank slate.
That said, recasting and redesign still happened by hand. One returning character needed a visual overhaul after the primary image model struggled to render him consistently; running the original character image back through Nano Banana (Google’s image model) ended up fixing the inconsistency, for reasons that weren’t fully clear even to the production. Another character was recast entirely, with an existing channel character (Flamethrower Girl) stepping into a new role after an earlier version of the character wasn’t working during production. A wardrobe change inside OpenArt was enough to get her ready for the part.
Which production techniques worked, and which didn’t?
Not every experiment made it into the final film. Early tests of the episode’s opening scenes were built out using 3D pre-visualization tools, CozyClay and Three.js, with the idea of blocking out camera angles and sets before generating final shots. Both approaches ran into the same issue: letting AI coding tools like Claude and Codex take too much control over scene construction produced results that weren’t usable, and more time ended up going into fixing the pre-vis than into actually making the episode. That workflow was ultimately dropped in favor of more direct generation.
- 1Secure
- 2Regulation-compliant
- 3Auditable
- 4Scalable
Two other tools were tested but not heavily used in this episode, with plans to lean on them more in future installments. World Labs’ Atlas tool, a 3D Gaussian-splat style system, allows building a 3D set and then rendering specific angles out of it, which is useful for generating backplates and location references. Genie 4 was used in a similar capacity, helping find camera angles for reference shots of specific locations like a bone valley set.
A lower-tech but effective addition was ShotDeck, a reference library of film stills that includes metadata like color palette, film stock, aspect ratio, and camera used for each shot. Building a lookbook from ShotDeck references and feeding it into the second-brain system gave the generation pipeline concrete cinematographic anchors instead of vague style descriptions.
What does the actual generation and editing process look like?
Once references, characters, and locations were locked, production moved into straightforward generation and reroll cycles on OpenArt, primarily using image model SeaDream 2.5. Generations on that model reportedly come back in 10-bit color, which matters for anyone planning to do color correction later, since it preserves more tonal information to work with in grading.
The MCP-driven workflow handled most generations, but manual edits on the OpenArt platform itself were sometimes faster for small fixes. One example: a shot where a character was awkwardly holding what looked like an oversized bullet instead of a pen. Rather than burn tokens re-prompting through the full pipeline, the fix was a simple reference-to-video edit, uploading the clip and instructing the model to change the object in the character’s hand to a black pen.
For viewers wondering about scale, the project generated around 79 clips total, with 59 landing in the final cut. Many of the clips that didn’t survive were false starts from testing new techniques. Several usable shots weren’t generated at their final length either; some action beats were cropped out of longer, full-length generations rather than produced as discrete clips, a common efficiency trick for squeezing more usable footage out of each generation run.
How much of the post-production still relies on traditional tools?
A fair amount. Two persistent continuity errors didn’t get fixed by regenerating footage. In one shot, the generation model added a rifle slung over a character’s shoulder that wasn’t supposed to be there. Rather than risk a re-roll that might introduce new problems, the fix went to rotoscoping, specifically handled using Claude, which removed the unwanted object from the shot with only a minor visible artifact in the final frame. The oversized bullet-pen problem mentioned earlier used a similar philosophy: solving it outside the generation model itself rather than hoping a reroll would fix it.
The takeaway for anyone building a similar pipeline: AI generation handles the heavy lifting of creating footage, but traditional compositing and editing tools, along with AI coding assistants repurposed for tasks like rotoscoping, still do a lot of the fine cleanup work that generation models can’t reliably self-correct.
Frequently Asked Questions
What AI tools were used to make this short film?
The production combined Gemini for script organization, Claude (including Claude Opus and Claude Code) for story development and post-production tasks like rotoscoping, OpenArt for image and video generation with an MCP integration, and supplementary tools including Nano Banana for image consistency fixes and ShotDeck for cinematographic reference material.
What is MCP (model context protocol) in an AI filmmaking context?
MCP is a protocol that lets AI coding assistants like Claude Code or Codex directly drive generations on a platform like OpenArt. Instead of manually uploading prompts and references each time, the coding assistant can pull from a stored project “brain” containing the script, character references, and prompt style, and issue generation requests automatically.
Why did the 3D pre-visualization tools get dropped?
Tools like CozyClay and Three.js were tested for blocking out scenes before final generation, but letting the AI tools control too much of the scene setup produced unusable results. The time spent fixing pre-vis outweighed the benefit, so the production reverted to generating shots more directly.
How many generations does it typically take to get a usable shot?
Using the SeaDream 2.5 image model, the production generally found a usable result within about two generation attempts, though results sometimes needed to be cropped or recombined rather than used as a single complete clip.
Why use traditional tools like After Effects or rotoscoping instead of just regenerating the shot?
Regenerating a shot risks introducing new errors or losing an otherwise good performance or composition. For small, isolated problems, like an object that shouldn’t be in a character’s hand, it’s often faster and safer to fix the issue directly in post-production than to gamble on a fresh generation.
