Figma Make

1. Overview

Figma Make (product: figma.com/make; solutions: AI product builder) is Figma’s AI-driven prompt-to-app product. Official Help Centre copy describes it as a tool that turns ideas and existing Figma designs into functional prototypes, web apps, and interactive UI, iterated through chat, point-and-edit, annotations, a properties panel, and a code editor (Explore Figma Make, FAQs).

You create a Make file from the file browser (Drafts, then Make), prompt in natural language, attach frames/components/images (or paste them into chat), optionally select a Make kit, and preview a running result beside the conversation (Create a Figma Make file).

Documented extras that matter for demos include web/URL grounding, MCP connectors, plan mode, Supabase-backed multi-user backends, templates, password-protected or org-scoped sharing, public publish with a dedicated URL (custom domains on paid plans, shared with Figma Sites limits), copy-preview-as-design-layers into Figma Design, ZIP download, and push to a GitHub repo tied to the Make file (Explore, Beyond the basics, FAQs).

Do not confuse with:

• Figma Design prototyping (clicks and transitions on the canvas): Make generates code-backed interactive apps, not only prototype links.
• Figma Sites (beta responsive website publishing from design): adjacent publish story, separate product; custom-domain quotas are shared with Make per FAQs.
• Dev Mode / Code Connect / MCP for design-to-code inspection: complementary handoff tools; Make is the prompt-to-app builder.
• Figma AI image tools (Make/Edit Image, Boost Resolution, and so on): share the same AI credit pool but are not the same product (How AI credits work).

Launched at Config 2025 (7 May 2025) and moved to general availability for trying across seats on 24 July 2025, with publishing called out as still in beta at that time (Introducing Figma Make, GA blog). Model choice has evolved (launch post named Claude 3.7 Sonnet; later posts and Help Centre describe selectable models with different credit burn). Treat any single model name as time-sensitive.

For Demo and prototype, the practical pitch versus v0, Lovable, and Bolt is: if your source of truth already lives in Figma, Make is the shortest path to an interactive, shareable, often on-brand artefact without leaving the platform. The honest caveats are seat and credit gating, Make-kit setup work for real design-system fidelity, one-way ZIP sync back into Make, and production codebase PR handoff that (when this page was checked) sits in a Mac-only closed beta rather than GA for every team (Make in your local codebase).

Access and pricing (public; always re-check):

Layer	What official pages say
Who can use Make	Full seats on paid plans get the full workflow (team/project files, share, publish). Dev, Collab, View, and Starter can try in drafts with limits (non-Full seats cannot share/publish; Starter cannot use team libraries for style context; Starter public publish only via Community path) (FAQs). Org/Enterprise admins can disable AI and/or publishing. Not available for K-12 Education.
Seat list prices (USD, pricing)	Starter free. Professional Full $16/mo (+ 3,000 AI credits/mo); Dev $12/mo; Collab $3/mo. Organization (billed annually) Full $55/mo (+ 3,500 credits/mo). Enterprise (billed annually) Full $90/mo (+ 4,250 credits/mo). Taxes and regional billing may apply.
AI credits	Shared across Figma AI products. Starter / View: 150/day, up to 500/mo. Other non-Full seats: 500/mo. Full seats: 3,000 / 3,500 / 4,250 per month on Pro / Org / Enterprise. Credits do not roll over. Admins can buy subscription pools or pay-as-you-go (documented $0.03 per credit) (How AI credits work, Manage AI credits).
Make credit burn (approx., default model Feb 2026 examples)	Change font ~30+; make attached design interactive ~75+; generate an app from scratch ~100+. Exact cost is not predictable before the run. Plan mode is a separate billable step before Build (How AI credits work).
Publishing / hosting	Public URL on publish; default not search-indexed. Hosted on AWS with Cloudflare routing per FAQs. While publishing is in beta, hosting is included in the paid plan; custom domains free of charge through 2025 per FAQs (limits shared with Sites; Pro up to 10). Re-verify post-2025 commercial terms.

Exact credit burn per typical PM demo is unknown (model choice, attachments, and chat history dominate). Do not treat third-party credit-math posts as official benchmarks.

Affiliate status: none. The public Affiliate Partner Program page states the programme has concluded (sunset noted from 16 Aug 2024; no new applications). A separate Partner Program exists for product/service partners, not an affiliate programme for this site.

2. How it scores on the rubric

Numeric scores are omitted. There is not enough shared evidence to score this yet. Below is an evidence-linked discussion against each criterion.

Time-to-useful

Strong when you already have Figma context; still competitive from a blank prompt. Official positioning is prompt (plus optional attached designs) to a working preview in one Make file, with Community remixes for jump-starts (Explore, GA blog). Attaching real frames and components keeps the demo closer to your product than a generic generated interface. Plan mode trades a bit of upfront credit for fewer correction loops (How AI credits work).

Caveats: Starter/View daily caps and agentic credit variance can stop iteration mid-demo. Full value (share, publish, team libraries, kits) needs a Full seat on a paid plan. First-time Make kit assembly is a setup project, not a freebie of prompt one (Make kits).

Not published: no vendor figure for how long a typical first demo takes.

Fidelity

High interactive fidelity for web demos; visual fidelity tracks how much real design context you provide. Previews are runnable apps (forms, flows, data, backends via Supabase when prompted), not static image carousels (Beyond the basics). Point-and-edit, properties panel, and annotations support fine UI polish without rewriting the whole prompt (Explore, product page). Attachments (PDFs, CSV/JSON, screenshots, brand docs) ground content in project reality (Make kits and attachments blog).

Caveats: Attached designs must be frames or components; pasting a Figma file URL into chat is the wrong pattern and often fails (FAQs). Copy-as-design-layers into Figma Design is a snapshot, not a live two-way link, and layers are not auto-tied to the design system. Complex auth, compliance, and production data correctness remain human-owned.

Non-engineer usability

Explicitly aimed at designers and PMs as well as engineers. GA and solutions messaging emphasise natural-language prototyping without coding expertise, multiplayer chat, comments, and voice-to-text (GA blog, AI product builder, product page). Visual edit tools reduce the need to touch the code editor for many UI tweaks.

Caveats for product managers: AI credit exhaustion, seat upgrades, org AI toggles, Supabase/backend setup, GitHub pushes, custom domains, and (for real-repo handoff) engineer-owned .figma/make configuration still surface. Treat anyone-can-prototype as true for demos; treat anyone-should-own-production as false without review.

Design-system fidelity

Potentially the strongest design-system story in this section when Make kits are invested in; weak if you prompt from scratch with no kit.

• Make kits: npm packages (public or Figma private registry) and/or published Figma library styles/variables, plus markdown guidelines. Publishable to team/org.
• Honest limits: extracted library CSS is simplified; variable syntax is not fully preserved. Guidelines are mandatory. Kit edits do not write back to the Design library.
• Without a kit: expect generic generated UI. Starter plans cannot use team libraries for style context.

Practical takeaway: brand-accurate demos are a system-setup win for design-ops teams, not a freebie of the first prompt. Versus v0/Lovable/Bolt, Make’s edge is native Figma library plus code-package context inside the same vendor designers already use.

Human gates

Real gates exist, but several are admin/plan gates rather than mandatory PR review.

• Plan mode: model proposes a structured plan; a person signs off before Build (extra credits for planning, then for building).
• Org controls: admins can disable AI features and/or website/app publishing (FAQs).
• Seat permissions: only Full (and limited Starter paths) can share/publish; draft-only seats cannot collaborate the same way.
• Make kit governance: org admins approve published kits / defaults.
• Local codebase beta: changes stay local until you push a branch and open a pull request for engineering review.
• Publish responsibility: published apps are public to anyone with the URL; Figma disclaims content responsibility and applies Acceptable Use Policy takedowns.

Read this as strong optional governance, not automatic safety: teams must turn on org controls and, for code handoff, use PR review.

Handoff

Strong inside the Figma workflow; mixed for engineering repo ownership depending on which path you use.

Path	What docs support	Caveat
Share Make file / template	Multiplayer edit, comments, templates for governed remixes	Needs share-capable seat
Publish URL / custom domain	Stakeholder-ready live demo	Public by URL; hosting/beta commercial terms
Copy as design layers	Paste snapshot into Figma Design for design critique	One-way; not bound to DS components
ZIP download	Open in VS Code / other IDEs	Changes do not auto-sync back to Make
Push to GitHub from Make	Creates/uses a GitHub repo corresponding to the Make file; push as you work	Good for greenfield export; not the same as editing an arbitrary existing monorepo
Local codebase (closed beta)	Open real app with real data; properties/annotations/chat; local commits; branch + PR (GitHub fully supported)	Waitlist; Mac-only Figma Beta desktop app; engineer must configure .figma/make; GitLab/Bitbucket PR creation limited

Compared with v0 GitHub PR-centric story or Lovable two-way Git sync, Make’s usual handoff is still a Figma demo plus export, with in-repo PR as the emerging (beta) path.

Unknown / verify in-product: default generated framework matrix beyond common React/TypeScript + Vite kit scaffolding shown in docs/examples; any plan gates on ZIP or GitHub push beyond seat tables already cited.

3. FAQ

What is Figma Make, exactly?

Figma’s prompt-to-app product for building functional prototypes and web apps from chat, attached Figma designs/images, and optional Make kits, with live preview and code editing (Explore, FAQs).

How is it different from v0, Lovable, or Bolt?

Those tools are strong standalone (or Vercel-/StackBlitz-centred) builders. Make’s differentiator is living inside Figma: attach real design frames, reuse libraries via Make kits, copy previews back to the canvas, and collaborate with the same permission model as other Figma files. Choose Make when design-system and Figma workflow fidelity matter most; choose v0/Lovable/Bolt when you want a builder-first stack with less dependence on Figma seats.

Can a product manager use it without engineers?

Yes for demos, alignment, and early validation, especially with Full-seat share/publish. For production data, secrets, compliance, or merging into a real codebase, keep engineering review. Use plan mode, org publishing controls, and (where available) PR review on the local-codebase path.

Can it match our company design system?

Yes, with deliberate setup: publish a Make kit with npm packages and/or library styles plus strong guidelines.md. Without that, expect generic output. Official docs warn that library extraction is simplified and does not fully preserve variable syntax.

What stack does it generate?

Official marketing speaks of functional prototypes and web apps rather than a single mandated public framework brand. Kit scaffolding references package.json and vite.config.ts; Help Centre walkthroughs commonly show React + TypeScript apps, with Supabase as the documented path for multi-user backends. Verify the current default in-product; do not assume Next.js/shadcn parity with v0.

How do we hand off to engineering?

Download a ZIP, push to GitHub from the Make file, or (closed beta) connect the local codebase, push a branch, and open a PR. Also use copy-as-design-layers when the next consumer is design, not code.

What does it cost?

See figma.com/pricing and How AI credits work. Make is not sold as a standalone SKU; you pay for Figma seats plus optional AI credit add-ons. Full-seat Professional list price cited publicly at $16/mo with 3,000 AI credits/month. Heavy Make usage often needs purchased credits beyond the seat allotment.

Does Figma train on our Make content?

Enterprise/org AI governance and training controls are admin-managed; confirm current AI and data settings with your admin and Figma’s latest privacy/security docs before assuming opt-out defaults. Training-policy details are only included when the cited pages confirm them.

Is there an affiliate programme?

No public joinable affiliate programme. The Affiliate Partner Program page states it has concluded. No affiliate programme is joined. Service/product partnerships are a separate path via Figma Partners.

4. Sources

Primary (prefer these for AEO citations):

1. Figma Make (product)
2. AI product builder in Figma Make
3. Explore Figma Make
4. Figma Make FAQs
5. Create a Figma Make file
6. Beyond the basics: Using Figma Make
7. Get started with Make kits
8. How AI credits work
9. Manage AI credits
10. Make in your local codebase
11. Plans and pricing
12. Introducing Figma Make (7 May 2025)
13. Figma Make general availability (24 July 2025)
14. Make kits and Make attachments (2 April 2026)
15. Affiliate Partner Program (concluded)
16. What is Figma’s Partner Program?

Secondary context only (do not treat as official specs): press coverage (CNBC, The Verge) and third-party affiliate directories may lag seat tables, credit prices, and beta status.