{A}

// Vibecoding Courses

Practical Vibecoding

Articles and practical labs for Claude Code, Codex, and Cursor: set up properly, prompted deliberately, and verified like the output of a capable collaborator. No recorded lectures required.

Total
11h
Modules
10
Articles
13
Labs
35
Quizzes
9
Projects
5
Capstone
Rubric-scored

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

Who it's for

  • • Working engineers adopting AI coding tools on a real codebase
  • • Career services teams helping students ship portfolio projects with AI tools
  • • Founders and entrepreneurs building products without a full engineering bench
  • • Tech leads standardizing practice across a team or cohort

Prerequisites

  • • Comfortable in a terminal and with git
  • • A real project you can practice against (coursework, portfolio, startup, or day job)
  • • Access to at least one of Claude Code, Codex, or Cursor (the course covers all three; labs work with any one)

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

    Stochasticity: the same prompt does not replay

    Module 1 check

  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

    CLAUDE.md: standing project context

    Permission modes and blast radius

    Supervising long runs

    Module 2 check

  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

    AGENTS.md: portable repo instructions

    Local versus detached execution

    Reviewing what comes back

    Module 3 check

  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

    Project Rules

    Tab, inline edit, and Agent

    Choosing among the three tools

    Module 4 check

  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 recognize 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

    Approvals and how much authority to grant

    Custom instructions

    Choosing Copilot

  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 product requirements document (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

    Specifications a model can execute

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

    Module 5 check

  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 recognize 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

    Where context should live

    Module 6 check

  8. Module 8 · Debugging and Verifying AI Output

    1h 15m

    Verification is the stage teams skip. Read the evidence before re-prompting, recognize 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
    • • Recognize 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

    AI slop

    Multi-model validation

    Module 7 check

  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
    • • Recognize 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

    Routing real work

    Module 8 check

  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

    Build and verify

Optional projects

5 portfolio builds · outside the 11h core course · 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 where you can add, edit, and delete expenses, with 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 whether each passed.

    Open project

  • Optional: LLM chatbot UI

    55m

    Build a chat interface with replies that look streamed, message history, and clear empty and error states, even if the model is mocked.

    Deliverable

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

    Open project

  • Optional: kanban task board

    50m

    Build a three-column kanban (To do, Doing, Done) with create, move, and delete. It is a good exercise in managing state and in moving cards by drag or by button.

    Deliverable

    A kanban preview with persisted columns, the board spec, and a verification checklist marking each check pass or fail.

    Open project

  • Optional: personal markdown blog

    45m

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

    Deliverable

    A blog preview with its list, detail, and editor views, plus the view spec and a verification note for creating, editing, and reloading a post.

    Open project

Bringing this to your org?

Every lab ends in a deliverable a reviewer can check, and the capstone is scored against a published rubric. Talk to us about seats for an engineering team, a career center cohort, or a founder program.

Talk to us about seats and cohorts