How to build a $2M video production pipeline

i'm giving you 7 free skills and the exact pipeline directors are using to produce AI films with millions of dollars in budget in higgsfield... the whole system revealed step-by-step, with the skill that runs each stage ready to install today

Seedance 2.5 at 1080p (only on higgsfield) now means you can one shot full 30sec ads/creatives/trailers without any upscaling... this is awesome

here's what's inside:

• the single platform the whole workflow runs through and why
• the one problem every AI film dies on
• the 11 stages and the two gates that hold them together
• every stage broken down, the automatable ones closing with the skill that runs it
• what stays human and why
• the full playbook block

to get access to all the skills, join here: https://t.me/tgmachina i'll be posting them shortly

and if you want to go deeper on turning AI video into actual revenue, the training and the weekly systems for that live in the real time AI ops community at weeklyaiops.com

the engine: seedance 2.5 at 1080p and the CLI

everything in this article runs through one platform: higgsfield

two reasons, and both are structural: the whole surface is built for agentic use, so your agent can drive every generation end to end, and Seedance 2.5 at 1080p only on higgsfieldruns on it

the whole workflow runs on one video model, deliberately

one model means one prompt grammar, one set of quirks, one consistency behavior to learn... the image models only build the reference sheets that feed it

that video model today is Seedance 2.5

it one-shots a 30 second clip with the dialogue lip-synced and the sound effects generated in the same pass, and it carries a reference budget big enough to hold your cast, your location, a key prop, a camera move, a voice, and the ambience inside one generation

the pipeline's iteration rule gives a failing shot 10 to 15 attempts before you're allowed to blame the wording

the CLI is the agentic door:

• npm install -g @higgsfield/cli
• higgsfield auth login
• npx skills add higgsfield-ai/skills

three commands and every model becomes callable from Claude Code or whatever harness you run, which means an agent can hold the whole pipeline... what generates, in what order, with which model, while you direct

and if 2.5 gets replaced next quarter, nothing below changes... treat the model table as a snapshot, because the stages and the gates are the part you keep

here's a quick example of what you could produce with this pipeline:

the actor doesn't remember how he looked yesterday

that sentence is the entire reason this pipeline exists

a video model has no memory between generations, so if a character's appearance isn't described exhaustively in every single prompt, neighbouring shots hand him a different face, a different jacket, a different age

on a 10 second clip nobody notices... across 90 minutes it kills the film, because the audience reads a continuity break faster than any other flaw

the model has no memory, so the pipeline is the memory

half the stages you're about to see exist only to remember things on the model's behalf... what the hero wears, how far the door sits from the window, which palette owns the scene

and the memory runs on four rules you never break:

• generate nothing for the film until every asset is locked
• one asset gets one approved passport, copied verbatim into every prompt that uses it
• edits are surgical: change one line, keep everything else word for word
• everything is versioned and logged, because an unlogged good shot is a shot you can't reproduce

break the first rule and you remake half your material once the look drifts

the rest of this piece is those four rules stretched into a working studio

the 11 stages

classic pre-production is casting, location scouting, and a prop shop

here it runs in reverse: you fix digital references instead, and the tighter you close the early stages, the cheaper every generation after them gets

• breakdown: the script becomes scenes and shot cards
• references: images collected as specification, per asset and per style
• the visual bible lock: every board gets a written decision
• asset sheets: characters, locations, and props get passports
• the library: passports stress-tested, then locked into a registry
• generation: shots produced from cards and passports
• edit: assembly runs in parallel with generation
• cleanup: artifacts fixed shot by shot
• color: an outsourced colorist unifies then grades
• sound: an outsourced post team cleans and mixes
• master: festival and platform deliverables plus the archive

the stages run in sequence at scene level, with one exception: while scene N generates, the editor is already assembling scene N-1 and the director team is shotlisting N+1

that overlap exists because a reshoot here costs minutes, not a shooting day

the editor watches an assembly, orders a missing cutaway, and has it the same afternoon... which means editing stops being post-production and starts actively shaping what gets made

but none of it starts until the gates say so

a stage exits through a written checklist, and the hardest gate sits in front of generation: every character, variant, location, and prop in a scene needs a registry row marked locked before a single film frame renders

the most expensive rule in the pipeline, and the most rewarding

now the stages themselves

each one below closes with the skill i built to run it, and all 7 are waiting in the telegram

stage 1: the breakdown

before anyone writes a prompt, the script becomes shot cards

each shot gets a card of 22 fields in three lanes:

• identity: scene and shot id, location, time of day, characters with their asset tags and state variants, props, description, the dialogue verbatim, running time, complexity
• direction: the shot's goal, the task as a verb, dramaturgy, blocking, acting, style device
• camera and edit: size, movement, lens, angle, cut type, pace, transition

22 fields sounds like bureaucracy until you see what it buys: the prompt later writes itself almost mechanically, because the column groups map one to one onto prompt blocks

two rules ride along

every clip carries one action, never a sequence of them

and any text that must appear inside the frame... a sign, a phone screen, a title... leaves the generation entirely and goes onto its own task list, because video models write text badly and titles belong to the edit

the skill: /film-breakdown takes a script, a treatment, or a one-paragraph idea and walks it scene by scene, one question at a time, writing the scene table and one shot-card file per scene as it goes

every shot leaves with all 22 fields filled, and any in-frame text is already pulled onto its own task list before you ever prompt

but a perfect card still describes a man no two models will draw the same way... that problem has its own two stages

stages 2 and 3: references and the lock

a reference here is a spec

"a tired father in a worn jacket" produces a different man in every model and every head

an actual image of him settles the question, which is why the rule runs one direction only: find the existing image first, then describe it... never imagine a description and hunt for proof

the working counts: 10 to 20 images for a lead character, 8 to 15 per key location, 3 to 5 per prop, plus separate boards for light, color, optics, camera movement, texture, cutting tempo, and sound

those ranges are counted from working productions, not guessed, which is why i'm not rounding them

every image gets a caption naming exactly what is taken from it

an image you just like, with no caption, is junk a week later

and the images marked "like this... not allowed" become the ban list, which saves you more generations than the references do

the fastest way to fill the style boards is to extract from real cinema instead of imagining: feed stills from films that already carry your feeling to a vision model, have it name the lens, the light direction, the palette, the grain, and lock the output as one paragraph that gets pasted into every prompt of the project

then comes the lock, and the lock is written

every board ends in a fixed decision... approved, revise, or rejected... recorded on the board itself

a style that was approved verbally means the director and the prompt engineer are holding two different films, and they find out a month in

the skill: /reference-board runs the interview one board at a time... you supply the references, it forces a caption on every image, files every anti-reference into the ban list, and closes each board with the written decision, approved, revise, or rejected

nothing gets called locked without that decision on the board

stage 4: the passport

here's where consistency gets manufactured

watch what happens to one character: he gets an exhaustive text descriptor, and a sheet of reference images generated on a neutral grey background... front, three-quarter, profile, back, close portrait

that pair, descriptor plus references, travels into every prompt he appears in, word for word, file for file

that's his passport, and a production holds one per character, location, and prop

wet clothes are a different passport

so is blood... @cal, @cal_wet, and @cal_blood are three separate assets with three separate tags, because a variant described inline is a variant the model will forget

two details make passports hold:

• the descriptor is never shortened, since "trimmed for brevity" is exactly where consistency dies
• a location's passport carries the scene's palette and light character inside it, so every shot in that location arrives pre-graded

and the reference images themselves get built by hand first, in an image model, before any video prompt exists

lock them and never regenerate them... if the motion looks wrong later you fix the motion prompt, because a new image undoes every piece of consistency work stacked on the old one

every passport lands as a row in one living registry: tag, type, version, seed file, scenes, status

a passport at this point is still a draft, because a passport built on one lucky image is a false victory

the skill: /asset-passport builds one asset at a time... it interviews you until the descriptor has no gaps, writes the grey-background reference-sheet prompts for your image model, splits every state variant into its own tagged asset, and files the registry row at draft

stage 5: the stress test

before any asset is trusted, it generates under combat conditions: different angles and shot sizes, the lighting of its actual scenes, and standing next to every asset it will share a frame with... because a character who holds up alone often breaks the moment he shares a frame

the tests are cheap static images, run before a single expensive video generation

characters have to hit 10 out of 10 repeatability

which is correct

anything below that keeps the registry row at draft, and the scene it blocks either waits or consciously moves to the next production block

generation for a scene starts when every row it touches says locked, and not an hour earlier

the skill: /stress-test reads your registry and breakdown, builds the combat matrix... angles, shot sizes, the real scene light, a two-shot beside every co-star... hands you the test prompts, and flips the row to locked only on a full pass

no full pass, no lock, and the scene stays closed

with the registry green, the production finally starts rendering... and every shot of it comes from the same fifteen blocks

stage 6: the prompt

every shot prompt is the same 15 blocks in the same fixed order

no negative prompt anywhere... every prohibition is rewritten as what IS in the frame

this is what the generation stage runs on, because once the blocks are locked the render itself is mechanical

the blocks worth stealing on their own:

• the opener states "EXACT N CHARACTERS - NO DUPLICATES" because the model adds people the moment you leave the count open
• the location map gives distances in metres and names the line the camera never crosses
• one lens per shot, and the field of view changes only on a hard cut
• action lands in timed beats of 0.3 to 0.8 seconds
• physics persists: damage never heals mid-scene, debris stays where it fell
• light is never flat and frontal, it comes shaped from the location's own sources
• the style block closes with a 60:30:10 colour line: the dominant hue, the secondary, and the accent's share of the frame

for a 30 second one-shot the prompt splits into four timed beats... 0-6 sets the scene, 6-14 builds, 14-24 turns, 24-30 resolves... with the full detail set written per beat, timestamps included

references get the same discipline: every attached image, clip, or audio file states what it controls and what it must not touch

"@video 1 defines motion and pacing" is half a role... the other half is "do not take identity, clothing, or scene from it", and that second line is what stops one reference leaking into a shot it was never meant to shape

motion gets its own grammar: every prompt names the camera move and pairs it with an event that happens during the clip

then it says no frozen figures, outright

a dolly past a standing figure is a still image that drifts

the same dolly while the sail tears loose is a film

then the iteration rule

an edit changes one line and keeps everything else verbatim, every attempt gets logged with what changed and the verdict, and a shot that hasn't landed by attempt 15 doesn't need better words... it needs a simpler shot: split it in two, drop an action, change the angle

a finished take is accepted by checklist... matches the references, no artifacts, camera as ordered, lip-sync holds, cuts with its neighbours... and only accepted takes get final names in the selects folder

that acceptance is the last yes a shot ever needs, because the editor never touches raw generations

the skill: /shot-prompt takes one shot card plus the locked passports of everything in frame, and it refuses to write a generation-ready prompt while any of those assets is still draft

then it writes the 15 blocks with every descriptor pasted verbatim and keeps the generation log with you... one line changed per attempt, simplify the shot at 15

the studio is a file tree

there's no production office in this pipeline

there's a directory

• assets holds the passports: characters, locations, props
• prompts holds the shot cards and every prompt version
• generations holds raw attempts, and nobody but the prompt engineer goes in
• selects holds accepted takes only, and it's the single folder the edit is allowed to see
• edit, color, sound, and master hold the finishing chain
• docs holds the breakdown, the bible, the registry, and the generation log

one more law: a reference file is never renamed

a new version is a new file, because renaming breaks every prompt that points at the old one

the skill: /studio-init asks one question, the project name, then scaffolds the whole tree, seeds the breakdown, the bible, the registry, and the generation log as ready templates, and writes the three folder laws into the project so every agent that touches it inherits them

and the seventh skill is the front door: /setup asks what image and video models you work with, how you access each one, and never assumes a stack... it writes the shared config into your project so every other skill reads the same setup, then hands you the chain in order: setup, studio-init, film-breakdown, reference-board, asset-passport, stress-test, shot-prompt

all 7 are in the telegram: https://t.me/tgmachina

stages 7 to 11: what stays human

edit, cleanup, color, sound, and master are the five stages no skill runs

the pipeline generates picture and scratch audio, and it stops there on purpose

finishing is human work

the edit trims the first and last half second of nearly every generation, because clips drift at their edges

and it cuts harder than feels natural, because generated shots lean into slow entries... the standing instruction is to cut more aggressively than you think you should

generated sound is scaffolding: the lip-synced lines set the timing, then a sound post team cleans that same voice instead of re-recording it, rebuilds the effects, and mixes to platform loudness

color goes to a colorist whose first job is unifying neighbouring shots, since every location's passport already delivered a built-in grade to refine

and the masters ship like any studio's: a DCP, the standard cinema delivery package, for festivals, a ProRes file, the high-quality archival format, for the vault, plus platform encodes and subtitles

the archive keeps more than the finished film

it keeps the means of production... every final prompt, the generation log, the registry, the locked passports... because the sequel starts from everything the last production learned

the playbook block

the whole pipeline, compressed to the block worth saving:

1. lock the visual bible in writing before anything generates for the film
2. one asset, one passport: exhaustive descriptor plus grey-background references, copied verbatim forever
3. stress-test every passport to 10/10 in scene light and two-shots before its scenes open
4. write every prompt as the same 15 blocks, four timed beats for a 30 second shot
5. change one line per attempt, log every generation, simplify the shot at attempt 15
6. accept takes by checklist into selects: the edit sees nothing else
7. trim the edges, cut aggressive, lock picture, hand color and sound to humans

skip the locks and half your material gets made twice

models will swap out from under this system... the method itself expects its model table to age in months

the sequence and the gates are the part that doesn't

thank you higgsfield for sponsoring this article

the 7 skills drop in my telegram shortly: https://t.me/tgmachina