Consistent Character Sheets with AI Image Tools in 2026: A Production Workflow Guide

Why character consistency is the bottleneck in 2026

AI image generation crossed the "good enough for a pitch deck" line sometime in 2024. What it has not solved is the thing a character sheet actually needs: the same person, from six angles, in four outfits, with the same scar on the left cheek. A model that produces a stunning hero portrait on Tuesday will produce a slightly different nose on Wednesday, and a different jawline entirely if you mention "side view."

The stakes went up in 2025. Steam's AI disclosure requirements, now enforced through the platform's content survey, mean developers must declare pre-generated and live-generated AI content — and Valve has been rejecting builds where the disclosure doesn't match what's in the store page. itch.io's policy, updated in early 2025, requires similar disclosure and gives developers a public-facing tag. If your character sheet is inconsistent, you cannot honestly ship a store page that shows one cast and a game that shows another. Consistency stopped being an aesthetic preference and became a compliance and marketing problem.

Meanwhile the tools got better at exactly this. Midjourney's --cref character reference flag, introduced with V6 in early 2024, and the --sref style reference flag, plus V7's improved reference weighting after its April 2025 launch, changed the practical ceiling. Stable Diffusion's ecosystem settled on IP-Adapter and, more recently, Flux-based identity adapters. Dedicated services like Scenario trained purpose-built character models. The gap between "cool AI art" and "shippable character sheet" is now mostly a workflow gap, not a model gap.

The three approaches, and when each one breaks

There are three real ways to lock a character, and they fail in different places.

Reference-image conditioning (Midjourney --cref, Flux identity adapters)

This is the lowest-friction approach. You generate one strong hero image, then pass it as a character reference on every subsequent prompt. Midjourney's --cref accepts a URL and a --cw weight from 0 to 100; --cw 100 carries face, hair, and clothing, while lower values let you change the outfit. In V7, reference adherence improved noticeably on profile and three-quarter views, which were the weakest angles in V6.

The failure mode is drift under pose change. Ask for a full-body action shot and the model will often keep the face but re-invent the proportions — suddenly the character is taller, or the hands are the wrong size. For a character sheet with a turnaround, you will still get a different body every time. The fix is to generate the turnaround first at low variation, then use each angle as its own reference for downstream expressions.

Trained identity (LoRA, DreamBooth, Scenario character models)

If the character appears in more than a handful of assets, train them. A LoRA on 15–30 curated images, run for 1,500–2,500 steps at a learning rate around 1e-4, will hold a face far more reliably than any reference flag. Scenario's character trainer productizes this: you upload a set, it returns a model you can call with structured prompts and pose controls. The tradeoff is setup time and the cost of a training run, typically $5–$30 depending on provider and steps.

The failure mode here is overfitting. Train too long and every output looks like the same three-quarter portrait; the model has memorized your reference set rather than the character. You also inherit the lighting and background of your training images unless you curate aggressively. The rule that has held up in production: 20 images, varied lighting, neutral background, no extreme expressions.

Hybrid: locked identity plus pose and expression control

The workflow that actually ships combines a trained or referenced identity with a separate control layer — ControlNet OpenPose for the skeleton, or a pose-reference image. You generate the character once, then drive the pose from a rough stick figure or a Mixamo render. This is the only approach that reliably produces a usable turnaround: front, side, back, and three-quarter, all recognizably the same person.

It is also the most expensive in GPU time and the least forgiving of a bad base image. Get the base right at 1024×1024 or higher, lock the seed, and only then start varying pose.

What this looks like in a real pipeline

A small studio building a narrative game with a cast of eight did this in roughly this order, and the numbers are representative of what I've seen across several teams.

First, they generated 40–60 candidates per character in Midjourney V7 using --cref against a single approved hero image, then picked the three best angles. That's 320–480 generations for the cast, at roughly 30 seconds each on the standard plan — a day of wall-clock time, mostly unattended.

Second, they trained a LoRA per main character in Stable Diffusion (via ComfyUI with the IP-Adapter and ControlNet nodes), 20 images each, ~2,000 steps. Training on a rented A100 ran about $8 per character. Side characters stayed on --cref to save time; the two leads got LoRAs because they appear in 200+ assets.

Third, they locked seeds and used ControlNet OpenPose for the turnaround and expression sheets. Expression variants — happy, angry, hurt, neutral — came from the same seed with prompt-only changes, which kept the face stable. When a face drifted, they regenerated from the base rather than trying to inpaint, because inpainting a face at 512px almost always reintroduces drift.

Fourth, cleanup. AI output is not game-ready. They ran everything through Adobe Photoshop (AI) for symmetry fixes and palette normalization, and used Vectorizer.ai for any UI-facing character icons that needed to scale cleanly. For characters that would appear in-engine as sprites or portraits, Krita with its AI plugins handled the final paint-over, which is still faster than fixing a model's hands.

The honest result: about 70% of the sheet was usable directly, 30% needed manual correction, and the total time per character dropped from roughly two days of a concept artist's work to about three hours of prompting plus one hour of cleanup. That is the real number. Anyone claiming fully automated character sheets is selling something.

Practical advice

• Generate the base at the highest resolution you can afford, then lock the seed. Every downstream variation should reference that seed. Changing seeds mid-sheet is the single most common cause of drift.
• Use --cref with --cw deliberately. Set --cw 100 when you need the outfit, drop to --cw 20–40 when you are changing costume but keeping the face. Do not leave it at default and hope.
• Train a LoRA past five appearances. The break-even is real: below five assets, reference flags are faster; above it, training pays for itself in saved regeneration.
• Keep a canonical reference image and never regenerate it. Your hero image is the anchor. If you improve it, re-derive everything, or you will have two subtly different casts.
• Build the turnaround before the expressions. Pose variation is where identity breaks; solve it first, then vary expression on a locked pose.
• Disclose accurately. If you ship AI-generated character art, Steam and itch.io both require it. Keep a manifest of which assets were AI-generated and with what tool — this doubles as your consistency audit trail.
• Budget for cleanup. Assume 25–30% of output needs human correction. Plan the artist's time accordingly rather than assuming AI removes the role.

Outlook

The trajectory is clear: identity conditioning is getting cheaper and more reliable. Midjourney's reference handling improved materially between V6 and V7, and the open-source side is converging on adapters that hold identity across pose and lighting without per-character training. Within the next year, expect reference-based consistency to match what a small LoRA achieves today, which will push training down to only the most-reused heroes.

The unsolved problem is the character sheet as a format. No current tool understands that a turnaround, an expression sheet, and a prop sheet are one coherent document. You still assemble it by hand. That is where the next wave of tooling will land — and until it does, the studios that win are the ones treating consistency as a pipeline problem, not a prompt problem.