u/jeffbradshaw

It's not a prompt generator. It's a way to actually test whether your current MJ setup holds up — instead of assuming it does because one batch looked good.

What would actually convince you a setup is reliable? One clean batch never has, in my testing. What's your bar?

When v0.5 lands, the real question I want answered isn't "did you like it" — it's "did using it change how you'd test your own setup." That's the thing I'm actually trying to teach.

Opening the Full Guide provides an option to provide your feeback. This will help shape PRZEM Art Director Pro.

But "looks clean in one batch" and "actually holds" are two different claims — and most of us never test the gap between them.

Building something that walks you through testing that gap yourself. Releasing it soon — and I genuinely want to know if it teaches what it's supposed to.

While testing multi-figure scenes in Midjourney, I kept treating --sref and --sw as look controls.

That was only partly true.
The style stayed consistent. The black-and-white look held. The illustration language held. The visual identity was stable.
But the figure count still failed.
Same scene. Same roles. Same intended structure.
In some runs, three figures collapsed into two. In others, one figure absorbed another. Sometimes the observer disappeared entirely.
The mistake was assuming that if the style was consistent, the scene was controlled. It wasn't.

What the tests showed:
--sref does not only bring a look. It can also bring latent composition tendencies.
--sw does not only control style strength. It also controls how strongly those tendencies enter the scene.
So when you increase --sw, you may not just be increasing the look. You may also be increasing the pressure of whatever figure spacing, pose logic, cropping habits, or composition bias came with that SREF.
That matters a lot in multi-character prompts.

The working model we're using now:
--sref = visual reference + latent composition tendencies
--sw = strength of those tendencies
prompt = explicit structure
--no = penalty against known failure states
Once we separated those systems, the results got easier to diagnose.
If the look is wrong, adjust the look layer. If the figure count is wrong, fix the scene architecture. If the model keeps collapsing the same way, name that failure state and block it.

The big lesson:
A style control can still affect structure. And a good-looking SREF is not automatically a controllable SREF.
That's why we've started testing SREFs not just by appearance, but by whether the scene survives them.

Has anyone else seen --sref or --sw change more than just the look?

Most people use --no wrong. It's not an exclusion tool. It's a structure tool.

If you've been using --no to block unwanted elements — wrong background, wrong colors, stray objects — you're using it correctly but incompletely.

We found something different while testing multi-figure scenes systematically using the PRZEM scoring system.

When figure count kept failing — MJ collapsing three figures into two, or merging characters — we tried --no two figures, single figure, solo, duo and the failure states stopped.

We weren't excluding objects. We were excluding failure modes.

That's a different use case entirely.

What's actually happening:

MJ has default tendencies for certain scene types. Ask for a group and it wants to simplify. Ask for complexity and it looks for the nearest familiar pattern to collapse it into.

--no applies a mathematical penalty. If you name the failure state, you penalize it before it happens.

This reframes the parameter entirely. It's not about what you don't want in the image. It's about which behavioral defaults you're blocking.

The second finding — style vs. structure:

While testing this, we confirmed something we'd suspected: look controls and structure controls are completely separate systems.

Look controls — sref, sw, style language. These determine how the image feels.

Structure controls — figure count, positional language, spatial anchors, --no as a behavioral block. These determine what the scene actually contains.

Most people treat these as one system. They're not.

We proved it across three scored tests. The sref held beautifully in every condition. The style was consistent. The figure count failed every time — until we stopped trying to fix it with style controls and fixed the prompt architecture instead.

The look and the scene are separate problems. They need separate solutions.

Has anyone else found uses for --no beyond standard exclusion?

Three scored tests. One clear answer.

If you've tried to control multiple figures in MJ you already know the problem — you ask for three, you get two. Or you get three but the staging collapses. We've been testing this systematically using the PRZEM scoring system and today we finally isolated what was actually failing.

What we tested: Same sref code. Same scene. Three conditions.

Test 1 — Style Creator neutral foundation, --sw 100 Test 2 — Style Creator complex foundation, --sw 100 Test 3 — Rewritten prompt + --no parameter, no --sw

What the scores showed: Tests 1 and 2 both failed figure count. The look delivered — the sref held beautifully — but MJ kept dropping or merging figures regardless of style weight.

Test 3: all four images. Three figures. Every time. Contact point held. Wardrobe separation held. Staging held.

What actually fixed it wasn't the sref. It was the prompt.

Two changes did the work:

1. Positional language instead of narrative. We stopped describing action ("two men in a struggle") and switched to spatial anchors ("left: elderly man... center and right: two younger men"). MJ reads position. It interprets narrative.
2. Front-load the figure count. "Three men, full shot." First four words. Not buried in the middle of a description.
3. --no two figures, single figure, solo, duo. Confirmed working in MJ 8.1. Blocks the failure states directly.

The sref and --sw are look controls. They don't fix broken scene structure. Fix the structure first — then apply the look.

That's the finding. Three tests, scored, documented.

I've been running structured validation tests on multi-character Midjourney presets — and the hardest part wasn't the prompts. It was deciding what "this works" actually means.

The framework I landed on:

The unit is the 4-image batch, not the best single image. MJ generates four at a time. If you're picking your favorite and calling it validated, you're not testing — you're curating.

Individual image scoring, not batch averaging. Each image is scored against defined criteria: figure count exact, role clarity readable, silhouette separation, wardrobe distinction, contact/distance holds, scene intent intact. An image passes or fails. You don't average the scores.

Pass threshold: 3 of 4, with zero figure-count failures. A batch where three images hold the relationship and one drops a figure entirely is a different problem than a batch where all four have minor wardrobe drift. The threshold has to account for the type of failure, not just the count.

Baseline environment first. Before testing in any real-world setting, every preset runs in a minimal gray studio — controlled, featureless. It eliminates contamination. Extra figures drawn in by a busy background. Lighting that obscures separation. If a preset can't hold in a clean environment, it's not ready.

This methodology is what let me retire one preset entirely (it triggered MJ's combat pattern every time regardless of prompt language) and validate four others with confidence.

What does your MJ testing process look like — or are you mostly running until something looks right?

A few weeks ago I posted about using a spatial logic approach to fix MJ's multi-character consistency problem. That post hit over 1,600+ views so I figured the problem resonated.

Since then I've been cleaning up the tool I built to solve it and today I'm releasing a public test build.

PRZEM Stage v0.4 — a blocking tool for three-character AI image scenes. You place figures, set body orientation and gaze direction, choose a relationship preset, and export a Midjourney-ready prompt.

Four validated relationship presets: Push, Witness, Triangle, Support.

A few things I learned building and testing it:

The prompts are deliberately long — MJ V8.1 has a hard 150-token limit (roughly 100–120 words) and auto-shortens anything above it. Because the most critical spatial logic is front-loaded, the relationship still holds after trimming. 3 out of 4 images in my latest Support preset batch held figure count, spatial separation, and role clarity.

Body and gaze sliders are in but labeled experimental — they influence prompt language, not guaranteed body accuracy. Validation testing on those controls is planned for the next release.

The tool is free to use. There's also a short feedback form built in — I'm genuinely interested in whether the presets hold for other users or just my workflow.

jbradshaw.design/PRZEM_Stage_v04_public

What preset would you test first?

I've been building a structured Midjourney workflow for multi-character scenes — controlled presets, scorecards, seed tracking, batch validation. The goal: figure out what MJ can actually hold consistently, not just what looks good once.

The Support preset — one character physically supporting another — scored 0/4 on first pass. Every image either merged the figures, dropped one entirely, or added random bystanders. Standard fixes (more descriptive language, stronger relationship cues) didn't move the needle.

The recode that worked: switched to a seated/upright block instead of standing figures, removed the blocking map entirely, added wardrobe specifics, and put explicit negatives on the failure patterns I kept seeing. Next batch: 4/4.

What made the difference wasn't more prompting — it was understanding how MJ weighted the spatial relationship. Once the physical logic was right, the rest followed.

Has anyone else found that MJ responds better to physical/spatial language than relational language for multi-figure scenes?

Read the Case Study https://www.jbradshaw.design/przem-case-study

https://preview.redd.it/43s7qp2l343h1.png?width=1200&format=png&auto=webp&s=8439689cbd6bbaf557fbe3af5de123df8dc4702d

I didn’t build PRZEM to make better AI images.
I built it to find out what could actually be controlled.
Multi-character scenes are where AI image generation starts to break down: extra figures appear, roles collapse, bodies merge, and the scene quietly becomes something else.

So I started testing it like a production problem.
One 4-image batch at a time.
One scorecard at a time.
Figure count. Role clarity. Spacing. Contact points. Scene intent.

The most useful finding came from a failure.
One preset went 0/4 because the prompt structure itself was causing Midjourney to invent an extra figure. Once that structure was removed and the pose was anchored more clearly, the same preset went 4/4.
That changed how I thought about the project.
This wasn’t just prompting anymore.
It was art direction with evidence.

Case study:https://www.jbradshaw.design/przem-case-study

I didn’t build PRZEM to make better AI images.
I built it to find out what could actually be controlled.
Multi-character scenes are where AI image generation starts to break down: extra figures appear, roles collapse, bodies merge, and the scene quietly becomes something else.

So I started testing it like a production problem.
One 4-image batch at a time.
One scorecard at a time.
Figure count. Role clarity. Spacing. Contact points. Scene intent.

The most useful finding came from a failure.
One preset went 0/4 because the prompt structure itself was causing Midjourney to invent an extra figure. Once that structure was removed and the pose was anchored more clearly, the same preset went 4/4.
That changed how I thought about the project.
This wasn’t just prompting anymore.
It was art direction with evidence.

Case study:
https://www.jbradshaw.design/przem-case-study

I didn’t build PRZEM to make better AI images.

I built it to find out what could actually be controlled. Multi-character scenes are where AI image generation starts to break down: extra figures appear, roles collapse, bodies merge, and the scene quietly becomes something else.

So I started testing it like a production problem. One 4-image batch at a time. One scorecard at a time. Figure count. Role clarity. Spacing. Contact points. Scene intent. The most useful finding came from a failure. One preset went 0/4 because the prompt structure itself was causing Midjourney to invent an extra figure. Once that structure was removed and the pose was anchored more clearly, the same preset went 4/4.

That changed how I thought about the project.
This wasn’t just prompting anymore. It was art direction with evidence.

Case study: https://www.jbradshaw.design/przem-case-study