Skip to content
Human by design.
Magic by code.
← Maryl Gonzalez

From UX/UI Designer to AI‑Native Designer

Maryl GonzalezMaryl Gonzalez · My workflow with Claude Code, Codex and Figma

This tutorial is for UX and UI designers who already know their craft and want to start working with AI without knowing how to code. It gives the broad strokes of how I design today: Figma to think and decide, Codex for the creative assets, Claude Code to build, and a coded prototype as the deliverable instead of a static mockup.

I prepared this guide as a tutorial, on the recommendation of Ash.

Video lessons

Eight short videos follow one small project, Little Wins, from an empty Figma file to a live URL shared with the team. Each one covers a single idea, runs a minute or less, and is a real screen recording narrated in English. Every lesson has a download button if you want to keep it or share it.

LESSON 01 · 1:00Start in Figma

A new file: the flow, one screen laid out, colors and type saved as variables.

Download MP4

LESSON 02 · 0:46Define DESIGN.md

The design system is created in Figma first, then the agent reads the file and generates DESIGN.md from it, and the designer corrects it.

Download MP4

LESSON 03 · 0:52From frame to running screen

The Figma frame handed to the agent, and the screen appearing in the browser.

Download MP4

LESSON 04 · 0:48Creative assets with Codex

The art assets for the project, generated and placed into the screen.

Download MP4

LESSON 05 · 0:52The review loop

Reviewing what was built, giving feedback, and the fix.

Download MP4

LESSON 06 · 0:46Back to Figma and live

The coded screen back in Figma, and the published URL.

Download MP4

LESSON 07 · 0:51Working as a team

The shared project, and one request sent to a teammate's agent in Discord.

Download MP4

LESSON 08 · 0:53Figma builds itself

One instruction to the agent in Orca, and the interface appearing on the Figma canvas on its own. The idea for this one came from Ash: make the magic visible.

Download MP4

Who this is for, and the core idea

Your design process does not change. You still research, map flows, and care about hierarchy, states and accessibility. What changes is who does the mechanical part, and how soon you see your design actually working.

Stays the sameChanges
Research, judgment and design decisionsThe prototype is real code, not linked screens
Figma as the place to explore and alignYou describe intent in words and the agent builds it
The design system as the source of truthThe system also lives in files the AI reads
Your eye for review and polishYou review in the browser, with real data and states

The new skill is not coding. It is giving clear context, asking for precise changes, and reviewing what the AI delivers with a critical eye.

The tools and what each one is for

Three tools do the work, and a connector called MCP lets them talk to each other. Figma is where design decisions are made, the coding agents are where they get built, and the browser is where they get judged.

ToolWhat it isWhat I use it for
FigmaThe design canvas you already knowExploring layouts, defining components and variables, aligning with stakeholders
Claude CodeAn AI agent that lives inside the project folder. It reads and edits the real files, runs the app and sees its historyBuilding screens from Figma or from a description, iterating on look and feel, visual QA, pushing code back into Figma
CodexOpenAI's coding agent, working on the same project filesEverything creative: defining DESIGN.md and generating the art assets for each project, such as SVG icon sets
Figma MCPThe bridge between Figma and the agentsLets the agent read a frame's structure, variables and screenshot, and write frames back into a file
Browser MCP (Playwright)A real browser the agent can driveOpening the prototype, taking screenshots in light, dark and mobile, checking what was actually built
OrcaThe workspace where the agents run, each in its own tabGiving instructions to Claude Code and Codex in one window and handing tasks from one agent to the other

My rule of thumb: Codex for everything creative, Claude Code for building and reviewing. If you do not use Codex in your process, Claude Code can do everything except the creative assets that need image generation, which Codex has and Claude Code does not.

None of these replace the others. Figma without the agents stays a picture. The agents without Figma and a design system produce generic UI.

The workflow at a glance

The workflow runs from the design system to a published prototype, and most of the time goes into one loop: the agent builds, you review in the browser, you give feedback.

  1. Design in FigmaThe system first, then the screens.
  2. Write DESIGN.mdGenerated from the Figma file.
  3. Build with agentsCodex for the art, Claude Code for the build.
  4. Review in the browserLight, dark and mobile. Not right yet? New feedback, build again.
  5. Sync to FigmaCoded screens back as editable frames, for team review.
  6. Polish and shipAccessibility pass and a live URL.
  7. Share with the teamSame Figma file, same project, agents that ask each other.

Steps 3 and 4 are the loop. Context is set once per project. Figma comes before the build for decisions and after it when the team needs the result on a canvas.

DESIGN.md: the master design system for the AIs

Defining DESIGN.md is the most important step in this workflow. It is a single text file in the project folder that describes the brand's visual identity, and it acts as the master design system that every agent reads before it draws or builds anything.

The order matters: the design system is created in Figma first, and DESIGN.md is generated from it. Figma is where the system is designed, and DESIGN.md is how the agents receive it.

In a traditional process the design system lives in a Figma library and in the designer's head. Agents cannot see either by default. DESIGN.md puts the same decisions where Claude Code and Codex will find them, so a screen built by one and an icon set generated by the other come out looking like the same product.

What goes in it

  • Color: the palette with names and roles (background, surface, primary, text, states), for light and dark
  • Typography: families, the size scale, weights, and where each one is used
  • Spacing and shape: the spacing scale, corner radii, borders, shadows
  • Components: how buttons, cards, inputs and navigation should look and behave
  • Rules in plain words: what the brand always does and never does, including the style of icons and illustration

How to work with it

  1. Create the design system in Figma first: variables, styles and components. Then have the agent turn it into the file, and correct it yourself.
  2. Treat it as the agents' source of truth. When a design decision changes, change it in Figma first, then regenerate DESIGN.md and let the agents apply it.
  3. Keep it in sync with Figma variables, so the canvas and the code never disagree.
  4. Point every agent at it. The project context files (CLAUDE.md, AGENTS.md) should say that DESIGN.md must be followed.

In my setup, Codex writes DESIGN.md from the Figma design system, because it handles everything creative. That is a preference, not a requirement. The whole workflow, including DESIGN.md, can be done with Claude Code if your team does not use Codex, with one exception: the creative assets. Codex uses an image generation tool for some of them, and Claude Code does not have one, so those assets still need Codex or another image tool. Claude Code can still write simple SVG icons as code. For iconography and illustration with an artistic finish, I use Codex.

The quality of everything the agents produce depends on this file. A vague DESIGN.md gives generic UI, and a precise one gives UI that looks like yours.

When the team already shares a design system in Figma

Large design teams rarely start from a blank file. They work from a shared design system in Figma: published libraries of components, variables and styles that every file on the team uses. This workflow does not replace that system. It plugs into it.

The shared library stays the source of truth for design. DESIGN.md becomes its written mirror for the agents, so it is derived from the library and never invented next to it.

In the Figma libraryWhat the agent does with it
Variables (color, type, spacing, modes such as light and dark)Reads them through the Figma MCP and uses the same names and values as tokens in code
Published components and their variantsFinds the matching library component and reuses it, instead of drawing a new one that only looks similar
Components already built in codeWith Code Connect, each Figma component is linked to its real code component, so a frame turns into the team's own components
New screens the agent creates in FigmaAre assembled from library components and variables, so they stay linked to the system and update with it

Three rules keep a large team consistent:

  1. One system, two forms. The Figma library is for people and DESIGN.md is for agents. Both describe the same decisions.
  2. Changes flow one way. The design system team updates the library first. DESIGN.md and the code tokens are then regenerated from it, never edited on their own.
  3. Agents consume the system and do not extend it. If a screen needs a component that does not exist, that is a request to the design system team, not something an agent adds silently.

For a designer on a product team, this means the first prompt is rarely "design a screen". It is "build this screen using our library", with the library file connected.

Step by step

Each step below is something you already do as a designer, done with a different tool. The order matters most at the start: the design system first, screens second.

  1. Create the design system in Figma. Define the variables, styles and components first: color, type, spacing, and the pieces every screen will reuse. On a team that already shares a library, this step is done and you connect to it.
  2. Bring it into DESIGN.md. Have the agent read the Figma file and write DESIGN.md from it, then add the project context files (CLAUDE.md for Claude Code, AGENTS.md for Codex). Without this, every screen comes out generic.
  3. Design the screen in Figma and hand the frame to the agent. Lay out the screen with the system's components. Low fidelity is fine, because the goal is to make decisions. Then paste the frame link and say what to build. Through the Figma MCP the agent reads the layout, the variables and a screenshot, and adapts them to the components already in the project.
  4. Direct with intent, not CSS. Say "the cards feel flat against the gradient, I want them to float like frosted glass" instead of naming properties. When you have a reference, name the site or drop a screenshot and point at the specific pattern.
  5. Review in the browser, not in the code. Ask the agent to open the prototype and take screenshots. Check light and dark, desktop and mobile, empty, loading and error states. This is a design critique that happens while the thing is being built.
  6. Send it back to Figma when people need it there. The agent can push a coded screen into a Figma file as editable frames. Use this for stakeholder reviews or to keep the library in sync with what was actually built.
  7. Save a checkpoint after each good step. A commit is a named save point. Make one per idea, and one before any big visual experiment, so undoing is always cheap.
  8. Finish it like a product. Run a dedicated pass for accessibility, contrast, real content and responsive behavior, then publish to a live URL. At this point the prototype is close to production code, and developers get something that runs instead of a spec.

Steps 3 to 5 are a loop. Most of the time is spent there, and one pass usually takes minutes.

The last step: share the project with the team

The workflow ends when the project stops being yours alone. The whole team works on the same Figma file and the same project, each person with their own agent, and the agents can ask each other for what they need.

SharedWhat it gives the team
The Figma fileOne canvas for decisions, with edit access for everyone
The project in Claude Code and CodexThe same code, the same DESIGN.md and the same context files, so every agent follows the same rules
A shared channel for people and agentsOne place to ask for things, with a written trail of what was asked and answered

As an example only, this is how it can work with a collaborator. Each of us runs our own Claude, and both are connected to a shared Discord channel. When one of us needs something from the other, we mention the other person's Claude in that channel. It picks up the request and replies there, with the context of its own side of the project.

The shared channel is what turns separate AI setups into a team. Without it, each designer has a fast agent and the handoffs between people are still slow.

Translating the process you already have

Every habit from a traditional design process has a direct equivalent here. Start from the left column, which you already know, and learn the right column one row at a time.

What you do todayThe AI-native version
Write a design briefWrite CLAUDE.md / AGENTS.md: what the product is, who it is for, how the project is organized
Maintain a style guide or UI kitKeep DESIGN.md and Figma variables in sync, so the agent uses your tokens
Build a moodboardGive the agent named references and screenshots, and say which pattern you want from each
Draw wireframesSketch in Figma, or describe the screen and let the agent build a rough first version
Design high-fidelity mockupsRefine the coded screen directly, with Figma for the decisions that need a canvas
Link screens into a clickable prototypeThe prototype is the running app, with real navigation, data and states
Annotate specs and redlines for handoffHand over the code and the live URL. The spec is the thing itself
Run a design reviewReview screenshots the agent takes in every mode and viewport
Save versions and duplicate pagesCommit small, named checkpoints
Do a final QA pass with developersRun your own accessibility, contrast and responsive pass before anyone else sees it
Draw or source icon sets and other art assetsGenerate them with Codex as SVG, guided by your own art direction, and place them straight into the project

How to start

Start with one small, real screen you have already designed, not a new product. You know what good looks like for it, so you can judge the agent's output instead of guessing.

  1. Install Claude Code or Codex and open it inside an empty project folder
  2. Connect the Figma MCP so the agent can read your files
  3. Ask the agent to set up a starter project and run it, so you see a page in your browser
  4. Write a short DESIGN.md from the variables and design system in your Figma file: ask the agent to draft it, then correct it
  5. Paste the link to one Figma frame and ask the agent to build it
  6. Ask for screenshots in light, dark and mobile, and give feedback the way you would to a junior designer
  7. Commit when it looks right, then try one change described only by how it should feel

Good first projects are a landing page, a settings screen, or one card component with all its states. Avoid starting with a full flow, authentication or anything that needs a backend.

You do not need to read the code to begin. You do need to read what the agent says it did, and check it against what you see.

Bringing an existing project into the workflow

You do not need a new project to work this way. A product that already exists, in code, in Figma or in both, can join the workflow at any point. The only difference is that the first step is reading what is there instead of starting from a blank file.

What you already haveHow it enters the workflow
A Figma file, no code yetConnect the file to the agent, turn its variables and components into DESIGN.md, then build from the existing frames
A coded product, no Figma fileAsk the agent to read the code, write DESIGN.md and the context files from what it finds, and push the real screens into Figma as editable frames
Both, but out of syncDecide which one is the truth, write DESIGN.md from it, and let the agent bring the other side up to date

In every case the first deliverable is the same: a DESIGN.md that describes the product as it is today. Review it carefully before asking for anything new, because an existing product carries inconsistencies and the agent will copy them faithfully.

From there the steps are the ones above. New screens, redesigns and fixes go through the same loop of build, review and feedback.

Common mistakes

Most early frustration comes from treating the agent like a search bar or like a magic button. These are the mistakes worth avoiding from day one.

MistakeWhat to do instead
Asking for a whole app in one promptBuild one screen or one component at a time
Skipping the design system filesWrite the context first. Ten minutes there saves hours of generic output
Dictating CSS propertiesDescribe the intent and the feeling, and let the agent choose the implementation
Trusting "done" without lookingAlways ask for a screenshot and check it yourself
Checking only desktop in light modeCheck dark mode and mobile separately. Bugs hide in the mode you did not open
Making many changes before savingCommit after every step that works
Explaining the same quirk every sessionWrite it down once in the project's context file
Abandoning Figma completelyKeep it for exploration and alignment. Code is for building, not for every decision

A minimal glossary for designers

These are the only technical words you need for the first month. Each one maps to something you already know.

TermWhat it means in design terms
TerminalA text window where you talk to the agent. You type sentences, not commands
Repo (repository)The project folder plus its full version history. Think of a Figma file with every version saved
CommitA named save point you can return to
BranchA duplicate of the project for trying an idea without touching the main version
AgentAn AI that does not only answer: it reads files, edits them and runs things
MCPA connector that lets the agent use another tool, such as Figma or a browser
Design tokensYour Figma variables, written as code: colors, type, spacing
ComponentThe same idea as in Figma, built once in code and reused
Dev server (localhost)A private preview of the app running on your own computer
DeployPublishing the app to a real URL anyone can open
+
A SOUNDTRACK OF MY OWN
Different skiesAmbient edit · Original music by Maryl

Ready to play with your first interaction.

Soft, responsive sounds. You set the mood.