Mastering Claude Code

An agent is only as good as what you give it

A model answers from what it can see. Give it the right facts, the right amount of thinking, a way to prove its work and clear limits, and it delivers. Leave one out and it guesses with confidence.

Four questions run through the whole workshop:

• Context. Does the agent have the right facts?
• Reasoning. Is this task worth a bigger model or more effort?
• Evidence. What proves the result is correct?
• Autonomy. Do your checks and limits earn the right to step away?

You learn to answer them with Claude Code, in four steps. Each step is a belt, and each belt ends with something that runs.

Four belts

• White belt, foundations. What a model is, what the harness around it does, your first conversation with Claude Code.
• Blue belt, build CLASH. From a spec to a running app: plan first, work in small steps, let Claude look at the page, review like a stranger.
• Brown belt, control the context. Write a CLAUDE.md from real rules, package a habit as a skill, audit with subagents, turn a story into a spec, scope rules to paths.
• Black belt, orchestrate and let go. Tests as the goalpost, agent teams and dynamic workflows, hooks, the browser as a check, worktrees and CI, the Agent SDK, scheduled and background work, your own MCP server.

One real app

You build CLASH, a map app for spontaneous meetups in Berlin. A clash is an activity at a place and a time. People join, hosts accept or reject, notifications follow. You start with a spec and an empty repository. CLASH is live and free to use, so you can try it before you build it yourself.

Real code has real mistakes: a Server Action that skips an ownership check, a map that crashes on the server, an avatar that slows every page. You find them and you fix them with evidence.

By the end you have:

• CLASH, built by you with Claude Code and compared with the reference
• a CLAUDE.md based on real rules, a reusable skill and a set of hooks
• an authorization audit run three ways, with the fix merged
• a browser test suite and a measured performance fix
• the audit running in CI, a worktree flow and a small Agent SDK program
• Claude Code working with nobody at the keyboard: an output style, a goal, a loop, a background session and a routine
• your own MCP server on CLASH, and a second app that publishes its talks as clashes through it

How it runs

The trainer explains an idea, shows it live, and then you do it on your own machine. Every task has a reset branch, so nobody gets stuck and nobody waits for the group. Slides, task files and answer keys are yours to keep.

Who it is for

Anyone who writes code and wants to use Claude Code well. Basic programming skills in any common language are enough, plus the basics of git. The app you build, CLASH, is written in TypeScript. You do not need to know it: if you can read code in another language you can follow along, and Claude Code explains what is new. You do not need any Claude Code experience.

What you need

A laptop with Node.js 20.19 or newer, git and the GitHub CLI. A Claude account with Claude Code access: Pro works, a higher plan leaves more room for the agent team task. A GitHub account. The full setup checklist waits on your workshop page once you are enrolled.

White belt: foundations

You learn what a model is, what the harness around it does, and how to keep a conversation on course.

1. How a model works. Tokens, chances, no memory and a limited context window: what a language model is, why it guesses, and why Claude Code puts files in front of it.
2. The harness and your first conversation. What Claude Code adds around the model: the loop, the prompt, tools and permissions. Then you start it in a project and ask about a file.
   Task: Set up Claude Code and ask your first question.

Blue belt: build CLASH

You go from a spec to a running app, one small step at a time.

3. Plan before you build. Write a brief with goal, rules and a finish line, and use plan mode to review a hard-to-undo change before Claude writes a single file.
   Task: Scaffold the app and plan its data model.
4. Small steps and the safety moment. Build in small steps you can check, undo one with /rewind, watch the context window and see why every Server Action needs its own ownership check.
   Task: Build login and clashes in small steps.
5. Let Claude see the result. Reuse a pattern by pointing at it, give Claude the error or the live page instead of describing a bug, and add quality gates to CLAUDE.md.
   Task: Build venues, the map and notifications.
6. Parallel jobs, memory and review. Batch independent jobs in one brief, run work in the background, save a rule to memory, review your own diff like a stranger and ship through Claude.
   Task: Finish the app, review it and ship.

Brown belt: control the context

You decide what Claude knows, when it loads it and who checks the work.

7. Context and CLAUDE.md. Read /context, write a CLAUDE.md from six real CLASH rules, and review a plan in plan mode before any code changes.
   Task: Write a CLAUDE.md from real rules and review a plan.
8. Skills and plugins. Write a skill for a recipe you repeat, check what skills cost in context, and package it as a plugin you can share.
   Task: Write the clash-feature skill and ship venue favourites with it.
9. Subagents for audits. Hand an audit to a read-only subagent so your own context barely moves, and tell a fresh subagent from a fork.
   Task: Audit the Server Actions with a read-only subagent.
10. From story to spec. Turn a vague story into a settled spec with Example Mapping, run as a skill that interviews you before it drafts.
    Task: Build the discover skill and save a settled spec.
11. Path-scoped rules. Scope a project rule to app/actions/** with paths: frontmatter and check in /context that it loads only on a matching read.
    Task: Write a path-scoped rule for Server Actions.

Black belt: orchestrate and let go

You add tests, teams, hooks and a browser as checks, then step away on purpose.

12. The test-driven inner loop. Drive code from a saved spec one rule at a time, and package the red-green-refactor loop as a skill that stops itself.
    Task: Drive the capacity rules with a TDD skill.
13. Agent teams and dynamic workflows. Describe an agent team and a dynamic workflow in plain words, read the generated script, and pick the right strategy for a job.
    Task: Run the ownership audit as a team and as a workflow.
14. Hooks and security. Turn a repeated rule into a hook that blocks, warns or holds a turn open, and learn where Claude's reach into your files stops.
    Task: Build four Claude Code hooks.
15. The browser closes the loop. Let Claude drive a real browser through MCP, write the test after the flow works, and prove a fix with a measured before and after.
    Task: Test the join flow and fix the avatar payload.
16. Worktrees, batch and CI. Run agents side by side in separate worktrees, know when /batch fits, and run the same audit in CI on every pull request.
    Task: Run two worktrees and audit every pull request.
17. The Agent SDK. Run the Claude Code agent loop inside your own program with read-only tools, a hook and a turn limit.
    Task: Host the agent loop in your own program.
18. Capstone. Ship one feature on the reference CLASH as a pull request, using every tool from the workshop together.
    Task: Ship one feature with every tool from the workshop.
19. Nobody at the keyboard. Set an output style, bound a run with /goal, loop a check, run an audit in the background and see a cloud routine.
    Task: Run Claude Code with nobody at the keyboard.
20. Build your own MCP server. Design an MCP server with four tools over the CLASH database, trust it selectively and call it from a second app.
    Task: Design an MCP server for CLASH.