· 8 min read · AI, Process, UX

AI workflows in a software company, part 1: the design flow

Tape, scissors, a cutting knife and sticky notes on a blue desk
Photo: Jo Szczepanska, CC0

In an AI-centered design flow you don't start in Figma anymore. You start with a working prototype, and the designer's job moves from drawing screens to judging them. That is a real change. It also has limits, and in a big company they matter a lot more than in a small one.

The old flow and the new one

The old flow was a line. Idea, research, sketches, wireframes, mockups, handoff, and then code. Code came last because it was the expensive part.

Now code can come early. Roughly like this:

  1. Idea and brief. You write down the problem, who the user is and what "good" means. AI can't do this part for you.
  2. Research. AI helps with desk research, summarizing transcripts and clustering notes. It does not replace talking to people (more on that below).
  3. An early prototype. A prompt, a sketch or a Figma frame turns into something clickable in minutes, in Claude Code or a tool like v0.
  4. Review. You test it, throw most of it away and pick a direction.
  5. The real front end. The direction you picked gets built with the real design system, close to the final code.
  6. Checks. Accessibility, copy, edge cases, and usability tests with real people.

So the designer becomes more of a reviewer and curator than a maker. Making things got cheap, which means judgment is worth more now, and so is the discipline to actually test what you made.

What AI does well in design

Early work. Ideas, quick concepts, a prototype you can put in front of people in a usability test. Text AI is also fine for UX copy, for brainstorming, and for a first pass on accessibility. A first pass, not the last one.

Where it fails

Weak hierarchy, poor contrast, uneven spacing, a generic look. If you work with a good design system, the results get better.

Research is a no-no. Synthetic users are too positive and too shallow, and they can't possibly replace real people.

Claude Code for designers

Claude Code works in a repo and a terminal, so it sounds like a developer tool. But Figma's own guide lists quite a few designer uses: building prototypes from real components, building Figma frames from code, fixing spacing that drifted, rewriting generic empty-state copy, flagging accessibility issues and syncing tokens. It can read your designs through the Figma MCP. Figma also says it is not a developer replacement and that you are the one who decides what ships.

Why Claude Code

Right now I think it's the best tool for this, and together with Figma it works better than anything else I've tried. It works in your actual project, not in a sandbox, so what it builds is real code you keep. It reads the Figma file, builds against your own components and tokens, and then it can open the result in the browser, compare it with the design and fix what's off. It can also hand work to other agents, for example one that reviews what the first one built.

Developers seem to agree. It's the most used coding agent in this year's surveys.

To be fair, on paper Figma treats several tools the same. Cursor, Codex, Copilot and others connect to the same Figma server (Figma). The difference shows in practice, in how closely it follows the design and how well it fixes its own mistakes. That's my experience, not a benchmark, and this changes fast.

How I'd set it up

It depends where you start. This is a way of thinking, not a recipe, because every project starts somewhere else. Some have a finished product and no current designs, some have only designs, some have nothing yet.

  • You have a finished codebase, but the designs are old or missing. Let Claude bring the product into Figma. It can build Figma frames from your code (a beta feature on Figma's side), so the design team gets a real picture of what exists and can work from there.
  • You have Figma, but no code. Go the other way and let it generate the code from your designs. It reads them through the Figma MCP. Messy files work, but a tidy file with named layers, components and variables gives you noticeably better results.
  • You have both, and they have drifted apart. Connect them (more on that below) and let Claude point out where the design and the code no longer match.
  • You have nothing yet. An empty project is fine. Describe what you want, write a short spec or let Claude interview you until you have one, and build the design and the code side by side.

Whatever the starting point, keep version history from the very first step, so you can always go back when something goes wrong.

Rules. Claude figures out a lot by itself, so only write down what it can't guess: use the tokens, reuse existing components, stick to the spacing scale, meet the accessibility minimums. Those rules can live in several places. Some apply to the whole project, some only to you, some only to certain parts of the code. Claude treats them as context, not as law, so keep them short and specific. It also remembers your corrections over time. How to write good rules is a topic of its own, and I'll go into it in a future article.

Connect design and code. Once real components exist in code, whether you started from code or from Figma, Figma's Code Connect maps them to the components in your design files, so the generated code reuses what you have instead of inventing lookalikes. Before you have code, you don't need it. Check your Figma plan, though. The free tier gives you only a handful of AI calls a month, and Code Connect needs a paid plan.

Let it check its own work. It does this when it has a way to, like tests or a browser, or when you ask. So give it one. Connected to your browser, it opens the page, compares it with the Figma design, reads the errors and fixes what it finds. Ask for evidence, a screenshot next to the design, not just a "done".

Big tasks are fine, at first. Don't chop the work into tiny pieces. A big task often comes out better in one go, and then you fix the small stuff. Tell it to be ambitious, otherwise it tends to build the smallest thing that fits the request. That's for prototypes and new projects. In an existing production codebase, split the result into small changes someone can actually review, like in part 2.

Review with agents, not by hand. Nobody reads every change. You read what you can in the time you have and let AI check the rest: a fresh reviewer that never saw your conversation, and small checker agents that each do one job, like the design system or accessibility. For accessibility, also run a proper checker tool on the real page and tab through it with the keyboard yourself, because models can be confidently wrong about it. The agents narrow down where to look. Before anything goes to production, a person still looks at the risky parts, logins, payments, personal data, and owns the change. For a throwaway prototype you can skip that.

Keep it safe. Only connect tools you trust, keep access keys out of the project, and check which client or NDA designs your company allows in an AI tool.

Label prototypes as prototypes. A polished screen pulls stakeholders into button-color debates way too early (NN/g warned about this in 2025).

Enterprise versus small

In a small company or on a website, the gain is speed. Templates, a simple deploy, a few people deciding. AI can take you from idea to a live page in a day, and if you guessed wrong it's cheap to fix.

In enterprise software the same speed runs into friction. The flows are complex, there are many roles, and there are legacy screens the model has never seen. The design system has to be followed exactly, close enough doesn't count. Compliance and accessibility need evidence, and "looks fine" isn't evidence. Then there's data privacy, meaning what can go into a prompt and which tools are approved at all. Third-party MCP servers carry a prompt-injection risk, and Anthropic says you should trust a server before you connect it.

On top of that, approvals are slow and there are many stakeholders. A fast prototype does not make a decision meeting any shorter.

I think this is why the gains are so uneven. Prototyping speeds up everywhere. Getting to production doesn't.

Honest limits

The output looks the same everywhere unless you give it strong direction. Models can be confidently wrong about accessibility. And cheap prototypes tempt teams to skip research. That is the real danger, and I see it happening everywhere, with management blinded by their vibe-coded results.

The next post is part 2: faster is not better, about AI across the whole development cycle.

Sources

Comments