Overview
As artificial intelligence becomes woven into daily workflows and creative processes, thoughtful interaction design matters more than ever. These ten rules come out of years spent designing AI systems that serve human needs, not just technological capability. They are the principles I return to for building AI interactions that feel natural and productive rather than merely automated.
My goal is not to make AI more human, but to make human-AI collaboration more seamless. Each rule addresses a specific challenge in designing systems that adapt to context, respect user intent, and enhance rather than replace human creativity and judgment. I apply these whether I am designing a conversational interface, a creative tool, or a decision-support system.
1. Build trust through transparent reasoning
An AI system has to make its reasoning visible and comprehensible, especially when its recommendations or decisions affect outcomes. That means clearly communicating confidence levels, data sources, assumptions, and limitations. When the system hits uncertainty or conflicting information, it should say so rather than presenting false certainty. A user should understand not just what the AI concluded, but how it got there and what would change the recommendation.
Trust is earned through transparency: show the work, admit the limits, and let the user verify the reasoning for themselves.
2. Match AI mode to task context
A system should clearly distinguish between a directive mode, precise and constrained execution, and a collaborative mode, a creative, exploratory partnership. Users need to be able to switch between the two based on what they are actually trying to do. Directive mode should respect existing constraints and deliver surgical precision; collaborative mode should offer creative freedom and room for architectural thinking. Whichever mode is active should be obvious and stay consistent through the interaction.
Use directive mode when you already know what you want. Use collaborative mode when you want to discover what is possible.
3. Design for explicit role division
I design AI systems with clear divisions of responsibility, each party contributing its own strengths. AI handles rote, data-intensive, large-scale work; people focus on meaning-making, strategy, and contextual judgment. Getting this right means understanding both human processing limits and AI's own accuracy limitations, so the two form a genuinely complementary partnership rather than a lopsided one.
Do not ask AI to be human, or humans to be machines. Ask each to contribute the strength only it can bring.
4. Adapt to deployment context
An AI system should adjust its behavior to the situation it is deployed in, automatically optimizing output format, response speed, interaction depth, and performance for that environment, its constraints, and its usage patterns. The system should sense these factors and shape itself to fit the reality of how and where it is actually being used, rather than presenting one fixed behavior everywhere.
Good AI does not just answer questions. It understands where, how, and why it is being used, then shapes itself to that reality.
5. Communicate across modalities to match context
An AI system should adapt how it communicates to the user's preferences, the task, and the situation, rather than forcing everyone into a single interaction paradigm. That means using multiple sensory channels, visual, auditory, textual, tactile, deliberately, choosing the right combination for each interaction instead of firing every channel at once. The system should recognize when to shift modalities based on environment (a noisy space calling for visual communication), user capability (accessibility needs), task complexity (a spatial concept that benefits from a diagram), and stated preference, while keeping the conversation continuous and explaining why it is switching when it does.
Speak the language of the moment. Good AI adapts its voice to match the need.
6. Design for anticipatory partnership
I build AI systems that actively map the trajectory of a user's goals, identifying likely pathways, obstacles, and opportunities before anyone has to ask. The system should function as a strategic scout, reading patterns in behavior to surface relevant options, suggest the next step, and prepare resources for likely scenarios ahead of time. This is not just responding to commands; it is anticipating needs and helping a user discover possibilities they had not considered.
Good AI does not wait to be asked. It illuminates the path ahead and reveals doors the user did not know were there.
7. Design for universal accessibility
AI systems have to be inherently accessible to users with disabilities, with equal access and functionality regardless of physical, cognitive, or sensory limitation. That means multiple input and output modalities, support for assistive technology, and adjustable interaction methods that accommodate a range of needs. Accessibility belongs in the core architecture, not bolted on afterward, so a user with a disability gets the system's full capability without compromise.
True intelligence removes barriers. Good AI makes sure everyone can participate fully in the conversation.
8. Practice intentional restraint
An AI system has to exercise deliberate self-limitation: the ability to collect, process, or act on information does not create an obligation to do so. In practice that means privacy through data minimization, avoiding over-personalization that turns invasive, resisting the temptation to automate decisions that need human judgment, and knowing when to step back instead of intervening. A well-designed system chooses not to retain information it does not need, not to surface insights that might cross a boundary, and not to optimize for engagement at the cost of a person's wellbeing. Restraint shows up as asking permission before expanding what it can do, forgetting information once the task is done, and holding a clear line between what the AI could know and what it should know.
Real intelligence shows up as restraint. Good AI knows that just because it can does not mean it should.
9. Ensure security as the foundation for trust
Security belongs in a system's core architecture as the essential prerequisite for trustworthy operation, the foundation that lets people share sensitive information, rely on outputs, and put AI into critical workflows. Without demonstrable security, no amount of capability matters; people simply will not engage meaningfully with a system they cannot trust. Security requirements are first-order design constraints that shape the architecture from the start, not attributes to optimize later. Confidentiality, integrity, availability, and privacy have to be non-negotiable properties a user can depend on without needing to understand the mechanism underneath.
Security is the bedrock of trust. Without it, even the most capable system is just an interesting experiment no one can actually use.
10. Design for graceful failure
Failure is inevitable, so every interaction has to be designed to degrade gracefully when things go wrong instead of collapsing outright. That means building a system that recognizes its own limitations, detects when it is operating outside its competence, and offers a useful fallback instead of a confusing or misleading output. When the system cannot fulfill a request, it should say clearly what went wrong, what it can do instead, and how the user can proceed, turning failure into a navigable moment rather than a dead end. It should preserve partial functionality where it can, keep a user's work and context intact through the failure, and learn its boundaries from the moment. Success is not measured by perfection but by how well the system helps a person recover and keep going when perfection is not possible.
The measure of intelligent design is not whether it fails, but how. Good AI turns breakdowns into stepping stones, not roadblocks.
Closing
None of these ten rules is really about AI capability. They are about the relationship between a system and the person using it: whether that person can see how a conclusion was reached, whether the system knows the difference between what it could do and what it should, and whether a mistake leaves them stranded or steadies them and lets them continue.
I keep coming back to these principles because the technology keeps changing and the underlying relationship does not. Build for trust, divide the labor honestly, adapt to context, hold back when holding back is the right call, and fail in a way that leaves the user better off than a silent crash would. That is what makes a system feel intelligent, not the sophistication of any single answer it gives.