The AI Clubhouse Guide to Vibe Coding
A beginner-to-intermediate field guide for turning ideas into working software with AI coding agents, without pretending the code, security, data, or deployment takes care of itself. Built from our workshops, so it goes deeper than a list of links.
Quick start
Vibe coding is steering software with language.
You describe the outcome. The AI coding agent edits files, runs commands, reads errors, and loops. Your job shifts from typing syntax to setting direction, providing context, reviewing behavior, and deciding when the result is good enough.
By the end, you should be able to:
- Explain vibe coding in plain English, including Karpathy's original meaning.
- Pick the right coding surface: chat, IDE, CLI, desktop, browser, or cloud.
- Set up a Mac or Windows machine so agents can run real commands.
- Use Codex, Claude Code, and Cursor without treating any of them like magic.
- Deploy with Vercel, store data in Supabase, and keep API keys out of source code.
- Add project rules, skills, MCP, subagents, hooks, and analytics when the work gets serious.
Describe the outcome
Say who the user is, what they need, which stack or constraints matter, and what finished means.
Ask for a plan
For non-trivial work, make the agent inspect the repo and propose a short plan before it edits files.
Build in slices
Move one route, screen, API endpoint, database table, or bug at a time. Smaller loops create cleaner recovery.
Run the work
Ask for lint, tests, type checks, migrations, browser screenshots, or deployment verification before accepting the result.
Review behavior
Use the app. Inspect the diff at a high level. Understand the risk before you ship to real users.
Definition and history
One tweet named it.
"There's a new kind of coding I call 'vibe coding', where you fully give in to the vibes, embrace exponentials, and forget that the code even exists."
Andrej Karpathy · February 2, 2025
His workflow in the same post: talk to the tool, hit Accept All without reading diffs, paste errors back in with no commentary. That strict version, never reading the code, is what the word means; if you review and test what the AI wrote, Simon Willison calls that AI-assisted development. In practice you slide along the spectrum with the stakes: full vibes for a disposable prototype, supervised agents for a weekend app, real review for anything touching users, money, or data. This guide teaches the whole spectrum.
The behavior before the name
Copilot autocomplete, ChatGPT paste-and-fix, and Cursor rebuild coding around AI.
The phrase sticks
Karpathy names the loop. Claude Code ships the same month; Codex relaunches as an agent in May.
Word of the Year
Collins Dictionary crowns "vibe coding," ten months after the tweet.
The serious version
Plans, rules files, MCP, subagents, and AI reviewing AI. The vibes stayed; guardrails arrived.
AI fundamentals
What the model is doing under the hood.
You do not need a machine learning degree to vibe code well. You do need a practical mental model for why agents are brilliant one minute and strangely wrong the next.
Tokens
Models process text in chunks called tokens. A giant prompt, pasted logs, screenshots, and selected files all compete for the same attention budget.
Context window
The context window is everything the model can see right now: your prompt, files, instructions, images, command output, and earlier conversation.
Reasoning
Reasoning models spend more compute thinking through a task. Use them for architecture, debugging, security review, and product tradeoffs.
Tools
Tools let an agent leave chat and act: read files, edit code, run tests, search docs, inspect a browser, query a database, or call an API.
Hallucination
A hallucination is a confident wrong answer. Treat every AI result as a draft until it runs, tests, and survives inspection.
Agents
An agent is a model plus tools plus a loop. It can plan, act, observe the result, and continue until the task is finished or blocked.
Model families, and what to actually pick
Three labs make the frontier models you'll use. Anthropic's Claude family: Haiku (fast, cheap), Sonnet (the everyday workhorse), Opus (the heavyweight). OpenAI's GPT family, which powers Codex. Google's Gemini. Every coding tool lets you switch between models from a dropdown or slash command.
The practical rule from our workshopSonnet for almost everything. Opus when you're coding something ambitious, hard refactors, subtle bugs, architecture. Haiku rarely, outside speed-critical edge cases. Don't chase leaderboards; the reshuffle every few months matters far less than your workflow.
The harness matters as much as the brainA raw model can only write text. What makes modern tools feel magical is the agent harness around the model: the loop that reads your files, runs your code, sees the error, and fixes it without you pasting anything. That's why an agent with a mid-tier model routinely beats copy-pasting into the smartest chat box on earth. When you compare tools, you're comparing harnesses.
What plans costFree tiers hit usage limits fast, fine for a taste, frustrating for a project. The standard on-ramp is about $20/month: Claude Pro (covers Claude Code), ChatGPT Plus (covers Codex), or Cursor Pro. Heavier tiers ($100–$200) buy headroom for daily, long-session work; see the Q&A for when that math makes sense.
What models are good at
- Turning rough intent into a first working draft.
- Explaining unfamiliar code, APIs, and errors.
- Applying patterns across multiple files.
- Generating tests, fixtures, migrations, and docs.
- Finding likely causes when you provide logs and reproduction steps.
Where you stay responsible
- Choosing what should exist and what should not.
- Keeping secrets private and data access narrow.
- Testing edge cases the model did not imagine.
- Understanding product tradeoffs and user impact.
- Shipping only after the deployed app behaves correctly.
The coding toolbelt
Claude Code, Codex, and Cursor, in real depth.
These three overlap heavily, and plenty of builders run two side by side. Here is what each one actually is, the features that matter, and how people combine them, at the level of detail we use in our workshops.
Claude Code
An agent, not an editor. You open a terminal in a project folder, type claude, and talk. It reads the whole codebase, plans, edits files across the project, runs commands and tests, and drives git, committing, branching, opening pull requests. Non-developers ship working software with it every day; it's the tool we teach most at AI Clubhouse.
Plan mode (Shift+Tab): writes a spec you approve before it touches code. /init: studies your project and writes a CLAUDE.md memory file. /compact: compresses a long session so quality doesn't degrade. Permission modes: dial autonomy from ask-everything to auto-accept. Worktrees: built-in UI for running parallel sessions on the same repo. Plus skills, hooks, MCP, and subagents, section 08 covers each one properly.
The same engine runs in the terminal, a VS Code extension (inline diffs in your editor), the Claude desktop app (visual diff review, parallel sessions), and the browser at claude.ai/code, sessions can move between them, including to your phone. Requires Claude Pro ($20/mo) or an API key.
Codex
OpenAI's coding agent, same shape as Claude Code: a CLI, an IDE extension, and its distinctive strength, a cloud mode where tasks run on OpenAI's servers in parallel. Fire off three bugs from your phone, review three pull requests after lunch. Included with ChatGPT Plus, so many people already own it without realizing.
The features that matter/goal: where plan mode executes a spec once, goal mode keeps looping until the objective is done, self-compacting its context, it will run for hours on an ambitious task. AGENTS.md: its project memory file, same idea as CLAUDE.md. Code review: point it at a branch and it reviews like a colleague. Cloud sessions: kick off work that survives your laptop closing.
Codex's own docs tell you to create git checkpoints before and after each task. Good advice for every agent, it's workflow step 5 for a reason.
Cursor
A full code editor (built on the bones of VS Code) with AI woven into every surface. Three ways in: Tab, autocomplete that predicts your next edit; Inline Edit (Cmd+K), select code and describe the change; Agent (Cmd+I), the full describe-a-feature experience with checkpoints you can roll back to, separate from git. Plan Mode (Shift+Tab) makes it research and propose before executing. Rules (.cursor/rules) are its project memory.
Everything is visible, file tree, diffs, terminal, which makes Cursor the gentlest bridge between pure vibes and understanding your own project. Several of our power users eventually found that Codex CLI + Claude Code covered what Cursor did for them and let the subscription go; others live in it daily. The move that gets you both: run Claude Code inside Cursor's built-in terminal. Editor comfort, agent horsepower, one setup.
Cmd+I: "Explain this codebase: main entry points, key modules, where the styling lives. Then suggest three small, safe improvements and implement the one I pick."How builders actually combine them
One split that's been working for our power users: Codex for the bulk of coding tasks, Claude for design and frontend iteration. They even chain: Codex can invoke Claude mid-session for a design review and pull the result back into the build.
Git worktrees are the underrated unlock. Multiple copies of your repo checked out at once, so several agent sessions build different features in parallel and merge when ready. Claude Code has worktree UI built in. When you hear someone say they "manage a team of agents," this is the mechanic.
And the browser builders, Claude Design (claude.ai/design), Lovable, Bolt, v0, Replit, are the zero-setup on-ramp: great for prototypes and landing pages, with a ceiling you'll hit within weeks when you want a custom backend or code you can take anywhere. Claude Design hands off directly to Claude Code with one command, we've run that exact flow live at a workshop and deployed the result before the session ended.
Machine setup
Set up your computer so the agent can actually build.
Most beginner failures are environment failures: missing Git, old Node, commands run in the wrong folder, secrets pasted into source code. Fifteen minutes here prevents all of it. Three ingredients before the AI tools: a terminal you can find, Git (your undo button), and Node.js (the runtime most web projects need).
Accounts first
1. Sign up at claude.ai and upgrade to Pro ($20/mo), the free tier hits limits fast, or at chatgpt.com if you're going the Codex route (Plus includes it). 2. Create a free GitHub account, it's where your code lives online and the bridge to hosting. 3. Optionally grab the Claude desktop app from claude.com/download , it bundles chat, Cowork, and Claude Code in one place.
Setting up on a Mac
Press Cmd+Space, type "Terminal", hit enter. You'll mostly paste commands into it, that counts as using it.
Paste this and accept the popup (installs Apple's dev tools, Git included), then install Node LTS from nodejs.org or via Homebrew:
xcode-select --install
brew install node # or download the LTS installer from nodejs.org
node -v && npm -v # both should print versions# Claude Code
curl -fsSL https://claude.ai/install.sh | bash
# Codex (optional second agent)
npm install -g @openai/codexCursor: download from cursor.com and drag to Applications (macOS 12+).
4 · Introduce yourself to Git, then gogit config --global user.name "Your Name"
git config --global user.email "you@example.com"
mkdir my-first-app && cd my-first-app
claude # log in with your Claude account when promptedThat's the last Git command you memorize. From here, tell the agent "commit this" or "push this to GitHub" and it runs Git for you.
Setting up on Windows
Press the Windows key, type "PowerShell", hit enter. Your prompt should start with PS C:\, that's how you know you're in PowerShell, not the older CMD (several install commands differ between the two).
winget install Git.Git
winget install OpenJS.NodeJS.LTS
# close and reopen PowerShell, then:
node -v; npm -vGit for Windows matters more than it looks: it gives agents a proper bash shell to work with. Without it, Claude Code falls back to PowerShell as its shell.
3 · Install your agent# Claude Code
irm https://claude.ai/install.ps1 | iex
# Codex (optional second agent)
npm install -g @openai/codexCursor: download the installer from cursor.com (Windows 10+).
4 · Optional: WSL for the smoothest rideMost tutorials assume a Unix-style system. wsl --install + a reboot gives you a real Ubuntu terminal inside Windows. Not required on day one; worth it once you're hooked. Keep projects in a normal user folder, not a cloud-synced folder with aggressive file locking.
git config --global user.name "Your Name"
git config --global user.email "you@example.com"
mkdir my-first-app; cd my-first-app
claudePrompting and workflow
The quality of your prompt matters less than the quality of your loop.
A good prompt gives the agent enough context to make the next decision. A good loop keeps the agent honest. Use the prompts below as patterns, not scripts to blindly copy.
Spec prompt
I want to build a simple booking page for a private AI workshop. Audience: startup founders. Stack: Next.js. Start by asking up to 5 clarifying questions, then propose the route structure, data model, and implementation plan.Implementation prompt
Implement the approved plan in small steps. Follow the existing design system. After each major step, run lint and summarize what changed, what was verified, and what still needs review.Debug prompt
The page loads but form submission fails. Read the route handler, client form, env validation, and logs. Identify the root cause first. Do not change code until you can explain the failure.Review prompt
Review this branch against main for bugs, security issues, missing tests, and deployment risk. Prioritize findings with file references. Skip style opinions unless they hide a real bug.The five habits that separate smooth sessions from painful ones
Shift+Tab before anything that touches more than one file. Reading a 20-line plan is the cheapest debugging you will ever do.
Not a paraphrase, the raw wall of red text, with no commentary. This is straight from Karpathy's original workflow and it still fixes most things. For visual bugs, paste a screenshot instead; agents read images.
Commit checkpoints constantlyAfter every working milestone: "commit this with a good message." A checkpoint makes any future disaster a "roll back to the last commit" away, it's the safety net that makes full-vibes experimentation rational.
Watch your contextOne chat per task. /compact at ~80% full. A model with a foggy memory writes foggy code.
1) Full error pasted. 2) Fresh chat, clean description. 3) "Add logging and find the root cause before changing code." 4) Roll back to the last good commit, take a smaller step. 5) Second opinion from a different model. In that order.
Rules that save projects
- One project folder per app. One Git branch per experiment.
- Never paste secret keys into chat unless the tool is explicitly designed to store them securely.
- Ask the agent to explain assumptions before a large edit.
- Use screenshots for visual changes and logs for runtime failures.
- When the agent gets stuck, ask for root-cause analysis instead of random fixes.
- Before deploy, run the app from a clean terminal and test the user path yourself.
Hosting, data, and sharing
Getting online is part of the skill.
An app on your laptop is a diary entry. The magic moment is a URL you can text to a friend. The standard beginner stack: Vercel for hosting, Supabase for accounts and data, environment variables for the secrets that connect them.
Vercel: your app on the internet in minutes
Vercel takes a web project and puts it on a live URL, no servers to configure. The hobby tier is free and comfortably covers personal projects.
The workflow worth learningSign up with your GitHub account → Add New Project → import your repo. From then on it's automatic: every push to GitHub deploys itself. The main branch goes to your production URL; every experiment branch gets its own private preview URL, share previews for feedback, promote to production when it's right. This page you're reading ships exactly this way.
Or just ask the agentPush this project to a new GitHub repo and deploy it to Vercel. Walk me through any logins you need.Custom domains are a settings-page affair: buy one (Vercel sells them, or Namecheap/Porkbun), add it under Project → Settings → Domains, done in ten minutes.
Supabase: accounts, data, and uploads without a backend degree
The moment your app needs to remember things, user accounts, saved entries, uploaded images, Supabase is the beginner-friendly answer: a real Postgres database, login (email, Google, magic links), and file storage in one dashboard, free tier included.
How you'll actually use itCreate a free project at supabase.com, then hand the wiring to your agent: "Add Supabase to this app: sign-in with email, store each user's entries in the database." It writes the integration; you paste in two values from Project Settings → API (a project URL and an API key, next block explains where those live safely).
The one thing you must not skipRow Level Security. It's the database rule that says users can only see their own rows. Vibe-coded apps that leaked strangers' data made real headlines in 2025, and they almost always skipped RLS. The insurance costs one prompt:
Enable Row Level Security on every table and write policies so users can only read and write their own data. Then try to access another user's data and prove it fails.API keys: what they are and how not to get burned
An API key is a long secret string (sk-ant-api03-x7Kd…) that proves to a service, Anthropic, OpenAI, Supabase, Stripe, that a request comes from your account. Anything done with your key is billed to you and acts as you: a credit card number that can also read your data.
Secrets go in .env.local in your project, and that file is listed in .gitignore so it never reaches GitHub. Your code reads keys from the environment; they are never typed into it:
# .env.local — never committed to git
ANTHROPIC_API_KEY=sk-ant-api03-...
SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOi...When you deploy, paste the same values into Vercel → Project → Settings → Environment Variables, that's how the live app gets its secrets without them touching GitHub. In Next.js, only values prefixed NEXT_PUBLIC_ reach the browser; everything else stays server-side.
1. Never in frontend code, anything shipped to the browser is view-source public; AI features belong in a server route that holds the key. 2. Set a spending limit in every provider's billing page the day you create a key. 3. Rotate on leak, revoke and reissue in the dashboard; scanner bots find leaked keys in minutes, not days.
Analytics: know if anyone's actually using it
Vercel Analytics is the path of least resistance if you host on Vercel: toggle it on in the project dashboard, tell your agent "add Vercel Analytics," and you have visitors and page views with zero cookie banners. Google Analytics 4 is the free industry default with a clunkier dashboard. PostHog is the upgrade when you care about behavior, which buttons get clicked, where users drop off, session replays, with a generous free tier.
Minimum launch checklist
Intermediate systems
Rules, skills, MCP, subagents, and hooks turn prompting into a system.
Beginners ask the model to do everything in one chat. Intermediates build an environment where the agent has the right context, tools, and boundaries before the work starts. This is the material we spend the most time on in workshops.
CLAUDE.md, AGENTS.md, and Cursor rules
A markdown file at your project root, read at the start of every session, it's how you stop repeating yourself. Claude Code reads CLAUDE.md, Codex reads AGENTS.md, Cursor reads .cursor/rules. Put in: what the project is, commands to run, coding conventions, architecture boundaries, and things the agent should never touch. Run /init in Claude Code and it writes one for you by studying the project.
Skills and slash commands
Skills turn "I keep typing the same long prompt" into "it already knows." A skill is a folder, not a file: inside is a SKILL.md with YAML frontmatter (a name and a description) plus the instructions, templates, or scripts the skill uses. On disk they live at ~/.claude/skills/.
The description field is what the agent matches against when deciding whether to load a skill. Write it like a job posting: "use this skill when the user asks for a PRD, BRD, or spec doc." Specific descriptions trigger reliably; vague ones don't.
How they fireAutomatically, the agent matches your prompt against active skill descriptions and loads the right one. Or manually as a slash command (/review-pr, /deploy), the slash name matches the skill's frontmatter name. Built-ins like /init and /compact work the same way.
Easiest path: just describe the skill you want in chat and the agent builds the folder itself, interviewing you for the details. Because skills are folders, sharing is a zip file or a git repo teammates clone into their own skills directory. Community index: awesome-claude-skills.
MCP: plug your agent into everything else
The Model Context Protocol is an open standard (Anthropic released it; everyone adopted it) that lets agents talk to outside tools and data. Think USB for AI: one connector shape, thousands of devices. Without MCP you copy-paste between your tools and your agent; with it, the agent sees the real thing live.
Concrete examplesAdd the Supabase MCP server and the agent inspects your actual database schema and rows. Vercel's lets it check deployments and build logs. There are servers for GitHub, Slack, Figma, Stripe, Notion, browsers, essentially everything. Adding one is a single command:
claude mcp add --transport http supabase https://mcp.supabase.com/mcpCursor and Codex support the same servers. One workshop tip that saves context: prefer "load tools when needed" over always-on connectors, every active tool eats context window.
Subagents and git worktrees
Subagents are helpers your main agent spawns for focused jobs, one explores the codebase while another writes tests, each with its own clean context window. Claude Code does this automatically on big tasks; you can also define custom ones (a code reviewer, a security checker) that fire on demand.
Git worktrees are the multiplayer unlock: several copies of the repo checked out at once so multiple agent sessions build different features in parallel without stepping on each other, then merge. Claude Code ships worktree UI; at our Engineering Deep Dive, one speaker runs Claude Code, Codex, and Gemini this way overnight, on the logic that a subscription is a 24-hour employee you shouldn't send home at 5pm.
Hooks and permission modes
Hooks run deterministic actions around agent events, auto-format every edited file, run lint before any commit, block a risky command. They're better than prompt reminders because they always happen. Permission modes are the trust dial: start with ask-everything, loosen to auto-accept edits as trust builds, and keep confirmations for anything destructive or outward-facing. (The fully-hands-off end is YOLO mode, see the Q&A for the honest tradeoff.)
Scheduled tasks and recurring agents
Once something works, make it recurring: type /schedule in Claude Code (or the Claude desktop app) and describe the cadence, daily dependency audit, morning PR review, weekly analytics summary. Desktop scheduled tasks run on your machine, so the laptop has to be awake; cloud routines run on managed infrastructure and don't care. It's the difference between an agent you use and an agent that works for you.
Power Q&A
The questions everyone asks, answered the way we answer them in the room.
Pulled from our Power User workshop and Engineering Deep Dive Q&A sessions, including the contested ones.
Which tool should I actually start with?
If you already pay for Claude Pro, start with Claude Code. If you already pay for ChatGPT Plus, start with Codex, it's included. If the terminal makes you nervous, install Cursor and run one of the CLI agents inside its built-in terminal so you can see the files change while you work. There is no wrong pick; the loop is the same and the skills transfer.
What we tell workshop attendees: don't buy three subscriptions on day one. Pick one, ship two or three small projects, and add a second tool when you hit a real limitation, usually parallel work or a second opinion on a hard bug.
Which model should I pick inside the tool?
The advice from our Power User workshop still holds: Sonnet for almost everything, day-to-day building, writing, research. Opus when you're coding something ambitious, gnarly refactors, subtle bugs, architecture decisions. Haiku is fast but rarely the right choice outside specific edge cases.
Don't agonize over leaderboards. Rankings reshuffle every couple of months, and at our Engineering Deep Dive, Dennis (a CTO who rebuilt his 15-person company around Claude Code) put a number on it: switching models buys you maybe 1.1–1.2x. Restructuring your workflow around agents buys 2–3x. The loop, not the leaderboard.
What's plan mode, and when do I use it?
Plan mode runs before any complex build. Instead of executing immediately, the agent reads the relevant parts of your codebase and writes a spec of what it intends to do. You review, push back, then let it execute. In Claude Code press Shift+Tab; Cursor has its own plan mode; Codex plans when you ask it to. Skipping plan mode on a non-trivial feature is the most common reason you end up with code that "almost works." Default to it for anything bigger than a one-file change.
What about goal mode / long-running agents?
Where plan mode is "execute this spec once," Codex's /goal is "keep going until the objective is done." It self-loops, auto-compacts its own context, and will run for hours on an ambitious task. Power users take this further: at our Engineering Deep Dive, Jeffrey runs Claude Code, Codex, and Gemini in parallel overnight, his framing was "imagine you hired an engineer for 24 hours and only gave them 8 hours of work." You don't need that on week one. For normal features, plan + execute is enough.
What's YOLO mode, and should I use it?
By default agents ask permission before running commands or editing files. YOLO mode is the community name for turning those confirmations off and letting the agent execute everything immediately. The productivity gain is real; so is the risk of a model misfiring on your machine.
The balance we recommend: auto-approve reads, local edits, and dev servers; keep confirmations on for anything destructive or outward-facing, file deletes, sending emails, deploys, spending money. Your git checkpoints are what make even that loosening safe.
How do I manage context when sessions get long?
One chat per topic, don't make a single conversation carry six tasks. When you hit roughly 80% of the context window in Claude Code or Codex, run /compact: it summarizes the history and continues fresh while preserving the important state. Past 80%, output quality drops fast and the model starts inventing things. If a session gets weird, a fresh chat with a clean description of the problem beats fighting a polluted one.
Do vibe coders still write tests?
Contested, and worth hearing both sides. At our Engineering Deep Dive, Dennis told a room of engineers "we basically stopped writing tests", his argument being that tests were a contract protecting your code from the next engineer, and the next entity reading your codebase now holds the whole thing in a million-token context window. His company ships a high-volume trading platform, so this wasn't a hobbyist take. The room pushed back anyway.
Our beginner-safe version: you don't need to hand-write tests, but you should ask the agent to write and run them for anything that handles money, auth, or user data. Tests are cheap when the AI writes them, and they catch the regressions you won't notice by clicking around.
Do I actually need to read the code?
The honest workshop answer: AI coding is now good enough that most builders don't read most of the code, they read the plan, watch the behavior, and dive into the code only when something specific breaks. That's Karpathy's original vibe, grown up. The exception is the finish line: before anything public holds real user data, run a security review (there's a prompt for it in section 07) and read what it flags.
When does a $100+ plan beat the $20 plan?
Pro ($20) covers learning and evening projects comfortably. The Max tier ($100+) buys headroom for long Claude Code sessions, big contexts, and parallel work, it starts making sense when you're coding most days. Codex's heavier tiers work the same way. If you're blowing through limits mid-project, most tools now have a pay-as-you-go overage toggle, cheaper than upgrading a tier for one heavy week. Start at $20; let your usage tell you when to move.
A 7-day learning path
One week to become useful, then keep building.
Learn the language of web apps
Pages, components, APIs, databases, auth, hosting, env vars, and Git.
Set up your machine
Install Git, Node, one editor, one CLI agent, and create your first local project.
Build a tiny app
Use a plan-first workflow to create a single-route app with a form and result page.
Add data
Connect Supabase, store one record type, and turn on Row Level Security.
Deploy a preview
Push to GitHub, deploy on Vercel, set env vars, and share a preview URL.
Instrument behavior
Add one analytics event, test the funnel, and fix the biggest point of confusion.
Refactor and document
Create project instructions, ask for review, clean dead code, and write a README.
Sources and next steps
Keep the guide current by returning to primary docs.
AI coding tools change quickly. The concepts above are stable, but commands, product names, permission modes, and pricing shift. Verify setup instructions against official docs before teaching or deploying.
Much of this guide is repurposed from AI Clubhouse workshop material, our Claude Power User workshop and our Engineering Deep Dive, plus the beginner teaching style of Maggie Wiedner's oops it works fundamentals page.