Over the past few weeks, I've been interviewing product designers to understand how they're really spending their time and what's preventing them from having a greater impact. I spoke with designers from FAANG, Fortune 500 insurance companies, MarTech platforms, and fast-growing startups. What I discovered was both validating and concerning: already burdened designers are being asked to do more than ever before, but the tools they're using aren’t fully keeping up.
Whether you buy into the ‘10x’ idea or not, it’s a useful frame: one person creating the impact of ten. What this means is, just like a 10x developer isn't shipping 10x lines of code, the 10x designer isn't shipping 10x the designs: they're delivering 10x impact across user experiences, business objectives, and their teammates' productivity.
The designers I interviewed are already pushing to be 10x performers, grabbing every AI tool they can find just to keep up. But as one lead designer told me, these tools are only getting them "20% of what they need." The other 80%? That's where the real opportunity lies, and it's what this post is about.
Based on my interviews with product designers, the typical product designer manages relationships with 2-3 product managers and supports 5-8 engineers simultaneously. At Builder, the ratio currently is 1.5 product managers and 10 developers for each product designer.
Most end up wearing every hat, from research to prototyping to pixel-polish. One FAANG product designer described his reality: "I'm usually the only designer working on multiple products. I do a lot of UXR, problem discovery, designing the wireframes, the high fidelity mockups, prototyping, and even lots past that."
Based on my recent interviews with product designers, here's where I learned many product designers spend their time:
- ~20-30% user research, synthesis, coordination, and reporting
- ~20-40% design work (includes low-fi, mid-fi, high-fi, and prototyping)
- ~35-40% meetings & stakeholder management, review cycles, feedback loops, and explanations
- ~15-33% implementation support, design QA, developer handoff, and clarifications
Yes, the sample was small and messy, but one thing stood out: most of their time drains into meetings, endless review cycles, and chasing engineers for fixes. And, each product designer interviewed said they’d prefer to spend more time on research or designing than those areas.
According to the designers I spoke with, a lot of the time they spend getting stakeholder approval up the chain and across their organization, plus their time spent on implementation support (heavy annotations, Figma prototyping, pointing out the right components in Storybook, etc.) could be reduced by creating high-fidelity, interactive prototypes that leveraged their company’s design system and code component library.
The designers I interviewed have tried many AI solutions to help them spend less time in meetings and implementation support and more time on research and design. Just a sample of solutions they tried include AI App Builders such as Lovable, v0, Figma Make, and Bolt, and many had even dabbled in full-on AI coding IDEs such as Cursor and Claude Code. While these tools accelerated certain tasks, they didn’t help designers get as far as they’d like. Here's why:
One senior designer explained that while tools like Lovable help her solve "the blank screen problem" of getting started, they only provide "20% of what I need." Another lead designer was even more critical: "It gets me 20% of what I need. But the remaining 80% is building that flow and validating it and making sure it's consistent with our design system."
As one designer warned: "If you're using AI to design, it's essentially gonna take the average of everything." This is one major reason designers are using AI to help explain their ideas and explore interactive design concepts, but still switch back to Figma to design with their existing components, tokens, and patterns.
A lead designer revealed a critical inefficiency: "I'm adding more data to a prompt when I already know visually what that will look like... Why am I doing that? That's taking more time than I need versus me already knowing how to move forward with this design." Quick iterations in Figma already happen at the speed of thought; waiting on an AI run — only to see it make random changes — slows designers down instead of speeding them up.
A Visual IDE (Integrated Development Environment) is an AI-powered design and development solution that lets designers create web app front-ends and prototypes with real, production-ready code instead of static mockups in Figma. Here’s a quick graphic showing how it’s different from pure code IDEs for developers and AI App Builders for solo hobbyists:
AI-Powered IDEs
Primary users: Developers
Interface: Code-first
Workflow: Developer workflows only
Tech stack compatibility: Any stack/framework
Common use cases:
• Full-stack development
• Complex applications
• Backend services
Example offerings: GitHub Copilot, Cursor, Claude Code
AI Visual IDEs
Primary users: Product managers, designers
Interface: Visual-first
Workflow: Cross-functional workflows
Tech stack compatibility: Any stack/framework
Common use cases:
• Frontend development
• Rapid prototyping
• Design-to-code workflows
Example offerings: Fusion, by Builder.io
AI App Builders
Primary users: Founders, solopreneurs, hobbyists
Interface: Visual-first
Workflow: Solo creator workflows
Tech stack compatibility: Restrictions on stack/framework options
Common use cases:
• MVPs
• Personal projects
• Simple greenfield web apps
Example offerings: Bolt, Lovable, Replit, v0
| AI-Powered IDEs | AI Visual IDEs | AI App Builders | |
|---|---|---|---|
Primary users | Developers | Product managers, designers | Founders, solopreneurs, hobbyists |
Interface | Code-first | Visual-first | Visual-first |
Workflow | Developer workflows only | Cross-functional workflows | Solo creator workflows |
Tech stack compatibility | Any stack/framework | Any stack/framework | Restrictions on stack/framework options |
Common use cases |
|
|
|
Example offerings | GitHub Copilot, Cursor, Claude Code | Fusion, by Builder.io | Bolt, Lovable, Replit, v0 |
Instead of creating artifacts that need heavy commenting and translation at every step, designers work directly with real components and production-ready code visually.
One designer told me about her experience using AI app builders to generate prototypes: "The sign-off process was so much quicker. Instead of showing static screens and explaining interactions, stakeholders could actually click through and experience the flow. Every project goes through a series of sign-offs with our design director and product leadership... the sign-off process was so much quicker with them."
With a Visual IDE, this cuts even more cycles because:
- Prototypes use real data and APIs: no more "imagine this pulls from our database"
- Interactions work exactly as they will in production: no surprises later
- Changes happen in real-time: adjust in the meeting, not after
- Non-technical stakeholders can contribute directly: PMs can tweak copy, adjust layouts
As another designer mentioned: "For [the developers] it just connected the dots... they were very appreciative of it. They asked, 'can we do this all the time?'"
Designers I spoke with used AI App Builders to help accelerate ideation and explain and expand upon Figma designs, but most stopped short of an entire AI-powered collaboration. They didn’t pass over the generated experience without a Figma design because the AI App Builders they used didn’t fully understand and leverage their design system.
One designer noted: "I have to prompt it pretty much every time to use the right RGB or Hex values” and another mentioned that she always paired a Figma with a prototype because the AI didn’t fully understand exactly how the components in her team’s Storybook worked like she did.
With a Visual IDE, designers can complete the entire design process because it includes your actual design system and component library, letting designers rapidly:
- Swap components instantly: try different patterns without rebuilding
- Test with data immediately: see how designs break or scale
- A/B test variations in production: not just in mockups
- Preserve all explorations: branch and compare without losing work
The traditional handoff process is broken. As one designer explained: "I spend hours annotating designs, writing specs, and then still get pulled into clarification meetings." Another mentioned spending "15-33% of my time" on implementation support, with much of that being "working with engineers, doing things like getting into a staging environment, seeing what they're building, giving feedback, making Jira tickets."
With a Visual IDE, handoff disappears. There’s nothing left to throw over the wall:
- Designers work with the same components developers use: no translation needed
- Code is production-ready from the start: developers review PRs, not rebuild from scratch
- Design tokens and spacing are automatically correct: no more "is this 8px or 12px?"
- Responsive behavior is built-in, not described in documentation
As one designer who taught himself to code explained: "The engineers can probably spend better time elsewhere [than in design review meetings] and provide better value and impact." When developers get clean, production-ready code instead of mockups, everyone wins.
Let me share a concrete example from our team at Builder. In the past two weeks, a product designer, product manager, product marketing manager, support team member, and demand generation manager have all used our Visual IDE to ship features to our product. In each case, developers reviewed a PR and shipped with nearly zero code refactoring.
Here's what this meant for our product designer:
- Design review meetings dropped from 5 to 1: stakeholders could click through the real thing
- Developer clarification time went to near zero: the code was self-documenting
- Iteration speed increased 4x: changes were made and tested in real-time
- They supported 2x more projects without working longer hours
What to learn more? Read how Builder’s teams are using Fusion today!
At Builder, our Visual IDE (Fusion) is built for enterprise workflows from the ground up. We can show you how to:
- Import your existing design system and component library
- Set up your team's workflow in minutes
- Ship your first production feature in hours, not weeks
Our designers already ship production features this way. Try Fusion and see how much faster your own ratios flip, or reach out for a personalized demo.
Builder.io visually edits code, uses your design system, and sends pull requests.
Builder.io visually edits code, uses your design system, and sends pull requests.
Connect a Repo
