My AI Video Workflow After Losing a Good Take to a Messy Folder

I lost a good clip once. Not to a bad generation, to a folder. Three models, a dozen retries, and by the time I found the one take that actually worked, I couldn't remember which prompt or which settings had made it. That's when I stopped treating my ai video workflow as "open a tool and generate" and started treating it as a pipeline with stages.

This post covers the five stages I settled on, where generation fits into them, and a small script that keeps the stages from turning back into a mess.

An AI video workflow is a pipeline, not a button

Generating a clip is one step. The workflow around it is what determines whether you can find that clip again, reuse it, or explain to a client why it looks the way it does. I settled on five stages:

1. Source. The raw input: a product photo, a brief, a reference clip.
2. Draft. Cheap, fast generations meant to be thrown away.
3. Review. A human decides which drafts are worth finishing.
4. Final. The approved generation, rendered at full quality.
5. Archive. Final output plus everything needed to reproduce it: prompt, model, source, and cost.

Skip the stages and you get what I had: good takes buried next to bad ones, with no way to tell which prompt made which file.

These stages matter most in projects with real volume: an AI product video generator for a small store working through a catalog, a social creator testing openers, a game studio iterating on scene concepts. One-off clips can survive a messy folder. A dozen shots a week can't.

The stages also don't care which kind of generation feeds them. A source can be a still you animate, in which case it's the image to video AI case and the quickest way to animate a photo you already have. Or it can be a text prompt with no image at all. Either way, the pipeline is the same five stages.

Where generation happens in the workflow

For the draft and final stages, I used VOKOO, a multi-model AI creation platform built around video. Its tagline is "Create more. Switch less," and that's the part of the pipeline I didn't want to build myself. I dropped in a product photo, typed a short prompt, and had a clip to review before I finished my coffee.

It's a web workspace, not something I script, so I treat it as one stage that other stages feed into and pull from.

Draft cheap, generate fast

The AI video generator turns a prompt, or a prompt plus an image, into a video. Make a video before the idea gets cold. I run every new idea here first, at a lower spec, before anything is worth finishing.

Fix the source before you draft from it

A soft photo makes a soft draft. The AI photo editor and image upscaler let me edit, refine, and make small or blurry images crisp and usable without leaving the flow.

Switch models, not tabs

The AI agent lets me try different models without rebuilding my workflow. Same source, same prompt, different model, and only the best draft moves to Review.

Render the final once you've picked a winner

I pick quality and generation specs per stage and see the estimated credit cost before I submit. Drafts are cheap; only the winner gets rendered at full quality. One place to generate, edit, enhance, and animate.

The script that keeps the stages from collapsing

The workspace handles generation. Keeping Source, Draft, Review, Final, and Archive apart is my job, and I automate it with one script and one naming rule.

The rule: every file starts with a shot ID, like shot03__push_in__model_a.mp4. The script reads that name and files the clip where it belongs.

# pipeline.py - sort generated clips into Draft/Review/Final/Archive by filename
# usage: python pipeline.py inbox/*.mp4
# naming convention: <shot_id>__<note>__<model>[__final].mp4
import csv
import shutil
import sys
from pathlib import Path

STAGES = ["draft", "review", "final", "archive"]
for stage in STAGES:
    Path(stage).mkdir(exist_ok=True)

MANIFEST = Path("manifest.csv")
if not MANIFEST.exists():
    MANIFEST.write_text("filename,shot_id,note,model,stage\n")

def route(path: Path) -> str:
    return "final" if "__final" in path.stem else "draft"

rows = []
for arg in sys.argv[1:]:
    src = Path(arg)
    parts = src.stem.split("__")
    shot_id, note, model = (parts + ["", "", ""])[:3]
    stage = route(src)
    dst = Path(stage) / src.name
    shutil.move(str(src), dst)
    rows.append([src.name, shot_id, note, model, stage])
    print(f"{src.name} -> {stage}/")

with MANIFEST.open("a", newline="") as f:
    csv.writer(f).writerows(rows)

Drop new exports in inbox/, run python pipeline.py inbox/*.mp4, and every clip lands in the right stage folder with a row in manifest.csv.

Rename a file to add __final once it's approved, run the script again, and it moves from draft/ to final/.

Archive what you'll need to reproduce a clip

Archiving is the stage people skip, and it's the one that saves you two weeks later. This appends the prompt and cost to the manifest row for a finished clip:

#!/usr/bin/env bash
# archive.sh - log prompt, model, and cost for a finished clip
# usage: ./archive.sh shot03__push_in__model_a__final.mp4 "slow push-in, warm light" 4.5
FILE="$1"; PROMPT="$2"; CREDITS="$3"
echo "$(date +%F),$FILE,$PROMPT,$CREDITS" >> archive_log.csv
cp "final/$FILE" "archive/$FILE"
echo "archived: $FILE"

Two weeks later, archive_log.csv and the file itself are enough to reproduce or explain the clip. No memory required.

Keeping the workflow cheap as it scales

The stages themselves keep cost down: drafts are cheap by design, and only approved shots get the full-quality render. The platform shows the estimated cost before you submit, so a draft never quietly becomes an expensive mistake.

If you'd like an LLM to draft the note for each shot ID from a brief, RouteAI provides a cost-effective, OpenAI-compatible API gateway with multiple models, so setup stays simple.

Try this next

An AI video workflow isn't the tool you generate with. It's the stages around it that decide whether a good take survives long enough to matter. VOKOO handles Draft and Final for me. Stop managing tools. Start making things.

Here's a short test you can run today:

1. Create the five stage folders and drop pipeline.py next to them.
2. Generate two drafts for one shot and route them with the script.
3. Rename the winner with __final and run the script again.
4. Archive it with archive.sh, and check the estimated cost before you scale up.

If you want an easy AI video generator that keeps simple AI video creation simple and still leaves room to explore, try VOKOO at https://vokoo.ai.