How I built a self-monetizing AI comic pipeline
Every day, a machine on my desk reads the tech news, draws a three-panel comic about it, renders it into a vertical video, and publishes it — but only after a human approves every single step. This is the honest tour: how it is set up locally, what one comic actually costs, how the human gates work, and how it is actually monetized right now.
The one-line architecture
A scheduled worker finds a trending tech story, writes three competing scripts, draws the panels with a local image model, assembles them into a comic strip and a vertical video, and publishes. A human sits at two gates: one that approves the topic, and one that approves the finished comic before it goes live. Everything runs on one Windows machine — no paid cloud inference, no per-image API bill.
What is in the box
The stack is .NET 10, PostgreSQL and Angular — deliberately boring, because the goal was a reliable pipeline I could leave running, not a clever one. The interesting parts are the models, and they are all local:
- Scripts — a local LLM (Qwen 2.5 3B) writes the dialogue, including three different takes on the same story so a human can pick the best one.
- Art — Stable Diffusion XL draws the panels. Three panels per comic.
- Video — ffmpeg assembles the panels into a vertical video for YouTube and TikTok.
The only cloud services are where a local machine fundamentally cannot reach: the YouTube publishing API, Cloudflare for hosting, and TikTok's API.
How the pipeline is gated by humans
Nothing goes live without a person explicitly approving it. There are three decisions, in order:
- Approve the topic — the scheduler queues a headline, but nothing is generated until a human says yes.
- Pick the take — the script stage writes three angles, and a human picks the one that gets drawn.
- Approve the comic, with informed consent — the operator reads the full story and checks a box confirming they have read it before the publish button even unlocks.
The reverse actions exist too: a published comic can be taken down, and a rejected or failed run can be reopened. All of this happens through a private review dashboard, separate from the public site, that requires the operator to authenticate. The machine does the grind; the human does the judgment.
What one comic actually costs
I measured this rather than guessed. The art stage is the expensive one — during generation the GPU sits at roughly 210 watts (its full 220 W limit) at about 98% utilization, and drops to around 94 W when the run finishes.
That works out to roughly 0.5–1.5 cents of electricity per comic, depending on your local power rate. Run the pipeline a few times a day and the whole thing costs under a dollar a month in power. There is no per-image or per-token API bill anywhere in the loop — the image model, the script model and ffmpeg all run locally.
- Marginal cash cost per comic: about a penny of electricity.
- The fixed cost: one consumer GPU. That is the entire infrastructure.
- The real cost: your attention. A human still approves the topic and reads the finished story before it publishes — that time, not the electricity, is what limits output.
How it is monetized
Here is the honest part. The monetization is built but not yet paying, and every channel sits behind an external approval that is not in the code:
- Advertising — the ad setup is live, but Google must approve the domain before ads serve.
- YouTube — every comic publishes there, but monetization needs 1,000 subscribers and 4,000 watch hours.
- TikTok — cross-posting works, but public posting is gated on a platform audit.
The strategy is to treat this like a small media operation, not a technical demo: publish consistently, let the archive compound, and let the approvals arrive on their own schedule.