Software engineers call it non-deterministic behavior: the same input produces different outputs. In traditional software that is usually a bug, and in generative AI it is the default.

In brand design it is unacceptable.

With coding agents and generative models, a brand designer can spin up a banner generator, a layout engine or a copy assistant in an afternoon, and that power comes with a cost most designers underestimate.

If you wrap an LLM in a UI and hand it to a marketing team, you have not built a design tool. You have built an entropy machine, because you have injected probabilistic behavior into a discipline that survives on consistency.

This is the era of the designer-builder. Your job is no longer to produce assets. It is to build the constraints that force machines to behave deterministically.

The conflict: entropy vs brand

Generative models are high entropy: they drift and improvise. Brand systems are low entropy by definition, because they depend on repetition, recognizability and trust.

That tension is why most AI design tools fail in production. A wrapped generator is not a workflow. It is a slot machine: occasionally impressive, mostly noisy, impossible to scale.

So your job as a brand designer is not to unleash AI. It is to contain it.

Designing rule-based creative systems

Containing it starts with a shift in mindset. By hand, you nudge spacing and resize type on instinct because you understand the aesthetic goal. Machines do not infer intent reliably. They respond to structure.

So to make AI useful in brand production, you translate aesthetic judgment into explicit rules a machine can enforce. That is not a loss of creativity. At scale, it is the only way creativity survives.

The constraint-first technique: controlling hallucination

The first rule is never to generate from a blank slate, because it raises variance, hallucination and correction cost, and pruning afterwards is expensive and unreliable.

Production systems avoid that with a constrain → generate → render loop.

  1. Constrain. Encode your brand logic as structured data: style objects, schemas, layout rules, palette, composition, negative space, negative prompts, prohibited behaviors.
  2. Generate. Use that structure to force the model’s hand, and only where variability is acceptable.
  3. Render. Deterministic code produces the final output, so the generator never touches the physics of the layout.

The constraints are the mold and the model is the liquid. You are no longer trimming the hedge after the fact; you are pouring material into a form you already built, and the constraints determine the result.

The hierarchy of constraints

Not all constraints are equal, so in an effective system you layer them.

Hard constraints are the physics: immutable, and in most brand systems they live in templates.

  • The logo always anchors bottom-right with 20px padding.
  • Text never overlays the subject’s face, so it is truncated past 50 characters.
  • Headlines are always Noto Sans Bold.

Implementation: autolayout, CSS Grid, absolute positioning, masks, fixed and dynamic containers. The model supplies content and the system enforces structure, with no override.

Soft constraints are the vibe. They keep stylistic variance inside a defined range, and you manage them through the model’s hyperparameters and its context.

  • High variance for ideation, low variance for compliance.
  • Generate headlines by mimicking proven patterns rather than abstract traits like “witty”.

Implementation: temperature tuning and few-shot examples at the system level, so the model imitates patterns you supply instead of inventing a tone.

Elastic constraints are the variance. This is the adaptive part of the system, where it responds to real data without breaking.

  • Short headlines scale up in size and weight, and long headlines scale down.
  • If the marketer picks the “Luxury” template, populate only with approved assets from the /Luxury folder, or generate images only from the luxury.json specification.

Implementation: conditional logic and if/else rules, so the layout adapts to the data without drifting.

The headless mindset

Once the logic is in place, the question is what the marketer sees, and here designers keep making the same mistake: they try to build design tools. Marketers do not want a lite Figma or a canvas. They want outputs, because what makes them successful is data.

So you decouple input, logic and output.

  • Input: a form, a spreadsheet, dropdowns. This is the only thing the marketer touches, and all they put into it is content.
  • Logic: a black box of your code, your constraints and your taste, encoded.
  • Output: the rendered assets.

Remove the canvas and you remove the error. If you never give them a font picker, they cannot use Comic Sans.

From designer to architect

The designers who win will not be the ones handcrafting the best single asset. They will be the ones building systems that generate ten thousand on-brand assets without supervision.

You are designing the bakery now, not just baking bread.

AI and code are materials, like grids, type systems and color theory before them. The difference now is scale, and scale demands architecture.

First published on replikit.substack.com. Topics: designer-builder, brand systems, AI.