8 Projects That Teach You Claude Code, Level by Level [2026]

Nobody gets good at Claude Code by reading about Claude Code. The skill lives in your hands: the request you phrase, the plan you approve, the permission you scope, the hook that fires when the agent tries something it shouldn't. This article is a project ladder: eight builds, each engineered to force one level of skill, ordered so that every project makes the next one possible. Do them in your own repositories with your own API key. Each maps to a level of Preporato's Claude Code course, where the same builds come with rubric grading and specific feedback on what you missed; here they come free with honest self-checks instead.

Project 1: The supervised bug fix

Skill forced: reading the agentic loop. Take a real bug you already understand and have Claude Code fix it while you approve every action. The rule that makes it a lesson: ask "why" about one action per run. Self-check: you can narrate, from memory, what the agent read, what it changed, and what it ran to verify.

Project 2: The prompt rewrite experiment

Skill forced: prompting with criteria. Pick one refactoring task and run it twice in fresh sessions: once with a one-line request, once with explicit success criteria, verification instructions, and boundaries. Diff the two results. Self-check: you can name the two specific criteria that changed the outcome, which is the Level 2 lesson (and the same discipline the prompt evaluation task grades formally).

Project 3: The repo that teaches itself

Skill forced: context management. Write a CLAUDE.md for your main repository: build and test commands, conventions, the three rules everyone breaks. Add a directory-level file in one subpackage with rules that apply only there. Then verify with /context and a fresh session that the right rules load in the right places. Self-check: a task you run in the subpackage respects the local rule without you mentioning it. The CLAUDE.md guide is the companion reading.

Project 4: The planned feature

Skill forced: workflows. Build a small feature test-first in plan mode: Claude proposes the plan, you edit the plan before approving, tests get written before implementation, and the session ends in a reviewable PR. Use rewind at least once, on purpose, when a step lands wrong. Self-check: the PR description, the tests, and the diff read like a colleague's work you would approve.

Project 5: The hardened setup

Skill forced: customization and permissions. Build your .claude directory like infrastructure: a settings.json permission set that allows your routine commands and blocks the destructive ones, one slash command for a workflow you repeat, one skill with real instructions, and one hook that provably fires (start with a PreToolUse guard that blocks a dangerous command; test it by asking Claude to run that command). Self-check: the hook blocks it, every time, because a hook is enforcement and a prompt instruction is a request. This is the exact build the hardening task grades, and the skills guide plus hooks guide cover the theory.

Project 6: The connected agent

Skill forced: MCP and tool design. Connect Claude Code to one real external system through the Model Context Protocol: a database, an issue tracker, an internal API. Scope it deliberately (project scope, least privilege, secrets outside the config), then design one tool interface an agent can actually use well: clear description, typed arguments, unambiguous errors. Self-check: a fresh session discovers the tool and uses it correctly without hand-holding. Companion reading: MCP tool design best practices; the graded version is the MCP server task.

Project 7: The parallel review

Skill forced: subagents and orchestration. Take a meaty review or migration and split it: subagents explore in parallel with isolated context, results synthesize into one report, and one piece runs headless (a claude -p invocation in a script or CI job with JSON output your pipeline can parse). Self-check: the headless run exits with structured output a script consumes, and you can explain why the subagents did not pollute each other's context.

Project 8: The capstone agent

Skill forced: the Agent SDK. Build a small production-shaped agent in Python or TypeScript on the Agent SDK: one clear job (triage, extraction, review), structured output validated against a schema, guardrails on what it may do, and a routine that runs it on a schedule or trigger. Self-check: someone else can run it, it fails safely on hostile input, and its output feeds a program rather than a person. The course's Level 8 capstone is this project with a rubric and a grader.

Why grading changes the outcome

Self-checks keep you honest; a grader keeps you complete. The course version of this ladder submits each project from your machine and returns rubric feedback (what passed, what you missed, what production would have punished), which is the difference between "my hook probably works" and a verdict. Level 1 is free to start; the full ladder ships with Preporato Pro, alongside the CCA-F practice tests if certification is on your roadmap, since these eight projects cover most of that exam's blueprint on the way through. The complete path article maps that alignment level by level.

Next steps

Pick project 1 and a real bug, today. When a build deserves a verdict instead of a self-check, the course grades the same ladder.

Sources:

• Claude Code documentation
• Claude Agent SDK documentation
• Model Context Protocol
• Anthropic: Claude Code best practices