Dynamic UI is the future of interfaces
Do we need hyper-personalization or just better cohorting?
GUIs represent a structural inefficiency in software design. These static interfaces optimize for the median user while forcing the tail to perform cognitive labor to adapt the product to their needs. I believe the next step function in software value will not be better static design, but "GenUI": interfaces that adapt probabilistically to user intent in real-time. And no, while voice and national language will increasingly become the interfaces to talk with software, they will never be an absolute replacement of GUIs.
The thesis for Dynamic UI originates from observing my friend, who is slightly on the ADHD spectrum. Every time he opens a YouTube video, he immediately clicks on the speed 2x button. It is a reflex; the interface, in its default state, fails him. He is forced to fight the UI to match his cognitive tempo.
This behavior is a proxy for a systemic inefficiency in modern software. We have built an entire industry - SaaS tools, Product Ops job roles, and optimization frameworks - around improving static UX functions. We A/B test or segment users, but we almost never achieve true hyper-personalization.
We accept this friction as the cost of doing business. However, It is almost common knowledge that each improvement in user onboarding, decrease in friction on key feature usage, or time to value has a material impact on the top line and retention. Yet, our current solution is to serve the same dashboard to a CTO and a Junior Analyst, hoping it satisfies both.
Enter Generative UI
I believe the future is dynamic UI, but the path there is full of traps.
Early trends that support that we are already walking this path are Google's latest research on Generative UI, and commercial takes from companies like Fibr or Coframe, which optimize website landing pages; Mutiny AI, which personalizes website copy; and Thesys, an API layer that builds adaptive UIs in real time.
But the transition from static UI to Generative UI will not merely be a frontend trend; but an infrastructure upheaval. We will be moving from pre-stock valid options (buttons, forms) to a model where users' intent is predicted, and the system assembles the solution from raw primitives. This shift breaks the fundamental assumptions of how we build, test, and ship software. The winners in this space will not just be the ones who generate the best UI, but the ones who solve the Latency-Cost-Consistency Trilemma
How this stack could look like?
1. The Intent Classification Layer (What needs to be generated)
In a GenUI architecture, the URL is no longer the primary source of truth for layout. Instead, the user’s prompt or behavioral signal (e.g., hovering, rage-clicking, previous session context) is sent to an inference router. This router classifies the intent against a vector database of capabilities. Quick inference time, pre-saved memory and preferences would be the key to solving the intent classification layer.
2. The Component Registry (Do we generate or just pull)
GenUI means the LLM writes HTML/CSS from scratch for every user and every use. This is, however, the golden end state, but a trap in the short term. Allowing an LLM to generate raw DOM elements leads to hallucinations, broken layouts, and security vulnerabilities, not mentioning the high cost of doing so at scale.
Instead, the "Design System" becomes an API. We treat React Server Components as "tools" that the model can call. The model doesn't output <div class='chart'>...</div>. It outputs a function call: renderrevenuechart({ data: x, type: 'bar', colorscheme: 'darkmode' }). The frontend runtime then executes this function, rendering a pre-validated, brand-safe component.
This approach fundamentally takes the stack away from an n=1 personalization, but as most scaled-up consumer solutions would suggest, there are only so many cohorts that you need to make.
3. The Orchestration & Streaming Layer (How fast can we do it)
This is the most critical technical unlock. LLM inference is slow, UI generation will be slower. Streaming improves time-to-first-response, but it doesn’t make the underlying generation fast. A standard web app has <100ms latency. In most cases, even a 1-second latency would be fatal.
I believe a key unlock would also come from the likes of user-simulating agentic swarm engines like Sanctum or Featurely. These could solve two problems: categorize users' interactions and behavior into a particular demographic cohort, and generate a personalized UI. While also effectively solving the non-deterministic testing problem. If the UI generates an unclickable button, Sanctum's agents detect the regression before a human does.
Pros and cons. Is this even a paradigm worth pursuing?
The Pros (Why this is inevitable)
1. Retention & Time-to-Value: Friction kills retention. If an AI can predict that a user wants to execute a trade and presents a "Buy" button immediately, skipping three navigation steps, the impact on the top line is material.
2. Accessibility: GenUI can be the holy grail for accessibility. For a visually impaired user, the system could strip away all decorative CSS and present a high-contrast, text-heavy interface automatically. For a user with motor impairments, it could enlarge hit areas. GenUI could be a big step in reducing barriers to learning a new technology and can take even complex systems to the masses.
3. End of "Feature Bloat": Current SaaS platforms are cluttered with features 90% of users don't use. With GenUI features only appear when relevant to the context.
The Cons (The traps)
1. The Latency Penalty: A widely cited Amazon study found that every 100ms of latency cost them 1% in sales. Latency, if unsolved, would be the grave for Generative UI.
2. Cost Economics: Any improvements in retention/usage by GenUI would be useless if the cost for generation doesn't outweigh benefits. Current LLM tokenomics do not support this. We need SLMs running on edge inference to make this viable.
3. Hallucinations & Brand Safety: An LLM might generate a "Delete Account" button in green (primary color) instead of red (danger color), or invent a discount code that doesn't exist.
4. Muscle Memory: Users rely on spatial consistency. "The save button is always top right." If the UI is too dynamic, it breaks muscle memory, actually increasing cognitive load rather than reducing it. There is a sweet spot somewhere in the middle, and maybe true personalization is not needed.
So do I feel that the way I use YouTube is unique to me and hence demands a personalized interface for me? Probably not. But I still believe that my note-taker app would benefit from accepting some eccentricities that come with the way I manage my schedule and processes. Personalization of technology would not just be around memory, but also the interface.
Would apps just include dynamic surfaces, or would a Wabi, which focuses on a personalized app for every user, fill in the much-needed user personalization gap?