Wire Claude Code to GitHub, Supabase & Vercel

The promise of agentic coding isn't "the AI writes a function." It's that one operator, talking to one agent, can scaffold an app, provision a database, push to a repo, and ship it to production — without ever leaving the conversation. The trick is giving the agent hands: connect Claude Code to GitHub, Supabase, and Vercel, and the gap between an idea and a live URL collapses to minutes.

Here's exactly how to wire it up.

Two layers: connectors and CLIs

You'll plug each service in two ways, and it's worth understanding why you want both.

• MCP connectors give Claude structured, read-and-reason access to a service's API — listing repos, inspecting database schemas, reading deployment logs. This is how the agent knows the state of your world.
• CLIs give Claude hands to act — git push, supabase db push, vercel --prod. These are the operations that change things.

Connectors are for understanding; CLIs are for doing. The fast loop uses both: the agent reads context through MCP, then runs the CLI to execute. In Claude Code you add a connector with claude mcp add, and you grant CLI access by pre-approving commands in your settings allowlist.

GitHub: the source of truth

Connector. Add GitHub's official remote MCP server, then authenticate over OAuth:

claude mcp add --transport http github https://api.githubcopilot.com/mcp/
# then, inside Claude Code:
/mcp        # → select github → Authenticate

Now the agent can search code, open issues, read PRs, and create repos directly.

CLI. The gh CLI is what actually moves code. Authenticate once:

gh auth login        # choose GitHub.com → HTTPS → browser

With both in place, "create a private repo and push this" becomes a single instruction. A clean pattern: let the agent open a draft PR as soon as there's something to show — the PR becomes your review surface instead of a wall of diffs.

Pre-approve the safe verbs (gh pr create, gh pr view, git push) in your settings allowlist so the agent stops asking. Keep the dangerous ones (git push --force, branch deletes) gated.

Supabase: the backend in one command

Connector. The Supabase MCP server lets Claude inspect your schema, run read queries, check advisors, and (if you allow it) apply migrations. Add it with a personal access token from your Supabase dashboard:

claude mcp add supabase -- \
  npx -y @supabase/mcp-server-supabase@latest \
  --project-ref=YOUR_PROJECT_REF --access-token=YOUR_PAT

Start it --read-only while you're exploring; drop the flag when you're ready to let the agent write migrations. Now "what tables exist and what's the RLS policy on profiles?" is answered instantly — no dashboard tab-hunting.

CLI. The Supabase CLI owns local dev and migrations:

npx supabase login
supabase init                       # once per project
supabase link --project-ref YOUR_REF
supabase migration new add_votes    # author SQL
supabase db push                    # apply to the remote project

The magic move: describe a feature ("add a votes table, one per user per tool, RLS so users only edit their own"), let Claude write the migration SQL, review it, and db push. You went from sentence to schema without opening a SQL editor.

Vercel: ship to a real URL

Connector. Vercel's MCP server gives the agent visibility into projects, deployments, and — crucially — runtime and build logs, so it can debug a failed deploy itself:

claude mcp add --transport http vercel https://mcp.vercel.com
/mcp        # → vercel → Authenticate

CLI. The Vercel CLI links the repo and ships:

npm i -g vercel
vercel login
vercel link                 # connect this folder to a Vercel project
vercel env pull             # sync env vars locally
vercel                      # preview deploy
vercel --prod               # production

Link the GitHub repo to the Vercel project and every push gets a preview URL automatically. When a deploy breaks, the agent reads the build log through the connector, finds the type error, fixes it, and redeploys — a loop that used to mean three browser tabs and a coffee.

The loop, end to end

Once all three are wired, a single session looks like this:

1. Scaffold — pnpm create next-app, the agent writes the first pages.
2. Database — describe the data model; Claude authors the migration and supabase db pushes it.
3. Version — gh repo create --private --push, draft PR opened.
4. Ship — vercel link + vercel --prod; live URL in under a minute.
5. Iterate — every change is a sentence: the agent edits, commits, pushes, and the preview redeploys itself.

That's the whole point. The friction that used to live between tools — copy-pasting connection strings, hunting through dashboards, context-switching between five tabs — is exactly the friction an agent with connectors and CLIs erases.

A few rules that keep it fast and safe

• Pre-approve read-only and routine commands in your settings allowlist; keep destructive ones (force-push, db reset, table drops, rm -rf) gated behind explicit confirmation.
• Work in a git worktree if you run multiple agent sessions against one repo, so they don't clobber each other.
• Least-privilege tokens — scope your Supabase PAT and GitHub token to what the project needs; start Supabase MCP read-only.
• The PR is the checkpoint. Let the agent move fast inside a branch; you review at the PR, not at every keystroke.

Wire it once and the stack disappears. What's left is the part that was always supposed to be the job: deciding what to build, and watching it go live as fast as you can describe it.