The Visible Layer
Why a generated interface no longer proves there's design behind it.
So AI has commodified the UI. What now?
Let’s be honest, the visible layer of digital design has been largely commodified. Google Stitch, Claude Design, v0, Lovable can all generate a plausible interface from a sentence. That’s the conversation everyone is having (ad nauseam).
But Karri Saarinen made the deeper point recently in Output Isn’t Design: “the hard part of design is rarely generating the form.” The rest of design is figuring out what should exist at all. This essay sits in that lineage. The argument I want to add is more specific: the surface layer of design was already mostly pattern selection and design systems, and the rest of the UX process, the part that decides whether a product is actually any good, is still mostly untouched (for now).
The surface converged. That’s why generation works.
Most modern interfaces do not constitute invention. Login, onboarding, dashboards, checkout, settings, search, filters, tables, navigation, modals, alerts, empty states. These are solved problems, partly because users move between products and learn the patterns once. Modal behavior, table affordances, button placement, the way a filter chip works. Cross-product literacy. The patterns are universal by design.
Design systems made that convergence official a decade ago: stop reinventing the dropdown. They formalized the patterns into reusable components, documented the props and states, and made the inventory portable. Once that work was done, machine assembly was the obvious next step. AI generation didn’t invent the convergence. It inherited it from design systems and industrialized it.
On the brand and UI side, you can watch the cycle complete in real time. Last week Google open-sourced DESIGN.md, a portable markdown spec that hands AI design and coding agents like Stitch, Claude Design, and Cursor a project’s design tokens and component rules in a single file. The spec covers colors, typography, spacing, border-radius, component variants, contrast rules. Visual identity, made portable to any agent. But there’s no field for the user’s mental model. No field for the task flow. No field for what the product is for or who it’s for. The investment is going where the patterns already converged.
When a model generates a competent page design now, it isn’t doing magic. It’s drawing from a world where most surface problems already have conventional answers and where the answers are increasingly written down. The convergence is real. But it’s also a much narrower achievement than the demos make it look.
A polished looking page no longer proves anything
Visual polish, layout skill, UI fluency, and the visible craft of design used to be a moat. But now a non-designer can prompt their way to something that looks competent. The visible layer has been cheapened. I’m not saying here that UI is dead; in fact, I believe the opposite to be true. Originality is now more important than ever. It will stand out against the grey of agentic creation.
That matters because product design has historically been judged on what it looks like. A polished screen was circumstantial evidence of careful thinking underneath. Not anymore. The screen looks the same whether someone spent three weeks understanding the user or three minutes describing one to a model. Saarinen makes the same observation from the other direction: products that look ambitious and impressive at first glance often start to come apart the moment you actually use them. The form is there. The fit is not.
Surface patterns converge across products. Mental models don’t.
The natural follow-on is: if surface patterns converged, why haven’t deeper layers converged too?
Surface patterns converged because users learned them across products. Mental models don’t work that way. A mental model is a position on what the product is for, what the user is doing, and how the underlying world is shaped. Two products can share a button pattern and hold completely different positions on what they exist to do.
Notes apps are maybe the cleanest example. Apple Notes is what you get when no position is taken: a plain text editor with folders, search, and a few formatting controls. Competent, generic, theory-free. Notion and Obsidian each take a position, and the position shows up in the underlying object model.
Notion’s primary unit is the block. Blocks compose into pages, and pages can become databases. It’s a structured-composition theory of thinking, built for someone managing wikis, project trackers, team knowledge bases. Obsidian’s primary unit is the markdown file. Files live in a vault you own and link to each other through links. It’s a knowledge-belongs-to-the-user theory, built for someone who wants their notes in plain text, on their own machine, forever.
These object models aren’t arbitrary technical choices. They exist because each product is solving a specific problem for a specific kind of user. The user and the problem come first. The mental model is the position the product takes on them. The object model is what that position looks like written down.
Ask a model to generate “a notes app” and you get the average. Something Apple-Notes-shaped: clean, generic, capable, theory-free. The chrome looks right. The point of view is missing because no one took one. No specific user, no specific problem.
This is the gap the surface convergence hides. AI assembly is good at producing the average of a category. It is not good at producing a product that takes a position.
The work the current tools aren’t doing
Set research aside (that is a huge topic in its own right that I’ll come back to another day). Even with the research done, there’s a body of work that has to happen before anything appears on a screen.
Framing: what is the product for, and what is it not for? Which user does it serve, which does it ignore? What does success mean? The current tools don’t frame. They accept whatever framing arrived in the prompt (its all implicit).
Mental model and information architecture: what nouns live in the user’s world, how do they relate, what’s the taxonomy? Sophia V Prater ‘s OOUX methodology is the rigorous version of this work. The approach models objects and the relationships between them before any screens exist.
Interaction and behavioral design: flows, state machines, what the system decides versus what it asks, permissions, multi-user behavior, edge cases, time-on-task priorities. A pro tool optimizes for keystroke economy and reversibility on the fiftieth use. A consumer tool optimizes for legibility on the first. These are different products built on different assumptions about who is using them and how often.
Current tools work almost entirely downstream of all that. They take a sentence and produce an artifact. The framing is whatever was in the sentence. The object model is implicit, undocumented, and unstable across sessions. The flows are inferred from what the use case usually looks like, not from what this particular user’s task actually is.
The output looks like design. But most of the work that makes design good hasn’t happened.
Pattern libraries are not systems
A design system gives you the parts. It doesn’t automatically give you the rules for using them. Without that layer, even a good system can be reduced to a warehouse of components: buttons, cards, tabs, menus, charts, forms. Inventory without governing logic.
The value of a system was never the inventory. It’s the rules of use. When does this pattern appear? What is it allowed to do? Which product principle does it express? What expectation does it set in the user? How does it scale across teams and edge cases?
Christine Vallaure de la Paz made a related point in a recent piece on agentic design systems: “good building blocks do not come from a component library maintained in isolation.” They come from someone who modeled the whole product first. The agentic setup pulls toward efficiency, toward the inventory of things to colour in quickly. Whether anything in the inventory is worth assembling is a separate question, and it’s the one that doesn’t get asked enough.
A model can remix the inventory without understanding the rules. That’s local optimization at scale. Each generated screen makes sense on its own; the product as a whole feels incoherent because nobody, human or model, was working on the system. Only on its parts.
Pages aren’t designed in isolation
A feature is never just a feature. The moment it enters a product, it becomes a relationship to everything it touches. Does it fit an existing pattern or do you need a new one? Where does it sit in the user’s flow? Does its placement here change what the user expects over there? Pattern reuse isn’t aesthetic preference. It’s the difference between a product that scales and a maintenance burden every team and user pays.
I wrote about this previously: every feature you add reshapes the product around it. The architect Eliel Saarinen put the same discipline in spatial terms: always design a thing by considering it in its next larger context. A chair in a room. A room in a house. A house in a city plan.
And this is exactly what today’s design generation tools don’t do. When you prompt v0, Google Stitch, Claude Design, or Figma Make for a component or a screen, it has no relationship to the whole. It doesn’t know your patterns, your users’ learned behaviors, the top tasks the application has to support, or where this thing sits in a journey. It produces parts that look good in isolation and quietly accumulate the cost of reconciling them, for designers, for engineers, for users who have to learn five variations of the same control.
The unfinished part of the stack
Familiar patterns aren’t the problem. Good design uses them all the time. The problem is assembly without a model: of the product, of the user, of the system those patterns belong to. The visible competence of the output convinces people the work is done. In a word you might just say the UX. Right now AI assembly skips it.
Much of what passed for product design was already pattern selection. The value was never the production of screens. It was the authorship of the system underneath: deciding which patterns exist, when they apply, where consistency matters and where it has to give.
For these tools to get better they need to move upstream. Into framing, mental models, object design, flows. Into the work that actually decides whether the product is any good. Not many people are building there yet. But watch this space... more on this soon.
(Originally published on LinkedIn: April 28, 2026).