GenAI products present teams with an unfamiliar challenge: answers arise contextually, emergently, and sometimes unexpectedly. Anyone responsible for such a product soon realises that the usual tools no longer work. Feature lists, acceptance criteria and deterministic user stories all reach their limits when the core of the product is a language model.
The crucial question is therefore no longer simply: ‘Does the feature work?’ but rather: ‘Do our users trust what the system does?’ With GenAI products, trust is not just a soft, secondary attribute. It is a core product quality. This makes UX a key responsibility for everyone in charge of GenAI products.
Contents
- UI, UX and why the distinction is crucial with GenAI
- The trust issue: users believe too much or too little
- Magic sells well, but honesty goes further
- Managing uncertainty: practical approaches for day-to-day product work
- What this means for your role in the product team
- Conclusion
UI, UX and why the distinction is crucial in GenAI
In project practice, UI and UX are often used interchangeably. This distinction has always been relevant. With GenAI, it becomes a fundamental requirement. UI refers to the actual interface: buttons, input fields, layouts. UX encompasses the entire experience: how does the interaction feel? Does it provide clarity or cause confusion? Does it build trust or erode it?
In traditional software, these two levels are often closely intertwined. When you click a button, you experience a clear response. Action and outcome are predictable. For years, the design of digital interfaces was based on this unspoken assumption: systems are controllable, and what is controllable can be managed through design – via clear interaction patterns, visual consistency and hierarchical navigation.
With generative AI, this controllability has disappeared. The actual interface is language – open, ambiguous and bidirectional. The system’s response is not a predefined output, but an event that only takes shape at the moment of interaction. The system’s behaviour becomes the user experience.
For product teams, this has a direct implication: UX is no longer a downstream design task. It begins with the question of how the system communicates with users. This question must be embedded in the backlog, in the refinement process and in the product strategy.
The trust issue: users believe too much or too little
Anyone observing GenAI products in practice will encounter two contrasting types of user.
Type 1: The convinced. They ask a question and accept the answer without questioning it. The system’s linguistic fluency creates a false sense of security: the more confident an answer sounds, the more likely it is to be taken as true. This effect is reinforced by the public debate surrounding terms such as ‘superintelligence’. When the media and tech companies hold out the prospect of virtually omniscient systems, the logical conclusion for users is: why should I doubt it?
Type 2: The sceptics. They have once experienced the system making a false claim – whether a fabricated source or a factually incorrect detail – and now mistrust everything. For these users, trust does not collapse at the first mistake. What matters is how the system handles the error: does it signal uncertainty? Does it allow for correction? Does it offer an alternative perspective?
Added to this is a psychological mechanism that has a particularly strong effect with GenAI: people project human categories onto systems that operate linguistically. They expect the system to ‘stand for something’ – a stance, a role, an ethic. This phenomenon of projectivity is not a fault on the part of users. It is a psychological automatism. A system that displays no stance and communicates no boundaries triggers either blind acceptance or deep mistrust. Both are dangerous.
For product teams, this means that trust is a product quality that must be actively designed. It does not arise of its own accord simply because the system functions well enough.
Magic sells well, but honesty goes further
It happens regularly in the early stages of a project: the new AI system is introduced with superlatives. It ‘understands’ the user. It ‘knows’ the answer. It ‘learns’ from every interaction. This language is tempting. It goes down well in demos and stakeholder presentations.
The problem is that it creates expectations that no real-world system can fulfil in the long term. When users experience the first ‘hallucination’, the first factual error, the first unsatisfactory answer, it is not just the AI illusion that crumbles. Often, trust in the entire product crumbles with it.
The psychological reality is sobering: people are more likely to trust systems that show their limitations than those that pretend they have none. Systems that appear too perfect seem uncanny. They fascinate in the short term, but they do not build lasting trust.
What is the alternative? Honesty as a design principle. A system that acknowledges uncertainty, makes context visible and keeps sources transparent comes across as more credible than one that always sounds infallible. This does not mean highlighting weaknesses. It means designing the system to be human, not flawless.
Our recommendations:
Examine the language used to describe your product. What expectations does it raise amongst the team, stakeholders and users? And are these expectations realistic?
Managing uncertainty: practical approaches for everyday product work
If trust is the key product quality, the practical question arises: how do you design for it? The answer lies not in elaborate UI redesigns, but in a new approach to language as a design material. The following elements have proven their worth in practice:
- Uncertainty markers: The system actively signals when a response is based on uncertain grounds, for example through phrasing such as ‘There are conflicting sources on this point.’ This provides guidance without undermining the system’s authority.
- Contextual comments: The system briefly explains the basis for its assessment. Not as comprehensive technical documentation, but as a clear indication of its own line of reasoning.
- Source references: Transparency regarding the basis of an answer enables users to evaluate and verify it for themselves.
These elements can be understood as linguistic design patterns – reusable building blocks that make UX visible. Not as pixels, but as behaviour.
The following table shows the difference between traditional and GenAI-specific UX logic:
| Traditional UX logic | GenAI UX logic |
|---|---|
| Clear input → predictable output | Open-ended input → emergent response |
| Avoiding errors | Classify errors and provide constructive guidance |
| Control through interaction patterns | Trust through transparency and dialogue |
| UI shapes the interface | UX shapes the system’s behaviour |
| The user operates the system | The user and the system engage in a dialogue |
This new UX logic requires a shift in thinking, away from the interface and towards the experience. This experience is not created in the design programme, but in every single interaction between the user and the system.
What this means for your role in the product team
Whether you’re a Product Owner, designer or developer, together you decide what the product does and how it feels. With GenAI products, the whole team is responsible for the trust that users develop in the system. This changes the team’s day-to-day work in three areas:
1. Incorporating UX earlier in the process
Building trust is not a task for the final sprint review. It must be integrated into the product strategy. Questions such as ‘How should the system respond to errors?’ or ‘Which language builds trust and which does not?’ are product questions, not design questions.
2. New questions in the backlog
Add a new category to your set of requirements: quality of interaction. How should the system respond when in doubt? What happens if the answer is uncertain? How does the system communicate its own limitations? These questions cannot be answered once and for all. They must be developed iteratively, through practice.
3. Treat language as a product feature
With GenAI products, language is not merely a channel of communication. It is the product. How the system phrases its responses, whether it asks for clarification or answers directly, whether it signals uncertainty or glosses over it: all of this can be shaped. And all of this has a direct influence on how users experience and evaluate the product.
Our recommendation: Involve UX expertise early on in the process. Not to design screens, but to shape the system’s behaviour. And carry out regular user tests, focusing on the key question: “Does the user trust what the system says?”
Anyone who consistently takes these three areas into account doesn’t just change the product. They change the way the whole team thinks about GenAI.
Conclusion
GenAI is not just changing the technology behind digital products. It is changing what good product design means. Trust is not a side issue that the UX team will sort out at some point. It is a key quality for which the entire product team is responsible right from the start.
Trust can be shaped. With honesty rather than magic, with transparency rather than a display of omnipotence, with language as a conscious design tool. Product teams that understand this and integrate it into their day-to-day work develop products that win over users – sustainably and for good reason. That is what sets digital champions apart: they do not rely on short-term fascination, but on genuine trust.
This article is based on insights from the book “When Is It Good Enough? Softwareprojekte im Zeitalter generativer KI” by Dr. Felix Böhmer, Dr. Tehseen Rug, and Tessa Pfattheicher (iteratec).
