Vibe Coding — Build Real Software with AI
Ship a live app. Then be able to explain every line of it.
Anyone can prompt an app into existence. Almost nobody can ship one that survives contact with real users. This course teaches the second thing — building full-stack applications with Claude Code, Cursor and Copilot, then reading, reviewing, debugging and deploying what the AI produced.
- Duration
- 8 Weeks
- Contact Hours
- 40+ hours
- Modules
- 8
- Level
- Beginner → Shipping Builder
AI & DevelopmentWhat You Will Be Able to Do
Outcomes, not topics covered. Each one is something you can demonstrate by the end of the course.
- 1Build and deploy a working full-stack web application using AI coding tools
- 2Write specifications and prompts that produce correct code instead of plausible code
- 3Read AI-generated code well enough to say what it does and where it will break
- 4Review AI output for the four things it habitually gets wrong: security, edge cases, cost, and silent failure
- 5Debug an application you did not write line by line
- 6Use Git and GitHub properly — branches, commits, pull requests, rollback
- 7Deploy to production with a database, authentication and secrets handled correctly
- 8Judge when to reach for AI, when to reach for a library, and when to stop and think
Full Curriculum
8 modules. Published in full — nothing behind a signup form.
- The shift: from writing every line to directing and verifying
- What LLMs are good at — boilerplate, patterns, translation, explanation
- What they are bad at — novel logic, your business rules, knowing they're wrong
- Hallucinated APIs, outdated packages, confident nonsense — with live examples
- Why 'it runs' and 'it works' are different claims
- The one rule: never ship code you cannot explain
Hands-on: Set up Claude Code / Cursor and build a first working page
- Claude Code: agentic coding in the terminal, file editing, running commands
- Cursor: AI-native editor, inline edits, codebase context
- GitHub Copilot: inline completion and its limits
- v0 and AI UI generation
- Chat models for architecture and debugging conversation
- Choosing the right tool for the task — and the cost of each
Hands-on: Build the same feature three ways; compare output quality
- Specification before prompt: what are you actually building?
- Context is everything — files, schema, constraints, existing patterns
- Decomposition: why 'build me a marketplace' fails and six small prompts don't
- Constraining output: stack, style, error handling, no new dependencies
- Iterating on a failed attempt vs restarting clean
- Writing a project rules file so the AI follows your conventions
Hands-on: Take a vague idea, write a real spec, generate a working feature
- How the web works: client, server, request, response
- HTML/CSS/JavaScript — enough to read and edit confidently
- What a framework does; Next.js project structure
- Components, props, state — the mental model
- What a database is, what a table is, what a query does
- APIs, JSON, and environment variables
Hands-on: Hand-edit AI-generated code to make five specific changes
- Project setup: Next.js, Tailwind, Supabase, Git from commit one
- Data modelling: designing tables before generating code
- Authentication: sign-up, login, sessions, protected routes
- CRUD against a real database
- File uploads and image handling
- Forms, validation and error states — the part AI always under-builds
Hands-on: A working app with authentication and persistent data
- Reading a file top to bottom and narrating what it does
- Tracing a request from button click to database row and back
- Security failures: secrets in client code, missing authorization, unparameterized queries
- Edge cases: empty states, nulls, network failure, double submit
- Cost failures: N+1 queries, unbounded loops, unnecessary API calls
- Silent failure: swallowed errors and empty catch blocks
- Reviewing a diff before accepting it
Hands-on: Audit a supplied AI-generated codebase; find the seeded bugs
- Reading a stack trace and finding the actual line
- Browser devtools: console, network, elements
- Debugging with AI — giving it the error, the code and the context
- Writing tests so a fix stays fixed
- Security pass: env vars, row-level security, input validation, rate limiting
- Performance basics: what makes a page slow
Hands-on: Take a broken app and get it green
- Git properly: branches, meaningful commits, pull requests, revert
- Why 'the AI deleted my working version' stops happening once you use Git
- GitHub as portfolio and collaboration surface
- Deploying to Vercel; environment variables in production
- Custom domain, analytics, error monitoring
- Post-launch: reading feedback, shipping increments
- Working with a real developer when you outgrow the tools
Hands-on: Deploy the capstone live
Capstone Project
Ship a live, publicly reachable full-stack application of your own design — with authentication, a database, a public GitHub repository with real commit history, a README, a signed security checklist, and a written architecture walkthrough explaining how the app works end to end in your own words. The walkthrough is graded hardest: shipping something you cannot explain does not pass.
Who This Course Is For
- Non-programmers with a product idea and no team
- Designers and marketers who keep waiting on a developer
- Business owners who want internal tools without a hire
- Junior developers who want to be 5× faster without shipping 5× the bugs
- Anyone who tried 'just prompting it' and watched it fall apart at week two