Claude Code Power User Guide: Every Command, Shortcut, and Hidden Feature

# Project: MyApp
 
## Stack
- Next.js 16, TypeScript strict, Tailwind CSS, Prisma + PostgreSQL
- pnpm for package management
- Vitest for unit tests, Playwright for E2E
 
## Conventions
- Components: PascalCase, co-located tests (Component.test.tsx)
- API routes: zod validation on all inputs, never trust req.body
- Database: always use transactions for multi-table writes
- Commits: conventional commits (feat/fix/chore/docs)
 
## Commands
- `pnpm dev` — start dev server
- `pnpm test` — run unit tests
- `pnpm test:e2e` — run Playwright suite
- `pnpm build` — production build (MUST pass before PR)
 
## Rules
- Never modify migration files once committed
- All API responses use { data, error } shape
- No `any` types — use `unknown` + type narrowing

# In CLAUDE.md
paths:
  src/app/api/**:
    - Always validate with zod before business logic
    - Return 422 for validation errors, not 400
  src/components/**:
    - No inline styles — Tailwind only
    - Accessibility: every interactive element needs aria-label

# Start directly in plan mode
claude --permission-mode plan
 
# Start in auto (bypassPermissions for CI/scripts)
claude --permission-mode bypassPermissions -p "run all tests and fix failures"

# Context management
/clear          # Clear conversation (fresh context, same session)
/compact [focus]  # Compress context — optionally tell it what to preserve
/cost           # Show token usage and cost for current session
/context        # Visual grid of context usage
 
# Navigation
/resume         # Pick up a previous session
/rename [name]  # Name the current session
/branch [name]  # Fork conversation (alias: /fork)
 
# Code review workflow
/diff           # Interactive diff viewer for pending changes
/copy           # Copy last response to clipboard
/export         # Export full conversation
 
# Agent control
/plan [desc]    # Enter plan mode, optionally describe the task
/loop [interval]  # Schedule a recurring task (e.g. /loop 5m "run tests")
/agents         # Manage running sub-agents
 
# MCP
/mcp            # Interactive MCP server manager
/hooks          # Manage lifecycle hooks
 
# Advanced
/btw <question>   # Ask a side question without spending context
/effort [level]   # Set reasoning effort: low / med / high
/voice          # Push-to-talk (20 languages)
/pr-comments [PR] # Pull GitHub PR comments into context
/insights       # Analyze session efficiency

// .mcp.json (project-level, commit to VCS)
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": { "DATABASE_URL": "${DATABASE_URL}" }
    },
    "browser": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}

# List all connected MCP servers
claude mcp list
 
# Run Claude Code AS an MCP server (expose it to other tools)
claude mcp serve

# Claude Code creates an isolated branch + worktree automatically
claude --worktree feature-auth
 
# Or configure in CLAUDE.md for agent isolation

agents:
  isolation: worktree     # each agent gets its own working tree
  sparsePaths:            # only check out what the agent needs
    - src/auth/
    - src/api/
    - tests/auth/

/batch
# Claude prompts for task list, spawns one worktree per task, runs concurrently

# 1M token context for large codebases (Opus 4.6 on Max/Team/Ent plans)
# Auto-compact kicks in at ~95% capacity — set focus before it triggers:
/compact preserve all type definitions and the API contract we designed

# query_claude_code.py
import subprocess, json, sys
 
def run_claude(prompt: str, cwd: str = ".") -> str:
    result = subprocess.run(
        ["claude", "-p", prompt, "--output-format", "json"],
        capture_output=True, text=True, cwd=cwd
    )
    if result.returncode != 0:
        raise RuntimeError(result.stderr)
    return json.loads(result.stdout)["result"]
 
# Use in CI: auto-generate changelogs
diff = subprocess.run(["git", "diff", "HEAD~1"], capture_output=True, text=True).stdout
changelog = run_claude(f"Write a user-facing changelog entry for this diff:\n{diff}")
print(changelog)

# Pipe stdin
cat error.log | claude -p "Find the root cause and suggest a fix"
 
# Cost cap (never spend more than $2 on one task)
claude -p "refactor the auth module" --max-budget-usd 2
 
# Stream JSON output for integration
claude -p "list all TODO comments in src/" --output-format json | jq '.result'

CLAUDE_CODE_EFFORT_LEVEL=low claude -p "rename all instances of UserModel to User"