Operate the builder
Run a terminal agent with boundaries
Set up the machine, keep secrets out of Git, write project instructions, review diffs, test permission profiles, leave durable handoffs, isolate parallel work, and recover a failed run.
Full course curriculum
25 modules from setup to capstone
The builder course starts with your machine and one terminal agent, then moves through a complete app, raw APIs, a streamed model connection, data, retrieval, agents, MCP, memory, evals, reliability, safety, a local lane, and a capstone tied to your own use case.
Practical outcomes
The exercises make the capability visible
Completion is self-paced and artifact-based. The course asks you to predict a change, explain it, run it on a known case, force a failure, and return to a safe state. By the capstone, that evidence spans the build workflow and the system around it.
Ship software
Take one app through release
Turn a problem into observable requirements, compare designs, build in stages, map tests, review dependencies, replay the README, record a known-good release, and prove rollback.
Own the connection
Read the wire and isolate the provider
Diagnose HTTP and JSON failures, handle streams and timeouts, build a tested model application, define canonical request and response types, and prove a configuration-only connection swap.
Build the data layer
Move source data into useful retrieval
Choose sources, ingest files and APIs, clean and structure records, process audio and video inputs, and improve retrieval through chunking, embeddings, hybrid search, reranking, and evals.
Build systems that act
Design tools, agents, MCP, and memory
Define narrow tools, choose an orchestration pattern, expose portable tools and resources through MCP, and structure working state and durable knowledge without turning every memory problem into a vector database.
Operate the system
Measure quality, cost, failure, and risk
Run deterministic, model-graded, and human evals; keep traces; enforce budgets; define fallback and recovery behavior; validate outputs; keep irreversible actions behind approval; and compare hosted and local routes with recorded evidence.
Every shipped module01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
The full syllabus
Before you start
Run the environment yourself
Before Module 1: Get your machine ready
The bridge from the free lessons into the builder track. Twelve small moves on your own machine so Module 1 isn't the first time you install a runtime, clone a repo, run a server, read a traceback, or call a model. The model call runs against a free local mock by default; a real provider key is optional. Do the lab, don't read it.
Foundations
Models, prompts, and evidence
What an LLM actually is
Beyond "predicts the next word." The minimum mental model that supports every later decision in this course.
Prompting as engineering, not vibes
Structured outputs, few-shot, chain of thought, self-critique, prompt versioning, and the smallest eval set that gates a prompt change. The shift from prompt-as-art to prompt-as-engineering, with examples.
The build workflow
Direct the agent and preserve control
Building with AI coding agents
Learn the terminal coding-agent loop, the project brief, conservative permissions, diff review, and the failure recovery used throughout the course.
Operate your AI coding setup every day
Turn daily coding-agent work into recoverable infrastructure with reusable workflows, durable handoffs, isolated parallel work, enforced permissions, and recurring runs you can stop.
Builder bridge
Release one bounded application
Build a small app with an AI coding agent
Take one bounded product from problem statement to tested release without surrendering review, dependency judgment, or rollback.
API builder
Understand the wire and isolate providers
APIs without the fog
Explain every part of an API request, inspect the raw response, and diagnose the failure instead of copying an opaque SDK call.
Build a hosted model application
Turn one hosted model connection into a small streamed, tested, observable application with a clear data contract.
Build the provider adapter
Put provider-specific behavior behind one canonical request, response, event, error, and contract-test boundary.
Model selection as a routing problem
Stop treating model selection as a guess or a religion. Walk through the routing-table mental model with examples across multiple domains.
Data is the spine
Ingest, structure, and retrieve useful data
The data sources that matter
A mental map of where data comes from, what each kind costs, and where each fits in an LLM system. The thesis the rest of the course rests on.
Getting data IN: ingestion patterns
Files, APIs, webhooks, scraping, transcription, OCR, queues, idempotency. Worked examples across multiple domains.
Cleaning and structuring data for LLMs
Chunking strategies, deduplication, schema enforcement, metadata extraction. The unsexy work that decides whether the LLM sees signal or noise.
Turn audio and video into usable data
Produce a consented, time-aligned, speaker-labeled transcript joined to sampled slides, charts, and scene changes.
Retrieval (RAG) done right
Why naive RAG fails. The five fix points: chunking, embeddings, hybrid retrieval, reranking, evals. Worked examples across multiple domains.
Building things that act
Tools, agents, and portable capabilities
Tool use and function calling
The primitive every agent system is built on. Tool design as API design. Three worked examples across domains.
Agents and orchestration
Single agent, sequential, parallel, supervisor/router, human-in-loop. Framework-agnostic patterns first, then LangGraph specifics. Three worked examples.
MCP architecture as a builder
MCP (Model Context Protocol) lets you expose tools and data to LLMs in a portable way. Build your own MCP servers; three worked examples across domains.
Production discipline
State, evals, reliability, and safety
Memory and knowledge architecture for agents
How to structure an agent's working memory and knowledge base so it loads the right context fast, never loses what it learned, stays out of bloat, and coordinates with other agents. Markdown-and-links first; a vector store only when you've earned it.
Evals, observability, debugging
Three eval types, trace logging, debugging agent runs. The unsexy module that separates working systems from faith-based ones.
Cost, latency, reliability at scale
Per-task budget caps, fallback chains, graceful degradation. The runtime engineering that prevents end-of-month billing surprises.
Safety and guardrails
Prompt injection defense, output validation, audit trails, when to require human approval. Patterns that prevent shipping confidently-wrong systems.
Local lane
Run and compare a local connection
Own a local model lane
Choose a local workload, fit a model to the machine you own, run it through a loopback API, and leave a service card you can restart.
Swap it in, measure it, keep the right route
Point one text workflow at hosted and local connections, expose capability gaps, measure the result, and choose a reversible route.
Compounding (capstone)
Apply the full path to one use case
Building your own personal AI stack
Pick a use-case track. Walk through what putting it all together looks like, using the primitives from M1-M15.
Capstone choices
Seven use cases, one evidence standard
Business
CRM intelligence assistant
Start with read-only questions over account sources and citations before any customer-facing write.
Personal
Calendar, email, and notes life-OS
Begin with a read-only daily summary over your own sources and treat the resulting logs as sensitive data.
Content
Multi-platform pipeline
Start with transcript structure and clip identification, then keep publishing behind human review.
Domain intelligence
Daily brief generator
Build the data store first and require every published claim to point back to a source row.
Internal tooling
Organization knowledge MCP server
Ingest and search one internal source before adding more sources or any write capability.
Operations
Incident response copilot
Begin with one fast, read-only runbook search tool and add bounded sources one at a time.
Research
Paper-library assistant
Preserve document and citation structure during ingestion before building search and synthesis.
What every capstone ships
The common package includes a proposal, data-flow diagram, threat model, representative evals, a route or capability statement where relevant, one tested failure path, operator documentation, and an optional self-graded demo. Four tracks include working starter repositories. Three are architecture walkthroughs because their source systems vary too much for one starter to fit.
Readiness
Know what the paid path expects
You bring
Structural judgment and willingness to test
You can break a problem into parts, work in a terminal, complete technical exercises, read an agent's diff, and decide whether the result is safe and correct.
The setup lab supplies
The code-side minimum
Install a runtime, clone a repository, run a server and script, read a traceback, keep a secret out of Git, make one request, inspect JSON, commit a change, and restore a bad edit.
Anyone who needs variables, loops, functions, and syntax taught from the beginning should take a basic programming course first. The paid course teaches supervision and system-building through technical work.
Questions and answers
Curriculum questions, answered
How many modules are in the builder course?
The builder course contains 25 shipped modules, starting with the machine setup lab and ending with the capstone. The journey order on this page comes from the same course roster used by the paid reader.
What do learners build before the capstone?
The required work includes a local setup record, an agent project brief, daily-driver operating artifacts, a small tested app release, a raw API record, a streamed model application, a provider adapter, data and retrieval exercises, agent and MCP work, evals, safety checks, and local-route comparison evidence.
What does the capstone require?
Each capstone requires a proposal, data-flow diagram, threat model, representative evals, a route or capability statement where relevant, one tested failure path, operator documentation, and an optional self-graded demo.
Does the paid course teach programming syntax from the beginning?
Basic syntax instruction sits outside the course. The setup lab teaches the terminal, runtime, scripts, tracebacks, Git, and a first request. Later modules expect you to read diffs, run technical exercises, and judge whether the agent’s work is safe and correct.
Keep building
Use the syllabus as the purchase evidence
Read the module map, compare it with the work you want to do, and use the free path or official vendor training first when that covers your goal. The paid course is for the longer build path across tools, data, agents, and production discipline.