Claude Code — Beginner to Pro
A sequenced curriculum: read the files in number order (00 → 57). Every file ends with a prev/next link, every stage ends with a milestone, and 45-capstone-projects.md has a hands-on project to prove each stage.
Works two ways:
- Self-study — follow the stages, do the capstones
- Teaching others — each stage below has 🎯 core ideas and a 🎬 live demo; see the Instructor Guide at the bottom
Every file ends with two built-in study aids:
- 🧠 Quick Recall — a memory trick / mnemonic so the concept sticks (e.g. “Esc stops, Esc-Esc time-travels, Shift+Tab shifts trust”)
- 👨🏫 Teach It — how to teach that topic: the one-liner to say, the demo to show, and the mistake learners will trip on
Sources: code.claude.com/docs · Anthropic courses (mapped in 44-anthropic-courses.md)
Stage 1 — Foundations 🟢 (Beginner)
Section titled “Stage 1 — Foundations 🟢 (Beginner)”🎓 Course: Claude Code 101
| # | File | Topic |
|---|---|---|
| 00 | Overview | What “agentic AI coding assistant” means, plain-language |
| 01 | Installation & Setup | Install, login, config locations |
| 02 | Quickstart | Your first real session, step by step |
| 03 | Core CLI Usage | Flags, piping, one-shot mode |
| 04 | Slash Commands | Every built-in command |
| 05 | Interactive Mode & Shortcuts | Keyboard mastery |
| 06 | How Claude Code Works | Internals: loop, tools, context |
🎯 Core ideas: agent ≠ chatbot (it acts and verifies); the agentic loop (gather → act → verify); you approve every change by default; describe outcomes, not steps. 🎬 Live demo: in a real repo — “what does this project do?” → “fix this bug” → approve the diff → “commit it”. Nothing lands harder than a stranger’s bug fixed in 3 minutes. Milestone: install, navigate, prompt, explain the loop. → Capstone 1
Stage 2 — Working Sessions 🟢
Section titled “Stage 2 — Working Sessions 🟢”| # | File | Topic |
|---|---|---|
| 07 | Tools Deep Dive | Every tool with real examples |
| 08 | Sessions & Checkpointing | Resume, name, fork, /rewind |
| 09 | Context Window Management | /context, /compact, caching |
| 10 | Plan Mode & Thinking | Plan first, think harder, opusplan |
| 11 | Real-World Workflows | 10 end-to-end workflows |
🎯 Core ideas: the context window is finite working memory — manage it deliberately; /rewind makes mistakes cheap, so be ambitious; plan mode before big changes; /clear between tasks, /compact within them.
🎬 Live demo: let Claude make a mess on purpose, then double-Esc → restore code. The room relaxes visibly once they see undo exists.
Milestone: you control how Claude works. → Capstone 2
Stage 3 — Configuration 🟡 (Intermediate)
Section titled “Stage 3 — Configuration 🟡 (Intermediate)”🎓 Course: Claude Code in Action
| # | File | Topic |
|---|---|---|
| 12 | Settings System | settings.json scopes & precedence |
| 13 | Model Config & Env Vars | Aliases, effort, fast mode, env vars |
| 14 | Permissions | Rules reference |
| 15 | Permissions — Real Examples | 5 real scenarios |
| 16 | Sandboxing & Security | OS-enforced boundaries, credential protection |
🎯 Core ideas: four settings scopes (managed > local > project > user); permission rules decide what runs, the sandbox limits what running commands can touch — layers, not alternatives; match the model to the task (sonnet daily, opusplan for design, haiku for scripts).
🎬 Live demo: allow Bash(npm test:*) in project settings, re-run — the prompt disappears. Then /sandbox and show a network prompt fire on first domain use.
Milestone: safe, prompt-free automation. → Capstone 3
Stage 4 — Memory & Context 🟡
Section titled “Stage 4 — Memory & Context 🟡”| # | File | Topic |
|---|---|---|
| 17 | Memory | CLAUDE.md & auto memory reference |
| 18 | Memory — Real Examples | 3 real CLAUDE.md files |
| 19 | Project Structure | The .claude directory layout |
🎯 Core ideas: CLAUDE.md is standing instructions loaded every session — keep it under ~100 lines and it pays rent on every token; auto memory is Claude’s own notebook; mid-session CLAUDE.md edits apply only after /clear.
🎬 Live demo: ask for a commit → sloppy message. Add a commit convention to CLAUDE.md, /clear, ask again → perfect message. Cause and effect in 60 seconds.
Stage 5 — Extending: Skills, Hooks, MCP, Plugins 🟡
Section titled “Stage 5 — Extending: Skills, Hooks, MCP, Plugins 🟡”🎓 Courses: Introduction to agent skills, Introduction to MCP
| # | File | Topic |
|---|---|---|
| 20 | Skills | Overview |
| 21 | Skills Step-by-Step | Build your first skill |
| 22 | Skills — Real Examples | 10 complete skills |
| 23 | Hooks | Reference |
| 24 | Hooks — Real Examples | 12 hook recipes |
| 25 | MCP Servers | Reference |
| 26 | MCP — Real Examples | Real integrations |
| 27 | Plugins | Package & share extensions |
🎯 Core ideas: one mental model — skills = knowledge on demand (loaded when invoked), hooks = guaranteed automation (the harness runs them, not the model), MCP = new abilities (external tools/data), plugins = the shipping container for all three.
🎬 Live demo: build a /release-notes skill live from git log (5 min), then a PostToolUse format-on-edit hook — edit a file badly and watch it auto-format.
Milestone: Claude Code customized to your team. → Capstone 4
Stage 6 — Agents & Parallelism 🟠 (Advanced)
Section titled “Stage 6 — Agents & Parallelism 🟠 (Advanced)”🎓 Course: Introduction to subagents
| # | File | Topic |
|---|---|---|
| 28 | Agents Overview | The agent system |
| 29 | Subagents | Specialized workers |
| 30 | Agent Project Structure | Designing the agent layer |
| 31 | Worktrees | Parallel isolated sessions |
| 32 | Agent Teams | Coordinated multi-session teams (experimental) |
🎯 Core ideas: delegation is context protection — verbose work happens in the subagent’s window, only the summary returns; subagents report back, teammates talk to each other; parallel work needs file separation (worktrees or one-owner-per-area).
🎬 Live demo: run a test suite normally (watch context fill) vs. via a test-runner subagent (main context stays clean). /context before and after tells the story.
Milestone: you delegate and parallelize. → Capstone 5
Stage 7 — Automation & CI/CD 🟠
Section titled “Stage 7 — Automation & CI/CD 🟠”| # | File | Topic |
|---|---|---|
| 33 | Headless & Scripting | claude -p, piping, CI patterns |
| 34 | Routines & Scheduling | Cloud automation, /schedule, /loop |
| 35 | GitHub Actions | @claude in CI |
| 36 | Code Review | /code-review, ultrareview, PR reviews |
🎯 Core ideas: claude -p makes Claude a Unix tool — pipe anything in, get JSON out; scheduling ladder: /loop (in-session) → desktop tasks (your machine) → routines (cloud, machine off); layered review catches bugs where they’re cheapest.
🎬 Live demo: git diff main | claude -p "review for security issues" --output-format json | jq — one line, real review, parseable output.
Milestone: Claude works while you don’t. → Capstone 6
Stage 8 — Surfaces: IDE, Desktop, Web, Chat 🟠
Section titled “Stage 8 — Surfaces: IDE, Desktop, Web, Chat 🟠”| # | File | Topic |
|---|---|---|
| 37 | VS Code Extension | IDE integration |
| 38 | Desktop, Web & Remote Control | Teleport, dispatch, work from anywhere |
| 39 | Slack, Chrome & Channels | Chat-to-PR, browser automation, event push |
🎯 Core ideas: one engine, many surfaces — CLAUDE.md/settings/MCP follow you everywhere; sessions move between devices (teleport in, remote-control out); meet work where it happens (bug report in Slack → PR back in Slack).
🎬 Live demo: start a task in the terminal → /remote-control → approve its next permission prompt from your phone, held up so the room can see.
Stage 9 — Pro 🔴
Section titled “Stage 9 — Pro 🔴”🎓 Course: Building with the Claude API
| # | File | Topic |
|---|---|---|
| 40 | Agent SDK | Build custom agents (Python/TS) |
| 41 | Cost Management | Token economics & optimization |
| 42 | Large Codebases | Monorepos at scale |
| 43 | Best Practices | 15 production practices |
🎯 Core ideas: the pro bar is building agents for others, not just using one; cost is an engineering constraint you design for (caching, model mix, delegation); big codebases need scoped context (nested CLAUDE.md, targeted reads). 🎬 Live demo: 30-line Agent SDK script with one custom tool, run it, show the cost readout. Milestone: you build agents for others. → Capstone 7
Stage 10 — Practice & Certification 🏁
Section titled “Stage 10 — Practice & Certification 🏁”| # | File | Topic |
|---|---|---|
| 44 | Anthropic Courses | Full Skilljar catalog mapped to this path |
| 45 | Capstone Projects | 7 real-case projects + scorecard |
Stage 11 — Specialized & Reference 📚 (read as needed)
Section titled “Stage 11 — Specialized & Reference 📚 (read as needed)”Complete coverage of every remaining topic — dip in when a feature becomes relevant.
| # | File | Topic |
|---|---|---|
| 46 | JetBrains & Terminal Setup | IntelliJ/PyCharm plugin, terminal tuning |
| 47 | GitLab CI/CD | @claude in GitLab pipelines |
| 48 | Computer Use | Claude controls your screen (macOS) |
| 49 | Goal & Advisor | /goal autonomy + stronger-model second opinions |
| 50 | Agent View & Workflows | Background session manager + 100-agent orchestration |
| 51 | Artifacts & Deep Links | Publish live pages; launch sessions from URLs |
| 52 | Output Styles, Voice & UI | Personas (incl. Learning mode), dictation, status line |
| 53 | Dev Containers & Sandbox Environments | The isolation ladder for autonomous runs |
| 54 | Prompt Caching Deep Dive | What invalidates the cache and why it matters |
| 55 | Troubleshooting | Diagnose install, session, MCP, and model issues |
| 56 | Enterprise Deployment | Providers, managed settings, analytics, rollout |
| 57 | Glossary | Every term in plain language, cross-linked |
🎯 Core ideas: the power-user trio is 49+50 (/goal + agent view + workflows = real autonomy); 54 (caching) quietly explains half of all “why is it slow/expensive” questions; 55 + 57 are the references you hand to anyone you onboard.
8-Week Plan (files + courses + capstones)
Section titled “8-Week Plan (files + courses + capstones)”| Week | Files | Course | Deliverable |
|---|---|---|---|
| 1 | 00–06 | Claude Code 101 | Capstone 1 — tour-guide a strange repo |
| 2 | 07–11 | — | Capstone 2 — plan, wreck, rewind, re-do |
| 3 | 12–19 | Claude Code in Action | Capstone 3 — zero-prompt test loop |
| 4 | 20–24 | Intro to agent skills | 2 skills + 1 hook shipped to a real repo |
| 5 | 25–27 | Intro to MCP | Capstone 4 — full onboarding kit + 1 MCP server |
| 6 | 28–32 | Intro to subagents | Capstone 5 — review fleet, parallel worktrees |
| 7 | 33–39 | MCP Advanced | Capstone 6 — hands-off pipeline (headless + routine + CI) |
| 8 | 40–45 + skim 46–57 | Building with the Claude API | Capstone 7 — ship a real Agent SDK agent |
Stage 11 isn’t a week of its own — pull files in when they become relevant: 52 (Learning style) in week 1 if teaching, 49–50 in week 6–7 for autonomy, 53 before any unattended run, 54 the first time someone asks “why was that turn slow?”, 55/57 always open in a tab.
Instructor Guide — Teaching This Curriculum
Section titled “Instructor Guide — Teaching This Curriculum”Your prep is already done: every file’s 🧠 Quick Recall block gives you the mnemonic to put on a slide, and its 👨🏫 Teach It block gives you the demo and the mistake to pre-empt. Before a session, read just those two blocks in each file you’re covering.
The three rules that make it land
Section titled “The three rules that make it land”- Demo live, in a real repo — never slides. The product is the demo. Every stage above has a 🎬 suggestion; each takes under 5 minutes.
- Learners type from minute one. Watching an agent is boring; directing one is addictive. Pair up: one navigates (says what to ask), one drives (types). Swap.
- Capstones are the certification. A stage isn’t “taught” until the learner’s capstone runs. Use 45’s scorecard as the class tracker.
Session formats
Section titled “Session formats”- 60-min intro session = Stage 1: 00 talk-through (10 min) → live demo (10) → everyone installs + runs quickstart (25) → each person fixes one thing in their own repo (15)
- Half-day workshop = Stages 1–3 + Capstone 1 as the closing exercise
- Team onboarding (recommended) = the 8-week plan, one weekly 60-min session per row: 20 min recap + demo of the new stage, 40 min working on the deliverable together
- Brown-bag single topic = any one file from Stage 11 (they’re self-contained)
Set the teaching environment
Section titled “Set the teaching environment”- Turn on the Learning output style for trainees (52): Claude explains decisions and leaves
TODO(human)gaps — the tool teaches alongside you - Demo repo: pick something small with tests (a past internal project beats any toy repo)
- Have
/statuslineshow context % so learners see the window filling — makes Stage 2 concrete
Common beginner mistakes (address these proactively)
Section titled “Common beginner mistakes (address these proactively)”| Mistake | Fix to teach |
|---|---|
| Vague prompts (“fix the bug”) | Outcome + location + proof: “fix the empty-form bug in ContactForm; tests must pass” |
| Pasting whole files into chat | Give paths — Claude reads files itself, selectively |
| Never clearing context | /clear between tasks is free; a 200-message session is not |
| Approving everything blindly | Read the diff for a week; then earn acceptEdits |
| Treating a wrong turn as failure | /rewind or /branch — exploration is the workflow |
| One giant CLAUDE.md | 100-line budget; overflow goes to skills |
| Fear of breaking things | Show checkpointing + git early; ambition follows safety |
The 10 commands to teach first
Section titled “The 10 commands to teach first”claude · /help · /clear · /model · Shift+Tab (plan mode) · Esc (interrupt) · Esc Esc (rewind) · /context · /resume · !cmd
Answering questions you don’t know
Section titled “Answering questions you don’t know”Model the meta-skill: ask Claude Code itself, live — “how do I configure X?” It has a built-in docs agent. The lesson is that the tool answers questions about itself; 55 covers the rest.
Fast Tracks
Section titled “Fast Tracks”- “I just want to be productive this week”: 00–07, 11, 17–18, then capstones 1–2
- “I’m setting this up for my team”: 12–19, 20–27, 36, 56, then capstone 4
- “I want to automate everything”: 16, 29–36, 39, 49–50, 53, then capstone 6
- “I’m building an AI product”: 40 + Building with the Claude API course + capstone 7
- “Something’s broken”: 55 → 57 →
claude doctor
Keep the capstone scorecard honest — a stage isn’t done until its capstone runs.
Written by Fenil Patel