A very short story of UI

I want to explore how I see this shaping the future of interfaces. But before we look ahead, let's take a quick look at how UI has evolved so far. Let's start by defining what the User Interface is:

A user interface (UI) is the space where interactions between a user and a digital system occur, enabling input and providing output.

We started with only keyboards. Interfaces were terminals: text in, text out. You had to be a hacker to use a computer. To simplify, we created GUIs: buttons, windows, icons. Suddenly, computing became visual. You could point and click instead of typing memorized commands. We had to teach users to use something called a mouse.

Bus Mouse, 1986

There was nothing “natural” about the mouse. The Apple Macintosh and later Windows didn't just introduce a new input device — they reshaped how people interacted with computers. Icons, menus, buttons, and visual affordances taught users to point instead of remember. It was a major step in the evolution of UI — making computers easier to understand and opening them up to millions of new users.

In 1985, Microsoft included Paintbrush (Paint) in Windows 1.0, helping users build muscle memory using the mouse in a fun, creative way.

The web introduced a new kind of interface: instead of interacting with applications on one machine, we could browse an interconnected world of information. The browser became our new tool, and links became the basic building blocks for navigating it. HTML gave us links, CSS added style, and JavaScript made them interactive. As the web evolved, so did the way we built interfaces. Responsive design made them adapt to different screens. Frameworks made complex applications easier to build. Smartphones pushed us toward touch-first, mobile-first interfaces. Each step made the interface more capable, more accessible, or more adaptable. But the design process was similar:

• We design and build interfaces.
• Users interact.
• We analyze and improve.

That cycle has stayed pretty stable. Until now?

Where we are now

Most of us are still writing UIs by hand. We build design systems. We stitch components together. We develop interfaces for watches, phones, tablets, desktops, TVs and cars. We account for loading, empty, error, mobile, desktop and every other state we can think of. AI is already making this process faster.

Liquid Glass

But what if we stopped building every possible interface state ourselves? What if, instead of deciding what the user will see beforehand, we could let the system figure out what interface makes sense when they need it? This is where Generative/Ephemeral UI becomes interesting. But there's an important distinction. Gen-UI isn't simply an LLM writing JSX. The interesting part is that the model can choose which interface primitives should exist for this particular interaction.

Meet Ephemeral Interfaces

Ephemeral Interfaces are those in which interaction surfaces aren’t fixed entry points anymore, but temporary structures that materialize around intent and context, dissolving once their task is complete and leaving behind the distilled learnings of the exchange.

Imagine this: instead of opening a fixed app layout, you tell your device what you want to do. You say, or even think:

The UI builds itself — pulls the right data, shows you a chart, buttons, filters, and generates a summary. The interface is dynamic — generated based on your intent, context, and past behavior. This is where we may be heading: from User Interfaces to User-Generated Interfaces.

This is already possible today.

Projects like Vercel's json-render take this idea and make it concrete: the application defines a catalog of allowed components and actions, the model generates a structured UI specification, and the application renders that specification using real components.

The important part is the constraint. The model doesn't get to invent an entire application. The developer defines the vocabulary. The model composes it. There are plenty of other examples of this idea in action — from AI-generated dashboards and chat interfaces to React Native apps, PDFs, emails, 3D scenes, and even terminal UIs. See more examples here. That changes the role of a design system. It is no longer only a collection of components for developers to use. It becomes a vocabulary that an AI system can use to construct interfaces.

Designing possibilities

This is where I think the biggest shift happens. If AI can compose interfaces, we don't need to design every possible screen in advance. Instead, we define the system from which those screens can be created.

• Primitives — the building blocks
• Rules — how the UI behaves
• Constraints — what the system is allowed to do
• Tokens — the visual language
• Actions — what the interface can actually trigger
• Data — what it can access

The model handles the composition. This doesn't mean developers disappear. It means the abstraction moves up. When you remove the constant friction of implementation, you get something back: time and cognitive space. Time to explore more directions instead of committing early; prototype ideas instantly, instead of negotiating feasibility; iterate on interaction, not just layout; focus on meaning, not mechanics.

Instead of asking:

Can we build this?

We think:

What should this feel like?

Instead of spending hours aligning elements, fixing spacing bugs, handling loading states, we can focus on crafting better flows, defining clearer user intent, designing systems that adapt intelligently. Your job becomes less about drawing the final screen…

…and more about defining:

• rules (how UI behaves under different contexts)
• constraints (what good looks like)
• primitives (the building blocks AI can use)
• tokens (design language at scale)
• training signals (what the system should optimize for)

You stop designing screens. You start designing possibility spaces, and creativity actually expands. Ideas that were previously too expensive to build become cheap to explore. Niche flows. Temporary tools. Personalized experiences. Interfaces that would never justify their own feature in a roadmap.

We're not ready yet

We're still early.

Just a beautiful concept

AI-generated interfaces look weird. Accessibility is an afterthought. Models hallucinate. And an interface that changes too much can destroy the familiarity and muscle memory that made graphical interfaces successful in the first place.

There are harder problems too:

Consistency

Will the same product still feel like the same product when every interaction can produce a different interface?

Trust

Why did this interface appear? Why did the system choose this action?

Accessibility

Can dynamically generated interfaces remain accessible across different users, devices and assistive technologies?

Performance

How quickly can a useful interface be generated before it starts feeling slower than a traditional one?

Security

What happens when generated UI can trigger real actions?

Taste

Who decides whether a generated interface is good? These are not solved by making the model smarter. They require better systems.

I believe that we're in that phase again: early, weird, full of possibility.

What I’m excited about

People don’t use interfaces the way we expect. They use them the way they understand. Watch someone older on Android. Instead of going “home” with ● they’ll hammer the back button ◄  until the app disappears. Not because it’s wrong — because it matches their mental model: go back = undo everything. The system fights them, so they brute-force it.

UIs that adjust complexity based on your skill level. Most apps are frozen at one level of complexity. Beginners get overwhelmed. Power users get slowed down. We already see hints of adaptive complexity:

• Figma hides advanced controls until you need them, but still exposes everything if you know where to look
• Notion starts as a blank page, then unfolds into databases, relations, and formulas

But this is still manual discovery. What’s missing is progression:

• first-time use — guided, constrained, almost “dumb”
• repeated patterns — shortcuts appear
• expert usage — UI gets out of the way entirely

Same tool. Different surface.

Custom interfaces that adapt to your screen, intent, and mood. Responsive design solved the layout. Not behavior. We still ship the same interface everywhere, just rearranged. But intent matters more than screen size. Think:

• late night, tired — fewer options, larger targets, less noise
• focused work — dense, information-rich, keyboard-first
• quick check — minimal, glanceable, ephemeral

Some products are getting close:

• TikTok optimizes for passive consumption vs active creation with completely different flows
• Spotify shifts between discovery, background listening, and active control depending on context

But it’s still coarse. Mostly mode switches. The next step is continuous adaptation — interfaces that reshape themselves moment to moment.

New interaction primitives. Keyboard, mouse, touch — these were stable for decades. Now the input layer is breaking apart again.

• Voice — Siri, Google Assistant
• Vision — Apple Vision Pro tracks where you look
• Gesture — hands as controllers, no physical input
• Context — location, time, activity shaping behavior
• Thought (?) — early experiments with brain-computer interfaces

None of these is perfect yet. Voice is unreliable. Vision is awkward. Gesture is tiring. But together, they point to something else: Interfaces that don’t wait for explicit input. They infer. Put it together:

• a beginner gets a simplified UI
• an expert gets speed and density
• the system reshapes itself based on context
• the UI can be generated on demand
• input is no longer limited to taps and clicks

Same product. Different reality per user. That is a new generation of responsive and adaptive design.

Conclusions

The interface might no longer be a fixed thing we ship. It’s becoming a living layer between humans and systems — one that learns, adapts, and helps. We’ll still need creative design. We’ll still need clean code. But the job is shifting. We stop designing screens, and start designing possibility spaces.

Develop. Shape the tools. Let the UI dance.