I built an operating system
What if your computer created the experience you needed, when you needed it? I built a working concept to find out.
About three years ago, I was in the car with Hamed, the frontend lead at my previous company. As I usually do, I asked a question that had been circling in my mind for some time: what would the future of frontend development look like?
Initially, the conversation was about how we work, what we would build and how we would build it. But then I found myself thinking differently about it. Why would we build a fixed interface if we could ask for one and get it? If AI could understand what someone wanted, why would that person always have to work through an interface someone else had designed in advance?
The ideas started flowing. A user could say, “Show me my tasks,” and get a structured task list. Ask for images and get a grid. Ask the agent to do something, provide the details it needs, approve the action, and it's done.
Beautiful interfaces that appear when you need them. You explain what you want to do, and the software arranges itself around the task. Ask something different, and the experience changes.
I called it “dynamic experiences.”
I could see the concept, but I couldn't fully picture the UI. I could describe a computer producing the right interface on demand. I couldn't yet point to something and say: like this.
A new name and a visualization
About a year later, I saw a video featuring Peter Smart talking about generative UI. The examples made the idea much more concrete.
There was a name for what I had been trying to describe. More importantly, there were examples I could watch and think through. And they were beautiful!
I started following the concept more closely, expecting one of the major players to announce something huge. From time to time, I would go online and search for generative UI. I came across projects such as Thesys, json-render and Data2UI. They approach different parts of the problem, from replacing text responses with interfaces to making data easier to explore. Recently, I also started noticing richer interactive responses in ChatGPT.
It all reinforces the idea. Progress feels slow, and I haven't seen the full experience Peter showed become a reality yet. But I'm convinced this is the direction of travel.
What interests me most is how much of a useful experience can be created around a request, beyond making an impressive first response.
Claude Artifacts are currently the closest example of what I imagined: something I can use and keep changing. A conversation can produce a dashboard, a solar-system simulation or a game. But the result lives outside the stream of messages; it isn't yet a core part of the interaction.
Then, last weekend, I woke up thinking: the whole operating system needs to work this way.
Why stop at the app?
Much of what I do on a computer still begins with choosing an application. Increasingly, though, I start with an AI-powered tool.
“Check my email, archive notifications and bring up the first one that needs my attention.”
Senta, my personal agent, opens a browser tab and shows me an email I should respond to, often with a draft already written.
“I have a new concept I want to work on. Read the following document to catch up and open a new Google Doc.”
There are still many things I do “the traditional way.” I need to plan something, so I open a calendar. I need to understand some information, so I find a document, a spreadsheet or a dashboard. I need a particular tool, so I look for one, install it, learn its conventions and fit my task into them.
I wanted to explore a computer where the system would create the experience around each request. It could keep the relevant windows and conversation together, then let me return to them later. The agent would be part of how the computer worked, rather than another application I had to keep switching back to. So I started building it. :)
A canvas, an agent bar and experiences that could appear on request.
Like a concept car, it needed to feel real enough for people to understand the choices and try the experience, while being honest about the questions still unanswered.
And I wanted to let people drive it. Try it yourself:
Interactive prototype ready to load.
The previews in this article run the Tabula interface with scripted demonstrations and sample content. You can take over and try the interactions. They show the concept, rather than a live AI service generating each response.
The concept
An interface that understands what you're working on, presents the next most important thing, lets you move easily from one focus to the next and generates experiences as you need them. Here's a piano...
Interactive prototype ready to load.
I still expect some things to be familiar and dependable. A calendar shouldn't have to reinvent itself every morning. But there is a lot of room between the software I use every day and the one small thing I need for the next twenty minutes.
That space interests me. A tool might be worth making for one person, for one task, without needing to become a company, a subscription or another permanent item in a dock.
The computer still needs manners
Once experiences could appear on request, I spent a lot of time deciding how they should behave.
Where does a new window go? What happens to what I was already doing? How do I get back to it tomorrow?
The Today view was too busy. The launcher needed to open with the cursor already in its search box. The glass effect looked promising and was horrible to read. A gesture intended to move between spaces fought with ordinary scrolling.
These were the decisions that turned a broad idea about the future into something I could actually judge.
Each piece of work got a space. Its windows and conversation stayed together. I could leave a task and return to it without rebuilding its arrangement from a pile of unrelated windows.
Interactive prototype ready to load.
Windows needed rules I could predict. They sit in a horizontal row. Minimize one and it goes to a shelf at the side. Restore it and it comes back to its place.
One rule became particularly important: nothing new should open where I can't see it.
If the agent opens a window while I'm working full screen, it joins me in a split. When I leave that view, the pair stays linked. I shouldn't have to go looking for something the computer just created for me.
Interactive prototype ready to load.
Finding an experience should also be quick. Open the switcher, type “cal”, press Enter, and get to the calendar. Recall brings back experiences I have used, so I can return to the thing itself rather than hunt through the conversation that produced it.
Interactive prototype ready to load.
The agent needed restraint too. Initially, typing a request opened more conversation than I wanted. Sometimes I only wanted to say one thing while keeping my work visible.
The bar ended up with three states: quiet, large enough for the current exchange, and deliberately opened. Opening the full conversation should be my decision.
The same principle applies to actions. The concept shows the agent preparing a reply or suggesting an event, with the decision left to me. Giving an agent a central place in the interface makes those boundaries more important.
Interactive prototype ready to load.
Even the transparency became a small system: Solid, Frosted and Clear, used consistently across the interface. If the text became difficult to read, the effect had failed.
Interactive prototype ready to load.
Most of my work was this kind of iteration. The agents could build another version quickly. I still had to use it, notice what felt wrong and explain the behavior I wanted instead.
Then I put it on a laptop
Today I asked how much it would take to turn the concept into a Linux distribution. I had an extra HP laptop from 2011 and wanted to try it on real hardware.
The result is a fun, early computer experiment built on Fedora, running my interface. AI agents wrote most of the code. I supplied the product direction, the corrections and the hands when something needed plugging in.
By the evening, it booted straight into the interface in under a minute. It could update over the internet without another reinstall. After fixing a bug in the first request from the screen, it generated a working Solar System Quiz, with questions, hints and a rocket that moved as you answered.
There is a lot left to think about
A concept car gives you something to react to. It doesn't settle how the roads, factories and service stations should work.
This experiment opens up questions much larger than its windows and agent bar.
Where do developers fit? Generated experiences still need reliable components, data, permissions and careful engineering. What do developers make when some of the interface is assembled at the moment someone needs it? What deserves to remain deliberately designed and maintained?
What happens to websites? A website can be a place to visit, a source of information or a tool. If an agent can bring the relevant experience to the user, which parts should remain destinations, and which should become available wherever the work is happening?
What happens to app stores and software subscriptions? We have built economies around distributing applications and charging for access to them. A useful tool generated for one task doesn't fit neatly into that model. Nor does it make the underlying service, expertise or operating cost disappear.
Those questions deserve their own article. So do trust, accessibility, cost, privacy and the difference between an experience that looks right and one that can be relied on.
For now, I wanted to take the thought from that conversation in the car and make it concrete enough to explore.
I can point to something now and say: like this, but keep going.
Interactive prototype ready to load.
New essays by email
I’ll send you a note when I publish an essay.