Figma Make

What is Figma Make?

Figma Make is an AI app builder and prototyping product inside Figma. It generates interactive interfaces and functional web experiences from prompts, existing Figma designs, uploaded files, and connected context. The resulting Make file can be tested in a preview, changed through additional prompts, and in supported cases published as a website.

The product sits between a conventional design prototype and a general-purpose coding environment. A designer can begin with screens from Figma Design and ask Make to add navigation, responsive behavior, animations, or application logic. A product manager can start with a written description of a workflow. A developer can use it to explore an interface or add lightweight functionality before moving into a more traditional codebase.

What people use Figma Make for

Figma Make is primarily a product discovery and interface development tool. Its strongest use cases are situations where a team needs to see and test an idea quickly, but does not yet need a fully engineered production application.

• Turning ideas into functional prototypes: Describe a product concept, dashboard, workflow, or interface and generate an interactive starting point.
• Making static designs interactive: Bring Figma Design frames and components into Make, then add interactions, responsive behavior, animations, and application logic.
• Testing product flows: Create clickable experiences that stakeholders can review and use during discovery, planning, and usability discussions.
• Building lightweight web apps: Generate small internal tools, dashboards, and proof-of-concept applications, including experiences that use uploaded data.
• Adding a basic backend: Connect a Supabase project for authentication, data storage, secrets, and server-side functionality when a prototype needs more than static content.

This makes Figma Make different from a general-purpose chatbot. The output is not just an answer or code snippet: it is an interactive visual experience that remains connected to the Figma workflow. It is also different from a conventional design-only prototype because it can produce functional behavior and work with data.

How the workflow works

A typical workflow begins with a Make file and a natural-language prompt. Users can describe the desired application, attach existing Figma designs, or provide supporting material such as images, documents, PDFs, code, CSV files, JSON, audio, and video. Make uses that context to generate a preview.

Iteration is central to the product. Instead of rebuilding a prototype manually, the user can ask for changes to layout, styling, text, behavior, or application logic. This is useful for exploring several directions quickly, although the generated result still needs human review and testing.

Figma libraries and reusable design context can help keep generated interfaces closer to an existing product language. Make output can also be copied into Figma Design as editable design layers, which supports a handoff from functional exploration back into a conventional design process.

Backend features and external context

For prototypes that need stored data or user accounts, Figma Make can connect to Supabase. This can provide authentication, storage, secrets, API access, and basic application data without requiring the user to build every backend component from scratch. Supabase is an external dependency, however, so its configuration, permissions, and data policies remain part of the overall project.

Make also supports Make connectors and custom MCP connectors. These connections can bring requirements, product documentation, tickets, design-system information, or other external context into the prompting workflow. Connector access should be treated as a meaningful authorization decision: the quality of the result depends partly on the context supplied, and sensitive information should not be added casually.

Publishing and platform support

Figma Make is accessed primarily through the Figma web application. Generated prototypes and web apps can be published to a dedicated website URL when the relevant plan and sharing controls allow it. Published experiences can also be embedded into Figma Design, FigJam, and Figma Slides workflows.

Figma documents selected desktop beta functionality for connecting Make to local codebases. The limited beta workflow is intended for visual editing of local code and can include branches, commits, and pull-request preparation. It is not the same as a mature, unrestricted integrated development environment, and availability depends on beta access and platform support.

For comparison, products such as Replit, v0, and Lovable are more directly positioned around prompt-based software or web-app development. Figma Make’s distinguishing context is the connection between generated behavior, existing Figma designs, design libraries, visual review, and collaborative product work.

Pricing and access

Figma Make is included in Figma plans rather than sold as a separate standalone subscription. The free Starter plan provides limited access and AI credits. Current research indicates that Starter includes unlimited drafts, 150 AI credits per day, and up to 500 AI credits per month, while exact access to sharing, publishing, seats, and other capabilities depends on the plan and workspace configuration.

Paid access is part of Figma’s broader subscription structure. The advertised Professional Full seat starts at $16 per month on monthly billing, although Figma also offers other seat types with different capabilities and prices. AI usage is governed by credits shared across relevant Figma AI features, and consumption varies according to the selected model, task complexity, prompt context, attachments, and conversation history.

Figma’s documentation gives approximate examples such as 30 or more credits for a font change, 75 or more credits for making a design interactive, and 100 or more credits for generating an app from scratch. These examples should not be treated as fixed prices for every task. Enterprise availability and administrative controls are available through Figma’s broader organization and enterprise offerings.

Important limitations

• It is not a complete production engineering replacement: Generated code and behavior require testing, debugging, and technical review before serious deployment.
• Credit usage is variable: Larger prompts, attached context, complex changes, and extended conversations can consume substantially different amounts of AI credit.
• Figma dependence is significant: The product relies on Figma accounts, plans, seats, files, and workspace permissions.
• Backend functionality adds setup: Supabase can extend a prototype, but it introduces another service, configuration surface, and data-management responsibility.
• Advanced code workflows remain limited: Local-code editing and related Git workflows are described as beta functionality with platform and access restrictions.
• Output quality varies: A generated interface may need substantial prompting and correction, particularly when requirements are ambiguous or the application logic is more complex.

These limitations make Figma Make a better fit for exploration, validation, and lightweight applications than for teams seeking unrestricted engineering control, predictable per-request costs, or a standalone app builder outside the Figma ecosystem.

Privacy and data considerations

Prompts, attached files, designs, generated outputs, and connected data are processed to provide the service. Figma’s AI materials describe de-identification and aggregation measures for certain model-improvement uses, and its administrative Content Training setting allows organizations to control whether relevant customer content may be used for AI training. Figma states that content sharing for AI model training is optional, while separate policies apply to areas such as Figma for Education and Figma for Government.

Users should review their organization’s Figma settings and avoid placing credentials or sensitive information directly into prompts. Supabase projects and external MCP connectors have their own permissions and policies, so privacy should be evaluated across the complete workflow rather than within Figma Make alone.

Who should use Figma Make?

Figma Make is a strong fit for product designers, UX teams, product managers, founders, and developers who need to turn ideas or existing screens into testable experiences quickly. It is particularly useful when visual design context matters and stakeholders need to interact with a concept rather than review static frames.

It is less suitable for teams that need a fully controlled production codebase, highly predictable infrastructure and cost behavior, or a tool independent of Figma. Developers may find it useful for early exploration and visual iteration, but should treat generated output as a starting point rather than automatically deployable software.