Level 3
Build with AI
The builder book: from an idea to a small app running on a server, with AI as the partner that writes code and you as the builder who reads, tests and releases. 22 chapters, 4 projects and a 6-session bootcamp.
- Who it is for
- People who have finished AI Foundations and want to build a small tool or web app themselves, including those who have never worked as programmers.
32 lessons, about 200 minutes
Start this levelFoundations
Module 1
Chapter 1: Building with AI
What AI does and what stays your job, the difference between a prototype and a ready app, and how to choose a small first app worth building.
Module 2
Chapter 2: The web app map
The five parts of a web app, the line between browser code and server code, and how to trace one request from click to saved data.
Module 3
Chapter 3: Setting up your machine
A runtime, package manager, editor and version control on your own machine, secrets in environment variables, and the variables that ship to the browser.
Module 4
Chapter 4: From idea to spec
A one-page spec with users, flow and data, checkable acceptance criteria, and cutting scope until the first version is done in a few days.
Core skills
Module 5
Chapter 5: Reading code from AI
Reading the diff before accepting a change, asking for explanations without handing over judgement, and spotting code that looks right but is wrong.
Module 6
Chapter 6: Asking for small changes
Applying the request checklist to code changes, splitting features into small checkable steps, and writing limits for the agent.
Module 7
Chapter 7: Data and migrations
Designing a simple table, writing add-only migrations, running them before the new app starts, and rehearsing risky ones on a schema-only production copy.
Module 8
Chapter 8: Debugging with AI
Reproducing an error, giving AI the whole error and the latest changes, then testing one hypothesis with one change.
Module 9
Project 1: A small team tool
Build a small tool your team uses, from a one-page spec to running on your machine, with small commits and a decisions note.
Tools in practice
Module 10
Chapter 9: The terminal without fear
Basic terminal commands, how to read output and exit codes, why green does not always mean success, and the signs of dangerous commands that need reading first.
Module 11
Chapter 10: Editors and CLI agents
How editor assistance differs from an agent that runs commands itself, how to set an agent's permissions as narrow as its task, and how to check every command before approving it.
Module 12
Chapter 11: Git and branches
Small commits with messages that explain why, working on branches, adding files explicitly, and undoing a wrong change without losing other work.
Module 13
Chapter 12: Your first release
Taking an app from your machine to a server: build on a strong machine, a matching architecture, a tag for rollback and complete variables.
Module 14
Chapter 13: Troubleshooting production
Looking at production from outside like a user, recognising caches, memory, host keys and flags that never arrive, then writing an incident note.
Module 15
Project 2: Release to a server
Release the team tool from Project 1 to a server with a written runbook, rehearse rollback before you need it, and check the result as a user.
Level up
Module 16
Chapter 14: Context engineering
A project instruction file the agent reads every session, choosing what material goes into the context, and a progress ledger so long work can resume after a session stops.
Module 17
Chapter 15: Plan, build, review
A task plan naming files, tests first, verification commands and out of scope; a build and separate review loop per task; and the steps that always wait for the owner's approval.
Module 18
Chapter 16: Test first
Writing a test that fails for the right reason before asking for code, building fixtures shaped like real data including empty values, and running tests on a throwaway database with an explicitly set address.
Module 19
Chapter 17: Worktrees and parallel work
One worktree per task with files added by explicit path, one releaser per app who checks what is running before releasing, and merging parallel work one branch at a time.
Module 20
Chapter 18: Reviewers that test real data
A useful reviewer tests code with rows shaped like real data, matches done claims with command output, and checks product claims at the source. This chapter also gives a brief template for a separate reviewer.
Module 21
Chapter 19: App security
Secrets out of code and tracked files, including infrastructure plan files; pinned dependency versions and same-day critical patches; guarded public sign-up; and user text as data in AI features.
Module 22
Chapter 20: The real build as the gate
The type checker and unit tests are necessary but not enough. The real production build is the gate before release, a local gate list is used when CI is unavailable, and tests are picked because they prove the change.
Module 23
Project 3: A feature with tests
Add one real feature to your team tool with a written plan, tests first, a separate reviewer with hard data, and release after the real build passes.
Resources and bootcamp
Module 24
Chapter 21: Learning sources that last
Prefer official docs and release notes over a model's memory, follow security advisories for your dependencies, and build a learning habit that does not depend on one tool.
Module 25
Chapter 22: Runbooks and checklists
Write a release runbook someone else can run, put together before and after release checklists, and close every step with evidence, not a green status.
Module 26
Project 4: A complete app for real users
Build and release a small complete app for real users, rehearse migration and rollback on a schema-only production copy, then hand it over with docs and a runbook.
Module 27
Session 1: Machines and an idea
The first bootcamp session: every machine passes one checklist, the group picks one small app idea, and the repository opens with an ignore list before the first commit.
Module 28
Session 2: Spec and plan
The group writes a one-page spec and a written task plan, asks AI to attack that plan, then turns the important findings into written limits.
Module 29
Session 3: Build with tests
Pairs build plan tasks with a test that fails first, then swap roles as reviewers who repeat the evidence on their own machines.
Module 30
Session 4: Release and rollback
The group releases the app to a practice server with a runbook read aloud, drills a rollback against a timer, and fixes the runbook from every deviation.
Module 31
Session 5: Security and review
The group checks the running app as an attacker would: secrets, dependencies and flows that can be cheated, then sorts findings into fix now, scheduled or switch off.
Module 32
Session 6: Demo and handover
The closing session: a final release from the complete branch, a demo from the server with a real user, a handover proven by the new owner, and a thirty-day plan.
Final assessment
10 scenarios from every module; pass with 8 right. It opens once you have finished every module.