From Zero to a Production-Ready Supabase App in One Command

I've been building apps on Supabase for three years. Over that time I kept refining my patterns and rules until I landed on a setup I genuinely enjoy on every project: business logic in the database, an extra layer of security with schema isolation, multi-tenancy from day one, and async background tasks with pg_cron, pgmq, and Edge Functions (which also power any integration the database functions can't handle on their own).

The patterns were solid. But setting them up on every new project was repetitive, and keeping them consistent across sessions was even harder. So I built AgentLink to automate the whole thing.

AgentLink is two things: a CLI that scaffolds a production-ready Supabase project in one command, and a set of agent skills that keep the agent building with the same secure patterns, every session, every feature.

Let me show you how it works by building a real app: an internal task manager.

One Command to Start#

It starts with a single command: npx agentlink-sh@latestCopy

The CLI walks you through a short setup: it names your project, checks for the Supabase CLI, installs the agent skills, configures your editor, and connects to Supabase. In under two minutes, you have a full project — not an empty boilerplate, but a real, production-ready foundation with a React frontend on TanStack Start (in SPA mode) already wired up.

A Real Foundation#

Here's what the project looks like in Supabase right after scaffolding.

Opening the Supabase dashboard, you can see it's not empty. The apiCopy schema is there, separate from publicCopy, so your tables are never exposed directly to the client. The internal utility functions for reading secrets and calling edge functions are already defined. The auth hooks are configured. The orchestration for background tasks with pg_cron and pgmq is in place. Everything you'd normally spend the first day setting up is already there — the patterns that make the rest of the build go smoothly.

Building with the Agent#

Now the fun part. I open Claude Code and describe what I want to build, in plain language.

I want to build an internal task manager for teams.

Users sign up and create a workspace. They can invite team members to the
workspace with two roles: admin and member. Admins can manage projects and
members, members can work on tasks.

Inside a workspace, users create projects. Each project has a name,
description, and color.

Within a project, users create tasks. Each task has a title, description, a
status (todo, in progress, done), a priority (low, medium, high), and can be
assigned to a team member.

Users can see all tasks for a project in a board view grouped by status, and
move tasks between statuses.

The dashboard shows each member the tasks assigned to them across all
projects, sorted by priority.

That's it — no schema, no architecture decisions, just the app described the way you'd explain it to a teammate.

The agent doesn't ask me whether roles belong in a join table or how to enforce who can touch what. It doesn't surface five options and make me choose. It already knows the patterns. It models workspaces, projects, and tasks, writes the RPCs, enforces the admin and member roles, and follows the architecture that's already in place.

This is the part that matters most. A capable agent with no guidance will make reasonable decisions that drift from one session to the next — a webhook here, a database trigger there, business logic on the client in one feature and in the database in the next. AgentLink removes that drift. The agent builds the same way every time because the patterns are encoded, not improvised.

The Result#

After 13 minutes and 39 seconds with Claude Opus 4.8, the app is running.

Here's the full flow: you create a workspace, invite a team member, and set up a project. Inside the project, you add tasks with a status, priority, and an assignee. The board view groups tasks into todo, in progress, and done columns, and you can drag a task across as work progresses. Each member's dashboard pulls their assigned tasks from every project into one view, sorted by priority.

Multi-tenancy works — each workspace only sees its own data. Admins manage projects and members, members work on their tasks. All of it built on the foundation AgentLink set up, with the agent following the patterns the whole way.

From Local to Production#

When it's ready, deploying to production is three commands away:

# First, add the production environment, you will be prompted to connect to your Supabase organization to create the project
npx agentlink-sh@latest env add prod

# Then create a migration (production only applies DB changes through migrations)
npx agentlink-sh@latest db migrate task_manager_initial

# Finally, deploy
npx agentlink-sh@latest env deploy prod

The first command provisions a fresh Supabase project in the cloud for production and stores its credentials. The migration command captures your current schema as a versioned migration — production only applies database changes through migrations, never direct pushes, so every change is tracked and reversible. The deploy command then applies that migration, pushes your edge functions, syncs the required secrets to the vault, and updates the project configuration. Your app is now live in production.

With the backend live, the front-end still needs a home.

AgentLink builds a TanStack Start front-end in SPA mode, which means every route has to fall back to the app shell. The scaffold already drops in the vercel.jsonCopy that wires this up, so on Vercel there's nothing to configure — push and the site is live.

The exact app from this walkthrough is running at task-manager.agentlink.sh — sign up and try it for yourself.

Why This Matters#

The hard part of building on Supabase was never the features. It was the decisions, and the consistency.

Which pattern do I use? Where does the logic live? How do I keep it the same across every feature and every session? For experienced developers, that judgment comes from years of projects. For everyone else, it's a minefield — and agents left to improvise often make reasonable choices that compound into something fragile or insecure.

AgentLink encodes opinionated judgment that holds up on production-grade applications. The patterns I've refined over these years, applied automatically, every time.

The task manager I just built is the first of several templates I'll be releasing soon (2 ready!) — complete internal tools you can clone, adapt, and run on your own Supabase. See them all and subscribe to hear when each one lands at agentlink.sh/templates.

Get Started#

AgentLink is live.

npx agentlink-sh@latest

Run the command above to scaffold your first project!

Happy building!