Intro to Vibe Coding

Challenge 083–5 hours, spread over days (save points make it resumable)

Capstone: A Product, Not a Page

Mission. The whole 201 stack, end to end: an app with accounts, memory, and (optionally) money β€” shipped with previews, backups, and a real user who isn't you.

😱 The story

The 101 capstone made you a builder: one folder, one page, one human delighted. This capstone makes you an operator: a product with users, data it must not lose, money it must not misplace, and a running system someone depends on. The difference between the two isn't talent. It's that an operator runs the whole loop β€” build, protect, watch, recover β€” and that loop is exactly what this course installed. Time to run it all at once.

πŸ“‹ The menu

Pick something that genuinely needs the stack β€” memory, accounts, and ideally one payment. The classics:

  • The tiny SaaS β€” a tracker (habits, plants, invoices) with sign-in, per-user data, free tier + $2 "pro" tier
  • The paid digital good β€” a guide/template/checklist behind a Stripe checkout, delivered on payment (webhook unlocks it)
  • The booking page β€” for a real person's services: accounts, requests saved to the database, a small deposit via Stripe
  • The team tool β€” one shared list/dashboard for a real group you're in, sign-in required

Pick the one a real person needs. In 201, "someone else depends on this" is a feature, not a bug β€” it's what makes you run the safety gears.


The build β€” phases

Phase 1 β€” Intent on paper (15 min)

Before the AI: who is it for, what does a user do (one primary action), what's the data (which tables), what's the money (free / paid / deposit), and β€” new for 201 β€” what must never leak or be lost (secrets, user data, orders). Write it. This page becomes your AGENTS.md seed.

Phase 2 β€” Map and house rules first (15 min)

New folder, new AGENTS.md β€” now with the 201 rules baked in:

# House rules (201)
- Tour the project map before any non-trivial change; say which files
  you'll touch
- One small change at a time; run the tests after each accepted change
- Secrets: never in code, chat, or git β€” .env locally, host panel on the
  server; use the no-peek pattern, I paste values myself
- Auth: managed only (Supabase). Payments: Stripe-hosted checkout only.
  Card numbers never touch this app
- Before I merge anything to main: preview first, tests green

Phase 3 β€” Build the skeleton, then the organs (60–90 min)

Order matters now, because the parts depend on each other:

  1. Memory first (Challenge 1): tables designed from Phase 1's "what's the data". Check the schema in plain English before building on it.
  2. Lock second (Challenge 2): sign-in, then RLS before real data arrives. The bouncer goes on before the party, not after.
  3. Money third, in test mode (Challenge 3): product, checkout, webhook β€” all test-mode until Phase 5.
  4. Any API ingredient (Challenge 4): middleman only, keys on the server, graceful failure, usage caps on day one.
  5. Small bites throughout, tests growing alongside β€” every must-always- work becomes a check, and "run the tests" closes every bite.

The rhythm, as always: ask β†’ diff β†’ try β†’ tests β†’ commit β€” with the 201 addition: push to a branch and look at the preview, not just localhost.

Phase 4 β€” Grow it without losing the map (30–60 min)

This is where 201 projects die: feature four arrives and nobody remembers where feature one lives. Countermeasures, all mandatory:

  • The project map updates with every moving day (Challenge 5)
  • Debugging stays evidence-based: two witnesses, exact text (Challenge 6)
  • Rejection stays free: every scope creep gets "restore and re-ask smaller"
  • IDEAS.md eats the "also add…" avalanche alive

Checkpoint: "Would I let a stranger sign up and pay right now β€” and could I recover from a disaster tonight?" That's v1.

Phase 5 β€” The pre-flight, 201 edition (30 min)

The 101 checklist, wearing its grown-up shoes:

  • Git clean, log reads like a story, everything pushed
  • Tests green β€” no green, no ship
  • Secrets audit: nothing in code or git; server keys in the host panel; no-peek respected everywhere
  • RLS on, and you attacked it (impostor rows refused)
  • Stripe: tested end-to-end; go-live checklist done if selling for real
  • Spend caps + usage alerts on every paid service
  • Backup taken today; rollback rehearsed today (break a branch, not prod)
  • RUNBOOK.md updated for this product's stack
  • The skeptic pass: "Review this like a paranoid senior engineer β€” what leaks, what breaks, what embarrasses?"

Phase 6 β€” Ship (30 min)

Merge to main, watch the deploy, open production on a phone. Then the 201 moment the 101 never had: the rollback you don't need β€” knowing the reverse gear is there and tested while everything works. Calm is the feature.

Phase 7 β€” The human test, real edition (ongoing)

One real user (not your mom β€” someone who'd actually use it). Watch them. Fix the top confusion, re-ship via preview. If you take payments: their real receipt is the real milestone β€” and your first refund policy gets written the day their first "oops" email arrives. (It will. Be kind; refunds are marketing.)

Then post the product to the graduation thread β€” live link, one sentence, hardest bug. That thread is the course's hall of fame, and 201 graduates are its engineers.


🏁 The Operator's Checklist (print this one)

  1. One folder per project; the map lives in README + AGENTS.md and is true
  2. Memory first, bouncer before the party (RLS before real data)
  3. Secrets: no-peek, drawer locally, host panel on the server, caps on day one
  4. Test keys until it works; live keys only with the go-live checklist
  5. Cards never touch the app; Stripe hosts the register
  6. Middleman for every ingredient; timeouts and polite failures always
  7. Small bites β†’ diff β†’ preview β†’ tests β†’ commit; no green, no merge
  8. Prod is sacred: nothing arrives without a rehearsal, nothing stays broken without a rollback
  9. Backups on a schedule that isn't "never"; restore rehearsed in daylight
  10. Day You always leaves Night You a RUNBOOK

βœ… You passed when…

  • A stranger signed up, and their data is theirs alone
  • The app survived your own three-act disaster drill (missing key, wrong path, crash) with polite manners
  • Money moved (or the full test-mode loop did), and the webhook recorded it
  • You shipped a real update via previewβ†’merge after the launch
  • You have taken a backup and rehearsed a rollback on the live project
  • A real human depends on it β€” and so does your RUNBOOK
  • The product is in the graduation thread

πŸŽ“ Where to go next

  • Watch it live: your analytics (visits), Stripe dashboard (money), Supabase (memory), Vercel (uptime) β€” four panes, one product
  • "Automate your boring work" β€” the next track: AI agents that handle files, reports, and schedules. Bring your requests to the planning thread
  • Contribute: you can now read a project's map, fork a repo, and send a pull request. Open source is a door you know how to knock on
  • The real secret: 101 taught you to direct an intern. 201 taught you to operate a system. Both were the same loop, over and over: brief, small bites, save points, verify, ship β€” and now: rehearse, back up, runbook, recover. Keep the loop. It scales.

πŸ†˜ When it goes wrong

  • Mid-build overwhelm: "this is now a REAL system." Yes β€” and you have the gears. Save point, map, runbook. Overwhelm shrinks to the size of the next small bite.
  • A real user hits a real bug. Evidence template, two witnesses, exact text. You have rehearsed this. Communicate kindly and visibly: "found, fixing, shipped" beats silence every time.
  • Money goes weird (double charge, failed webhook). Stop, don't hack. Stripe's dashboard is truth; reconcile there. Refund generously first, diagnose second β€” trust is the actual product.
  • You're afraid to touch the live app. Then a gear is missing: preview deploys, tests, backup, rollback β€” rehearsed. Fear isn't a sign to stop; it's a sign a gear needs installing.
  • Time's up, it's not done. Cut scope, not gears. A smaller product with the full loop beats a bigger one with the loop "to do later." Later is where 2am lives.