SPARK_ACCELERATOR
STEPS:0/5
DAY 1// FOUNDATION & REALITY INSTALL

Foundation & Reality Install

"I am an operator, not a learner."

LED BY

Damien Rufus

$spark init -_
Hard Win

App running and under your complete control.

session agenda
$spark agenda --day=1

Session Agenda

Today's session is broken into three blocks plus a break. Start each timer when you begin that block. The timers will warn you when time is running low so you can stay on pace.

TOTAL SESSION TIME
2h 30m
BLOCK 01

Machine Setup & Services

45:00
45 min total0m elapsed
BLOCK 02

Build Your App

01:00:00
60 min total0m elapsed
BREAK

Break

15:00
15 min total0m elapsed
BLOCK 03

Deploy & Go Live

30:00
30 min total0m elapsed

Timers are independent — start each one when you begin that block. If you finish a block early, move on to the next. The timers will keep running so you can track your total pace.

machine setup
$spark setup --prerequisites

Machine Setup

Before we build, your machine needs the right tools installed. Select your operating system below and follow each step. Every command can be copied with one click.

These instructions are for macOS (MacBook, iMac, Mac Mini). You'll use the built-in Terminal app. If you have Apple Silicon (M1/M2/M3/M4), all tools below are fully compatible.

01

Install Homebrew (Package Manager)

Homebrew is the missing package manager for macOS. Open your Terminal app (search for "Terminal" in Spotlight with Cmd + Space) and paste this command:

terminal
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
02

Install Node.js (v22 LTS)

Node.js is the engine that runs your app. We'll install it through Homebrew so it's easy to manage:

terminal
brew install node@22
03

Install pnpm (Fast Package Manager)

pnpm is a faster, more efficient alternative to npm for installing packages:

terminal
npm install -g pnpm
04

Install Git (Version Control)

Git tracks every change you make so you can always go back if something breaks. It may already be installed on your Mac:

terminal
git --version
# If not installed, macOS will prompt you to install Xcode Command Line Tools
# Click "Install" when prompted, or run:
xcode-select --install
05

Install VS Code (Code Editor)

Visual Studio Code is the code editor we'll use. It's free and works great with our stack:

terminal
brew install --cask visual-studio-code
06

Install pi (AI Coding Agent)

pi is a terminal-based AI coding agent from pi.dev. This is the tool you'll use to generate your entire app from the prompt you build below:

terminal
npm install -g @mariozechner/pi-coding-agent
07

Install Cursor (AI Code Editor — Optional)

Cursor is an AI-powered code editor built on VS Code. Optional but recommended for editing code alongside pi:

terminal
brew install --cask cursor
08

Install Supabase CLI

The Supabase CLI lets you manage your database and auth from the terminal:

terminal
brew install supabase/tap/supabase
09

Install Vercel CLI

The Vercel CLI handles deployment — pushing your app live to the internet:

terminal
npm install -g vercel
10

Create Required Accounts

You'll need accounts on these platforms. All have free tiers that are more than enough to get started:

// Verify Everything Works

terminal — run all checks
# Paste this into your terminal to verify everything is installed:

echo "=== Checking your setup ==="
echo ""
echo "Node.js:" && node --version
echo "pnpm:" && pnpm --version
echo "Git:" && git --version
echo "Supabase CLI:" && supabase --version
echo "Vercel CLI:" && vercel --version
echo "pi:" && pi --version
echo ""
echo "=== All checks complete ==="

# ✓ If you see version numbers for each tool, you're ready!
# ✗ If any command says "not found", go back and install that tool.
connect your services
$spark connect --services

Connect Your Services

Your app needs a database, hosting, payments, and AI. Follow each guide below to create accounts, get your API keys, and wire everything together. Work through them in order — each one builds on the last.

Work through these in order

Each service builds on the previous one. Start with Supabase (your database), then GitHub (your code), then Vercel (your hosting). Stripe and AI keys can be added when you need them. Finish with the Environment Variables section to wire everything together.

tech stack
$spark stack --list

Production-Grade Infrastructure

Built on the same stack that powers real businesses. No toy frameworks, no rented platforms. You own every layer.

N
Next.js 16
Framework
R
React 19
UI Library
TS
TypeScript
Language
SB
Supabase
Backend
PG
PostgreSQL
Database
S
Stripe
Payments
TW
Tailwind 4
Styling
V
Vercel
Hosting
dependency audit
$spark deps --audit

Dependency Audit

Every package verified against npm registry. Green means the doc version range covers the latest release. Orange means the doc should be updated to reflect the latest.

// Core

packagedoc_verlateststatus
next16+16.1.6
react19.2+19.2.4
react-dom19.2+19.2.4
typescript5.7+5.9.3

// Backend

packagedoc_verlateststatus
@supabase/supabase-jslatest2.98.0
@supabase/ssrlatest0.8.0

// UI

packagedoc_verlateststatus
tailwindcss4.1+4.2.1
@radix-ui/react-slotlatest1.2.4
class-variance-authoritylatest0.7.1
clsxlatest2.1.1
tailwind-mergelatest3.5.0
lucide-reactlatest0.575.0
sonnerlatest2.0.7

// State

packagedoc_verlateststatus
zustand5+5.0.11
@tanstack/react-query5+5.90.21

// Forms

packagedoc_verlateststatus
react-hook-form7.71+7.71.2
@hookform/resolverslatest5.2.2

// Validation

packagedoc_verlateststatus
zod4+4.3.6

// DnD

packagedoc_verlateststatus
@dnd-kit/corelatest6.3.1
@dnd-kit/sortablelatest10.0.0

// AI

packagedoc_verlateststatus
ai6+6.0.103
@ai-sdk/openailatest3.0.36
@ai-sdk/anthropiclatest3.0.48
@ai-sdk/googlelatest3.0.33
build your app
$pi --interactive

Build Your Prompt

Choose an example or enter your own app idea. Your inputs get merged into the coding document template. Copy the personalized prompt and paste it into pi to generate your entire app.

Fill in your app details below — start from an example, write your own, or paste your custom GPT output and we'll extract the details automatically. Everything gets merged into the coding document template. When you're ready, copy the personalized prompt and paste it into pi.

0/5 fields
how to use pi
$pi --help

How to Use pi

Follow these 5 steps to go from prompt to running app. Each step shows you exactly what to type and what you'll see in your terminal.

STEP 01

Open Terminal & Navigate

Get to your project folder

Open your terminal app (Terminal on Mac, Windows Terminal on PC) and navigate to the folder where you want to create your project.

Tips

On Mac: Press Cmd + Space, type "Terminal", hit Enter
On Windows: Press Win + X, select "Windows Terminal"
Replace "my-saas-app" with your actual app name
1 / 5
Terminal — Step 1
# Open your terminal and navigate to your projects folder
$ ~
cd ~/projects
# Create a new folder for your app
$ ~/projects
mkdir my-saas-app && cd my-saas-app
$ ~/projects/my-saas-app
build sequence
$spark build --steps

The Build Sequence

Check off each step as you complete it. Your progress is saved automatically.

[01]

Start with a proven template

No building from scratch. You begin with production-grade infrastructure that's already been battle-tested.

[02]

Connect your infrastructure

Database, hosting, security — all connected and configured. You own every piece.

[03]

Set up authentication

Users can sign up and log in. Professional-grade security with server-side session handling.

[04]

See your app running live

Real URL, real users. Your app is deployed and running on the internet.

[05]

Learn how to recover if something breaks

Things will break. That's normal. Knowing how to recover is what separates operators from learners.

$spark infra --diagram

Your Infrastructure

Every piece of infrastructure you connect today is something you own. No platform dependency. No rent extraction. No hidden costs.

Database// PostgreSQL via Supabase
connected
Auth// Supabase Auth + SSR
configured
Hosting// Vercel Edge Network
ready
Security// RLS + Server-side checks
active
$spark recovery --playbook

When Things Break

Operators don't panic when things break. They follow the playbook.

recovery-playbook.sh
# The Recovery Playbook
# =====================

# 1. IDENTIFY — What broke?
git diff HEAD~1        # See what changed
vercel logs            # Check deployment logs

# 2. ISOLATE — Stop the bleeding
vercel rollback        # Restore last working version

# 3. FIX — Address the root cause
git checkout main      # Start from clean state

# 4. VERIFY — Confirm the fix
pnpm dev               # Test locally first
vercel --prod          # Deploy when confident

# 5. DOCUMENT — Learn from it
# → Add to your team's runbook

Day 1 Complete

Tomorrow you deploy to the internet, connect Stripe for real payments, and install marketing infrastructure. By the end of Day 2, your app will be accepting money.

Day 1

Foundation

in progress
Day 2

Deploy & Monetize

Day 3

Ship & Scale