GenAI for online content creators

A pipeline that turns a creator’s idea into a finished video, with human-in-the-loop approvals.

Product: Content Factory
Role: Product owner and builder
Period: 2026
Built with: Claude Code

Business request

I wanted to run a faceless YouTube Shorts channel about American housing economics. Producing one video by hand takes hours: finding an idea, writing a fact-checked script, collecting footage, recording a voice and editing. I wanted this to take minutes of my attention per video, without losing control over quality.

Challenges

Quality at every step

A fully automatic flow produced wrong facts, mismatched footage and misheard words in captions. The pipeline needed human approval points.
Cost

Every video calls several paid APIs for text, voice, images and transcription. Costs had to be visible and capped before anyone else could use the tool.
Reliability

A render with ten steps fails somewhere. Every step had to be repeatable without redoing the previous ones.
A second audience

The tool started as an operator tool. Friends needed a simpler flow, with their own accounts and their own data.

Delivered solution

The platform takes a project through five steps, and each step stores its result so it can be reviewed or repeated.

Pipeline flow

Idea shortlist
Fact-checked script
Storyboard scenes, visuals, on-screen text
Assets stock footage, AI images, voiceover
Render and metadata

↺ A human approves each step before the next one starts

Behind it, each step is a small stateless worker. LangGraph runs the workers and a Postgres checkpoint allows a run to resume after a restart. Every output is a versioned artifact, so I can see which prompt and model produced it. The render runs either on the server with FFmpeg or on my laptop through a CapCut export, both from the same timeline.

Other parts

Operator mode for me, and a simplified “Creator” flow for friends (pick a story, a voice and characters, see the cost, get a video).
Google sign-in, per-user data isolation and server-side access checks.
Credits with a hold before each paid call, a refund if the call fails, and hard limits so nobody can overspend. The owner tops up accounts and sees usage.
Two security audits, with findings tracked and fixed, and a backup and restore drill.

Tech stack Python, FastAPI, LangGraph, Postgres, Cloudflare R2, FFmpeg, Claude and other model APIs, plain HTML and JavaScript, Railway.

Outcome

The full flow works from idea to rendered video on the test environment, in 9:16 and 16:9, with real runs reviewed by hand.
Around 3,400 automated tests pass.
Credits, limits and the owner admin view are built. They are switched off until the friends beta opens.
Not yet done: production release, online payments, publishing to YouTube.

Lessons learned

Human approval points cost little and catch most errors. I would add them earlier next time.

Store every step’s output as its own artifact. Retrying one step is then cheap and debugging is simple.

Plan billing and access control before a second user arrives, not after. Adding them later touched almost every paid call.

A fixed flow with an LLM at some steps worked better than an autonomous agent. I knew the order of the steps in advance, so I did not need an agent to decide it.