Everyone is teaching you to prompt. Nobody is teaching you to verify.
Learn to code for real. Then build with AI.
The only course that makes you good enough to catch the AI's mistakes. Twenty-two modules: write and debug code without depending on anyone, use AI as a multiplier, then ship real products on top of LLMs — with a gate in the middle where AI is forbidden.
What you have built by the end of each stage. Not screenshots of a finished course — the projects the curriculum makes you ship.
AI can write almost any code. Almost nobody can tell when it's wrong.
It invents API options that never existed. It ignores the edge case that matters. It writes error handling that only looks like error handling. All of it compiles. Some of it ships.
You get fast. You don't get good.
If the AI writes your code from the first line, you never build the models you need to judge its output. So this course goes the other way round: you write it by hand until you can read code on sight. After that, AI is a multiplier instead of a crutch.
Three products. Twenty-two modules. 155 lessons.
Each product names the previous one as a recommended prerequisite and never repeats its content. Nothing is locked: if you already program, start at M9 or M15.
Learn to Code (For Real)
You write every line yourself. AI explains concepts and translates errors — it never hands you a solution.
deliverable — An environment validated by ship-it doctor, your first script, a repo on GitHub.
A diagnostic places you at M0, M5, M9 or M15 — you never sit through what you already know.
AI explains
deliverable — A CLI that reads a file, transforms the data and writes the result.
AI explains
deliverable — Fifteen katas, all tests green.
AI explains
deliverable — A repo with git history, pull requests, tests, lint and CI.
AI writes boilerplate
deliverable — A working interface: responsive, accessible, built from state.
AI writes boilerplate
deliverable — A resilient client for an authenticated API: timeouts, retries, backoff.
Entry point if you already program.
AI writes boilerplate
deliverable — Your own API with a Postgres schema, auth, file storage and a public deploy.
AI writes boilerplate
deliverable — An app that takes payments and answers messages: webhooks, idempotency, OAuth, Stripe, email.
AI writes boilerplate
deliverable — A complete application — CRUD, auth, database, payments, deploy — written by hand.
No code generation of any kind. You do not move on until it passes the rubric.
AI forbidden
Code With AI
Now the AI writes. Your job changes: read it, test it, and find what it got wrong before production does.
deliverable — A report comparing three models on the same task, with real costs and latencies.
AI generates
deliverable — A versioned prompt library with tests.
AI generates
deliverable — A full feature built in small batches, every commit verifiable.
Claude Code end to end: context, scope, spec before code — and the tasks where AI costs you time.
AI generates
deliverable — A review report on an AI-generated pull request, with the bugs you found.
Invented APIs, ignored edge cases, error handling that only looks like error handling.
AI generates
deliverable — A feature delivered in an existing repository, from issue to merge.
AI generates
deliverable — A public portfolio, a profile that passes filters, and a proposal sent to a real client.
AI generates
Build With AI
The AI stops being the tool and becomes the product: structured outputs, RAG, agents, evals, cost.
deliverable — Your own endpoint with streaming, error handling and a cost log per user.
AI is the subject
deliverable — An endpoint returning schema-validated JSON, and a model calling real functions.
AI is the subject
deliverable — Semantic search over the user's documents, with citations and a measured pipeline.
AI is the subject
deliverable — An agent with a loop, tools, guardrails and an auditable decision log.
AI is the subject
deliverable — An app with auth, quotas, caching, evals in CI and cost alerts.
Prompt injection, PII, provider migration without breaking the app.
AI is the subject
deliverable — Your own public product, with a README, evals and a cost analysis.
AI is the subject
deliverable — Reference, not sequence: the same patterns in Python, provider differences, multimodal, web security, glossary.
AI is the subject
What the AI is allowed to do, per phase
This is the course's central pedagogical decision, and it is enforced rather than suggested. Every lesson declares its policy in a callout at the top.
Explain concepts, translate error messages, generate extra exercises.
Generating solution code. Completing your exercises.
Generate boilerplate and config, explain libraries.
Writing your business logic.
Nothing.
Any code generation at all.
Generate, refactor, test, document.
Accepting output you have not read and not tested.
It is the subject of study.
—
Something runs your work and tells you if it's right.
A course that only shows you code cannot tell you whether yours works. This one ships the machinery to check.
Verifies versions, PATH and permissions on Windows/WSL, macOS and Linux, then prints a report you can paste when you ask for help. Setup is where most beginners quit.
No exercise enters the course without an automated test. You get green or red against a readable acceptance criterion — not an opinion.
Every module ships a starter repository and a solution branch, so no evening disappears into scaffolding.
Dependencies and models pinned by version, a verified-on date on every lesson, a public changelog per product. Updates are included in the purchase.
Pick where you start.
M0–M21 in full, plus the toolkit you keep and reuse on real work.
Three months. I verify your code and your path.
VAT may apply at checkout · secure checkout — stripe · refund policy
Real students. Real shipped work.
no results published yet. they will live here.
Do the work. If it's not for you, get your money back.
No. Learn to Code (For Real) starts at M0: what a file is, what the terminal does, your first script. If you already program, the diagnostic in the first lesson sends you to M5, M9 or M15 instead — you never sit through what you already know.
The point is to be able to judge what it writes. If the AI generates your code from the first line, you never build the mental models you need to evaluate the output — you get fast and incompetent. M8 is the proof: a full-stack application written entirely by hand, no code generation. After that gate, everything is AI-assisted.
No. The course is sold whole, M0 to M21, because the three parts depend on each other: the M8 gate only means something after the fundamentals, and verifying what AI writes requires being able to write it. If you want coaching, the mentorship includes the whole course and you pay only the difference.
Build With AI (M15–M21) is written for you: structured outputs, tool calling, MCP, RAG with citations, agents with guardrails, evals in CI, quotas and cost control. It assumes you can already read and test code, and nothing forces you to buy the earlier products.
The three products together are 155 lessons, about 85 hours of reading and doing — and that figure is the sum of the lessons themselves, not a marketing estimate. The projects sit on top of it: the M8 gate, the two build projects and the capstone are each measured in days, not minutes, and they are where most of the learning happens. Each product stands alone, which is exactly why they are sold separately: a single 155-lesson course is a bootcamp nobody finishes.
Claude, plus the free tiers of Supabase and Vercel, cover the course. Budget roughly $20–40 a month of API usage while you build — and M9 includes a lesson on capping your spend so a loop can't empty your account.
Dependencies and models are pinned by version in the starter repos, every lesson carries a verified-on date, each product has a public changelog, and the whole thing is reviewed quarterly. Updates are included in what you paid. M19 also teaches you to abstract the provider and validate a model swap with evals.
No — and run from anyone who does. M14 covers the portfolio, the pricing, the first client and the contracts worth refusing. What you do with it is yours.
Same content, plus me: 6 × 45-minute 1:1 calls over three months, asynchronous review of up to two pull requests a month, and a direct channel where I answer within 48 business hours. It is not live chat and it is not unlimited access — fixed duration, renewable. 10 seats a quarter, by application.
They teach you to ask. None of them teach you to evaluate the answer, because that requires teaching programming properly first — which is slow to produce and makes no viral demo. That is the whole difference, and it is why the gate exists.