---
number: "007"
slug: "007"
title: "From a Figma Make prototype to a repo you actually own"
summary: "Prototype in Figma Make, push it to GitHub, give it a proper home in your own repo, harden it with a Cursor agent, and ship preview deploys on Vercel. The trick is keeping Make's one-way push from overwriting your work."
chain: ["Figma Make", "GitHub", "Cursor", "Vercel"]
for: "Designers who code a little, PMs with a prototype that got popular, and founders who built the demo in Make and now need it to be real"
time_to_set_up: "About 90 minutes (estimate), longer if the prototype is large"
cost: "From $20/mo (Figma Professional Full seat, monthly) with GitHub, Cursor and Vercel on free plans"
last_verified: "Oct 2026 (desk-checked, not run end-to-end)"
date: "2026-10-14"
---

# From a Figma Make prototype to a repo you actually own

**Chain:** Figma Make → GitHub → Cursor → Vercel

## 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](https://help.figma.com/hc/en-us/articles/35463818346647-Push-from-Figma-Make-to-GitHub)) Figma's two-way "Make on your local code" is a Mac-only closed beta with a waitlist ([Figma blog](https://www.figma.com/blog/figma-make-now-on-your-local-code/)), 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](https://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

| Tool | Plan you need | Current price (Oct 2026) | Link |
|---|---|---|---|
| Figma Make | Full seat on a paid plan (Make uses AI credits). Push to GitHub works on all plans | Professional Full seat $20/mo, or $16/mo billed annually | [figma.com/pricing](https://www.figma.com/pricing/) |
| GitHub | Free | $0 | [github.com/pricing](https://github.com/pricing) |
| Cursor | Free works for local agent edits. Plus covers Grok models only. Premium for cloud agents and third-party models | $0; Plus $8/mo; Premium $30/mo | [cursor.com/pricing](https://cursor.com/pricing) |
| Vercel | Hobby (personal, non-commercial). Pro for commercial use | $0; Pro $20/user/mo | [vercel.com/pricing](https://vercel.com/pricing) |

## Setup

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

Before exporting, ask Make to tidy up:

```text
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:

```bash
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:

```text
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:

```bash
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](/drops/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](/drops/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.*