What Is AI Product Design? A Complete Guide for 2027
The cornerstone guide to designing products with AI, built around the code first approach.

Zander Whitehurst
16 min read
AI product design is the practice of designing digital products with AI as both a material and a medium. It covers two things: designing features that are powered by AI, and using AI tools like Claude Code, Cursor and Figma MCP to take an idea from a problem statement to a working, shippable interface. In practice it means designers spend less time drawing pictures of software and more time shaping real software directly, using their judgement to frame problems, direct AI agents and refine the result until it is genuinely good.
Going into 2027, this is no longer a niche way of working. A single designer can now build a convincing, working prototype in an afternoon, and teams are reorganising around that fact. The designers who thrive over the next few years will understand both sides of it: how to design with AI, and how to design for it.
I run Memorisely, and over the past couple of years I have watched a lot of designers go through this shift, including myself. I have made most of the mistakes in this guide personally, some of them more than once. What follows is everything I wish someone had told me at the start, built around the approach that has changed my own work the most: designing in code first.
What AI product design is, and what it is not
Meaning one: designing AI powered features
This is designing the parts of a product where AI does something for the user. A writing assistant, a smart search, a summary of a long thread. These features behave differently from traditional software. The same input can produce different outputs, they can be wrong with total confidence, and they need new patterns for trust, feedback and control.
Meaning two: designing with AI as your medium
This is using AI to do the work of design itself. Generating working prototypes from a written brief, pulling designs out of Figma into code, iterating on layouts by talking to an agent. Here AI is not the feature. It is the pencil.
This guide covers both, but it leans on the second meaning, because that is where the biggest change to a designer's day is happening.
What it is not
AI product design is not typing "make me a beautiful dashboard" into a tool and shipping whatever comes out. It is not replacing designers with prompts, and it is not a shortcut around understanding users. When making things becomes cheap, deciding what to make becomes the whole job.
How the workflow changed
For most of my career the process was wireframes, then static mockups in Figma, then a clickable prototype, then handoff, then weeks of pointing out differences in the build. That made sense when code was expensive. Changing a layout in Figma took minutes. Changing it in code took days and a patient engineer.
AI has changed the cost of code. A rough working interface now takes about as long to build as a rough frame takes to draw. Once that is true, the process reorganises. The workflow I teach now looks like this:
- Frame the problem clearly
- Write a short PRD (product requirements document)
- Prompt a working prototype in code
- Critique it with real behaviour, real data and real people
- Refine, in code or in Figma, whichever makes the next decision cheaper
- Ship
Handoff has mostly disappeared. Instead of handing over a picture of software, designers hand over software. Engineers review it, harden it and integrate it, rather than rebuilding it from a description.
I remember the moment this clicked for me. I had spent two days on a beautiful set of onboarding screens. Mostly out of curiosity, I rebuilt the first one in code with Claude in under an hour. Within five minutes of clicking around I found three problems my frames had politely hidden. The form jumped when an error appeared, the button was off screen on a small laptop and the empty state did not exist. Two days in Figma, and the browser told me the truth in five minutes.
The code first approach in depth
Why code is the new canvas
The canvas used to be Figma because Figma was where you could move fastest. Speed is still the reason. The fastest medium has simply changed.
Code gives you things a static frame never can:
- Real behaviour. Hover, transitions, loading, errors and focus states exist as actual behaviour, not annotations.
- Real data. You can test with a forty character name, a list of three hundred items or an account with nothing in it.
- Real feedback. People click working prototypes and try to break them. Static frames get opinions about colour. Prototypes get feedback about how things work.
The problems that sink a feature are usually behavioural, and you only find those by using the thing.
The loop
Here is the loop I use for almost every feature now.
1. Frame the problem. Write down who this is for, what they are trying to do and what is getting in the way. One paragraph. If you cannot write it, you are not ready to prototype, and no amount of AI will save you.
2. Write a PRD. Not a forty page document. A short brief covering the problem, the user, the key scenarios, the constraints and what success looks like. This becomes the context you give the agent, and it is the biggest single factor in the quality of what comes back.
3. Prompt a working prototype. Give Claude Code or Cursor the PRD, point it at your design system and ask for one small thing first. Layout before interaction. One screen before five.
4. Critique. Click through it. Resize the window. Try the empty state and the absurdly long name. Put it in front of a colleague or a user.
5. Refine in code or Figma. Small behavioural fixes go straight back to the agent. Visual problems that need careful comparison often go into Figma first, then the decision comes back into code.
6. Ship. Open a pull request, get an engineer to review it and see it go live.
Then go round again. Each lap takes minutes, which makes it feel more like sketching than production.
What designers actually need to know
The question I get asked most is "do I need to learn to code?" The honest answer is that you need to understand code, not write it from memory.
HTML and CSS are the basics. It helps to know what a heading, button, list and form actually are, and roughly how flexbox and grid lay things out. But you do not need to master them before you start. The real way designers work inside a codebase is through three things you already understand from Figma:
- Tailwind. Styling with small utility classes. It maps beautifully to how designers already think: padding, gap, radius, text size. Reading Tailwind is like reading a Figma inspect panel, and it is where most of your design changes will actually happen. I wrote a fuller introduction in Tailwind CSS for designers.
- Design tokens. The named values behind your colours, spacing, radius and type, like
surface-raisedortext-muted. Tokens are the bridge between your Figma variables and the code. When you change a token, every component that uses it updates, which is exactly how you keep a codebase consistent as AI writes more of it. - Component props. Every component has properties, called props, that control how it looks and behaves:
variant="primary",size="sm",disabled. If you have built variants and component properties in Figma, you already understand this. Knowing the props of your components lets you compose whole screens without writing new styles.
Add Git basics on top, what a branch, a commit and a pull request are, and you have enough to save your work, experiment safely and share it for review. GitHub basics for designers covers everything you need.
You pick this up by doing the work. Ask the agent to explain what it just built. That habit alone has taught me more than any course I ever started and abandoned. Within a few weeks, a line like rounded-xl border p-6 flex flex-col gap-3 reads as plainly as a Figma frame.
A worked example: saved searches
Let me walk through a real feature the way I would actually do it. Imagine a recruitment product where users run the same candidate searches every week and are tired of rebuilding the filters each time.
Framing the problem. I write: "Recruiters repeat the same complex searches weekly. Rebuilding filters takes minutes each time and they often get them slightly wrong, so they miss candidates. They need a quick, reliable way to rerun a search they trust." That tells me the real goal is reliability and speed, not just a save button.
Writing the PRD. The user is a recruiter. The scenarios are saving, rerunning, renaming and deleting a search, and seeing whether there are new results since last time. Constraints: use the existing design system, the filters panel already exists, it must work on a laptop. Success: a recruiter can rerun a saved search in one click.
Prompting the first version. In Cursor I give the agent the PRD and a focused request: "Using our existing components, add a Saved searches section to the top of the filters panel. Just the layout and three example saved searches. No interactivity yet." A couple of minutes later I have something rough but real.
Critiquing. With three saved searches it looks fine. With fifteen, the actual filters are pushed off screen. There is no empty state, so a new user sees a strange blank gap. And nothing tells the recruiter which searches have new results, which was the most valuable part of the brief. None of this would have shown up in a mockup with three tidy rows.
Refining. I go back to the agent in small steps. Limit the list to five with a "Show all" link. Add an empty state that explains saved searches with one clear action. Showing new results without making the list noisy is a visual problem, so I take a screenshot into Figma and explore four options side by side: a count badge, a dot, a bolded name and a line of text. The count badge wins because it tells the recruiter how much is new, not just that something is. I bring that back with specific instructions: "Add a count badge using our Badge component, subtle variant, aligned right in each row. Hide it when the count is zero."
Then I polish in the browser: hover states, a three digit badge, a very long search name.
Shipping. I open a pull request and an engineer reviews it, wires up real data and catches a performance concern I would never have spotted. From problem to pull request took an afternoon, and every decision was tested against real behaviour.
Where Figma still fits
The code first conversation sometimes gets framed as "Figma is dead". It is not. I still open it most days.
What has changed is its role. Figma becomes the sketchbook rather than the spec. It is still the best tool for comparing visual directions side by side, brand and illustration work, early concept exploration with lots of very different ideas, and maintaining the visual language of your design system.
Figma MCP connects the two worlds. It lets agents like Claude Code read your Figma files directly, so they use your real layout, spacing, tokens and components rather than guessing from a screenshot. You can explore in Figma, pull a frame into code, refine in the browser and push polished components back into your system.
The skill is knowing which medium makes the next decision cheaper. If the question is "how does this behave?", go to code. If it is "which of these four looks right?", go to Figma.
Design systems as AI infrastructure
If I could tell every design team one thing going into 2027, it would be this: your design system is no longer just a library. It is infrastructure for AI.
Agents build with whatever they are given. Give them a strong, documented system and they produce work that looks and behaves like your product. Give them nothing and they invent their own styles, which is how you end up with seven slightly different greys and buttons from three different companies.
Your design system can no longer live in Figma
For years the design system lived in a Figma library, with a coded version that engineers kept roughly in sync. That was fine when designers drew in Figma and engineers built from the drawings. It does not work when the work happens in Claude Code, Cursor, a PM's prototype and an engineer's pull request on the same afternoon.
The design system has to be ubiquitous. It needs to exist everywhere work gets made: in Figma for exploration, in code as real components and tokens, in the rules and skills every agent reads, and in the documentation people actually check. If it only exists in one of those places, every other place quietly invents its own version.
The test I use is simple. If a PM opened Claude Code tomorrow and asked for a new settings page, would the result use your tokens, your components and your patterns without anyone reminding them? If the answer is no, your system is still a Figma file, not infrastructure. Building that kind of system is what our AI Design Systems Bootcamp is about. I go deeper on this in Design systems need to be everywhere.
A system that works well with AI has three layers:
- Tokens. Colour, spacing, type, radius and shadow as named values. When an agent uses
spacing-4instead of a random pixel value, consistency comes for free. - Components. Real coded components with clear props and variants that mirror your Figma library.
- Rules. Written instructions agents follow, like "always use the Button component", "every list needs an empty state" or "form errors appear below the field". In Cursor these live in rules files, in Claude Code in project instructions. Either way, every agent session starts from your quality bar.
Rules are the new design documentation. The old kind sat in a wiki nobody read. The new kind gets read every time an agent builds something.
Skills aligned with your team
Rules tell an agent what to avoid. Skills teach it how your team actually works. A skill is a packaged set of instructions, examples and references that an agent loads when a task calls for it: how you write empty states, how you structure a PRD, how you compose a settings page from your components, how you check a screen for accessibility before it ships.
This is the part of the strategy I think most teams are missing, and it matters more than any single tool choice. Here is why.
When every designer on a team prompts in their own way, with their own private skills, the agent produces as many styles as there are people. One designer's version of a form has inline errors, another's has a toast, a third has both. Each piece of work looks reasonable on its own. Put them side by side and the product starts to feel like it was built by strangers. AI does not create that inconsistency, it just multiplies whatever inconsistency was already there, faster than any review process can catch it.
Shared skills flip that around. When the whole team works from the same skills, every agent session starts from the same craft standards. The junior designer gets the same quality bar as the design lead on their first day. Engineers and PMs who prototype get the same patterns the designers use. And when you improve a skill, every future piece of work improves with it. That is how a team's taste scales when AI is doing more of the making.
What good team alignment looks like in practice:
- One shared source. Skills live in the project repo, not on individual laptops. They are versioned and reviewed like code, so everyone is always using the current version.
- Built on your system. Every skill points at your real tokens, components and rules, so it reinforces the design system instead of working around it.
- Owned by someone. Each skill has an owner who keeps it current as the product changes. An outdated skill is worse than none, because the agent follows it confidently.
- Covering the craft, not just the code. The most valuable skills encode judgement: UI polish, UX writing, accessibility, motion and the states people forget.
- Agreed as a team. Writing a skill forces the conversation about how you actually want things done. That conversation is often worth as much as the skill itself.
My advice is to start small. Pick the two or three patterns your team argues about most, agree on them, and write them down as skills. You will notice the difference in your next design review. If you want a head start, the Memorisely skills are built to be shared across a team and adapted to your own system.
Designing AI features people trust
Now for the first meaning. When you design a feature powered by AI, three things matter most.
Show uncertainty honestly. AI can be wrong and rarely sounds unsure. Show sources where you can, make it clear what was generated and match your language to the confidence of the result.
Make feedback easy. Give people a simple way to say "this is wrong" or "this is helpful", and make it obvious the feedback was heard.
Keep the human in control. Let people review before anything important happens. Offer undo. Make results easy to edit rather than just accept or reject. An AI that drafts an email is fine. An AI that sends it without asking is a very different conversation.
Essential jargon in brief
- LLM (large language model). The AI system underneath tools like Claude, trained on huge amounts of text to understand and generate language and code.
- Tokens. The small chunks of text a model reads and writes, used to measure usage and limits (not to be confused with design tokens).
- Context window. How much information a model can hold in mind at once, including your prompt, files and the conversation so far.
- Agent. An AI that can take actions, like reading files, running commands and editing code, rather than just replying.
- MCP (Model Context Protocol). A standard way for AI tools to connect to other software, such as Figma, so they can read and act on real information.
- Skill. A packaged set of instructions and examples an agent loads for a specific kind of task, like writing UX copy or auditing accessibility.
Skills and roles
The skills that matter more than ever
When AI handles more of the making, three skills rise to the top.
Problem framing. A brilliantly built answer to the wrong question is still the wrong answer. It just arrives faster.
Judgement. Looking at what the agent produced and knowing whether it is good enough, what is wrong and what to do next. This is where I spend most of my teaching time, because it separates good AI work from noise.
Taste. The agent is fast, not opinionated. Spacing, hierarchy, rhythm and the feeling of quality still come from you.
The rise of the product builder and the design engineer
The design engineer sits between design and engineering, comfortable in Figma and in code, often owning the design system and front end polish. The role has existed for years, but AI tools have made it far more accessible to designers. Our AI Design Engineering Bootcamp is built for exactly this move.
The product builder is broader. Someone who can take an idea from problem to shipped feature mostly on their own, combining product thinking, design and enough technical confidence to direct agents well. I see more designers moving this way. You do not need a new job title to benefit, but knowing where roles are heading helps you choose what to learn next.
Common mistakes
I see the same mistakes over and over, in my own work and in the designers I teach.
- Shipping AI slop. Generic, slightly off interfaces that look finished at a glance and fall apart on inspection. The agent gave you a draft. Your job is to edit it until it meets your bar. The Fix AI Slop Skills give your agent that bar to work from.
- Skipping the problem. Jumping straight to prompting because it is fun. Without a framed problem, you just produce the wrong thing more efficiently.
- Ignoring the system. Letting the agent invent styles instead of pointing it at real components and tokens. Nothing looks like your product and nothing can be reused.
- Everyone using their own skills. Private prompts and personal skills mean every designer gets a slightly different product out of the same agent. Share them and agree on them as a team.
- Prompting too much at once. Big prompts produce big messes. Work in small loops.
- Forgetting the states. Empty, loading and error states are exactly where prototypes prove their value. Build them early.
A small confession. My first prototype built this way had a modal that refused to close and a button that turned purple for reasons I still cannot explain. I showed it anyway. People used it, and the feedback beat anything a polished frame had ever got me. Ugly and real beats beautiful and static almost every time. Just do not stop at ugly.
How to get started: a practical 30 day plan
This plan fits alongside a normal job and assumes no coding experience.
Week one: get comfortable with the tools
- Install Cursor or Claude Code and set up a simple starter project with Tailwind.
- Build one small static page from a description, like a profile card or pricing section.
- Ask the agent to explain everything it builds in plain English, and commit each change you like.
Week two: learn the loop on something real
- Pick a small, real piece of your product, such as a settings page.
- Write a problem statement and a short PRD, then prototype it one step at a time, including empty, loading and error states.
- Share the link instead of a Figma file in your next review and notice how the feedback changes.
Week three: connect Figma and your system
- Set up Figma MCP and pull a frame into code.
- Point the agent at your real components and tokens, and write a rules file with five rules it must follow.
- Agree one shared skill with your team, such as how you write empty states, and add it to the project repo.
- Practise the round trip: find a tricky visual problem in code, explore it in Figma, bring the decision back.
Week four: ship something
- Run the full loop on a slightly bigger feature, from problem to pull request.
- Ask an engineer to review it and listen carefully to what they flag.
- Write a short reflection on where code made you faster and where Figma still won.
After thirty days you will not be an engineer, and that is not the goal. You will have a working loop and a clearer sense of where your judgement adds the most value.
Closing
AI product design is not really about tools, even though that is where most of the conversation happens. It is about the distance between an idea and something real shrinking almost to nothing, and what designers choose to do with that.
When I started designing, the hardest part of the job was making things. Now it is deciding what is worth making and knowing when it is good enough. I think that is a better job. It puts the most human parts of design, understanding people, framing problems and caring about quality, right at the centre.
If you would like to learn this way alongside other designers, it is what we work through together in our live AI Product Design Bootcamp, or across all six bootcamps on the AI Design Training Path. But you do not need a bootcamp to start. Pick one small feature this week, build it in code and see what the browser tells you.
Memorisely