Course · Claude Code

The Claude Code course

This is a hands-on course, not a reference: every lesson takes a problem you’ll actually hit and shows the exact move that fixes it. If you want the spec-level “what is this primitive” view, that’s Foundations - this course is the other half, the muscle memory.

Four principles that organize everything

Claude Code has a lot of surface - models, permission modes, sessions, skills, subagents, hooks, headless runs. Underneath, four principles sort all of it, and this course returns to them by name:

Capability - what the agent can figure out and accomplish with its model and tools. Picking a model, raising its reasoning effort, delegating to subagents, connecting systems through MCP: all capability decisions.
Context - what information is available when the agent decides. Instructions, rules, skills, retrieved files, tool results, memory, the conversation itself. Context is the discipline this whole course teaches: what the agent sees, when, and how much you can trust it.
Control - what guides execution, enforces boundaries, or lets you intervene. Permission modes and rules, plan mode, hooks, deny lists, the fail-closed posture an unattended run needs (refuse rather than guess when a check cannot run).
Cost - what completing the task consumes: money and tokens, compute, elapsed time, your attention, and rework when something goes wrong.

They trade against each other. A stronger model cannot recover a fact the agent never saw (capability does not replace context); a rule in context asks the model nicely, while a permission or hook enforces (guidance is not control); an unattended run needs checks it can trust before you walk away (control buys back cost). You will meet these trades in the chapters, stated where they matter.

The curriculum

Eleven chapters, in reading order, sharing one running example - a small TypeScript payments service with real seeded defects - carried from first install to unattended automation. Follow along in any repo of your own; chapter 1 sets up the payments service the lessons carry. Every page restates the facts it needs, so you can start at the top or land on the problem in front of you.

1 · Make one change you can trust Install, inspect the payments service, add a health endpoint, and judge the patch from its diff and tests.

2 · Keep the work coherent across sessions Recover the health-check decision, handle an interruption, compare approaches, and carry a checked handoff into the next session.

3 · Permissions & modes Control when Claude Code asks, run shell inline, accept edits on a leash, lock the agent out of what it shouldn't touch, and run hands-off without handing over the keys.

4 · Make the agent research and propose before it builds Plan the idempotency fix before any code moves: enter plan mode, interrogate and correct the proposal, keep the plan on disk, and take a big one to the cloud.

5 · Give the agent standing knowledge with rules and memory Audit the CLAUDE.md the repo already carries, learn what earns its tokens, layer scopes, and meet the memory system the agent writes itself.

6 · Match the model and the reasoning effort to the task The error-string tweak goes light and fast; the rate-limiter race gets the capable model and deep thinking. Spend both on purpose.

7 · Keep noisy work out of your main thread with subagents Payments succeed and every balance reads zero: delegate the trace, fan out the audits, background the long parts, and save the recurring auditor as a file.

8 · Package a repeated procedure as a skill the agent runs itself Write the wrap-up ritual once as a SKILL.md, tune the description so it fires at the right moment, and know when a command or subagent fits better.

9 · Extend the agent's reach with MCP, hooks, and plugins Connect the systems around the repo, build the deterministic test gate the rules file could only ask for, and ship the whole setup to your team.

10 · Run the review when nobody is watching Go headless with a fail-closed permission posture, review every pull request in CI, and fence a nightly regression loop.

11 · Operate Claude Code fluently at the keystroke level The inline moves, side questions, and editing habits that turn the primitives into reflex once the hard parts are behind you.

How to read it

Each module is a chapter - not a stack of disconnected reference cards. The lessons build on each other: each one picks up a problem, adds a move to your repertoire, and hands off to the next.

Read in order and you get the full progression. Land mid-course from a search and the page still works: every lesson states its own problem, its starting facts, and the terms it uses, so no earlier chapter is required reading - just more depth when you want it.

What you won’t find is a fixed template stamped onto every lesson. Some need a long worked transcript, some a single command and a warning, some a digression into why the tool behaves the way it does. The shape follows the content, the way a good book varies its chapters.