You can spot it in two seconds
Open any landing page launched in the last year and give yourself two seconds. You already know whether a person made it.
The gradient hero. The three feature cards in a row, each with a tiny icon in a tinted circle. Everything rounded exactly the same amount. A "Get started" button, a "See how it works" button next to it in ghost style. Inter, or whatever Inter is wearing this month. A purple that fades into a blue. Scroll and there's a logo wall of companies that have never heard of the product.
None of this is wrong. That's the uncomfortable part. Every one of those choices is defensible on its own. Together they produce a page that could belong to any of ten thousand companies, and your brain files it under "nobody was here" before you've read a word.
People started calling this AI slop somewhere around 2024 and it stuck, because it names a feeling we all had and couldn't explain. Same thing happened with AI images a year earlier. The hands got fixed. The skin got fixed. And still, you can tell.
Everyone got the order wrong
When the image models landed, the joke was that designers were first in line. Then Copilot and Cursor and the rest showed up and the joke moved to frontend. Backend was supposed to be safe. Distributed systems, consistency guarantees, all that hard stuff. The real engineering.
I've spent twelve years on the frontend side of that line and I think it's backwards.
Here is the claim, and the rest of this post is me trying to earn it: the more AI makes everything look the same, the more the interface becomes the only part of a product that can still be different. Backend converging on sameness is a feature. Frontend converging on sameness is a funeral.
Backend is the easier target, and nobody minds
Think about what makes a task easy for a model. It wants a well-documented problem, a known good shape for the answer, and a way to check whether it got it right.
Backend has all three.
The patterns are written down. Not just written down, written down by the people who scaled them. Every big tech engineering blog is a free textbook on queues, caches, sharding, idempotency, retries. The reasoning behind each decision is public. There's a word for the ideal backend and it is "boring". Boring is a compliment. Nobody opens a status page and thinks "I wish this Postgres felt more personal".
Correctness is checkable. Tests pass or they don't. p99 is under the budget or it isn't. The contract is the OpenAPI spec and the model can read it.
And the user never sees it. This is the big one. If your API is shaped like Stripe's and your queue is shaped like everyone's queue, your customer will never know and would not care if they did. Sameness costs you nothing here. It is literally best practice.
Someone will say "try vibe-coding a consensus protocol". Fair. The hard five percent of backend stays hard. It also lives in maybe fifty companies on earth. The median backend is a CRUD app with a job runner and a cache, and that shape has been solved so many times the model has seen it from every angle.
What I saw when I built the pipeline myself
I'm not arguing from the sidelines. I built a Figma-to-code pipeline on top of MCP. Designer finishes a frame, the pipeline reads it, maps it onto our existing component library, and hands back a working React screen that uses our buttons and our inputs and our spacing tokens instead of inventing new ones.
It worked. Better than I expected. Settings pages, forms, tables, modals, the whole middle of the app came out usable on the first pass most of the time. The kind of screen a mid-level engineer would have spent a day and a half on became a twenty-minute review.
Here's what it never did well, and I watched it try for months.
It could not decide what was worth being different. Hand it a frame where the designer had done something slightly odd on purpose, a card that breaks the grid, a transition that lingers a beat longer than it should, and it would quietly regularise it. Snap the card back to the grid. Use the default easing. Not because it was wrong, because the odd thing didn't match anything in the library and the safest move was to pick the nearest known shape.
That is the exact behaviour that produces slop. Not errors. Safety. A thousand locally reasonable choices that add up to a page with no fingerprints on it.
The human in the loop wasn't there to fix bugs. The human was there to say "no, leave that weird, it's the point".
Taste has no spec
Now run the backend checklist against the frontend.
Well-documented problem? Sort of. There are design systems and WCAG and a hundred "best practices" posts. But none of them tell you what your product should feel like. There is no engineering blog that explains why Linear feels like Linear.
Known good shape? That's the trap. There is a known good shape. It's the one from the first section. Following it is how you end up looking like everyone.
A way to check? A user looks at the screen for two hundred milliseconds and decides whether they trust you. There's no test for that. There's no p99 for "this looks like somebody cared".
And this is the part that holds up even as the models get better. Being distinctive is relative. The moment a style is learnable and common, it stops being distinctive by definition. Whatever the model converges on becomes the new default, and the new default is exactly what people learn to see through. The target moves every time it's hit. A model that nails today's taste is producing tomorrow's tell.
Meanwhile features have become table stakes. Anyone can clone your feature list over a weekend now. Nobody is choosing you for having a dashboard. What's left to choose on is how it feels to use the thing, and that is the surface.
Imperfect is not the same as bad
I keep hearing "people want human imperfection in UI now" and I want to be careful with it, because it's half right and the wrong half is dangerous.
Nobody wants a misaligned button. Nobody misses the 2009 web.
What people respond to is intention. A choice that a template would never make, made on purpose, and then committed to. Linear's keyboard-first everything. Arc's sidebar that refused to look like a browser. Raycast's little animations that nobody asked for. These are not imperfect products. They're extremely polished. They're just polished in a direction nobody else picked.
The tell for slop isn't ugliness. It's the absence of a decision. You look at a page and can't find a single spot where someone chose the harder option because they liked it better.
So if you're a frontend person reading this and feeling relieved, don't get the wrong idea. The job isn't to add quirks. The job is to have opinions and ship them. That was always the job. It's just that for a while, shipping fast could cover for not having any. It can't anymore, because fast is free now.
"The future has no UI"
There's a camp that says all of this is moot because the interface is going away. You'll talk to an agent, it'll call the APIs, work gets done, no screens. Who needs a frontend when you can just ask.
I'd buy it if I knew what I wanted every time I opened an app. I don't. Most people don't.
Think about how you actually use the big consumer products. You open Spotify without a song in mind. You open YouTube without a query. You open a shopping site to see what's there. You scroll Instagram to be shown things. Half the money in consumer software comes from people who arrived with no intent and left having found something. That's discovery, and discovery is a browsing problem.
Agents are great at retrieval. "Book me the 7am flight." "Find the invoice from March." Clear ask, clear answer, no screen needed, fine. But a chat box is a terrible place to not know what you want. A blank input with a blinking cursor is the least helpful interface ever designed for someone who hasn't decided yet. A good grid of options beats it every time.
So yes, a chunk of the interface will disappear, the chunk that was only ever a form in front of an API. That chunk was already the boring part. What's left is the part where someone has to be shown something they didn't ask for and be glad about it. That part gets more important, not less.
Where the value goes
When building something is free, the value moves to whatever isn't. I count three things: distribution, trust, and the way the product feels in your hands. Two of those three live in the interface. A page that looks generated now reads as "we didn't care enough to be here", and that's a trust problem before it's a design problem.
I'll put a prediction down so you have something to argue with. Within two years, "must not look AI-generated" shows up as a line item in design briefs, written down, the way "must be mobile responsive" did ten years ago. And somewhere right now, someone is building a product whose entire edge is that it looks like a person made it. I'd bet on them.
Backend engineers, you're fine. Boring was always the goal, and you're about to get very good at it very cheaply.
Frontend people, the bar just moved. Not down. Up, and sideways, to a place the models can't follow because the moment they get there it stops being the place.
