A Consistent Visual Language

A single beautiful render is easy. The hard, professional skill is a set - six or eight images of the same project that clearly belong together. When they do, the presentation reads as a resolved scheme seen from many angles; the viewer trusts that a single design mind is behind it. When they do not - when the entry shot is a moody dusk photograph, the interior is a bright watercolour, and the facade is a glossy noon render - the eye reads incoherence as indecision, and no amount of individual quality rescues it.

This matters because a project is almost never sold on one image. A client, a jury or a planning board sees a board, a deck, a set. The set's job is to build a single, convincing world, and consistency is the load-bearing quality. It is exactly the same instinct as a material palette or a typographic system: the discipline is in the repetition, in choosing constants and holding them, not in the flourish of any one element.

AI makes coherence harder than traditional rendering, because every generation is a fresh roll of the dice - new light, new mood, new incidental detail, unless you actively pin them down. Left to its defaults, a text-to-image tool produces a gallery of strangers. So consistency with AI is not a happy by-product; it is something you engineer, using three families of lever - seeds, references, and trained styles - that this lesson takes in turn. Master them and you can hand over a set that looks authored, not assembled.

The seed is the random number that sets the model's starting noise - the initial roll before denoising begins. Same seed plus same prompt plus same settings gives you the same image every time; change the seed and you get a completely different one from the same words. This is the most fundamental consistency lever, and most beginners never touch it because tools default to a random seed on every run.

Once you can fix the seed, two powers open up. First, reproducibility: you can return to an image you liked and get it back, or hand a colleague a seed and prompt and have them see what you saw - AI stops being a slot machine you can never replay. Second, and more useful for coherence, single-variable iteration: with the seed locked, any change in the output is caused by the one thing you changed in the prompt, not by a new random roll. Swap 'morning light' for 'dusk' on a fixed seed and you see the same scene at dusk, not a different building at dusk. That is the difference between comparing and gambling - the same discipline Module 1.4 taught for prompts, now anchored by the seed.

The determinism under this is real: with a deterministic sampler (DDIM and its relatives), the seed fully pins the trajectory from noise to image, which is why the same inputs reproduce the same output. For a coherent set, you exploit it by building your images from a seed family - a small handful of seeds you know give the composition and quality you want - and reusing them across the project rather than rolling fresh each time. The seed is the quiet backbone of consistency: lock it to compare fairly and to make a set that shares a visual DNA.

Seeds pin the roll; style references pin the look. Modern tools let you hand the model an image and say 'make new things that look like this', independent of the seed. In Midjourney this is the --sref flag (style reference) and --cref (character/subject reference); in the Stable Diffusion world it is the IP-Adapter, which injects an image's style into generation alongside the text prompt. Either way, you are conditioning on a reference image rather than trying to describe a look in words - and a picture carries nuance no adjective list can.

For a project set, this is the workhorse. You establish one image whose mood, palette and rendering feel right - the visual key of the project - and then use it as the style reference for every subsequent generation. The entry shot, the interior, the courtyard, the facade all inherit the same atmospheric fingerprint even though their subjects differ. Where a text prompt struggles to reproduce a specific warmth or grain across ten images, a style reference just shows the model the target, and consistency follows far more reliably.

The craft is in choosing what the reference controls and how strongly. Most tools let you dial the style weight, so you can carry a strong family resemblance without every image collapsing into a clone of the reference. Combine this with a fixed seed family and locked prompt constants (medium, light, camera) and you have layered three independent consistency controls - roll, look, and description - each reinforcing the others. That stack is how a set stops looking like it was made by eight different people on eight different days.

When a project (or a studio) needs a look reused heavily and precisely - beyond what a single reference image can hold - you move up to training a style into the model. These are the fine-tuning techniques from Module 2/3, applied here in service of coherence. A LoRA (low-rank adaptation) is a small, efficient add-on you train on a set of images so the model reliably produces that style or subject on command. DreamBooth fine-tunes the model to reproduce a specific subject or look from a handful of examples. Textual inversion learns a new 'word' that summons a particular style you can then drop into any prompt.

The payoff is a style you can summon at will across an entire project, or even across every project a studio does, with far tighter consistency than references alone. Train a LoRA on your practice's preferred rendering - its palette, its light, its material sensibility - and every designer can invoke the house style with a token. For a single large project with dozens of images, a project-specific LoRA can hold the visual language rock-steady from concept board to competition panel. This is the heavy machinery of consistency, and it is how serious visualisation teams keep a signature.

The honest trade-off is effort and data. Training needs example images, some compute, and a willingness to iterate - it is overkill for a quick concept and worth it for a sustained body of work. The rule of thumb stacks cleanly: fixed seeds for reproducibility, style references for carrying a look across a set, trained styles for reusing a look across a whole project or studio. Reach for the lightest lever that achieves the coherence you need, and escalate only when the volume of images justifies it.

Levers are nothing without a system to deploy them. A coherent set starts with a decision, not a generation: write a short visual-language spec for the project and lock the constants before you make a single hero image. Name the medium ('architectural photograph'), the light ('soft overcast, morning'), the palette ('laterite, teak, lime plaster'), and the camera ('35mm, eye-level, f8'). These are the things that stay fixed across every image; only the subject changes shot to shot.

Then work like a photographer on a shoot, not a tourist snapping at random. Draw up a shot list - entry court, living volume, courtyard at dusk, facade from the street, one detail - so you know the set you are building before you build it. Establish your visual key image, capture its seed and set it as your style reference, and generate every subsequent shot with the constants locked and the reference carrying the look. Vary only the one thing that should vary: the subject and viewpoint. This is the practical meaning of the earlier figure - lock the constants, vary the subject - and it is what turns eight generations into one project.

Hold two habits and the whole thing compounds. First, keep a small project style sheet: the locked prompt constants, the seed family, the reference image, the LoRA token if you trained one - so anyone on the team can add a consistent image to the set months later. Second, review the set together, never image by image: lay the six out side by side and cull anything that breaks the language, however good it is alone. Consistency is a property of the set, so judge it at the level of the set. Do that, and your AI imagery stops looking like a lucky gallery and starts looking like the considered visual identity of a resolved design - which, across this whole module, is the entire point.