How designers adapt as interfaces become generative and disposable

For most of our careers, designing software has meant designing interfaces. Screens, flows, navigation, states. When something didn’t work, the answer was usually to redesign the UI.

That mental model is starting to change.

As AI agents and generative systems become more capable, the interface is no longer the only, or even the primary, way people interact with software. Interfaces are becoming cheaper to create, easier to tailor to a specific moment, and less necessary to keep around forever.

This raises an uncomfortable question for designers and product teams: if interfaces no longer need to be durable by default, what are we actually designing now?

This article explores that question, what’s changing underneath it, and what it means for how we design, build, and run products in the future.

Durable, persistent interfaces are all we’ve ever known

For as long as we’ve been designing, the interface has been the product.

When you bought software, you were buying a bundle of screens and flows for performing tasks.

The advent of AI agents is challenging this approach.

Generative AI and agentic systems are changing the economics of pixels. They’re no longer scarce or expensive to produce. Even if the quality isn’t perfect yet, once pixels become cheap and contextual, the interface no longer needs to be durable (permanent, or non-changing) by default.

What does this mean for UIs?

• Instead of designing a single interface to serve everyone, which is expensive to overhaul and update, the product can anchor itself in a durable core: the data models, business rules, permissions, workflows, audit logs, and domain logic that define how the system works.
• On top of that, it can generate contextual, in-the-moment interfaces on demand, only when they’re actually needed.

In this way, the interface isn’t something you learn once and expect to stay the same. Parts of it are created on demand, shaped by intent, and exist only to support a specific decision before fading away.

The world that shaped long-lived interfaces

To understand why this feels so disruptive, it helps to remember why coherent, long-lived interfaces became the default in the first place.

For decades, interfaces were expensive to produce.

Designing and building UIs takes time, careful planning, extensive iteration, and many rounds of design and development. Add to that QA, localization, documentation, training, and often extensive cross-team coordination. Once an interface is shipped, you want to amortize that cost for as long as possible.

Because of that, one interface has to work for everyone. It doesn’t matter much if it fits your exact needs or preferences. The interface had to be shared by thousands or millions of users across many different workflows, and it had to stay stable so people could learn it once and use it again and again.

Organizations naturally optimize around this reality. They invest in opinionated interaction design, rigid navigation structures, and strong mental models. They build training programs, certifications, and change management processes to help people adapt to the software, rather than the other way around.

Stability isn’t just a design choice; it’s an economic necessity.

That model makes sense when every pixel has to be carefully designed and agreed on up front. The challenge, and the opportunity, is that the way we design and experience interfaces may soon look very different.

How software is decoupling

This change in how we design interfaces didn’t come from a single breakthrough, but from several self-reinforcing developments maturing at the same time.

• First, generative UI enables the creation of full-screen experiences and interfaces from text or context, challenging the idea that every screen needs to be carefully designed in advance.
• Second, the way we think about UI is changing. Instead of permanent pages, we’re seeing more ephemeral, throwaway, hyper-contextual panels. Interfaces can appear for a specific task, work on top of the same durable core, and then disappear once that task is done. We’re already seeing early versions of this in tools like chat-based assistants, natural-language analytics, and AI-powered IDEs, where interfaces appear as temporary panels or artifacts in response to a specific task, then fade away once that task is complete.
• Third, software is increasingly acting on our behalf. Instead of a person clicking through menus and dashboards, an agent can take an instruction, call the right APIs, and generate exactly the UI needed in that moment, like a chart, table, or summary panel. People are already doing this today, asking a system for a specific view of their data and getting it back instantly, without ever opening a traditional dashboard.

Taken together, the interface stops being a fixed place you navigate and starts behaving more like a response to what you’re trying to do, shaped by intent and context rather than something you have to search through.

This doesn’t mean all interfaces are constantly changing. There is still an important role for durable UI in products, especially for navigation, onboarding, and shared understanding.

What changes is what sits underneath the surface. Instead of maintaining hundreds of rarely used pages, many of those experiences can be generated on demand. This is especially true for low-traffic views and one-off decision panels that are expensive to design and maintain but rarely revisited.

The result is a product with a stable surface people recognize and rely on, and flexible, task-specific interfaces that appear only when needed.

Imagine a customer service software scenario

What this change means for designers, teams, and product strategy

This changes what it means to design, build, and run products in the first place.

For designers, the center of gravity moves away from designing specific screens and flows. The work becomes more about defining how systems generate the right interface at the right time.

That includes defining patterns and constraints, and setting the rules that govern how UI appears across different contexts. In practice, designers focus less on individual screens and more on shaping how user intent turns into an interface, without surprising or overwhelming people.

For PMs, the questions change too. Instead of asking, “What page do we build next?”, the focus moves to intent and outcomes. What kinds of tasks should the product support? Which state changes need to be safe and auditable? Where is human judgment required, and where can things be automated? Product thinking moves upstream, closer to decisions and consequences, rather than pages and features.

For engineers, especially those working on the front end, the job becomes less about pushing pixels and more about building reliable foundations for generation. That means stable agent interfaces, strong validation logic, clear boundaries, and systems that support composability without breaking trust. The UI becomes thinner, but the underlying structure has to be more robust.

Where durable UI still wins

There are still areas where a durable UI matters. Complex, high-stakes work relies on cognitive mapping and spatial memory. People performing tasks in fields like finance, healthcare, or incident response depend on familiar layouts and predictable behavior. Constantly changing interfaces add risk in those environments.

Regulated contexts also demand durability. Audit trails, training, and compliance require reproducible flows. You need to be able to show exactly what someone saw and approved, which is hard to reconcile with fully ephemeral interfaces.

Team collaboration is another place where durable UI remains important. Shared work needs shared views. People need common reference points, and teams need ways to pin, share, and standardize what they’re looking at.

What actually becomes valuable

As this transition plays out, what makes products successful starts to change.

Winning products are easy for agents to work with. They have clean schemas, predictable behavior, strong safeguards, and clear boundaries. They are composable and reliable, which makes them useful building blocks in larger systems.

Products that struggle tend to rely too heavily on the interface itself as the value. If the main differentiator is a beautiful UI or a carefully controlled monolith that users must live inside, that advantage erodes quickly once people can generate their own views on top.

The biggest impact is that the UI is no longer the moat. What matters more is the underlying system, how well it supports intent, and how safely it enables the on-demand generation of interfaces.

Advice for designers

As AI-generated interfaces become easier to create, the role of design changes. When UI is no longer something you carefully handcraft once and ship to everyone, design moves upstream. The work shifts away from perfecting individual screens and toward shaping how systems behave, make decisions, and respond over time. In this world, designers gain a different kind of responsibility.

Below, I share practical guidance for designers, covering when generated interfaces work, when they don’t, and how design systems, reversibility, and clear boundaries help them feel usable and trustworthy.