All Courses & Projects

Build your first web page with AI in the opening chapters, then understand what is happening behind the scenes. You will see how the web works, read HTML and CSS without memorizing anything, and refine your page into something you would show anyone. No experience needed. This is where your vibe coding journey starts.

Set up a complete AI coding workflow with the terminal, npm, and a terminal AI agent. Go beyond installation: use the agent on a real task, learn the describe-review-approve loop, and bring browser-built projects to your local machine.

Most AI coding tools start each session without knowing anything about the project. You'll fix that by setting up config files for project context, shared standards across tools, MCP servers that connect AI to live data like GitHub issues, and automated checks that catch mistakes without you asking. By the end, every AI session starts informed instead of guessing.

One bad AI prompt can rewrite your entire project in seconds. Git gives you unlimited undo. You'll save snapshots, branch safely, recover from any mistake, and push your code to GitHub. When you work with teammates, Git keeps everyone's changes organized without overwriting each other. Your AI agent handles every Git command while you learn what each one actually does.

Stop getting garbage from AI and start getting what you actually want. You will practice the patterns that consistently produce good results: specific build prompts, follow-up conversations, debug templates, and mini-specs for bigger features. Works with any AI tool you use. This is the most transferable skill in vibe coding.

Build interfaces that look polished without learning design. You'll use component libraries to drop in professional UI, Tailwind CSS to make layouts work on any screen size, and learn how to turn screenshots into real working code with AI. If you work with a designer using Figma, you'll also see how to connect those designs directly to your project. No design background needed.

Add a database to your app without learning SQL. You'll use Supabase to store user data, and your AI agent will design the tables, write the queries, and wire everything into your UI. Every app needs this. Now you know how to build one.

Turn your frontend into a full-stack product that knows who is logged in, protects every route, and keeps running when things break. You will build API routes in Next.js, add authentication with Supabase or Clerk, handle errors properly, and set up background jobs for slow work. You describe the feature. AI writes the server code. This is where your app becomes a product.

You'll learn how to connect external services to your app: transactional email, optional payment processing, and webhook chains that trigger actions across multiple services at once. You'll use Stripe or Polar for checkout, Resend or a similar service for email, and build handlers that keep everything in sync. By the end, you have the integration skills vibe coders use on every app they ship.

You don't need to understand every line of code. You need a reliable system for reviewing AI output and catching mistakes before your users do. Review prompts, testing checklists, and TypeScript error messages become your quality toolkit. This is the quality mindset every vibe coder needs before shipping.

You learned to catch AI mistakes in the Spotting AI Mistakes Fast course. Now you'll fix the ones that slip through. Copy error messages directly to AI, describe silent bugs without understanding the code, and use Git as an undo button for your entire project. Broken apps stop feeling like disasters.

You'll ship apps that are safe from the mistakes that cost builders thousands. Learn the attack names every developer should know (XSS, SQL injection, CSRF), tell AI to protect against each one, and run a 10-minute security checklist before every deploy. No security background needed.

Every push feels risky until you have a system. You'll build a pre-ship routine that catches bugs before your users do: a quick manual check, AI-generated automated tests, and preview deploys via Vercel. After this course, shipping stops being scary.

Your app works on your laptop. Now make it real by shipping it to the internet. You'll connect your project to Vercel, configure production settings, and learn to read build logs so failures don't feel like disasters. By the end, you'll know how to roll back a broken deploy in seconds and set up monitoring so you catch problems before your users do.

You can build anything now. This course teaches you what is actually worth building. You will scope MVPs to three core features, set a single price from day one, and track activation, retention, and revenue instead of vanity metrics. This is the last mindset course before your capstone project.

You built something great and nobody knows about it. This course fixes that. You will launch on Hacker News, Reddit, and Product Hunt without sounding like a sales pitch. You will write SEO content with AI that brings free traffic for years and set up referrals that turn happy users into your best marketers. By the end, you have a weekly growth routine you can follow from day one.

Add a chatbot, smart search, or content generation to your app using AI APIs. You will tell your coding AI to wire up the Anthropic or OpenAI API, then keep costs down with rate limits and caching. This is the final course in the Vibe Path before your capstone project.

You already use AI for chat and autocomplete. Agents are different. They read your codebase, run commands, check results, and loop until the work is done. This course teaches you how that loop works, how to stay in control of it, and how to write tasks that agents can actually execute. It's the mental model every other course on this path builds on. Completely free.

Project rules tell agents how to work. Tasks tell them what to work on. This course teaches you to write task descriptions so precise that agents finish them on the first try. Five components, ten seconds of thinking, and dramatically better output. Less babysitting, more shipping.

You repeat the same instructions every session. Reusable skills fix that. This course teaches you to build on-demand agent workflows: skill files that load when relevant, shell preprocessing that injects live data, isolation modes that keep your main session clean, and activation controls that prevent accidental triggers. By the end, you have a portable skill library that makes any agent better at your specific work.

Agents with broad file access and shell permissions can cause real damage without malice. This course builds the safety infrastructure that prevents disasters: a risk framework for every delegation decision, permission scoping that matches task risk, secrets hygiene that stops leaks before they happen, automated gates that catch dangerous actions, audit trails that trace what went wrong, and awareness of emerging risks like prompt injection.

Technical debt is where agents earn their keep. Learn to distinguish agent-friendly debt from design decisions only you can make, plan refactors in safe batches, handle legacy code and dependency upgrades, and build a system that steadily improves your codebase without heroic effort.

Build a personal page with AI and deploy it to a live URL in one session. Each step shows you the exact prompt to use, what to expect, and what to fix. By the end you will have a public link with your real name on it.

Break a real project on purpose, then recover it using AI and Git. You will introduce real bugs across three commits, inspect the damage with diffs, and undo each commit one at a time. By the end you will know that most code disasters are recoverable and exactly how to recover them.

Build a professional landing page from scratch using AI. You will find inspiration, screenshot designs you like, generate a full page section by section, make it responsive with dark mode, and polish the details. You walk away with a complete, polished landing page ready to deploy when you learn deployment later.

Build a complete SaaS app from spec to launch using AI. You'll set up a database, add authentication, build CRUD features, integrate payments, and deploy to a live URL. This is where you put everything together and ship something real.

Get hands-on practice finding and fixing real problems in a broken app by describing them to AI. You'll test every page, describe every bug, and get AI to fix each one. Deliverable: a fully working app and a fix report documenting your process.

Take one of your existing projects and make it production-ready by telling AI to add tests, security checks, error handling, and automatic monitoring. Deliverable: a hardened app that's ready for real users.

Take your project from 'works on my laptop' to 'live on the internet.' You'll deploy to Vercel, set up production settings, fix deploy failures, add monitoring, and share your live URL. Deliverable: a working app on a real URL.

Take a deployed app and get real people using it. You'll launch on multiple platforms, set up referrals and SEO, track what's working, and iterate based on real feedback. Deliverable: 100 real users and active growth systems running.

This is it. Build your own product from scratch - pick the idea, scope the MVP, build it with AI, deploy it, and get real users. Nobody tells you what to build. You use every skill from the path to ship something real. This is where you go from learner to builder.

Evaluate, use, and steer any terminal agent. Covers Claude Code, Gemini CLI, Codex CLI, and Aider through practical patterns: choosing the right agent, reading live output, catching drift, recovering from mistakes, and building daily habits.

Real features are too big for one agent session. This course teaches you to break work into agent-sized tasks, sequence them with verification checkpoints, delegate research to keep context clean, run parallel agents on independent tracks, and recover when the pipeline breaks. The workflow that ships features fastest isn't one long session. It's a structured pipeline of focused ones.

Agents break things in predictable patterns. This course teaches you to recognize each failure mode in seconds, recover in under two minutes, save good work from bad runs, and design workflows where mistakes stay cheap. The skill that separates fast developers from frustrated ones isn't avoiding failures. It's recovering from them before they compound.

Agents make the same mistakes until you tell them not to. This course teaches you to write project rules files, shared cross-tool conventions, scoped directory rules, persistent context strategies, and agent-navigable documentation that make agents understand your codebase from the first prompt. Less correction, more shipping.

One agent hits a wall when features span too many files. The fix isn't a bigger context window. It's splitting work across multiple agents that each own a clear piece. This course teaches coordination modes, proven patterns (sequential chains, parallel pools, builder-reviewer pairs), contract-first ownership design, and how to review and merge multi-agent output so independently-built pieces work together on the first merge.

Agents can only do what their tools allow. MCP is the open protocol that connects agents to databases, APIs, issue trackers, and your internal systems. This course teaches you to evaluate which servers to connect, compose a focused tool ecosystem that protects your context budget, decide when to build custom servers, and navigate MCP-specific security risks like tool poisoning.

Agents make mistakes in predictable patterns. This course teaches you to review agent-generated code efficiently, calibrate trust by task type, catch drift before it compounds, and give feedback that actually improves future output. The developer who reviews well ships faster than one who checks nothing or checks everything.

Pick a module in a real codebase that needs work. Plan the refactor, delegate it to agents in verified batches, confirm nothing broke, and document the agent-assisted process so you can repeat it.

Agents don't have to wait for you to start them. Learn to run agents unattended in CI pipelines, choose the right tasks to automate, set security boundaries for headless execution, and build trust through a staged progression from optional to required.

Large codebases break naive agent workflows. Learn context selection strategies, search techniques for unfamiliar code, monorepo package scoping, contract-first multi-repo coordination, and how to decompose large changes without losing coherence.

You know the techniques. Now make them a system. Build a personal workflow that compounds over time: how to audit which tasks benefit most from delegation, how to choose the right oversight level, how to build patterns from repeated work, and how to evolve your system as you and the tools improve.