Learn the 18 practical guidelines for Human-AI Interaction and discover how to design AI products that are clear, useful, controllable, and easier to trust. Explore expectations, context, errors, explanations, memory, personalization, feedback, controls, bias, and AI updates.
Table of contents:
- Why human-AI interaction needs its own design rules
- The 18 guidelines at a glance
- Three distinctions every AI designer should remember
- What the research actually found
- The 18 guidelines showed broad relevance
- Explainability still has a practical problem
- Bias needs more than a checklist
- How to use the 18 guidelines in a real UX process
- Don’t stop at the interface
- There are limits to the 18 guidelines
- What happens when guidelines conflict?
- A practical human-AI interaction checklist
- The bigger lesson for AI product design
- A simple principle to take into your next AI project
- Examples behind the 18 guidelines
- The researchers deliberately removed some guidelines
- Some guidelines are hard to see in a normal usability test
- The guidelines don’t replace AI ethics
- The guidelines have limits in high-risk products
- A final point the paper makes about model and interface design
- The most useful takeaway
AI can write, recommend, search, predict, filter, translate, recognize images, and respond to natural language. That sounds impressive, but good AI interaction isn’t created by model capability alone.
The real test starts when a person uses the product.
Does the user know what the AI can do? Do they know when it can make mistakes? Can they correct it when it gets something wrong? Can they understand why it made a suggestion? Can they control what it remembers or learns?
These questions sit at the center for a human-AI interaction designer.
The research paper Guidelines for Human-AI Interaction, presented at CHI 2019 by Saleema Amershi and a team of researchers from Microsoft and the University of Washington, brought together more than 20 years of work on the design of AI-infused systems.
The researchers distilled more than 150 AI-related design recommendations into 18 practical guidelines. They then tested those guidelines across 20 AI-infused products with 49 HCI practitioners.
The result is useful because the guidelines don’t ask designers to simply “make AI trustworthy.” That’s too vague to act on.
Instead, they turn that broad goal into things you can actually see in a product.
A button can be easy to dismiss. A recommendation can explain why it appeared. A system can show users what it can do and how often it may make mistakes. A setting can give people control over what the AI monitors.
That makes these guidelines practical for UX designers, product designers, researchers, product managers, and engineers working on AI products.
Let’s look at the 18 guidelines and, more importantly, what they mean in real product design.
Why human-AI interaction needs its own design rules
Traditional interface design often assumes fairly predictable behavior.
You click a button. Something happens.
You enter information. The system processes it.
You make a change. The interface reflects that change.
AI can behave differently.
An AI system often works with uncertain predictions. It can produce false positives and false negatives. Its output can change based on context, input, personalization, data, or later model updates. The same text can even produce different results over time.
That creates a different design problem.
Imagine an autocomplete system suggesting the wrong word. That’s annoying.
Now imagine an AI system filtering an important email into the wrong folder. That’s costly.
Take the same idea into healthcare, finance, transportation, or another high-risk setting, and a poor AI decision can have much bigger consequences.
So the interface needs to help people work with uncertainty.
The user doesn’t need to understand the model architecture. They do need enough information and control to use the system safely and effectively.
Here’s the key idea:
AI should work with people, not make people work around AI.
The 18 guidelines provide a practical way to think about that relationship.
The 18 guidelines at a glance
The researchers grouped the guidelines into four stages of interaction:
- Initially: What the user needs to know before using the AI
- During interaction: How the AI should behave during use
- When wrong: What happens when the AI makes a mistake or misunderstands the user
- Over time: How memory, learning, feedback, settings, and updates should work
This structure matters. AI interaction isn’t one moment. It unfolds over time.
The full set appears in Table 1 of the paper, with examples from activity trackers, music recommenders, navigation systems, web search, voice assistants, email, social networks, photo organizers, and other products.
Let’s take them one at a time.
Initially: Start with clear expectations
The first two guidelines deal with something designers often underestimate: expectations.
Before users can judge an AI system, they need to know what they’re dealing with.
1. Make clear what the system can do
Help the user understand what the AI system is capable of doing.
Don’t make users guess.
If your product can summarize documents, say so.
If it can recommend products, show that capability.
If it can detect movement, explain what it tracks.
If it can answer questions but can’t perform actions, make that distinction clear.
A user should have a basic mental model of the system before asking it to do something important.
The paper gives an activity tracker as an example. The product showed the metrics it tracked and explained those metrics, such as steps, distance, exercise time, and calorie burn.
This doesn’t mean filling the screen with technical documentation.
A short explanation can be enough.
For example:
“This assistant can summarize documents, answer questions, and extract key points. It can’t verify facts on its own.”
That’s much more useful than a vague label such as “AI Assistant.”
A useful UX question
If a new user spent 30 seconds with this feature, would they understand what the AI can and can’t do?
If the answer is no, the product has an expectation problem.
2. Make clear how well the system can do what it can do
Knowing what an AI can do isn’t enough.
Users need some sense of how reliable it is.
This is different from Guideline 1.
Guideline 1 asks:
What can the system do?
Guideline 2 asks:
How well can it do that job?
The research team found that participants sometimes confused these two guidelines. They later revised the wording to make the distinction clearer.
For example, a music recommender might use language such as “we think you’ll like this.” That small phrase communicates uncertainty without turning the interface into a statistics lesson.
This matters even more for AI systems that produce uncertain results.
Instead of:
“This is the answer.”
The product may need:
“Here’s the answer I found. Please check the details.”
Or:
“These results are suggestions.”
The right level of confidence communication depends on the task.
A casual movie recommendation doesn’t need the same warning as a financial decision tool.
During interaction: Be helpful without becoming annoying
Once the user starts interacting with AI, timing and context become important.
AI shouldn’t simply react to every possible signal.
Sometimes the best response is immediate.
Sometimes the best response is no response at all.
3. Time services based on context
Time when to act or interrupt based on the user’s current task and environment.
Timing can make an AI feature feel helpful or irritating.
Think about navigation. Route guidance needs to appear at the right moment. A turn instruction that arrives ten seconds after the turn isn’t useful.
The paper uses navigation as an example of context-sensitive timing, where route guidance updates based on the user’s location and current situation.
The same principle applies to notifications, recommendations, suggestions, and assistants.
Ask:
- Is the user busy?
- Is this information urgent?
- Has the user asked for help?
- Would an interruption break their current task?
- Can the information wait?
An AI system shouldn’t confuse activity with usefulness.
More notifications don’t mean more help.
4. Show contextually relevant information
Display information relevant to the user’s current task and environment.
Context matters.
A search for a movie title can return nearby showtimes for today’s date. That’s more useful than returning a generic list of theaters across an entire country. The paper uses this type of location-aware search as an example.
Context can include:
- Current task
- Location
- Time
- Device
- Environment
- Information already entered
- The user’s immediate goal
But don’t confuse current context with long-term personalization.
That’s a subtle distinction, and the researchers found that participants did confuse Guideline 4 with Guideline 13.
Guideline 4 is about what is happening now.
Guideline 13 is about what the system learns over time.
That difference becomes very useful during design reviews.
5. Match relevant social norms
Deliver the experience in a way that fits the user’s social and cultural context.
AI doesn’t operate in a cultural vacuum.
Tone matters.
Language matters.
Voice matters.
Social expectations matter.
A voice assistant using a semi-formal style may feel appropriate in one setting and awkward in another. The paper gives a voice assistant using a semi-formal conversational style as an example.
This guideline asks designers to think beyond visual usability.
Consider how the AI speaks.
Consider what it assumes.
Consider what feels normal to the people using it.
A product built for a global audience can’t assume that one group’s social expectations represent everyone.
This is where research and diverse evaluation become particularly useful.
6. Mitigate social biases
Make sure the AI’s language and behavior don’t reinforce unfair or undesirable stereotypes.
This guideline sounds simple.
The hard part is spotting the problem.
A designer can miss a bias simply because the bias doesn’t affect them.
The research found that participants sometimes disagreed about the presence of bias in the same product category. Some saw no issue. Others identified assumptions about gender, health, or race.
That tells us something important.
Bias review can’t rely on one person’s perspective.
A navigation system, for example, may assume a standard walking speed. That assumption may work for some people and fail badly for others.
The researchers found Guidelines 5 and 6 among the least clear for participants. They suggested that a diverse set of evaluators can help reveal problems that may be invisible to people from majority groups.
So don’t ask only:
“Does this work?”
Ask:
“Who does this work for, and who might experience it differently?”
That’s a much stronger design question.
When the AI gets it wrong: Give people a way forward
AI makes mistakes.
That’s not a side issue. It’s part of the interaction model.
The important question is what happens next.
Can the user correct the system?
Can they ignore it?
Can they ask again?
Can they understand why the result happened?
The next five guidelines focus on that moment.
7. Support efficient invocation
Make it easy to request the AI system’s services when needed.
If people want AI help, they shouldn’t have to hunt for it.
A voice assistant might respond to a wake command. A writing assistant might appear when the user selects text. An AI image tool might provide a clear action near the canvas.
The interaction should feel discoverable and direct.
The paper gives voice invocation through a wake command as an example.
There is a simple balance here.
AI shouldn’t constantly interrupt users.
But when users want it, calling the AI should be easy.
8. Support efficient dismissal
Make it easy to dismiss or ignore unwanted AI services.
This guideline is easy to overlook.
Designers often spend time making AI suggestions visible.
They should spend the same care making them disappear.
A recommendation can be ignored.
A suggestion can be closed.
A notification can be dismissed.
An AI-generated panel can stay out of the user’s way.
The paper gives an e-commerce recommendation feature as an example of something unobtrusive and easy to scroll past.
This is a small interaction, but it says something powerful:
The user is still in charge.
9. Support efficient correction
Make it easy to edit, refine, or recover when the AI is wrong.
This may be one of the most important guidelines for practical AI products.
AI gets things wrong.
The product needs to make recovery easy.
Suppose an assistant creates the wrong reminder. The user should be able to edit it.
Suppose an autocomplete feature suggests the wrong completion. The user should be able to keep typing.
Suppose an AI organizes photos incorrectly. The user should be able to move them.
The paper gives an example of a voice assistant showing a “Tap to Edit” action after creating a reminder.
Good AI UX doesn’t pretend errors won’t happen.
It plans for them.
10. Scope services when in doubt
Clarify the user’s goal or reduce the AI service when uncertain.
This is where restraint matters.
If the AI isn’t sure what the user wants, it shouldn’t confidently take a large action.
A safer pattern is to narrow the request.
For example:
User: “Book it for Friday.”
AI: “Do you mean the 3 PM appointment or the 5 PM appointment?”
That’s better than making a guess and forcing the user to fix the result later.
Autocomplete provides a simple example. Instead of automatically completing a sentence, the system can present several suggestions.
The paper also notes that this guideline can be difficult to observe in a short product session because uncertainty often happens behind the interface.
That’s a useful reminder for designers.
Some AI behavior needs longer observation.
11. Make clear why the system did what it did
Give the user access to an explanation of why the AI behaved as it did.
This is where explainability becomes part of UX.
A user doesn’t always need a technical explanation of the model.
They need a useful explanation of the decision.
For example:
“This route was selected because it has the shortest estimated travel time.”
That’s much better than:
“Recommended route.”
The paper’s navigation example uses the fastest route as the stated reason for the recommendation.
The research found that this guideline was relevant but often poorly implemented. Participants reported cases where they had no idea why something was recommended, or where an explanation existed but wasn’t clear enough.
That distinction matters.
An explanation isn’t useful simply because it exists.
It needs to answer the user’s actual question.
“Why did I get this?”
That’s the question.
Over time: AI becomes part of the relationship
The interaction doesn’t end after one task.
AI systems can remember recent conversations. They can learn from behavior. They can change after updates. They can respond differently based on feedback.
That creates a second layer of design problems.
12. Remember recent interactions
Maintain short-term memory and let users refer to it easily.
People shouldn’t have to repeat themselves every few seconds.
If a user asks:
“Who is the author?”
Then:
“Where were they born?”
The system should understand who “they” refers to, when the context supports it.
The paper gives web search as an example of maintaining context across related queries.
The important word here is recent.
Guideline 12 isn’t about building a permanent profile of the user.
It’s about short-term interaction memory.
That distinction matters because participants confused Guideline 12 with Guideline 13 during the study.
13. Learn from user behavior
Personalize the user’s experience by learning from their actions over time.
This is different from remembering the current conversation.
Learning happens across interactions.
A music recommender can notice which songs you repeatedly add to playlists and use that behavior to shape later recommendations.
The paper gives this type of recommendation behavior as an example.
Personalization can make a product feel more useful.
But it creates a UX question:
What does the system think it knows about me?
Users may not know.
That gap can become uncomfortable, especially when the AI makes a surprising assumption.
So learning needs to be treated as part of the product experience, not something hidden entirely behind the model.
14. Update and adapt cautiously
Limit disruptive changes when updating or adapting AI behavior.
AI products change.
Models get updated.
Recommendations shift.
Personalization changes.
Interfaces evolve.
From the user’s point of view, though, sudden changes can feel like the product has become a different product overnight.
The paper uses music recommendations as an example where new suggestions can update while an existing list remains stable.
This gives users some continuity.
Think of it like editing a document.
If the entire page changed every time you typed a sentence, you’d lose confidence quickly.
AI systems need similar stability.
Change is fine.
Surprise is the problem.
15. Encourage granular feedback
Let users provide feedback about their preferences during normal interaction.
Feedback shouldn’t always require a trip to a settings page.
Sometimes the best feedback control is right beside the AI output.
For example:
- Mark this recommendation as useful
- Hide this suggestion
- This isn’t relevant
- Keep showing things like this
- Mark this email as important
The paper gives an email example where a user can mark an item as important when the AI did not classify it that way.
That’s granular feedback.
It affects a specific interaction.
And here’s where another subtle distinction matters.
Granular feedback is different from global controls.
The researchers found that participants sometimes confused Guidelines 15 and 17, so they revised the wording to make the difference clearer.
16. Convey the consequences of user actions
Tell users how their actions will affect future AI behavior.
If a user changes something, the product should make the consequence visible.
Imagine hiding an advertisement.
The interface might say:
“We’ll use this feedback to improve future recommendations.”
Now the user knows what happened.
The paper gives this exact type of interaction as an example for social networks, where hiding an ad communicates that future ads will be adjusted.
This creates a clear feedback loop:
Action → consequence → future behavior
Without that loop, users may click controls without understanding their effect.
17. Provide global controls
Let users globally customize what the AI monitors and how it behaves.
Granular feedback handles individual cases.
Global controls affect the broader system.
For example, users might control:
- Location history
- Personalization
- Data access
- Monitoring
- Recommendation preferences
- Memory
- AI assistance settings
The paper uses photo organization as an example. A user can turn on location history so the AI can group photos by where they were taken.
The difference is simple:
Guideline 15: “I don’t like this particular result.”
Guideline 17: “Change how this system behaves for me.”
That distinction should be clear in the interface.
18. Notify users about changes
Tell users when the AI adds or updates its capabilities.
AI changes over time.
A new capability can change how people use a product.
A model update can change behavior.
A new feature can introduce a new interaction pattern.
Users shouldn’t have to discover important changes by accident.
The paper gives navigation software as an example, where small teaching callouts explain important new features and larger changes may receive more direct attention.
The goal isn’t to announce every minor backend change.
The goal is to communicate changes that affect the user’s experience.
If the AI behaves differently tomorrow, the user should have some way to understand why.
The guidelines work as a system
It’s tempting to treat the 18 guidelines as 18 separate boxes.
That’s not how good AI interaction works.
They connect.
Imagine an AI writing assistant.
- Guideline 1 tells users what it can do.
- Guideline 2 sets expectations about how well it performs.
- Guideline 3 helps the system decide when to appear.
- Guideline 4 helps it show relevant suggestions.
- Guideline 7 makes the assistant easy to invoke.
- Guideline 8 makes suggestions easy to dismiss.
- Guideline 9 lets users correct bad output.
- Guideline 11 explains why a suggestion appeared.
- Guideline 12 remembers recent context.
- Guideline 13 learns from behavior.
- Guideline 15 collects granular feedback.
- Guideline 17 gives users broader controls.
- Guideline 18 tells them when important behavior changes.
Now the product starts to feel coherent.
The guidelines aren’t separate features. They’re pieces of the interaction model.
Three distinctions every AI designer should remember
The research found several places where participants confused guidelines.
These distinctions are worth keeping close during design reviews.
Capability vs. quality
Guideline 1: What can the AI do?
Guideline 2: How well can it do it?
A system can be capable of summarizing a document without producing a perfect summary every time.
Don’t mix those two ideas.
Current context vs. learned preference
Guideline 4: What matters right now?
Guideline 13: What has the system learned about the user over time?
Your current location is context.
Your repeated preference for a particular type of content is learned behavior.
The paper found six cases where participants confused these concepts.
Granular feedback vs. global controls
Guideline 15: Change this specific AI interaction.
Guideline 17: Change the broader behavior of the system.
A “Not useful” button is granular feedback.
A “Turn off personalized recommendations” setting is a global control.
Both matter. They solve different problems.
What the research actually found
The guidelines weren’t created as a list of opinions.
The research team built them through four phases.
- First, they gathered recommendations from industry sources, public articles, and academic research. They found 168 potential AI design guidelines. After grouping and filtering them, they reduced the set to 20 initial guidelines.
- Second, 11 members of the research team tested the initial guidelines through a modified heuristic evaluation. This process reduced the set to 18 and exposed areas where the wording was unclear or where guidelines overlapped.
- Third, 49 HCI practitioners evaluated the guidelines across AI features in 20 products.
- Fourth, 11 experts reviewed revised wording and guideline pairs that had confused the user study.
That’s a useful model for UX work in itself.
Don’t write a design rule and assume it’s clear.
Test it.
Watch people use it.
Look for confusion.
Rewrite it.
Test it again.
Good guidelines get better through contact with real users and practitioners.
The 18 guidelines showed broad relevance
Across the 20 products studied, participants identified 785 examples related to the 18 guidelines.
Those examples included:
- 313 applications
- 277 violations
- 89 neutral responses
- 106 cases where participants judged a guideline did not apply
Participants found at least one application or violation of every guideline across the product categories tested.
That doesn’t mean every guideline applies equally to every AI product.
The research makes that clear.
Voice assistants, activity trackers, and photo organizers produced fewer total applications or violations in some areas. Some guidelines were hard to observe during a short session, particularly when the relevant AI behavior happened behind the interface.
That’s an important lesson.
A guideline can be useful even when you can’t spot it in five minutes.
Some AI behavior only becomes visible over time.
Explainability still has a practical problem
One finding stands out.
Guideline 11, “Make clear why the system did what it did,” had many violations despite the large amount of research around AI explanations.
People often wanted to know why something happened.
They couldn’t always find an explanation.
And sometimes an explanation existed but didn’t answer the real question.
This is a familiar UX problem.
A product says:
“Recommended for you.”
That’s technically an explanation.
But it’s not a very useful one.
A better explanation might say:
“Recommended because you viewed three similar products.”
Now the user can understand the connection.
Of course, more explanation isn’t always better.
In some systems, detailed explanations can expose information that creates other problems. The paper points out that explanations may be less useful in low-cost scenarios such as music or movie recommendations than in high-risk decision-support settings.
So the question isn’t:
“Should we explain everything?”
A better question is:
“What explanation helps this user make a better decision?”
Bias needs more than a checklist
Guidelines 5 and 6 reveal another important lesson.
Some problems aren’t easy to see from one perspective.
During the study, participants sometimes disagreed about social norms and bias in the same types of products. The researchers concluded that diverse evaluators can help identify issues that might remain invisible to members of majority groups.
For AI products, this matters during research, usability testing, design review, content review, and model evaluation.
A team can have strong technical skills and still miss a social assumption.
That’s why AI design needs more than interface inspection.
It needs people with different experiences asking different questions.
How to use the 18 guidelines in a real UX process
You don’t need to wait until the product is finished.
Use the guidelines throughout the design process.
During discovery
Ask:
- What decisions will the AI make?
- What can go wrong?
- What does the user need to know before using it?
- Which actions need confirmation?
- What should the user be able to correct?
- What should the AI remember?
- What should it learn?
- What should the user be able to control?
This gives your research plan a clearer shape.
During user flows
Mark every point where AI enters the experience.
For each point, ask:
Can the user tell what the AI is doing?
Can the user tell why it is doing it?
Can the user stop it?
Can the user correct it?
Can the user recover from a wrong result?
This quickly exposes gaps.
During wireframing
Don’t design only the successful path.
Design the failure path.
For every AI action, think through:
AI suggestion → user accepts
AI suggestion → user ignores
AI suggestion → user corrects
AI suggestion → AI is uncertain
AI suggestion → user wants to know why
That’s where human-AI interaction starts to become real UX work.
During usability testing
Turn the guidelines into evaluation questions.
For example:
Guideline 1: “Can users explain what the AI can do?”
Guideline 2: “Can users describe how reliable they think it is?”
Guideline 9: “Can users correct an incorrect result without starting over?”
Guideline 11: “Can users explain why the system produced the result?”
Guideline 17: “Can users find broader AI settings?”
You can then test the interface against specific behaviors rather than asking vague questions about whether the AI “feels good.”
The original research itself found that the guidelines lend themselves well to heuristic evaluation.
Don’t stop at the interface
Here’s where the paper becomes especially relevant for AI product teams.
The researchers intentionally focused on guidelines that designers could observe through the interface.
They excluded broader principles that require decisions at the AI model level.
For example, deciding the ideal action based on costs, benefits, and uncertainty can require model-level decisions rather than a visible UI change.
That means a good AI product needs collaboration across disciplines.
The designer sees the interaction.
The researcher sees the user’s behavior.
The product manager sees the product goal.
The engineer sees system constraints.
The model team sees model performance and uncertainty.
These views need to meet.
A beautiful interface can’t compensate for a model that behaves badly.
A powerful model can’t compensate for an interface that leaves users confused.
Human-AI interaction sits between the two.
There are limits to the 18 guidelines
The paper doesn’t present these guidelines as a complete answer to every AI design problem.
That’s important.
The researchers point out that some guidelines may not directly fit systems without conventional graphical interfaces, such as voice assistants and activity trackers. Highly regulated or high-risk areas may need more specialized guidance too, including semi-autonomous vehicles, robot-assisted surgery, and financial systems.
The guidelines focus on observable interaction behavior.
They don’t cover every model-level decision.
They don’t cover every ethical issue.
They don’t solve every fairness problem.
And they don’t remove the need for domain expertise.
The researchers explicitly state that fairness and broader ethical concerns extend beyond social norms and social bias. An AI system can follow these guidelines and still have serious effects on people’s lives or livelihoods.
That’s a point worth keeping in bold:
Good AI interaction design is necessary, but it isn’t sufficient by itself.
What happens when guidelines conflict?
Real products create trade-offs.
One guideline can sometimes pull against another.
The paper gives an example involving Guideline 13 and Guideline 16. A complex model may make it harder to show users the consequences of their actions while actively learning from their behavior.
This is where rigid checklist thinking falls apart.
You don’t simply tick 18 boxes and call the design finished.
You ask:
What are we gaining?
What are we giving up?
What does the user need most in this situation?
For a low-risk recommendation, a lightweight explanation may be enough.
For a high-risk decision, the interaction may need stronger controls, clearer explanations, and more opportunities for human review.
The right design depends on the task.
A practical human-AI interaction checklist
When reviewing an AI feature, walk through these questions.
Before interaction
- Can the user tell what the AI can do?
- Can the user tell how well it performs?
- Are limitations clear?
- Are expectations realistic?
During interaction
- Does the AI act at the right time?
- Does it show information relevant to the current task?
- Does the experience fit the user’s social context?
- Have you looked for social bias?
When the AI is wrong
- Can users invoke the AI easily?
- Can they dismiss unwanted suggestions?
- Can they correct mistakes?
- Does the AI ask for clarification when uncertain?
- Can users understand why something happened?
Over time
- Does the system remember useful recent context?
- Does it learn from behavior?
- Does it change cautiously?
- Can users give specific feedback?
- Can they understand the effect of their feedback?
- Do they have global controls?
- Do they know when important AI behavior changes?
This checklist is much more useful than a vague goal such as “make the AI feel human.”
The goal isn’t to make AI human.
The goal is to make human interaction with AI clear, useful, controllable, and predictable enough for the task.
The bigger lesson for AI product design
There’s a temptation to judge AI products by the quality of their outputs alone.
That’s too narrow.
A model can produce an excellent answer and still create a poor experience.
Imagine an AI assistant that gives accurate recommendations but doesn’t explain them.
Or one that gives great suggestions but makes them impossible to dismiss.
Or one that learns your preferences but gives you no control over that learning.
Or one that improves after an update but never tells you what changed.
The model may be good.
The product isn’t.
Human-AI interaction design looks at the space between the model’s behavior and the person’s experience.
That’s where trust is built or lost.
That’s where confusion happens.
That’s where people decide, often very quickly, whether they want to keep using the feature.
The 18 guidelines give designers a language for talking about those moments.
Instead of saying:
“The AI feels confusing.”
You can ask:
Does the user understand what it can do?
Instead of:
“People don’t trust the recommendation.”
Ask:
Does the system explain why it made the recommendation?
Instead of:
“The personalization feels creepy.”
Ask:
Does the user know what the system has learned, and do they have global controls?
That’s a much stronger design conversation.
A simple principle to take into your next AI project
If you remember only one thing from these guidelines, remember this:
Give people clarity, control, and a way back.
Clarity tells users what the AI can do and how well it can do it.
Control lets users invoke, dismiss, correct, customize, and influence the system.
A way back means the product doesn’t punish users when the AI gets something wrong.
That’s the human side of human-AI interaction.
AI will continue to become more capable. That makes good interaction design more important, not less. The researchers themselves argue that the growing use of AI in computing creates a continuing need to develop and refine human-AI design guidance.
And perhaps that’s the most useful way to read these 18 guidelines.
They aren’t instructions for making AI look intelligent.
They’re instructions for making AI work better with people.
The distinction is small on paper.
In a real product, it can make all the difference.
Yes. I reviewed the PDF again against the previous article. The main 18 guidelines were covered, but a few source-specific details and research findings were missing or could be made more precise.
You can add the following sections to the article. They stay close to the original paper rather than adding unrelated AI advice.
Examples behind the 18 guidelines
One thing the previous article could have included more clearly is the actual product evidence used in the paper.
The researchers didn’t present the guidelines in isolation. They showed examples from real AI-infused products.
Here is the complete mapping from the paper’s Table 1.
| Guideline | What it means | Example used in the research |
|---|---|---|
| G1. Make clear what the system can do | Explain the AI’s capabilities | Activity tracker explains the metrics it tracks |
| G2. Make clear how well the system can do what it can do | Communicate expected performance and possible mistakes | Music recommender uses “we think you’ll like” |
| G3. Time services based on context | Act or interrupt at an appropriate time | Navigation provides timely route guidance |
| G4. Show contextually relevant information | Show information related to the current task and environment | Search shows nearby movie times |
| G5. Match relevant social norms | Fit the user’s social and cultural expectations | Voice assistant uses a semi-formal conversational style |
| G6. Mitigate social biases | Avoid reinforcing unfair stereotypes or biases | Autocomplete suggests both gendered terms |
| G7. Support efficient invocation | Make AI easy to request | Voice assistant responds to a wake command |
| G8. Support efficient dismissal | Make unwanted AI easy to ignore | E-commerce recommendations can be easily scrolled past |
| G9. Support efficient correction | Make mistakes easy to edit or recover from | Voice assistant provides “Tap to Edit” after creating a reminder |
| G10. Scope services when in doubt | Clarify intent or reduce the AI’s action when uncertain | Autocomplete presents several suggestions instead of automatically choosing one |
| G11. Make clear why the system did what it did | Give users an explanation | Navigation explains that the route was selected as the fastest |
| G12. Remember recent interactions | Keep useful short-term context | Search continues a query thread from an earlier question |
| G13. Learn from user behavior | Personalize based on actions over time | Music recommendations change based on listening behavior |
| G14. Update and adapt cautiously | Avoid disruptive AI changes | Music recommendations update part of a list while keeping another part stable |
| G15. Encourage granular feedback | Let users give feedback during normal interaction | Email lets users mark an incorrectly classified message as important |
| G16. Convey the consequences of user actions | Explain how an action will affect future AI behavior | Hiding an ad tells users that future ad relevance will change |
| G17. Provide global controls | Let users control AI behavior across the product | Photo organizer lets users turn location history on |
| G18. Notify users about changes | Tell users when AI capabilities change | Navigation uses in-app callouts and pop-ups for important new features |
The researchers deliberately removed some guidelines
This is another useful part of the paper that the previous article didn’t cover.
During the early evaluation, the team considered guidelines such as:
- Explore versus exploit in moderation
- Be especially conservative in the beginning
- Inform users when they should take control
- Fall back to a human where appropriate
Some were removed because they were difficult to identify through interface inspection or were better treated as instances of another guideline.
For example, “informing the user when to take control” and “fallback to a human where appropriate” were considered instances of G10.
“Enable users to change privacy permissions” and “allow private mode” were folded into G17.
This tells us something useful about UX heuristics:
A good guideline should be observable enough for a designer to evaluate.
If a rule sounds good but nobody can reliably identify whether an interface follows it, it becomes difficult to use as a design tool.
Some guidelines are hard to see in a normal usability test
This is one of the more interesting findings.
Not every AI behavior is visible during a single session.
For example, G13: Learn from user behavior may take days or weeks to become noticeable.
The same applies to G14: Update and adapt cautiously.
You can’t always judge long-term adaptation after five minutes of testing.
The study found that some participants reported certain guidelines as difficult to observe without knowledge of the underlying AI algorithms. Voice assistants had the highest number of “does not apply” responses among the tested categories.
This means AI usability research needs more than one testing window.
For some features, you need:
Short-term usability testing + longitudinal observation.
That’s especially true for systems that learn, personalize, or change.
The guidelines don’t replace AI ethics
The paper is very clear about this.
The 18 guidelines touch social norms and bias, but they don’t cover every ethical question surrounding AI.
A product can follow all 18 guidelines and still have a serious social impact.
For example, an AI system could clearly explain what it does, allow correction, provide controls, and communicate changes while still affecting someone’s livelihood in a harmful way.
The researchers say broader ethical questions require continued attention and that detecting these issues can depend on who performs the evaluation.
So don’t treat the 18 guidelines as an ethics checklist.
They’re primarily a human-AI interaction and usability framework.
That’s a more accurate description.
The guidelines have limits in high-risk products
The researchers also point out that general guidelines don’t automatically cover every domain.
Specialized guidance may be needed for areas such as:
- Semi-autonomous vehicles
- Robot-assisted surgery
- Financial systems
- Voice-based systems
- Activity trackers
These products can have very different risks, interaction models, and regulatory requirements.
A recommendation from a movie app and a recommendation from a medical system shouldn’t carry the same interaction pattern.
The stakes are different.
The user’s ability to recover is different.
The cost of an error is different.
That’s why AI UX needs domain context alongside general interaction principles.
A final point the paper makes about model and interface design
Perhaps the most important missing idea is that AI UX can’t live entirely inside the interface.
The researchers deliberately focused on things designers could observe and evaluate in an interface.
But some AI decisions happen at the model level.
For example, deciding when an AI should act automatically versus waiting for a person can require consideration of:
- Expected benefits
- Potential costs
- Uncertainty
- Model performance
- The consequences of an incorrect action
Those decisions aren’t solved with a button or tooltip.
They require designers and model developers to work together.
That gives us a useful model:
Model behavior → AI decision → interface behavior → human response
You can’t fix every problem at the UI layer.
Sometimes the model needs to change.
Sometimes the interaction needs to change.
Sometimes both need to change.
The most useful takeaway
The 18 guidelines aren’t a checklist for making an AI interface look smarter.
They’re a framework for making the relationship between a person and an AI system easier to understand and control.
Before the interaction, set clear expectations.
During the interaction, respect context.
When the AI is uncertain or wrong, give the user a way to recover.
Over time, be careful with memory, learning, personalization, feedback, and changes.
And keep one more thing in mind:
AI UX doesn’t end with the interface.
The model, the data, the interaction, the user, and the surrounding social context all affect the final experience.
That is probably the biggest lesson to carry from the paper into real product work.
The researchers developed the guidelines through multiple rounds of evaluation and found them broadly relevant across AI-infused products, but they also clearly identified areas where further research and domain-specific guidance are needed.
Source
Amershi, Saleema et al. “Guidelines for Human-AI Interaction.“ CHI Conference on Human Factors in Computing Systems, 2019. The paper proposes and evaluates 18 generally applicable guidelines, based on more than 150 AI design recommendations and a user study involving 49 design practitioners and 20 AI-infused products.