It's life, Jim, but not as we know it: September 2025

Beyond the Prompt—Designing for True AI Interactivity

In this series, we first established the importance of giving your AI a Persona to build trust and then implemented Guardrails to ensure it behaves safely and reliably. We have designed an AI that is trustworthy and responsible. But a safe AI is useless if no one wants to use it.

Imagine a stand-up comedian walking onto a massive stage. The spotlight hits them, the crowd leans in, and the comedian… just stands there. The silence becomes uncomfortable. This is the risk we run with our AI applications. We build incredibly complex technology, place a chat window in front of the user, and simply wait. We've built the stage but have forgotten that the performer needs to engage the audience.

Prompting is not yet second nature for most users, and a blank interface can be intimidating. To move beyond the "silent comedian" problem, we need to design experiences that actively teach, guide, and reward the user. The masters of this are game designers. Let's apply their principles to build AI that is not just functional, but truly interactive.

Four Game Design Principles for AI Engagement

1. The Interaction Loop: Learning Through Feedback

Game designers know that players learn by doing. The fundamental unit of this learning is a simple loop: the user takes an action, the system simulates a result, and critically, provides feedback. This feedback helps the user update their mental model of how the system works.

Why this matters for your AI: Every prompt is a trip through this loop. The quality of your AI's feedback directly determines how quickly users learn to interact with it effectively.
Example in Practice: User Action: "weather?" Bad Feedback: "Invalid location. Please try again." (This makes the user feel like they made a mistake). Good Feedback: "I can get you the weather! Could you let me know which city you're interested in? You can also grant location access for me to check your current spot." (This is helpful, provides options, and teaches the user about the AI's capabilities).

With good feedback, the user’s mental model is updated. They learn how to ask better questions next time, transforming potential frustration into a moment of mastery.

2. Perceived Value: Making the Effort Worthwhile

Games constantly dangle carrots—rewards, points, new abilities—to motivate players. Players will invest effort in actions they perceive as valuable.

Why this matters for your AI: Typing a detailed prompt is an effort. Users have existing, predictable ways of doing their work. For them to switch, the perceived value of using your AI must be immediate and high. If their first few attempts yield generic or unhelpful answers, they will revert to their old habits.
Your Takeaway: Front-load the value. Design for quick wins that demonstrate your AI's power early on. A user who gets a surprisingly insightful answer in their first session has tasted the reward and is far more likely to invest time in learning to use the tool more deeply.

3. Skill Chains: Guiding the User's Journey

Games don't start at the hardest level. They gradually build complexity, teaching one skill at a time. Mastering a simple skill (like jumping) enables the player to learn a more complex one (like jumping onto a platform). This is a "Skill Chain."

Why this matters for your AI: No one is born a prompt expert. Your AI's interface must serve as an onboarding process. Start with simple, suggested prompts and guide users toward more complex interactions. If your AI requires specific formatting, teach the user with helpful feedback instead of failing silently.
Your Takeaway: Map out the user's learning journey. Define the skills they need—from basic queries to complex, multi-turn conversations—and design an experience that guides them along that chain.

4. Burnout: The Silent Killer of Engagement

In games, burnout occurs when a player gets frustrated from repeated failure or gets bored after mastering the game. This is precisely why users abandon AI tools.

Failure Burnout: "I keep trying to get this AI to analyze my data, but it never understands. This is useless." The user gets stuck and gives up.
Boredom Burnout: "The AI can summarize emails, but it doesn't help with my core tasks." The user masters the basic features but sees no deeper value and disengages.
Your Takeaway: Burnout is a design failure. Use analytics and user feedback to identify where users are struggling or dropping off. Are they failing to get value? Are they unaware of advanced features? Use these insights to improve your feedback loops, add more valuable capabilities, or create clearer paths to mastery.

Beyond the User: Applying These Principles to AI Agent Training

These principles are not just for user interfaces; they are critical for training autonomous AI agents. In this context, the agent is the "player," and the training environment is the "game."

The Interaction Loop: The agent takes an action, the environment changes, and a reward signal provides the feedback that updates the agent's internal model.
Perceived Value: The reward function must be carefully designed to incentivize the actual behavior you want, avoiding loopholes.
Skill Chains: Curriculum learning, where an agent is trained on simple tasks before moving to more complex ones, is the direct application of skill chains.

Designing an agent training environment is user experience design—but for an AI.

Bringing It All Together: The Three Pillars of Human-Centered AI

Building successful AI-driven applications requires a fundamental shift from traditional UX. Over this series, we have explored three critical considerations that form the pillars of a more human-centered approach:

Persona: We must deliberately design the AI's personality, voice, and tone to build trust and align with our users' expectations.
Guardrails: We must implement robust security and behavioral rules to ensure our AI is not only helpful but also safe, reliable, and professional.
Interactivity: We must design the user's journey with intention, using principles of engagement to teach them how to unlock the AI's full potential.

By moving beyond the underlying technology and focusing on these three pillars, product managers, designers, and engineers can create AI applications that are not just powerful, but intuitive, trustworthy, and genuinely delightful to use.

Don't Just Ship the Model—The Critical Need for AI Guardrails

In our last post, we discussed the importance of giving your AI a distinct and trustworthy persona. Now, let's talk about how to ensure that persona behaves responsibly, every single time.

Imagine onboarding a new employee. You’d typically have an interview process, background checks, and a clear understanding of their skills. But what if this new hire was a complete unknown? What if you gave them a laptop, full access to company resources, and simply trusted they would be a productive member of the team, all without any formal training or oversight?

You wouldn't just hope for the best. You'd have strict security policies, HR training, and a clear code of conduct. This is precisely the framework we need when integrating AI agents into our applications.

What if that new employee could be tricked by a phishing email into wiring funds to a scammer? Or started sharing confidential client information? Or, just as damagingly, what if they were rude, abusive, or expressed extremist views in a conversation with a customer? As we integrate AI, we must recognize that they are exposed to a new frontier of risks that product teams must actively manage. Welcome to your new employee.

The "Lethal Trifecta": A New Class of Vulnerability

As technologist Simon Willison eloquently explains, the most significant security risks for AI agents emerge from a combination of three factors: access to private data, exposure to untrusted content, and the ability to communicate externally.

This "lethal trifecta" creates a potent vulnerability. An AI agent with access to your company's private documents, that can also read incoming emails (untrusted content), and has the ability to send its own emails (external communication) can be manipulated into performing actions that compromise your entire system. This isn't hypothetical; attackers use techniques like prompt injection to turn your AI against you, instructing it to find and exfiltrate sensitive data.

Guardrails: Your AI's Code of Conduct

So, how do we protect our products, our companies, and our users? The answer is by designing and implementing robust guardrails. These are the architectural constraints and behavioural policies that prevent an AI agent from acting outside of its intended purpose. Relying on third-party solutions alone is not enough; this must be built into your product's DNA.

Let's break this down into two critical areas: Security Guardrails and Behavioural Guardrails.

Part 1: Security Guardrails

These are the technical barriers that protect against malicious attacks and data breaches.

1. Data Minimization: The "Need-to-Know" Principle Your AI agent should only have access to the absolute minimum amount of data required to perform its task.

Example: An AI assistant helping with a support ticket needs access to that ticket's data, not the entire customer database. Before data is sent to the AI, it should be scrubbed of irrelevant personally identifiable information (PII).

2. Input Validation: Inspecting What Comes In You must inspect and sanitize the data being fed into your AI to detect and block hidden, malicious instructions.

Example: An AI tool that summarizes web articles must first scan the page's content for malicious scripts or known prompt injection phrases (e.g., "ignore all previous instructions...") before passing the text to the LLM.

3. Enforcing Existing Permissions: Don't Let the LLM Bypass Your Security Enterprise systems use layers of abstraction and strict Role-Based Access Control (RBAC) to manage secure access to data. These same principles must be applied to data accessed by an LLM. Never assume an LLM will respect your existing permissions for free. While its ingenuity in finding answers is powerful, that power must be constrained by your security model.

Example: If your data retrieval system is designed to only allow an AI to access a "dev" environment, you need technical enforcement to prevent it from generating queries that access the "production" database, even if a user prompt subtly encourages it.

Part 2: Behavioural Guardrails

This is where we connect directly back to the persona we defined in Part 1. Behavioural guardrails ensure the AI's persona remains consistent, professional, and aligned with your brand, preventing it from saying something inappropriate or harmful.

4. Output Monitoring: The Character Clause It is not enough to just prevent data leaks; you must police the AI’s personality. An unconstrained LLM can drift into unsafe conversational territory.

What it is: A final check on the AI's response to ensure it adheres to your brand's voice, tone, and code of conduct before it's shown to the user.
Example: An AI that generates customer service emails should have its output scanned to ensure it doesn't use abusive language, express biased opinions, or become inappropriately suggestive. You can implement filters and define "canned responses" for when a conversation veers into a forbidden topic, such as, "I cannot discuss that topic, but I can help with [intended function]."

5. Contextual Awareness: Defining the AI's "Role" This is about setting clear boundaries for the AI's responsibilities so it understands what it is and, just as importantly, what it is not.

What it is: Programming the AI with a clear understanding of its operational purpose and limitations.
Example: An internal HR chatbot should be programmed with the context that its role is to answer questions about public company benefits. If a user asks for an opinion on a political candidate, the AI should recognize that this question falls outside its defined role and politely decline, reinforcing the persona of a professional HR assistant, not a personal confidant. As a rule, your AI Agent should be as aware of your HR policies as any other employee.

What's Next?

Implementing comprehensive guardrails is the foundation of a trustworthy AI. In the final post, we'll explore a third critical consideration for building human-centered AI products:

Part 3: Beyond the Prompt - Designing for True AI Interactivity: We'll discuss strategies for fostering engaging, multi-turn interactions and creating user experiences that feel more like a conversation than a command line.

Key Takeaways for Product Managers and Engineers:

Guardrails Have Two Halves: You must protect against both external security threats (like data exfiltration) and internal behavioural failures (like inappropriate responses).
Codify Your Brand's Principles: Your AI's operational rules should reflect the same code of conduct and ethical boundaries you would instill in a human employee.
Behaviour is a Feature: An AI that is consistently helpful, professional, and on-brand is not an accident. It is the result of deliberate design and robust behavioural guardrails.

It's life, Jim, but not as we know it

Designing the Human Element: Three New Considerations for AI-Driven Applications: Part 3 of 3