Human: Design AI Apps Around Real People
Published · Updated
Human-centered AI design starts with the person using the system rather than the model's capabilities. This guide explains how human goals, control, clarity, feedback, accessibility, trust, consent, error recovery, and appropriate automation can shape an AI app experience that remains understandable and useful.
Start with a real human goal
Start with a real human goal should begin with a concrete goal and an observable current state. Define what the user or team is trying to accomplish, what information is available, what assumptions are being made, and what result would count as successful. In human-centered AI design, this prevents broad design or product advice from becoming disconnected from actual work. A useful guide connects each recommendation to a decision point, visible behavior, and evidence that can be reviewed by someone who was not present when the original decision was made.
Evaluate Start with a real human goal with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not provide a specific changelog entry, impact customer, Miro importer behavior, or performance metric, explain the method without inventing those details. This keeps the article useful while protecting the difference between published information and general operating guidance.
Ownership around Start with a real human goal should remain clear. Teams need to know who prepares the input, who reviews the outcome, who maintains the related dependency or content, and who decides when a change is ready. A lightweight checklist, status, or review record is usually enough. The goal is continuity: another person should be able to understand why the current design exists, reproduce the evaluation, and safely continue the work without relying on private memory.
As the product grows, retest Start with a real human goal with more users, data, screens, releases, or workflows. Look for stale assumptions, duplicated work, ambiguous states, hidden latency, missing validation, inaccessible interactions, weak evidence, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses measured behavior to decide what should change next. It avoids adding complexity simply because a new tool, feature, or AI capability exists.
- Start with a real human goal
- Evidence
- Validation
- Ownership
Keep meaningful control visible
Keep meaningful control visible should begin with a concrete goal and an observable current state. Define what the user or team is trying to accomplish, what information is available, what assumptions are being made, and what result would count as successful. In human-centered AI design, this prevents broad design or product advice from becoming disconnected from actual work. A useful guide connects each recommendation to a decision point, visible behavior, and evidence that can be reviewed by someone who was not present when the original decision was made.
Evaluate Keep meaningful control visible with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not provide a specific changelog entry, impact customer, Miro importer behavior, or performance metric, explain the method without inventing those details. This keeps the article useful while protecting the difference between published information and general operating guidance.
Ownership around Keep meaningful control visible should remain clear. Teams need to know who prepares the input, who reviews the outcome, who maintains the related dependency or content, and who decides when a change is ready. A lightweight checklist, status, or review record is usually enough. The goal is continuity: another person should be able to understand why the current design exists, reproduce the evaluation, and safely continue the work without relying on private memory.
As the product grows, retest Keep meaningful control visible with more users, data, screens, releases, or workflows. Look for stale assumptions, duplicated work, ambiguous states, hidden latency, missing validation, inaccessible interactions, weak evidence, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses measured behavior to decide what should change next. It avoids adding complexity simply because a new tool, feature, or AI capability exists.
- Keep meaningful control visible
- Evidence
- Validation
- Ownership
Explain what the AI is doing
Explain what the AI is doing should begin with a concrete goal and an observable current state. Define what the user or team is trying to accomplish, what information is available, what assumptions are being made, and what result would count as successful. In human-centered AI design, this prevents broad design or product advice from becoming disconnected from actual work. A useful guide connects each recommendation to a decision point, visible behavior, and evidence that can be reviewed by someone who was not present when the original decision was made.
Evaluate Explain what the AI is doing with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not provide a specific changelog entry, impact customer, Miro importer behavior, or performance metric, explain the method without inventing those details. This keeps the article useful while protecting the difference between published information and general operating guidance.
Ownership around Explain what the AI is doing should remain clear. Teams need to know who prepares the input, who reviews the outcome, who maintains the related dependency or content, and who decides when a change is ready. A lightweight checklist, status, or review record is usually enough. The goal is continuity: another person should be able to understand why the current design exists, reproduce the evaluation, and safely continue the work without relying on private memory.
As the product grows, retest Explain what the AI is doing with more users, data, screens, releases, or workflows. Look for stale assumptions, duplicated work, ambiguous states, hidden latency, missing validation, inaccessible interactions, weak evidence, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses measured behavior to decide what should change next. It avoids adding complexity simply because a new tool, feature, or AI capability exists.
- Explain what the AI is doing
- Evidence
- Validation
- Ownership
Design feedback as a two-way loop
Design feedback as a two-way loop should begin with a concrete goal and an observable current state. Define what the user or team is trying to accomplish, what information is available, what assumptions are being made, and what result would count as successful. In human-centered AI design, this prevents broad design or product advice from becoming disconnected from actual work. A useful guide connects each recommendation to a decision point, visible behavior, and evidence that can be reviewed by someone who was not present when the original decision was made.
Evaluate Design feedback as a two-way loop with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not provide a specific changelog entry, impact customer, Miro importer behavior, or performance metric, explain the method without inventing those details. This keeps the article useful while protecting the difference between published information and general operating guidance.
Ownership around Design feedback as a two-way loop should remain clear. Teams need to know who prepares the input, who reviews the outcome, who maintains the related dependency or content, and who decides when a change is ready. A lightweight checklist, status, or review record is usually enough. The goal is continuity: another person should be able to understand why the current design exists, reproduce the evaluation, and safely continue the work without relying on private memory.
As the product grows, retest Design feedback as a two-way loop with more users, data, screens, releases, or workflows. Look for stale assumptions, duplicated work, ambiguous states, hidden latency, missing validation, inaccessible interactions, weak evidence, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses measured behavior to decide what should change next. It avoids adding complexity simply because a new tool, feature, or AI capability exists.
- Design feedback as a two-way loop
- Evidence
- Validation
- Ownership
Make accessibility part of the core design
Make accessibility part of the core design should begin with a concrete goal and an observable current state. Define what the user or team is trying to accomplish, what information is available, what assumptions are being made, and what result would count as successful. In human-centered AI design, this prevents broad design or product advice from becoming disconnected from actual work. A useful guide connects each recommendation to a decision point, visible behavior, and evidence that can be reviewed by someone who was not present when the original decision was made.
Evaluate Make accessibility part of the core design with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not provide a specific changelog entry, impact customer, Miro importer behavior, or performance metric, explain the method without inventing those details. This keeps the article useful while protecting the difference between published information and general operating guidance.
Ownership around Make accessibility part of the core design should remain clear. Teams need to know who prepares the input, who reviews the outcome, who maintains the related dependency or content, and who decides when a change is ready. A lightweight checklist, status, or review record is usually enough. The goal is continuity: another person should be able to understand why the current design exists, reproduce the evaluation, and safely continue the work without relying on private memory.
As the product grows, retest Make accessibility part of the core design with more users, data, screens, releases, or workflows. Look for stale assumptions, duplicated work, ambiguous states, hidden latency, missing validation, inaccessible interactions, weak evidence, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses measured behavior to decide what should change next. It avoids adding complexity simply because a new tool, feature, or AI capability exists.
- Make accessibility part of the core design
- Evidence
- Validation
- Ownership
Build trust through predictable behavior
Build trust through predictable behavior should begin with a concrete goal and an observable current state. Define what the user or team is trying to accomplish, what information is available, what assumptions are being made, and what result would count as successful. In human-centered AI design, this prevents broad design or product advice from becoming disconnected from actual work. A useful guide connects each recommendation to a decision point, visible behavior, and evidence that can be reviewed by someone who was not present when the original decision was made.
Evaluate Build trust through predictable behavior with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not provide a specific changelog entry, impact customer, Miro importer behavior, or performance metric, explain the method without inventing those details. This keeps the article useful while protecting the difference between published information and general operating guidance.
Ownership around Build trust through predictable behavior should remain clear. Teams need to know who prepares the input, who reviews the outcome, who maintains the related dependency or content, and who decides when a change is ready. A lightweight checklist, status, or review record is usually enough. The goal is continuity: another person should be able to understand why the current design exists, reproduce the evaluation, and safely continue the work without relying on private memory.
As the product grows, retest Build trust through predictable behavior with more users, data, screens, releases, or workflows. Look for stale assumptions, duplicated work, ambiguous states, hidden latency, missing validation, inaccessible interactions, weak evidence, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses measured behavior to decide what should change next. It avoids adding complexity simply because a new tool, feature, or AI capability exists.
- Build trust through predictable behavior
- Evidence
- Validation
- Ownership
Design for errors and recovery
Design for errors and recovery should begin with a concrete goal and an observable current state. Define what the user or team is trying to accomplish, what information is available, what assumptions are being made, and what result would count as successful. In human-centered AI design, this prevents broad design or product advice from becoming disconnected from actual work. A useful guide connects each recommendation to a decision point, visible behavior, and evidence that can be reviewed by someone who was not present when the original decision was made.
Evaluate Design for errors and recovery with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not provide a specific changelog entry, impact customer, Miro importer behavior, or performance metric, explain the method without inventing those details. This keeps the article useful while protecting the difference between published information and general operating guidance.
Ownership around Design for errors and recovery should remain clear. Teams need to know who prepares the input, who reviews the outcome, who maintains the related dependency or content, and who decides when a change is ready. A lightweight checklist, status, or review record is usually enough. The goal is continuity: another person should be able to understand why the current design exists, reproduce the evaluation, and safely continue the work without relying on private memory.
As the product grows, retest Design for errors and recovery with more users, data, screens, releases, or workflows. Look for stale assumptions, duplicated work, ambiguous states, hidden latency, missing validation, inaccessible interactions, weak evidence, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses measured behavior to decide what should change next. It avoids adding complexity simply because a new tool, feature, or AI capability exists.
- Design for errors and recovery
- Evidence
- Validation
- Ownership
Use automation where it helps the person
Use automation where it helps the person should begin with a concrete goal and an observable current state. Define what the user or team is trying to accomplish, what information is available, what assumptions are being made, and what result would count as successful. In human-centered AI design, this prevents broad design or product advice from becoming disconnected from actual work. A useful guide connects each recommendation to a decision point, visible behavior, and evidence that can be reviewed by someone who was not present when the original decision was made.
Evaluate Use automation where it helps the person with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not provide a specific changelog entry, impact customer, Miro importer behavior, or performance metric, explain the method without inventing those details. This keeps the article useful while protecting the difference between published information and general operating guidance.
Ownership around Use automation where it helps the person should remain clear. Teams need to know who prepares the input, who reviews the outcome, who maintains the related dependency or content, and who decides when a change is ready. A lightweight checklist, status, or review record is usually enough. The goal is continuity: another person should be able to understand why the current design exists, reproduce the evaluation, and safely continue the work without relying on private memory.
As the product grows, retest Use automation where it helps the person with more users, data, screens, releases, or workflows. Look for stale assumptions, duplicated work, ambiguous states, hidden latency, missing validation, inaccessible interactions, weak evidence, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses measured behavior to decide what should change next. It avoids adding complexity simply because a new tool, feature, or AI capability exists.
- Use automation where it helps the person
- Evidence
- Validation
- Ownership
Questions
What should I verify first?
Start with the current goal, observable baseline, owner, dependencies, and a clear definition of success.
Should I assume details that are not in the source?
No. Keep published facts separate from general guidance and mark unknown details clearly.
How should failures be handled?
Define a visible failure state, owner, recovery path, and evidence that normal behavior has been restored.
When should the guide be reviewed?
Review it after meaningful changes to design, releases, workflows, accessibility, performance, evidence, or published platform behavior.