David Hoang — Notes

Dynamic Interfaces

Sat, 04 Apr 2026 00:00:00 GMT

Introduction: why interfaces are the unsettled layer

The software interface layer is the least understood—and most unsettled—part of AI-era computing.

Every major computing shift goes through an awkward adolescence. Early versions look primitive in hindsight, not because the ideas were wrong, but because the interaction grammar had not yet been invented. The first release of iPhone OS famously lacked copy and paste. Touch computing existed, but its affordances were incomplete. A few years later, interactions like pull-to-refresh became so natural that we forgot they were ever invented.

Dynamic Interfaces (structured outline)

Introduction / thesis: what dynamic interfaces are

The software interface layer is the part of AI-era computing that remains least understood and most unsettled.
Early versions of new interaction paradigms always look primitive in hindsight (e.g., iPhone OS lacking copy/paste, pull-to-refresh emerging from Tweetie).
Current AI interfaces—especially chat—are transitional forms, not the final pattern.
Dynamic interface describes systems that redesign themselves based on feedback, intent, and context.
Unlike responsive design or personalization based on cohorts, dynamic interfaces tailor the interface itself to individual users.
As computation accelerates and learning cycles shorten, the interface can evolve continuously, not in slow human-run experiments.
The future interface responds to behavior, preference, environment, and task—not just display dimensions.

A new MVC

Summarized by Dia.

Context: Traditional MVC separated data, UI, and logic; AI and decentralized protocols (like MCP) are shifting this toward dynamic, agent-orchestrated, distributed systems.

End users control and store their own data.
Data also becomes inferred and summarized from LLMs.
Context windows.
Apps become interchangeable views over personal data stores.
Interfaces are declarative queries across distributed data, not bespoke APIs.

New MVC

LLMs as models: probabilistic, continuously trained systems—“grown, not built.”
Apps as views: UI layers that render, query, and pass data; portability over storage; interoperability by design.
Agents as controllers: interpret, plan, and coordinate actions across systems via protocols like MCP; real-time context switching.

Implications

Shift from app-centric to system-centric product experiences.
Managing endpoints, protocols, and interactions replaces monolithic codebases.
Vendor lock-in becomes a liability; AI interfaces act as meta-layers across apps.
Software is decoupling, enabling portability, ownership, and agent-driven orchestration.

Model

Models expand beyond a single datasource into LLMs, APIs, external datasets, and federated data. Users may choose models, build their own, or bring their own dataset (BYOD). Models become negotiable components, not fixed infrastructure.

View

The “view” becomes less about fixed screens and more about interface surfaces spanning devices and contexts. Influenced by Ruben Verborgh’s “apps as views” concept. Universal Control, Stage Manager, and AR environments hint toward interfaces that float across display boundaries. Views adapt not only in layout but in function, depending on the task and context.

Controller

The controller evolves most. Interaction is no longer exclusively initiated by the user; agents and AI controllers act on behalf of the user. User input remains the ground truth, but AI can propose or execute adjustments. The controller mediates between human intent, model capability, and interface behavior.

Non-deterministic workflows

Many AI-era flows won’t behave like fixed scripts: paths branch, retry, or adapt based on model output, tools, and context.

Context and ambient experience

Dynamic interfaces interpret context beyond device state (e.g., Focus modes, presence near a device). Software anticipates needs through richer contextual signals: environment, behavior patterns, ergonomics, accessibility preferences.

Multi-device experiences proliferate: phones, tablets, computers, wearables, XR displays, and invisible or ambient devices. Future environments have too many surfaces to design manually for each form factor.

Interfaces become ambient: flowing across devices, resizing themselves, reprioritizing content, and responding to user needs without being explicitly summoned.

End user experience

Human-centered by design

Personalization becomes possible with memory. Even when content was personalized to the end user, the interfaces were built in such a rigid way they didn’t get the value of it. Dynamic interfaces amplify human-centered design rather than threaten it. Users retain free will, not just “control.” Interfaces should be aligned with natural cognition.

Cognitive efficiency

Interfaces should minimize cognitive load (Jef Raskin’s framework).

Malleable software

Chat interfaces often hide complexity rather than reduce it. Dynamic interfaces can surface appropriate UI controls to replace or complement prompts.

UI as an abstraction layer

UI controls handle complexity for the user—e.g., style dials or sliders that modify multiple underlying properties. Products like Flair AI show how generative UI elements can help users steer outcomes without writing extensive prompt text.

Personalized accessibility

Humans are historically poor at prioritizing accessibility; machines can adapt interfaces in real time. Dynamic interfaces allow per-user adjustments for color, contrast, ergonomics, reading needs, and more, based on feedback inside the app.

Feedback loops

Feedback is no longer limited to formal usability sessions. Users provide input through natural language, gestures, screenshots, or in-context signals. The system iterates immediately, adjusting layout, hierarchy, or flow.

Configurable dynamism

Users choose how dynamic they want their interface to be—from fully static to highly adaptive. Choices include:

Which models or algorithms to use
How views are customized
What logic the system can automate

Dynamic interfaces support personal software—software that builds itself around the user.

How we build dynamic interfaces

Design tools evolve into hybrid design–development environments

A future IDDE (integrated design and development environment): drawing or manipulating UI elements impacts functionality directly (similar to visual development tools). Tools like Figma will likely blend vector drawing, component authoring, logic definition, debugging, and automation.

Abstraction as a spectrum

Both high-level abstractions (no-code) and low-level control (code) are needed. Tools must help users move along the abstraction spectrum depending on skill and intent. Sophisticated concepts should not be introduced before users are ready; too much abstraction limits capability.

Extensibility and interoperability

AI models and agents will pressure walled gardens to open up. Interoperability becomes mandatory. Authoring environments must be extensible to accommodate numerous data sources, models, and agent workflows.

Defining what is “designable”

Developers and designers specify which parts of a UI can be modified dynamically and which remain fixed—analogous to IBDesignable in Xcode: declaring what the system may alter. Users could define constraints (e.g., what they want more or less of) that guide the system’s reconfiguration.

Developer-defined abstractions

Not all users need to understand raw code or agent orchestration. Libraries of logic, integrations, and templates will exist alongside component libraries. Collaboration requires multiple layers of comprehension and abstraction.

Structured and unstructured prompt criteria

Chat and direct manipulation can coexist. Adobe’s generative features point toward hybrid workflows where prompts trigger structured options. Prompts invoke intent; UI refines and executes it.

Conclusion

Dynamic interfaces are not a futuristic invention but a continuation of decades of software evolution. The opportunity is to connect past concepts with new capabilities and steer them toward human needs.

As interfaces become dynamic, software becomes more personal, adaptive, and humane—not more opaque. The goal is not AI designing everything for us, but AI helping us spend less time wrestling with software and more time on the work—and relationships—that matter.

Open questions

Where does predictability (learnable affordances) trade off against adaptation (right control at the right time)?
How do we avoid mode chaos when the interface can reshape itself?
What patterns count as dynamic but still feel designed—not arbitrary?

AI Interface Systems

Wed, 15 Jan 2025 00:00:00 GMT

Early thoughts on how AI is fundamentally changing interface design...

Terminal / Command Line - Traditional OS: CLI (bash, zsh) - AI OS: LLMs (text, voice) - What’s changing: - Language becomes the universal command surface - Power shifts from syntax → intent interpretation - Prompting evolves into command composition and reuse

Process Manager
- Traditional OS: init, schedulers, background processes
- AI OS: Agents
- What’s changing:
  - Execution becomes continuous, not request/response
  - Agents decide when to act, not just how
  - Orchestration over time becomes the core capability
Kernel
- Traditional OS: Resource coordination, system rules
- AI OS: Plans (and logs)
- What’s changing:
  - Plans are no longer documents; they are coordination primitives
  - They constrain execution across humans + machines
  - Planning shifts from prediction to alignment and constraint
Filesystem
- Traditional OS: Files, directories, permissions
- AI OS: Information in files (not apps)
- What’s changing:
  - “File over app” becomes foundational (Kepano’s philosophy)
  - Apps stop being the source of truth; files do
  - Memory moves from opaque storage → inspectable structure
File Formats
- Traditional OS: Fixed formats (.doc, .jpg, .mp3)
- AI OS: Multimodal, metadata-rich files that can mutate and change based on context while retaining the original form
- What’s changing:
  - A “file” becomes a bundle of structured data + intent
  - Content can transform across text, audio, image, summary, plan
  - Format is no longer presentation-specific, but capability-specific
RAM / Working Memory
- Traditional OS: Volatile memory
- AI OS: Context windows
- What’s changing:
  - Context is abundant but fragile
  - Systems confuse recall with understanding
  - Long-term value comes from promoting context → files → plans
Device Drivers
- Traditional OS: Hardware drivers
- AI OS: Tools, APIs, system actions
- What’s changing:
  - Models don’t act directly; drivers translate intent into execution
  - Tool reliability becomes system stability
  - Permissions and scope become first-order concerns
Window Manager / Views
- Traditional OS: Desktop environment
- AI OS: Apps as Views
- What’s changing:
  - MVC decouples: models ≠ views ≠ controllers
  - Apps stop being “systems” and become projections of state
  - The same underlying data can render across many surfaces
Interface Layer
- Traditional OS: GUI, input devices
- AI OS: Dynamic, state-aware interfaces
- What’s changing:
  - Interfaces respond to what the system knows, not just user input
  - Chat is a bootstrap UI, not the end state
  - IDEs and OSes evolve toward adaptive, context-revealing surfaces
Interoperability Layer
- Traditional OS: IPC, system calls
- AI OS: Interoperability (not integrations)
- What’s changing:
  - Systems coordinate through shared primitives, not brittle glue code
  - IDEs and OSes become peers in a larger execution environment
  - Data, plans, and actions flow across boundaries by default
Security & Permissions
- Traditional OS: Users, roles, sandboxing
- AI OS: Identity, consent, memory access
- What’s changing:
  - Personalization requires explicit permission models
  - Memory access becomes as sensitive as file access
  - Without this, intelligence defaults to surveillance
Logs & Observability
- Traditional OS: Logs, stack traces, system monitors
- AI OS: Decision traces, plan diffs, tool histories
- What’s changing:
  - Trust comes from inspectability, not confidence scores
  - Systems must explain what happened, not just answer
  - Debugging intelligence becomes a core UX problem

A New MVC is Emerging

Sat, 04 Jan 2025 00:00:00 GMT

Traditional MVC separated data, UI, and logic. AI and decentralized protocols are shifting this toward dynamic, agent-orchestrated, distributed systems.

The old MVC

The pattern we've used for decades assumed:

Models were databases you controlled
Views were screens you designed
Controllers were logic you wrote

Everything was monolithic. Data lived in your app. UI was bespoke. Logic was deterministic.

The new MVC

LLMs as Models — Probabilistic, continuously trained systems. "Grown, not built." Models expand beyond a single datasource into LLMs, APIs, external datasets, and federated data. Users may choose models, build their own, or bring their own dataset.

Apps as Views — UI layers that render, query, and pass data. Portability over storage. Interoperability by design. The "view" becomes less about fixed screens and more about interface surfaces spanning devices and contexts. Views adapt not only in layout but in function.

Agents as Controllers — Interpret, plan, and coordinate actions across systems via protocols like MCP. Real-time context switching. Interaction is no longer exclusively initiated by the user. The controller mediates between human intent, model capability, and interface behavior.

What this means

Shift from app-centric to system-centric product experiences
Managing endpoints, protocols, and interactions replaces monolithic codebases
Vendor lock-in becomes a liability
AI interfaces act as meta-layers across apps
Software is decoupling, enabling portability, ownership, and agent-driven orchestration

The controller evolves most dramatically. User input remains ground truth, but AI can propose or execute adjustments. Non-deterministic workflows become the norm.

This note is extracted from my longer essay on Dynamic Interfaces.

AI as Creative Partner

Fri, 03 Jan 2025 00:00:00 GMT

Rough notes on something I've been thinking about...

The shift from tool to collaborator

Traditional tools are passive. You push pixels, they move. AI tools push back. They have "opinions" (even if those opinions are statistical patterns).

This changes the creative dynamic. It's less like using Photoshop and more like working with a very fast, very literal junior designer.

What I'm noticing

The best outputs come from iteration, not first attempts
Knowing what to ask for matters as much as the AI's capabilities
The "taste gap" still applies—you need to know good from bad
Speed enables experimentation in ways we haven't fully explored

Questions to explore

Does AI assistance atrophy certain skills?
What new skills does it require?
How does credit/authorship work?

This note is very early. Will revisit as I work with these tools more.

Design Systems Thinking

Sun, 15 Dec 2024 00:00:00 GMT

Design systems are often reduced to component libraries, but that misses the forest for the trees. A true design system is a way of thinking—a shared language and set of principles that guide how a team approaches problems.

Components are outputs, not inputs

When teams start with components, they're working backwards. Components should emerge from understanding:

What problems are we solving?
What patterns keep recurring?
Where do we need consistency vs. flexibility?

The three layers

I think about design systems in three layers:

Principles — The "why" behind decisions
Patterns — Reusable solutions to common problems
Components — The tangible building blocks

Most teams jump straight to layer 3 and wonder why adoption is hard.

Living systems

The best design systems evolve. They're not perfect—they're good enough, and improving. This requires:

Regular audits and pruning
Clear contribution models
Measuring what matters (adoption, consistency, velocity)

The goal isn't to build a perfect system. It's to build a system that makes the team more effective.

Building Product Intuition

Wed, 20 Nov 2024 00:00:00 GMT

Product intuition isn't magic—it's pattern recognition built through deliberate practice. The best product thinkers I know share a few habits.

They use everything

Not just products in their domain. They notice how grocery stores arrange aisles, how airports handle wayfinding, how games onboard new players. Every designed experience is a case study.

They ask "why" obsessively

Not just "what does this do" but "why did they choose this?" Every decision in a product is a bet. Understanding the bet helps you understand the thinking.

They ship and learn

Intuition without feedback is just guessing. You need the tight loop of:

Form a hypothesis
Build something
See what happens
Update your mental models

Open questions I'm still exploring

How do you balance intuition with data?
When should you trust your gut vs. test?
How do you transfer intuition to a team?

More to come as I think through these...