The UI is still not the point
Everyone is asking whether the machine can build their UI. I think that is the wrong question, and the right one is far more interesting.
Right now, in design teams everywhere, the same experiment is running. Someone feeds a prompt to Claude Design, or one of its cousins, and waits to see whether it can produce the screen they would have designed themselves. Some people are delighted. Some are frightened by how good it is. Some are disappointed in the results. A few are furious, and I understand why. When a machine can do in 10 seconds the thing you trained 10 years for, it’s annoying.
I want to move us off this question for now, because (nearly) all of us are asking it wrong.
Here is what we are really doing. We have been handed a tool that can grow an interface out of intent, something genuinely new in the world, and we are pointing it at the oldest task we know. Draw a fixed screen. Convert the canvas to code. Hand it down the line, faster and cleaner and with fewer late nights. Useful but look closely at what we are optimising for: We’ve been given something revolutionary, and we are using it to do old school design. A better-preserved version of the old way of doing things.
Canvas to Code
Canvas to code is a brilliant answer to a question that is already on its way out.
You can watch the whole industry racing to perfect it. Figma put an agent right on the canvas that generates and remixes and respects your design system, then made it possible to push those changes into a real codebase and open a pull request without ever leaving the file. It is clever work, and if your job today is getting a fixed design into fixed code, you should use it. Just notice what it is for. It is the most beautiful possible version of the handoff we have always done. It is the road getting smoother, right before it all changes.
Because here is where this is all heading, and it is so much more interesting than a faster mockup.
The interface is ephemeral
It isn’t going to be a screen you design once and ship to everyone alike. An interface that assembles itself in the moment, out of the materials you have given it, around the particular person using it...this is where we’re headed. The same banking app composes itself one way for someone calm on a Tuesday morning, checking a balance out of habit, and another way entirely for someone at eleven at night who has just understood that the rent will not clear. Same materials, different human, different moment. The screen stops being a thing you ship, and becomes a thing that happens, freshly, every time someone arrives: it becomes ephemeral.
So what is left for designers, if we are not creating the screens, and not even prompting the screen?
This new craft
If the interface is composed live, by an agent, in a moment you will never be in the room for, then your craft moves to two things. You build the environment the agent works inside, the components, the constraints, the rules of the house, so that whatever it assembles is made of the right material. Then you feed in your design intentions, the taste, the care, the things it must refuse to do, written down in a form a machine can absorb efficiently and accurately.
That is the whole reason I build what I build. Skills that carry a designer’s judgment as plain text. A way to turn a moodboard into something an agent can read. A small tool that asks whether your design can even be understood by an agent before you hand anything over. All of it is about the same thing, making the environment good and the intentions legible, so that what emerges there is something you would be proud to put your name on.
How do you work like this?
You stop finishing screens and start preparing materials. A set of components an agent can compose from, with the rules of combination written down: what sits next to what, how space behaves, which piece to use and when. Then you write your intentions in plain language, the way you would brief a thoughtful designer who is about to make a thousand small decisions without you in the room. How should this treat someone who is rushed. What does it never do, whatever happens. What should it feel like when the news on the screen is bad. You are not producing the outcome any more. You are designing the infrastructure, architecting the full experience, and curating the best outcomes.
Then you do the part that surprises people. You let it build, and you watch what comes back across many different moments. You correct the environment and the intentions, never the single screen. It is closer to coaching than to drawing. You train judgment into a system, and then you trust it in the places you will never get to enter.
You could start with one flow. Instead of designing the screen, write down everything an agent would need to know to design it well: the taste, the priorities, the hard refusals. Hand it over. Look at what it makes. Then resist every instinct to fix the pixels, and fix the instructions instead. That small discipline, correcting the brief rather than the output, is the whole new craft in miniature.
This is the thinking behind Designpowers if you want a place to try it.
We used to hand over screens and now we hand over intent.
Evolve your tools
An interface that bends and evolves to adapt to different users can bend the right way, toward what they truly need or it can shift the wrong way, toward whatever keeps them comfortable and agreeable and clicking. A shape that shifts to please you is not always a shape that serves you. When the form (the UI, the experience) no longer holds still, the form can no longer reliably carry your conscience for you. The only thing keeping a morphing interface honest is the intention you built into it. Which is why feeding in your design intentions is not a refinement you get to later.
I would retire the question that keeps being asked this month. Stop asking whether the agent can reliably build your screen. It can, or it nearly can, that was never the interesting part.
Start asking the question that matters now: what environment, and what intentions, would let an agent build the right thing when you are not around? How do you evolve the right infrastructure?
Try Figma’s canvas agent, Claude Design, or v0 to make your own system legible to an agent, look at the Figma MCP server and the open design-system MCP servers now appearing. If you want to feel a morphing interface first-hand, Thesys C1 and the Vercel AI SDK both let a model assemble UI at runtime, themed to your own tokens.
For the design-intentions layer, you are welcome to what I have been building over at Owl-Listener.
Go and open your design system tonight, and read it the way a machine would. Could an agent tell what you value from it? Could it tell what you would never, ever ship? If the answer is no, that is not a flaw in the machine.
This space is really exciting and emerging at this moment.
I think what you saying here is a bit what we're trying to build at TypeUI (https://www.typeui.sh/).
We use design skills for UI orientation: specifications for buttons, typography, modals, etc.
Then we use prompts for layouts: hero sections, pricing sections, navbars.
Lastly, we use a fundamentals skills that is always applied and verified in a loop.
We're still not getting to the best results, but we're getting there!
Thanks for the article, it is always a nice read.
The UI was never really the point.