Practical Vibecoding

What you'll be able to do

• Set up and operate Claude Code, Codex, and Cursor, and choose between them per task
• Write specifications with non-goals and checkable acceptance criteria
• Curate context deliberately instead of attaching everything
• Debug from runtime evidence rather than by re-prompting
• Route work to the right model tier and defend the resulting bill

Curriculum

10 modules · 11h of content

1. Module 1 · The Vibecoding Loop

   45m

   What these tools actually do, the four-stage loop that governs every session with one, and why two identical prompts never produce identical code. Sets the vocabulary the rest of the course uses.

   After this module you can

   • • Name the four stages of the vibecoding loop and say which two a human owns
   • • Explain why a spec must define success criteria rather than describe a specific output
   • • Predict which parts of a generated result will vary between runs and which will not

   What vibecoding is, and what it is not

   • LabVibecoding is delegation, not dictation8m
   • LabIntent → Generation → Verification → Refinement10m

   Stochasticity: the same prompt does not replay

   • Interactive lessonWhy your prompt will never run twice8m
   • LabLab: the blue website experiment12m

   Module 1 check

   • QuizModule 1 graded quiz7m

2. Module 2 · Claude Code: Setup and Operation

   1h 30m

   Install and authenticate Claude Code, give it standing project context through CLAUDE.md, choose a permission mode deliberately, and supervise long agentic runs with plan mode and checkpoints.

   After this module you can

   • • Install, authenticate, and run a first Claude Code session in a real repository
   • • Author a CLAUDE.md that removes the conventions a model would otherwise re-guess every session
   • • Choose a permission mode from the blast radius of the task, and state when bypass mode is defensible
   • • Interrupt and re-steer a long agent run instead of unwinding it afterwards

   Install, authenticate, first session

   • LabFrom zero to a working session10m

   CLAUDE.md: standing project context

   • Interactive lessonThe file that stops the model re-guessing your conventions12m
   • LabLab: author a CLAUDE.md for a repository you own20m

   Permission modes and blast radius

   • LabChoosing how much authority to delegate10m

   Supervising long runs

   • LabPlan mode, subagents, and checkpoints12m
   • LabLab: drive a multi-file change end to end18m

   Module 2 check

   • QuizModule 2 graded quiz8m

3. Module 3 · Codex: Setup and Operation

   1h 15m

   Install and authenticate Codex, give it repo context through AGENTS.md, understand the difference between local and detached cloud execution, and review the diffs it hands back without rubber-stamping them.

   After this module you can

   • • Install and authenticate the Codex CLI and run a first task against a repository
   • • Write an AGENTS.md and explain how it differs in scope from a tool-specific rules file
   • • Choose between local and cloud execution from the properties of the task
   • • Review a detached agent diff at the right altitude instead of reading it line by line

   Install, authenticate, first task

   • LabGetting Codex running8m

   AGENTS.md: portable repo instructions

   • Interactive lessonOne instruction file, many agents12m

   Local versus detached execution

   • LabWatching versus dispatching10m
   • LabLab: dispatch a task to a sandboxed repository20m

   Reviewing what comes back

   • LabReviewing a detached diff without rubber-stamping it10m
   • Interactive lessonWhen Codex is the right tool8m

   Module 3 check

   • QuizModule 3 graded quiz7m

4. Module 4 · Cursor: Setup and Operation

   1h 15m

   Set up Cursor and its codebase index, write Project Rules, and, the part most users skip, choose deliberately between Tab, inline edit, and Agent, which are three different amounts of delegated authority wearing one interface.

   After this module you can

   • • Set up Cursor with a working codebase index and a configured model picker
   • • Write Project Rules and scope them so they apply where they should and nowhere else
   • • Choose between Tab, inline edit, and Agent from the shape of the edit rather than from habit
   • • Steer context deliberately with @-mentions instead of trusting automatic retrieval
   • • Select among Cursor, Claude Code, and Codex for a given task and defend the choice

   Setup, indexing, and models

   • LabInstall, index, and pick your models8m

   Project Rules

   • Interactive lessonRules that apply where they should12m
   • LabLab: scoped rules and deliberate context20m

   Tab, inline edit, and Agent

   • LabThree tools, three amounts of authority12m
   • LabReviewing before accept8m

   Choosing among the three tools

   • Interactive lessonCursor, Claude Code, or Codex?8m

   Module 4 check

   • QuizModule 4 graded quiz7m

5. Module 5 · GitHub Copilot: Past Autocomplete

   1h

   Most people run Copilot as fancy autocomplete and stop there. Move it up the delegation ladder: agent sessions that edit across files, an approval model you set on purpose, and custom instructions that carry your conventions into every request.

   After this module you can

   • • Move between inline completion, chat, and agent sessions from the shape of the work rather than from habit
   • • Configure approvals so routine tool calls run unattended and consequential ones still stop for you
   • • Write repository custom instructions, and recognise them as the same mechanism as Claude Code memory and Cursor rules
   • • Review an agent session honestly through the changed-files diff instead of accepting a summary
   • • Say when Copilot is the right tool and when a terminal agent beats it

   The delegation ladder

   • LabCompletion, chat, and agents are three different jobs10m
   • Interactive lessonWhen the cheapest surface is the wrong one7m

   Approvals and how much authority to grant

   • LabSetting the approval model on purpose10m
   • LabWrite your own allow list14m

   Custom instructions

   • LabRepository instructions, and the idea behind all three tools9m
   • QuizSame idea, three names4m

   Choosing Copilot

   • Interactive lessonWhen it wins, and when a terminal agent beats it6m

6. Module 6 · Prompting and Specification Writing

   1h 30m

   The durable half of the skill. Structure a prompt so it does not depend on cleverness, write a PRD a model can execute against, use few-shot and chain-of-thought deliberately rather than superstitiously, and write acceptance criteria that survive sampling variance.

   After this module you can

   • • Apply the four-part check: role, task, constraints, output format, to any prompt
   • • Write a PRD with must-haves, non-goals, and acceptance criteria a model can execute against
   • • Choose few-shot or chain-of-thought based on the failure you are actually seeing
   • • Write non-goals that prevent unrequested scaffolding before it happens
   • • Convert a vague request into criteria that are checkable in under a minute

   Structure, not cleverness

   • LabThe four-part check12m

   Specifications a model can execute

   • Interactive lessonThe PRD skeleton15m
   • LabLab: rewrite three vague prompts as specifications20m

   Few-shot, chain-of-thought, and non-goals

   • LabTwo techniques, used deliberately12m
   • LabNon-goals: the highest-leverage line you can write8m
   • LabLab: acceptance criteria that are actually checkable15m

   Module 5 check

   • QuizModule 5 graded quiz8m

7. Module 7 · Context Engineering

   1h

   More context is not better. Learn what context rot is, how to curate the files that actually matter, when standing rules beat per-prompt attachments, and how to cut a bloated prompt without losing fidelity.

   After this module you can

   • • Explain context rot and recognise its symptoms in a degrading session
   • • Select the minimum file set that supports a task, and justify each exclusion
   • • Decide whether a piece of context belongs in a rules file, a prompt, or neither
   • • Cut a bloated prompt substantially without degrading the result

   Why more context is not better

   • LabContext rot10m
   • Interactive lessonCurating the file set12m

   Where context should live

   • LabRules, prompts, and the cost of "always"10m
   • LabLab: cut a bloated prompt by 70%20m

   Module 6 check

   • QuizModule 6 graded quiz8m

8. Module 8 · Debugging and Verifying AI Output

   1h 15m

   The stage teams skip. Read the evidence before re-prompting, recognise AI slop for what it is, debug a broken app from console output alone, and use multi-model validation where the stakes justify the extra minute.

   After this module you can

   • • Read console output, stack traces, and network logs before issuing a new prompt
   • • Refine with a named symptom rather than a restated request
   • • Recognise the characteristic shapes of AI slop in a diff
   • • Debug a failure using runtime evidence rather than guesswork
   • • Decide when a question is worth asking of two different models

   Evidence before re-prompting

   • LabRead the console first12m
   • Interactive lessonThe evidence loop12m

   AI slop

   • LabHow AI goes wrong, and what it looks like10m
   • LabLab: debug from console output alone25m

   Multi-model validation

   • LabAsking the same question twice8m

   Module 7 check

   • QuizModule 7 graded quiz8m

9. Module 9 · Model Routing and Cost Control

   45m

   Frontier models for hard problems, cheap models for easy ones, stated as a principle everyone agrees with and almost nobody implements. Build a routing table your team will actually follow, and learn to defend the resulting bill.

   After this module you can

   • • Route a task by blast radius and verification cost rather than by habit
   • • Write a routing table with named defaults your team can follow without deliberating per task
   • • Recognise the two expensive failure modes: frontier-everything and cheap-everything
   • • Explain a monthly AI bill in terms of the work it displaced

   Match tier to blast radius

   • LabThe routing decision10m
   • Interactive lessonA routing table your team will actually follow12m

   Routing real work

   • LabLab: route ten real tasks and defend the bill15m

   Module 8 check

   • QuizModule 8 graded quiz8m

10. Module 10 · Capstone: Ship a Feature Under Supervision

    45m

    One integrated deliverable that exercises every module: a real feature, specified properly, built with the right tool at the right model tier, and verified from evidence a reviewer can confirm without taking your word for anything.

    After this module you can

    • • Take a real feature from spec to merged change using the full loop
    • • Justify tool and model-tier choices in writing, against the criteria from Modules 4 and 8
    • • Produce a verification record a reviewer can audit without trusting you
    • • Score your own record against the rubric before calling it done, naming symptoms rather than restating criteria

    The brief

    • Interactive lessonCapstone brief and rubric8m

    Build and verify

    • LabCapstone: specify, build, verify, record37m

Optional projects

5 portfolio builds · outside the 11h spine · Builder labs you can ship to Showcase

• Optional: personal portfolio website

  45m

  Ship a one-page portfolio you could hand a recruiter: hero, projects, and a clear way to contact you. Spec it first, then build in the Builder.

  Deliverable

  A live portfolio preview plus the written spec and a short verification note listing which criteria passed.

  Open project →

• Optional: expense tracker

  50m

  Build a small expense tracker with add/edit/delete, category totals, and a running balance you can verify by hand.

  Deliverable

  A working tracker preview, the data-model spec, and a verification note with the three checks and pass/fail.

  Open project →

• Optional: LLM chatbot UI

  55m

  Build a chat interface with streamed-looking replies, message history, and a clear empty/error state, even if the model is mocked.

  Deliverable

  A chat preview with mocked replies, the UX spec, and a verification note covering empty/happy/error paths.

  Open project →

• Optional: kanban task board

  50m

  Build a three-column kanban (To do / Doing / Done) with create, move, and delete, good practice for state and drag-or-button transitions.

  Deliverable

  A kanban preview with persisted columns, the board spec, and a verification checklist with pass/fail.

  Open project →

• Optional: personal markdown blog

  45m

  Ship a tiny blog: a post list, a post detail view, and an editor that stores markdown locally, classic portfolio fodder.

  Deliverable

  A blog preview with list/detail/editor, the view spec, and a verification note for the create-edit-reload path.

  Open project →