From a Figma Make prototype to a repo you actually own

Why now

• Figma Make got a new model. Gemini 4 Argon rolled out in Make on Oct 13, 2026, on all plans, and Make prototypes are increasingly good enough that people want to keep them.
• Make can push to GitHub, but only one way. It creates its own repo, pushes to the default branch, and overwrites anything edited on GitHub at the next push. (Help Center) Figma's two-way "Make on your local code" is a Mac-only closed beta with a waitlist (Figma blog), so most people need the workaround in this drop.
• Cursor's plans changed this month. Cursor is now sold as "The X Subscription", with a free tier and paid tiers from $8/mo. Details are in the Cost section, because they affect which models you can use. (cursor.com/pricing)

Who it's for

Anyone with a Make prototype that has outgrown Make: it needs auth, real data, tests or a real URL. You should be comfortable running a few git commands, or willing to let Cursor run them for you.

What you get

• Make's repo kept as a clean export mirror that Make can overwrite safely.
• Your own repo where real development happens, with Make's later design changes pulled in deliberately rather than clobbering your work.
• A Cursor-hardened codebase: routes, accessibility fixes, environment config and a test or two.
• Vercel preview deploys on every pull request, and production on merge.

You'll need

Setup

1. Get the prototype to a stopping point (Figma Make, 10 min)

Before exporting, ask Make to tidy up:

Before I export: split the app into components in /src/components, move all copy into
one file (src/content.ts), remove unused files, and make sure `npm run build` passes.
Don't change the visual design.

2. Push to GitHub (Figma Make, 5 min)

Make settings → GitHub → Connect GitHub, choose your account, then Create Repository and name it <project>-make-export. The connection is per Figma team, and Make can only push to repos it created.

3. Create your real repo (GitHub + terminal, 10 min)

Create an empty repo on GitHub called <project>. Then:

git clone https://github.com/<you>/<project>-make-export.git <project>
cd <project>
git remote rename origin make
git remote add origin https://github.com/<you>/<project>.git
git push -u origin main

From now on, origin is yours and make is Make's export. Make can keep overwriting make/main as much as it likes.

4. Harden it with an agent (Cursor, 40 min)

Open the folder in Cursor, create a branch (git checkout -b harden) and give the agent this:

This is a Figma Make prototype that we're turning into a real app. On this branch:
1. Read the codebase and write ARCHITECTURE.md (what's here, what's fake).
2. Add client-side routing for the screens that currently swap via state.
3. Fix accessibility: labels, focus order, color contrast, alt text.
4. Replace hard-coded data with a typed module in src/data/ and mark TODOs where
   a real API will go. Don't invent an API.
5. Add environment config (.env.example) and a basic test for the main flow.
6. Keep `npm run build` passing after every step. Commit after each step.
Don't change the visual design. Ask before adding any dependency.

Review each commit. Agents are good at this kind of refactor and bad at noticing when they've quietly changed the design, so compare screens against Make.

5. Connect Vercel (Vercel, 10 min)

In Vercel: Add New → Project, import <project> (your repo, not the export), and accept the detected framework settings. Push the harden branch and open a pull request. Vercel posts a preview URL on the PR. Merge when it looks right, and production deploys from main.

6. Pull later design changes in on purpose (10 min, whenever)

When the designer iterates in Make and pushes again:

git fetch make
git checkout -b design-sync
git merge make/main   # resolve conflicts, keeping your hardening

Or ask Cursor: Merge make/main into this branch. Prefer my versions of logic files, Make's versions of styling and copy, and list every conflict you resolved. Open a PR, check the preview, and merge.

Time to set up

About 90 minutes (estimate, not timed) for a prototype of a few screens. The Cursor step scales with the size of the prototype.

Cost

• Minimum: a Figma Professional Full seat, $20/mo monthly or $16/mo annually, with GitHub Free, Cursor Free and Vercel Hobby.
• With cloud agents and Claude or GPT models in Cursor: + Cursor Premium $30/mo. Third-party models are billed at API list price from your usage pool.
• Commercial project: + Vercel Pro $20/user/mo. Hobby is for personal, non-commercial use.

Prices are list prices as of Oct 14, 2026.

Gotchas

• Make overwrites its own repo. Anything edited in <project>-make-export on GitHub is lost at the next Make push. That's why step 3 exists. Never develop in the export repo.
• Make pushes to the default branch only, with no branch management. It also doesn't support GitHub Enterprise Server or GitHub IP allow lists.
• Cursor pricing is new and confusing. As of October, Cursor's plans are sold as "The X Subscription" by X Subscription Corp. Plus ($8/mo) includes Grok models only and no cloud agents. Premium ($30/mo) adds cloud agents, automations, Bugbot reviews and third-party models at API list price. New signups for the old $20 Pro plan have ended; existing Pro subscribers keep it for now. Usage pools refresh weekly. Check the pricing page before you commit, because this may keep moving.
• Prototype code isn't production code. Make-generated apps often have fake data, no auth and no error states. The agent marks TODOs; it won't build your backend unless you ask (and Drop 003 is a good place to start).
• Make uses AI credits. Heavy iteration on a Full seat can exhaust the monthly allowance. Do structural cleanup in Cursor, not Make.

Remix

• Skip Cursor: use Claude Code (Drop 003) for step 4. The prompt works as-is.
• Two-way, if you get in: if you're accepted into Figma's local-code beta, connect your own repo directly and skip step 3.
• Design system first: before step 4, run the Figma MCP server's get_design_context on your real component library, so the agent swaps Make's components for yours.

Freshness log

• Oct 14, 2026: First published. Desk-checked against Figma's Push to GitHub help article, local-code beta post and pricing page, Cursor's pricing page, GitHub's pricing page and Vercel's pricing page.

Last verified: Oct 2026 (desk-checked, not run end-to-end). We checked every step, setting and price against the vendors' current docs. We have not yet run this chain live. If a step doesn't match what you see, reply and tell us. It'll be fixed in the next refresh.