How to use this course

Every other course on this site teaches something outside itself — order flow, SAT grammar, a Pearson spec point. This one teaches the thing that built all of them. "Building with Claude" walks through the actual constructs this repository uses to get real work done with Claude Code — Skills, subagents, and multi-agent Workflow scripts — read directly out of the files that already exist here: content/skills.ts, the knowledge/skills/*/SKILL.md files, knowledge/workflows/scripts/*.js, and two articles this site has already published about what went right and what broke. Nothing in this course is a reconstruction or a tidied-up example written for teaching purposes. The Workflows module says so about itself directly, reading from "workflow scripts that this repository's own sessions actually ran, kept... rather than left to age out of a chat transcript."

That includes this course. The module you're reading, and the four others sitting next to it, were written by a Claude Code subagent — the exact agent() primitive the Subagents module describes — given one task prompt and told to read the real files first. It had no memory of any other session, was handed the same build-script pattern every other course on this site uses, and is now, in this sentence, describing the mechanism it was itself produced by. That's not a rhetorical flourish. It's the plainest evidence available that the pattern works, pointed at itself instead of asserted about something else.

#What "with Claude" means here, specifically

Three constructs, each with a real mechanism and a real failure mode, not a vague endorsement of "AI-assisted development":

• A Skill — a markdown file with YAML frontmatter whose description field is written as a trigger condition, not a summary, so the right skill loads at the right moment without anyone remembering to ask for it by name.
• A subagent — one agent() call: a prompt in, a result out (a plain string, or a validated object when the caller supplies a schema), with no memory of any other agent unless a script hands it that agent's output.
• A Workflow — a plain script deciding how many subagents run, in what order, and what happens to one subagent's output before the next one sees it. The intelligence is in the agents. The structure — sequencing, branching, deciding what one agent's result becomes as the input to the next — is in the deterministic code around them.

Modules 2 through 4 take these in that order because each one sits on top of the last. A Workflow script's choice between pipeline() and parallel() only makes sense once you know a subagent has no memory of its siblings; that isolation only makes sense once you know a Skill is what decided a subagent should exist for this task in the first place.

#What this course is not

It is not a general introduction to large language models, a prompt-engineering course, or a guide to any AI product other than Claude Code specifically. It makes no claim that multi-agent orchestration is free, fast, or automatically more reliable than one careful person doing the work directly. The honest-limits module says plainly where the machinery in modules 2 through 5 stops helping, using a real, unfiltered piece of evidence: a live production course whose own version-history comments run past two dozen separate audit-and-fix passes, each closing a real content gap the previous pass missed — despite every one of those passes using the adversarial-verification pattern module 4 teaches. That fact isn't saved for later because it would look better there. It's stated once, in the module where it belongs, and referenced honestly everywhere else.

#Module map

1. Start here — this page.
2. Skills — what a Skill actually is, how its description field works as a trigger, and the real incident that shows why a skill has to live inside version control to survive.
3. Subagents — the agent() primitive itself: isolation, structured output, concurrency limits, and what "no shared memory" actually costs in practice.
4. Workflows — pipeline vs. parallel, and the adversarial-verify pattern that catches a plausible-sounding wrong answer a single pass would have shipped.
5. Building real things — one real course build, one real production incident with a deployment ID attached, and the honest limits of piloting before scaling.
6. The honest limits — what none of the above actually fixes, with the evidence.
7. Reference — every skill, script, and article this course draws on, so you can go read the source directly instead of trusting a summary of it.

#How to use it

New to all three constructs: read in order. Module 4 assumes module 3, and module 3 assumes module 2 — none of the three reads well out of sequence.

Already write Claude Code skills or subagent scripts: skip to whichever of modules 3–5 you don't already have scars from, then read module 6 regardless. It's the one module written specifically for someone who already believes the pattern works.

Deciding whether any of this is worth adopting at all: read module 6 first, then decide whether modules 2–5 are worth the time. That's a deliberately unusual reading order for this site's own courses, and it's the right one here — the cost of the machinery should be visible before the machinery itself is.

Unlike this site's research-backed courses on external subjects, almost nothing in this one needs an evidence tier. A claim here is a file in this repository, quoted, that you can open and check yourself right now — module 7 explains the one place that isn't quite true.