With GenUI coming, who’s redesigning Setup, Onboarding and Support?

Gemini 3 was just released and the growing idea of generative user-interfaces (genUI) and the concept of “malleable software”, we must ask the question… if every user has their own software/UI, how do we train, support and collaborate with them?

I’ve long believed that the future of software isn’t just smarter… it’s smarter about you. Imagine a digital interface that doesn’t ask you to adapt, but adapts to you and with you. A UI built just for you. Your tasks, your context, your pace, your language.

From Personalization to Individualization: The Promise of GenUI

We’re moving beyond standard personalization (“you like X so we’ll show you more X”) toward true individualization, which are UIs dynamically composed, shaped, and delivered for a specific user in a specific moment. Google’s Gemini 3 introduction includes a research paper on “Generative UI” showing that the model generates entire interfaces (not just text responses) based on user prompts. For example:

• In their experiments, a user asks“Explain how RNA-polymerase works”, and the system doesn’t just deliver text, it spawns an interactive layout, visualizations, filters and maybe a simulation.
• In the Gemini blog:“AI Mode in Search now uses Gemini 3 to enable new generative UI experiences like immersive visual layouts and interactive tools and simulations.”

As a designer and innovation-practitioner, this is deeply exciting: it means software becomes much less “one-size-fits-all” and much more “just-for-me”... or as we say at FreshForm a UME (Uniquely Meaningful Experience). Your interface and experience is crafted on demand, by a system that understands you, your context and your goals.

Malleable Software & the Designer Perspective

The notion of generative UI dovetails nicely with the concept of “malleable software”, which is software that isn’t rigid, static, versioned once and shipped forever, but rather is continuously adaptable, re-mixable, remix-friendly, and personal.

Malleable software supports not just one UI but many variants, many forks, many user-customized adaptations. It allows users (or even communities) to tweak, re-shape, extend, and reuse. In a world of generative UI, that’s a key enabler: the system may generate a bespoke UI, but that UI may also be adapted, re-versioned, shared, remixed. The software must be structurally ready for that.

In a recent episode of the podcast Dive Club the designer/engineer Geoffrey Litt talked about this future:

“...when I say malleable software, I do not mean only disposable software. Having shared environments that we all work in together that are predictable is also really important. Ironically, in some ways, I think sometimes malleable software results in more stable software because I have more control. So people really far away in some corporate offices aren't like pushing weird redesigns on me every day. I get to kind of organize my own house and keep it the way I want, you know, I think about long-lasting software that evolves gradually through use as the primary lens for thinking about malleability.” — Geoffrey Litt

Where the Challenge Kicks In: Training, Support amp; Collaboration

Here’s the crux: If every user has a unique UI, tailored to their need, their context, their language, then our existing paradigms for training, documentation, support and collaboration start to unravel.

• Training & Onboarding:Traditional training assumes a known UI, fixed menus, fixed workflows. If each interface is different, how do we build training materials? Do we train patterns instead of specific tools?
• Support & Help-desk:When a user calls for help (“I can’t find feature X”), the support agent typically asks “Which version of the UI are you using?” or “Under the menu path”. But if the UI is dynamically generated and unique, how do we identify their UI?
• Collaboration:If two users on the same software see different UIs, how do they collaborate, share workflows, or build together? How do teams communicate (“click the green button on the left”) when the green button on their interface might be somewhere else (or styled differently)?
• Versioning & Change Management:In a malleable environment, UIs may be evolving continuously. Who manages the lineage? Who verifies that the custom UI remains usable, accessible, and maintainable?
• Documentation & Knowledge Sharing:Knowledge bases assume one canonical UI. But if every UI is bespoke, do we need dynamic documentation that adapts per-interface? Or embedding of help inside the UI itself?

Or… I argue that we need to completely reimagine and redesign of what training, onboarding, and support looks like.

These aren’t just UX issues, they are organizational issues. They affect training budgets, support models, team workflows, knowledge-management practices and even compliance (for enterprise software). The promise of individualized UI is transformative, but there’s a risk of fragmentation and chaos without sufficient planning.

Designing for this New Reality: Some Practical Thoughts

Since you and I are both immersed in innovation, I want to offer a few practical ideas that can help navigate the transition from static UI to generative UI + malleable software:

• Shift training to pattern literacy not screen literacy.Teach the conceptual patterns (cards, interactive canvas, filters, workflows) and let the system translate to the user’s variant. Example: Instead of teaching people where every button “should be” in their unique remodeled house, teach them the core layout patterns; like knowing the kitchen is always near the dining area, no matter how they’ve customized it.
• Embed help and support in the UI itself via context-aware agents.If the UI is unique, let the support be unique too; an AI assistant that recognizes your UI and guides you. Example: It’s like having a contractor who knows your exact home, down to your custom cabinets and added sunroom, and can guide you through any fix or upgrade because they recognize your personal remodel.
• Promote shared abstractions for collaboration.Even if two users have different UIs, they might share underlying intents or workflows. Enable them to share the work flow intent(e.g., “create report”), not the exact menu path. Example: Even though each neighbor’s home looks different inside, everyone still understands shared intentions like “host a dinner” or “clean the garage”; so collaboration is based on purpose, not identical floor plans.
• Version and audit UI variants.In a malleable software environment, maintain an internal registry of UI variants, track who changed what and why, ensure accessibility/consistency. Example: Just like a community HOA keeping records of which homes added solar panels, updated plumbing, or expanded a room, the system tracks UI changes so safety, accessibility, and consistency stay intact.
• Design for remix and co-creation.Let users customize their UIs (to a degree) and share those customizations with peers. Malleable software doesn’t freeze the UI. Example: Homeowners share renovation ideas, like an open-concept kitchen or a built-in desk nook, and others adopt or remix them; the neighborhood evolves through shared creativity, not rigid sameness.
• Support multilingual and multicultural contexts.Your audience (designers, product teams, global users) benefits from interfaces that adapt language, cultural idioms and context. Generative UI + individualization is a big enabler here. Example: Think of neighbors customizing their homes with cultural touches, tile patterns, colors, symbols, while still living in the same community; generative UI does the same with language and context across users.

My Belief: The Future Is Unique UI + Shared Experience

I believe the future will allow users to learn and use software in a way so unique, it’s made just for them. It’s not a one-size-fits-all dashboard or fixed workflow anymore. Instead, you interact with software that recognizes you, your preferences, your goals, your context… and shapes the interface accordingly.

But, and this is the important caveat, the paradox is that while each UI becomes unique, the human practices around training, support and collaboration must become ever more universal. We must build systems and organizational patterns that accept variation but still enable shared understanding, shared workflow, shared help.

As Geoffrey Litt said in the Dive Club episode: “malleable software vs. disposable software”, the software that lasts and evolves is the one that invites adaptation, user-agency and remix.And with Gemini 3 now delivering generative UI capabilities, we are at the threshold of that shift.

If you are a designer, product leader or innovator, consider how your interface and experience strategy might evolve and ask:

• Are we building one UI for all, or are we enabling unique UI per user?
• How will we train a user if their UI might look totally different tomorrow?
• How will our support model handle variant experiences?
• How will our collaboration workflows remain coherent across variant UIs?

If you’re curious, I’d love to hear your thoughts: How are you preparing for this era of individualized interfaces? What training, support or collaboration approaches are you experimenting with?