Claude Code Mastery

Claude Code Fundamentals

Learn what makes Claude Code an agentic tool rather than an autocomplete engine: the read-act-observe loop, the built-in tools it uses to explore and change your codebase, the permission modes that govern its autonomy, and where its configuration lives. By the end you'll be able to trace exactly what happens, tool call by tool call, when you ask it to fix a bug.

CLAUDE.md and Context Configuration

Understand why CLAUDE.md exists and how it composes with auto memory and settings.json, how to write instructions that survive a growing context window instead of bloating it, and how to back a probabilistic agent with deterministic guardrails using permissions and hooks.

Settings, Permissions & Hooks

Master Claude Code's settings hierarchy, the full permission-rule syntax and mode set, and the hooks system's lifecycle events, JSON contract, and exit-code semantics — the three mechanisms that turn an agent you supervise into one your whole team can trust unattended.

Claude Code Platforms and Interfaces

Claude Code is one engine with many front doors: a terminal CLI, VS Code and JetBrains plugins, a desktop app, cloud sessions on the web, a mobile client, and integrations with Chrome, Slack, and computer control. This subject maps what each surface actually gives you, where they diverge from the CLI reference experience, and how to choose deliberately instead of by habit — plus the terminal ergonomics (statusline, keybindings, fullscreen, voice) and output styles that shape how any single surface feels day to day.

Plan Mode and Autonomous Workflows

Understand the concrete mechanisms Claude Code exposes for trading oversight against speed — plan mode's research-then-approve flow, including how to review, edit, and iterate on a plan before anything executes, plus self-pacing loops and goal conditions for unattended work. By the end you'll know when each mode earns its cost, how to steer a plan instead of just accepting or rejecting it, and where to go next when a task outgrows a single conversation entirely.

Skills, Slash Commands & Plugins

Learn how Claude Code's built-in commands, custom skills (which have absorbed custom slash commands), and plugins let you turn a one-off prompt into a reusable, shareable capability — and how to decide which of the four extension mechanisms fits a given piece of team knowledge.

Claude Code: Models, Cost, and Context

Claude Code gives you real levers over capability, latency, and cost: which model runs, how hard it thinks, whether it runs faster for more money, and how aggressively it manages its own context window. This subject teaches you those levers precisely — model aliases vs. pinned IDs, effort levels, fast mode, the advisor tool, prompt caching mechanics, subagent model routing, and the concrete habits that separate a $3/day session from a $30/day one — so you can make deliberate tradeoffs instead of accepting whatever the defaults hand you.

MCP Servers and Subagent Orchestration

Understand why the Model Context Protocol exists and how an MCP server extends what an agent can see and do, why that access model demands more careful trust and credential design than local file edits, and how subagents let you decompose a task across isolated context windows — sequentially for context hygiene, or in parallel for wall-clock speed — with git worktrees keeping concurrent writers from clobbering each other.

Claude Code Workflows and Agent Teams

Go beyond one conversation delegating a few subagents at a time. Learn dynamic workflows — scripts Claude writes that a runtime executes in the background to coordinate dozens to hundreds of agents — how to start, watch, save, and resume one, and the cost and scale controls that keep a run bounded. Then learn agent teams, an experimental peer-coordination model with a shared task list and direct messaging between teammates, and when reaching for a lead-and-teammates structure beats both a single agent and a scripted workflow.

Git Workflows with Claude Code

Learn how Claude Code reads git state for context, generates commits and PRs with proper attribution, reviews diffs with /code-review, resolves conflicts and rebases, and isolates parallel work with git worktrees — plus the safe-habits checklist that keeps an agent with git access from doing something you can't undo.

Claude Code Sandboxing and Security

Learn to reason about Claude Code as a system with a real attack surface: where prompt injection actually enters a session, how the built-in Bash sandbox and dev containers isolate what a command can reach, how permission rules and hooks compose into layered defense, what MCP servers can do outside the sandbox, and what data actually leaves your machine. By the end you'll be able to design a defensible sandbox-plus-permissions policy for a real team, not just recite the individual settings.

Claude Code Scheduled Tasks and Remote Agents

Claude Code doesn't have to live inside a single terminal you're staring at. It can poll in the background of an open session, fire on a schedule with your laptop closed, run in the cloud while you sleep, react to a chat message from your phone, and let you steer a session running on your desk from the bus. This subject builds the decision framework for all of it — /loop, /goal, desktop scheduled tasks, cloud routines, Remote Control, cross-session messaging, and channels — and the safety habits that make unattended and remote Claude trustworthy rather than terrifying.

Headless Mode, CI Automation & the Agent SDK

Learn how to run Claude Code non-interactively with -p, parse its structured JSON output, wire it into GitHub Actions and GitLab CI/CD with cost and safety controls, and understand the Agent SDK as the same harness exposed as a Python and TypeScript library — including when to reach for each option.

Claude Code Best Practices: Reliable, Cheap, High-Leverage Sessions

Synthesise the whole Claude Code track into working habits: manage the context window deliberately, always give Claude a check it can run, plan before touching code, prompt with acceptance criteria, scope permissions narrowly, control cost, and know how to recover when a session goes wrong.

Case Study: Shipping a Fix with Claude Code, End to End

Follow one bug — CSV exports intermittently missing rows in a TypeScript/Node monorepo — from a ten-minute setup audit through exploration, a wrong hypothesis, a checkpoint recovery, implementation, a workflow that generalizes the fix, a PR with /code-review, CI, and a follow-up routine. Every decision is named, justified, and linked back to the track subject that owns it, so you can see the whole toolkit working together instead of one mechanism at a time.