AI Product Design
Mastery Guide

The honest read on the current market: a principal-level designer who has already shipped strategic AI work (upstream system framing, AI-integrated design system governance, articulated principles for trust and human control) and is adding an MBA in AI Strategy and Leadership on top is rare. Most designers competing for the same roles do not have that combination.

The work to do is not building foundation. It is sharpening narrative, closing two narrow remaining gaps, and putting the portfolio in front of the right rooms.

From pixel-perfect to prototype-driven

Static Figma mockups are no longer the senior deliverable. The expectation is working prototypes built in v0, Lovable, Cursor, or Figma Make that can go in front of a user or executive and be iterated live. "Demo-driven design" is becoming default at strong product companies because the cost of building real prototypes has collapsed.

From usability testing to evals

Traditional usability testing assumes a deterministic interface. AI products are probabilistic. Senior designers are now expected to be in the conversation about evals: how do you know your AI feature is good, what are you measuring, how do you handle disagreement between behavioral signals and self-report. Designers do not need to write evals, but they need to influence what gets measured.

From "AI as a feature" to "AI as the substrate"

Two years ago AI was a sidebar feature. In 2026 it is the substrate of how products are built. A senior designer who cannot use AI tools fluently looks like a designer in 2014 who could not use Sketch.

From features to agents

The next wave is agentic products, software that takes actions on behalf of users. This breaks traditional form-and-button UX entirely. Companies hiring at senior and principal level want designers who can reason about autonomy levels, control surfaces, transparency, recovery, and trust.

Native mobile craft depth

For senior mobile-heavy roles, the signal that matters is deep native platform craft: gestures, motion, haptics, system integration. The fix is small: sharpen existing case studies with explicit native craft annotations (iOS gestures, haptic moments, motion choices, platform integration like Wallet passes and lock-screen widgets). Two screens and 200 words can materially change how a case study reads.

Portfolio surface craft

Hiring managers form a craft judgment in the first ten seconds, before they read a word. A 90-minute self-audit with one or two trusted designers, focused on spacing, typography hierarchy, image quality, card design, and whether the visual language reads "principal" or "senior," produces outsized returns.

Public writing

This is the single largest leverage point when the portfolio is ready. Two or three substantive pieces published over 90 days puts your name in front of the right hiring managers. Suggested topics drawn from real work: what you learned shaping AI experience vision before features existed; AI trust is built before the model is loaded; governance as partnership, not enforcement; what an MBA in AI Strategy is teaching you that design school did not.

Most designers do not have an MBA. Almost none have one specifically in AI Strategy and Leadership. This is a real differentiator if positioned correctly, and a wasted line on a resume otherwise.

How to use the framing in interviews

• Lead the strategic narrative with it. When asked "why are you interested in this role," the MBA bridges enterprise design experience and AI strategy fluency. A 30-second version: "I am a principal product designer with 15+ years in enterprise B2B and financial services. The reason I am in an MBA on AI strategy now is that I wanted to go beyond designing AI features and be able to shape how organizations decide where AI creates value in the first place."
• Translate frameworks back into design language. When the MBA exposes you to BCG's AI maturity model or Davenport's AI transformation framing, apply each to design decisions. Design leadership and product VPs value this most.
• Use it as license to take strategic interviews seriously. Many designers feel underqualified in executive rounds about AI strategy. Explicit credentialing changes that dynamic.

Designers trained on web and mobile spent fifteen years getting good at deterministic systems: click button A, get screen B. AI products break that contract. The same input can produce a different output the second time. The interface has to communicate not what will happen, but what is likely to happen, and what to do when the unlikely happens instead.

What changes when outputs are probabilistic

• Specs become probabilistic. You cannot specify "the system shows X." You have to specify "the system shows something in this range, with these guarantees and these failure modes."
• QA becomes statistical. You test by sampling many runs and checking a quality bar. Evals replace usability tests for the AI-specific surface.
• Failure modes are first-class design surfaces. What the system does when it is wrong, uncertain, or refuses is part of the design, not an afterthought.
• Trust replaces predictability. Users cannot trust the system to do the same thing every time. So the design has to earn trust through transparency, control, and graceful recovery.
• Variance can be a feature. In creative tools, variance is the point: regenerate is a verb. In transactional tools, variance is a bug. Knowing which mode you are in is half the design.

Every AI feature can be placed on a four-mode spectrum, defined by who initiates the interaction and how much authority the AI has. Where a feature sits on this spectrum is the single most consequential design decision you make. (These four modes are my own way of organizing the space, not an established industry-standard term.)

A mature AI product is rarely all one mode. The same product can have features in every mode. An enterprise quote platform could have passive anomaly detection, active summarization, collaborative editing assistance, and agentic batch renewal.

Three questions help you decide:

• How reversible is the action? Highly reversible actions can sit further toward agentic. Irreversible actions need active or collaborative with explicit confirmation.
• How well-defined is the goal? Clear goal = active mode works. Fuzzy goal = agentic shines (it can decompose). Exploring = collaborative.
• How much does the user want to learn? Power users and craftspeople usually prefer collaborative. Time-pressed and casual users usually prefer agentic.

Every AI feature has four phases: invocation, input, output, and control. Each phase has a small set of patterns.

Invocation patterns

• Inline trigger: Invoked from within the work surface via shortcut, slash command, or contextual menu. Examples: "/" in Notion, Cmd-K in Linear.
• Sidebar: Persistent assistant surface alongside the work. Examples: Microsoft Copilot, Notion AI sidebar.
• Modal/overlay: Focused mode that takes over the surface. Useful for high-attention tasks.
• Ambient surfacing: AI invokes itself when conditions are met. Most passive-mode features.
• Command palette: Launcher pattern adapted for AI. Powerful, dense, invisible to discovery.

Input patterns

• Open prompt: Free-text input. Maximum flexibility, maximum ambiguity.
• Structured prompt: Guided fields (tone, length). Reduces ambiguity, constrains creativity.
• Suggested prompts: Starter cards or examples. Help discovery; risk feeling canned.
• Attachments and context: Uploaded files, selected text, current page context.
• Voice and multimodal: Speech, images, video as inputs.

Output patterns

• Streamed text: Progressive reveal. The expected default for chat.
• Draft/replace: Single output to accept, edit, or reject.
• Side-by-side: Current and proposed versions shown together.
• Inline insertion: Output drops into existing work at a chosen location.
• Multiple variants: Several options. Useful for creative work; overwhelming for transactional.
• Structured output: Tables, lists, cards. Often more scannable than prose.

Control patterns

• Regenerate: Produce another sample. Critical when outputs are probabilistic.
• Edit prompt: Refine the input. Often more powerful than regenerate.
• Narrow scope: Operate on a subset (selected text, one section).
• Adjust parameters: Tone, length, formality, depth. Quick toggles after output.
• Continue/expand: Extend, deepen, follow up.
• Reject and revert: Remove AI contribution and return to prior state. Should be one click.

These address the recurring problem space of agentic systems: how does the user know what the agent will do, control what it does, and recover when it does the wrong thing? (This grouping into six patterns is my own framing, not an established industry-standard set.)

• The bottomless chat. Chat presented as the universal interface, even when the task is structured. Users get lost in conversation when a form would have served better.
• Confirmation fatigue. An agent that asks permission for every microaction. Users stop reading the confirmations; safety value goes to zero.
• The over-confident agent. Hallucinated answers presented with the same visual weight as verified ones.
• Silent action. The agent does something significant without telling the user. Trust evaporates.
• Magic without ratchet. Impressive demo with no path for the user to improve, correct, or customize it.
• Hidden memory. The agent surfaces something the user said three sessions ago in a context they did not expect. Often well-intentioned; almost always experienced as a violation.
• Agent sludge. When transparency or confirmation patterns become more burdensome than the work itself. The agentic equivalent of dark patterns by negligence.

• Welcome/empty state. What the user sees before typing. Job: communicate what the AI can do, set expectations, lower the cost of the first message.
• In-progress states. What the user sees while the AI is thinking. Job: communicate liveness without overpromising.
• Output. The response itself. Job: be useful, scannable, honest about uncertainty.
• Edge cases and errors. Refusals, ambiguity, failures. Job: tell the user what happened, what to do next, and what will not change if they retry.

The dominant writing failure in AI products is over-explanation. Three principles:

• Lead with the answer. First sentence is the answer. The rest is context, caveats, or follow-up. Inverted pyramid, not academic essay.
• Match length to input. Short question, short answer. A two-line question producing six paragraphs is a craft failure.
• Be honest about uncertainty without hedging into meaninglessness. "I am not sure, but my best guess is X" is fine. "It depends on many factors" is wallpaper.

A system prompt is the persistent instruction given to a model that sets its role, tone, constraints, and behavior. It is the single most important design surface in an AI product, and almost no one outside the team that writes it treats it as a design artifact.

Designers who do not co-author the system prompt cede the most consequential design decisions in the product to whoever does.

What a good system prompt covers

• Role and identity. Who is this AI? What does it represent?
• Scope and capability. What is it for? What is it not for?
• Tone and voice. Formal or casual? Specific vocabulary to use or avoid?
• Format defaults. When bulleted? When prose? How long by default?
• Refusal patterns. How does the AI decline gracefully?
• Examples (few-shot). Two or three concrete interactions that show the desired behavior.
• Safety and trust constraints. Confidence calibration, citation requirements, what to never claim.

How design and engineering should co-author

Design drafts persona, tone, format, and example interactions. Engineering drafts technical constraints, tool access, safety filters. PM owns scope. All three review together on real test cases. The prompt is versioned. Changes are reviewed like code changes. The prompt is evaluated continuously: whenever quality slips, check the prompt before changing the model.

This five-pillar grouping is my own synthesis for design work, not a canonical industry standard; the closest formal reference is NIST's AI Risk Management Framework, which names seven characteristics of trustworthy AI.

European Union: the AI Act

The most comprehensive AI regulation in force. Four risk tiers: Unacceptable (banned: social scoring, manipulative AI, most real-time biometric ID in public), High (heavily regulated: AI in hiring, education, credit, medical, law enforcement), Limited (transparency obligations: chatbots must disclose, AI content must be marked), Minimal (no special obligations). For product designers: if your product touches EU users and falls into high-risk territory, the design must include disclosures, explanations, human oversight surfaces, and reporting paths.

United States: patchwork by sector and state

• NIST AI Risk Management Framework: Voluntary federal framework, increasingly required in government procurement.
• Sector-specific: FDA on AI in medical devices; financial regulators on AI in lending; EEOC on AI in hiring.
• Colorado: The original Colorado AI Act (2024) was repealed and replaced by SB 26-189 in May 2026. The replacement is significantly scaled back, focused on disclosure and transparency rather than the EU-style risk framework. New effective date: January 1, 2027.
• NYC Local Law 144: Automated hiring tool requirements.
• Federal preemption: A December 2025 White House executive order directs federal agencies to challenge conflicting state AI laws, signaling movement toward a national framework.

Asia-Pacific

• South Korea: The AI Basic Act passed December 2024 and took effect January 22, 2026, making it the second comprehensive national AI law after the EU AI Act. It establishes obligations for high-impact AI, generative AI disclosure, and transparency requirements.
• China: Comprehensive generative AI regulation focused on content control and algorithmic recommendation.
• Singapore: Model AI Governance Framework, influential as a voluntary best-practice reference.
• Japan: Lighter-touch, principles-based approach.

For multinational products, the lowest-common-denominator approach often means designing to EU AI Act standards globally.

• Disclosure: AI-generated content must be marked in many jurisdictions. The AI label is a required component.
• Explanation: For high-stakes decisions, users have the right to know why. "Why" panels and reasoning surfaces are required UI components.
• Human oversight: High-risk AI decisions must have a meaningful human review path. Override and escalation routes are the spine of the experience.

Mature products have features at different levels. The level shifts as trust accrues: a user might start at Level 3 and migrate to Level 4. The Autonomy Dial pattern exposes this migration in the interface.

• Activity panel: Persistent surface showing what the agent is doing, separate from chat. Separates the agent's cadence from the user's conversation cadence.
• Approval queue: Dedicated surface for pending agent actions. Each item actionable in one click with enough context to decide without leaving.
• Audit log: After-the-fact record of every action and decision. Searchable, filterable, exportable. Critical for regulated environments.
• Override/escalation route: Path for the user to disagree, undo, or escalate. Visible without being prominent. Even if 99% of actions do not need it, the existence of an override is what makes users trust the 99%.

The defining shift in agentic UX is from instructing the system to delegating to it. The user specifies the outcome, not the steps. Design patterns that work:

• Start broad, narrow conversationally. Initial input is open. Follow-ups elicit constraints only as needed.
• Surface assumptions. Make every inference visible and editable in one click. "I will assume X, change?"
• Distinguish hard from soft constraints. "Must be Tuesday" vs "prefer Tuesday but flexible."
• Show the search space. "I looked at 12 options and these 3 fit best" is more trustworthy than "here is your result."

Common architectures

• Hub-and-spoke: One orchestrator routes to specialized sub-agents. Spokes usually hidden unless the user opts into transparency.
• Pipeline: Agents run in sequence. Each output feeds the next. Stage-by-stage progress visualization.
• Swarm/peer agents: Multiple agents collaborate, sometimes disagreeing. Cutting edge; surfaces for showing agent disagreement and reconciliation.

Multi-agent failure modes

• Cascading errors: Early agent's mistake propagates. Mitigation: per-stage confidence reporting, per-stage rollback.
• Cost runaway: Multiple agents each making model calls. Mitigation: visible cost meters, budget caps.
• Coherence loss: Agents that do not share full context produce inconsistent output. Mitigation: shared memory, explicit handoff structures.

• The task is fuzzy. Users do not always know what to ask. "Did the user complete the task" assumes a task exists.
• The output varies. A single usability session cannot tell you whether the AI is good. You need many samples.
• Success is multi-dimensional. A response can be technically correct and still wrong (wrong tone, wrong length, wrong assumption).
• Trust forms slowly. The first three interactions tell you about novelty. The thirtieth tells you about trust.
• The user changes the AI as much as the AI changes them. Users learn to prompt better. Snapshot research misses this.

What stays

User interviews remain irreplaceable. Field observation reveals what controlled studies hide. Open coding still works. Triangulation across methods is more valuable, not less.

What changes

• Sample sizes go up. Where a deterministic UI might need 5-8 users, an AI feature often needs 20+ to see the distribution.
• Sessions get longer or get replaced. Diary studies, longitudinal logs, and repeat sessions become the norm.
• "Did you complete the task" becomes "what did you learn?" The research question shifts from outcome to insight.
• Behavioral signals supplement interviews. Edit rate, regenerate rate, conversation depth, return rate are research data.

• Where does the user grant the AI authority, and why?
• What is the first thing they do when the AI is wrong?
• How has their use changed over the last month?
• Do they describe the AI as a tool, a collaborator, or a service?
• What did they ask the AI to do that they used to do themselves?
• What surprised them, positively or negatively?
• Where did they stop using a feature they initially tried?
• What do they tell other people the product is good for?

Five things to watch for:

• Probabilistic noise: Output variance adds statistical noise. Sample sizes need to go up substantially.
• Long horizons for trust: Trust forms over weeks. Plan AI A/B tests to run longer than non-AI equivalents.
• Multi-dimensional success: Optimizing one metric often degrades others.
• Self-reinforcing effects: More confident outputs get higher acceptance, not because they are better, but because users accept confident outputs more readily.
• Selection effects from variance: Users with bad first experiences churn faster, making the buggier variant look better than it is.

An eval is a systematic test of an AI system's behavior, run against a curated dataset, producing scores that are comparable over time. It is the closest thing AI product teams have to a unit test. It is to AI quality what regression tests are to traditional software.

The eval landscape

• Golden datasets: Curated input/expected-output pairs representing the universe of what the system should do well. Building the golden dataset is a design act.
• LLM-as-judge: Using one LLM to evaluate another's outputs. Works for clear, structural criteria. Fails for subjective quality.
• Pairwise comparison: Two outputs side by side; which is better? Often more reliable than absolute scoring for subjective quality.
• Human evals: Expert raters score against a rubric. Expensive, slow, irreplaceable for some tasks.
• Online vs offline: Offline gates releases. Online catches what slipped through in production.

• Evals encode what "good" means. The rubric is a consequential design decision. If the rubric is wrong, the system optimizes toward the wrong outcome.
• Eval data is design data. If the eval set does not include real edge cases, demographic ranges, and intent diversity, the product will not handle them well.
• Evals make tradeoffs visible. Improving one dimension often degrades another. Eval reports make these explicit.

Designer's contributions to golden datasets

• Real user intents drawn from research, not engineering hypotheticals.
• Edge cases and ambiguous prompts that real users actually submit.
• Demographic and contextual diversity.
• "Negative" examples: what the system should refuse or redirect on.

A senior designer is the team's eval-for-what-evals-miss:

• Coherence across turns. Single-turn evals miss whether the AI maintains personality and consistency across long conversations.
• The feel of the product. Aesthetic quality, voice consistency, conversational rhythm.
• Novel scenarios. Evals test what you anticipated. Real users do things you did not.
• Long-horizon outcomes. Did the user accomplish their actual goal, or just complete a turn?
• Subtle wrongness. Technically fine but tonally wrong, slightly evasive, patronizing. Numeric evals miss this.

Common eval traps

• Goodhart's Law: Optimize hard for an eval score and the model finds ways to score well without being better.
• Eval contamination: Eval data leaks into training data. Scores rise; real quality does not.
• Judge drift: The LLM-as-judge model changes; scores look like they moved when only the measurement did.
• Stable averages, hidden tail: Mean scores stay flat while the worst 5% gets worse.

Most metric dashboards are inherited from non-AI products. They measure engagement well but trust poorly. Metrics senior designers should advocate for adding: acceptance rate (the user's willingness to act on the AI's output), edit rate (how much the user modifies before using), regeneration rate (how often the user asks for another try), recovery rate (how often the user recovers from a bad output rather than abandoning), stuck rate (sessions where the user appears unable to make progress), and trust decay (users disabling AI features over time).

• High engagement = good. Sometimes high engagement is users struggling. Always pair engagement with task success and trust signals.
• Long conversations = good. Sometimes length means users failing to get what they need on the first try.
• Thumbs-up rate = product quality. Users thumbs-up to be polite or because they do not know better. Weak signal.
• Many features used = good. Sometimes breadth is users trying things and bouncing off. Depth beats breadth.
• Faster response = better. Sometimes a slower, more considered response builds more trust. "Thinking" UI patterns exist for a reason.

What senior and principal interviews test

• Strategic framing: Can you take an ambiguous business problem and decompose it into the right design questions?
• Craft and taste: Do your decisions show visual and interaction judgment beyond "follows guidelines"?
• Systems thinking: Can you reason about how one decision propagates across a product surface, a design system, and a team?
• Collaboration and influence: How did you bring engineering, PM, and execs along on a hard call?
• Domain fluency: For AI roles, can you talk credibly about evals, agents, autonomy? For mobile roles, gestures, haptics, platform conventions?

Questions to ask back

• "How does design typically get involved in AI initiatives here, before features are scoped or after?"
• "What is your eval pipeline for AI features? How often does it run?"
• "How do you measure trust separately from engagement?"
• "Where does the team draw the line on autonomy for your most agentic feature?"
• "What is the most important AI experience principle the team has converged on?"

Five signals that place a candidate ahead of most senior applicants:

• "I have designed for probabilistic outputs" followed by a specific example.
• "I have contributed to evals" with specifics: rubric design, golden dataset curation, reading the eval dashboard.
• "I shipped with metric X that mattered" tying a behavioral or trust metric to a design decision and an outcome.
• "I design the failure mode first" with an example of how you applied it.
• "I read evals" and can name a real quality dimension you pay close attention to.

The two-minute story

Name a specific AI feature you worked on. Name the metric that mattered. Name the eval thinking you contributed. Name what went wrong and how you adjusted. End on a principle you take from it. Two minutes. One feature. Specific metrics. This shape, repeated across two or three stories, is what makes a senior AI design candidate distinguishable.

AI prototyping and vibe-coding

• v0 (Vercel): Fastest path from prompt to working React/Tailwind component.
• Lovable: Full-app generation from prompts. Strong for end-to-end concept demos.
• Bolt.new: Similar space, sometimes better for complex apps.
• Cursor: Go from "asking it to write a function" to "pair-coding a small product."
• Claude Code: Command-line agent. Worth a weekend to feel how a real agent's UX is shaped.

Mobile prototyping

• Origami Studio: Meta's native interaction prototyping. Physics-based motion the way iOS engineers think.
• ProtoPie: More approachable. Supports sensor input, conditions, and variable-driven interactions.
• Figma prototyping (advanced): Variables, conditionals, component properties for working flows.

Books (short list, MBA-adjusted)

• AI Engineering, Chip Huyen (O'Reilly, 2025). Strong on evals, RAG, agents. The single most useful book.
• Hands-On Large Language Models, Jay Alammar and Maarten Grootendorst. Visual, hands-on vocabulary builder.
• Designing Agentive Technology, Christopher Noessel. Older (2017) but foundational. Re-read in light of current agents.
• Refactoring UI, Schoger and Wathan. For the visual craft signal in portfolio surface.

Practitioner content

• Hamel Husain on evals (hamel.dev). The clearest writing on AI evaluation.
• Eugene Yan on building LLM products (eugeneyan.com). Thoughtful, hands-on.
• Anthropic's "Building Effective Agents." The clearest current-state guide to agent patterns.
• Maggie Appleton, Geoffrey Litt, Amelia Wattenberger on generative UI.
• Smashing Magazine's agentic AI series (Feb 2026). Two-part deep dive on UX patterns.
• Microsoft's AI Agentic Design Principles.

Newsletters

• Lenny's Newsletter. Smashing Magazine. UX Collective. Linear blog. Stripe Press.

Days 1-30: Sharpen

• Refine presentation versions of lead case studies. Tighter, tested timing, clear pivot moments.
• Add native iOS craft annotations to mobile case studies.
• Run a 90-minute portfolio surface audit with trusted designers.
• Draft and publish one substantive piece on AI experience vision.
• Update LinkedIn to lead with principal AI strategy positioning.
• Read AI Engineering (Chip Huyen), Anthropic's "Building Effective Agents," and both Smashing Magazine agentic AI articles.
• Build one v0 prototype of an AI feature, however small.

Days 31-60: Targeted applications

• Identify 8-12 target companies. Apply to 3-5 with tailored materials.
• Reach out to former colleagues at AI-forward companies for warm intros.
• Publish a second piece (suggested: governance as partnership).
• Run two full mock portfolio presentations on Zoom, recorded.

Days 61-90: Live interviews and visibility

• Take live interviews. Treat the first as calibration.
• Publish a third piece (suggested: the MBA reflection piece).
• Apply to one speaking opportunity.
• Refresh materials after each interview based on what came up.