Six months ago, generating a single 4-panel comic on Comicory cost me ~$0.80 in GPU time and produced something that looked AI-generated in the worst way — washed-out colors, fingers melting, the same character looking like three different people across panels.
Today the same comic costs $0.152 (so ~$0.038 per panel) and looks consistent enough that nobody asks "is this AI?" in the first three seconds.
I didn't switch to a cheaper provider. I didn't quantize my models harder. The win came from prompt engineering and model selection — the boring layer everyone skips because it's not flashy. Here are the 7 things that actually moved the needle.
1. Stop using SDXL for thumbnails
I was running SDXL 1.0 (1024×1024, ~6.5s on an A10G) for every generation, including the rough draft thumbnail the user sees during the wizard. Switching to SD 1.5 + a good anime LoRA at 512×512 for thumbnails cut that step from 6.5s to 1.1s.
Users don't care about thumbnail quality. They care about iteration speed. And SD 1.5 thumbnails get refined to SDXL only on final render.
Saving: $0.041/comic (4 thumbnail-equivalent generations per session avg)
2. Front-load identity tokens, demote style tokens
Every prompt engineering tutorial says "put important things first." Almost nobody quantifies it. After A/B testing 200 panels, I found character identity drift drops ~38% when the LoRA trigger token + descriptor sit in the first 12 tokens:
# Before (drift across panels: ~31%)
"masterpiece, best quality, anime style, vibrant colors,
detailed background, miraCharacterV3, woman with red hair..."
# After (drift across panels: ~9%)
"miraCharacterV3 woman, red hair, green eyes,
freckles, anime style, masterpiece, detailed background"
This alone halved the number of regen requests, which is the single biggest cost driver in a generative product.
3. Use negative prompts to skip CFG cycles
Counter-intuitively, a strong negative prompt lets you lower CFG scale from 7.5 to 5.0 without losing prompt adherence. Lower CFG = fewer effective sampler steps needed for the same fidelity.
My current negative is 47 tokens: lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, jpeg artifacts, watermark, signature, blurry... etc. Boring, but with CFG 5.0 I can drop steps from 28 to 22 and the human eye can't tell.
Saving: ~21% per generation step.
4. Cache the seed for "same character, next panel"
For multi-panel comics, the wizard generates panel 1, the user approves, then panels 2-4 inherit the same seed with only the action/background changing in the prompt. This means panels 2-4 don't need to do full character search — they're starting from a latent space already near the desired identity.
I drop steps for panels 2-4 from 28 to 18 and only re-render panel 1 at full step count. Quality across the strip is more consistent than running each panel fresh, and the GPU time is 35% lower.
# Pseudocode
seed_panel_1 = random_seed()
panels[1] = generate(prompt_1, seed=seed_panel_1, steps=28)
for i in [2, 3, 4]:
panels[i] = generate(prompts[i], seed=seed_panel_1, steps=18)
5. Embed the dialogue after image generation, not in the prompt
Old approach: "...woman saying 'I forgot my keys'" baked into the prompt. The model would render warped text 70% of the time, costing me a regen.
New approach: generate clean image with empty speech bubbles, then composite Pillow text afterward. Zero text rendering errors, deterministic typography, and I save the regen budget for actual artistic misses.
This sounds obvious in retrospect. It took me four months to stop fighting the model on something it was never good at.
6. Pick the model per panel, not per comic
Not every panel benefits from SDXL. Establishing shots (wide angle, lots of background) yes — character close-ups don't need 1024². I built a router that picks:
- SDXL Turbo for close-ups and reaction shots (4 steps, $0.011/panel)
- SDXL 1.0 + LoRA for full-body action and establishing shots ($0.052/panel)
- SD 1.5 + LoRA for backgrounds inserted into composite scenes ($0.008/panel)
Average panel cost dropped from $0.061 (everything-on-SDXL) to $0.029 (routed). Quality assessed via a 50-panel blind test at 4.2/5 vs 4.3/5 — within noise.
7. Pre-warm the GPU once per session
This isn't strictly prompt engineering, but it interacts with everything above. Cold-loading SDXL + LoRA takes ~14s. If the user does 6 generations in one session, I was eating that cold start every ~3rd request because of autoscaler scaledown.
Pinning one warm replica per active session for 5 minutes after the last request cut average wall-clock latency from 8.4s → 3.1s and the GPU bill barely moved (idle warm time on Modal is ~$0.0008/sec).
Before / after
| Metric | Old | New |
|---|---|---|
| GPU cost per panel (avg) | $0.061 | $0.029 |
| Effective cost per panel including regens | $0.20 | $0.038 |
| Avg latency per panel | 8.4s | 3.1s |
| Character consistency score (internal) | 4.0/10 | 8.7/10 |
| User regen rate per session | 2.3 | 0.7 |
The regen rate metric is the one I care about most. Every regen is a user staring at a spinner thinking "is this thing worth $9/month." Cutting that 3x doubled my trial-to-paid conversion in March.
If you want to see the pipeline in action, Comicory is the side project this all lives inside. The "create a 4-panel" wizard runs through every trick above in the same order I described them.
Top comments (0)