When the World Becomes the Interface
- #ai
- #generative-ui
- #frontend
- #future-of-software
- #ambient-computing
Thirty spokes share one hub; it is the emptiness at the centre that makes the wheel useful. Clay is shaped into a vessel; it is the hollow within that makes it useful. Doors and windows are cut for a room; it is the empty space that makes it useful.
So what is there gives form — and what is not there gives use.
— Tao Te Ching, ch. 11
I have spent roughly ten years building apps. For most of that time, the basic assumptions of software felt stable: a designer decided what the user would see, a developer turned it into components and screens, and the user learned how to navigate what we had built.
Recently, I have been moving more of that work to large language models myself. Much of my working day is now spent asking Claude to generate whole components, assemble layouts and sometimes produce an entire interface, then reviewing what comes back the way I would review a colleague's pull request. More recently, we have gone a step further and begun generating some UI components at runtime — not written in advance, but created when the user needs them.
My first reaction was practical: this will make frontend development faster.
Then I realised that this may be the least interesting consequence.
The bigger question is not whether AI will write more of our frontend code. The bigger question is whether the frontend will continue to exist as a fixed object at all.
What if the next screen is not designed until the moment you need it?
We have changed the location of software before
Software used to live on the computer in front of you. You bought it, installed it from a disk or downloaded it, and stored your files locally. Moving to another machine often meant reinstalling everything and manually carrying your data with you.
The internet loosened that connection. Software moved into the browser, data moved into the cloud, and a URL became enough to access tools that once required a local installation.
Then smartphones gave us another dominant container: the app. We became accustomed to searching an app store, installing a product, granting it permissions, creating an account and learning its particular navigation system.
Each transition changed where software ran, but one assumption remained untouched: the software itself had already been designed.
The user could only move through possibilities that a product team had anticipated. A button existed because somebody had designed it. A page existed because somebody had added it to the application. If the feature was not there, the user waited for a future release.
That assumption is now beginning to break.
The interface may become an output
In November 2025, Google Research presented a system called Generative UI. Instead of producing the familiar wall of text, the model could design and code a customised interactive response: a webpage, tool, simulation, game or small application generated for a specific prompt.
Google described this as an early step toward experiences tailored to the user's needs, rather than forcing the user to choose from an existing catalogue of applications. That last phrase matters: an existing catalogue of applications. It points to a future in which selecting software may be replaced by generating it. And the results were not a toy: in the accompanying paper, human raters judged the generated interfaces comparable to ones built by human experts in 44% of cases. Not a majority — but a startling number for interfaces that did not exist thirty seconds before they were evaluated.
We can already see rough versions of this idea elsewhere. Claude Artifacts can turn a conversation into a website, prototype or interactive dashboard. Vercel's v0 generates application code and runs it in a browser preview, with additional systems detecting and repairing broken output. These are still primarily creation tools, but they establish an important new pattern: the model's answer does not have to be text. It can be working software.
Imagine asking:
Help me compare these three apartments and work out which one I can realistically afford.
Today, you might open a property app, a map, a banking app, a spreadsheet and a mortgage calculator.
A generative system could instead create one temporary workspace containing the apartment details, travel times, repayments, deposit scenarios, personal notes and booking actions. That particular interface might never have existed before. It would be created for one person, for one decision, and it would disappear once the decision was made.
This is not just a more convenient chatbot. It is a different model of software.
The interface becomes disposable. Like the pot in the Tao Te Ching, its usefulness lives in what is not permanently there.
I do not think the LLM will literally become the browser
It is tempting to say that everything will be "rendered by the LLM," but that is technically misleading.
The browser, operating system or spatial device will still perform the final rendering. It will calculate layouts, paint pixels, process gestures and execute interactions. The LLM's role is different: it decides what experience should exist and produces the code or semantic description required to create it.
In that sense, the LLM begins to resemble a runtime compiler for human intention.
The input is no longer simply a click. It is a goal, combined with personal context and the capabilities available to the system. The output is not necessarily a page. It might be a page, a workflow, a visualisation, a conversation, a control surface — or an action performed without displaying an interface at all.
Recent research goes further still, describing interfaces that can generate new features, infer unmet needs and restructure themselves at runtime instead of remaining fixed collections of layouts and functions.
That is a much more radical idea than AI-assisted coding. AI-assisted coding helps us build the application faster. A self-evolving system questions why the complete application must be built in advance.
The app store may become invisible
I do not believe app stores will suddenly vanish. Apple and Google have too much invested in identity, distribution, payments, permissions, security and trust.
But the visible store — the place where people browse millions of icons — may become far less important.
Today, organising a dinner means a restaurant app, a maps app, a calendar and a rideshare app, each opened, operated and closed in sequence. In the future you might just say: organise dinner with Sarah next Thursday, somewhere between our offices, nothing too loud, under $100 each. A personal agent could call several services, compare options, check calendars, calculate travel time and produce a small confirmation interface. You might never know which applications were involved.
In that world, companies would publish capabilities rather than expecting users to enter their complete application. A transport provider might expose the ability to estimate and book a ride. A restaurant platform might expose search and reservation. A bank might expose transaction analysis or payment actions under strict permission rules.
Apple's App Intents already moves in this direction. Developers describe the actions and data their apps make available to the wider system, allowing Siri, Spotlight, Shortcuts and Apple Intelligence to discover and invoke those capabilities. Apple now describes these schemas as a way for its intelligence layer to understand what an app can do and use those actions when responding to natural-language requests.
This is not the end of the app yet. But it is an early separation of an app's capabilities from its visible interface.
My prediction is that by 2035, most ordinary consumer tasks will no longer begin with tapping an app icon.
That prediction may be wrong. People may remain more attached to familiar applications than technologists expect. Regulation, trust and business incentives may preserve the current model for much longer.
But if it is right, the app store of the future will look less like a shopping centre and more like an infrastructure market: a registry of verified actions, permissions, identities, prices and reputations that personal agents navigate on our behalf.
The request may become smaller
A second shift concerns input.
The keyboard forces us to explain ourselves explicitly. Voice reduces some friction, but we still need to formulate a command. A contextual system already knows more: where we are, what we are looking at, what we were doing a moment ago and what normally matters to us.
The request might shrink from a full sentence — compare the ingredients, nutritional value and price of these two products against my dietary preferences — down to two words: which one? Gaze identifies the products. Personal context supplies the preferences. The language model infers the missing structure.
Eventually, input may come through subtle muscle activity or deliberate brain signals. This still belongs more to medical research than consumer technology, and it should not be described as unrestricted mind reading.
But progress is real. Meta's Brain2Qwerty research uses AI to decode text from non-invasive brain recordings. In June 2026, Meta presented Brain2Qwerty v2, capable of real-time sentence decoding from MEG signals under research conditions, while emphasising its potential for people who have lost the ability to communicate. Implanted brain–computer interfaces are progressing from cursor control toward attempted speech. The first important use cases are medical, and rightly so. Yet the long-term implication is difficult to ignore: intention can become a computer input without passing through a keyboard, touchscreen or spoken sentence.
That possibility is exciting, but it also creates a problem more serious than any current privacy setting.
We will need a thought firewall.
A neural system must distinguish between private mental activity and a deliberate command. It should not interpret every passing thought as input. Ideally, raw signals would be processed locally, and nothing would leave the device until the user performed an intentional mental equivalent of clicking "send."
The future of computing may depend as much on protecting unexpressed thought as today's internet depends on protecting passwords.
The phone may dissolve rather than disappear
People often ask what will replace the smartphone, as though another single object must take its place.
I suspect the phone will be unbundled.
Its screen may move into lightweight glasses, projected surfaces or spatial displays. Input may be divided between voice, gaze, hand gestures and wrist signals. Cameras and environmental sensors may provide context. Computing may be distributed between wearable hardware, nearby devices and the cloud.
The phone could survive for years as the hidden processor and identity anchor, even after we stop holding it.
Eventually, software might appear wherever it is useful. You look at a broken machine and instructions appear over the relevant parts. You stand in an empty room and a redesign becomes visible at full scale. During a meeting, previous decisions, names and translated speech appear privately in your field of view. On a wall, the same system creates a temporary planning space. Through earbuds, it becomes a conversation.
There may be no canonical version of the interface. The system could generate a semantic experience and allow each available device to express it differently.
At this point, we are no longer talking only about websites. We are talking about ambient computing: software distributed through rooms, vehicles, wearables and connected objects. The connected environment supplies sensing and action; the model supplies interpretation; the personal agent supplies continuity across all of it.
Not every interface should be generative
This is where I become less enthusiastic.
A probabilistic interface is a terrible idea in many situations.
I do not want my bank to invent a new transfer flow every morning. I do not want an aircraft cockpit to reorganise itself because the model has inferred that the pilot prefers a cleaner layout. Professional tools depend on muscle memory. Medical systems, financial transactions and critical infrastructure depend on predictability.
There is also a basic human problem: constantly changing interfaces can be exhausting. Familiarity is not merely a limitation of old software. It is a feature.
The future will therefore contain fixed and generated systems at the same time.
Authentication, permissions, payments, safety rules and core business logic will remain deterministic. Around those stable foundations, an AI layer may compose temporary interfaces and workflows. The most useful model may be human-designed islands connected by generated software.
Designers and developers will still define visual languages, accessibility standards, action contracts and safety boundaries. But they may stop designing every possible journey through the system.
Frontend development would not disappear. It would move one level down.
Instead of building each screen, frontend engineers would increasingly build the environment in which screens can be safely generated. That is a real engineering discipline, not a consolation prize. Someone has to design the component vocabulary the model is allowed to compose from. Someone has to build the sandbox that stops a generated interface from doing something the user never authorised. Someone has to define the state model that survives when the interface around it is regenerated, and write tests capable of evaluating screens that did not exist when the product shipped.
If anything, this is harder than what we do today. We currently test what we built. We will need to test what the system might build.
My actual bet
I do not think the future is a world where "everything is an LLM."
That description gives the model too much credit and hides the systems around it.
My bet is more specific: the app will stop being the default unit of digital experience.
Apps will remain as trusted containers, professional tools and branded destinations. Websites will remain valuable when people want to explore, read, shop or experience something intentionally designed.
But an increasing share of everyday computing will begin with intent rather than navigation. We will not always search for the right software, install it, learn its interface and operate it step by step. A personal intelligence layer will interpret what we need, discover trusted capabilities and construct the smallest useful experience around the task. Sometimes that will be a complete interface; sometimes a single button, a voice, or an action that simply asks for confirmation.
The progression, as I see it, is not merely from desktop software to websites to mobile apps.
It is from software as a product we operate to software as a material that forms around intention.
For fifty years, the value of software has been in what was there: the screens, the buttons, the features someone designed in advance. The Tao Te Ching suggests the usefulness of a thing lives in its emptiness — the hollow of the pot, the space inside the room. Perhaps the same is becoming true of software. The most useful interface may be the one that is not there until you need it, and gone when you no longer do.
If that happens, the browser will not disappear. Neither will apps, screens or developers. They will simply stop being the centre.
The centre will be the person, the current situation and the thing they are trying to do.
The world itself becomes the interface.