Bahasa Indonesia

AI in the Product Designer Workflow: Where It Helps, Where It Breaks

Every design tool now has an "AI" button. You've clicked most of them. Half produced output that looked like a 2019 Dribbble shot in a trench coat. The other half saved you a real afternoon.

The difference isn't the tool. It's where in the workflow you pointed it.

I've spent the last year being too embarrassed to admit how much I use AI on certain tasks, and too irritated to admit how much I refuse to use it on others. This is the cleaned-up version of what I've actually settled on. No "AI will replace designers" doom. No "AI will 10x your craft" hype. Just the parts of the week where it earns its keep and the parts where I still tell it to go away.

Why this matters now

PMs are shipping with v0 and Cursor without you. I don't say that to scare anyone. I say it because the question of "should designers use AI" already got answered by people who aren't designers.

If you don't have a point of view on AI in your craft, someone else's point of view becomes the default. And that default is almost always a generic Tailwind card stack with three icons, a gradient, and the word "Empower" somewhere in the hero. You know the one.

So this is less about embracing AI and more about getting specific. What does it actually do well? What does it ruin? And what's the smallest test you can run this month to find out?

Where AI genuinely helps

These are the parts of my week where I've stopped being precious about it. The output is good enough, the time saved is real, and the part of the job that used to live here wasn't where I earned my paycheck anyway.

Research transcript clustering

Twenty user interviews used to mean a week with a spreadsheet, a tag column, and the slow erosion of my will to live. Now it's roughly thirty minutes.

Dovetail AI, Notion AI, or Claude with the transcripts pasted in will pull themes, frequency, and quote clusters faster than any human. I still read every quote. I still cross-check the synthesis against my own gut from sitting in the actual sessions. But I skip the spreadsheet stage entirely, and the time I save goes into more interviews, which is where the leverage actually lives.

The trap: don't trust the first cluster. Run two passes with different prompts and look at where they disagree. Disagreement is where the interesting research is.

Prototype seeding

v0, Galileo, Figma Make. I use these for the boring scaffolding: a settings page nobody will look at twice, a table for an internal admin tool, a wizard with five steps that all look the same.

The trick is to treat the output as a wireframe, not a design. The grid is a starting point. The hierarchy is a starting point. Then you redesign roughly 70% of it because the AI version is generic and your product isn't. But you skipped the blank canvas, which is the worst part of any sprint that involves layout you don't care about.

For consumer surfaces or anything brand-led, this falls apart. We'll get to that.

Microcopy variants

Empty states, error messages, onboarding tooltips, button text when "Save" feels too plain but "Apply changes" feels too long. I generate ten variants, throw out nine, edit one.

The key word is edit. Anything I shipped verbatim from an LLM hit production sounding like an LLM. The cadence is wrong. The restraint is wrong. There's always one too many adjectives. But as a brainstorm partner, it beats staring at the cursor blinking next to "Sorry, something went wrong" for the hundredth time.

Alt text and accessibility scaffolding

First-pass alt text. ARIA label drafts. Color contrast checks. Screen-reader heading structure sanity-checks.

I verify all of it. AI hits WCAG AA on the obvious stuff and misses every nuanced edge case. But the blank page is gone, and that matters when accessibility work is already the part of the job most teams under-resource. A 50% head start beats 0%.

I'll caveat this hard in the next section, because shipping AI-generated alt text without review is how you ship "image of a person" 4,000 times across a marketing site.

Dev-handoff scaffolds

Cursor turning a Figma frame into a working component the engineer refines. This is, quietly, the most underrated AI design tool of the bunch.

Pair Cursor with a good design system and you cut handoff time in half. The engineer doesn't have to translate spacing tokens manually. You don't get the third "is this what you meant?" Slack message at 4pm Friday. The first commit is closer to your intent on the first try.

It works because there's a strict design system constraining the output. Without one, Cursor freelances, and freelance Cursor is just v0 with extra steps.

Where AI breaks (and you should not outsource it)

This is the list I'd staple to a monitor for any junior designer asking how much AI to use. Everything below is where the job pays you to think, and where AI thinks like everyone who came before, which is exactly the wrong instinct.

Taste

AI averages. Your job is to be specific.

When I ask an AI to design a SaaS dashboard, it gives me a SaaS dashboard. Generic, plausible, forgettable. Three KPI cards across the top, a chart, a table, a sidebar. It looks like every other SaaS dashboard because it was trained on every other SaaS dashboard.

But you're not designing a SaaS dashboard. You're designing this dashboard for this user, who works in this context, where the chart is the wrong primary because the user actually opens the page to do one specific task and the chart isn't it. AI won't catch that. You will.

Problem framing

AI answers questions. Designers decide which question is worth answering.

If a PM asks for a settings redesign and you ask Claude to redesign settings, you both got it wrong. The interesting move is realizing settings doesn't need a redesign. It needs to be unbundled, with the three settings people actually use surfaced into the main flow and the rest tucked into a "more" drawer. AI does not do that move. AI builds a better settings page.

The framing call is yours. Don't delegate it.

Accessibility nuance

I said this above and I'll say it again because it bears repeating. AI hits the WCAG AA contrast checks. It writes plausible alt text. It generates ARIA roles that look right.

It does not understand keyboard navigation flow when a modal opens inside a sheet inside a drawer. It does not understand that a screen reader reading "button button button button" across a card grid is technically compliant and functionally hostile. It does not understand that an autoplay video without a pause control violates more than just one criterion.

Test with a screen reader. Test with keyboard only. Test with reduced motion on. AI is not a replacement for the actual tests, no matter how confident the output sounds.

Brand voice

AI copy sounds like AI copy. The cadence, the inside jokes, the restraint, the willingness to leave a sentence shorter than it wants to be. That's still you.

Every brand I respect has a voice that's slightly weird. Slightly off-rhythm. Says things in an order that surprises you. AI cannot reproduce that, because AI was trained to be the opposite of weird. It was trained to be reasonable. Reasonable is the death of brand voice.

If your brand voice can be replicated by an LLM, your brand doesn't have a voice.

Novel interaction patterns

AI is trained on what exists. If your product needs something new, AI will pull you toward what's average.

I once asked Galileo to mock up a flow for a feature that was genuinely novel. It produced a perfectly fine version of the closest existing pattern, which was the wrong pattern. I spent an hour pushing it to do the new thing and got nowhere. I closed the tab and sketched it on paper in 15 minutes.

When the answer is novel, AI is anchor weight. Don't fight it. Just don't use it for that part.

Honest tool takes

In rough order of how often I open them:

  • Figma AI. Solid for renaming layers (this alone is worth it), generating placeholder content that isn't "Lorem ipsum," first-draft icons that you'll redraw. Mediocre at "design this screen": output is generic. Use it for the chores.
  • v0 / Galileo. Great for engineers spinning up internal tools without a designer. For consumer surfaces or branded experiences, the seam shows immediately. I use v0 for inspiration scaffolds I then redo from scratch. Galileo I use less.
  • Cursor for design-to-code. The most underrated AI design tool, full stop. Pair with a good design system and your handoff loop gets meaningfully faster. The single change with the highest ROI on this list.
  • ChatGPT / Claude as a thinking partner. Better than any visual tool above for critique, copy, naming, and pressure-testing your own logic. Worse than all of them for visual output. Treat it like a colleague you can interrupt at 11pm.

That's the whole list I actually open in a normal week.

The "AI designed it" giveaway tells

I keep this list pinned in my Figma. If three or more of these show up in something I'm about to ship, I redo it.

  • Three-card layout with three icons across the hero or value-prop section.
  • A gradient on a CTA that didn't need a gradient.
  • Copy that uses "Unlock," "Empower," or "Seamless" without irony.
  • Perfectly even spacing that ignores visual weight (everything is 16px because the prompt said "use consistent spacing").
  • Stock-photo-style hero illustration of diverse people pointing at a laptop.
  • A pricing page with three tiers, the middle one labeled "Most Popular," and a checkmark column comparison nobody will read.
  • Headlines that follow the "verb your noun" pattern. ("Streamline your workflow." "Accelerate your team." "Simplify your stack.")
  • Body copy that opens with "In today's fast-paced world."

Three of these and the design tells on itself before anyone sees the file. Redo it.

Your 30-day plan

You can read this article and nod along, or you can run a real test. Here's the cheapest version of the second option.

Week 1: Cluster one research project. Pick a project where you have 10+ user interview transcripts. Run them through AI clustering (Dovetail AI, Notion AI, or Claude). Do your own manual synthesis pass in parallel. Compare the two. Note where the AI got it right, where it got it confidently wrong, and where it surfaced something you missed. The point isn't to replace your synthesis. It's to calibrate your trust.

Week 2: Prototype-seed one internal screen. Use v0, Figma Make, or Galileo for one internal-facing screen end-to-end. Settings, a table, an admin panel, anything where brand polish doesn't matter. Time how long it takes versus your normal flow, and write down where you had to redo it from scratch. You'll learn fast which 70% you can keep and which 30% has to be rebuilt.

Week 3: Microcopy variant pass. Run all the microcopy in your current project (empty states, errors, tooltips, button text) through an AI variant generator. Keep what's better. Kill what's worse. Log the patterns where AI consistently helped versus consistently flattened your voice. This becomes your personal cheat sheet for the next sprint.

Week 4: Pair on dev handoff. Pick one component going to engineering this sprint. Set the engineer up with Cursor and a tight design-system constraint. Measure handoff time and rework loops versus last sprint's equivalent component. If it's faster and cleaner, this is your highest-leverage change. Make it permanent.

Four weeks. One real test per week. By the end, you'll have your own opinions instead of mine.

Optional: mapping to the ACE Framework

If your team uses the ACE vocabulary (Ingest, Analyze, Predict, Generate, Execute), it's worth naming where design AI fits and where it doesn't.

  • Ingest: pulling research transcripts, support tickets, and session recordings into a workable corpus. AI helps a lot.
  • Analyze: clustering themes, surfacing frequencies, finding outliers in qualitative data. AI helps, with a verification pass.
  • Generate: prototype seeding, microcopy variants, alt-text drafts, dev-handoff scaffolds. AI helps inside guardrails.
  • Predict: which problem to solve next, which version to ship, which trade-off matters. You. Not AI.
  • Execute: the actual ship decision and post-launch ownership. You and your team. Not AI.

Saying this out loud is useful when a PM asks why you didn't just "let AI do it." The honest answer is that AI is helpful in three of the five capabilities, and the two it can't touch are the two that earn designers their seat at the table. Letting AI take Predict or Execute is letting AI design your product, which is also called shipping a generic product, which is also called the thing your competitors who don't have designers are already doing.

Common pitfalls

A short list of how this goes wrong, in roughly the order I've made each mistake myself:

  • Letting AI output skip critique because "it looks done." It looks done. It isn't done. Run it past your team.
  • Using AI for the part of the job that earns you respect. Taste, framing, novel patterns. If you outsource these, you become replaceable, and the person doing the replacing won't be AI. It'll be the next designer who didn't.
  • Hiding which parts of your work are AI-assisted. Tell your team. Transparency builds trust. Hiding it kills it the day someone notices.
  • Believing AI confidence over your own. AI sounds confident even when it's wrong. Your gut is calibrated by a thousand designs. Trust the gut.
  • Optimizing the wrong 30% of the week. AI that saves you 30 minutes on a task you only do once a month isn't worth integrating. Find the recurring pain.

Measuring success

Here's the bar I hold my own AI usage to.

You ship faster on scaffolding work: research synthesis, internal tool layouts, microcopy first drafts, dev handoff. You ship slower and more deliberately on the parts that matter: the framing call, the novel pattern, the brand voice, the accessibility nuance.

Your team can tell which 20% of your design week is now reclaimed time. You're using it to do more interviews, more critique, more thinking, more iteration on the parts of the work where iteration compounds.

And the most important measure: no one looks at your work and thinks "AI made this."

That's the bar. Anything less and you're using AI for the wrong part of the job.

Learn More