As a UX/UI designer, one of the biggest challenges I face is the long journey from idea to prototype. We spend time writing requirements, sketching, refining, and polishing. By the time something usable is ready, the team has often been waiting for weeks. That waiting slows projects down and makes collaboration harder than it needs to be.
I’ve been experimenting with ways to make that process faster without losing quality. Recently, I tried Figma Make, a tool that turns prompts directly into working React applications. It does not replace design, but it helps create something tangible that a team can click through and test almost immediately.
The Pain We All Know
If you’ve ever been on a cross-functional team, this will sound familiar:
- Stakeholders want something concrete to react to.
- Designers want enough time to produce clean, consistent screens.
- Developers need clarity before they start writing code.
The problem? The “real” version of a product often doesn’t appear until much later in the cycle. And when it finally does, it usually sparks yet another round of back-and-forth. The result is delay, rework, and frustration across the board.
What Figma Make Brings to the Table
What impressed me about Figma Make was not that it “designs for you” (it doesn’t), but that it reduces the distance between an idea and a prototype. Here’s what stood out:
- From a plain prompt, it generates a usable UI.
- It respects common UX patterns and accessibility basics.
- It lets you attach style guides or screenshots, so outputs feel closer to your brand.
- It creates a working React application you can actually click through.
- It includes practical features like “Point & Edit” for quick fixes, version restore, and a “Fix it” option for obvious UI bugs.
At the same time, there are real limitations:
- No export back into Figma Design (yet). You still rebuild final components manually.
- Complex layouts sometimes require multiple tries.
- You can’t control the underlying AI model or fine-tune results.
- Data and API integration are minimal: it’s UI-first for now.
A Real Example from My Work
We tested Figma Make on an internal estimating tool for a client. The users were long-time Excel veterans, so the challenge was to create something clear and familiar without overwhelming them.
Here’s how we approached it:
- We wrote a short, simple prompt: “Dashboard with sticky top nav, search, ‘New Project’ button, summary cards, and a table.”
- We expanded it with a structured brief using a prompt generator.
- We attached style references: typography scale, colors, radii, and shadows.
- We iterated in micro-steps: collapsible sections, card vs. table comparison views, settings pages.
- We fixed visual issues by pointing at elements, sending screenshots, and using “Fix it.”
- We tested flows directly in the React app to validate usability.
- Finally, we rebuilt the approved components in Figma Design with proper auto-layout, variants, and tokens.
The result? Stakeholders were clicking through ideas in days, not weeks. The design team still owned the craft in Figma, but we were no longer starting from a blank page.
Why This Matters for Engineering Leaders
This shift isn’t just about designers saving time. It’s about aligning product, design, and engineering earlier in the process. When teams can validate ideas sooner, they reduce rework, gain clarity before heavy investment, and keep morale high by moving at the pace of conversation.
AI is not replacing design quality. It is, however, accelerating clarity so designers can spend their time on what really matters: making thoughtful, consistent, human-centered experiences.
What Worked and What Didn’t
What worked well:
- Small, focused prompts produced better results than giant ones.
- Screenshots and style tokens dramatically improved consistency.
- Point-and-Edit tweaks saved time versus regenerating full pages.
- Version restore made experimentation less risky.
What didn’t:
- Complex modals and responsive sizing often needed multiple iterations.
- Some “fixes” required very direct instructions, sometimes with screenshots.
- The lack of export into Figma meant extra work in the final stage.
Who Should Try This
Designers who want to speed up ideation and give stakeholders something real to respond to.
Product owners/analysts who need a reference before committing design resources.
Developers who want to discuss structure earlier, grounded in something clickable.
A Practical Checklist to Get Started
- Know your users. What patterns are they used to: spreadsheets, dashboards, mobile apps?
- Collect your style references. Fonts, colors, spacing, tokens.
- Start simple. A basic dashboard prompt is enough for a first draft.
- Expand gradually. Add filters, modals, or comparison views one at a time.
- Attach screenshots/files. These anchor the tool to your design language.
- Use Point & Edit. Don’t waste cycles regenerating entire pages.
- Test flows early. Validate usability before polish.
- Restore versions as needed. Exploration is safer when rollback is easy.
- Rebuild in Figma. Use AI outputs as scaffolding, not the final product.
- Check governance. Ensure your use of AI tools clears compliance and privacy standards.
Final Thoughts
AI will not replace design. What it does is shorten the time it takes to get something real in front of people. For me, the real promise lies in how tools like Figma Make reduce friction, surface new ideas, and give teams a head start.
The craft, empathy, and strategic thinking of design still matter. But with AI as a partner, we can spend less time chasing pixels in the early stages and more time delivering meaningful, human-centered experiences.