What it does Every active MCP server adds its tool definitions to every single Claude call, consuming tokens even when unused.

Why it matters A single MCP with 50 tools can add thousands of tokens per request. Scope MCPs per-directory in settings.json so they only load when relevant.

"I try very hard not to use MCPs because they blow up context."

# Bad: global MCPs loaded everywhere
# Good: scoped MCPs in .claude/settings.json
{
  "mcpServers": {
    "database": {
      "command": 
"npx",
      "args": [
"@modelcontextprotocol/server-postgres"
    ]
  }
}
# Only put this in projects that need DB access

Sources: Edmund Yong, Jaymin West

What it does Shows a detailed breakdown of where your context tokens are being spent — system prompt, CLAUDE.md, MCPs, conversation history.

Why it matters Most engineers never check where their tokens go. MCPs are usually the biggest offenders, sometimes consuming 30–50% of available context with tool definitions alone. You can't optimize what you don't measure.

> /context

# Example output:
System prompt:     12,400 tokens (8%)
CLAUDE.md:          2,100 tokens (1%)
MCP tools:         48,200 tokens (31%)  <-- problem
Conversation:      89,000 tokens (57%)
Available:          4,300 tokens (3%)

Sources: Edmund Yong

What it does When connecting integration platforms, expose only the specific actions you need instead of loading the entire catalog.

Why it matters Zapier exposes 8,000+ actions by default. Each one becomes a tool definition in your context. That's potentially hundreds of thousands of wasted tokens. Pick 5–10 actions and skip the rest.

# Bad: expose everything
"composio": { "actions": "*" }

# Good: expose only what you use
"composio": {
  "actions": [
    "GMAIL_SEND_EMAIL",
    "GOOGLE_CALENDAR_CREATE_EVENT",
    "NOTION_CREATE_PAGE"
  ]
}

Sources: Edmund Yong

What it does Define subagents by specific tasks they perform, not vague roles they fill.

Why it matters "Frontend developer agent" is useless — it's a role without boundaries. "UI reviewer — uses Playwright to screenshot components, compares against design spec, reports mismatches" is a task with clear inputs, outputs, and tools. Task-scoped agents work. Role-scoped agents hallucinate.

# Bad: role-based agent
name:
 frontend-developer
description:
 Handles all frontend work

# Good: task-based agent
name:
 ui-reviewer
description:
 Screenshots components with Playwright,
  compares against design spec images,
  reports visual mismatches as a checklist.
tools:
 Bash (playwright only), Read
scope:
 src/components/**

Sources: Official Docs, John Kim

What it does Setting isolation to "worktree" gives each agent its own git worktree — a full copy of the repo that doesn't conflict with your working directory.

Why it matters Without worktrees, two Claude instances editing the same repo create file conflicts. With worktrees, each agent works in isolation. Perfect for parallel code review, testing, or feature branches.

# In agent definition or headless invocation
"isolation":
 "worktree"

# Agent gets its own copy at:
# .git/worktrees/agent-session-xyz/
# No conflicts with your main working directory

Sources: Official Docs

What it does Rules in .claude/rules/ can specify glob patterns so they only load when Claude touches matching files.

Why it matters Your React component conventions are irrelevant when Claude is editing a database migration. Path-scoped rules keep context lean by only loading relevant instructions.

# .claude/rules/frontend.md
# paths: src/components/**, src/pages/**

Use functional components only.
All props must have TypeScript interfaces.
Use Tailwind, never inline styles.
Every component needs a unit test.

# This file ONLY loads when Claude reads/edits
# files matching src/components/** or src/pages/**

Sources: John Kim, Official Docs

What it does Forces Claude to return output matching a strict JSON schema, parsing unstructured text into structured data.

Why it matters When you need machine-readable output — for CI pipelines, data processing, or chaining commands — JSON schema guarantees the shape. No more regex parsing of Claude's prose.

claude
 -p "Extract all API endpoints from src/routes/" \
  --json-schema '{
  "type": "object",
  "properties": {
    "endpoints": {
      "type": "array"
    }
  }
}'

Sources: Official Docs

What it does Use claude -p (headless mode) in GitHub Actions, pre-commit hooks, and build pipelines to automate code quality checks.

Why it matters Claude becomes a quality gate in your pipeline. Every PR gets an AI review. Every commit gets checked against your conventions. AI quality gates catch issues that linters miss.

"Build script with AI quality gate."

# .github/workflows/ai-review.yml
- name:
 AI Code Review
  run: |
    claude
 -p "Review the changes in this PR.
    Check for: security issues, missing tests,
    breaking API changes. Output as markdown." \
      --json-schema '{"type":"object","properties":{
        "issues":{"type":"array"},
        "approved":{"type":"boolean"}
      }}'

Sources: Academind, Official Docs

What it does Multiple Claude instances coordinating on a shared task list with dependencies, running in parallel.

Why it matters One agent writes the backend API. Another builds the frontend components. A third writes tests. They work simultaneously, aware of each other's progress. Best for parallel review and independent workstreams.

# Enable in environment
CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS
="1"

# Agents share a task list with dependencies
# Agent A: "Build /api/users endpoint"
# Agent B: "Build UserList component" (depends on A)
# Agent C: "Write integration tests" (depends on A+B)

Sources: Official Docs

What it does Setting memory: user in agent frontmatter lets the agent read and write a MEMORY.md file that persists across sessions.

Why it matters Without memory, every session starts cold. With persistent memory, agents accumulate knowledge: client names, past bugs, preferred patterns, things that failed before. Compound intelligence across sessions.

# .claude/agents/code-reviewer.md
---
name:
 code-reviewer
memory:
 user
---

You are a code reviewer. Check for patterns
that have caused bugs before (see MEMORY.md).
After each review, log new patterns found.

# MEMORY.md gets created automatically
# Agent reads it at start, writes to it during work

Sources: Official Docs

What it does PreToolUse hooks intercept dangerous operations before they execute. PostToolUse hooks run automated checks after every edit.

Why it matters A PreToolUse hook can block Claude from deleting production config files. A PostToolUse hook can run ESLint after every file edit. Shell scripts as automated quality gates — no human intervention needed.

# .claude/settings.json
"hooks":
 {
  "PreToolUse": [{
    "matcher": 
"Bash",
    "script": 
"./scripts/block-dangerous-cmds.sh"
  }],
  "PostToolUse": [{
    "matcher": 
"Edit|Write",
    "script": 
"npx eslint --fix $FILE"
  }]
}

Sources: Official Docs, John Kim

What it does A git-controlled markdown vault with CLAUDE.md, custom skills, agents, and commands that functions as a full business operating system.

Why it matters Claude Code isn't just a coding assistant. When you combine a structured knowledge base + CLAUDE.md + skills + agents + commands, you get a system that handles sales, content, client work, operations, and engineering. The compound effect is massive.

"Not a coding assistant. An operating system."

second-brain/
  CLAUDE.md                   # identity + rules
  .claude/
    commands/                # /close, /content, /sop
    agents/                  # prospect-researcher, writer
    skills/
      cold-dance/
        SKILL.md             # instructions
        references/          # examples, data
        scripts/             # automation scripts
  01_Projects/                 # client work
  02_Areas/                    # ongoing responsibilities
  03_Resources/                # reference knowledge

Sources: Original research, 800+ hours usage

What it does Skills bundle instructions (SKILL.md), reference data, and scripts into self-contained workflow packages that Claude loads on demand.

Why it matters MCPs are for external API connections — databases, email, calendar. Skills are for your own processes — how you write proposals, how you research prospects, how you generate content. They don't burn context like MCPs do.

# .claude/skills/prospect-research/
SKILL.md          # 'How to research a prospect'
references/
  icp-scorecard.md       # scoring criteria
  talking-points.md      # industry-specific angles
scripts/
  enrich.py              # pull LinkedIn data
  score.py               # calculate ICP fit

# Claude loads SKILL.md, reads references, runs scripts
# Zero context overhead when not in use

Sources: Original research, Official Docs

What it does Combines build + test + lint commands in CLAUDE.md with Playwright visual testing to create a fully autonomous quality loop.

Why it matters Build and test catch logic errors. Lint catches style issues. But neither catches visual bugs. Adding Playwright screenshots gives Claude 'eyes.' It can see what it built, compare against expectations, and self-correct visual issues without human review.

# CLAUDE.md validation section
## Validation Loop
After every UI change:
1. npm run build
2. npm test
3. npx eslint src/ --fix
4. npx playwright screenshot http://localhost:3000
5. Compare screenshot to design spec
6. If mismatch, fix and re-run from step 1
7. Only present when all pass + visual match

Sources: Edmund Yong, John Kim

What it does The deliberate practice of controlling what information enters Claude's context window and when.

Why it matters Prompt engineering is writing good instructions. Context engineering is controlling the entire information environment. The engineers who master this work 5–10x faster than those who just write good prompts. Context is the bottleneck, not the model.

"What you put in context matters more than what you prompt."

# Context engineering checklist:
1. CLAUDE.md: under 200 lines (critical rules only)
2. .claude/rules/: path-scoped (load on demand)
3. MCPs: surgical (5-10 actions, not 8000)
4. @imports: pull specific files, not directories
5. /compact: when context fills, don't start new chat
6. /clear: between unrelated tasks
7. /context: audit regularly, fix token hogs
8. Skills over MCPs for internal workflows

Sources: Edmund Yong, John Kim, Official Docs