One Prompt Is Not a Comic: How Our Six-Stage Pipeline Works

One-shot comic generators demo beautifully and work terribly. You type a prompt, a full page of comic comes out, and everyone in the room is impressed. Then you look closely: one panel has the wrong character, one line of dialogue doesn't fit, the third frame is gorgeous but the fourth contradicts it. And there is nothing you can do — the generator gives you no way to fix the one thing that's wrong without rerolling all of it.

We built Lovecomic on a different bet: a comic is not one generation, it's several different decisions that deserve separate control. That bet produced our six-stage pipeline, and this post is the honest version of why it exists and what each stage buys you.

A comic is six decisions, not one image

Think about what actually happens when a human studio makes an episode. A writer settles the story. A scriptwriter breaks it into scenes and dialogue. A character designer fixes what everyone looks like. A storyboard artist decides shots and pacing. Artists render the frames. A letterer places the words. Different people, different tools — and crucially, different feedback at each step. Nobody inks a page before someone approves the plot, because ink is expensive and plot decisions are cheap to change.

A one-shot generator fuses all of those decisions into a single roll of a joint distribution. Story, cast, camera, and rendering come out entangled in one image. You wanted to change one variable — the dialogue, say — but the only lever you have rerenders everything. That's not a workflow; that's a slot machine.

Factor the decisions apart, and each one gets its own lever.

The stages, one by one

Here is the pipeline as it actually runs, stage by stage:

1. Outline → story bible. Your one-line idea (or full script) is expanded into a structured bible: logline, tone, themes. This is the cheapest stage to change, so it's where premise problems should surface — not after the art exists.
2. Script → numbered scenes. The bible becomes concrete scenes with dialogue, numbered and ordered. Reading this stage is the last chance to cut a bad beat for free.
3. Cast & assets → reusable cards. Characters, locations, and props are extracted as asset cards. Optionally, each recurring character gets an AI reference sheet — the canonical image that keeps faces stable. Why that matters is its own post: why AI comics change your character's face.
4. Storyboard → panel descriptions. Every panel gets a written shot description before any pixels are drawn. This is where a comic is really directed — framing, what's in frame, who speaks — and it costs almost nothing to revise.
5. Panel art → rendering. Only now does the image model run, one panel at a time, with the character references passed in alongside each description. You get several candidates per panel and a version history you can scroll.
6. Lettering & export. Speech bubbles are placed on the panels, and the episode assembles into a vertical webtoon strip — plus a dialogue-free silent version and English or Chinese output. Export is publish-ready.

Running alongside the art stages is a QA pass: a vision model scores each generated panel and lists visible issues. It's advisory — it tells you what to look at, it doesn't silently redo anything.

One engineering property worth knowing: stages are idempotent. A stage whose output already exists is skipped on retry, and retries never delete prior work. If a long run fails at panel nine, resuming continues from panel nine — you don't pay for panels one through eight again.

The point is where you can intervene

The pipeline exists to give you control points, so the control has to be real:

• Autopilot mode runs everything hands-off — one click from idea to lettered episode, about ten minutes for a twelve-panel episode when the queue is quiet. For premise validation and "is this idea worth an episode," it's the right gear.
• Manual mode pauses at each stage boundary for approval. Approve the bible, then the script, then the board — and you can switch between modes mid-project without losing progress.
• Panel-level control is where most real editing happens: pick your favorite candidate, or reroll a single panel with a plain-language instruction — "make it night, keep everything else." Version history means a wrong turn is never final.

The deeper pattern: cheap stages (text) are where you make big decisions, expensive stages (images) are where you make small ones. The pipeline enforces that order so you never pay GPU prices to discover a story problem.

Build your own line

The six stages aren't hardcoded theology — the same capabilities are exposed as nodes in the flow editor: text and image inputs, outline, script, cast & assets, storyboard, a generic LLM transform with your own prompt template, character sheets, panel art, and vision QA. Wire them into your own graph, save it, run it. Publish a flow and anyone can remix it in one click; the flows gallery already has public lines to borrow from.

What it costs

Text stages — outline, script, storyboard, QA — are free. Billing lands where GPUs land: character sheets and panel art consume credits. The details are on the pricing page; the design principle is that iteration on words should never be rationed, only iteration on pixels.

Try the whole line

The fastest way to understand the pipeline is to run one episode through it in Autopilot, then flip to Manual mode and re-run a stage you're curious about: start in the studio. If you want to write a better first input before you do, the prompt guide breaks down what the pipeline actually reads from your idea.