What product and UX designers can try, from design systems an AI agent can follow to reviewing what it makes, taken from what the teams in these articles did. Jev, an AI model from TypeSafe, checks that each one makes sense without its article. How the check works

The files an AI agent reads before it works, such as AGENTS.md, CLAUDE.md, design-system rules and other written instructions, and the person or team who keeps them current.
In the design system's documentation for each component, add when to use the component and when not to beside its properties, so an AI agent building screens retrieves the reasoning as well as the options.
At the end of a working session with an AI agent, have it turn the designer's review comments into written rules or skills that later sessions follow.
Name design-system representatives in both design and engineering who take part in final decisions, so review does not wait on a central team.
Write rules the AI agent reads at the start of every session that say where new work goes and how to name files.
Sort a prototype folder into main, exploration and archive areas, with a short map at the top that says what not to touch.
Before an AI tool builds an interface component, write down how it takes keyboard focus, which states it shows, how it is dismissed and which colour tokens it uses in each mode.
Keep a register of deliberate exceptions to the design system's rules, each with its reason, for AI agents to read before they report a bug.
Have an AI agent add feedback from review meeting transcripts to the design file as annotations, so the designer can take part in the meeting.
Write the design system's usage rules and known mistakes into guideline files attached to the library, so the AI agent reads them on every task.
Define the design system's colours, type, spacing and components in one source before AI agents build screens, and point every agent's instruction file at that source.




Check colour contrast in screens an AI agent builds, even when the agent used the correct colour values from the design file.
Write down an order of authority for conflicting design guidance, from the user's goal to general heuristics, and give it to the AI agent.
Give an AI design tool synthesised research findings and recommendations, not raw user comments alone.
Write a design system's DESIGN.md file mainly as an overview, colour roles and rules on what to do and avoid, and name the package version its values came from.
After an AI agent builds a screen from the design system, mark up the remaining layout problems on screenshots or recordings and send them back to the agent.
Mark which component is current and which are retired, so an AI agent does not have to guess between them.
Give an AI model a guide of about 100 words for each task, with a definition, three to five solved examples and a few rules taken from a designer's past decisions.
Log every component that an AI agent searches for and does not find, and review that list as the design system's backlog.
Before merging a page that an AI agent has rebuilt, click through its interaction states and confirm that each existing function still works.
Check every colour and size in a screen built by an AI agent against the design system's named values, and replace any that is not one of them.
Give every Figma component the same name and properties as its counterpart in the code component library, so an AI agent rebuilding a screen can match each part.
Write a script that compares the component names, properties and defaults in the Figma library with those in the coded components, instead of asking an AI model to compare them.
When the same lesson recurs across an AI agent's runs, write it as a one-line rule in the agents' instructions, and have a designer approve the rule in the pull request.
Instruct AI agents that when no approved component, pattern or documented exception fits, they report the gap for review instead of creating a new pattern.
Ask the AI agent for a note beside each prototype listing the components it used, what it built by hand and where Figma and code differ.
Ask the AI agent to write a list of everything it could not express or was unsure about each time it builds design-system components, and review that list by hand.
Keep components identical in Figma and code, then write their usage rules into DESIGN.md files and Agent Skills so that AI tools build screens from the same rules.
When someone corrects an AI agent's mistake in the design system, have the agent write the lesson in a file beside its instructions. Then add an automated check that fails the build if the mistake returns.
Have the design-system team publish its rules from one shared service that AI coding agents read directly, so no developer works from an outdated copy.
Prototype with AI agents on a design branch that is never merged, and have developers rebuild the accepted ideas on a feature branch.
When a change made with an AI agent goes wrong in code, fix the design in the design tool first, then have the agent carry it back into code.
Write a short contract for each design-system component in its code, listing the allowed variants and the uses it forbids, so that AI coding agents follow it when building screens.
Write the steps for documenting a component, such as diagramming its structure and mapping colours to tokens, as AI agent skills that any designer can run.
Give every component a profile and rules for correct and incorrect use, and write down what the product never does.
Put the rules an AI agent keeps getting wrong into the instruction file it reads every time.




Before adding variants to a component library, separate the few that need a design decision from those that only repeat sizes, and handle the repeats with variables.
Score AI-generated designs against a written checklist of criteria drawn from the research.
Keep building screens and maintaining the design system as separate jobs for AI agents, so an agent that needs a missing component notes it instead of changing the design system.
Give the AI agent a way to look up the existing component and its rules for the screen it is building, instead of the whole design guide.
Tell AI agents in writing which components and properties are deprecated, and what to do when no component or token fits.
Have the design-system team store its design tokens, the named values for colour, type and spacing, in one shared industry format that every design tool and AI agent reads the same way.
Settle which source wins when the design file and the shipped component disagree before giving either to an AI tool as a reference.
Let a designer, not the AI agent, decide which corrections are added to the design system.

AI makes a working prototype quick, so the effort moves to choosing a direction and getting from prototype to production with a reliable product.
Hold design reviews in small groups several times a week instead of in one large weekly meeting.
Bring a working prototype to a design review instead of a written specification.
Have someone with strong design knowledge review an AI-generated prototype before anyone treats it as ready to ship.
Remove any named solution, such as generative AI, from a design workshop's problem statements, so that the team does not choose the answer in advance.
Place several prototype directions side by side where the team can compare and discuss them, instead of judging one prototype on its own.
Show stakeholders a working prototype with real data instead of static screens when proposing a new idea.
Split design guidelines into many small markdown files with an index, so an AI agent reads only the file it needs.
Split design system guidelines into many small Markdown files with an index, so that an AI agent reads only the file it needs.
Book small-group sessions to set up access, VPN, the terminal and Git before a workshop that teaches designers to prototype with AI tools.
Compare one recurring design task done with and without an AI agent, timing the first version, the review and the fixes until the team can approve the change.
Before engineers give a coding agent a refined design prototype to apply, have the designer write down the secondary interactions and edge cases the prototype does not show, so the agent does not invent them.
Keep 20 to 30 real user tasks with known good answers, and rerun them whenever a model or vendor release changes, reviewing the results like a usability study.
Build prototypes from the production design system and let reviewers load their own account data, so that reviews discuss the idea rather than placeholder content.
Document the design system for AI agents with code examples, consistent component interfaces and guidance on when to use each pattern.
Hand engineers the refined working prototype, with its design system and a changelog of what changed in each version, instead of a separate set of design files.
Change one piece of the interface or one step of a flow at a time with an AI model, and check it against the current product before merging it back.
Build stakeholder prototypes from the same coded components the developers use, so reviewers see how the design will behave in the shipped product.
Start each AI chat session in early research with a short brief, and copy what the session produced back into the project's shared notes.
Agree with engineering what belongs in a designer's pull request, what must be tested, who reviews it and who owns the change once it ships.
Before choosing a direction from an AI prototype, build out the states it leaves out, such as a cancelled booking, to see whether the direction still holds.
Give designers prototype templates built on the design system, and let improvements made in a prototype flow back into the template.

How the jobs of product managers, designers, engineers and their managers change when AI agents do more of the building.
After an AI agent finishes a task, show the user a list of the decisions it made and why, and let the user reverse any of its actions from that list.
Have user experience designers write down which product changes need a person's review, such as changes to navigation, in the instructions AI agents follow when they build.
Have the designer review an AI-drafted prototype for usability and accessibility, and approve the experience separately from the product manager's sign-off on scope.
Have each design leader own one piece of production work a month, such as a component or a prompt, and put it through the usual review.
Keep a simplified copy of the product with fake data where designers can prototype in code without waiting on or breaking the production system.
List the week's pending decisions, mark the few that are hard to undo, and return every reversible decision to the person doing the work.
Have designers submit visual changes as pull requests built from the design system's coded components, and have a developer review each one before it ships.
Name three to five people who use AI tools every week to decide which tools the team adopts or drops, and give operations the contracts, security, access and budget.
Give product designers ownership of the production interface, including its performance, bugs and quality, and have them ship changes as pull requests.
Build a small throwaway tool with controls for one design question, try the design's variants on real content, and export the chosen values as code or design tokens.
Treat AI output as a draft that someone checks before anyone builds on it.
Set up a separate coding environment for designers who build with AI, with written permissions for what they may change, shared AI skills and a design system the AI can read.

A person or team answers for what an AI agent does, and decides its instructions, its default settings and when it must hand a decision to a person.
Run a hard design review of an AI feature before any code is written, testing each part of the concept against what happens when it goes wrong.
Write down the decisions that stay with people, such as creative direction and money, before handing studio work to AI agents.
In evaluations of an AI feature, test the whole task end to end, not only the text it writes, and include cases where a connected tool is disconnected, a saved preference changes or no answer fits.
Show the user exactly which records an AI agent will add, change or delete, run the change only after approval, and return the values it replaced.
Make the agent acknowledge the steps a user has already tried before it suggests anything new.
Give every instruction file that an AI agent works from a named owner who keeps it current.



When a feature's behaviour is hard to show in static screens, build an interactive prototype in code with the real design tokens and let stakeholders try it on their phones.
List the moments when users lose trust in a support agent and write the agent's behaviour for each one, including a stated handoff to a person.
Give each AI agent its own account with minimal rights and one of three levels of action: act and log it, prepare and wait for approval, or never act.
For each action an AI agent can take, decide with engineers whether it needs the user's approval and what stops when the user cancels.
Ask a person to accept the AI agent's plan for a broad request before the agent may request permission to change files.

A person other than the one who built a piece of AI-assisted work checks it and approves it before it reaches customers, often called keeping a human in the loop.
Write down which actions an AI agent may take alone, such as opening a pull request, and which wait for a person, such as merging or deploying to production.







Sort the actions an AI agent asks a person to approve into tiers by consequence, such as spending, publishing or deleting, and offer undo for actions that can be reversed.
Have a person review each interface an AI agent builds by opening its live preview link, including on a phone.
Before an AI agent's proposed change is applied, show users a preview of its full effect, including on other people, and apply it only when they confirm.
Ask the coding agent for a plain-language summary of every change a designer submits, and hold the change to the same review standard as an engineer's.
Sort design system guidance for AI agents into rules checked automatically, guidelines a person reviews, and decisions a named person owns.
Let an AI agent propose documentation updates when a Figma component changes, and have a person approve each update before it merges.
Include an accessibility check in the reviews an agent must pass before it is released to other staff.
Ask an expert in the subject, not a generalist, to review an AI agent's output, with a structured way to check each answer.
Put a designer on the team that sets up the company's AI agents, so that the agents' output is judged by a designer's standard of good work.

A written record of what was decided and why, kept with the work so that someone who did not build it can review it.
Keep a file beside each prototype that records what was decided, by whom and why, and read it before changing the prototype.
Replace a feature's requirements document and design brief with one table that has a row for each thing the product lets someone do. Link a click-through prototype under each row, and have a designer record a video walkthrough at the top.
Add a deliberate review step whenever research findings are copied into a new document, such as a ticket or a brief, and record what changed.
Put a short human-written brief at the top of every ticket or specification handed to an agent, and label each section as written by a person or generated by the agent.
Write a prototype's fidelity rules, such as no new colours or components, in a file that the AI agent reads before each task.
Sketch a screen in rough grey lines before any code, and check whether the rules written for it contradict each other.
Show the design options rejected during discovery beside the option carried forward, so that a reviewer can see that alternatives were compared.

Before an AI feature is built, the team writes down what a good output looks like, so that the result can be tested against it.
After a release, interview users from any group whose usage data looks unexpected, such as a department that sends back many support tickets.
Have the agent add sliders and other live controls to a prototype, so that its colours, sizes and motion can be adjusted while it runs.
Have the AI agent ask its questions or show its plan before it builds anything.




Split a structured AI conversation into explicit stages with rules for moving between them, instead of relying on one long prompt.
After an AI agent proposes failures in a set of real user sessions, have a person check each one against the team's own notes on those sessions. Accept or reject each failure before anyone writes a metric for it.
Before changing an AI feature's prompt to fix a known error, write a check that counts how often the error appears, and rerun it after every change.
Write a research section into a feature's spec naming the expected outcome, signs of success and harm, and what to track, so the coding agent builds the tracking.

Product pages and data designed so that an AI agent, not only a person, can use them.
In design review, check that each flow can be finished without guessing: distinct button labels, states visible without hovering, and a clear confirmation when a task succeeds.
Cut the app's sidebar from a list of product pages to about five items, each named for a question customers ask of their data.
Run a usability study of a task that an AI agent starts and a person finishes, and check whether information, logins and progress carry across the handoff.
Replace checkmarks in comparison tables with specific values that name their source and date, so that an AI assistant can copy them and a person can check them.
Use the places where AI agents operating the product fail as a list of usability problems to confirm with people and fix.
Study how customers who work through AI agents use the app, and design a home page that shows what needs their attention today.
Give AI agents the same actions and forms that people use in the interface, and show an agent only the actions that are possible at the current step.

A set of correct answers or expected results, prepared by someone other than the builder, that a reviewer uses to check work made with AI.
Write down the problem a feature solves before building it, and judge the result against that statement.


Compare any study that uses synthetic respondents with answers from real people before treating its findings as evidence.

A team checks on purpose that its people can still explain work that AI agents produced.
Have AI agents place before-and-after screenshots of each interface change side by side for review.
When AI tools draft research findings, have a second researcher work through the interpretation with the first, so that someone can disagree and catch what was missed.

A workshop that confirms rules a team has already drafted while reviewing real work, instead of trying to invent them in the room.
Write down a design principle whenever a review catches AI-generated work drifting from the product's existing patterns, and share the list with the other design leaders.
Check in design critique whether an AI feature's loading state describes more steps than the system runs, and use a plain spinner for a single quick call.

Before an AI agent starts, the work is split into pieces small enough for a person to review one at a time.

How people new to a craft build judgement when AI tools do the work that used to teach it.

Plays from links that are not filed under a topic.
For each new sign-up or login flow, list every step and every new term a customer must learn, and remove the ones that do not help them finish the task.
Design what a person sees while an automated action runs and just after it ends, such as a saving indicator, before the feature ships.
On each AI answer, label what the AI system checked against a source, what it inferred and what the user still needs to review before acting on it.
When a user gives an AI agent an instruction, ask whether it applies this once or from now on.
Show every standing rule an AI agent follows on one page where the user can read and revoke it.
Design an AI feature to hand users the finished result first, such as a personalised report, and offer the underlying tool and controls as a second step.
Keep the existing interface beside any new chat feature and track which path users choose.
Have the AI agent record each edit as a named move, such as merge, move or reframe, so users can see what changed.
When people keep asking an AI agent in chat to do the same job, have the agent build a small dedicated tool for that job instead.
Hello, I'm Wevy. Ask how product, design and engineering teams work with AI agents. The answer comes only from the 315 links on this site.
Claude picks the links and writes the answer from them only. Answers can be wrong. Do not type personal information: questions go to Anthropic. How Ask works · Privacy
I send the week's answers from real teams in one email, every Monday.
You get one email to confirm, then one every Monday. Your address goes to Resend once you confirm it. Privacy