The Design Compiler: the model never draws

Feed it a few dozen reference designs that share a feel. It reads them, writes down what makes them cohere as a validated JSON document, and then renders any brand's campaign through that document, as real vector artboards a designer can open and edit.

The architecture turns on one decision. Image-to-SVG models produce icon-grade output, not branded layout systems with typography. Raster models produce raster, and vectorising raster produces path spaghetti. So no model in this system emits vectors: a vision model reads references and emits a StyleSpec, a schema-validated description of a design language, and a deterministic SVG engine compiles that spec into artboards.

Three things follow. Design intelligence lives in validated JSON rather than a model's weights, so swapping models is a config change. The deterministic half works with no AI at all; a designer can hand-author a house style and every client renders through it. And when an artboard looks wrong, you can read the spec and tell whether retrieval, compilation, or rendering was at fault.

The reading half turns images into a design language: an annotator tags each reference against a designer-owned vocabulary, a corpus stores them behind a human confirmation step, and a style compiler blends weighted references into a StyleSpec, validated against the schema and the engine's capability manifest, deterministically repaired, re-asked at most once.

The writing half turns that language into artboards. A layout generator writes one spec per post per format in zone language (anchor, archetype, slots, never coordinates), so it may be adventurous because it cannot break anything. The SVG engine is the enforcer: it substitutes and clamps rather than rejecting, logs every intervention, and produces byte-identical output for the same inputs. A critic judges the render beside the references and proposes patches, each one applied, re-scored, and reverted unless it improves the result.

Nothing crosses between the halves except validated JSON. The brand kit (colours, typefaces, assets) joins only at render time, which is why one StyleSpec renders every client. Text legibility is a hard guarantee, not a hope: contrast is checked against every region of the background, support text never leaves the artboard, and bad art direction produces boring artboards, never broken ones.

That is the actual experiment. Design is not arbitrary. It runs on rules about hierarchy, contrast, rhythm, proportion and balance, and if those rules are real, some of them should be expressible as parameters. This system is a test of how far that goes, and an honest record of where it stops.

The core is six continuous energy axes (volume, density, order, motion, era, polish), each running from whispered to screen-filling, airy to packed, improvised to gridded. A reference is read as a point in that space; a compiled style is a weighted blend of the references it came from. Every field in the contract has to pass two tests before it is allowed to exist: describable, meaning a vision model can reliably infer it from an image, and actionable, meaning the engine changes its output because of it. A field that fails either is one the compiler will fill in while nothing happens, which is worse than not having it.

Some rules survive the translation as hard guarantees: the contrast floor, the bounds, determinism, clamping. Others only ever become approximations standing in for judgement: the energy axes themselves, rhythm scored as variance, imagery weight as area. The useful finding so far is not that design can be measured. It is that the places where measurement breaks down are specific, nameable, and consistently the places where taste actually lives.

Every part of it that produces something worth looking at is downstream of a person making decisions. The taxonomy is designer-owned, with a named human steward. Ground truth for the energy axes comes from two people annotating blind; disagreement is the signal, and it is far cheaper to learn from thirty images than three thousand. Taste enters at selection: choosing which work is worth learning from is the whole job, and nothing automates it. And the system is built to decline. When no asset clears the confidence bar it places nothing and leaves a labelled slot for a human, because a wrong image erodes trust faster than an empty frame.

Everything the model decides is reviewable: compiled specs open in a configurator generated from the schema itself (add a field to the schema and its control appears with no UI code touched), with each section's stated reasoning beside its controls.

The honest framing: it scales a design language. It does not originate one. A studio still decides what the work should feel like; this makes that decision reusable across every client, format and campaign that follows. And the evaluation protocol is deliberately stricter than the build: numbers produced against a synthetic corpus are treated as plumbing tests, not results. Saying so is part of the design.