aiux
ToolToolCoursesCoursesNewsNewsSavedSaved
Menu

Explore

  • Map
  • Patterns
  • Skills
  • Open source↗

Courses

  • ›Claude Code
    Overview

    Setup

    • Sign In to Claude Code
    • Install Node.js
    • Install Claude Code

    Figma ↔ Code

    • Set Up Figma MCP
    • Turn Figma Frames into Code
    • Using Figma Links in Prompts
    • Figma to Code Best Practices
    • Bring Code Back to Figma

    Prototype

    • Start Your First Claude Code Session
    • Create Your Project Folder
    • Generate Your First Prototype
    • See Your Prototype Live
    • Get Back to Editing

    GitHub

    • Create a GitHub Account
    • Create a Repository on GitHub
    • Connect Your Local Project to GitHub
    • Save Your Changes Going Forward
    • Share Your Work (Let Claude Code Handle Git)

    Best Practices

    • How to Describe Your Design to Claude Code
    • Testing Your Prototype
    • Iterating Based on Feedback
    • Handing Off Work to Developers
    • Troubleshooting Common Issues
  • ›Cursor
    Overview

    Setup

    • Download and Install Cursor
    • Navigate the Interface
    • Edit Code with AI Assistance

    Prototype

    • Use Tab Completions
    • Chat with AI (Cmd+L)
    • Make Inline Edits (Cmd+K)
    • Build with Composer

    Design-to-code

    • Convert Designs to Components
    • Build Frontend with React and Tailwind

    Best Practices

    • Customize Your Workspace
    • Master Advanced Features
    • Best Practices and Team Workflows
  • ›GitHub Copilot
    Overview

    Setup

    • Install GitHub Copilot
    • Your First Code Suggestion
    • Workspace Setup for Designers

    Core Features

    • Autocomplete & Code Completions
    • Chat for Design Questions
    • Inline Code Explanations

    Prototyping Workflows

    • From Design to Interactive Prototype
    • Building Responsive & Interactive Layouts

    Developer Collaboration

    • Reviewing Developer Code
    • Communicating with Your Dev Team
  • ›GitHub
    Overview

    Setup

    • Create Your GitHub Account
    • Install Git on Your Computer
    • Understanding Git Basics

    Core Features

    • Clone Your First Repository
    • Making and Committing Changes
    • Working with Branches

    Developer Collaboration

    • Creating Pull Requests
    • Reviewing and Merging PRs

    Best Practices

    • Handling Merge Conflicts
    • GitHub Workflow for Design Teams
  • ›Build a Conversational UI
    Overview

    Foundations

    • What Is Conversational UI? (And What It Isn't)
    • Anatomy of a Chat Interface

    Building

    • Building Message Bubbles in React
    • Typing Indicators & Streaming Responses
    • Suggested Prompts & Conversation Starters

    Advanced Patterns

    • Managing Conversation Context
    • Error Handling & Fallback Design
    • Voice Interface Design Patterns

    Ship It

    • Accessibility in Conversational UI
    • Putting It All Together - Architecture Checklist
    • Agentic Conversational UI - When AI Takes Actions
  • ›Claude Design
    Overview

    Setup

    • What Claude Design Is (and Isn't)
    • Your First Prompt: The Four-Part Framework
    • Importing Assets: Screenshots, Docs, and Codebases

    Iteration

    • Iterating via Conversation
    • Inline Comments and Direct Edits
    • Tweaks: Explore Variations Without Chat

    Design-system

    • Extracting Your Design System
    • Publishing and Applying Your Design System
    • Team & Enterprise Setup

    Workflows

    • Prompt to Interactive Prototype
    • Prompt to Pitch Deck
    • Handoff to Claude Code for Implementation
  • ›Using AI UX Skills
    Overview

    Foundations

    • What Is Claude Code?
    • What a Claude Code Skill Is
    • Patterns Teach You, Skills Teach Your Agent

    Setup

    • Install a Skill Pack

    Core Features

    • How Triggering Works

    Best Practices

    • Working With Skills Day to Day
  • ›Claude Docs
    Overview

    Foundations

    • What a Doc Is, and Why It Is Not a Chat

    Working

    • The Anchored Comment: Brief It by Pointing
    • Watching It Work
    • Tabs, Sharing, and the Two Names Problem

    Judgement

    • When a Doc Is the Wrong Ask
  • ›Claude Slides
    Overview

    Foundations

    • The Question Slides Asks First

    Setup

    • The Empty Picker, and the Legacy Trap

    Working

    • Skipping the System, and What You Get
    • Editing by Comment, on a Canvas

    Handoff

    • The Export, Inspected

What’s new

  • Muse hits 5M and Claude Design sync
  • OpenAI Dots and Zombie UI
  • Shopify Agent Checkouts and Humane Design
  • All →

Topics

  • Adaptive & Intelligent Systems
  • Human-AI Collaboration
  • Trustworthy & Reliable AI
  • Natural Interaction
  • Performance & Efficiency
  • Privacy & Control
  • Accessibility & Inclusion
  • Safety & Harm Prevention
Previous: Autonomy SpectrumNext: Plan Summary
Human-AI CollaborationAgentic

Intent Preview

Before any significant action, the agent presents a clear, scannable summary of what it intends to do - showing planned steps, reversibility status, and edit controls for user approval.

What is Intent Preview?

The Intent Preview pattern addresses a core anxiety in agentic AI: users need to understand what will happen BEFORE it happens. Unlike traditional AI where the user explicitly types a prompt and evaluates the response, agentic actions may be initiated proactively or involve consequences that are difficult to reverse - sending emails, booking flights, modifying files. This pattern shows a clear, scannable summary of planned actions using plain language (not technical jargon), with each step marked for reversibility and editable by the user. The preview must be sequential for multi-step operations, highlight irreversible actions visually, and never auto-dismiss. This transforms the approval moment from a binary yes/no into a structured review that builds trust and catches misunderstandings before they cause harm.

Problem

When an agent is about to take a multi-step action, users need to understand what will happen before it happens. Without an intent preview, users experience anxiety leading to constant monitoring or blind trust that erodes at the first mistake.

Solution

Before any significant action, present a clear, scannable preview showing planned steps in plain language, with reversibility indicators, edit controls for individual steps, and explicit approve/reject buttons. Never auto-dismiss the preview.

Real-World Intent Preview Examples

Implementation

Practice in Courses

Claude Code

Claude Code Course for Designers

23 lessons, free course

Cursor

Cursor Course for Designers

12 lessons, free course

When to use Intent Preview, and when it backfires

Use it when

  • The action is consequential or hard to reverse: sending mail, moving money, deleting files, booking, posting. The cost of a wrong action is higher than the cost of a glance.
  • The agent inferred intent rather than being told step by step. The preview is where you check that the agent understood what you actually meant.
  • The plan is multi-step and the user can usefully edit it: drop a step, change a recipient, fix an attachment before anything runs.

Don't, or minimize, when

  • The action is trivial and reversible. A preview for every autocomplete or draft just trains users to approve on reflex, and a reflex-approval is no approval at all.
  • You can only show a preview that summarizes the plan but isn't the literal contract the executor runs. A pretty summary stapled to a different execution path is worse than no preview.
  • The preview would lag the real state. If the agent re-plans after approval, the thing the user signed off on no longer exists, and you've collected consent for a phantom.

The trap

The cosmetic preview: a tidy, reassuring summary that doesn't match what actually executes. The diff quietly omits the step that overwrites the file. The summary says 'archive 3 threads' while the job deletes them. 'Email the team' renders as one calm line and fans out to 400 external addresses. The user reads it, it looks reasonable, they approve, and the agent does something they never agreed to. This is worse than no preview, because a preview manufactures consent: now there's a record showing the user said yes to an action they were never actually shown. Real approval requires that the words on the card are the exact instructions that run. If the summary and the execution can drift apart, you didn't build a preview, you built an alibi.

Take it into your own product

  1. 1

    The preview must be the thing that runs, not a description of it.

    Render the card from the same plan the executor consumes. The moment the summary is built separately from the instructions, they can drift, and a preview that can lie is worse than none: it collects consent for an action the user never saw.

  2. 2

    Preview consequence, not just intent.

    'Send email' and 'send to 400 external addresses' are the same intent and wildly different actions. Show reversibility and blast radius per step so the irreversible, wide-scope move can't hide inside a calm one-liner.

  3. 3

    Approval is for the plan as shown, and only that plan.

    If the agent re-plans after the user approves, the thing they signed off on no longer exists. A stale yes carried forward is a phantom consent. Re-prompt when the plan changes; never auto-run on a timeout.

  4. 4

    Make it editable, or it's just a confirmation dialog.

    The value of a preview is catching the misunderstanding before it executes. If the only options are approve and reject, you've reproduced the yes/no you were trying to replace. Let users drop a step or fix a recipient in place.

  5. 5

    Record what was shown next to what ran.

    Persist the previewed plan alongside the executed actions. If they ever diverge, that's the incident that proves your preview was honest, or proves it wasn't. Without that record, you can't tell a real approval from an alibi.

Save as a Claude skill

Save Intent Preview as a Claude skill

Saved skills collect on your dashboard, ready to download one at a time or as a pack for your repo. Once a skill is in place, Claude Code applies it whenever you work on a surface this pattern covers.

30-second check

Check if your product already has this pattern

Upload a screenshot. We'll tell you which of the 38 patterns your AI interface uses and where the gaps are.

Audit My Design

Take all 38 patterns as Claude skills

Get the whole library as skill files, so Claude applies these patterns while it builds instead of after you catch them in review.

  • One skill file per pattern, all 38
  • Drop them in .claude/skills and Claude applies them as it builds
  • Daily AI UX newsletter (unsubscribe anytime)

More in Human-AI Collaboration

Contextual Assistance

Offer timely, proactive help and suggestions based on user context, history, and needs.

Human-in-the-Loop

Balance automation with human oversight for critical decisions, ensuring AI augments human judgment.

Augmented Creation

Empower users to create content with AI as a collaborative partner.

Want More Patterns Like This?

Daily AI UX news and new pattern breakdowns, straight to your inbox. Unsubscribe anytime.

Previous PatternAutonomy SpectrumNext PatternPlan Summary

aiux

AI UX patterns from shipped products. Demos, code, and real examples.

Have an idea? Share feedback

Get daily AI UX news

Services

  • Audit my product
  • Request an audit

Resources

  • All Patterns
  • Browse Categories
  • Contribute
  • Claude Code Skills
  • AI Interaction Toolkit
  • Agent Readability Audit
  • Newsletter
  • Documentation
  • Figma Make Prompts
  • Designer Guides
  • Events
  • Design System
  • All Resources →

Company

  • About Us
  • Privacy Policy
  • Terms of Service
  • Contact

Links

  • Portfolio
  • GitHub
  • LinkedIn
  • More Resources

Copyright © 2026 All Rights Reserved.

Used by:
Claude
Claude
GitHub
GitHub

Agent Action Plan Preview

An interactive preview of planned agent actions with reversibility badges, edit controls, and approve/reject flow.

Toggle to code view to see the implementation details.