build-app
Use when building a new Butterbase app from scratch, creating a full-stack application, or when the user asks to set up a complete backend with database, auth, and deployment
Profile →npx skills add butterbase-ai/butterbase-skills --skill build-app --agent claude-code
Same command for any agent — swap --agent for codex, cursor, copilot.
Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.
What it does
Guides the agent through building a full Butterbase application from scratch, including creating an isolated backend, designing and applying a schema, enabling row-level security, configuring authentication, optionally deploying serverless backend logic, and finally deploying a frontend. It covers seven phases: App creation, schema design and application, RLS setup and verification, OAuth authentication configuration, optional backend functions deployment, frontend deployment, and final production checklist.
How it works
- Phase 1: Use tool init_app with {"name": "my-blog"} to provision a backend and obtain app_id and api_base. Optionally generate a service key via manage_auth_config with action: "generate_service_key".
- Phase 2: Interact with user to design the schema; preview via manage_schema with action: "dry_run", then apply with action: "apply" using a provided schema object. Verify with manage_schema action: "get".
- Phase 3: Enable RLS per user-owned table via manage_rls with action: "create_user_isolation"; optionally add public_read_column. Validate with tests using select_rows and insert_row tools, then list policies via manage_rls with action: "list".
- Phase 4: Configure OAuth providers via manage_oauth with action: "configure" and provide provider-specific credentials; frontend flow includes installing @butterbase/sdk and using it to sign in and fetch session tokens; optionally update JWT lifetimes with manage_auth_config action: "update_jwt".
- Phase 5: Deploy backend serverless functions with deploy_function, including requirements for handler export and return type; use invoke_function and manage_function for logs and testing; understand RLS behavior in functions per role.
- Phase 6: Deploy frontend: configure CORS with manage_app action: "update_cors", set frontend env vars with manage_frontend action: "set_env", build, create deployment, upload assets, start deployment, and finally update CORS with final URL.
- Phase 7: Run production checklist to verify readiness.
When to use it
Use when building a new Butterbase app from scratch, creating a full-stack application, or when the user asks to set up a complete backend with database, auth, and deployment.
What it can touch
- Tools: init_app, manage_schema, create_user_isolation, select_rows, insert_row, list, configure_oauth_provider (via manage_oauth), update_jwt, deploy_function, invoke_function, get_logs, manage_app, manage_frontend, create_frontend_deployment, start_deployment, update_cors.
- Files touched include app setup, schema definitions, RLS policies, OAuth configurations, function code, and frontend deployment assets.
Caveats
- The guide emphasizes that some calls and artifacts are dependent on prior phase outputs (e.g., app_id, schema, RLS policies).
- It notes platform-specific steps (e.g., Windows zip caveat for frontend upload).
- It requires storing service keys securely as full keys are shown only once.
> **Prefer `/butterbase-skills:journey`** — for a fully guided multi-stage build with preflight, planning, deployment verification, and (optionally) hackathon submission. This one-shot skill remains for users who want the legacy linear setup. # Build a Complete Butterbase App This skill walks through all seven phases of building a production-ready Butterbase application — from provisioning a backend to deploying a live frontend. Follow each phase in order; later phases depend on artifacts (app_id, schema, RLS policies) produced by earlier ones. > **Convention:** every JSON body below is the argument object for the tool named in its **Tool:** header. When the header reads `manage_schema` with `action: "apply"`, include `"action": "apply"` alongside the other fields when you make the call. --- ## Phase 1: Create the App Use `init_app` to provision an isolated backend with its own database and auto-generated REST API. **Tool:** `init_app` ```json { "name": "my-blog" } ``` **Returns:** ```json { "app_id": "app_abc123", "api_base": "https://api.butterbase.ai/v1/app_abc123" } ``` **Important:** Save `app_id` and `api_base` — every subsequent tool call requires `app_id`. ### Optional: Gen
- Phase 1: Create the App
- Optional: Generate a Service API Key
- Phase 2: Design & Apply Schema
- Preview First with dryrunschema
- Apply the Schema
- Verify the Schema Was Applied
- Schema Tips
- Phase 3: Secure Data with RLS
- Enable User Isolation
- Allow Public Reads (Optional)
- Test RLS Isolation
- Verify All Policies
- Phase 4: Authentication
- Configure an OAuth Provider
npm install @butterbase/sdk npm run build From the project root — use Git Bash on Windows cd dist && zip -r ../frontend.zip . && cd .. curl -X PUT "https://s3.amazonaws.com/..." \
What does the build-app skill do?
Use when building a new Butterbase app from scratch, creating a full-stack application, or when the user asks to set up a complete backend with database, auth, and deployment
How do I install it?
Run `npx skills add butterbase-ai/butterbase-skills --skill build-app --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.
Where does this skill come from?
From butterbase-ai/butterbase-skills, a repository with 532 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.
Is a popular skill a good skill?
Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.