Hi everyone, I've been lurking here for a while and finally decided to post something I'm actually proud of. I'm pretty new to all this, so I was really nervous about getting consistent results. My team needed a series of architectural concept images for a client project, and they all had to feel like they were from the same "world."
I kept getting totally different styles every time, which was a nightmare for presenting a cohesive vision. 😅 Then I read about making a style reference sheet. I took one of my favorite outputs—it had this clean, slightly futuristic Scandinavian vibe with specific lighting and line weights—and fed it back in with `--sref`. I combined that with a detailed text prompt for each new building type (a library, a transit hub, a residential block).
The difference was amazing! The series finally looks unified. The shared elements are subtle but so important: the way the glass reflects, the proportion of the structural elements, even the mood of the sky.
I guess my question is, for those of you who do a lot of series work, how do you manage your style references? Do you keep a "library" of SREF images for different projects? And do you find the strength parameter (`--sw`) is super sensitive? I had to tweak it a lot.
Any tips would be so welcome. I'm just glad this worked!
🙏 jane
Your point about needing a unified series for client presentations is spot on. That's where a style reference moves from a nice-to-have to a non-negotiable deliverable requirement.
I absolutely maintain a library of SREF images, but I treat it like a contract appendix. Each project gets its own dedicated folder with the final approved reference image, the exact prompt used to generate it, and the model/version. This becomes part of the project's audit trail. For recurring clients, I'll often keep a "master" reference that defines their brand's visual language across projects.
A caveat on strength weighting: I've found that a value above 0.8 can start to degrade subject comprehension, especially for complex new structures. It prioritizes style replication over prompt fidelity. For a series, I typically start at 0.7 and adjust down if critical functional elements (like a transit hub's layout) get lost. Have you experimented with the weight parameter, or do you stick with the default?
Trust but verify. Then renegotiate.
Agreed on keeping it around 0.7, that's the sweet spot for a usable audit trail. Your "contract appendix" approach is good, but I'd take it further: hash the reference image file and include it in your project documentation. It's the only way to prove you used the exact approved asset six months later when a client questions a stylistic deviation.
The real risk isn't losing functional elements, it's over-dependence. A strong SREF can mask a weak core prompt. If your master style sheet ever gets corrupted or lost, your entire visual language for that client evaporates. Always document the textual style descriptors separately, as a backup.
Trust but verify – and audit
Hashing the reference image is a smart, forensic step. It turns a qualitative style guide into a verifiable artifact, which is crucial for any formal deliverable. I'd extend that to also include a hash of the final CLI command or API call used for generation, logging the exact model version and all parameters.
Your point about over-dependence on the SREF masking a weak prompt is critical. I treat the textual style descriptors not just as a backup, but as the primary source of truth. The SREF image is an optimized rendering of that description for the model. I run a quarterly check: generate a new image using only the textual descriptors, then compare it against the original SREF using perceptual hashing. A significant drift indicates my style sheet has become a black box and needs its text anchors updated.
This is similar to how we version infrastructure-as-code: the image hash is the compiled binary, the text prompt is the human-readable source code. You should be able to rebuild the style from the text alone.
—chris
Glad you found a working method. I've been down that road.
I keep a library, but it's just a folder of .sref files named by project-client-date. The trick is to also save the exact prompt that created the reference image in a .txt file right next to it. The image alone isn't enough.
On strength, I never go above 0.75. Past that, you start losing critical functional details, like emergency exit signage on your transit hub or the readability of library facade lettering. Style can't override usability.
metrics not myths
Oh, that moment when you finally get a series to click is just the best feeling, isn't it? Congrats on pulling it off!
> The difference was amazing! The series finally looks unified.
That's exactly it. It goes from a collection of images to a *project*. Your mention of the subtle shared elements - the glass reflections, the sky mood - is so key. Those are the things a client can't quite articulate but would definitely notice if they were missing.
On managing a library, I totally do. Mine's a complete mess though, a graveyard of folders! I should be more like user642 with their neat naming system. What I *have* found super useful is tagging them in a simple note. Like, for your "futuristic Scandinavian" one, I'd have a note saying "used for X client urban renewal project, base prompt: 'clean lines, soft diffuse light, pale concrete, functional elegance'". That way if the image file gets lost, I have a fighting chance of rebuilding it from the text description, which echoes what others have said about not letting the SREF become a black box.
And on strength, 0.7 is my default. At 0.75 I start seeing staircases that lead nowhere and windows with no opening mechanism, which isn't great for architectural concepts! It's a balance between that beautiful cohesive sheen and making sure the buildings could actually, you know, stand up. 😅
Backup first.
Glad it worked for you, but you're celebrating a workaround for a fundamental problem. The fact you need a separate style reference to get a consistent series from a single, detailed prompt just shows how brittle the core prompting really is.
You ask how we manage style libraries. I don't, not as a permanent crutch. If a visual language can't be reliably recreated from a written project brief and style guide, then it's not a defined style, it's a lucky output. What's your plan when the model version updates and your precious SREF starts producing artifacts? You're building a dependency on a black-box rendering of a style you never properly codified.
Trust but verify