New: Check out my latest blog posts

← All posts
Design4 min read

The Future of User Interfaces

Standard User Interfacing, Generative UI, and Agentic UI are not competing. The future belongs to products that seamlessly transition between all three.

The Future of User Interfaces

User interfaces are no longer evolving in a single direction.

Standard User Interfacing, Generative UI, and Agentic UI each occupy a different place on the complexity spectrum. They are not competing approaches -- they are complementary ones.

The Interface Spectrum

Mode                        Complexity   User Input      Example
----                        ----------   ----------      -------
Standard User Interfacing   Low          Discrete        Button click, dropdown
Generative UI               Moderate     Intent          "Summarise this document"
Agentic UI                  High         Goal            "Refactor and test this feature"

Standard User Interfacing

The foundation of every application. Low complexity, discrete actions.

Buttons, toggles, menus -- the building blocks users have relied on for decades. Standard user interfacing is what you reach for when users need precision and control.

Best for: frequent, short, repeated tasks. Financial transactions. Destructive operations.

Generative UI

Bridges traditional interfaces and autonomous systems by using AI to simplify complex workflows.

Rather than replacing familiar UI patterns, Generative UI layers intelligence on top -- turning multi-step processes into guided, conversational flows.

Best for: synthesising or transforming content, collapsing multi-step flows into one instruction.

Agentic UI

The user states an intent, and the system handles the rest.

Best for: long execution paths, cross-system coordination, tasks where human involvement in individual steps creates bottlenecks.

Why This Matters

The conversation should not be Standard User Interfacing vs Agentic. The future belongs to products that combine all three.

Task complexity low?    -- Use Standard User Interfacing
User knows outcome       -- Use Generative UI
User wants the result    -- Use Agentic UI

The best software will not replace one interface with another -- it will seamlessly transition between them, using the right interface for the right moment.

Real Product Examples of Each Mode

Standard User Interfacing examples:

  • Figma toolbar -- every action is discrete and reversible
  • VS Code settings UI -- checkboxes, dropdowns, explicit saves
  • A calendar app -- click a slot, type an event, save it

Generative UI examples:

  • Notion AI -- natural language that restructures a document
  • GitHub Copilot -- autocomplete that suggests entire functions
  • Linear write with AI -- drafts a ticket description from a brief note

Agentic UI examples:

  • Devin -- give a task, it opens a browser, writes code, runs tests, creates a PR
  • Claude Code -- state an objective, it reads the repo, plans, implements, tests
  • Zapier AI automation -- describe a workflow, it builds and runs the integration

What is striking: the best products combine all three. Figma added Generative UI while keeping the precision Standard User Interfacing. Linear has a traditional issue tracker with Agentic AI for triage.

Where Can You See These in Action?

You can experience these interface modes right now in production applications:

Standard User Interfacing:

  • Figma -- toolbar design system
  • VS Code -- settings and editor
  • Linear -- issue board and navigation

Generative UI:

Agentic UI:

For deeper context on how AI adapts to user needs across interfaces, see Google's research on Adaptive AI User Interfaces (A2UI).

How to Build for Multiple Interface Modes

Supporting all three modes follows a clear architecture:

Shared data layer. All three modes read from and write to the same underlying state. Same data, different interfaces.

Capability boundaries. Define what each mode can and cannot do. Agentic UI should not have write access to things the user has not explicitly granted. Generative UI should not make changes without preview and confirmation.

Progressive disclosure. Start with GUI. Introduce Generative UI for tasks the user does repeatedly. Surface Agentic UI for users who have demonstrated they understand the system.

What is Coming Next

Several trends accelerating over the next two to three years:

Proactive interfaces -- surfaces relevant actions based on context before you open the tool.

Adaptive complexity -- interfaces that simplify when you are in flow state and expand when you need options.

Cross-application agents -- Agentic UI operating across multiple applications. The browser becomes the coordination layer.

Reversibility as a feature -- as interfaces become more automated, dedicated undo-the-last-agent-action patterns will become standard.

The underlying shift: interfaces are moving from tools you operate to systems you direct.

Keep reading