The Future of the Interface

A screen nobody designed

Imagine telling your phone: "I want to compare these three travel insurance plans, but I only care about medical coverage and cancellation." It doesn't give you a list of links. Nor an endless paragraph. A table appears with three columns, two highlighted rows and a button to choose.

Now imagine your mother makes the same request, and she struggles to read small print. For her, the screen arrives with large type, one option per view and a voice that explains the difference. Same data, same product, different interface.

Neither screen existed a second earlier. Nobody drew them in Figma or uploaded them to a server. They were composed on the spot, based on what each person wanted to do.

I've spent almost fifteen years working in technology, most of them as a product designer. I've watched static web design, responsive, mobile first, design systems and the app explosion come and go. This essay gathers a conviction that has been forming in me over the last few years: the next great transition in human-computer interaction won't be a prettier screen, but a screen that is generated for you.

The old deal: fetch, serve, display

For thirty years, the web has run on a very simple agreement. You ask for something. A server finds the page someone wrote in advance. Your browser draws it. Done.

That deal made perfect sense for its time. Compute was expensive and scarce, so the reasonable thing was to design once and serve many times. A team decided which screens existed, what came first and what sat three clicks deeper. Then millions of people walked through those same screens, each with different needs.

Product designers have spent much of our careers making that deal less rigid. Responsive design adapts the layout to the screen width. Personalization changes content based on history. A/B tests pick the variant that works best on average. All of that is valuable, but it still starts from the same premise: the interface exists before the person who uses it.

My question is uncomfortable on purpose. If an agent can understand what you want, has access to the data and has enough computing power, why do we need a finite set of pages waiting on a server? Why make people navigate to the screen that most resembles what they need, instead of building the screen they need?

An old promise with new tools

The idea isn't new. In 1960, J. C. R. Licklider published Man-Computer Symbiosis, imagining a relationship in which people and machines think together, each contributing what it does best. More than six decades later, we finally have machines capable of holding up their side of that conversation.

In 1997, Pattie Maes and Ben Shneiderman held a famous debate at the IUI and CHI conferences (Shneiderman and Maes, 1997). Maes argued that direct manipulation would have to give way to some form of delegation to software agents. Shneiderman replied that direct manipulation offers control and predictability, and that a person's intentions are not easily guessed. Rereading that debate today is fascinating, because they were both right, and the generative interface is precisely where their positions meet.

Jakob Nielsen named the shift in 2023. In his view, AI opens the third interface paradigm in the history of computing, after batch processing and command-based interaction (Nielsen, 2023). He calls it intent-based outcome specification: you no longer tell the computer what to do step by step; you tell it what outcome you want. Nielsen himself warns that the graphical interface won't disappear and that a hybrid model combining both paradigms is the most likely outcome.

That, for me, is the key. Chat was the first way to express intent, but it doesn't have to be the last. A text box that returns paragraphs is powerful, yet it forces you to read, remember and type again. A generative interface takes intent expressed in natural language and turns it into something you can see, touch and adjust: a sortable table, a slider, a map. Delegation in Maes's sense, with the visible control Shneiderman asked for.

Andrej Karpathy offered another useful image in 2025: language models resemble a new operating system, and today we are in something like the 1960s of computing, with expensive compute centralized in the cloud and accessed through time-sharing (Karpathy, 2025). If the analogy holds, we already know what comes next: compute gets cheaper, spreads out and ends up changing the shape of interfaces, as happened with the personal computer.

This is no longer science fiction

What a few years ago was conference speculation now has a name, papers and products.

In November 2025, Google Research published Generative UI: LLMs are Effective UI Generators (Leviathan et al., 2025). The thesis is direct: a well-prompted model with the right tools can generate not just content, but the entire interface. Setting generation time aside, human raters clearly preferred those interfaces over the classic formatted-text answer. Against designs made by human experts, the results were worse, but at least comparable in half of the cases (paper). Google brought the idea to the Gemini app with two experiments, dynamic view and visual layout.

In October 2025, OpenAI introduced its Apps SDK at DevDay. Sam Altman spoke of a new generation of apps that are "interactive, adaptive and personalized" and that you can chat with (VentureBeat, 2025). Nick Turley, head of product for ChatGPT, went further: he described the current version as the equivalent of the command-line era and said the evolution over the next few years is for ChatGPT to work more like an operating system (Yahoo Tech, 2025).

I find that statement revealing. An operating system isn't just another app: it's the space where everything else happens. If the assistant becomes that space, the interface stops being a destination you navigate to and becomes something you summon according to your intent.

The infrastructure is standardizing too. MCP Apps, the first official extension of the Model Context Protocol, lets an MCP server return interactive interfaces that render inside the conversation. It was developed jointly by Anthropic, OpenAI and open-source contributors, and clients such as Claude, ChatGPT, VS Code and Goose already support it (Thoughtworks Technology Radar, 2026). When direct competitors agree on a common standard, it is usually a sign that the problem is no longer experimental.

I'm not claiming these products are already generative interfaces in the full sense. Many still show predefined components inside a chat. But the direction is clear: the screen is starting to appear as an answer, not as a starting point.

An interface truly made for you

Of all the reasons I believe in this future, the one that moves me most is accessibility.

Today we design for an average user who doesn't exist. Then we add layers for whoever doesn't fit: a screen reader, a high-contrast mode, a zoom. The system stays the same, and it's the person who has to adapt to it.

In 2011, Jacob Wobbrock and colleagues proposed turning that logic around with ability-based design (Wobbrock et al., 2011). The idea is to focus on what the person can do, and to have the system, not the user, take responsibility for adapting. One of the examples that inspired the framework was SUPPLE, a system by Krzysztof Gajos that automatically generated interfaces based on each person's motor and visual abilities (Gajos et al., 2010).

The results are still impressive. In a study with people with motor impairments, interfaces generated by SUPPLE++ let participants work 26.4% faster and with 73% fewer errors than the manufacturers' default interfaces. Participants also clearly preferred them (Gajos, Wobbrock and Weld, 2008).

That happened more than fifteen years ago, with optimization techniques and hand-written specifications. What changes now is scale. An agent backed by a good design system could do the same for anyone and any task: larger type for those who need it, fewer options per screen for those who get overwhelmed, voice for those who can't read at that moment, more density for the analyst who wants to see everything.

And I'm not only talking about permanent disability. We all have situational limitations: a busy hand, sunlight on the screen, fatigue at the end of the day. An interface generated for the context can address them without anyone having to switch on a setting buried in preferences.

What we still don't know

It would be dishonest to write about the future without talking about what can go wrong. I believe in this direction, but not in its naive version.

The wait. Generating an interface costs time and compute. The Google study evaluates quality while leaving generation speed aside, and that is no small detail. A static page loads in milliseconds; a generated interface can take several seconds. My bet assumes compute will get cheaper and faster, as it always has, but today that wait is a real cost the user pays.

The evidence is promising, not conclusive. Chen and colleagues (2026) compared generated interfaces with a conversational experience across 76 participants. The generative option won 50.8% of comparisons and conversation 41.1%. That's an advantage, not a verdict. There are tasks where a good paragraph is more than enough.

Consistency. One of the great achievements of interface design is that things are where we expect them. If every request rearranges the screen, we force people to reorient themselves again and again. A generative interface that changes too much is as frustrating as a static one that never changes.

Control. Shneiderman was right in 1997: people want to understand what is happening and be able to undo it. If the agent decides what you see, it also decides what you don't see. That demands transparency about why something is shown and a simple way to correct it.

Trust and business. A company can't let a model invent a price, a buy button or a payment flow. The generated interface has to respect business rules, brand and regulation. Without that, flexibility becomes risk.

None of these problems makes me doubt the direction. They make me think the interesting work lies precisely in solving them.

The designer doesn't disappear: the role moves

Every time I talk about this, the same question comes up: if the interface generates itself, what is a product designer for? My answer is that the work becomes more important, even as it changes shape.

The Nielsen Norman Group describes it as outcome-oriented design: designers who focus on people's goals and define the constraints within which AI operates, instead of drawing every element of the interface (Moran and Gibbons, NN/g). We stop designing screens and start designing the rules that produce screens.

This is where the design system goes from being a component library to something far more valuable. If an agent is going to compose interfaces on behalf of a brand, it needs to know which pieces exist, how they combine, which relationships cannot break and which business decisions are non-negotiable. It needs, in other words, a contract.

A buy button can't appear without its price. A comparison has to keep attributes aligned. A payment flow has rules that aren't improvised. Today that knowledge is scattered across documentation, Figma and the team's heads. In a world of generative interfaces, it has to live somewhere an agent can consult and respect.

I think of the design system of the future as the grammar of a language. Grammar doesn't write the poems, but without it every poem would be noise. The agent writes the sentence; the design system ensures it makes sense, sounds like the brand and breaks nothing.

That is the question I'll develop in the next article in this series: what architecture a design system needs so that an agent can generate interfaces that follow the guidelines, patterns and business model of a real product.

The interface that doesn't exist yet

When I started in this field, a web page was a document. Then it became an application. Then came the phone, and the application slipped into our pockets. With each leap, what really changed wasn't the technology but who had to adapt to whom.

For decades, we have been the ones adapting. We learned where each menu was, how many clicks it took, which screen opened what. Generative interfaces promise to invert that relationship: the machine understands what we want and builds, in the moment, the exact space to do it.

I don't think that means the end of screens, of designers, or of the interfaces we know. Stable flows will remain for critical and repetitive tasks, because sometimes the best thing is for everything to always be in the same place. But I believe the center of gravity will shift. The question will stop being "what screens does this product have?" and become "what can this product do for you, and how does it show it to you?"

Licklider imagined a symbiosis. Maes imagined agents. Shneiderman demanded control. Nielsen gave intent a name. For the first time, we have the pieces to bring those ideas together into something an ordinary person can use.

The best interface you'll use in the coming years probably doesn't exist yet. It will be created the moment you need it.

References

• Chen, J., Zhang, Y., Zhang, Y., Shao, Y. and Yang, D. (2026). Generative Interfaces for Language Models. Findings of ACL 2026, 1499–1519.
• Gajos, K. Z., Wobbrock, J. O. and Weld, D. S. (2008). Improving the performance of motor-impaired users with automatically-generated, ability-based interfaces. CHI 2008.
• Gajos, K. Z., Weld, D. S. and Wobbrock, J. O. (2010). Automatically generating personalized user interfaces with Supple. Artificial Intelligence, 174(12–13).
• Karpathy, A. (2025). Software Is Changing (Again). Keynote at Y Combinator AI Startup School, June 17, 2025. Summary and transcript.
• Leviathan, Y., Valevski, D., Kalman, M. et al. (2025). Generative UI: LLMs are Effective UI Generators. Google Research. Blog post, November 18, 2025.
• Licklider, J. C. R. (1960). Man-Computer Symbiosis. IRE Transactions on Human Factors in Electronics, HFE-1, 4–11.
• Moran, K. and Gibbons, S. (2024). Generative UI and Outcome-Oriented Design. Nielsen Norman Group.
• Nielsen, J. (2023). AI: First New UI Paradigm in 60 Years. Jakob Nielsen on UX.
• Shneiderman, B. and Maes, P. (1997). Direct manipulation vs. interface agents. Interactions, 4(6), 42–61.
• Thoughtworks (2026). MCP Apps. Technology Radar, April 2026.
• VentureBeat (2025). OpenAI announces Apps SDK allowing ChatGPT to launch and run third-party apps. October 2025.
• Wobbrock, J. O., Kane, S. K., Gajos, K. Z., Harada, S. and Froehlich, J. (2011). Ability-Based Design: Concept, Principles and Examples. ACM Transactions on Accessible Computing, 3(3), 9:1–9:27.
• Yahoo Tech (2025). ChatGPT wants to become an operating system complete with an AI app store.