Why "same face" is the specific hard problem
AI image generators don't actually understand faces. They understand pixel patterns.
When you prompt "a woman at the beach," the model samples from an enormous latent space of pixel patterns associated with "woman at beach" training data. Which specific face it lands on depends on the random seed, the prompt vocabulary, the sampler, and dozens of other factors. Generate the prompt twice with different seeds and you get two different women — both plausible interpretations of the prompt, neither connected to the other.
Reference-image features (Midjourney --cref, DALL·E reference upload, Nano Banana input images) bias the sampling toward a reference but don't lock to it. The model is still sampling freshly; the reference just pushes probabilities slightly. Over a set of 10-20 shots, you get 10-20 different women who are vaguely similar — not the same person reliably.
For one-off creative work this is fine (generate "a woman at the beach," pick the best, move on). For anything shaped like "I want a specific character — same face, many scenes," the sampling-fresh-every-time problem is the dominant frustration.
The three mechanisms (plain English)
Three technical approaches exist for making the same face appear across many generations:
1. Reference image. Upload a photo of the target face, tell the model to use it as a reference, hope the output matches. Mechanisms: Midjourney's --cref flag, DALL·E's image reference upload, Nano Banana's input-images array, ComfyUI's IP-Adapter node. Fast setup (no training). Consistency is biased but not locked — the face drifts across generations, more on larger scene differences.
2. LoRA training. A LoRA is a small model file that teaches the base AI model what one specific face looks like, from 15-25 reference photos. Once trained, every generation using the LoRA locks identity to that face. Slow setup (20-40 hours for a non-developer learning Kohya, or 10 minutes via a hosted trainer with safe defaults). Consistency is reliable once trained.
3. Per-persona pre-trained. Someone else already trained the LoRA for you. You pick a persona from a roster, every generation of that persona uses the pre-trained model. Zero setup for the user. Consistency is reliable. This is what AI companion apps with curated personas do (Sloane's 80+ hand-curated women each have their own trained model); it's also what AI companion apps' custom-persona builders automate (you upload 1-5 photos, the system trains the model for you in ~10 minutes).
What each tool actually does
| Tool | Mechanism | Setup time | Consistency across 20 shots |
|---|---|---|---|
| Midjourney v7 | Reference image (`--cref`) | None | Medium — drifts across larger sets |
| DALL·E 3 / GPT Image | Reference image upload | None | Low |
| Nano Banana (Gemini 2.5 Flash Image) | Reference image (up to 3) | None | Medium — stylistic bias not identity lock |
| ComfyUI + IP-Adapter | Reference image | 4-20 hrs setup | Medium |
| ComfyUI + Kohya-trained LoRA | Trained LoRA | 20-40 hrs setup | High |
| Hosted LoRA trainer (Replicate, Fal) | Trained LoRA via API | 2-4 hrs integration | High |
| Sloane custom-persona builder | Per-persona LoRA auto-trained from 1-5 photos | ~10 minutes | High |
| Sloane curated personas (80+) | Per-persona LoRA pre-trained by Sloane team | Zero (just pick a persona) | High |
The left-side cluster (reference-image approaches) is faster to set up but doesn't solve the problem reliably. The right-side cluster (LoRA-based approaches) does solve it but requires either technical setup time or using a service that productizes the training.
What "per-persona LoRA auto-trained" means in practice
The AI companion app approach to character consistency is to productize the LoRA training process so end users never touch it.
Specific example: Sloane's custom-persona builder. You upload 1-5 reference photos of the person you want. The system handles everything downstream — dataset preparation, Kohya configuration, GPU allocation, training iteration, validation, model file storage. Average time from upload to usable trained model: ~10 minutes. From the user's side, it's "upload photos, wait for a notification, start generating."
What you get after training completes: every image generation on that persona uses the trained LoRA. Her face is locked across every photo, every outfit, every setting, every pose. The same woman at the beach is the same woman at the gym is the same woman in a sundress — not approximated per-generation, but reproduced from the trained model.
Trade-off: the custom persona lives inside the Sloane product. You can't export the LoRA file to use in ComfyUI (that's a trade for the ease-of-use). If you specifically need the trained file for your own creative pipeline, hosted LoRA training services (Replicate, Fal) give you the file; the Sloane approach gives you a persona you use inside the Sloane product.
Where each tool loses
Honest acknowledgment of what each option can't do.
Midjourney + --cref. Doesn't lock identity. Fine for stylistic consistency across a few related shots; falls apart across a lookbook-sized set. No API for workflow automation.
DALL·E / GPT Image reference. Lower consistency than Midjourney's --cref. Narrower content policy (refuses more categories than Midjourney).
Nano Banana reference images. Google's own documentation describes the feature as "stylistic reference," not identity preservation. Drifts especially on bigger prompt changes.
ComfyUI + IP-Adapter. Mid-tier consistency. Significantly better than naked reference-image biasing. Still inconsistent across larger sets. Setup requires ComfyUI learning curve.
ComfyUI + Kohya LoRA. Highest ceiling if you have the time to learn the stack. Longest setup. First few LoRAs will underperform until you develop training intuition.
Hosted LoRA trainers (Replicate, Fal). API-first, developer-oriented. Still requires dataset curation on your end. Not a consumer UI.
AI companion apps' custom-persona builders. Scope-limited to the AI companion use case. The trained persona exists inside the app, not as a standalone model file you can take elsewhere. If you want the trained LoRA for your own pipeline, hosted trainers are the better choice; if you want the persona for AI companion use, the builder's productized flow is dramatically faster.
The honest "which tool for which situation" answer
Match the tool to the use case:
For one-off creative work (you want a cool image, don't need the same character across many shots): Midjourney for freeform creative, DALL·E if you already pay for ChatGPT, Nano Banana for Google ecosystem workflows. All three are faster than any character-consistency route.
For "same character across a few related shots" (small-set creative work, under ~10 shots): Midjourney's --cref gets you most of the way with the least setup friction. Diminishing returns past a dozen shots.
For "same character across many shots" with technical investment acceptable: ComfyUI + Kohya-trained LoRA is the maximum-control answer. 20-40 hours of learning curve. Full flexibility over the output. Right if the tooling itself is interesting to you.
For "same character across many shots" without the technical investment: AI companion apps' custom-persona builders. Sloane productizes the training as a 10-minute flow. Narrower scope (AI companion use case) in exchange for dramatic ease-of-use improvement.
For "I want a pre-trained character I don't have to build myself": AI companion apps' curated rosters. Sloane's 80+ hand-curated women each have per-persona models already trained. Zero user setup; pick a persona and start generating with locked identity.
For developers building character-consistency into a custom product: Replicate or Fal's LoRA training APIs. Pay-per-training, programmable, abstracts the Kohya complexity while keeping developer control.
