DEV Community: Chaos Wang

Why AI-generated design all looks the same

Chaos Wang — Sat, 22 Aug 2026 06:25:46 +0000

If everything your AI produces looks vaguely the same — clean, competent, and completely forgettable — you are looking at AI slop. It happens for a structural reason, and there is a structural fix.

What is AI slop?

AI slop is the generic, average-looking output that AI tools produce by default — design that is technically fine but has no point of view. In a design context it shows up as the same soft gradients, the same rounded cards, the same purple-to-blue hero, the same safe sans-serif, on site after site and deck after deck.

The word 'slop' is doing real work: it names the feeling that the output was generated rather than designed. Nothing is wrong with any single element. The problem is that the whole thing is a statistical average — and averages, by definition, belong to no one.

Why AI-generated design looks generic

A model trained on millions of designs learns the center of that distribution, not its edges. Ask it for 'a modern, clean, beautiful landing page' and you are asking for the most probable design — which is, almost by definition, the most average one. Researchers call this homogenization: as more people lean on the same models, creative output converges toward a shared mean.

Generic input compounds the effect. Adjectives like 'modern', 'clean', 'professional', and 'minimal' do not point anywhere specific — every style in the training data claims them — so the model falls back on its default aesthetic. The more open the request, the more average the result.

This is not a bug that a future model fixes. A model with no instruction to be specific will always reach for the center. Distinctiveness is information you have to add from the outside.

Why better prompts don't fix it

Prompting helps at the margin. You can hand the model a reference, name a constraint, or paste an example, and the next output will be a little less generic. But the model still has no internal taste to anchor to — between your instructions it drifts back toward its average, and consistency across many screens collapses.

You cannot prompt your way into a specific aesthetic the model does not hold. 'Make it look like a high-end fintech product' is still an adjective cluster; ten people will get ten different interpretations, and the same person will get a different one tomorrow. To get a specific look reliably, the specificity has to live outside the prompt.

The fix: give your AI one real design style

The cure for an average is a commitment. Instead of letting the AI blend everything, constrain it to one specific, real, documented design style — a movement or a brand that already has a point of view and a set of rules. Bauhaus has rules. Swiss style has rules. Memphis has rules. A real style forces non-average choices, because it was built around a stance, not around being inoffensive.

Crucially, the style has to arrive as rules the model can apply — an actual palette, type scale, spacing system, and component logic — not as an adjective. 'Use Bauhaus' is still vague; the primary-color palette, the hard-offset shadows, the strict grid, and the zero-ornament principle are not. When the AI is following a defined system, it is no longer averaging — it is executing.

This is exactly the gap a curated style library fills. Curio packages real design styles as specs an AI can read and apply directly, so the distinctiveness is supplied from the outside and your AI stops reaching for the mean.

How to beat AI slop in practice

Pick a style with a real identity, not an adjective. 'Editorial Swiss grid' or 'Memphis' gives the model something to execute; 'modern and clean' does not.

Give the AI the style's actual rules — colors, type, spacing, shape language — rather than describing the vibe. Specifics are what survive the gap between prompts.

Commit to one style and do not blend. Slop often comes from averaging two or three influences; a single committed system reads as intentional. The whole point is a point of view.

FAQ

Is 'AI slop' just an insult, or a real phenomenon?

Both the term and the effect are real. 'AI slop' is informal, but it names a measurable tendency — homogenization, the convergence of AI output toward a statistical average. It is a structural property of how models generalize, not a temporary quality problem.

Won't a more detailed prompt fix the generic look?

Only at the margin. A detailed prompt nudges one output, but the model still has no taste to hold between requests, so it drifts back toward its average and consistency breaks down. A concrete, reusable style spec fixes the look reliably; a prompt does not.

Does using a named style make everything look derivative?

No — a real style is a grammar, not a template. It gives the AI consistent rules to compose with, the way a typeface or a grid does. Distinctiveness comes from committing to a point of view; derivative work comes from averaging several without committing to any.

Originally published on designbycurio.com. Curio is a design style library for AI agents — 1,000+ real design styles as machine-readable specs your AI can actually follow. If you want the practical follow-up, see How to give your AI design taste.

Your AI doesn't understand design. So I gave it a library it can read.

Chaos Wang — Sat, 22 Aug 2026 06:18:47 +0000

Ask any LLM to "make this landing page look like a high-end Swiss design studio" and you'll get something that gestures at the idea — a sans-serif font, some whitespace, maybe a red accent because it half-remembers Müller-Brockmann. It looks AI-generated because it is. The model has read a billion words about design but has no grounded, reusable representation of what "Swiss International Style" actually specifies: the exact grid, the type scale, the spacing ramp, the rules for what you must not do.

That gap is the whole problem. Models are great at language and bad at design systems, because a design system isn't language — it's a set of constrained values plus the discipline to apply them consistently. So I built the missing piece: a library of real design styles, turned into something a machine can actually consume.

It's called Curio. This post is about the part I think is interesting to other builders: making design machine-readable, and publishing the catalog for agents instead of for humans.

A design style is just tokens + rules

The insight is boring and that's why it works. Pick any coherent visual language — Bauhaus, Memphis, the Edo woodblock palette, Stripe's product aesthetic — and you can decompose it into:

Tokens: color families, type families and scale, spacing ramp, radii, shadow/elevation, motion timing.
Components: how a button, card, input, nav actually look in this language.
Rules: the "always" and the "never." (Swiss: never center body text, never more than two weights. Memphis: never subtle.)

Once a style is expressed that way, an AI doesn't have to imagine the look. It interpolates within a fixed, internally-consistent set of values. The output stops looking like a guess because it isn't one. Each style in Curio is packaged exactly like this — tokens, component specs, and an explicit "avoid" list — as a DESIGN.md file — markdown with YAML frontmatter — that a model can read in one shot (what is DESIGN.md?).

# excerpt of a design package an agent consumes
meta:
  name: Swiss International Style
  isDark: false
color:
  ink: "<hex>"
  paper: "<hex>"
  accent: "<hex>"   # values intentionally omitted here
type:
  family: "Helvetica Neue, Inter, sans-serif"
  scale: [<px>, <px>, <px>, …]   # 7-step modular scale
rules:
  always: ["strict baseline grid", "flush-left, ragged-right body"]
  never:  ["centered paragraphs", "more than two weights", "decorative type"]

The part I didn't expect to care about: publishing for agents

Here's the design decision I keep getting questions about. Curio's primary user isn't a person browsing a gallery — it's the agent acting on a person's behalf. When someone tells their assistant "design my deck like a 1980s arcade," the agent should be able to discover that a matching style exists and fetch its tokens, without a human in the loop.

So the catalog is published the way you'd publish for a crawler that thinks:

An llms.txt at the root — the llmstxt.org convention — that tells a model what the site is and how to apply a style in four steps.
An llms-full.txt with one line per style: name, blurb, URL.
An open index.json — the entire catalog as structured data (id, name, tags, color family, era, region, usage), so an agent can filter "give me dark, East-Asian, editorial" without scraping HTML.

This costs almost nothing to maintain (it's generated from the same source the site is built from) and it changes who the product is for. A human-first directory makes agents scrape and guess. An agent-first directory just answers. If you're building anything an LLM is supposed to consume, I'd push the llms.txt + open-JSON pattern hard — it's the cheapest "API" you'll ever ship.

Why this is also an SEO/discovery bet

There's a second reason to publish structured, citable pages: AI search. When someone asks Perplexity or ChatGPT "where do I find design tokens for a Bauhaus look," the answer comes from indexed, structured pages — not from a JS app that renders an empty shell. Every Curio style has a server-rendered page with the spec in the HTML, schema markup, and a stable URL. The same discipline that makes a page good for Googlebot makes it good for an AI engine citing sources. Designing for "the crawler is now a model" turns out to be the same checklist, just with the bar raised.

Where it's at

Curio has 1,000+ styles right now and grows weekly. Browsing and using it is free; there's a Pro tier for the full set. But honestly, the reason I wrote this is the pattern, not the pitch: treat design as data, and publish your catalog for the agent, not just the human. If you try the llms.txt approach on your own project I'd love to compare notes — and if the "why does AI design all look the same" problem is your itch too, I wrote up the longer argument here.

If you want to poke at it: designbycurio.com — and the llms.txt / index.json are right there to read.