Yah, fair. To be upfront, I didn’t run all 11 against the same repo. The post is an editorial comparison based on documented capabilities and practical concerns, not a benchmark, so treat the ratings as my judgment.
Here’s how the ones you listed shake out for client work:
Figma MCP Server + Cursor or Claude Code: my default when a client has approved Figma designs and an existing codebase. The MCP server only supplies structured design context (layers, components, variables). The agent still writes the code, so you need clear rules and diff review. But it keeps the work inside the client’s real components instead of spawning new button variants.
Cursor vs Claude Code: I rated them equally, and the difference is mostly workflow. Cursor is editor-centered, so you steer inline. Claude Code is terminal-centered and suits multi-step tasks you can specify up front. Try both on the same small task in your own repo. (Claude helped edit the post, and Anthropic makes Claude Code, which is why I put the disclosure in.)
v0: the one I’d reach for when there’s a brief but no finished design. It gets you to editable, polished React UI quickly. Name your custom components and tokens in the prompt, or it will invent its own, and expect to add edge cases and error states.
Lovable and Bolt.new: great for MVPs and getting early client feedback, but not what I’d trust as the final deliverable. Bolt.new is awkward when the client already has a repo, hosting, and database. With Lovable, review the backend access rules (like row-level security) before anything real touches it, because an app can look fine while exposing data.
So the shortlist that holds up best for real client projects is the Figma MCP Server with a coding agent for existing codebases, v0 for prompt-driven UI, and Lovable or Bolt.new for functional MVPs. Whichever you pick, run the same pre-handoff checks: visual comparison, responsive testing, functional checks, accessibility, and code review.
If you’ve run any of these on a client repo, I’d like to hear what broke first. That’s the part a docs-based comparison can’t tell you.
Agreed. The real test is whether the tool fits into the client’s existing workflow without creating more cleanup than it saves. The Figma MCP plus a coding agent seems the most practical starting point when the design system and codebase are already established. Have you tried it on a production project yet?
Right, and that’s the part the tooling can’t fix for you. The MCP server reads whatever Figma says today, so if the file has drifted from the codebase, the agent will faithfully build the drift. Speed just makes the mismatch show up sooner.
What helps in practice:
Treat the codebase as the source of truth for components. Map Figma components to real code components up front (Figma’s Code Connect is built for this), so the agent reuses <Button> instead of generating a new one.
Keep the token names identical on both sides. If Figma calls it color/primary/500 and the repo calls it --brand-main, the agent will guess.
Put the rules in the repo, in a CLAUDE.md or Cursor rules file: which components to reuse, where tokens live, what never to hand-code.
Review the diff for new components. A new variant appearing is usually the first sign of drift.
Honestly, that’s less a tooling problem than a design-dev sync problem, and the agent just makes it more visible.
The first draft is only half the test. A tool might generate a great-looking screen, but the real test is how easily it handles the client's next five changes without breaking the structure or creating more cleanup
Absolutely! The first draft is just the starting point. Real value shows up when you can handle client feedback and make repeated changes without breaking the structure or spending hours cleaning things up. That’s where these tools really prove themselves.
Funny, still all of them need some level of developer experience to make use of? Would also be interesting to see how much each 1 cost in the end (token wise). Generally speaking, structured outputs cost less than screenshots, but VLMs got cheaper, so who knows if that's still true? Also, token for token is generally the more interesting battle, sure 10b token budget produces better quality than 10m, but is the price worth it? Also worth noting, what model is being used for it, you'd get vastly different results using Gemini Flash vs Sonnet, vs Qwen Flash and GPT.
Fair points, and you’re right on the first one. Figma Make, Stitch and Banani are approachable for designers, but getting anything to production still takes someone who can read and fix the code. The post says as much, but it’s worth stating plainly: none of these remove the developer, they change where the developer’s time goes.
On cost, I don’t have measured numbers, and I didn’t want to publish guesses. I left prices out because they go stale, but token cost is a different and better question than sticker price. Your structured-vs-screenshot point is the right one to test. Structured context like the Figma MCP output should be cheaper and more precise than a screenshot, but cheaper VLMs may have narrowed that gap, and I haven’t measured it. I’d rather say that than repeat a rule of thumb that may be out of date.
Model choice is a real gap too. The post compares tools, but several of them (Cursor, Claude Code, and others) let you pick the model, and results will differ a lot between a small fast model and a frontier one. A tool-vs-tool comparison without a fixed model hides that variable.
A fairer follow-up would run the same task, say a pricing page in an existing React repo, with a fixed model across tools, then log:
Tokens in and out, comparing structured Figma context against a screenshot
Number of iterations to an acceptable result
Cleanup time and how many diffs got rejected
Then repeat it with different models on the same tool, to see whether paying more per token is worth it for fewer retries.
If you’ve got rough numbers from your own runs, I’d like to see them. I’ll put the results in a follow-up and credit anyone who contributes data.
Good summary and gameplan for a more in-depth test. Currently I'm quite swamped with projects, so I dont think I'll be able to contribute, most of my work, I run in parallel and on token plans that convert to credits, so the values will be inaccurate due to not having a clear token count.
What I meant by funny that they still need developer experience, is actually something I'm quite curious about. People say that LLMs get 90% of the work done, in 10% of the time, but the last 10% takes 90% of your time. As a broad statement, probably somewhat true, but unquantifiable, given all the variables. But the thing that bothers me, is that they still require a developer. None of them are user-friendly enough to actually allow someone whose non-technical to create an app, without being asked atleast a few questions they have absolutely no way of knowing the answer to? Even if it's only 90%, it's enough to get a POC working and test whether it's worth hiring a developer to finish it up? But no, they prefer making to too technical, while great for developers, makes it completely inaccessible to non-techs.
Totally understand, and no pressure. Token plans converting to credits make clean numbers hard anyway, and that’s a useful data point in itself: the pricing is opaque enough that even heavy users can’t easily say what a task cost.
On the developer point, I mostly agree, with one nuance. The POC use case is what Lovable, Bolt.new and Figma Make are best at. A non-technical founder can get a working prototype in front of users without a developer, and that’s often enough to test whether the idea is worth building. Where it breaks is what you’re describing: the tools ask or assume things like auth, database setup, hosting and data rules, and a non-technical person has no basis to answer them. Worse, the tool often won’t ask at all. It just picks defaults, and the app looks finished while the access rules underneath are wide open. That’s the real gap. It’s less “too technical” and more that the tools don’t know what the user doesn’t know, so the risks stay invisible until someone who can read the code looks.
So I’d say the 90% is real for a POC, but a non-technical user needs two things the tools mostly don’t provide yet: plain-language questions (“should people see each other’s data?”) instead of technical ones, and a built-in review step that flags security and data issues before anything real touches the app.
Your take is probably the bigger story than my comparison. Whoever makes the last 10% approachable for non-developers will win that segment. Do you think that’s a tooling problem, or does it need a different kind of product, like a guided builder that interviews you first?
Given my brainchild from last night. It's definitely a tooling flaw. So I was experimenting with a closed-loop rule-engine. Essentially, everytime the LLM makes a mistake, it appends a rule. It doesnt check the rules, or run the rules, they're run for it, so it essentially intercepts the stream, so a flawed call (eg. a write before read) gets trashed and sent back in less than a millisecond, so it can fix the output, before it even gets to the tool server. which is essentially rule-driven middleware, that prevents errors before they ever hit your screen.
I've been running a test on it, I wired it and told the LLM to build a game engine in rust. It's been building it and appended around 156 rules and the rules have an overall hit-rate of 86.7% (the other 12.3% are new types that get appended at end of turn). So it's progressively learning and from just watching it, it's doing MUCH better now. I used the lowest tier model I could get, specifically because it will make mistakes, so the rule engine can show it's worth.
To get from 90% to 100%, is just a matter of rules. If I gave you a codebase and a year to get it from 90% to 100%, you'll be able to write me massive list of requirements, generally speaking, those are scoped requirements that are generic enough that they're useful in various scenarios. So with enough data (lets say 1k developers, working for 3 months worth of recursive looping), the rule engine will be able to push that 90% to 98% atleast. With only small edges that are hyper niche.
So I definitely think that it's a matter of DoD (definition of done) and what makes the product whole. Those are rules.
This is a neat idea, and it lines up with the main thing I took from writing the post. The tool mattered less than the rules around it. The CLAUDE.md or Cursor rules file I mention is advisory: the model reads it and may or may not follow it. You’re moving enforcement out of the model and into middleware, which is a different and stronger guarantee. A write-before-read is also a good first target, because it’s deterministic and cheap to check.
I haven’t built anything like this, so take the rest as questions rather than corrections:
What does the 86.7% hit rate measure? Is it the share of flawed calls the rules caught, or the share of all calls that matched a rule? Those tell very different stories. (I’m guessing the remainder is 13.3%, not 12.3%.)
How do you stop the rule set from rotting? At 156 rules, some will overlap or conflict, and a rule that’s too broad will bounce valid calls and cost you speed. Do you track false positives, or retire rules that stop firing?
Do the rules transfer to stronger models? Using the cheapest model to force mistakes is a smart way to stress-test it. But I’d want to know which rules a better model never needed, and which ones still catch it.
I’m also less sure about the 90% to 98% extrapolation. Rules like “read before write” are syntactic, so they scale well. A definition of done is closer to “does this match the approved design, reuse the right components, and pass the tests.” That’s semantic and mostly depends on the project, so I’d expect it to need project-level rules plus real verification (tests, visual diffs) rather than a generic library. The generic layer could still get you a long way, and I’d love to see the numbers.
Is the engine open source, or are you writing it up somewhere? If you do, I’d like to read the rule categories and what the misses looked like.
The grouping by starting point is what makes this useful. A converter and an app builder solve different problems, so ranking them head to head wouldn’t have worked.
One thing I’d add to the pre-handoff checklist is performance and SEO basics. AI-generated frontends often look right but have problems that only show up in Lighthouse or Search Console:
Semantic HTML: a wall of <div>s instead of <header>, <nav>, <main> and proper heading order
Images: no width/height or lazy loading, and oversized files that hurt LCP and cause layout shift
Fonts and scripts: heavy web fonts or unused libraries pulled in by default
Metadata: missing or duplicated titles, meta descriptions and alt text
A quick Lighthouse run at mobile width catches most of it before the client sees it. It also pairs well with the accessibility checks you already list, since semantic markup helps both.
Have you noticed any of these tools producing cleaner markup than the others, or does it come down to the rules you give the agent?
Putting a converter and an app builder in one ranking would have been misleading.
Your checklist additions are good, and I’m adding them to my handoff list. Semantic HTML and image dimensions are the two I see missed most. Layout shift from images without width/height is something clients notice before they can say what’s wrong. A Lighthouse run at mobile width is a cheap final gate, and it overlaps nicely with accessibility, since proper landmarks and heading order help screen readers and crawlers alike.
On your question: in my experience it’s mostly the rules you give the agent. Some tools default to cleaner output than others, but the gap closes quickly once you state the requirements up front: semantic landmarks, one H1 with ordered headings, explicit image dimensions, lazy loading below the fold, no unused libraries, and unique titles and meta descriptions per page. Without those rules, every tool I tried drifted toward div-heavy markup on longer pages. I’d treat default cleanliness as a tiebreaker, not a selection criterion.
Do you keep a standard rules file you drop into these tools, or do you fix things after the fact?
Bookmarked. The table at the end (“if your priority is...”) is what I’ll actually come back to, since it saves the usual hour of tab-hopping between tools.
The Cursor vs Claude Code section was refreshingly honest too. Most posts pick a winner and call it a day, but “try both on the same small task in your own repo” is the only advice that really holds up.
My own rule of thumb: prototype in Figma Make or v0, then do the real implementation with an agent inside the repo. The prototype is for getting the client to say yes, not for shipping.
Glad the “if your priority is...” table is useful. It was written for exactly that “I don’t have an hour to tab-hop” moment.
Your rule of thumb matches how I use these tools. A prototype from Figma Make or v0 exists to get a yes from the client, and the real build happens in the repo, where the agent can see the actual components, tokens, and tests. The risky moment is when a client sees a polished prototype and assumes it’s nearly done. I now tell them up front that the prototype is for deciding, not for deploying. That one sentence saves a lot of awkward timeline conversations later.
One thing I’d add: once the client signs off, I treat the prototype as a reference and rebuild from it rather than copying the code in. Carrying prototype code into production is usually where the cleanup I mentioned in the post starts.
Do you keep any of the prototype code when you move to the repo, or do you start fresh and use it only as a visual spec?
Sidra Jefferi, Marketing Director, uses her knowledge of corporate actions and global markets to help improve reliable internet access in rural and underserved areas.
Grouping by starting point makes the comparison easier to use. One thing I noticed is that the scorecard has no column for output quality at the markup level, even though the pre-handoff checklist covers accessibility.
With design-to-code tools, my guess is that the Figma file’s structure decides a lot. Frames built with auto layout and named layers should translate into flex/grid and sensible components. Frames positioned by hand risk absolute positioning and nested divs that look right at one width and break at another. Semantics are a similar concern: a Figma “button” has no idea whether it should be a <button>, an <a>, or a div with a click handler.
Did you see this difference between tools, or between well-structured and messy files? I’d be curious whether the Figma MCP + agent route handled semantic elements and keyboard behavior better than the converters, or whether they all needed the same manual pass. An accessibility or semantic-markup column in a follow-up would be a useful addition to the scorecard.
Fair catch. The scorecard’s “design fidelity” only measures how the output looks, so it can’t tell you whether the markup underneath is any good. The checklist covers accessibility, but the scorecard doesn’t, and that’s a gap.
I haven’t run a controlled test of clean vs. messy Figma files across these tools, so I can’t give you measured differences. Your hypothesis matches what I’d expect, though:
File structure drives a lot. Auto layout and named layers give any tool, converter or agent, something meaningful to map to flex/grid and components. Hand-positioned frames push you toward absolute positioning and nested wrappers that look right at one width and break at another.
Semantics are the harder problem. A Figma “button” has no role attached. Converters have to guess from layer names and shapes, so I’d expect them to produce a lot of divs with click handlers.
The MCP + agent route has an advantage, but not an automatic one. The MCP server supplies layers, components, and variables, not semantic intent. The agent decides whether something is a <button>, <a>, or div, so the result depends on your rules. If the repo has real components (a that renders a native button) and your CLAUDE.md or Cursor rules say “use native elements, never click handlers on divs,” I’d expect much better output than a converter’s. Without those rules, I’d expect it to guess too.
Keyboard behavior needs testing either way. Focus order, focus states, and menu or dialog behavior aren’t in the design file, so I wouldn’t trust any tool to get them right without a manual pass.
I’d love to add an accessibility/semantic-markup column in a follow-up. My plan is to run one clean (auto layout, named layers) and one messy file through a few of these tools. I’d then compare element choices, a tab-through of the keyboard behavior, and an automated audit like axe or Lighthouse, plus the manual pass those tools can’t replace. If you’ve seen the clean-vs-messy difference yourself, I’d like to hear what broke first.
The 'cleanup cost' framing is the right way to buy these tools — fidelity to pixels is easy to demo, but whether the output reuses your components, consumes your design tokens, and survives a handoff is what determines if it paid for itself. One practical filter I use: run every candidate on the same representative page (form-heavy, responsive, backed by an existing component library) before comparing, because most vendors optimize for their showcase, not your codebase.
Exactly, and that’s the gap in my post. The ratings come from documented capabilities, not from running every tool on one codebase, so vendor showcase bias is something I couldn’t rule out. Your filter is the right fix.
If I do a follow-up, I’d use that kind of page: form-heavy, responsive, backed by a real component library. I’d score each tool on:
Component reuse: how many existing components it used versus new variants it invented.
Token usage: whether it used the design tokens or hard-coded values.
Time to mergeable: how long it took to get the diff reviewable, including rejected changes.
Forms are a good stress test because validation, error states, and accessibility are where generated output usually falls apart. Those problems don’t show up in a screenshot demo.
What would you put on that test page beyond forms? I’m wondering whether something like a data table or a modal flow would catch problems that a form wouldn’t.
Useful comparison. One thing I always look for with design to code tools is not the first generated screen, but how maintainable the output is after a few weeks of real development. Things like component structure, responsiveness, naming consistency, and how easy it is to integrate into an existing codebase usually matter more than pixel perfect generation. For a marketplace like Transferise, where booking flows and integrations evolve constantly, clean code and editability end up being the deciding factors. Which of the tools felt strongest when you had to make significant changes after generation?
Your criteria (editability, structure, how it fits an existing codebase, and what happens weeks in) apply to scrapers too. It’s the same idea as the “still works in week two” point in this post. One note: this article compares AI web scrapers, not design-to-code tools, so I think this comment may have been meant for the design-to-code comparison.
For scrapers, the equivalent of “clean, editable output” is how easy it is to change the extraction logic after the first run. I haven’t stress-tested this post’s tools by making big changes after setup. It’s an editorial comparison based on documented capabilities, so treat the following as my expectation, not a measured result.
Most editable: Crawl4AI. A CSS/JSON extraction schema is plain, readable code that lives in your repo. You can diff it, review it and change it when a layout changes, and its Markdown output drops into an existing pipeline easily.
Close behind: Firecrawl. Schema-based extraction with Pydantic models is easy to version and adjust, and the SDKs are simple to wire into existing code.
Hardest to change: the no-code tools. Robots and templates live inside the vendor’s UI, so a redesign usually means retraining by hand, and exporting your setup is difficult.
For a marketplace like Transferise, where flows and integrations keep changing, I’d pick tools where the logic is code you own, plus a validation layer and per-run field-completeness tracking. That makes changes cheap and breakage obvious.
Mayur Upadhyay delivers tech-driven solutions in Web Development, e-commerce development, and mobile app development, helping businesses to grow worldwide.
Grouping the tools by starting point (Figma file, prompt, full app, existing repo) makes more sense than ranking them head-to-head, since they solve different problems.
The point about the Figma MCP Server supplying context while the agent writes the code is the one I think most people miss. The output quality depends heavily on component rules and project conventions, so the tool matters less than the setup around it.
I also appreciated the warning about Lovable and Bolt.new MVPs. Generated apps can look finished while the auth and data-access rules are still unreviewed.
Curious how others handle this: when a client already has a design system, are you getting better results from Builder.io’s component mapping or from an MCP + agent workflow?
On the grouping: ranking head-to-head kept falling apart because Figma-to-code tools and prompt-to-app tools aren’t really competing. Starting from the input a client actually has made the choice much clearer.
You’re right on the MCP point. In my projects the tool itself mattered less than the setup around it. Once the component rules, naming conventions, and token usage were written down where the agent could read them, results improved far more than from switching tools.
And yes, the Lovable and Bolt.new warning came from experience. A generated MVP can look done while auth flows and data-access rules are still unreviewed, so I treat that review as a separate, non-negotiable step before anything goes in front of users.
On your question, my honest take is that it depends on how disciplined the design system is. When a client’s system is clean (consistent tokens, well-named components, a maintained library), Builder.io’s component mapping gives more predictable output with less setup. When the system is messier or the codebase has its own conventions, MCP plus an agent has worked better for me, because I can encode those rules explicitly and iterate on them. The trade-off is that MCP needs more upfront investment in the rules.
Curious what you’re seeing: are your clients’ design systems mostly well maintained, or do you find yourself cleaning them up first?
The scorecard is what stood out for me. Most roundups just say a tool is “great”, but rating each one on fidelity, code integration, and developer control makes it clear why converters and app builders can’t be compared directly.
I also liked that you said the ratings are editorial judgment and not benchmark results. That honesty makes the rest of the post more credible, and it’s rare in tool comparisons.
The Lovable section was a good reminder too. A generated app can look finished while the row-level security rules are still wrong, so reviewing the backend before handoff is essential.
One question: If a client has Figma designs but no component library yet, would you run Anima or Builder.io first and then move to Cursor or Claude Code, or go straight to the agent?
Good question. Without a component library, I’d go straight to the agent and skip Builder.io. Visual Copilot’s value is mapping designs to components you already have, so with no library there’s nothing to map to.
Anima: it can be a useful first pass if you have many mostly static pages and want quick markup and a rough responsive layout. The catch is that the output tends to be page-shaped rather than component-shaped, so you’d likely end up asking the agent to pull repeated elements out into shared components anyway. That can cost as much as building them cleanly from the start.
Agent first: this is the order I’d try.
Build the foundation before any pages. Have the agent create the design tokens (colors, spacing, type) and a small set of primitives (Button, Input, Card, and so on) from the Figma file through the MCP server. Review that set carefully, because everything after it inherits those choices.
Write the rules down. Put the new components and token names in your CLAUDE.md or Cursor rules file. After that, “reuse these, don’t create new variants” is an instruction the agent can follow.
Then build the pages on top of that foundation, one at a time, checking the diff for any new one-off components.
A cleanly structured Figma file with real components and variables already gives you most of a library. If the file is just loose frames and detached layers, I’d tidy it up first, since the agent will faithfully reproduce the mess.
Anima’s only real advantage here is speed on a first draft, which I’d weigh against the refactoring afterwards. This is my editorial take rather than a tested result, so if you’ve compared both routes on a real project, I’d like to hear how it went.
Levine Mundro has over 30 years of experience in sales and marketing. He focuses on driving growth, building client relationships, and shaping leadership strategy.
What I liked most is that the post doesn’t pretend one tool wins everywhere. Splitting the 11 tools into Figma-to-code, prompt-based UI, app builders, and coding agents matches how client work actually starts, so the shortlist table is easy to act on.
The Cursor vs Claude Code section was refreshingly practical. Calling the difference mostly a matter of workflow, editor-centered versus terminal-centered, and suggesting people test both on the same small task in their own repo is better advice than declaring a winner.
I also appreciate the disclosure about the post being edited with help from Claude. It’s a small detail, but it adds trust, especially in a space where so many comparisons are quietly sponsored.
The pricing section is smart as well. Leaving out numbers that will be stale in a month and explaining the patterns instead, like credit-based app builders burning through allowances during heavy iteration, will stay useful longer than a price table.
The split into categories was the part I fought with most. Early drafts had a single ranked list, and it fell apart the moment I tried to use it on real projects. A Figma-heavy client and a “we have an idea and a weekend” client need completely different tools, so grouping by how the work starts felt more honest than crowning a winner.
On Cursor vs Claude Code, I’m glad the “test both on the same small task” advice landed. Feature lists only go so far, and a tool either fits how you think or it doesn’t. Ten minutes in your own repo will tell you more than any comparison, mine included.
The disclosure was an easy call. I used Claude to help with editing, and if I’m asking readers to trust my judgment on tools, I should be upfront about how I use them too.
And you’re right about pricing. I didn’t want the post to be wrong a month from now, so I focused on the patterns, like credit burn during heavy iteration, since those tend to outlast the exact numbers.
Thanks again for taking the time to write this. If you try any of these on a client project, I’d love to hear what worked for you.
Full-stack developer and tech writer who enjoys making complex ideas simple. I write about web development, system design, and practical coding techniques to help developers improve more quickly.
I like that the post starts from what the client actually needs and not from a list of trendy tools. The “closest to the required result without creating more cleanup than it saves” test is a better way to judge any AI tool than counting how much code it generates.
The Cursor vs Claude Code section was refreshingly practical. Calling it a workflow difference (editor-centered vs terminal-centered) instead of declaring a winner is more honest, and the disclosure note adds to that trust.
The “What to check before handing code to a client” section is the part I’d share with junior developers. Checking responsive behavior at narrow widths and testing loading and error states catches the problems that screenshots hide.
Pricing is the one area where I’d love a follow-up, since credit-based app builders can get expensive after a few rounds of revisions. Even a rough note on how many iterations a typical client project needs would help agencies plan budgets.
The “closest to the required result without creating more cleanup than it saves” test came straight from client work. Early on I kept getting impressed by how much code a tool could generate, then losing hours trimming it back into something I could actually hand over. Judging by cleanup cost changed how I evaluated everything.
I’m glad the Cursor vs Claude Code section landed the way I meant it. Both are strong, and the right pick depends on whether you think best in an editor or a terminal, so a winner would have been misleading. The disclosure note was there for the same reason: you should know where I’m coming from when you weigh my opinions.
Sharing the pre-handoff checklist with juniors would make me happy. Narrow-width responsive checks and loading/error states are exactly what polished screenshots hide, and clients tend to find those problems on their own devices a week later.
Pricing is a fair gap, and a follow-up is a good idea. From my own projects, a typical client build took a handful of revision rounds, and credit-based builders got expensive when feedback came in vague or late. I’ll try to put together a rough iteration range and budgeting guide for agencies, so keep an eye out for it. If you’ve seen costs balloon on your own projects, I’d love to hear what drove it.
Grouping the tools by starting point instead of ranking all 11 together is the right call. Most comparison posts compare Figma-to-code converters against app builders, which doesn’t make sense.
I also liked that you said the scorecard is editorial judgment, not benchmarked. The “n/a” for design fidelity on the prompt-based tools is honest too, since they don’t start from an approved design.
The Figma MCP Server plus a coding agent looks strongest on paper, but the post says the result depends on the context and instructions you give the agent. So here’s my question: what do you put in your project rules or instruction file to stop the agent from inventing new button or input variants when you already have a component library? Is it a list of components, token names, or explicit “never create new components” rules?
Also curious whether you’ve seen Visual Copilot’s component mapping pay off on a messy codebase, or whether it really needs a clean design system first. Thanks for the pre-handoff checklist at the end, it’s the part I’d bookmark.
Thanks, Jennifer. On your first question, the short answer is all three, but each does a different job.
A component inventory, not just a prohibition. A bare “never create new components” rule gets ignored or causes odd workarounds, because the agent doesn’t know what already exists. I list the components with import paths and one line on when to use each, for example Button (variants: primary, secondary, ghost) from @/components/ui/button. Pointing it at the Storybook or the components/ui folder works too.
Token rules. I say where tokens live and ban raw values in components: no hex colors, no arbitrary px or Tailwind [...]values, use the spacing and color tokens only. Token names need to match between Figma and the repo, or the agent guesses.
A “when nothing fits” rule. This is the one that stops variant sprawl: “If no existing component fits, don’t create one. Say so and propose the closest match or the prop change needed.” Giving it a way out stops it from inventing something to finish the task. New variants should be added as props on the existing component, not as parallel components.
Two things back the rules up. Code Connect mappings are stronger than prose rules because the agent gets the real component, and I review every diff for new files in the components folder, since that’s where drift shows up first.
On Visual Copilot, I should be upfront: I haven’t pushed its mapping hard on a messy codebase. My read from the docs is that it depends on clean, consistent mappings, so I’d expect it to struggle where naming is inconsistent. In the messy cases I’ve worked on, MCP plus an agent was easier to fix, because I could keep tightening the rules after each bad diff. If you’ve tested Visual Copilot on a messy repo, I’d like to hear how it went.
The “which tool” question gets easier once you ask what the deliverable is. I’ve seen teams burn a week on a Figma-to-code converter, then rebuild half of it because the output ignored their existing components. The point about mapping to a design system first, before picking a tool, is the part most people skip.
One thing I’d add to the pre-handoff checklist is a visual regression check against the approved design, like screenshot diffs at a few breakpoints. Eyeballing spacing and typography is where AI-generated UI quietly drifts.
Also, the “prototype for sign-off” vs “code for production” split deserves more attention. Clients often see a polished Figma Make or Lovable demo and assume it’s nearly done, so setting that expectation early saves a lot of pain.
You’ve nailed the failure mode I see most often. Teams pick a tool first, then discover the output ignores their component library and end up rebuilding half of it. Mapping to the design system up front saves far more time than any tool’s generation speed.
Visual regression checks are a great addition to the pre-handoff checklist. Screenshot diffs at a few breakpoints (say mobile, tablet, desktop) catch the quiet drift in spacing, font weights and line heights that eyeballing misses. Tools like Playwright snapshots, Chromatic or Percy make this fairly cheap to set up, so I’ll add it to the checklist.
You’re also right about prototype-for-sign-off versus code-for-production. A polished Figma Make or Lovable demo makes clients assume the work is almost finished, when the real work of accessibility, state handling, edge cases and integration is still ahead. Setting that expectation at kickoff, and labeling demos clearly as prototypes, avoids a lot of painful conversations later.
Appreciate you adding these. Would love to hear what’s worked for your team on the regression side!
I like that you flagged the ratings as editorial judgment. That said, I’d love to see this follow-up: run the same small task, say a pricing page in an existing React repo, through two or three of these and compare the actual cleanup time. Scorecards like “High / Medium / Low” are useful for shortlisting, but the real cost shows up in how many diffs you reject.
I’d also push back slightly on lumping Bolt.new and Lovable together. In my experience they differ a lot once you need to export and keep working in your own repo, and that’s where most client projects end up.
Pricing is the other gap. I understand why you skipped it, but credit-based tools can get expensive fast when a client keeps asking for revisions, so even a rough “what burns credits” note would help freelancers quoting projects.
Thanks for the thoughtful feedback, and glad the editorial-judgment note was useful.
You’re right about the scorecards. High/Medium/Low is good for shortlisting, but it can’t show the real cost, which is how much of the output you end up rejecting or rewriting. A pricing page in an existing React repo is a good test because it forces the tool to deal with your components, styling conventions, and file structure instead of starting from a blank slate. I’m planning a follow-up along those lines, tracking cleanup time and rejected diffs across a few tools.
Fair point on Bolt.new and Lovable too. They look similar in a feature table, but export and repo handoff is where they diverge, and that matters most for client work you need to keep maintaining. I’ll break them out and compare that workflow directly.
On pricing, I skipped it because plans change so often, but a “what burns credits” note is a good middle ground. Revision-heavy client work is exactly where credit-based tools get painful, so I’ll add a section on what drives usage and how to pad a quote for it.
If you’ve run Bolt or Lovable on a real client project, I’d love to hear what the export and handoff experience looked like. And thanks for the bookmark!
Grouping the tools by starting point (Figma file, prompt, existing repo) instead of ranking them head to head is the right call, because a converter and an app builder solve different problems.
The point about Lovable and Bolt.new needing a backend review stands out. Generated apps can look finished while the data-access rules are wide open, so checking auth and row-level security before handoff matters as much as visual fidelity.
I also like that the scorecard is labeled as editorial judgment, not benchmark results. One thing I’d be curious about: has anyone run the Figma MCP + Cursor/Claude Code setup on a repo with a messy or undocumented component library? I’d expect the results to depend heavily on how well the components are named and documented.
Thanks, this is exactly how I think about it. A converter and an app builder solve different problems, so ranking them head to head would have been misleading.
You’re right about the backend review. Lovable and Bolt.new can produce something that looks finished while the auth and row-level security rules are still wide open. I now treat that check as part of handoff, not an optional extra.
On Figma MCP with Cursor or Claude Code on a messy component library: I haven’t pushed it that far, so I can only share my expectation, which matches yours. The output seems to depend on how well components are named, documented, and mapped to Figma. With inconsistent naming, I’d expect it to generate near-duplicates instead of reusing what exists. Adding a short component inventory or rules file to the repo before running it would probably help a lot.
If anyone has tried this on a legacy codebase, I’d love to hear how it went. I’d happily fold it into a follow-up.
We're a place where coders share, stay up-to-date and grow their careers.
11 tools compared is a lot of patience. which one actually survived client work?
Yah, fair. To be upfront, I didn’t run all 11 against the same repo. The post is an editorial comparison based on documented capabilities and practical concerns, not a benchmark, so treat the ratings as my judgment.
Here’s how the ones you listed shake out for client work:
So the shortlist that holds up best for real client projects is the Figma MCP Server with a coding agent for existing codebases, v0 for prompt-driven UI, and Lovable or Bolt.new for functional MVPs. Whichever you pick, run the same pre-handoff checks: visual comparison, responsive testing, functional checks, accessibility, and code review.
If you’ve run any of these on a client repo, I’d like to hear what broke first. That’s the part a docs-based comparison can’t tell you.
that disclosure helps. the Figma MCP plus agent combo is the only part that sounds like it survives a real codebase.
Agreed. The real test is whether the tool fits into the client’s existing workflow without creating more cleanup than it saves. The Figma MCP plus a coding agent seems the most practical starting point when the design system and codebase are already established. Have you tried it on a production project yet?
The cleanup test is the whole thing. If the Figma side drifts from the codebase, the agent just ships the drift faster.
Right, and that’s the part the tooling can’t fix for you. The MCP server reads whatever Figma says today, so if the file has drifted from the codebase, the agent will faithfully build the drift. Speed just makes the mismatch show up sooner.
What helps in practice:
<Button>instead of generating a new one.color/primary/500and the repo calls it--brand-main, the agent will guess.Honestly, that’s less a tooling problem than a design-dev sync problem, and the agent just makes it more visible.
The first draft is only half the test. A tool might generate a great-looking screen, but the real test is how easily it handles the client's next five changes without breaking the structure or creating more cleanup
Absolutely! The first draft is just the starting point. Real value shows up when you can handle client feedback and make repeated changes without breaking the structure or spending hours cleaning things up. That’s where these tools really prove themselves.
Funny, still all of them need some level of developer experience to make use of? Would also be interesting to see how much each 1 cost in the end (token wise). Generally speaking, structured outputs cost less than screenshots, but VLMs got cheaper, so who knows if that's still true? Also, token for token is generally the more interesting battle, sure 10b token budget produces better quality than 10m, but is the price worth it? Also worth noting, what model is being used for it, you'd get vastly different results using Gemini Flash vs Sonnet, vs Qwen Flash and GPT.
Fair points, and you’re right on the first one. Figma Make, Stitch and Banani are approachable for designers, but getting anything to production still takes someone who can read and fix the code. The post says as much, but it’s worth stating plainly: none of these remove the developer, they change where the developer’s time goes.
On cost, I don’t have measured numbers, and I didn’t want to publish guesses. I left prices out because they go stale, but token cost is a different and better question than sticker price. Your structured-vs-screenshot point is the right one to test. Structured context like the Figma MCP output should be cheaper and more precise than a screenshot, but cheaper VLMs may have narrowed that gap, and I haven’t measured it. I’d rather say that than repeat a rule of thumb that may be out of date.
Model choice is a real gap too. The post compares tools, but several of them (Cursor, Claude Code, and others) let you pick the model, and results will differ a lot between a small fast model and a frontier one. A tool-vs-tool comparison without a fixed model hides that variable.
A fairer follow-up would run the same task, say a pricing page in an existing React repo, with a fixed model across tools, then log:
Then repeat it with different models on the same tool, to see whether paying more per token is worth it for fewer retries.
If you’ve got rough numbers from your own runs, I’d like to see them. I’ll put the results in a follow-up and credit anyone who contributes data.
Good summary and gameplan for a more in-depth test. Currently I'm quite swamped with projects, so I dont think I'll be able to contribute, most of my work, I run in parallel and on token plans that convert to credits, so the values will be inaccurate due to not having a clear token count.
What I meant by funny that they still need developer experience, is actually something I'm quite curious about. People say that LLMs get 90% of the work done, in 10% of the time, but the last 10% takes 90% of your time. As a broad statement, probably somewhat true, but unquantifiable, given all the variables. But the thing that bothers me, is that they still require a developer. None of them are user-friendly enough to actually allow someone whose non-technical to create an app, without being asked atleast a few questions they have absolutely no way of knowing the answer to? Even if it's only 90%, it's enough to get a POC working and test whether it's worth hiring a developer to finish it up? But no, they prefer making to too technical, while great for developers, makes it completely inaccessible to non-techs.
Totally understand, and no pressure. Token plans converting to credits make clean numbers hard anyway, and that’s a useful data point in itself: the pricing is opaque enough that even heavy users can’t easily say what a task cost.
On the developer point, I mostly agree, with one nuance. The POC use case is what Lovable, Bolt.new and Figma Make are best at. A non-technical founder can get a working prototype in front of users without a developer, and that’s often enough to test whether the idea is worth building. Where it breaks is what you’re describing: the tools ask or assume things like auth, database setup, hosting and data rules, and a non-technical person has no basis to answer them. Worse, the tool often won’t ask at all. It just picks defaults, and the app looks finished while the access rules underneath are wide open. That’s the real gap. It’s less “too technical” and more that the tools don’t know what the user doesn’t know, so the risks stay invisible until someone who can read the code looks.
So I’d say the 90% is real for a POC, but a non-technical user needs two things the tools mostly don’t provide yet: plain-language questions (“should people see each other’s data?”) instead of technical ones, and a built-in review step that flags security and data issues before anything real touches the app.
Your take is probably the bigger story than my comparison. Whoever makes the last 10% approachable for non-developers will win that segment. Do you think that’s a tooling problem, or does it need a different kind of product, like a guided builder that interviews you first?
Given my brainchild from last night. It's definitely a tooling flaw. So I was experimenting with a closed-loop rule-engine. Essentially, everytime the LLM makes a mistake, it appends a rule. It doesnt check the rules, or run the rules, they're run for it, so it essentially intercepts the stream, so a flawed call (eg. a write before read) gets trashed and sent back in less than a millisecond, so it can fix the output, before it even gets to the tool server. which is essentially rule-driven middleware, that prevents errors before they ever hit your screen.
I've been running a test on it, I wired it and told the LLM to build a game engine in rust. It's been building it and appended around 156 rules and the rules have an overall hit-rate of 86.7% (the other 12.3% are new types that get appended at end of turn). So it's progressively learning and from just watching it, it's doing MUCH better now. I used the lowest tier model I could get, specifically because it will make mistakes, so the rule engine can show it's worth.
To get from 90% to 100%, is just a matter of rules. If I gave you a codebase and a year to get it from 90% to 100%, you'll be able to write me massive list of requirements, generally speaking, those are scoped requirements that are generic enough that they're useful in various scenarios. So with enough data (lets say 1k developers, working for 3 months worth of recursive looping), the rule engine will be able to push that 90% to 98% atleast. With only small edges that are hyper niche.
So I definitely think that it's a matter of DoD (definition of done) and what makes the product whole. Those are rules.
This is a neat idea, and it lines up with the main thing I took from writing the post. The tool mattered less than the rules around it. The CLAUDE.md or Cursor rules file I mention is advisory: the model reads it and may or may not follow it. You’re moving enforcement out of the model and into middleware, which is a different and stronger guarantee. A write-before-read is also a good first target, because it’s deterministic and cheap to check.
I haven’t built anything like this, so take the rest as questions rather than corrections:
I’m also less sure about the 90% to 98% extrapolation. Rules like “read before write” are syntactic, so they scale well. A definition of done is closer to “does this match the approved design, reuse the right components, and pass the tests.” That’s semantic and mostly depends on the project, so I’d expect it to need project-level rules plus real verification (tests, visual diffs) rather than a generic library. The generic layer could still get you a long way, and I’d love to see the numbers.
Is the engine open source, or are you writing it up somewhere? If you do, I’d like to read the rule categories and what the misses looked like.
The grouping by starting point is what makes this useful. A converter and an app builder solve different problems, so ranking them head to head wouldn’t have worked.
One thing I’d add to the pre-handoff checklist is performance and SEO basics. AI-generated frontends often look right but have problems that only show up in Lighthouse or Search Console:
<div>s instead of<header>,<nav>,<main>and proper heading orderwidth/heightor lazy loading, and oversized files that hurt LCP and cause layout shiftA quick Lighthouse run at mobile width catches most of it before the client sees it. It also pairs well with the accessibility checks you already list, since semantic markup helps both.
Have you noticed any of these tools producing cleaner markup than the others, or does it come down to the rules you give the agent?
Putting a converter and an app builder in one ranking would have been misleading.
Your checklist additions are good, and I’m adding them to my handoff list. Semantic HTML and image dimensions are the two I see missed most. Layout shift from images without width/height is something clients notice before they can say what’s wrong. A Lighthouse run at mobile width is a cheap final gate, and it overlaps nicely with accessibility, since proper landmarks and heading order help screen readers and crawlers alike.
On your question: in my experience it’s mostly the rules you give the agent. Some tools default to cleaner output than others, but the gap closes quickly once you state the requirements up front: semantic landmarks, one H1 with ordered headings, explicit image dimensions, lazy loading below the fold, no unused libraries, and unique titles and meta descriptions per page. Without those rules, every tool I tried drifted toward div-heavy markup on longer pages. I’d treat default cleanliness as a tiebreaker, not a selection criterion.
Do you keep a standard rules file you drop into these tools, or do you fix things after the fact?
Bookmarked. The table at the end (“if your priority is...”) is what I’ll actually come back to, since it saves the usual hour of tab-hopping between tools.
The Cursor vs Claude Code section was refreshingly honest too. Most posts pick a winner and call it a day, but “try both on the same small task in your own repo” is the only advice that really holds up.
My own rule of thumb: prototype in Figma Make or v0, then do the real implementation with an agent inside the repo. The prototype is for getting the client to say yes, not for shipping.
Glad the “if your priority is...” table is useful. It was written for exactly that “I don’t have an hour to tab-hop” moment.
Your rule of thumb matches how I use these tools. A prototype from Figma Make or v0 exists to get a yes from the client, and the real build happens in the repo, where the agent can see the actual components, tokens, and tests. The risky moment is when a client sees a polished prototype and assumes it’s nearly done. I now tell them up front that the prototype is for deciding, not for deploying. That one sentence saves a lot of awkward timeline conversations later.
One thing I’d add: once the client signs off, I treat the prototype as a reference and rebuild from it rather than copying the code in. Carrying prototype code into production is usually where the cleanup I mentioned in the post starts.
Do you keep any of the prototype code when you move to the repo, or do you start fresh and use it only as a visual spec?
Grouping by starting point makes the comparison easier to use. One thing I noticed is that the scorecard has no column for output quality at the markup level, even though the pre-handoff checklist covers accessibility.
With design-to-code tools, my guess is that the Figma file’s structure decides a lot. Frames built with auto layout and named layers should translate into flex/grid and sensible components. Frames positioned by hand risk absolute positioning and nested divs that look right at one width and break at another. Semantics are a similar concern: a Figma “button” has no idea whether it should be a
<button>, an<a>, or adivwith a click handler.Did you see this difference between tools, or between well-structured and messy files? I’d be curious whether the Figma MCP + agent route handled semantic elements and keyboard behavior better than the converters, or whether they all needed the same manual pass. An accessibility or semantic-markup column in a follow-up would be a useful addition to the scorecard.
Fair catch. The scorecard’s “design fidelity” only measures how the output looks, so it can’t tell you whether the markup underneath is any good. The checklist covers accessibility, but the scorecard doesn’t, and that’s a gap.
I haven’t run a controlled test of clean vs. messy Figma files across these tools, so I can’t give you measured differences. Your hypothesis matches what I’d expect, though:
divswith click handlers.<button>,<a>, ordiv, so the result depends on your rules. If the repo has real components (a that renders a native button) and your CLAUDE.md or Cursor rules say “use native elements, never click handlers on divs,” I’d expect much better output than a converter’s. Without those rules, I’d expect it to guess too.I’d love to add an accessibility/semantic-markup column in a follow-up. My plan is to run one clean (auto layout, named layers) and one messy file through a few of these tools. I’d then compare element choices, a tab-through of the keyboard behavior, and an automated audit like axe or Lighthouse, plus the manual pass those tools can’t replace. If you’ve seen the clean-vs-messy difference yourself, I’d like to hear what broke first.
The 'cleanup cost' framing is the right way to buy these tools — fidelity to pixels is easy to demo, but whether the output reuses your components, consumes your design tokens, and survives a handoff is what determines if it paid for itself. One practical filter I use: run every candidate on the same representative page (form-heavy, responsive, backed by an existing component library) before comparing, because most vendors optimize for their showcase, not your codebase.
Exactly, and that’s the gap in my post. The ratings come from documented capabilities, not from running every tool on one codebase, so vendor showcase bias is something I couldn’t rule out. Your filter is the right fix.
If I do a follow-up, I’d use that kind of page: form-heavy, responsive, backed by a real component library. I’d score each tool on:
Forms are a good stress test because validation, error states, and accessibility are where generated output usually falls apart. Those problems don’t show up in a screenshot demo.
What would you put on that test page beyond forms? I’m wondering whether something like a data table or a modal flow would catch problems that a form wouldn’t.
Useful comparison. One thing I always look for with design to code tools is not the first generated screen, but how maintainable the output is after a few weeks of real development. Things like component structure, responsiveness, naming consistency, and how easy it is to integrate into an existing codebase usually matter more than pixel perfect generation. For a marketplace like Transferise, where booking flows and integrations evolve constantly, clean code and editability end up being the deciding factors. Which of the tools felt strongest when you had to make significant changes after generation?
Your criteria (editability, structure, how it fits an existing codebase, and what happens weeks in) apply to scrapers too. It’s the same idea as the “still works in week two” point in this post. One note: this article compares AI web scrapers, not design-to-code tools, so I think this comment may have been meant for the design-to-code comparison.
For scrapers, the equivalent of “clean, editable output” is how easy it is to change the extraction logic after the first run. I haven’t stress-tested this post’s tools by making big changes after setup. It’s an editorial comparison based on documented capabilities, so treat the following as my expectation, not a measured result.
For a marketplace like Transferise, where flows and integrations keep changing, I’d pick tools where the logic is code you own, plus a validation layer and per-run field-completeness tracking. That makes changes cheap and breakage obvious.
Grouping the tools by starting point (Figma file, prompt, full app, existing repo) makes more sense than ranking them head-to-head, since they solve different problems.
The point about the Figma MCP Server supplying context while the agent writes the code is the one I think most people miss. The output quality depends heavily on component rules and project conventions, so the tool matters less than the setup around it.
I also appreciated the warning about Lovable and Bolt.new MVPs. Generated apps can look finished while the auth and data-access rules are still unreviewed.
Curious how others handle this: when a client already has a design system, are you getting better results from Builder.io’s component mapping or from an MCP + agent workflow?
On the grouping: ranking head-to-head kept falling apart because Figma-to-code tools and prompt-to-app tools aren’t really competing. Starting from the input a client actually has made the choice much clearer.
You’re right on the MCP point. In my projects the tool itself mattered less than the setup around it. Once the component rules, naming conventions, and token usage were written down where the agent could read them, results improved far more than from switching tools.
And yes, the Lovable and Bolt.new warning came from experience. A generated MVP can look done while auth flows and data-access rules are still unreviewed, so I treat that review as a separate, non-negotiable step before anything goes in front of users.
On your question, my honest take is that it depends on how disciplined the design system is. When a client’s system is clean (consistent tokens, well-named components, a maintained library), Builder.io’s component mapping gives more predictable output with less setup. When the system is messier or the codebase has its own conventions, MCP plus an agent has worked better for me, because I can encode those rules explicitly and iterate on them. The trade-off is that MCP needs more upfront investment in the rules.
Curious what you’re seeing: are your clients’ design systems mostly well maintained, or do you find yourself cleaning them up first?
The scorecard is what stood out for me. Most roundups just say a tool is “great”, but rating each one on fidelity, code integration, and developer control makes it clear why converters and app builders can’t be compared directly.
I also liked that you said the ratings are editorial judgment and not benchmark results. That honesty makes the rest of the post more credible, and it’s rare in tool comparisons.
The Lovable section was a good reminder too. A generated app can look finished while the row-level security rules are still wrong, so reviewing the backend before handoff is essential.
One question: If a client has Figma designs but no component library yet, would you run Anima or Builder.io first and then move to Cursor or Claude Code, or go straight to the agent?
Good question. Without a component library, I’d go straight to the agent and skip Builder.io. Visual Copilot’s value is mapping designs to components you already have, so with no library there’s nothing to map to.
Anima: it can be a useful first pass if you have many mostly static pages and want quick markup and a rough responsive layout. The catch is that the output tends to be page-shaped rather than component-shaped, so you’d likely end up asking the agent to pull repeated elements out into shared components anyway. That can cost as much as building them cleanly from the start.
Agent first: this is the order I’d try.
A cleanly structured Figma file with real components and variables already gives you most of a library. If the file is just loose frames and detached layers, I’d tidy it up first, since the agent will faithfully reproduce the mess.
Anima’s only real advantage here is speed on a first draft, which I’d weigh against the refactoring afterwards. This is my editorial take rather than a tested result, so if you’ve compared both routes on a real project, I’d like to hear how it went.
What I liked most is that the post doesn’t pretend one tool wins everywhere. Splitting the 11 tools into Figma-to-code, prompt-based UI, app builders, and coding agents matches how client work actually starts, so the shortlist table is easy to act on.
The Cursor vs Claude Code section was refreshingly practical. Calling the difference mostly a matter of workflow, editor-centered versus terminal-centered, and suggesting people test both on the same small task in their own repo is better advice than declaring a winner.
I also appreciate the disclosure about the post being edited with help from Claude. It’s a small detail, but it adds trust, especially in a space where so many comparisons are quietly sponsored.
The pricing section is smart as well. Leaving out numbers that will be stale in a month and explaining the patterns instead, like credit-based app builders burning through allowances during heavy iteration, will stay useful longer than a price table.
The split into categories was the part I fought with most. Early drafts had a single ranked list, and it fell apart the moment I tried to use it on real projects. A Figma-heavy client and a “we have an idea and a weekend” client need completely different tools, so grouping by how the work starts felt more honest than crowning a winner.
On Cursor vs Claude Code, I’m glad the “test both on the same small task” advice landed. Feature lists only go so far, and a tool either fits how you think or it doesn’t. Ten minutes in your own repo will tell you more than any comparison, mine included.
The disclosure was an easy call. I used Claude to help with editing, and if I’m asking readers to trust my judgment on tools, I should be upfront about how I use them too.
And you’re right about pricing. I didn’t want the post to be wrong a month from now, so I focused on the patterns, like credit burn during heavy iteration, since those tend to outlast the exact numbers.
Thanks again for taking the time to write this. If you try any of these on a client project, I’d love to hear what worked for you.
I like that the post starts from what the client actually needs and not from a list of trendy tools. The “closest to the required result without creating more cleanup than it saves” test is a better way to judge any AI tool than counting how much code it generates.
The Cursor vs Claude Code section was refreshingly practical. Calling it a workflow difference (editor-centered vs terminal-centered) instead of declaring a winner is more honest, and the disclosure note adds to that trust.
The “What to check before handing code to a client” section is the part I’d share with junior developers. Checking responsive behavior at narrow widths and testing loading and error states catches the problems that screenshots hide.
Pricing is the one area where I’d love a follow-up, since credit-based app builders can get expensive after a few rounds of revisions. Even a rough note on how many iterations a typical client project needs would help agencies plan budgets.
The “closest to the required result without creating more cleanup than it saves” test came straight from client work. Early on I kept getting impressed by how much code a tool could generate, then losing hours trimming it back into something I could actually hand over. Judging by cleanup cost changed how I evaluated everything.
I’m glad the Cursor vs Claude Code section landed the way I meant it. Both are strong, and the right pick depends on whether you think best in an editor or a terminal, so a winner would have been misleading. The disclosure note was there for the same reason: you should know where I’m coming from when you weigh my opinions.
Sharing the pre-handoff checklist with juniors would make me happy. Narrow-width responsive checks and loading/error states are exactly what polished screenshots hide, and clients tend to find those problems on their own devices a week later.
Pricing is a fair gap, and a follow-up is a good idea. From my own projects, a typical client build took a handful of revision rounds, and credit-based builders got expensive when feedback came in vague or late. I’ll try to put together a rough iteration range and budgeting guide for agencies, so keep an eye out for it. If you’ve seen costs balloon on your own projects, I’d love to hear what drove it.
Grouping the tools by starting point instead of ranking all 11 together is the right call. Most comparison posts compare Figma-to-code converters against app builders, which doesn’t make sense.
I also liked that you said the scorecard is editorial judgment, not benchmarked. The “n/a” for design fidelity on the prompt-based tools is honest too, since they don’t start from an approved design.
The Figma MCP Server plus a coding agent looks strongest on paper, but the post says the result depends on the context and instructions you give the agent. So here’s my question: what do you put in your project rules or instruction file to stop the agent from inventing new button or input variants when you already have a component library? Is it a list of components, token names, or explicit “never create new components” rules?
Also curious whether you’ve seen Visual Copilot’s component mapping pay off on a messy codebase, or whether it really needs a clean design system first. Thanks for the pre-handoff checklist at the end, it’s the part I’d bookmark.
Thanks, Jennifer. On your first question, the short answer is all three, but each does a different job.
A component inventory, not just a prohibition. A bare “never create new components” rule gets ignored or causes odd workarounds, because the agent doesn’t know what already exists. I list the components with import paths and one line on when to use each, for example
Button(variants: primary, secondary, ghost) from@/components/ui/button. Pointing it at the Storybook or thecomponents/uifolder works too.Token rules. I say where tokens live and ban raw values in components: no hex colors, no arbitrary px or Tailwind
[...]values, use the spacing and color tokens only. Token names need to match between Figma and the repo, or the agent guesses.A “when nothing fits” rule. This is the one that stops variant sprawl: “If no existing component fits, don’t create one. Say so and propose the closest match or the prop change needed.” Giving it a way out stops it from inventing something to finish the task. New variants should be added as props on the existing component, not as parallel components.
Two things back the rules up. Code Connect mappings are stronger than prose rules because the agent gets the real component, and I review every diff for new files in the components folder, since that’s where drift shows up first.
On Visual Copilot, I should be upfront: I haven’t pushed its mapping hard on a messy codebase. My read from the docs is that it depends on clean, consistent mappings, so I’d expect it to struggle where naming is inconsistent. In the messy cases I’ve worked on, MCP plus an agent was easier to fix, because I could keep tightening the rules after each bad diff. If you’ve tested Visual Copilot on a messy repo, I’d like to hear how it went.
Glad the checklist is useful.
The “which tool” question gets easier once you ask what the deliverable is. I’ve seen teams burn a week on a Figma-to-code converter, then rebuild half of it because the output ignored their existing components. The point about mapping to a design system first, before picking a tool, is the part most people skip.
One thing I’d add to the pre-handoff checklist is a visual regression check against the approved design, like screenshot diffs at a few breakpoints. Eyeballing spacing and typography is where AI-generated UI quietly drifts.
Also, the “prototype for sign-off” vs “code for production” split deserves more attention. Clients often see a polished Figma Make or Lovable demo and assume it’s nearly done, so setting that expectation early saves a lot of pain.
You’ve nailed the failure mode I see most often. Teams pick a tool first, then discover the output ignores their component library and end up rebuilding half of it. Mapping to the design system up front saves far more time than any tool’s generation speed.
Visual regression checks are a great addition to the pre-handoff checklist. Screenshot diffs at a few breakpoints (say mobile, tablet, desktop) catch the quiet drift in spacing, font weights and line heights that eyeballing misses. Tools like Playwright snapshots, Chromatic or Percy make this fairly cheap to set up, so I’ll add it to the checklist.
You’re also right about prototype-for-sign-off versus code-for-production. A polished Figma Make or Lovable demo makes clients assume the work is almost finished, when the real work of accessibility, state handling, edge cases and integration is still ahead. Setting that expectation at kickoff, and labeling demos clearly as prototypes, avoids a lot of painful conversations later.
Appreciate you adding these. Would love to hear what’s worked for your team on the regression side!
I like that you flagged the ratings as editorial judgment. That said, I’d love to see this follow-up: run the same small task, say a pricing page in an existing React repo, through two or three of these and compare the actual cleanup time. Scorecards like “High / Medium / Low” are useful for shortlisting, but the real cost shows up in how many diffs you reject.
I’d also push back slightly on lumping Bolt.new and Lovable together. In my experience they differ a lot once you need to export and keep working in your own repo, and that’s where most client projects end up.
Pricing is the other gap. I understand why you skipped it, but credit-based tools can get expensive fast when a client keeps asking for revisions, so even a rough “what burns credits” note would help freelancers quoting projects.
Still bookmarking this for the comparison tables.
Thanks for the thoughtful feedback, and glad the editorial-judgment note was useful.
You’re right about the scorecards. High/Medium/Low is good for shortlisting, but it can’t show the real cost, which is how much of the output you end up rejecting or rewriting. A pricing page in an existing React repo is a good test because it forces the tool to deal with your components, styling conventions, and file structure instead of starting from a blank slate. I’m planning a follow-up along those lines, tracking cleanup time and rejected diffs across a few tools.
Fair point on Bolt.new and Lovable too. They look similar in a feature table, but export and repo handoff is where they diverge, and that matters most for client work you need to keep maintaining. I’ll break them out and compare that workflow directly.
On pricing, I skipped it because plans change so often, but a “what burns credits” note is a good middle ground. Revision-heavy client work is exactly where credit-based tools get painful, so I’ll add a section on what drives usage and how to pad a quote for it.
If you’ve run Bolt or Lovable on a real client project, I’d love to hear what the export and handoff experience looked like. And thanks for the bookmark!
Grouping the tools by starting point (Figma file, prompt, existing repo) instead of ranking them head to head is the right call, because a converter and an app builder solve different problems.
The point about Lovable and Bolt.new needing a backend review stands out. Generated apps can look finished while the data-access rules are wide open, so checking auth and row-level security before handoff matters as much as visual fidelity.
I also like that the scorecard is labeled as editorial judgment, not benchmark results. One thing I’d be curious about: has anyone run the Figma MCP + Cursor/Claude Code setup on a repo with a messy or undocumented component library? I’d expect the results to depend heavily on how well the components are named and documented.
Thanks, this is exactly how I think about it. A converter and an app builder solve different problems, so ranking them head to head would have been misleading.
You’re right about the backend review. Lovable and Bolt.new can produce something that looks finished while the auth and row-level security rules are still wide open. I now treat that check as part of handoff, not an optional extra.
On Figma MCP with Cursor or Claude Code on a messy component library: I haven’t pushed it that far, so I can only share my expectation, which matches yours. The output seems to depend on how well components are named, documented, and mapped to Figma. With inconsistent naming, I’d expect it to generate near-duplicates instead of reusing what exists. Adding a short component inventory or rules file to the repo before running it would probably help a lot.
If anyone has tried this on a legacy codebase, I’d love to hear how it went. I’d happily fold it into a follow-up.