What if software could shape its own interface?, Prakash Upadhyay

An early exploration into AI-generated, context-aware interfaces (noui.si)

Every app you use was designed before you showed up.

Someone decided where the buttons go, which screens exist, and what the “main flow” looks like. You adapt to it: you learn the menus, hunt for the setting, and tap through five screens to do something you could describe in one sentence.

I’ve been exploring a different question. What if the interface wasn’t designed in advance, but assembled for you, in the moment?

That’s the idea behind noui.si. To be clear up front, it’s an early exploration, not a launched product. This article is about the possibilities, not a claim that they’re solved.

Why I’m thinking about this

This isn’t a new obsession. Years ago I worked on a different version of the same question: how should people talk to a web interface? I’m the inventor on a patent for a voice-interacted web UI framework (US10936288B2) and I led that work.

That work taught me two things that shape how I see this exploration. First, people don’t want to learn an interface, they want to say or do what they mean and have the software keep up. Second, the hard part is never the clever demo, it’s the plumbing underneath: how the interface stays predictable, understandable and trustworthy while it responds to something as open-ended as human intent.

Voice was one way into that problem. Generated, context-aware interfaces feel like the next. noui.si is me picking the thread back up.

The core idea

Today, AI mostly lives inside a chat box. You type, it types back. That’s powerful, but it’s one interface for everything, and text is often the wrong shape for the answer.

Imagine instead that a model decides what form your answer should take, then builds it:

Ask about a trip, and get a map, a day-by-day itinerary and a place card, not three paragraphs.
Ask to compare two options, and get an interactive comparison with a slider for your budget.
Ask something simple, and get something simple. No dashboard for the sake of it.

The interface becomes an output of your intent and context, streamed to you as you need it, rather than a fixed container you navigate.

Why this might matter

Less learning, more doing. The best interface is the one you don’t have to learn. If the system meets you with the right controls, the learning curve shrinks.
Context as a first-class input. Where you are, what you’re doing, what you did a minute ago, which device you’re on. Interfaces today mostly ignore this. Generated interfaces could use it.
Right format, right moment. A map when you need direction. A form when you need to enter data. A single button when that’s all it takes. Same product, different shape.
Accessibility by default. An interface generated for you could adapt to how you perceive and interact: larger targets, simpler layouts, voice-first flows, without a separate “accessibility mode” someone had to build.
Software for the long tail. Many needs are too niche for anyone to build an app for. If interfaces can be composed on demand, a one-off task could get a one-off tool.

What has to be true first

I don’t want to oversell this. Several hard problems sit between the idea and something people would trust:

Consistency. People build muscle memory. An interface that reshuffles itself constantly is exhausting. Where should it stay stable, and where should it adapt?
Trust and safety. Generated interfaces can take actions. Users need to see and control what happens, especially with money, data and permissions.
Speed. If it takes ten seconds to build a screen, a static one wins. Streaming and partial rendering matter a lot.
Design quality. Generated is not the same as good. Taste, hierarchy and restraint need to be built into the system, not left to chance.
Predictability for builders. Product teams need guardrails: brand, components, constraints. The likely path is models composing from a trusted design system, not drawing pixels freely.

What I’m exploring

Right now, noui.si is a place to think in public. I’m interested in small experiments: what the building blocks of a generated interface might be, how context could shape them, and where this clearly beats a traditional UI (and where it doesn’t).

I’ll share what I learn, including what doesn’t work.

An invitation

If you design, build or think about interfaces, I’d love your perspective. Where would you want software to adapt to you? Where would it frighten you? What’s the first use case you’d trust?

Not another interface to learn. An interface that meets you where you are.

That’s the direction. I’ll keep exploring.

Follow along at noui.si