The Claude Code Superuser Guide: From Developer to Agent Orchestrator

The Paradigm Shift

Claude Code is not "ChatGPT in your terminal." It's a headless developer living natively in your shell with immediate access to your filesystem, git history, and toolchain.

This guide teaches the workflows that unlock that transformation.

For strategic context on how Claude Code fits into Anthropic's enterprise platform play and developer-led GTM strategy, see Anthropic: How the Safety Company Became the Enterprise AI Standard.

The Three Fundamentals

Before tactics, internalize these principles:

1. Context is Currency

Every file you reference, every command you run, every word in your prompt consumes your 200k token budget. Power users treat context like RAM—precious and finite.

2. Agents Are Specialists, Not Generalists

Don't ask one agent to research, plan, implement, test, and document. Create specialized agents with constrained tools and clear mandates.

The assembly line beats the generalist every time.

To build specialized agents with modular skills and procedural knowledge, see The Architect's Guide to Engineering Claude Code Skills.

3. Infrastructure Beats Prompting

Better CLAUDE.md, better slash commands, and better worktree management deliver more ROI than prompt engineering ever will.

Invest in your environment, not in longer prompts.

For architectural patterns on building modular skills with the Hub-and-Spoke model, see The Architect's Guide to Engineering Claude Code Skills.

Essential Workflows

The "Compact Before Auto-Compact" Pattern

Claude auto-compacts at 75% context usage. This is too late. The model has already degraded from context bloat.

The Progressive Disclosure Pattern for CLAUDE.md

Instead of cramming everything into CLAUDE.md, structure knowledge hierarchically:

project-root/
├── CLAUDE.md                    # Concise (500-1000 words)
├── agent_docs/
│   ├── architecture.md          # Deep dives
│   ├── database_schema.md
│   ├── api_conventions.md
│   └── security_practices.md

In CLAUDE.md:

# Project Context
 
TypeScript/React SPA with Node.js backend.
 
## Key Commands
- \`npm run dev\` - Start dev servers
- \`npm test\` - Run test suite
- \`npm run build\` - Production build
 
## Documentation
 
Before working on features, read relevant documentation:
- Architecture: @agent_docs/architecture.md
- Database: @agent_docs/database_schema.md
- API conventions: @agent_docs/api_conventions.md
 
**Read these files only when relevant to your current task.**

The Checklist Pattern for Complex Tasks

For multi-item tasks (50 lint errors, 20 test failures), use a checklist:

> Run npm run lint and write all errors to LINT_ERRORS.md as a markdown checklist
 
> Fix each item in LINT_ERRORS.md one at a time. After fixing and verifying each, check it off before moving to the next.

This keeps Claude focused and prevents it from getting overwhelmed or skipping items.

Permission Modes: The Shift+Tab Cycle

Toggle permission modes with Shift + Tab:

Power User Toolkit

Custom Slash Commands

Transform repetitive prompts into keyboard shortcuts. Commands are Markdown files in .claude/commands/.

---
description: Run full TDD cycle for a feature
argument-hint: [feature-name]
allowed-tools: Bash, Read, Edit, Glob
model: sonnet
---
 
# TDD Cycle for $1
 
## Phase 1: Test Generation
1. Analyze requirements for $1
2. Create test file in tests/
3. Run test and confirm it FAILS
 
## Phase 2: Implementation
1. Write minimal code to pass test
2. Run test again
3. Iterate until pass
 
## Phase 3: Refactor
1. Review code for clarity
2. Ensure tests still pass
 
Execute autonomously.

---
description: Generate conventional commit
---
 
## Context
- Current status: !git status
- Current diff: !git diff HEAD
- Current branch: !git branch --show-current
- Recent commits: !git log --oneline -10
 
## Task
Create conventional commit with message: $ARGUMENTS
Stage all changes and push to remote.

Specialized Subagents

Create custom agents via /agents for recurring specialized workflows:

---
name: security-auditor
description: Analyzes code for OWASP vulnerabilities
tools: Read, Grep, Glob
model: sonnet
---
 
You are a paranoid security researcher.
Find vulnerabilities in the code provided.
Focus on: SQL Injection, XSS, Access Control.
Only report issues with severity ratings—do not suggest fixes.

---
name: test-engineer
description: Writes comprehensive tests
tools: Read, Grep, Write, Bash(npm test:*), Bash(pytest:*)
model: sonnet
---
 
You are a test engineer.
Write comprehensive tests, run test suites, analyze coverage.
Never modify production code.

Automation with Hooks

Hooks execute shell commands at specific lifecycle events. Configure in .claude/settings.json.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | { read file_path; if echo \"$file_path\" | grep -q '\\.ts$'; then npx prettier --write \"$file_path\"; fi; }"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.command' | { read cmd; if echo \"$cmd\" | grep -qE 'rm -rf|sudo|mkfs'; then echo '{"decision": "block", "reason": "Dangerous command blocked"}'; fi; }"
          }
        ]
      }
    ]
  }
}

The value: Code quality enforcement happens automatically, invisible to the agent. Every file Claude touches is immediately formatted and linted before you see it.

Parallel Development: The Git Worktree Revolution

Running one Claude instance is synchronous. Running multiple in the same directory causes race conditions. The solution: Git Worktrees.

The Foundation

Git worktrees allow multiple branches checked out into separate directories, sharing the same object database:

# Main project
cd ~/project
 
# Create worktrees for independent features
git worktree add ../project-frontend feature/login-ui
git worktree add ../project-backend feature/login-api
git worktree add ../project-tests feature/e2e-tests
 
# List all worktrees
git worktree list

Then launch parallel agents in separate terminals:

# Terminal 1:
cd ../project-frontend && claude
> /init
> Build the Login React component
 
# Terminal 2:
cd ../project-backend && claude
> /init
> Build the Login API endpoint
 
# Terminal 3:
cd ../project-tests && claude
> /init
> Write E2E tests for login flow

The Wave Strategy

Advanced Patterns

The Dual Claude Verification Pattern

Use one Claude to write code, another to verify with fresh context:

# Terminal 1: Implementation
cd ~/project && claude
> Implement user authentication feature
> /export auth-implementation.md
 
# Terminal 2: Verification (separate context)
cd ~/project && claude
> /clear
> Review @auth-implementation.md for security issues, edge cases, and test coverage

Separate context prevents confirmation bias.

Extended Thinking for Complex Problems

# One-time thinking
> ultrathink: design a caching layer for our API that handles invalidation, scales horizontally, and supports different cache strategies per endpoint
 
# View thinking process
# Press Ctrl+O to see Claude's internal reasoning

Security and Permissions

The Settings Hierarchy

Resolution order: Project local → Project → User (most specific wins)

Permission Patterns

{
  "permissions": {
    "allow": [
      "Read(*)",
      "Grep(*)",
      "Bash(git log:*)",
      "Bash(npm test:*)"
    ]
  }
}

{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Bash(rm:*)",
      "Bash(sudo:*)"
    ]
  }
}

Wildcard patterns:

• * matches all: Read(*) allows reading any file
• ** matches nested paths: Read(./src/**) allows all files in src/
• :* matches arguments: Bash(git:*) allows any git command

The "YOLO" Flag

The Complete Superuser Workflow

Project Setup

Daily Development

# Monitor context, compact proactively
> /context  # Check usage
> /compact preserve database schema, discard debugging output  # At 60-70%
 
# Toggle auto-accept when you trust direction
# Shift+Tab → auto-accept mode
 
# Use plan mode for exploration
# Shift+Tab twice → plan mode

Cost Optimization

> /model   # Switch models
> /cost    # Monitor spending

The Bottom Line

The most effective engineers treat Claude not as a chatbot but as a high-velocity junior developer that requires precise instruction, robust infrastructure, and automated guardrails.

The future belongs to those who orchestrate synthetic labor forces effectively.