Building a production-grade UGC workflow for automated product reviews

UGC only works in volume. You test ten hooks to find the one that holds attention for three seconds, and each of those ten needs a person with a camera, a script, and an evening of editing. The thing the format needs most is the thing a person is slowest at.

So I wanted to know how much of that run an agent could hold end to end. The whole thing: read the product, decide the angle, write the lines, generate the character, film it, hand back something postable.

It came out at $4.75 a video^[1] and about $300 of development before the cost stopped me halfway. Character consistency worked better than I expected. Continuity between the clips never worked at all, and that turned out to be the part worth writing about.

Seven phases, two of them mine#

The two branches leaving the diagram are there because every generation bills. A model that misreads an instruction and loops costs real money, so the two generating stages count their own calls and halt the run when the count passes twelve — the expected number is eight, and anything above that means something is wrong in a way retrying won't fix.

The two places it stops for me are the only other real decision in the sequence.

The first one is about money too. Everything before the script costs four cents and everything after it costs $4.70,^[2] so the check sits at the four-cent mark, where I read sixty words of text before that text authorises the expensive half. It takes ten seconds and it's the cheapest place in the run to catch a bad one.

The second stop is about Veo. A generation caps at eight seconds, and the clips came back with unpredictable tails — the line would finish at six seconds and the character would sit there for the remaining two with an empty expression on her face. Trimming that automatically means detecting the exact frame where she stops looking mid-sentence, and I can see it instantly while a program can't. So I cut the clips together myself.

Both of those stops produce something the next run reads. Every time I approve, edit or reject a script my note gets appended to a file, and the script phase reads the last five entries before writing anything. When I rate a finished video, the rating goes to a second file along with the outfit and the room it used, and the phase that picks those reads it before choosing. It's the cheapest possible version of a feedback loop: the last few notes pasted into the next prompt.

Whether it compounds I never found out. A file like that has to get some depth before the notes outweigh the noise, and I stopped well before then. The half that would have closed the loop properly — pulling view counts and retention off the posted videos and feeding those back instead of my own opinion — I scoped and never built.

The same face in every clip#

The hard technical problem is that four separately generated images have to show the same person, in the same room, wearing the same clothes. Generate them independently and you get four strangers.

The obvious approach is to chain them — feed scene one into scene two, scene two into scene three. That compounds. Every hop drifts a little further from the original face, and by the fourth clip it's someone else's sister.

What works is re-anchoring. Every scene after the first takes scene one's output as its reference image, so nothing is ever more than one hop from the original. Alongside it goes a fixed photograph of the room, passed on every single call, which holds the broad shape of the background. The clothing description is copied word for word between scenes, and the expression is the only thing I let change.

The character held. Across runs the face, the hair and the outfit come back the same, clip to clip.

Continuity was the part I never solved#

The person stayed the same. The room and the conversation didn't.

The room drifted object by object. The reference photograph kept the set broadly right, but the model would add and remove things between generations — a mug on the desk in one clip and gone in the next, a box that moves along the shelf. In a still it reads as nothing. Across four clips in sequence it reads as four different rooms.

The conversation drifted for a different reason. Each clip is generated on its own and knows nothing about the other three. The model has no idea what energy the previous clip ended on, so a scene that closes flat gets followed by one that opens like the video just started. Stitched together it reads as four takes of someone rather than thirty seconds of one person talking, and that's the exact tell that makes something look generated.

That got the failure rate down without getting it to zero. I also wrote out the intonation each scene should start and end on, so scene three would begin where scene two left off. It helped and it never held reliably. Some runs still came back with her saying something that was never in the script.

None of this is a quality problem with any individual clip. Each one on its own is convincing. The failure lives entirely in the seams, and the seams are the one place a model generating four independent things has no visibility into.

The expensive models weren't the reliable ones#

I started with Opus writing the scripts, and it was too expensive to run on something I'd regenerate three times over one bad line. Gemini Pro wrote the best scripts of anything I tried and wouldn't return valid JSON consistently enough to sit inside a pipeline, so runs died at phase three for reasons that had nothing to do with the writing.

What I settled on was a cheap model per phase, picked for the shape of the task, with programmatic checks on the output and my own review behind that.

The thing I'd underweighted: when a human reads every script before a cent gets spent downstream, paying more for the model writing it buys much less than it looks like. The review gate was already catching what a better model would have prevented — and I had been spending my attention on the four cheapest phases in the run.

I stopped at $300#

The half I never built was the edit, and by then I knew why it was hard. Cutting around unpredictable clip tails needs a model that can tell when a person has stopped talking and started waiting, which is a bigger problem than the one I set out to solve.

More to the point, automating the edit doesn't touch the thing that was actually wrong. Stitching clips faster doesn't help when what's wrong with them is that they don't sound like one conversation.

If I picked it up again I'd stop treating each clip as an independent generation and carry explicit state between them — the last half-second of audio, the ending pitch, something the next generation can condition on — instead of describing the energy I want in words and hoping the model reads it the same way twice.

That constraint isn't specific to video. Any pipeline that fans work out to parallel generations and stitches the results has it: each piece is coherent on its own, the joins are where it comes apart, and the model can't see the join. What I'd want to know before starting something like this again is whether the seams are decoration or whether they're the product. Here they were the product.