GPT-5.6 Sol takes the top spot in web design rankings: it learned design taste — and how to dodge the usual AI clichés
- On Design Arena's web design (non-agentic) leaderboard, OpenAI's GPT-5.6 Sol landed in first place, 18 spots above its predecessor GPT-5.5 — the first time an OpenAI model has topped this board.
- The benchmark team converted 1,000 of its generated web pages into image vectors and clustered them. The resulting design map has clear gaps — sitting exactly where purple gradients, bento-box layouts, and oversized headlines (the usual AI web clichés) would be.
- Both models dodge these clichés, but for different reasons: GLM-5.2 simply never learned the tropes, while GPT-5.6 Sol learned them and refuses to render them.
- It starts from a reliable template, then heavily customizes for each request — landing somewhere between cookie-cutter and total improvisation.
- It didn't dodge everything: 26.5% of its outputs still stuff in confetti, and it's noticeably weak at building data charts.
You can spot an "AI website" at a glance — this one learned not to look like one
You can usually spot an AI-made website in a second: a purple-to-blue gradient background, a screen chopped into bento-box cards, a giant headline hogging the whole hero section. See enough of them, and that unmistakably "fake" plastic sheen practically becomes an AI website's birthmark.
Design Arena's method: feed different models the same web-generation task, put the results in front of humans for blind selection, and rank models by how often they get picked. GPT-5.6 Sol won the "web design (non-agentic)" board — meaning single-shot generation, not multi-turn agentic revision.
The tells that scream "an AI made this"
The purple gradients and bento boxes mentioned above are just a couple of examples. In the field, this whole family of tics has a name: anti-patterns, or "design smells" — dead giveaways the moment you see them. To understand this finding, it helps to see the full lineup first.
Three months ago, when analyzing GPT-5.5, Design Arena put together a list of these design smells. The main ones:
| Design smell | What it looks like |
|---|---|
| Purple-to-blue gradient | Background uniformly washed in a purple-to-blue gradient — the signature AI-image color scheme |
| Bento-box layout | Page chopped into unevenly sized card blocks, packed into the screen like a bento box |
| Oversized headline text | Skips the hero image, uses one giant line of headline text to fill the whole first screen |
| Offset layout | Elements deliberately staggered left and right to look "intentionally designed" — really just a trope |
| Grid background | A faint grid line pattern laid over the entire page |
None of these is wrong on its own — the problem is AI models overuse them, to the point readers can spot them instantly. In Design Arena's blind tests, outputs carrying these smells are usually the ones that lose.
Plot a thousand web pages as a map, and a few patches go missing
Good taste and bad taste are both subjective calls. The benchmark team wanted evidence you could actually see, so they turned GPT-5.6 Sol's 1,000 generated pages into points on a map.
The process has two steps. First, every page screenshot is fed into a model called CLIP, which spits out a long string of numbers for each image — think of it as a "genetic code" for that image's style; images with similar styles get similar codes. Second, a technique called UMAP flattens that long code down into a single point on a 2D plane, while trying to preserve the original distances — pages with similar styles still land close together on the map.
CLIP is like issuing each web page a "style ID card" — a long code. UMAP then flattens a three-dimensional nebula into a flat star chart; the clumps, the density, and the empty patches in the original cloud mostly survive the flattening.
Spread out, those thousand points form the model's "design space" — the whole region of style it likes to generate, generates often. Once plotted, the benchmark team found something that shouldn't be there: clear holes in the map, patches of the point cloud conspicuously missing.
Below is the benchmark team's actual projection. The first image is GPT-5.6 Sol — dense with points, but with visible gaps; the second is GPT-5.5, whose point cloud is filled in, with no such gaps.
UMAP projections are designed to preserve holes from the original space. So when one model's map has a hole and another's doesn't, it means: that spot is somewhere GPT-5.6 Sol could generate — and does generate elsewhere — but chooses not to put anything there.
To confirm what's sitting inside the holes, the benchmark team overlaid GPT-5.6 Sol's and GPT-5.5's outputs on the same chart: GPT-5.6 Sol's points dyed orange, laid over GPT-5.5's. Wherever there are orange dots is territory GPT-5.6 Sol will visit; wherever there's only the base color and no orange, that's territory it avoids that the previous model would have gone to.
The two models overlap almost everywhere, except in the purple-gradient cluster, where there isn't a single orange dot. Bento boxes, oversized headlines, offset layouts — same story. What's sitting in those holes is exactly that batch of AI clichés.
Two models dodge the same clichés — by two very different routes
GPT-5.6 Sol isn't the only model that avoids AI clichés. But how it avoids them is different from everyone else, and that's the most counterintuitive part of this whole analysis.
Take GLM-5.2, which ranks ahead of it, as a comparison. It also rarely produces oversized-headline-style clichés — but it does so by learning from a batch of high-scoring templates that simply never contained those tropes to begin with. In other words, its design space never had a "purple gradient" region to draw from, so naturally it can't render one; no hole shows up on its map, because that spot was empty from the start.
GPT-5.6 Sol is a different story. The fact that its map has holes is exactly what shows it learned these tropes and has the ability to render them — it just steers away every single time it generates. It knows what a purple gradient looks like and where it belongs, and then chooses not to put it there.
Its design space covers where these clichés would sit, yet it actively steers away from generating there, leaving hole after hole on the map. This is "knows, and chooses not to."
It draws from a batch of templates that never contained these clichés — that style was never within its capability range to begin with, so the corresponding region never even exists on the map. This is "the option was never there."
Both routes can end up avoiding the same clichés in the final product. The difference shows in the shape of the capability itself: one draws a circle around that territory and labels it "off-limits," the other never mapped that territory in the first place. The benchmark team argues GPT-5.6 Sol looks more like learning followed by active suppression — a rare trait among models.
Starts from a reliable template, then heavily reworks each request
This is the benchmark team's second finding, about "personalization." Models that build web pages roughly split into two camps: heavily template-reliant ones that stay consistent but tend to look the same every time, and ones that barely use templates at all, generating everything from scratch each time — more variety, less reliability. GPT-5.6 Sol lands in the middle.
It starts from a set of proven, good design structures, then makes substantial adjustments for each specific request, so a whole batch of variants can grow out of a shared template — related to each other, yet each distinct. The benchmark team used an analogy: like bacteria evolving into different closely related strains, sharing a common foundation before branching out on their own.
As reference points for the two ends: GLM-5.2 also ranks high this round, and it does so precisely by learning from a batch of high-scoring templates — the upside is consistency, the downside is that variation mostly comes only from the request itself, with the same template showing up over and over. Claude Fable 5, by contrast, shows almost no template fingerprint at all; its design space is more scattered, with every output heavily customized to the request.
GPT-5.6 Sol sits between these two ends: templates keep the floor high, customization pulls the outputs apart. The benchmark team believes this lets every user get a page that fits their own needs while still looking like professional work — a major reason it ranks so high. One small tell: when picking images for different pages, it often reuses the same image across several different contexts.
Confetti everywhere, and charts still need work
GPT-5.6 Sol doesn't nail active cliché-suppression across the board. The benchmark flags two clear weak spots.
First: confetti. It has a particular fondness for scattering confetti animations across pages — showing up in over 26.5% of its outputs. How bad is it: even when it isn't handed a ready-made confetti library, it'll just hand-write one and use it anyway. This is itself a well-known AI cliché — just one it didn't manage to dodge.
Second: data charts. It's noticeably weaker at charts and data visualization, and can't produce a convincing real-world chart using chart.js (a common web charting library).
Purple gradients, bento boxes, oversized headlines, offset layouts, grid backgrounds — all leave holes on the map.
Confetti shows up in 26.5% of outputs — and it'll hand-write its own confetti library; data charts remain unpolished.
More than twice as fast as the previous leader, at half the price
Beyond rankings and taste, GPT-5.6 Sol also pulls ahead on speed and price. The benchmark team says it establishes two new efficient frontiers at once: one for "quality versus speed," one for "quality versus price."
Picture a drawn boundary line: standing on it, if you want a nicer-looking page, you have to spend more time or more money — there's no free lunch. GPT-5.6 Sol pushes that boundary forward, meaning it can hit the same level of visual quality faster and cheaper.
More discerning, and more flexible
The benchmark team boiled this down to two sentences.
First, it's more discerning. It appears to have learned which visual tropes make a web page instantly readable as "made by AI," and actively suppresses them, while keeping a set of reliable design structures ready to use. Second, it's more flexible. It fuses templates and customization together: templates set a reliable floor, then heavy per-request rework makes sure everyone gets a page that fits them, while still reading as professional work.
Taken together, these two points are Design Arena's main explanation for why GPT-5.6 Sol leads the single-shot leaderboard. As for the confetti it didn't dodge and the charts it can't quite pull off, those are laid out in the same benchmark — you need the whole picture, not just the highlight reel.
GLM-5.2 looks like it never learned these design smells in the first place, so it simply doesn't produce them; GPT-5.6 Sol looks like it learned them, knows these smells exist, but refuses to render them. Design Arena, analysis of GPT-5.6 Sol
OpenAI's GPT-5.6 Sol tops the web design leaderboard: it learned AI's dead-giveaway tropes — and deliberately won't draw them
Third-party benchmark Design Arena turned its thousand web pages into a map — and the missing patches sit exactly where purple gradients and other AI clichés should be. One page, with visuals, to catch you up.
↓ One page, one read · includes an animated diagram
Design Arena is a third-party AI design benchmark. The method is simple: feed different models the same web-generation task, put the results in front of humans for blind selection, and rank models by how often they win.
You can usually spot an AI-made website in a second — a purple-to-blue gradient background, a screen chopped into bento-box card blocks, an oversized headline hogging the whole first screen. That "instantly fake" look has practically become an AI website's birthmark. Yet OpenAI's new model, GPT-5.6 Sol, just took first place on this leaderboard, 18 spots above its predecessor — the first time an OpenAI model has ever topped it. To find out why, the benchmark team dug through its thousand generated pages.
Digging in, the benchmark team found its biggest difference: it learned those instantly-fake tropes, then actively refuses to put them on the page.
Learn tropes like purple gradients and bento boxes, then pile them on when generating — the result screams "AI-made"
Also learned these tropes, but steers around them every time — the result doesn't read as AI-made
But "dodging the tropes" is still a subjective claim — beauty is in the eye of the beholder. The benchmark team wanted evidence you could actually see.
Here's how the evidence was built: turn GPT-5.6 Sol's thousand generated pages into points on a single map.
Two steps. First, feed every page screenshot into a model called CLIP, which gives each one a code (pages with similar content and style get similar codes). Second, use a method called UMAP to flatten that long code into a single point on a plane, with similar-style points landing close together. Spread across a thousand points, that's the region of style it likes to generate — and the benchmark team noticed a few chunks conspicuously missing from the middle.
The benchmark team overlaid both models' outputs: in the purple-gradient cluster, GPT-5.6 Sol has not a single point — same story for bento boxes and oversized headlines. What's sitting in those holes is exactly that batch of AI clichés. Both models dodge them, but by different routes: GLM-5.2 never learned these tropes to begin with, so that region of the map was always empty; GPT-5.6 Sol learned them, can render them, but steers away every single time. One is "can't," the other is "can, but won't."
The same map reveals a second thing: its points aren't clustered rigidly. It starts from a set of solid templates, then heavily reworks each request — landing somewhere between "cookie-cutter" and "total improvisation."
Beyond taste, GPT-5.6 Sol also pulls ahead on speed and price.
It hasn't dodged everything: confetti shows up in over a quarter of its outputs, and it'll hand-write its own confetti library even without a ready-made one; it's also weak at data charts, unable to produce a convincing real chart with chart.js (a common web charting library). The benchmark lays all of this out alongside the wins.