Style-Prefix Architecture

You have a pipeline that generates many images, and a later stage that reads those images as references — for camera framing, layout, composition, not for style. You attach the image. The downstream model picks up everything: framing, layout, and the style you didn't want it to copy. Style bleeds into the next stage's output. The reference contaminated the thing it was meant to inform.

The fix is to make the reference class stylistically uniform by construction, so the downstream model can't confuse "the style I see here" with "the style I should produce." Every prompt in the class begins with the same prefix string. Outputs all look the same stylistically; they differ only in content. Style becomes a constant, not a variable — and a constant carries no information, so downstream readers naturally ignore it.

This is the style-prefix architecture: every prompt in a class is prepended with an identical style-string, turning the class's outputs into a neutral, interchangeable visual vocabulary. The canonical case is storyboard generation in an AI video pipeline. Every storyboard prompt — across every project, every shot — is prefixed with the same ~50-word style string:

traditional hand-drawn storyboard frame on white paper, clean black ink line art with selective red accent lines for key action and focal points, minimal shading using hatching, professional film storyboard sketch style, no color except black white and red

The shape

Any prompt in the class:
  [FIXED STYLE PREFIX, ~50 words]
  +
  [shot-specific description, variable]

Any output in the class:
  Looks like every other output in the class, stylistically.
  Differs only in content.

Why the fixity matters

A class of outputs that all look stylistically identical becomes a neutral reference vocabulary downstream stages can consume as composition information without being contaminated by style.

Concretely: rendered storyboards attach as vision references to a later stills-generation stage. The stills model is instructed to read them for camera framing, angle, and composition — not to copy their style. Because every storyboard frame across every project looks the same (hand-drawn, black-ink, red accents), the model can reliably separate "this frame teaches me about composition" from "this frame teaches me about style." If storyboards varied stylistically, the model wouldn't know which dimension to extract.

The fixed prefix is what enables the downstream reference-use discipline.

When to use it

• When a class of outputs will be consumed as reference by a later stage. The class needs a recognisable, stable identity.
• When style variance would contaminate the intended downstream use. If style varies, downstream stages can't cleanly separate "style from this ref" vs. "composition from this ref".
• When cost-per-output is a concern. Rendering all outputs in a cheap, fast style (line art, wireframe, storyboard) before committing to expensive final renders is the canonical cost saving.

When not to use it

• When the class is the final deliverable. Fixed-prefix outputs all look the same; if the user wants aesthetic variety, this architecture fights them.
• When style is one of the dimensions being explored. If style is a creative variable, fixing it defeats the purpose.

Failure modes

• Prefix ignored under temperature. Some models weakly honor long prefixes when temperature is high. Counter: keep the prefix short (~50 words) and front-loaded; test that the style actually lands.
• Prefix drifts over time. Maintainers tweak the string project by project and consistency erodes. Counter: store the prefix as a single constant, reuse verbatim across projects.
• Downstream stages don't actually separate style from composition. The architecture's value depends on downstream discipline. If the stills stage copies the storyboard style instead of reading composition from it, the benefit is lost. Counter: downstream system prompts must explicitly forbid style copying.

Generalises

• Wireframe-first UI design generation. Every wireframe looks identical (grey boxes, placeholder text); downstream stages read them for layout, not visual polish.
• Flat-vector illustration styles for iconography systems. A fixed palette + line-weight prefix across all icon prompts.
• Uniform diagram style across documentation. Every architecture diagram follows one prefix; readers process them as information, not as art.

The thread running through every case: when a class of outputs has to be read rather than admired, fixing its style is what makes the reading possible.