Master Claude Code in One Page

Claude Code is a command-line tool by Anthropic. You install it, open your terminal, type claude, and talk to it in plain English. It's not a chatbot — it reads your code, edits files, runs commands, and creates commits. Think of it as a senior developer who lives in your terminal and knows your entire codebase.

How to Write Good Prompts

Claude takes your words literally. A vague prompt gets a vague result. A specific prompt that says what to change, where it is, and how to verify it works gets precise code. Here's the difference:

The 6 Built-in Tools

When you ask Claude to do something, it picks from 6 tools. Every action shows up in your terminal — nothing is hidden. You approve each step (or let it run freely in acceptEdits mode).

Watch Claude fix a bug in TaskFlow — it reads the file, finds the issue, edits the code, and runs the tests:

Permissions — You're Always in Control

Claude asks before doing anything risky. You choose how much freedom to give it. Start with "default" — you approve each edit. As you build trust, switch to "acceptEdits" for faster flow.

Switch anytime with /permissions or start Claude with claude --allowedTools Edit,Write,Bash to whitelist specific tools. Advanced modes also include dontAsk (auto-deny unless pre-approved) and bypassPermissions (skip all prompts — CI only).

Out of the box, Claude knows nothing about your project. It doesn't know you use Next.js, prefer Tailwind, or hate semicolons. These features let you teach it.

CLAUDE.md — Your Project's Rulebook

Create a file called CLAUDE.md in your project root. Claude reads it at the start of every session — like onboarding notes for a new developer. Keep it focused (under 100 lines). Here's a good example:

# TaskFlow
Task management app for small teams.

## Stack
Next.js 15, TypeScript (strict), Prisma, PostgreSQL, Tailwind CSS

## Commands
npm run dev    # local server on :3000
npm test       # run Vitest
npm run build  # production build
npm run lint   # ESLint + Prettier check

## Conventions
- Always use TypeScript strict mode
- Use Prisma for all database queries
- API routes in src/app/api/
- Run tests before committing

## Never
- Never modify .env or .env.local
- Never use raw SQL — always Prisma
- Never push directly to main

Run /init to auto-generate a starter CLAUDE.md. You can also place a global one at ~/.claude/CLAUDE.md for preferences that apply to all projects (like "always use bun" or "never auto-commit").

The .claude Directory — Your Project's Brain

Every Claude Code project has a .claude/ folder at the project root. This is where all configuration lives — permissions, hooks, skills, custom commands, and MCP servers. Here's what a well-configured project looks like:

settings.json — The Central Config

This is where permissions, deny rules, hooks, and MCP servers all live. Here's a production-ready example:

{
  // ─── Permissions ───
  "permissions": {
    "allow": [
      "Edit",                  // auto-approve file edits
      "Write",                 // auto-approve new files
      "Bash(npm test*)",       // auto-approve test runs
      "Bash(npm run lint)"     // auto-approve linting
    ],
    "deny": [
      "Read:.env*",             // protect secrets
      "Edit:.env*",             // can't edit them either
      "Bash(rm -rf*)"           // block dangerous commands
    ]
  },

  // ─── Hooks ───
  "hooks": {
    "PostToolUse": [
      { // Auto-format every edited file
        "matcher": "Edit|Write",
        "command": "npx prettier --write $FILE"
      }
    ]
  },

  // ─── MCP Servers ───
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": { "DATABASE_URL": "postgresql://..." }
    }
  }
}

Memory — How Claude Remembers You

Claude has two kinds of memory:

Context Window — Claude's Short-Term Memory

Everything Claude sees at once fits in a 200K token context window. Your messages, files read, command outputs, CLAUDE.md — it all lives here. When it fills up, Claude auto-summarizes older content. You can also type /compact to manually free up space.

Choosing the Right Model

Three models, three tradeoffs. You don't need Opus to rename a variable. Switch mid-session with /model or start with claude --model opus.

CLI Flags — Quick Reference

Flags you add when starting Claude. The essential ones:

Monorepo tip: Use --add-dir to give Claude access to shared packages. Example: claude --add-dir ../packages/shared --add-dir ../packages/ui

Extended Thinking

For hard problems, tell Claude to think deeper. It uses a hidden scratchpad to reason step by step before answering — like a developer whiteboarding before coding. Three levels:

Extended thinking is on by default with maximum budget. These keywords were historically used to hint at reasoning depth — Claude still responds to them, but you no longer need them. The quality of your prompt matters more than the keyword.

Skills — Reusable Workflows

If you give Claude the same instructions more than twice, save it as a skill. Just a Markdown file with a name and steps. Your team shares them via git.

---
name: deploy
description: Deploy TaskFlow to production
---

# Deploy to Production

1. Run `npm test` — all tests must pass
2. Run `npm run build` — must compile cleanly
3. Run `npm run lint` — no errors allowed
4. Commit with message "release: vX.X.X"
5. Push to main — Vercel auto-deploys
6. Verify https://taskflow.app loads

Now type /deploy and Claude runs all 6 steps. Anyone on the team can use it.

Hooks — Guaranteed Automation

Unlike prompts (which Claude might interpret differently), hooks are shell commands that always run at specific moments in Claude's lifecycle. They can't be skipped or forgotten.

"hooks": {
  "PostToolUse": [{
    "matcher": "Edit|Write",
    "command": "npx prettier --write $FILE"
  }]
}

Slash Commands — Quick Actions

Type / to see instant actions. These are built-in and don't cost any tokens:

Custom Slash Commands

Create your own slash commands in .claude/commands/. Each file becomes a command:

Run all tests in the affected
modules. If any fail, fix the
code and re-run until all pass.
Show a summary when done.

MCP Servers — Plug In Any Tool

MCP (Model Context Protocol) is like a USB port for AI. Plug in a server and Claude gains new abilities — create GitHub PRs, read Figma designs, query databases, post to Slack. It's an open standard, not Anthropic-specific, so any tool can build an MCP server.

IDE Integrations — Claude in Your Editor

Don't want to leave your editor? Claude Code works inside VS Code and JetBrains IDEs. Same capabilities, but inline with your code.

The extensions use the same Claude Code engine underneath. CLAUDE.md, skills, hooks, and MCP servers all work the same way in your IDE.

Headless Mode — No Human Needed

Run Claude from scripts with no interactive session. The -p flag sends a single prompt and returns the result. This is how you put Claude in CI/CD pipelines, cron jobs, and automation scripts.

# One-shot prompt — get a quick answer
$ claude -p "What version is this project?"
TaskFlow v2.1.0 (Next.js 15)

# JSON output — for scripts and automation
$ claude -p "List all TODO comments" --output-format json

# Pipe input — review a git diff
$ git diff | claude -p "Review this diff for bugs"

# Restrict tools for safety in CI
$ claude -p "Review this PR" --allowedTools Read,Grep

Output formats: text (default), json (structured), stream-json (real-time streaming). Use stream-json in GitHub Actions to see progress as it runs.

GitHub Actions — Claude in CI/CD

Claude Code has a built-in GitHub integration. Install it on your repo and Claude can automatically review PRs, fix failing tests, or triage issues.

name: Claude PR Review
on: [pull_request]
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: |
          npm install -g @anthropic-ai/claude-code
          claude -p "Review this PR for bugs,
            security issues, and code quality." \
            --allowedTools Read,Grep \
            --output-format stream-json

Run /install-github-app inside Claude Code to set up the GitHub integration with one command.

Agent Teams & Worktrees

For large tasks, one Claude isn't enough. A lead agent splits the work among worker agents. Each worker gets its own worktree — an isolated git checkout on a separate branch — so they can edit files simultaneously without conflicts. When done, changes merge back.

TaskFlow needs all API routes migrated to the new error handler. The lead assigns 3 workers — auth-routes, task-routes, user-routes — and the whole migration finishes in parallel.

Pricing — Max vs API

Two ways to pay: Claude Max ($100-$200/month flat, unlimited use) or API (pay per token). Rule of thumb: 10+ sessions per day → Max is cheaper. Fewer → API wins. Every response shows the token count so you always know what you're spending.

Speed Up with Terminal Aliases

Typing claude dozens of times a day gets old fast. Set up shell aliases to save keystrokes and create instant workflows:

# Quick launch
alias c='claude'                      # just type 'c'
alias cc='claude -c'                   # continue last session
alias cr='claude -r'                   # resume a past session

# One-shot commands
alias cq='claude -p'                   # quick one-shot prompt
alias creview='claude -p "review this diff for bugs"'

# Pipe-friendly
alias cdiff='git diff | claude -p "review this diff"'
alias clog='git log --oneline -20 | claude -p "summarize recent changes"'

After adding these, run source ~/.zshrc or open a new terminal. Now c launches Claude, cc continues where you left off.

Multitasking with Multiple Sessions

You're not limited to one Claude session. Open multiple terminal tabs and run separate sessions in parallel — each with its own context window.

The Write-Test Cycle — TDD with Claude

One of the most powerful patterns: give Claude a failing test and let it code until the test passes. This is test-driven development, automated.

When to Use What — CLAUDE.md vs Skills vs Commands

Three ways to give Claude instructions, each for a different purpose. New users often put everything in CLAUDE.md — here's where each belongs:

Rule of thumb: if it should always apply → CLAUDE.md. If it's a multi-step recipe → Skill. If it's a one-off instruction → Command.