AI is changing the design industry faster than any of us expected.
UI execution is increasingly automated. System design, orchestration, and constraint design are becoming the differentiators.
If you’re a designer trying to stay relevant, this is for you.
The good news? You don’t need to code. You don’t need a CS degree.
You do need to understand how AI actually behaves with real users. The same work we’ve always done as UX designers: spotting where things break, redesigning for clarity, just applied to AI.
The fastest way to learn? Hands-on exercises. Not courses. Not theory.
Below are the exact practical exercises that helped me build expertise in human-centered AI, agent ecosystem design, service design for AI infrastructures, coordination patterns, and the emerging discipline Agentic Experience Design (AX).
These exercises develop the exact skills modern AI teams urgently need, while building a strong portfolio artifact.
Let’s get into it.
Why Practical Exercises Work Better Than Courses
AI is evolving too fast for traditional courses.
By the time a curriculum is approved, the tools have already changed.
But real audits, real breakdowns of real systems, redesigning actual failure moments, are skills that translate immediately into:
- portfolio case studies
- job interviews
- freelance work
- product roles for agentic systems
- agent behavior design
- workflow for consulting
And they help you build genuine, earned expertise.
So here are the 6 practical learning exercises that will turn you from AI-curious to AI-confident.
Exercise 1: Run an AI Agent Audit
Choose any agentic feature embedded inside a product or workflow. Focus on systems where AI proposes, decides, or acts, rather than simply responding to prompts. You are not auditing the base model itself (how smart ChatGPT is).
Focus on:
- Where the agent initiates actions
- Where users lose visibility or control
- How errors, uncertainty, and recovery are handled
- Whether escalation or interruption is possible
What you’re learning here is how models actually behave when users interact with them.
This is one of the best portfolio-building habits you can develop. Do it weekly and you’ll have more AI expertise than most people claiming to be “AI designers.”
Risk surfaced:
Loss of user control, unclear decision boundaries, silent failure, over-automation.
What you learn:
Human-centered AI, safety, usability, model behavior.
Exercise 2: Do an AI Accessibility Audit
Accessibility was an afterthought for most traditional platforms. Barely compliant. Retrofitted years later. And now? We’re building AI systems that exclude diverse users by default.
Screen readers can’t parse AI responses.
Cognitive load is through the roof.
Confirmation patterns don’t exist.
If we don’t design for accessibility now, we’re excluding more than a billion people from the entire AI revolution.
This teaches you safety-through-design, inclusive AI, user trust, and failure states. Skills that make you valuable to any team that actually cares about building products for everyone.
What you learn:
Safety-through-design, inclusive AI, user trust, failure states.
Exercise 3: Map the Frontstage and Backstage of an AI Service
Exercise 3: Map the Backstage of an AI Service
This is where designers start looking like strategists.
Pick any AI tool and map the complete service: frontstage and backstage. This is straight from service design, where we’ve been mapping what customers see versus what happens behind the scenes for decades. Now we’re applying it to AI systems.
Pick any AI tool and map:
- frontstage (what users see)
- backstage (what must exist behind the scenes)
- data flows
- orchestration
- triggers
- escalation
- responsiveness
- recovery flows
- monitoring needs
Even if you have to guess, it trains your ability to think like an AI product team. You start seeing the complete system, not just the interface. You understand why certain design decisions were made. You spot where things will break before they do.
This is systems thinking. And it’s what separates designers who get hired from designers who get passed over.
What you learn:
Service design, systems thinking, infra awareness.
Exercise 4: Define Agent Roles in an Ecosystem
In this exercise, you’ll practice defining boundaries for different agent types. This is exactly what product teams struggle with right now, knowing where the agent should act autonomously and where it needs human oversight.
Pick any tool or workflow and define:
- the agent’s purpose
- what it should not do
- handoff logic
- escalation to humans
- memory boundaries
- autonomy limits
- success criteria
The difference between an agent that’s useful and an agent that’s dangerous often comes down to how well teams defined these boundaries. Do this for a research agent. Then a scheduling agent. Then a content agent. A QA agent. A data-cleaning agent.
This is the work that keeps AI systems safe, predictable, and trustworthy.
What you learn:
Agent architecture, governance, behavioral design.
Exercise 5: Redesign One “Failure Moment”
Once you start auditing AI agents, you’ll notice something immediately: AI fails constantly.
Some of the most common failure moments:
- hallucinations
- broken flows
- poor prompting
- unclear next steps
- silent failures
- over-automation
- missing undo/confirm
- unpredictable actions
Instead of getting frustrated, use these failures to learn. Redesign JUST that one moment.
Keep it small. But do it weekly.
What you learn:
Safety, micro-interactions, model-limitation awareness.
Exercise 6: Build a Simple Agent or Automation
Exercise 6: Build a Simple Agent
This one is optional. You can absolutely understand how AI agents work without building them.
But if you want some hands-on experience, or you work closely with developers, try building a simple agent workflow. You can start with no-code automations like GPT Builder (Custom GPTs), Zapier Agents, or Airtable automations. If you want to go deeper, explore developer toolkits like LangChain.
Ideas for simple agents to build:
- A research summarizer
- A meeting-prep agent
- An email classifier
- A content consistency checker
- A user-interview synthesizer
- An interview-prep agent
You’ll start understanding what developers are dealing with when they are building these systems. And you can have more informed conversations about what’s actually possible versus what sounds good in theory.
What you learn:
No-code automation, prompt architecture, constraints.
What AI Systems You Can Evaluate Today
Several major platforms now offer coordinated multi-agent capabilities that move beyond simple copilots to autonomous task execution:
- Salesforce Agentforce 360: Uses the Atlas Reasoning Engine to execute multi-step workflows across sales, service, and marketing. Includes Agentforce Builder for creating custom agents.
- Microsoft 365 Copilot: Separate specialized agents across Word, Excel, Teams, and Outlook coordinate throughout your workday. Already deployed to 100M+ users.
- Google Workspace Studio: Agents across Gmail, Docs, Drive, and Chat that understand goals, plan actions, and execute on your behalf. Supports Agent2Agent (A2A) protocol for cross-platform collaboration.
- Amazon Q Business: Features “Agentic RAG” and performs 50+ actions across third-party apps like Jira, ServiceNow, and Salesforce.
- Amazon Buy for Me (Pilot Feature): Amazon’s pilot feature that can complete purchases on behalf of users, including from third-party sites, effectively acting like a shopping agent within the app (the beginning of “agentic commerce” and “machine customers”).
Consumer & Workflow Agents
This is the easiest and most accessible way to start. Although the following products expose partial agentic behavior, not end-to-end autonomy, that’s exactly what makes them useful to study.
What you can meaningfully audit today:
- Canva Magic Write/Design: delegated creation inside workflows
- Notion AI: summarization, classification, light task delegation
- Gmail/Google Workspace AI: drafting, prioritization, suggested actions
- Amazon Rufus: Amazon’s shopping Assistant supporting recommendation, comparison, purchase guidance
- Zapier AI/Power Automate: interpretation → automation → outcome
- Alexa (Echo Show): multimodal, ambient, interruptible agents
Many companies are also building proprietary agents using low-code platforms (like Agentforce Builder) or developer frameworks (CrewAI, Microsoft AutoGen, LangGraph), creating custom “agent factories” tailored to their specific business workflows.
What Makes a System “Agentic” vs. Just a Chatbot
Most consumer systems today are not full multi-agent architectures. Many rely on a single decision layer or simple orchestration and build as thin wrappers around base LLMs.
They may feel impressive, but they are not agentic in a meaningful sense.
Agentic systems must:
- Delegate tasks rather than just respond
- Make decisions and execute actions autonomously
- Manage state and persistence across sessions
- Handle consequences and errors
Remember when evaluating an agent, be it single or multi-agent system, you are not auditing how “smart” the system is, you are not testing how “intelligent” ChatGPT is, but:
- What happens when something goes wrong
- When the system acts on the user’s behalf
- How control, visibility, and recovery are handled
That’s where design risk lives and where you should focus.
Join the Agentic Design Community (Launching Q2 2026)
If you’re serious about designing for agentic systems, not just reading about them, the Agentic Design Community is a great place to practice. Inside the community, we focus on two things:
- Live audits of real agentic systems: Using the AI Agent Audit & Containment Risk Framework to analyze failure modes, control boundaries, and trust breakdowns.
- Multi-agent coordination patterns: Frontstage/backstage mapping, handoffs, escalation logic, and recovery strategies drawn from real-world systems.
- 2 live audit or system breakdown sessions per month
- 2 Q&A / review sessions (portfolio, system diagrams, audits)
- Shared templates and frameworks used in the sessions
This is not a course. There’s no content drip. No prompt hacks. No hype.
It’s a shared practice space for UX/product designers, service designers, accessibility practitioners, and PMs transitioning into the agentic era. We explore how agentic systems actually behave, how they fail, and how to fix them, preparing you for the jobs emerging fast.
Join the Waitlist →
