We built 52,488 design variations and blind reviewers still said they all looked the same

What the engine is allowed to vary

The engine that produces decks on this site does not have templates. It has eleven independent design decisions — we call them axes — and it chooses a value on each one per deck. The choice is a hash: FNV-1a over the brand name, the deck title and the axis name. That makes it fixed per deck and reproducible, so a client who re-renders gets the same file back and a measurement taken twice returns the same number twice.

Here are the eleven, with the values each one can take. They are declared in one place, DIALECT_AXES in src/studio/ooxml.js, and every number on this page is derived from that declaration rather than restated beside it.

Six visual worlds sit above the axes and constrain them. A world is an opinion about geometry: a Swiss page does not cut a photograph on a diagonal, so swiss pins that axis. An axis a world leaves unstated is an axis it has no opinion about, and the hash gets the full range.

No panel has ever returned different studios

The method. Take one deck's exact content. Render it three times under three forced axis vectors, deliberately distinct on every axis. Give three judges nothing but the rendered pages — no source, no rationale, no statement of what changed, not even the fact that anything was supposed to have changed. Ask one question: is this one studio's work or three? Take a confidence with the answer.

The judges are language models, not people. Each is a subagent shown only PNGs of the rendered pages. That is the single largest limitation on this page and we would rather state it in the method than bury it in a caveat: none of what follows is evidence about human readers. It is evidence that a reader with no access to the source cannot tell these decks apart, where that reader is a model.

That is eight judge verdicts across three runs. Seven said one studio; the eighth said related family, which is the same answer in a softer voice. Not one said three.

Between the first row and the third, the number of reachable combinations went from 243 to 17,496 — a seventy-two-fold increase. The highest confidence any judge placed on one studio fell from 0.93 to 0.88 to 0.84. The verdict did not move at all. Whatever the extra axes bought, it was not the thing the axes were added to buy.

The first panel's summary, verbatim: One studio, one template, three trim levels… the variation is confined to page furniture on roughly 4 of 13 pages. One judge went further and pixel-diffed the three renders: the journey page, the dark divider and the closing page came back RMS 0.00 across all three voices — not similar, identical. Those pages were bespoke constructions that no axis touched, and no axis count could have revealed that.

Ten decks, measured against each other

Every score above compares our output to external anchors. None of them compares our decks to each other, which is the actual complaint. So we built ten decks across ten trades — a design studio, a restaurant, a law firm, a charity, a startup, an architecture practice, a clinic, a school, a manufacturer, a gallery — each with its own brand palette, its own title, its own page count and its own layout order, and read every number out of the built .pptx rather than out of the plan that produced it. These are fixtures rendered locally in seconds; a real deck goes through a writer and an image pipeline first, and that takes a measured 4m40s at the median over 58 of them.

One control matters: each deck was re-rendered a second time with its measured axis vector forced through the renderer's test override, and the two files compared byte for byte. 10 of 10 were byte-identical, which proves the vectors reported below are the renderer's own choices and not a plausible re-derivation of them.

Read the table from the top and it is a triumph; read it from the bottom and it is the complaint. The eleven-axis vector is different on ten decks out of ten. The page-one shape signature is one of two things across all ten, and page one is the page every reader sees. Eighteen shape names out of a union of 122 appear on all ten decks. One preset geometry — rect — appears on all ten. Three exact x,y coordinates appear on all ten.

The palette row deserves its own sentence, because it is the row most likely to be quoted out of context. Ten distinct palettes is not the engine producing variety; it is the engine passing through the brand colours it was handed. On the one dimension where the output is unmistakably different deck to deck, the engine contributed nothing.

One axis has three values and two drawings

The picture axis is the one the engine treats as most significant — it is axis A, it was the first built, and its diagonal cut is the deck's signature. It has three values. Look at the contact sheet above and count: two decks cut on the diagonal, eight cut straight. Nothing shows the third value at all.

The reason is in the source, and it is not a bug. The function that cuts a picture panel takes a plateable flag, because a floating colour plate reads as a misprint rather than a design; only a real photograph can be inset. There are eight call sites, and two of them pass that flag. On the other six, value 2 falls straight through to value 1's branch and draws the identical rectangle.

So the axis contributes a factor of three to 52,488, and a factor of two to what most pages actually draw. That is one axis. We have not audited the other ten the same way, and the honest reading of this finding is that it is an example of the general problem rather than a measurement of it: a combination count is arithmetic over declared values, and a declared value is not a drawing.

Update, 23 August: the axis that drew two now draws three

The finding above was actionable and it has been acted on. The picture axis now has a third drawing: where a panel is a colour band rather than a photograph — the six call sites that cannot inset — value 2 draws a stepped edge, a rectangle with one corner notched. It reaches the page edge, so nothing shows behind it, and it is neither the diagonal nor the plain rectangle it used to be indistinguishable from.

Measured the same way the original finding was, by forcing each value and reading the geometry back out of the file rather than trusting the code: value 0 draws seven diagonal paths of three line segments each; value 1 draws no custom geometry at all; value 2 now draws stepped paths of five. Before the change, value 2 produced nothing — byte-identical to value 1. That is the gap this page measured, closed.

And the first attempt at it was wrong, which is the more useful half

The same change was first made in a second place as well. Dark pages carry a set of layered planes that were restricted to the diagonal voice, because under the other voices the cut was vertical and a bled plane cut straight reads as an empty picture slot — four reviewers had said so independently. With the edge no longer vertical that objection looked answered, so the planes were extended to the plate voice too.

It destroyed every illustrated page in the deck. Those planes are opaque and painted across the page; where the ground is a generated photograph they went straight over it. A hand-drawn studio interior became a flat red panel with a brown block on it. The build reported its pictures present and correct throughout, because they were — embedded, linked, and underneath.

The check that passed it was the wrong check. Contrast was sampled behind the heading at both voices and came back identical — on a deck built with no images. A picture cannot be covered when there is no picture. The verification proved something true and irrelevant, and was reported as confidence.

The plane change was reverted within the hour and the stepped edge kept. We are publishing the failed half because a page arguing that combination counts hide what a reader actually sees would be a poor place to quietly report only the half that worked.

We measured this wrong twice, in opposite directions

This section exists because a research page that reports only the runs that worked is a brochure. Both errors below were confident, both produced a clean number, and both were wrong about what the number counted.

  384 expressive    axes named: 9
   64 editorial     axes named: 8
   48 brutalist     axes named: 9
   32 documentary   axes named: 9
   16 swiss         axes named: 9
    1 corporate     axes named: 0
sum: 545

  52488 corporate     axes named:  0
   2304 expressive    axes named:  9
   1152 editorial     axes named:  8
    288 brutalist     axes named:  9
    192 documentary   axes named:  9
     96 swiss         axes named:  9
sum of all worlds: 56520

The pattern is the same in both errors, and it is written into this repository's own instrument notes as the fault that recurs most: a correct calculation of the wrong quantity, reported with the confidence of a right one. It is worth saying that error two undercuts a claim that would have supported our own conclusion. The grid is not pixel-identical across ten decks. That makes the sameness harder to explain, not easier.

The hypothesis, and why we are not claiming it

Our current explanation is one sentence: combinatorial variety is not perceptual variety. Eleven axes at two or three values each multiply into a large number out of small decisions — which connector shape, which card treatment, which hairline under a heading. A reader does not see 52,488. A reader sees colour, type, density and imagery, and if those four hold still then every deck looks the same however many connector variants exist beneath.

If that hypothesis is right, then the arithmetic that matters is not eleven axes but the handful a reader registers — type at two values, grid at three, picture at two on most pages. Twelve, not 52,488. And colour, the one dimension that is unmistakably different on all ten decks, is supplied by the client rather than generated.

We are not claiming that. Twelve is arithmetic downstream of an untested premise. Nobody has shown a reader two decks that differ only on the connector axis and asked whether they are different. Until somebody does, the list of load-bearing axes is a guess with a plausible shape, and the number twelve is that guess with a decimal point on it.

What we do not know

• Whether any of this holds for human readers. Every judge here is a language model shown rendered images. We have not run a human panel.
• Which axes are load-bearing. The obvious experiment — render one brief across many vectors and sort the axes by how much a reader notices — has not been run. Without it, the effective-variety number is unknown, not twelve.
• Whether the eleven-axis build scores differently. The last two axes landed after the most recent panel. It is possible, though we doubt it, that they are the two that matter.
• What the live model actually picks. Run B shows that when the style field is missing, all ten briefs land in one world. What the model chooses when the field is present, across many real briefs, we have not measured.
• How much of the sameness is invariant construction rather than narrow axes. Eighteen shape names on all ten decks and three pages at RMS 0.00 both point at furniture no axis touches. That list is the real answer and no axis count can produce it.

How to check this

The engine is not open source, so we cannot hand you a repository. What we can do is name the exact file and function behind every claim above, so that a disagreement is about a specific line rather than a paragraph. If you are building something similar, the instruments are more useful than our numbers — the ten-deck comparison took an afternoon, and it answers a question no amount of scoring against external references can reach.

Two things we would tell anyone repeating this. First, score your output against itself, not only against external references. Every quality loop we have run compares one deck to a professional anchor, and none of that work could have detected that our decks resemble each other — which is the failure a customer sees first. Second, check what your instrument is actually reading before you act on what it says. Both errors on this page passed review because the number was clean.

The rest of this work

• How long an AI presentation takes: 58 timed, median 4m40s — the wall-clock distribution for the pipeline that builds the decks measured here.
• Building .pptx by hand: what PowerPoint accepts and what silently breaks — including which applications honour an embedded typeface, which is why the figure above is a lower bound.
• What the Higgsfield API exposes, and what only the app does — the image endpoints behind every picture in a generated deck, and the one that returns 404 while being advertised.

Why we published a negative result

Every generative design tool sells a combination count. Thousands of layouts, millions of variations, infinite designs. We have one of those numbers and it is genuinely computed — and we can now show that it did not buy the thing customers were asking for. A combination count is a claim about a file. Nobody buys files.

We would rather be the tool that published its own null result than the one that kept quoting 52,488. The number is real. So is the panel that shrugged at it. What we do with that is the next piece of work, and when it produces an answer — including if the answer is that we were wrong about this too — it will be published here.

Three real decks, three businesses, one pipeline. Judge the sameness yourself — it is the honest test and it is the one on the product page.