How to build an AI video studio in Claude Code:

I turned Claude Code into a working film studio and i'm going to hand you the complete system: the skills, the prompts, the loops, and the six-stage pipeline that ties them together

each stage leans on a different part of the harness: skills for the models, subagents for the volume, bash for the cut, and engineered loops for everything that repeats

today, i'm teaching you to produce short films like this one using Higgsfield Supercomputer, Claude Code and Seedance 2.0:

1:29

here's what's inside this article:

the engine: every model on one platform, and the two ways in

stage 1: extract a style contract from real cinema

stage 2: frames at volume, characters and locations locked

stage 3: the agent writes every shot prompt

stage 4: motion, and the grammar that kills frozen shots

stage 5: the subagent fleet running generations in parallel

stage 6: score, montage from a text file, 4K master

if you want the full production kit behind this piece, the prompt boards, the style bible and the ready-to-run agent briefs, that's what the real time AI ops community at weeklyaiops.com is for

why the loop is the product

a professional shot used to be a bet, because every attempt cost real money and real days, so nobody experimented and everything looked the same

ai video collapsed that loop: describe a shot, generate it in minutes, watch it, change three words, regenerate

the cost of trying dropped so far that trying everything became the strategy

but a collapsed loop only pays if something runs it for you, because fifty cycles per shot across twenty shots is a thousand decisions, and a human clicking a generate button a thousand times is a very tired operator, and the work still ships slop

so the system splits the work in two:

you own taste: which frames feel right, which shots survive, what the film wants to be

the agent owns throughput: writing prompts, submitting generations, polling jobs, retrying failures, assembling cuts

the name for this skill on the timeline right now is loop engineering, and we're using it for this setup

an agent loop is a job the agent repeats until a condition is met, and this production is loops nested three deep:

the shot loop: generate, watch, change one variable, regenerate, until the shot earns its place

the fleet loop: walk the shot list, submit wherever a free slot opens, collect the winners

the session loop: log every generation, so the next production starts from everything this one learned

you engineer the loops once and the agent runs them all night, which is the difference between using a model and running a studio

every "agent-made film" you'll see, this one included, splits exactly this way: the agent plans, prompts, and retries, a human picks and directs

nobody has shown a watchable film made by an agent start to finish with no human involved, and the system below doesn't pretend to be one

cheap generation didn't make good video easy... it moved the entire job into taste

everything that follows is built around that sentence

the engine: one platform, two doors

this production touches image models, video models, music generation and upscaling, the pass that raises finished footage to 4K, which normally means five subscriptions, five tabs, five render queues, and five places to lose a file

higgsfield puts pretty much every model on one surface, behind a single login and credit pool, and the whole platform is built for agentic usage, which is exactly what this system needs, because an agent can't drive five separate logins

there are two doors into it:

supercomputer is the easy door: an agent that runs on the platform itself, plans your production, picks the best model for each task on its own, and cuts your scenes together, you describe what you want and it handles the routing, and it runs on skills the same way claude code does, so if you don't live in a terminal, start here

the CLI is the control door: it makes every model addressable from claude code or any harness you already run, which means your own agent holds the whole pipeline, what gets generated, when, with which model, in what order

and if you're new to ai video and have no idea how many iterations a good shot takes, supercomputer costs nothing to run: planning, testing and reworking spend zero credits, you only pay when you render the final video, so the free plan covers all the exploring

the CLI setup is three commands:

npm install -g @higgsfield/cli

higgsfield auth login

npx skills add higgsfield-ai/skills

the skills bundle teaches claude code when to reach for which model, how to keep characters consistent, and how to submit and poll jobs, so from this point your terminal is the studio

one command submits any model and waits for the result:

higgsfield generate create seedance_2_0 --prompt "slow dolly in as the sail tears loose" --start-image ./frame.png --duration 5 --resolution 1080p --wait

swap the model name and that same shape covers the whole production: gpt_image_2 for frames, nano_banana_2 for character edits, sonilo_music with --duration for the score, the upscaler for the 4K master

the flags that carry the pipeline:

--start-image sets the first frame for image-to-video, and a local file path uploads itself

--end-image locks the last frame, which is how chain shots connect

--wait blocks until the clip is done and prints the result url, and --json makes the output readable for an agent

higgsfield model list --json shows every model you can call, and higgsfield model get seedance_2_0 --json shows the exact settings one accepts

and running it all from claude code takes a text file, not an integration:

write the routing rules into your project's CLAUDE.md: which model per job type, the resolution ladder, the concurrency cap

the agent reads the rules once and every subagent it spawns inherits them

generations submit through bash, get checked with higgsfield generate get, and log to one file per run

everything below runs through that door

stage 1: extract taste from cinema, don't invent it

the fastest way to bring taste into ai video is to stop describing moods from imagination and start extracting them from shots that already worked on millions of people

your sources, bookmark these:

frameset.app for film and video stills, searchable by lens, lighting, movement

shotdeck.com and fancaps.net for frame-by-frame stills from almost any film

savee.com and cosmos.so for imagery and mood boards

eyecannndy.com for transitions and camera technique

pick five to ten shots that carry the exact feeling you want

then run the extraction move: feed each shot to a vision model like Gemini 3.1 Pro and have it name the shot's parameters in extreme detail... lens feel, lighting direction and source, palette, grain, contrast, blocking, atmosphere, era markers

the output becomes what i call a style contract: one locked paragraph of visual language that gets pasted into every image and video prompt for the project, word for word, so every generation pulls toward the same film

because you're no longer hoping a model understands "cinematic"

you're handing it the measured ingredients of a shot that already moved people

"cinematic" alone is the single most wasted word in ai video, the models have seen ten million images tagged with it, so it means nothing... reinforcement pairs are what land: "motivated warm lighting, 35mm grain, shallow depth of field, lifted blacks"

that one paragraph decides how everything downstream looks

stage 2: frames before motion, always

never generate video from imagination

generate still frames until the frame is right, then animate the winner, because a frame costs a fraction of a clip and takes seconds instead of minutes, so all your exploration happens at the cheap layer

the frame pass looks like this:

run the same shot brief through several diffusion models side by side with your style contract attached, and on one surface this is trivial: same prompt, five models, compare

try a LOT of frames per beat, different compositions, different moments inside the scene, different weather

refine the winners: Nano Banana for surgical edits and consistency passes, Soul Cinema for photographic character looks, GPT-Images-2 for dense art direction

lock what must stay identical: a reference sheet per character (front, three-quarter, profile, cropped separately, because grids confuse the video models into reading panels as different people), a separate sheet per wardrobe or state change, multi-angle sheets per location

this pass is also where supercomputer earns its keep if you'd rather not drive it yourself: it tests the same brief across models on its own, looks at the outputs, and iterates without you monitoring anything

three frame rules that decide more than any tool choice:

objects hold emotion better than faces, because faces drift between generations and objects lock, so when a story beat can land on a torn sail or a broken oar instead of an expression, hand it to the object

one impossible thing in one normal place is the composition that stops a scroll

give the character a cost: a figure walking is footage, a figure limping toward something is a story

the frames are only half the job though, because a beautiful frame that doesn't move is still slop...

0:03

stage 3: the agent writes the shot scripts

every shot needs a prompt, and prompt writing at volume is exactly the work you delegate

i use Fable 5 Medium as the script writer: it takes the beat sheet and the style contract and writes every shot's prompt in one locked template... scene context, references, blocking, camera, lighting, audio, style locks, same order every time

locked, because consistency across shots comes from repeated reference images and repeated language, never from seeds or luck

the prompt rules the scripts follow, each one worth stealing on its own:

one verb per shot: "he turns" generates, "he turns, walks forward, reaches out and speaks" collapses

five small actions land better than one adjective: "blank stare, slow blink, sips coffee, looks up" reads as a person, "he looks confused" reads as a stock photo

subject movement and camera movement always get separate sentences, because one clause carrying both is how you get the shaky nonsense everyone blames on the model

prompts that generate from text alone run 120 to 280 words, prompts that animate a reference image stay under 80, because past that the text starts fighting the image and your character drifts

constraints stay positive: "stable picture, sharp clarity" works, "no blur, no shaking" gets ignored

0:03

stage 4: motion, and the grammar that kills frozen shots

now the clips

each keyframe, the locked still you built in stage 2, goes through Seedance 2.0 image-to-video, which turns that still into a moving clip, as an isolated 3 to 5 second shot, and a minute of film is 12 to 16 of those stitched, which is how every real film works anyway... an editor cuts shots, not takes

shot isolation is also the consistency cheat: identity drift shows up past 30 seconds of continuous scene, and isolated beats never get there

my first two motion passes failed the same way: figures standing frozen while the camera drifted past them, clips that technically moved and visibly did nothing

the fix is a grammar, three parts, every image-to-video prompt:

a named camera move

an in-scene event: something HAPPENS during the five seconds

an explicit "no frozen figures"

same keyframe, two prompts: "slow dolly in, cinematic" gives you a still image that drifts, "slow dolly in as the sail tears loose and the crew scrambles to catch it" gives you a film

two motion techniques worth the whole section:

chain shots: the last frame of shot N becomes the reference frame of shot N+1, so continuity carries forward without a single character sheet being reloaded

time-code the climax inside one generation: [0-4s] wide and static, [4-8s] push-in as tension builds, [8-12s] close-up at the peak, [12-15s] the reveal, so you're directing cuts inside a single clip

one good clip is a sample though, a film needs sixty of them, and that's a volume problem

stage 5: the fleet

this is the stage where claude code earns the word studio

one orchestrator session owns the shot list

it spawns subagents by shot family... creatures, water, interiors, action... and each subagent writes its own prompts from the style contract, submits its generations through the CLI, polls its jobs, and reports back its winners

because every model is addressable from the same terminal, the fleet covers the whole shot list in parallel, across models, while you do something else

the fleet lives or dies on one unglamorous rule... respect concurrency

video models cap how many jobs run at once, so the agent checks active jobs and submits only when a slot frees

an agent that throttles finishes overnight... a naive loop dies on rate limits an hour in, which is correct, the cap is what makes the overnight run predictable

iteration discipline for the fleet: 3 to 4 candidates per shot, then change ONE variable per pass... the camera, the lighting, or the speed, never a full rewrite, because a fail you changed five things on teaches you nothing

and the agent logs every generation: prompt, model, result, kept or killed

your production becomes a database, and production number two starts from everything number one learned

0:03

stage 6: montage as code

the assembly is smaller than you think

music first: brief the score against the cut's emotional arc in movements, not moods (build, peak, quiet, resolve), generated in one pass, then trim the cut to the score

the cut itself is a text file: one line per clip with its duration and an audio flag, and ffmpeg, the free command-line video tool claude code already knows how to drive, reads the file and renders the film

every row of that file is a shot name, the seconds to keep, and an audio flag... 17-scylla-deck sits in my last cut's file with its audio flagged mute, because its generated shout fought the strings, and sea ambience two rows later stays live because it sells the scene

per-clip audio gets muted exactly where it collides with the score, kept everywhere it adds realism

which means the entire edit is reproducible and changeable in seconds, no timeline software, no editor

upscale once, at the end, on the finished cut, never on individual clips

generate at 720p while exploring, 1080p for keepers, 4K only for the final master, and you stop at the lowest resolution that answers the question you're asking

if driving ffmpeg and an upscaler from a terminal is more pipeline than you want, this stage is supercomputer territory too: hand it the winning clips and it assembles the cut and renders the 4K master itself

and the last cut pass is pure honesty: any clip where you'd check your phone gets deleted, whatever it cost you

0:05

what this system is actually for

the film is the demo... the system is the asset

the same six stages produce product ads, UGC at volume, brand films, launch videos, because nothing in the pipeline knows it's making a film

and a standing system wins on speed: when a moment hits your niche the window is measured in hours, and an operator with a style contract, locked characters and a generation fleet publishes while everyone else is opening tabs

the whole build, compressed:

extract a style contract from real cinema with a vision model

generate frames at volume across several diffusion models, refine, lock characters and locations into sheets

Fable 5 Medium writes every shot prompt from one locked template

Seedance 2.0 animates keyframes as isolated 3-5s shots: camera move + event + no frozen figures

subagents run the generations in parallel through the higgsfield CLI, throttled, logged

score, cut from a text file with ffmpeg, upscale the master once

skip stage 1 and every other stage produces beautiful footage of nothing in particular

the first film out of this system took one overnight session... yours starts the evening you install the CLI...

or give a try to Higgsfield Supercomputer for free (Higgsfield AI is sponsoring this article, but this thing is genuinely impressive) - it is capable of working autonomously from planning shots, writing prompts, picking models to a final production

everyone reading this can rent the same models, so the film is only ever as good as what you feed the system

taste in, film out

weeklyaiops.com