One place for design rules
A company selling a website builder that designs pages with an AI model has one problem to solve before it has a product. Left to itself, the model makes every site look the same. The same tall opening banner, the same centered headings, the same neat row of icons, one customer after another. A gallery of machine-built sites has a flat sameness to it, a single template showing through all of them. For a company whose whole point is that a customer gets to look like themselves, that sense is fatal. They are paying to stand out, and the machine keeps making them blend in.
Where the design lived
The cause is where the design decisions were living. To get good-looking pages out of a model, the fast thing to do is tell it what good looks like, right in the instructions it follows. Heroes should be tall. Headings should be centered. Use a row of icons rather than a plain list. Never put the same background twice in a row. Each of those is a defensible call on its own, and stacked together they are a house style, written into the one set of instructions the model reads every time it builds a page.
One set of instructions, every customer built from it, so every customer gets the same house style. The sameness was not the model being dull. It was the model being obedient to the one house style it had, the same for everyone, because there was only one copy of it and everyone was built from it.
The house style ends up there by the path of least resistance, not by stupidity. You build the product for a first customer, or for a demo. The choices that make that one page look good get written into the instructions, because that is the quickest way to make them stick. The next customer inherits them. By the tenth customer the instructions are a full aesthetic, nobody decided it on purpose, and it is now the look of the product.
Why one look is worse than a plain one
A single house style would be merely bland if it were right for everyone, and it is not. A law firm and a skate brand should not get the same page, and a style baked into the instructions hands them one anyway. The choices that make the first look right make the second look generic, and there is nothing for the customer to adjust, because the design is not data they can reach. It sits inside the instructions, identical for all of them.
A law firm and a skate brand should not get the same page, and a style baked into the instructions hands them one anyway.
Sameness costs more than a chance to stand out. It reads as low effort. A visitor who has seen the same machine-made shape a dozen times reads the thirteenth as one more page nobody bothered with, and a page that looks like nobody bothered is a page that loses the visitor before a line of it is read. For the customer paying for the site, that is the real loss, their own customers put off by a look they never chose.
The step meant to catch bad pages made it worse. The builder grades every page against a standard before it ships, the way a careful shop reviews work before it goes to a client. That grader was holding the same house style as its standard. So a page that broke from the built-in style to match an unusual brand was marked down for breaking from it. The customer's own look registered as a flaw. The builder was doing worse than failing to express a brand. It was correcting away from one, back toward the average, and calling that correction quality.
Take the design out and give it to the customer
The fix was to pull the design rules out of the instructions completely and move them somewhere the customer owns. Every hardcoded opinion about how a page should look came out of the prompts and the code and went into one per-customer object, the design brief, a plain statement of how that customer wants to look. It says their headings sit left, their palette runs muted, their pages want room rather than density. It is not spread across a dozen instructions. One object, one place, belonging to the customer.
Finding all of it was most of the work, because the design does not live in one tidy spot. The rule that heroes must be tall was in the layout instructions. The rule that headings center was in the styling. The preference for a row of icons over a plain list was a bare constant in the code, and the grader's rubric held a dozen more. Every one had to come out, because a single opinion left hardcoded is one more rule the customer cannot change. It was a hunt across the whole builder, not a single edit, run until the instructions held no design of their own.
The builder makes a page in a sequence of steps, and two of those steps make the visual calls, one laying out the page and one styling it. Afterward, both stopped carrying any design rules of their own and read them from the brief instead. The model no longer holds an idea of what looks good in general. It holds what looks good for this one customer, because that is the only design in front of it when it builds.
There is a name for this move, and engineers make it everywhere else. A database address or a feature flag goes in configuration, outside the code, because two deployments need different values. Design is configuration too. The mistake was treating an aesthetic as a fact about the software instead of a setting that varies by customer.
Where the design lives
Inside the prompts and code, one copy
One object the customer owns
Every customer gets
The same look
Their own look
The customer can change it
No, it is not data they can reach
Yes, it is their own object
The grader judges
Conformance to the house style
Consistency with the brief
The grader changes its question
Moving the design out was half of it. The other half was the grader. It stopped asking whether a page matched a house style, because there is no house style left to match. It started asking whether a page matched the brief. Consistency with the look the customer declared, in place of conformance to a universal one.
That flip changes what quality even means for the builder. A muted, restrained, left-aligned page is no longer a fault to be corrected. It is exactly right when the brief calls for restraint, and it is a fault only when it drifts from what the brief says. The grader went from enforcing one fixed idea of good to enforcing each customer's own, which is the only kind of enforcement that helps a customer instead of fighting them.
Two sites the builder makes put the point past argument, because they could hardly look more different and the same machine makes both. One is this blog, a personal, text-first place built for reading, spare and quiet, the design kept out of the way of the words. The other is Giant Context's own site, a product with something to sell, denser and more visual and more confident, the design doing much of the talking. Under one hardcoded house style the builder could make one of them well and the other badly, whichever the built-in style happened to suit. Reading each site's own design brief, it makes both correctly, and the grader passes each for matching its own brief rather than one shared standard. The same builder made two designs that share almost nothing, each right for the site it belongs to.
A check that guards creative work cannot hold a fixed rubric of what is good, because good is not fixed. It is whatever the client asked for. The only durable standard for generated work is fidelity to the intent behind it. Grade against a house rubric and you punish every client whose look is not the house's. Grade against the look the client declared and you finally have a check that stands on their side.
Why this is the product and not a detail
This is the difference between a template mill and a platform. A builder that gives every customer the same look is a template with a text box on it, and there is no lasting business in that, because any model can produce a generic page for free. A builder where each customer's site comes out looking like their brand, because their design is an object they own and the machine reads it rather than overrides it, is something a business pays for and keeps paying for.
The case sharpens at scale. A marketing agency running fifty client accounts is the customer who needs this most, because every one of those clients has to look like itself and none of them like each other. A builder with one house style baked into its instructions cannot serve that agency at all. It can only produce fifty versions of the same site. A builder that reads a per-client brief can hand the agency fifty distinct brands out of one machine and keep each one steady as the client grows. That is a market a template cannot reach.
A competitor cannot copy this in an afternoon, because there is nothing on the surface to copy. It is not a button. It is a decision about where the design lives. A builder that kept its design in the prompts would have to pull all of it out and rebuild around a per-customer object, on a product already serving customers. That is cheap to do at the start and expensive to do later, and doing it early is the whole advantage.
Brand consistency is the expensive, ongoing job a platform can make disappear, by holding a brand in one place instead of policing it across every page, email, and card a company puts out. The design brief is the builder's side of that same object. Holding the brand in one place is what a customer buys. Taking the design out of the generator, so it stops overriding that brand every time it builds, is what keeps it true. And because the design is now one owned object per customer, it is also the part you can grow later, a place to tune each customer's look more finely.
A design to follow, not one to own
The principle travels past websites. Whenever a model does work for many clients, do not bake the good look into the prompt, because one look in the prompt is one look for everyone. Put it in data each client owns, and grade the work against that data instead of a house standard. Then the same model makes each client look like themselves, and the check that guards the work is on their side.
Building something like this
I'm Jesse. I build platforms end to end, and I'm open to work. If this is the kind of engineering you need, get in touch.