UI unlocks AI

October 23, 2025

In 2022, thousands of developers had access to GPT-3.5 through the OpenAI playground. It was impressive but clunky: one prompt, one response, start over. Most shrugged and moved on.

Then in November, OpenAI launched the exact same model wrapped in a familiar chat interface. Within a week, ChatGPT became the fastest-growing application in history.

The model didn’t change, but the UI did.

And everything unlocked.

This pattern isn’t new. When Facebook switched from its wall profile-centric design to the newsfeed, many decried the destruction of their favorite social media platform, but the switch was undeniably effective. Recommendation algorithms allowed for dynamic personalization, and the infinite queue of the newsfeed catered to our every desire. Facebook usage skyrocketed, and other platforms quickly followed suit. Today, you would be hard-pressed to find any app that doesn’t incorporate some type of infinite news feed. Even boring enterprise apps like LinkedIn rely on infinite scroll feeds to keep their users engaged.

Similarly, the core catalyst was not technology-driven, but it was driven by a user interface (UI) development. Recommendation algorithms had been around for many years before and were already very well-understood. Yet, the full power of these algorithms was finally unleashed with the infinite feed UI transition.

Technology often follows this pattern: a deep technical breakthrough might lie dormant for years, and then the right UI introduction unlocks mass adoption.

This same technological arc is happening in generative AI, so I’ve been hunting for interesting AI-native UI patterns.

AI-native UI

What does it mean to be an AI-native product?

Perhaps the product has AI functionality as first-class primitives (e.g., RAG search, multi-agent inference, etc.) upon which the rest of the tech stack builds. Perhaps the UI itself is dynamically constructed with malleable components generated by a central LLM, or it’s a clean interface allowing seamless human-agent collaboration. At the moment though, the space is in such flux with so many different experiments, that it’s hard for people to have conviction in what these AI-native design elements actually are.

My current working approach: an AI-native UI surfaces unique model abilities, keeps state legible, and lets human users steer and recover. It trades static forms for continuous guidance, shows what the model knows and is doing, and makes correction cheap.

It reflects the underlying principles of classical product design:

A well-designed product communicates how it works at a glance, aligns with users’ mental models, guides action through clear cues, keeps the user informed through timely feedback, prevents (or gracefully recovers from) errors, and leaves people feeling competent — even delighted — rather than confused or powerless.

Delightful patterns

While I’ve tried and evaluated a bunch of different AI tools, there have been a few particularly salient examples in which I’ve been delighted with the experience.

  1. The chat loop (ChatGPT)

    • Why it works: zero-learning-curve, immediate feedback, safe to poke.
    • Design test: “Can a first-time user succeed in one turn and see what to try next?”
    • Failure mode: chat that tries to replace structured work without tools, sources, or memory.

  2. The embedded workbench (Cursor)

    • Why it works: keep conversation, code, and context in one place; reduce copy-paste thrash.
    • Design test: “Did we remove context switches and make the model’s view of the project visible?”
    • Failure mode: opaque context; hard to audit changes or revert.

  3. Ambient notes to structured output (Granola)

    • Why it works: meet users where they already take notes; anchor the model’s attention with human highlights.
    • Design test: “Does the tool respect social context and produce summaries people can trust?”
    • Failure mode: poor attribution and hard to correct errors.

  4. Split-pane agents (Devin)

    • Why it works: talk on the left, see actions on the right, scrub history to audit.
    • Design test: “Can I watch the plan, pause, step in, and undo?”
    • Failure mode: flurries of opaque tool calls; no checkpoints or reversibility.

Waxing poetic

ChatGPT: As I mentioned before, the turn-by-turn conversation UI for ChatGPT unlocked everything. The chatbot design is something that everyone is familiar with. The chatbot model is an incredible entry point because there is immediate feedback at first interaction — you say hello to the language model, and it says hello (and more) back instantaneously! When I first introduced people to ChatGPT, they would always start by saying hello to the model, be blown away by the first few interactions, and then proceed to experiment with other types of questions and queries. From a product perspective, there aren’t many ways to “break” the product, because it’s just a chatbot.

Cursor: I will never go back from using an agentic/AI IDE to write code — Cursor has changed that for me forever. When I first saw Cursor’s launch/demo video, it immediately clicked for me: instead of copying-and-pasting code from ChatGPT into VS Code, why not keep everything in one environment and minimize context switching? Because Cursor forked VS Code, the adjustment felt trivial, with the same IDE form factor but augmented with thoughtful AI bells and whistles (codebase indexing and understanding, agent workflows, context chips and context managers) to help me program more effectively. I didn’t have to re-learn anything or re-design my workflow to use Cursor; instead, it just felt seamless and granted me new coding superpowers. I felt “delighted — rather than confused or powerless.”

Granola: For years, I have been tried countless meeting note applications. They were always clunky and finicky, somehow chock full of different features but never doing things well. Granola is extremely well-designed and is simply a delightful experience. The form function is a simple notepad where you can jot down quick notes throughout the meeting, which mimics the way we naturally take notes; these phrases and words serve to anchor the LLM to summarize most pertinent and important details in the meeting, and the quality of the notes shows. Granola also records at the computer system-level, which means there isn’t the annoying AI meeting companion that requests to join the meeting. Granola doesn’t have any of these issues and actually makes the note-taking process seamless and human.

Devin: I have not used Devin as extensively as I have for the other tools, but they popularized such a prevalent UI element that I must cover it. In their original viral launch video, the Devin team demonstrated their coding agent product, featuring a split pane with a chat window on the left and a coding workspace on the right. This “split pane” view for agentic interaction is extremely intuitive — speak with the agent on the left side, see what it does on the right side, and bounce back and forth between the panes. It took only a few seconds to realize that this split pane view was incredibly useful.

A rubric for UI product-market fit

Great AI UI hits a Goldilocks zone where three things converge:

  • Familiarity: close enough to current habits to start instantly.
  • Model leverage: the UI exposes something the model is uniquely good at (reasoning across long context, tool use).
  • Feedback and control: the system shows its state, cites sources, and supports steering and quick reversibility.

Just as the infinite newsfeed unlocked recommendation algorithms and the chat interface unlocked GPT’s, we’re now watching the next chapter unfold. There are countless UI experiments running in parallel across so many different products, each testing different theories about how humans and AI should collaborate.

Some will fade. Some will become as ubiquitous as infinite scroll.

But the winners will share that Goldilocks quality — familiar enough to adopt immediately, powerful enough to make the old way feel obsolete, and transparent enough to keep us in control.

The AI-native UI that wins likely won’t be the one with the smartest model.

It will be the one that makes us feel smarter.

If you’re exploring in this domain, I’d love to learn from your experiments. Send me screenshots, successes and failures, design tests, and anything else!