Forem: Lukas Fryc

Claude Code Hooks: Complete Guide with 20+ Ready-to-Use Examples (2026)

Lukas Fryc — Mon, 09 Feb 2026 12:41:32 +0000

Claude Code hooks are shell commands, LLM prompts, or subagents that execute automatically at specific points in Claude Code's lifecycle. They let you enforce formatting on every file write, block dangerous commands before they run, inject context after compaction, and automate any repetitive workflow — without relying on the AI to remember.

Key Takeaway: Hooks give you deterministic control over a probabilistic system. Instead of hoping Claude Code remembers to lint your files, a PostToolUse hook runs Prettier automatically, every single time.

This guide covers everything: setup, all 12 hook events, 20+ ready-to-use configurations, advanced prompt/agent hooks, and troubleshooting. Whether you've never configured a hook or want to build production-grade automation, start here.

New to Claude Code? Start with Claude Code best practices first — hooks build on top of a solid CLAUDE.md setup.

What you'll learn:

What hooks are and why they matter
Your first hook in 2 minutes
All 12 hook events explained
20+ ready-to-use configurations
Advanced: prompt hooks and agent hooks
When to use hooks vs. CLAUDE.md vs. MCP
Troubleshooting common issues

What Are Claude Code Hooks?

Every Claude Code session follows a lifecycle: session starts, user prompts, tools execute, agent responds. Hooks let you inject your own code at any point in that cycle.

Think of them like Git hooks (pre-commit, post-merge), but for AI-assisted development. Git hooks run before/after Git operations. Claude Code hooks run before/after any Claude Code action — file writes, bash commands, even agent decisions.

Why not just put instructions in CLAUDE.md?

CLAUDE.md is a suggestion. Claude Code usually follows it, but it's not guaranteed. Hooks are deterministic — they always run. Use CLAUDE.md for guidelines ("prefer Bun over npm"). Use hooks for rules that must never be broken ("always format with Prettier", "never touch .env files").

Three types of hooks:

Type	What it does	Best for
Command	Runs a shell script	Formatting, linting, logging, security checks
Prompt	Asks an LLM a yes/no question	Complex decisions that shell scripts can't handle
Agent	Spawns a multi-turn subagent	Verification tasks requiring file reads + command execution

Your First Hook: Auto-Format Every File Edit

Let's set up a hook that runs Prettier on every file Claude Code writes or edits. Two minutes, zero complexity.

Step 1: Open your project's hook settings:

# Project-level (shared with team via git)
.claude/settings.json

# Or user-level (applies to all projects)
~/.claude/settings.json

Step 2: Add this configuration:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write 2>/dev/null; exit 0"
          }
        ]
      }
    ]
  }
}

Step 3: That's it. Every file Claude Code writes or edits now gets auto-formatted.

What's happening:

Claude Code writes a file (triggers PostToolUse for Write or Edit tools)
Hook receives JSON with the file path via stdin
jq extracts the path, Prettier formats the file
exit 0 ensures the hook never blocks Claude Code (even if Prettier fails on a non-supported file)

Verify it works: Ask Claude Code to create any file. Check git diff — you'll see Prettier's formatting applied automatically.

How Hooks Work: Input, Output, Exit Codes

Every hook receives JSON context on stdin and communicates through exit codes and stdout.

Input: JSON describing the current event. For a PreToolUse Bash hook:

{
  "session_id": "abc123",
  "cwd": "/your/project",
  "hook_event_name": "PreToolUse",
  "tool_name": "Bash",
  "tool_input": {
    "command": "rm -rf node_modules"
  }
}

Exit codes determine what happens:

Exit code	Meaning	Effect
0	Success	Action proceeds. Stdout parsed as JSON or added as context.
2	Block	Action is blocked. Stderr shown as feedback.
Other	Non-blocking error	Action proceeds. Stderr shown in verbose mode.

JSON output (optional, on stdout) controls behavior:

{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "deny",
    "permissionDecisionReason": "This command is blocked by project policy"
  }
}

All 12 Hook Events

Claude Code has 12 lifecycle events where hooks can fire. Here's the complete reference, grouped by category.

Session Lifecycle

Event	When	Can block?	Matcher values
SessionStart	Session begins or resumes	No	`startup`, `resume`, `compact`, `clear`
PreCompact	Before context compaction	No	`manual`, `auto`
SessionEnd	Session terminates	No	`clear`, `logout`, `other`

SessionStart is particularly useful for injecting dynamic context:

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "compact",
        "hooks": [
          {
            "type": "command",
            "command": "echo 'Reminder: Use Bun, not npm. Current sprint: auth refactor. Run bun test before committing.'"
          }
        ]
      }
    ]
  }
}

This injects reminders after every compaction — so Claude Code never forgets your project context, even in long sessions.

Pro tip: Use SessionStart with the startup matcher to set environment variables:

#!/bin/bash
# .claude/hooks/set-env.sh
if [ -n "$CLAUDE_ENV_FILE" ]; then
  echo "export NODE_ENV=development" >> "$CLAUDE_ENV_FILE"
  echo "export DEBUG=true" >> "$CLAUDE_ENV_FILE"
fi
exit 0

Tool Lifecycle

Event	When	Can block?	Matcher values
PreToolUse	Before tool executes	Yes	Tool name: `Bash`, `Edit`, `Write`, `Read`, `Glob`, `Grep`, `WebFetch`, `mcp__*`
PostToolUse	After tool succeeds	No	Same as PreToolUse
PostToolUseFailure	After tool fails	No	Same as PreToolUse
PermissionRequest	Permission dialog appears	Yes	Same as PreToolUse

PreToolUse is the workhorse. Use it to block, modify, or auto-approve tool calls:

{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "allow",
    "permissionDecisionReason": "Auto-approved by project policy"
  }
}

Three permission decisions:

"allow" — bypass permission system, auto-approve
"deny" — block the tool call
"ask" — show the normal permission prompt

PostToolUse is great for reactions: formatting, logging, running tests. It can't block (the action already happened), but it can give Claude Code feedback that influences its next steps.

Agent Lifecycle

Event	When	Can block?	Matcher values
SubagentStart	Subagent spawns	No	Agent type: `Bash`, `Explore`, `Plan`
SubagentStop	Subagent finishes	Yes	Same as SubagentStart
Stop	Main agent finishes	Yes	None (always fires)

Stop hooks are powerful — they can prevent Claude Code from finishing until conditions are met:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/verify-tests.sh"
          }
        ]
      }
    ]
  }
}

Critical: Always check stop_hook_active to prevent infinite loops:

#!/bin/bash
INPUT=$(cat)
if [ "$(echo "$INPUT" | jq -r '.stop_hook_active')" = "true" ]; then
  exit 0  # Let Claude stop — we already verified
fi
# Your verification logic here

User Interaction

Event	When	Can block?	Matcher values
UserPromptSubmit	User submits a prompt	Yes	None (always fires)
Notification	Claude sends notification	No	`permission_prompt`, `idle_prompt`

UserPromptSubmit can validate, transform, or block user prompts before Claude Code processes them.

Ready-to-Use Hook Configurations

Copy-paste these into your .claude/settings.json. Each one solves a real workflow problem.

Security and Protection

1. Block destructive commands

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'CMD=$(jq -r \".tool_input.command\" <<< \"$(cat)\"); for p in \"rm -rf /\" \"rm -rf ~\" \"drop table\" \"DROP TABLE\" \"truncate\" \"TRUNCATE\" \"--force\" \"push.*--force\"; do if echo \"$CMD\" | grep -qiE \"$p\"; then echo \"Blocked: pattern \\\"$p\\\" detected\" >&2; exit 2; fi; done; exit 0'"
          }
        ]
      }
    ]
  }
}

2. Protect sensitive files from writes

Save as .claude/hooks/protect-files.sh:

#!/bin/bash
INPUT=$(cat)
FILE=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')

PROTECTED=(".env" ".env.local" "secrets/" ".git/" "package-lock.json" "pnpm-lock.yaml")

for pattern in "${PROTECTED[@]}"; do
  if [[ "$FILE" == *"$pattern"* ]]; then
    echo "Protected file: $pattern" >&2
    exit 2
  fi
done
exit 0

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/protect-files.sh"
          }
        ]
      }
    ]
  }
}

3. Audit log all bash commands

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'jq -r \".tool_input.command\" <<< \"$(cat)\" | while read cmd; do echo \"$(date +%Y-%m-%dT%H:%M:%S) $cmd\" >> \"$CLAUDE_PROJECT_DIR\"/.claude/command-audit.log; done; exit 0'"
          }
        ]
      }
    ]
  }
}

Code Quality

4. Auto-format with Prettier (already shown above)

5. Auto-lint with ESLint and fix

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'FILE=$(jq -r \".tool_input.file_path\" <<< \"$(cat)\"); if [[ \"$FILE\" == *.ts || \"$FILE\" == *.tsx || \"$FILE\" == *.js || \"$FILE\" == *.jsx ]]; then npx eslint --fix \"$FILE\" 2>/dev/null; fi; exit 0'"
          }
        ]
      }
    ]
  }
}

6. Run type checking after TypeScript changes

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'FILE=$(jq -r \".tool_input.file_path\" <<< \"$(cat)\"); if [[ \"$FILE\" == *.ts || \"$FILE\" == *.tsx ]]; then npx tsc --noEmit 2>&1 | head -20; fi; exit 0'",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

7. Enforce test coverage — prevent stopping without tests

Save as .claude/hooks/verify-tests.sh:

#!/bin/bash
INPUT=$(cat)

# Prevent infinite loop
if [ "$(echo "$INPUT" | jq -r '.stop_hook_active')" = "true" ]; then
  exit 0
fi

# Run tests
if ! npm test --silent 2>/dev/null; then
  echo "Tests are failing. Fix them before finishing." >&2
  exit 2
fi

exit 0

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/verify-tests.sh",
            "timeout": 60
          }
        ]
      }
    ]
  }
}

Workflow Automation

8. Inject context after compaction

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "compact",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'echo \"Post-compaction context: Use Bun (not npm). Run bun test before committing. Current branch: $(git -C \"$CLAUDE_PROJECT_DIR\" branch --show-current 2>/dev/null || echo unknown). Last commit: $(git -C \"$CLAUDE_PROJECT_DIR\" log --oneline -1 2>/dev/null || echo none).\"'"
          }
        ]
      }
    ]
  }
}

9. Set environment variables on session start

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "startup",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'if [ -n \"$CLAUDE_ENV_FILE\" ]; then echo \"export NODE_ENV=development\" >> \"$CLAUDE_ENV_FILE\"; echo \"export NEXT_TELEMETRY_DISABLED=1\" >> \"$CLAUDE_ENV_FILE\"; fi; exit 0'"
          }
        ]
      }
    ]
  }
}

10. Auto-run tests when test files change

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'FILE=$(jq -r \".tool_input.file_path\" <<< \"$(cat)\"); if [[ \"$FILE\" == *.test.* || \"$FILE\" == *.spec.* ]]; then npx vitest run \"$FILE\" 2>&1 | tail -5; fi; exit 0'",
            "timeout": 30,
            "async": true
          }
        ]
      }
    ]
  }
}

11. Notify on branch switch (inject branch context)

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "startup|resume",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'BRANCH=$(git -C \"$CLAUDE_PROJECT_DIR\" branch --show-current 2>/dev/null); echo \"Current branch: $BRANCH. Recent commits: $(git -C \"$CLAUDE_PROJECT_DIR\" log --oneline -3 2>/dev/null)\"'"
          }
        ]
      }
    ]
  }
}

Notifications

12. Desktop notification on permission request (macOS)

{
  "hooks": {
    "Notification": [
      {
        "matcher": "permission_prompt",
        "hooks": [
          {
            "type": "command",
            "command": "osascript -e 'display notification \"Claude Code needs your input\" with title \"Claude Code\" sound name \"Ping\"'"
          }
        ]
      }
    ]
  }
}

13. Desktop notification on task complete (macOS)

{
  "hooks": {
    "Notification": [
      {
        "matcher": "idle_prompt",
        "hooks": [
          {
            "type": "command",
            "command": "osascript -e 'display notification \"Task complete — ready for next instruction\" with title \"Claude Code\" sound name \"Glass\"'"
          }
        ]
      }
    ]
  }
}

14. Linux notifications

{
  "hooks": {
    "Notification": [
      {
        "matcher": "permission_prompt|idle_prompt",
        "hooks": [
          {
            "type": "command",
            "command": "notify-send 'Claude Code' 'Needs your attention' --urgency=normal"
          }
        ]
      }
    ]
  }
}

MCP Tool Hooks

15. Log all MCP operations

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "mcp__.*",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'INPUT=$(cat); TOOL=$(echo \"$INPUT\" | jq -r \".tool_name\"); echo \"$(date +%H:%M:%S) $TOOL\" >> \"$CLAUDE_PROJECT_DIR\"/.claude/mcp-audit.log; exit 0'"
          }
        ]
      }
    ]
  }
}

16. Rate-limit specific MCP tools

#!/bin/bash
# .claude/hooks/rate-limit-mcp.sh
INPUT=$(cat)
TOOL=$(echo "$INPUT" | jq -r '.tool_name')
LOGFILE="$CLAUDE_PROJECT_DIR/.claude/mcp-rate.log"

# Count calls in last 60 seconds
RECENT=$(grep -c "$TOOL" "$LOGFILE" 2>/dev/null || echo 0)
echo "$(date +%s) $TOOL" >> "$LOGFILE"

if [ "$RECENT" -gt 10 ]; then
  echo "Rate limit: $TOOL called $RECENT times in the last minute" >&2
  exit 2
fi
exit 0

Custom Permission Policies

17. Auto-approve WebSearch and WebFetch

Tired of approving every domain one by one? This hook eliminates the nagging:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "WebFetch|WebSearch",
        "hooks": [
          {
            "type": "command",
            "command": "echo '{\"decision\":\"allow\"}'",
            "timeout": 5
          }
        ]
      }
    ]
  }
}

WebSearch and WebFetch are read-only — auto-approving them is safe. See the full writeup for why this works and how to clean up your existing domain allowlist.

18. Auto-approve safe read operations

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Read|Glob|Grep",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'echo \"{\\\"hookSpecificOutput\\\":{\\\"hookEventName\\\":\\\"PreToolUse\\\",\\\"permissionDecision\\\":\\\"allow\\\"}}\"'"
          }
        ]
      }
    ]
  }
}

19. Deny web access in offline mode

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "WebFetch|WebSearch",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'echo \"Web access disabled by project policy\" >&2; exit 2'"
          }
        ]
      }
    ]
  }
}

Advanced: Prompt Hooks and Agent Hooks

Most articles only cover command hooks (shell scripts). But Claude Code supports two more powerful types that almost nobody talks about.

Prompt Hooks: LLM-Powered Decisions

When your validation logic is too complex for a bash script, let an LLM decide:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "prompt",
            "prompt": "Review the conversation. Did the user's request get fully completed? Check: all files created, tests passing, no TODO comments left. Respond with {\"ok\": true} if done, or {\"ok\": false, \"reason\": \"what remains\"} if not.",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

The LLM must respond with {"ok": true} or {"ok": false, "reason": "..."}. If ok is false, Claude Code continues working.

When to use prompt hooks:

Code review quality gates ("does this follow our patterns?")
Semantic validation ("is this commit message descriptive enough?")
Complex decision-making that can't be reduced to grep/regex

Agent Hooks: Multi-Turn Verification

Agent hooks can read files, run commands, and make multi-step decisions:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "agent",
            "prompt": "Verify the work is complete: 1) Run the test suite. 2) Check for any TypeScript errors. 3) Verify no console.log statements were left in production code. Report your findings. $ARGUMENTS",
            "timeout": 120
          }
        ]
      }
    ]
  }
}

Agent hooks can use up to 50 tool turns — they can read files, grep for patterns, run bash commands, and make complex assessments.

When to use agent hooks:

End-of-task verification (tests pass, types check, no debug code)
Multi-file consistency checks
Complex pre-deployment validations

Combining All Three Types

A production-grade setup might layer all three:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write 2>/dev/null; exit 0"
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/verify-tests.sh"
          },
          {
            "type": "prompt",
            "prompt": "Check if the implementation matches what the user asked for. Are there any edge cases missed? Respond with {\"ok\": true} or {\"ok\": false, \"reason\": \"...\"}.",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

Command hooks handle the deterministic stuff (formatting). Prompt hooks handle the semantic stuff (does this match the request?). Each runs in sequence — if the command hook blocks (exit 2), the prompt hook doesn't run.

Hooks vs. CLAUDE.md vs. MCP: When to Use What

Claude Code has several extension points. Here's when to use each one:

Need	Use	Why
"Always format files on save"	Hook (PostToolUse)	Must happen every time, no exceptions
"Prefer Bun over npm"	CLAUDE.md	A preference, not a hard rule
"Never modify .env files"	Hook (PreToolUse)	Hard block, not a suggestion
"Our API routes follow this pattern"	.claude/rules/	Contextual guidance
"Run /deploy to ship"	Custom command	Reusable workflow
"Access our Jira board"	MCP server	External service integration
"Log every command to audit file"	Hook (PostToolUse)	Side effect, transparent to Claude
"Verify tests pass before stopping"	Hook (Stop)	Enforcement gate

Rule of thumb: If it's a suggestion, use CLAUDE.md. If it's a requirement, use hooks. If it's an external service, use MCP. If it's a reusable workflow, use custom commands.

Troubleshooting

"My hook isn't firing"

Check configuration loaded: Run /hooks in Claude Code to see active hooks
Matcher is case-sensitive: bash won't match Bash. Tool names are PascalCase.
Wrong event: PostToolUse fires after success only. For failures, use PostToolUseFailure.
File permissions: Ensure your script is executable: chmod +x .claude/hooks/your-script.sh

"JSON validation failed" error

Your shell profile (.bashrc, .zshrc) is printing output that corrupts the JSON. Fix:

# In your .bashrc/.zshrc — wrap interactive-only output
if [[ $- == *i* ]]; then
  echo "Welcome!"  # Only runs in interactive shells
fi

"Hook blocks everything" (infinite Stop loop)

Your Stop hook keeps blocking Claude Code from finishing. Always check stop_hook_active:

#!/bin/bash
INPUT=$(cat)
if [ "$(echo "$INPUT" | jq -r '.stop_hook_active')" = "true" ]; then
  exit 0  # Allow stop — we already had our chance
fi
# Your logic here

"jq: command not found"

Install jq — it's required for parsing JSON input:

# macOS
brew install jq

# Ubuntu/Debian
sudo apt-get install jq

# Or use Python as fallback
python3 -c "import sys,json; print(json.load(sys.stdin)['tool_input']['file_path'])"

Testing hooks manually

Don't guess — test directly:

# Simulate a Bash PreToolUse event
echo '{"tool_name":"Bash","tool_input":{"command":"rm -rf /"}}' | ./.claude/hooks/block-dangerous.sh
echo "Exit code: $?"

# Expected: exit code 2 (blocked)

Viewing hook execution in real-time

# Start Claude Code with debug output
claude --debug

# Or toggle verbose mode during a session
# Press Ctrl+O

Frequently Asked Questions

What are Claude Code hooks?

Hooks are user-defined shell commands, LLM prompts, or subagents that run automatically at specific points in Claude Code's lifecycle. They provide deterministic control — ensuring actions like formatting, linting, or security checks always happen, rather than relying on the LLM to remember.

Where do I configure Claude Code hooks?

In JSON settings files at three levels: ~/.claude/settings.json (all projects), .claude/settings.json (single project, shareable via git), and .claude/settings.local.json (project-specific, gitignored). Use the /hooks menu in Claude Code to view and manage your hooks.

Can hooks block dangerous commands?

Yes. PreToolUse hooks can block any tool call by returning exit code 2 or outputting a JSON decision with permissionDecision set to "deny". This is commonly used to prevent destructive commands like rm -rf, DROP TABLE, or force pushes.

What's the difference between command, prompt, and agent hooks?

Command hooks run shell scripts — best for deterministic tasks like formatting or logging. Prompt hooks use an LLM for yes/no decisions when logic is too complex for shell scripts. Agent hooks spawn a multi-turn subagent that can read files, run commands, and verify complex conditions.

Do hooks slow down Claude Code?

Command hooks add minimal overhead — typically milliseconds. Prompt and agent hooks are slower (they call the LLM), but you can set timeouts. Use async: true for long-running hooks that don't need to block the current action.

Can I use hooks with MCP tools?

Yes. Use regex matchers like mcp__github__.* to target specific MCP server tools, or mcp__.* to match all MCP tools.

I'm Lukas — I build AI-powered dev tools for solo founders. More on Claude Code workflows and AI-native development on my blog.

Cursor vs Claude Code: Which Ships Faster? (2026)

Lukas Fryc — Mon, 09 Feb 2026 10:00:16 +0000

Cursor vs Claude Code — which one should you actually use? The short answer: use Claude Code for building features and large changes. Use Cursor for editing, reviewing, and exploring code. Use both if you can afford it.

I've been shipping production code with both tools for over a year. Not testing them on toy projects — running 6 real SaaS products simultaneously. Here's what I've learned about when each tool shines and where it falls short.

What is Cursor?

Cursor is a code editor built as a fork of VS Code with AI deeply integrated into the editing experience. You write code in a familiar IDE, and AI assists with autocomplete, inline edits, and chat-based code generation.

Think of Cursor as VS Code with an AI copilot sitting next to you. You're still driving — the AI helps you type faster, understand code, and catch mistakes.

What is Claude Code?

Claude Code is Anthropic's terminal-based AI coding agent. Instead of sitting inside an editor, it runs as a command-line tool that autonomously reads your codebase, plans changes, writes code across multiple files, runs tests, and iterates until the task is done.

Think of Claude Code as an autonomous developer you delegate tasks to. You describe what you need, and it plans the approach and executes across your entire project.

This distinction — AI-enhanced editor vs. autonomous coding agent — is the fundamental difference that everything else flows from.

Side-by-Side Comparison

Feature	Cursor	Claude Code
Interface	VS Code (GUI)	Terminal (CLI)
AI Model	Multiple (GPT-4o, Claude, etc.)	Claude only (Anthropic)
Workflow	You write, AI assists	AI writes, you review
Autocomplete	Fast Tab completion	No autocomplete
Multi-file edits	One file at a time (mostly)	Plans across entire codebase
Autonomous execution	Limited agent mode	Full autonomy — runs tests, fixes errors
Project memory	Per-session context	CLAUDE.md + persistent rules
Extensibility	VS Code extensions	Custom commands, skills, kits
Price	$20/mo (Pro)	$100–$200/mo (Max)
Best for	Editing, exploring, small changes	Building, refactoring, debugging

When Cursor Wins

Inline Edits and Autocomplete

Cursor's Tab completion is genuinely fast. You start typing, it predicts the next 5–10 lines, and you tab through. For writing boilerplate, implementing interfaces, or filling in repetitive patterns, nothing beats it.

Claude Code doesn't do autocomplete. It's not trying to. Different tool, different job.

Code Exploration

When you're reading unfamiliar code, Cursor lets you highlight a function and ask "what does this do?" with full IDE context. You see the answer inline, next to the code. The visual feedback loop is tight.

With Claude Code, you'd ask the same question in the terminal. It works, but you're mentally switching between terminal and editor.

Small, Precise Edits

Need to rename a variable in 3 files? Fix a typo in a CSS class? Change an error message? Cursor handles these in seconds with Cmd+K inline edits.

Claude Code can do it too, but it's overkill. You're launching an agent to change one word.

Visual Diffs and Code Review

Cursor shows AI-generated changes as inline diffs. You see exactly what changed, highlighted in your editor with full surrounding context. For reviewing generated code, this visual feedback helps you catch issues faster than scanning terminal output.

When Claude Code Wins

Multi-File Features

"Add authentication with magic links, create the API routes, update the database schema, add the UI components, and write tests."

Cursor would need you to do this file by file, prompting in each one. Claude Code takes the whole task, plans it, and executes across 10–15 files in one shot. It reads your existing code, understands your patterns, and follows them.

This is where the productivity gap is massive. What takes 45 minutes of back-and-forth in Cursor takes one prompt in Claude Code.

Refactoring at Scale

"Migrate all API routes from Pages Router to App Router." "Convert all class components to hooks." "Replace Moment.js with date-fns across the entire codebase."

These are Claude Code's bread and butter. It reads the full codebase, understands the patterns, and makes consistent changes everywhere. In Cursor, you'd be doing this file by file, hoping you don't miss one.

Complex Debugging

When a bug spans multiple files — a state management issue that touches the store, a component, and an API route — Claude Code can read all relevant files, form a hypothesis, and fix it. It follows the data flow across your entire project.

Cursor gives you AI in one file at a time. You can reference other files, but you're still driving the investigation manually.

Autonomous Iteration

Claude Code runs your tests, sees failures, and fixes them. It runs the linter, fixes the warnings. It builds the project, catches type errors, and resolves them. This loop happens automatically.

In Cursor, you run the test, copy the error, paste it into chat, wait for a fix, apply it, run the test again. Each cycle is 30–60 seconds of manual work.

Persistent Project Context

Claude Code reads your CLAUDE.md file and .claude/rules/ directory at the start of every session. It remembers your architecture, coding standards, and project rules without you re-explaining anything.

This is the biggest productivity unlock for projects you work on daily. Configure it once, and Claude Code follows your patterns consistently forever. For a full guide on how to set this up properly, see my 15 Claude Code best practices — especially tips #1–4 on project setup.

Pricing: The Real Math

Cursor

Free: 2,000 completions + 50 slow premium requests/month
Pro ($20/mo): Unlimited completions + 500 fast premium requests
Business ($40/mo): Admin controls, enforced privacy

Claude Code

Max Plan ($100/mo): 5x usage cap — good for moderate daily use
Max Plan ($200/mo): 20x usage cap — heavy daily use
API Direct: Pay per token — no cap, but costs add up fast

Reality check: If you're coding 4–6 hours daily with Claude Code, the $200/month plan is the sweet spot. Cursor Pro at $20/month is 10x cheaper, but you'll hit the 500 request limit in 2–3 days of heavy use.

For solo founders on a budget: start with Cursor Pro. When you're shipping features and need speed over savings, add Claude Code.

The "Both" Workflow

Most productive developers I know use both. Here's the pattern:

Claude Code for:

Starting new features from scratch
Large refactors across multiple files
Complex debugging sessions
Setting up infrastructure (CI/CD, configs, deployments)
Writing tests for existing code

Cursor for:

Day-to-day editing and code review
Quick fixes and small changes
Reading and understanding unfamiliar code
Inline documentation and comments
Pair programming (you + AI side by side)

A typical day looks like this:

Morning: Open terminal, describe today's feature to Claude Code
Claude Code builds the scaffolding across 10+ files
Open Cursor to review, tweak, and polish the generated code
Use Claude Code again for the next big chunk
Cursor for final cleanup and small fixes

What Makes Claude Code Different

Beyond the terminal-vs-IDE distinction, Claude Code has properties that set it apart from any IDE-based AI tool:

Persistent context. Claude Code reads your .claude/ directory — project rules, coding standards, architecture decisions. Every session starts with full project understanding, not from zero.

Tool use. It runs shell commands, reads files, searches codebases, runs tests. It's not just generating text — it's executing a workflow.

Planning ability. For complex tasks, Claude Code creates a plan, breaks it into steps, and executes them in order. Cursor's agent mode does some of this, but Claude Code's planning is more thorough for multi-step tasks.

Extensibility. You can add custom commands, skills, and knowledge files that change how Claude Code works for your specific project. I've built domain-specific kits that turn Claude Code into an expert for marketing, QA, product management, and more — complete with specialized commands and workflows.

Verdict

There's no single "better" tool. But here's the decision tree:

Choose Cursor if:

You want AI to enhance your existing editing workflow
You prefer visual feedback and inline suggestions
Budget is tight ($20/month vs $100–$200/month)
You work mostly on small-to-medium changes

Choose Claude Code if:

You want AI to build entire features autonomously
You're comfortable working in the terminal
You value speed over cost
You frequently do multi-file changes and refactors

Choose both if:

You ship code daily and want maximum productivity
You're a solo founder wearing multiple hats
Different tasks genuinely need different tools

The tools aren't competing for the same job. Cursor makes you a faster editor. Claude Code gives you an autonomous engineering partner. The best setup is having both in your toolkit.

What's your setup? Cursor, Claude Code, or both? I'm curious how other developers split the work between them.

I'm Lukas — I run 6 SaaS projects solo with Claude Code. I write about AI-native development workflows on my blog.

I Replaced My Marketing Team with Claude Code

Lukas Fryc — Mon, 09 Feb 2026 09:57:41 +0000

I don't have a marketing team. I have 49 slash commands.

I run 6 SaaS projects solo. I'm a developer — 15 years of writing code. Marketing? I couldn't tell you the difference between TOFU and tofu until my AI explained it. (Top-of-funnel, apparently.)

But my blog is publishing SEO-optimized content, tracking keyword rankings, building backlinks, running outreach campaigns, and monitoring Reddit and Hacker News for opportunities — all from my terminal.

Here's exactly what I built and how it works.

The Problem

Solo founders have two options for marketing:

Learn it yourself — spend months studying SEO, content strategy, funnel design, and email marketing. Time you could be building product.
Hire someone — $3K-5K/month for a part-time marketing person. Multiply that by 6 projects.

I wanted option 3: build an AI that does it for me.

Not a chatbot that suggests blog topics. An actual system — with strategy, data pipelines, content production, and analytics — that runs from my terminal.

What I Actually Built

I built Marketing OS — a Claude Code project that turns slash commands into an autonomous marketing team. The file structure looks like this:

marketing-os/
├── .claude/
│   ├── commands/        # 49 marketing commands
│   ├── guides/          # Step-by-step workflows
│   ├── knowledge/       # SEO, GEO, conversion expertise
│   └── settings.json    # Permissions and hooks
├── config/
│   ├── strategy.md              # 90-day marketing plan
│   ├── product-context.md       # Brand voice, audience, positioning
│   ├── content-inventory.json   # Keyword tracking (14 keywords, 3 funnels)
│   └── brand-voice-examples.md  # Real writing patterns
├── content/
│   ├── drafts/          # Content pipeline
│   └── published/       # Archive
├── data/
│   ├── keywords/        # Ahrefs research cache
│   ├── rankings/        # Google Search Console data
│   └── competitors/     # Competitive analysis
└── outreach/
    ├── templates/       # Email templates
    └── campaigns/       # Outreach tracking

This isn't a toy. It's a production system with real integrations — Ahrefs for SEO intelligence, Google Search Console for rankings, ForumScout for social listening. Every piece of data is cached, tracked, and version-controlled in git.

The Roles It Replaces

Here's what each "marketing person" does and the commands that replace them.

SEO Specialist → /keywords, /rankings, /opportunities

When I type /keywords "claude code", the system:

Checks my domain's competitive position (DR 0 — brand new)
Pulls keyword data from Ahrefs (volume, difficulty, traffic potential)
Filters for keywords I can actually rank for (winnability score)
Shows me the 3 best options with reasoning

Real output from my system:

Priority 1 — Start Now
┌──────────────────────────┬────────┬────────┬─────┬─────────────┐
│ Keyword                  │ Vol US │ Global │ KD  │ Winnability  │
├──────────────────────────┼────────┼────────┼─────┼─────────────┤
│ claude code vs cursor    │ 3,300  │ 11,000 │  2  │ 92 ✅       │
│ claude code hooks        │ 1,700  │  4,900 │  —  │ 78 ✅       │
│ claude code best practices│ 1,100 │  3,300 │  —  │ 85 ✅       │
│ seo for developers       │   600  │  1,000 │ 20  │ 80 ✅       │
└──────────────────────────┴────────┴────────┴─────┴─────────────┘

That's real data. "Claude code vs cursor" has 3,300 monthly searches in the US, keyword difficulty of 2, and a DR 17 blog sitting at #3 in Google. Beatable.

I didn't research any of this. The AI did. I just typed /keywords.

Content Writer → /draft

/draft is a 12-step content pipeline in a single command:

Check if I already wrote about this topic (dedup)
Load my product context, brand voice, and claims
Research the keyword with Ahrefs (I choose the depth: 5, 15, or 30 credits)
Analyze search intent from the SERP
Find authoritative external sources and verify every URL exists
Generate an outline for my approval
Write the full post with SEO optimization
Add GEO elements (answer boxes, FAQ, citable stats) for AI chatbot citations
Verify every single link — internal and external
Enforce hard limits: title ≤60 chars, description ≤160 chars, 2+ internal links
Save draft and update the content inventory
Find a cover image on Unsplash

The output is publish-ready MDX. Not a rough draft I need to rewrite — actual content that matches my brand voice, follows my SEO rules, and links to my existing posts.

If you're curious about the kind of content guidelines I use, I wrote up my 15 best practices for Claude Code — tip #1 (write a CLAUDE.md file) is what makes all of this work.

Content Strategist → /setup, /mode, /report

/setup runs a marketing interview:

Analyzes my landing page and existing content
Asks 7 questions about my target audience and value proposition
Extracts brand voice patterns from my real writing
Creates a 90-day content calendar with Ahrefs-validated keywords
Generates strategy.md — a complete marketing plan

Then /mode lets me switch between three strategies:

Traffic mode — 50% educational content, grow audience fast
Conversion mode — 50% bottom-of-funnel, get customers now
Balanced mode — full-funnel, sustainable growth

/report shows where I am:

Progress Report
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Mode: BALANCED ⚖️

Keywords: 14 tracked (Ahrefs-validated)
Posts:    7 (5 published, 2 drafts)

├── BOFU: 0/0
├── MOFU: 2/6 published (33%)
└── TOFU: 3/8 published (38%)

Next recommended: "claude code CLAUDE.md"
Reason: 300/mo, winnability 80, follow-up to best practices post.

I don't decide what to write. The system tells me.

Social Media → /listen, /respond

/listen scans Reddit, Hacker News, and Twitter for conversations where people discuss problems my product solves. It scores each opportunity by relevance and timing.

/respond generates a genuinely helpful reply — not spam, not "check out my product." Value-first responses that happen to come from someone who built a solution.

I still post these manually. Authenticity matters. But finding the right conversations and drafting responses? Automated.

Outreach Manager → /outreach, /cold-campaign

/outreach finds link-building opportunities: guest post targets, resource pages, broken links I can replace. It generates personalized email templates.

For scale, /cold-campaign integrates with Apollo.io (contact database) and Instantly.ai (email warmup + sending) to run multi-step email sequences.

I still review every email before it goes out. But the research, personalization, and tracking are handled.

Product Marketing → /positioning, /launch, /changelog

/positioning generates messaging frameworks — value prop, elevator pitches, differentiators. /launch creates a full Product Hunt campaign with pre-launch, launch day, and post-launch checklists. /changelog turns a feature update into multi-channel announcements.

What a Real Session Looks Like

Monday morning. I open my terminal:

$ claude

Marketing OS loaded.
✓ 2 drafts ready to publish. Run /approve.
⏳ 5 days since last post. Ready to write? /draft
📊 14 keywords tracked.

> /next

Your single most important action:
Publish the "SEO for Developers" draft.
Reason: 600/mo keyword, article is ready, 5 days since last publish.

> /approve seo-for-developers

✓ Created PR to aiorg.dev repo
✓ Content inventory updated
✓ Velocity: 1 post every 3.2 days (healthy)

> /draft

Recommended: "claude code CLAUDE.md" (300/mo, winnability 80)
Write it? [Yes]

...

That's it. I voice-command this through Wispr Flow — I don't even type. My hands are for code review.

I also run 2-3 Claude Code sessions in parallel using Warp — one session writing content, another refactoring code in a different project, a third running tests. Each session stays focused on its task.

What It Can't Do

I want to be honest. Here's what the AI still can't handle:

Creative judgment. It writes good content. Not great content. The difference between "good enough to publish" and "people will share this" still requires a human eye. I review every piece.

Relationship building. Outreach emails get opened. But building genuine connections — the follow-ups, the DMs, the "I saw your talk" messages — that's still manual. And it should be.

Taste. The system doesn't know that this particular blog post title is cringe, or that this hook sounds like every AI article on the internet. I catch that in review.

Novel strategy. It's excellent at executing established marketing playbooks. But inventing a new go-to-market approach, or spotting a cultural moment to capitalize on? That's still human territory.

The honest ratio: AI does 85% of the work. I do 15%. But my 15% is what separates "content mill" from "content marketing."

The Data Integration Stack

The system isn't just Claude Code with good prompts. It relies on real data:

Ahrefs ($99-199/mo) — keyword volumes, competitor analysis, backlink tracking
Google Search Console (free) — real ranking positions, click data, indexing status
ForumScout (~$30/mo) — social listening across Reddit, HN, Twitter
Firecrawl ($9/mo) — JavaScript-heavy page scraping fallback

Without Ahrefs, /keywords still works — just with less accurate data. Without GSC, you get estimates instead of real positions. The system degrades gracefully.

How I Set This Up

The foundation of this entire system is two things:

1. A CLAUDE.md file that teaches Claude Code your project structure, commands, and rules. I wrote a complete guide with examples on how to write one.

2. Custom slash commands — markdown files in .claude/commands/ that define multi-step workflows. Each command is a detailed specification: what data to load, what questions to ask, what output to produce, what limits to enforce.

The /draft command alone is 950 lines of specification. That's not bloat — it's the difference between "write a blog post" and a repeatable system that produces consistent, SEO-optimized, brand-aligned content every time.

If you want to go deeper on the automation layer, I wrote about Claude Code hooks — shell commands that auto-format, auto-lint, and auto-validate every file Claude Code touches.

Why This Beats Hiring

A junior marketing person costs $3K-5K/month and handles one project. They need onboarding, management, and context on your product.

My system:

Runs across 6 projects simultaneously
Has zero onboarding (it reads the CLAUDE.md)
Works at 2am when I have an idea
Never forgets the brand voice or SEO rules
Costs ~$250/month (Ahrefs + Claude Max + minor tools)

It won't replace a CMO with 10 years of experience and genuine strategic insight. But for a solo developer who needs marketing to happen? It's not even close.

Start Small

You don't need 49 commands. Start with three things:

Write a CLAUDE.md with your product, audience, and voice
Create one custom command — /draft that loads your context and writes a blog post
Track what you write in a content-inventory.json file

That gets you 60% of the value. The other 39 commands are refinements.

I wrote an expanded deep-dive on my blog covering the full architecture, data integrations, and Marketing as Code philosophy behind this system.

I'm building in public, so all of this evolves weekly. The system I described today is version 1.22 — it looked very different 3 months ago and will look different 3 months from now.

What does your marketing setup look like? Anyone else running marketing from the terminal?

I'm Lukas — I run 6 SaaS projects solo with Claude Code. I write about AI-native development and marketing workflows on my blog.

Claude Code Best Practices: 15 Tips from Running 6 Projects (2026)

Lukas Fryc — Mon, 09 Feb 2026 09:44:28 +0000

I've been running 6 production projects with Claude Code for the past year. Not toy projects — real SaaS products with users, payments, and deployments.

These 15 practices are the ones that survived. I tried dozens more that didn't make the cut. Some I learned the hard way (tip #9 after losing 3 hours of work).

The single highest-impact thing? Writing a CLAUDE.md file. 10 minutes of setup saves hours of repeated explanations every session.

Still deciding between AI coding tools? I wrote an honest Cursor vs Claude Code comparison — spoiler: I use both.

Quick summary of all 15:

Write a CLAUDE.md file
Use .claude/rules/ for domain-specific rules
Add custom commands
Set up .claudeignore
Start with "what" and "why", not "how"
Break large tasks into phases
Reference existing patterns
Ask for plans before execution
Commit before big changes
Use /compact regularly
Let Claude Code run tests
One task per session
Use hooks for automation
Build project-specific kits
Review before approving

Project Setup

1. Write a CLAUDE.md File

This is the single highest-impact thing you can do. CLAUDE.md lives in your project root and Claude Code reads it at the start of every session.

Without it, every session starts from zero. With it, Claude Code immediately knows your stack, patterns, and rules.

# Project Name

Brief description of what this project does.

## Tech Stack
- Next.js 15 (App Router)
- Supabase (auth + database)
- Stripe (payments)
- Tailwind CSS v4

## Architecture
- /src/app — pages and API routes
- /src/lib — shared utilities and services
- /src/components — React components (use shadcn/ui)

## Rules
- Always use TypeScript strict mode
- Use server components by default, 'use client' only when needed
- Error handling: use Result pattern, not try/catch
- Tests: use Vitest, co-locate with source files

## Commands
- Dev: pnpm dev
- Test: pnpm test
- Build: pnpm build

10 minutes to write. Hours saved in every subsequent session.

2. Use .claude/rules/ for Domain Rules

CLAUDE.md covers the whole project. For domain-specific rules, use .claude/rules/:

.claude/rules/
├── api-routes.md      # How to write API routes
├── database.md        # Migration and query patterns
├── testing.md         # Testing conventions
└── components.md      # Component patterns

Each file loads when relevant. Claude Code reads api-routes.md when working on API routes, not when styling a button. Focused context = better results.

3. Add Custom Commands

Custom commands turn repetitive prompts into one-word shortcuts:

# .claude/commands/new-feature.md

Create a new feature following our standard pattern:
1. Create the API route in /src/app/api/
2. Create the database migration in /supabase/migrations/
3. Create the React component in /src/components/
4. Add a Vitest test file next to each new file
5. Update the sidebar navigation if needed

Now /new-feature does it all. I have about 15 custom commands across my projects — they're the single biggest time saver after CLAUDE.md.

4. Set Up .claudeignore

Like .gitignore for Claude Code. Reduces noise, keeps context focused:

node_modules/
.next/
dist/
*.lock
*.log
coverage/
.env*

Less context to scan = faster, more accurate responses.

Prompting Patterns

5. Start with "What" and "Why"

Bad prompt:

Create a file called auth.ts in src/lib with a function called verifyToken that takes a JWT string and returns the decoded payload using jose library

Good prompt:

I need JWT verification for my API routes. Users authenticate via Supabase, but I need to verify tokens in edge functions where the Supabase client isn't available.

The second gives Claude Code room to think. It might suggest a different approach. It might notice you already have a verification pattern elsewhere. Let it make architectural decisions.

6. Break Large Tasks into Phases

Don't ask for an entire feature in one prompt:

Plan: "I need to add billing with Stripe. What's your plan?"
Review the plan, adjust if needed
Execute phase 1: "Let's start with the webhook handler"
Verify (run tests, check the code)
Execute phase 2: "Now add the pricing page"

Each phase gets full attention. Claude Code won't rush step 5 because it's trying to remember step 1.

7. Reference Existing Patterns

Add a new API route for /api/projects. Follow the same pattern as /api/teams — same error handling, same auth middleware, same response format.

Claude Code reads the referenced file and replicates the pattern. Far more reliable than describing it in words.

8. Ask for Plans First

For any task touching more than 3 files:

Plan how you'd implement user notifications. Don't write code yet — just outline the approach.

Review the plan. Catch problems before 15 files change. Then say "looks good, execute it."

Saves significant time on reverts.

Workflow Habits

9. Commit Before Big Changes

Before any significant refactor:

git add -A && git commit -m "checkpoint before refactor"

If it goes wrong: one git reset away from safety. Without this, you're manually undoing changes across 20 files.

I learned this the hard way — lost 3 hours of work to a botched migration that touched every model file. Now I checkpoint religiously.

10. Use /compact When Context Gets Long

Long conversations degrade quality. Claude Code spends tokens processing old, irrelevant context instead of focusing on the current task.

Rule of thumb: compact after every major task completion. When responses get slower or less accurate, that's your signal.

11. Let Claude Code Run Tests

Don't copy-paste test output. Put your test command in CLAUDE.md:

## Commands
- Test: pnpm vitest run
- Test watch: pnpm vitest

Then: "Run the tests and fix any failures." Claude Code runs the suite, reads failures, fixes them, re-runs. This loop is 5x faster than manual copy-paste.

12. One Task Per Session

Don't do this:

Fix the login bug, then add dark mode, then refactor the API routes, then write tests.

Instead: fix the login bug. Compact or start fresh. Add dark mode. Each task gets focused context.

Advanced Tips

13. Use Hooks for Automation

Hooks run shell commands automatically before or after Claude Code actions:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write 2>/dev/null; exit 0"
          }
        ]
      }
    ]
  }
}

This auto-formats every file Claude Code writes. No more "fix the linting errors" follow-ups.

I wrote a complete hooks guide with 20+ examples if you want to go deeper — hooks are the most underused Claude Code feature.

14. Build Project-Specific Kits

If you repeat the same setup across projects, package it:

.claude/
├── commands/
│   ├── new-feature.md
│   ├── deploy.md
│   └── test-all.md
├── rules/
│   ├── api-patterns.md
│   └── testing.md
├── knowledge/
│   └── architecture.md
└── CLAUDE.md

Copy this .claude/ directory to any new project and Claude Code instantly knows your standards. I've packaged mine into reusable kits — one for each domain I work in (development, marketing, QA, product).

15. Review Before Approving

Claude Code is fast, not infallible. Before accepting large changes:

git diff — see everything that changed
Check for hardcoded values, missing error handling, security issues
Run the full test suite
Build the project to catch type errors

Trust but verify. Claude Code handles 90% of the work. Your job is catching the 10% it misses.

Bonus: What My Actual Workflow Looks Like

Here's the thing — I don't type any of this anymore.

Not the git commands. Not the CLAUDE.md file. Not even these prompts. I use Wispr Flow for voice input, so my "coding" sessions look like me talking to my laptop.

"Commit what we have and push to staging." Done.

"Write a CLAUDE.md for this project, check the tech stack from package.json." Done.

"Run the tests, fix whatever fails, then run them again." Done.

My hands are for code review. That's it.

I run multiple Claude Code sessions in parallel using Warp — one session refactoring the API, another writing tests, a third updating docs. Each session has its own context, its own task. I switch between them, review diffs, approve or reject.

My actual workflow looks like this:

Open Warp with 2-3 Claude Code sessions
Voice-assign each session a task via Wispr Flow
Switch between sessions, reviewing output
Approve good work, redirect bad work — by voice
Commit and move on

I write maybe 10-20 lines of code per day. By hand, I mean. Claude Code writes thousands. My job is architecture decisions and code review.

This isn't the future. This is Tuesday.

The 15 tips above get you started. But if you really want to see what's possible — stop typing and start directing.

The Compound Effect

Any single tip saves a few minutes. Combined, they transform the workflow. A well-configured project with CLAUDE.md, custom commands, hooks, and proper prompting ships features 5-10x faster than vanilla Claude Code.

Add voice input and parallel sessions on top, and you're not 5x faster — you're operating at a completely different scale.

The setup takes an afternoon. The savings compound every day.

What's your Claude Code setup? Do you use voice input? I'm always looking for patterns from other practitioners.

I'm Lukas — I run 6 SaaS projects solo using Claude Code. I write about Claude Code workflows and developer productivity on my blog.