CLAUDE CODE MASTER CLASS

TL;DR — MCP (Model Context Protocol) is how Claude talks to the world beyond your filesystem. One .mcp.json declares servers; each server exposes tools named mcp__<srv>__<tool>.

▸ Five mature servers worth knowing

• playwright — browser automation. Click, type, screenshot, evaluate JS. Default for authenticated workflows.
• chrome-devtools — network observability, performance, runtime. Debug-only.
• dbhub — multi-DB SQL (Postgres, MySQL, SQLite). Read-only by default.
• nextjs-devtools — build logs, routes, server actions, cache diagnostics.
• github — structured issues / PRs / repos / workflows (richer than gh CLI).

▸ Adding a server

// .mcp.json at repo root
{ "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-playwright"]
    }
} }

▸ Trust gate

By default Claude prompts before enabling MCP servers declared in a project. Set enableAllProjectMcpServers: true in settings to skip the prompt — only do that for repos you trust.

▸ Mental model

TL;DR — a skill is a folder with a SKILL.md inside. Its body IS the prompt. Invoke as /<name>. You stop pasting the same instructions every session.

▸ Anatomy

▸ Frontmatter that matters

---
description: One-line discovery hint (Claude reads this to know when to suggest you)
argument-hint: <new <slug> | list>
allowed-tools: [Read, Grep, Bash]
paths: ["docs/specs/**"]   # path-scoped: only loadable in matching dirs
context: fork               # isolated turn (doesn't pollute main convo)
---
# /name — body below this line is the prompt

▸ Two killer features

1. $ARGUMENTS — whatever the user typed after the slash command. Lets one skill handle many phrasings.
2. !`shell-cmd` — runs at skill-load time; stdout is injected as context. Great for live state ("today's date", "current branch", "open PR list").

▸ Bundled skills (already on your machine)

/simplify · /batch · /debug · /loop · /claude-api — all ship with Claude Code. /help lists them in your install.

TL;DR — an agent runs in an isolated context and returns a single message. Delegate when (a) the work needs many tool calls, (b) the result fits in a summary, or (c) you want to keep noise out of your main conversation.

▸ The five built-in agents

• general-purpose — multi-step research and execution. The default.
• Explore — read-only fast search. "Where is X defined? Which files use Y?"
• Plan — architect mode. Produces an implementation plan, doesn't write code.
• claude-code-guide — Q&A about Claude Code itself (this Master Class is a real-world example).
• statusline-setup — configures your status line. Niche but ships.

▸ A good delegation has five parts

TASK:        one sentence — what to do
CONTEXT:     files/paths the agent should read first
CONSTRAINTS: what NOT to do · budgets · style guardrails
DELIVERABLE: concrete artifact (file path, PR, summary shape)
DONE_WHEN:   verifiable condition (tests pass, file exists)

Either DELIVERABLE or DONE_WHEN is required (or both). The agent inherits no context from the parent — give it everything it needs upfront.

▸ Dispatch from a tool call

Agent({
  subagent_type: "Explore",
  prompt: "TASK: locate all callers of getUser() across src/.\n..." ,
  model: "sonnet",          // optional · overrides default
  isolation: "worktree",    // optional · runs in a temp git worktree
})

▸ Model-fit cheatsheet

Mechanical implementation → sonnet. Quick schema/protocol lookup → haiku. Architecture review or exploratory debugging → opus. Multi-source comparative research → opus if ≥2 signals fire; otherwise sonnet.

TL;DR — hooks are shell scripts that run on lifecycle events. 29 events total. Each gets JSON on stdin and decides via exit code: 0 = allow, 2 on PreToolUse = BLOCK (stderr shown to agent), anything else = log-only.

▸ The seven event families

1. Session lifecycle — SessionStart · SessionEnd · Setup · Stop · StopFailure
2. Prompts & instructions — UserPromptSubmit · UserPromptExpansion · InstructionsLoaded
3. Tool gates — PreToolUse · PostToolUse · PostToolUseFailure · PostToolBatch
4. Permission — PermissionRequest · PermissionDenied
5. Sub-agents & tasks — SubagentStart · SubagentStop · TaskCreated · TaskCompleted
6. Compaction — PreCompact · PostCompact
7. System — Notification · TeammateIdle · ConfigChange · CwdChanged · FileChanged · WorktreeCreate · WorktreeRemove · Elicitation · ElicitationResult

▸ Minimum viable hook

// .claude/settings.json
{ "hooks": {
    "PreToolUse": [{
      "matcher": "Bash",
      "hooks": [{
        "type": "command",
        "command": "bash .claude/hooks/check-bash.sh"
      }]
    }]
} }

#!/usr/bin/env bash
# .claude/hooks/check-bash.sh — read JSON from stdin, decide via exit
input=$(cat)
cmd=$(echo "$input" | jq -r '.tool_input.command')
if [[ "$cmd" =~ rm\ -rf ]]; then
  echo "blocked: rm -rf is denied in this project" >&2
  exit 2
fi
exit 0

▸ The one gotcha worth flagging

PostToolUse(Bash) fires only on tool success. To catch failures, pair it with PostToolUseFailure(Bash). The failure payload uses .error and has no tool_response.

▸ Three handler types

• type: command — shell script. The default.
• type: prompt — single-turn Claude eval over $ARGUMENTS.
• type: agent — spawn a sub-agent with tools for deep verification.