← Ship It
REFReference

Reference & appendices.

Cheat sheets, the debug-with-Claude protocol, glossary, safety & ethics, the rubric, troubleshooting, and sources.

Keep these within reach while you build — they're the stuff you'll actually reach for when something breaks or you forget how to phrase a prompt. Skim them once, then come back when you need them.

Appendix A — Teen-friendly prompting cheat sheet

Tape this to the wall. Good prompting is 80% of using AI well.

The four habits

  1. Be specific. "Make a blue button that says Join and is centered" beats "make it look good."
  2. Give context. Tell Claude what you're building and what you already have.
  3. Go step by step. "Walk me through this one step at a time and wait for me" prevents overwhelm.
  4. Ask it to explain. End with "explain what you changed and why" — every time.

Power phrases

  • "Assume I'm a total beginner."
  • "Do this one step at a time and wait for me to confirm."
  • "Show me exactly what you changed."
  • "Why did that error happen and how do I fix it?"
  • "Is there a simpler way to do this?"
  • "Don't change anything yet — first explain the plan."

Anti-patterns

  • Vague: "make it better/cooler/pop."
  • Ten requests in one breath.
  • Accepting code you can't explain at all.
  • Copy-pasting errors without reading them yourself first.

Appendix B — The "debug with Claude" protocol

When something breaks (it will), follow this so students learn to fish:

  1. Read the actual error. Out loud. Half of errors say exactly what's wrong.
  2. Find where it printed — terminal, browser console (F12), or Vercel logs.
  3. Copy the full red text.
  4. Ask Claude: "I got this error: [paste]. Here's what I was doing: [context]. What does it mean and how do I fix it? Explain before changing anything."
  5. Read the explanation, then apply the fix.
  6. Re-run and confirm. If still broken, tell Claude what changed since.

Rule: try to read the error yourself for 30 seconds before pasting it. Building that reflex is the difference between a coder and a copy-paster.

Appendix C — Glossary (plain English)

  • Terminal: a text way to command your computer.
  • Claude Code: the AI coding tool in the terminal.
  • Frontend: what the user sees (the page).
  • Backend: code that runs on the server, hidden from users.
  • Framework (Next.js): a pre-built project skeleton so you don't start from zero.
  • Localhost: the practice version of your site, only you can see it.
  • Deploy: put your site on the public internet.
  • Vercel: free host that deploys your site.
  • GitHub: cloud home for your code + its history.
  • Git commit: a named save point.
  • Database: a spreadsheet your website controls.
  • Table / row / column: sheet / entry / header.
  • Supabase: free hosted database + dashboard.
  • API route: a backend doorway your app talks to.
  • API call: asking another service to do something and getting an answer.
  • Environment variable (.env): a secret your app needs, kept out of the code.
  • Validation: checking input before trusting it.
  • Transactional email: an automatic email triggered by an action.
  • Resend: the email-sending service.

Appendix D — Safety, ethics & "don't ship your secrets"

Weave these in; don't save them for the end.

  • Secrets stay secret. API keys never go in code pushed to GitHub. Use .env. If one leaks, rotate it. (Show what a leaked key can cost.)
  • The most dangerous Supabase mistake: the service-role key bypasses Row Level Security — it can read and write everything, ignoring every policy. Use the anon (public) key in the browser/client; never expose the service-role key. It stays server-side, in .env only. This is the single most dangerous Supabase mistake for this kind of app.
  • Real people's data is a responsibility. No real personal data in practice databases. If a site ever collected real signups, people are trusting you with it.
  • AI is confidently wrong sometimes. Verify anything that matters. Never ship AI output as fact without a human check.
  • Don't trust user input or raw AI output. Validate input; constrain AI features.
  • Be kind in public. Anything live on the internet has your name on it. Build things you'd be proud to show a parent.
  • Honesty about age rules. We use tools the legit way (see Module 0). Faking your age to a service is a bad habit and can get you locked out.
  • Credit and originality. AI helps you build; the ideas and the care are yours. Don't pass off others' work; don't generate harmful or mean content.

Appendix E — Assessment rubric

Reward shipping, understanding, and debugging — not polish.

It ships

  • Beginning: Runs locally only.
  • Solid: Deployed, mostly works.
  • Strong: Live, stable, handles errors gracefully.

Understanding

  • Beginning: Can't explain the code.
  • Solid: Can explain the main parts.
  • Strong: Can explain most lines + the data flow.

Prompting

  • Beginning: Vague, one-shot.
  • Solid: Specific, iterative.
  • Strong: Specific, step-by-step, asks for explanations.

Debugging

  • Beginning: Stuck → gives up.
  • Solid: Uses the protocol with help.
  • Strong: Reads errors, isolates, fixes independently.

Data & backend

  • Beginning: No persistence.
  • Solid: Saves/reads data.
  • Strong: Clean form → API → DB flow + validation.

Craft & safety

  • Beginning: Secrets exposed / messy.
  • Solid: Secrets in .env, tidy.
  • Strong: Secure, thoughtful, kind public content.

Grade the process, not just the artifact. A student who debugged hard and shipped something simple beats one who got lucky with a flashy result they can't explain.

Appendix F — Troubleshooting (the stuff that actually goes wrong)

  • "command not found: claude" → Claude Code not installed / wrong terminal. The recommended install is the native installer (curl -fsSL https://claude.ai/install.sh | bash) or Homebrew/WinGet — none of these need Node at all. If you instead use the npm method (npm install -g @anthropic-ai/claude-code), that one requires Node 18+; install the current Node LTS for it. See the Claude Code setup docs.
  • Won't sign in / can't authenticate → Needs a paid Claude plan (Pro+); free Claude plan excludes Claude Code. Check the run model from Module 0.
  • Node too old → only relevant for the npm install method; install the current Node LTS (use nvm; don't sudo npm). The native installer avoids this entirely.
  • OAuth pop-up blocked → school network/browser; test in advance, allowlist the domains.
  • Works locally, breaks on Vercel → missing env vars in Vercel dashboard, or a build error. Read the build log, paste to Claude.
  • Supabase site "broken" after a week → free project auto-paused; un-pause in dashboard (~1 min cold start).
  • Database writes fail → Row Level Security policy; have Claude set a correct policy and explain it.
  • Emails not arriving → unverified domain, spam folder, or daily limit hit. Instructor-owned, pre-verified domain avoids most of this.
  • Secret got pushed to GitHub → rotate the key immediately, add to .gitignore, never reuse it.

Appendix G — Sources & current limits (verify before each cohort)

These were current as of June 2026. Pricing, free-tier numbers, and age rules change often — re-check the linked pages before each new group.

Age / terms (the constraint that shapes the course)

Tools, install & cost

  • Claude Code install & setup. The recommended install is the native installer (curl -fsSL https://claude.ai/install.sh | bash) or Homebrew/WinGet — no Node required. The npm method (npm install -g @anthropic-ai/claude-code) needs Node 18+; if you use it, install the current Node LTS. Claude Code setup docs · npm package
  • Claude Code requires a paid plan; Pro is $20/mo, Max $100/$200/mo. Claude pricing · Use Claude Code with Pro/Max
  • Vercel Hobby (free): ~100GB bandwidth, non-commercial, single developer, pauses at limits. Vercel Hobby plan · Vercel pricing
  • Supabase Free: 2 active projects, 500MB DB, 1GB file storage, pauses after ~7 days idle. Supabase pricing
  • Resend Free: 100 emails/day, 3,000/month; domain verification to send as your address. Resend pricing · Resend limits

For the instructor

These appendices are designed to be printed and reused across cohorts. Appendix A is a wall poster; Appendix B is the in-the-moment debugging script you run every time something breaks; Appendix E is the grading instrument referenced by the Module 8 capstone. The one thing that genuinely changes between cohorts is Appendix G — pricing, free-tier numbers, and especially the age/terms rules shift often, so re-check every linked page before each new group. Built ship-first on purpose: get a real thing live, then understand the layers underneath it. The goal isn't teens who can prompt an AI — it's teens who can prompt an AI and read what it wrote.

← All modules