The Claude Code Power Setup That Changed How I Build Software

A few weeks ago, I published a gist called "Claude Code Power Setup - Complete System Blueprint". It's my entire Claude Code configuration - everything I use daily as a staff engineer building software with AI agents. The response has been incredible, so I want to walk through what's in it and why each piece matters.

What's in the Gist

The gist is a complete, opinionated system for turning Claude Code from a coding assistant into a full development team. It includes:

• A global CLAUDE.md with Team Lead Mode
• A settings.json with 11 custom hooks
• 18 slash commands for common workflows
• A custom two-line status bar
• Model routing configuration
• Voice announcement hooks

The Global CLAUDE.md

This is the brain of the setup. It defines how Claude Code behaves across every project. The most important section is Team Lead Mode - a set of constraints that forces Claude to act as a manager rather than a developer. It creates teams, assigns tasks, spawns background agents, and stays available for conversation at all times.

But it's more than just Team Lead Mode. The CLAUDE.md also defines:

## Git & PR Preferences
- Always use --no-verify for both git commit and git push
- Merge, don't rebase: use git merge origin/main, NOT rebase
- Before committing, manually run: prettier, lint, tests, typecheck
- Fix issues found, THEN commit with --no-verify

## Agent Verification Commands
- Typecheck: Run from project root using project runner
- Lint: Use the project runner, NEVER run linter CLI directly
- Prettier: npx prettier --check from project root
- All commands MUST run from the project root directory

These aren't suggestions - they're hard rules that every agent follows. This means I never get a commit that skips formatting, or a PR that breaks the type checker.

The 18 Slash Commands

Slash commands are the fastest way to trigger common workflows. Here are some of my most-used ones:

• /commit - Run full pre-commit validation (prettier, lint, test, typecheck), fix issues, then commit
• /pr - Push branch and create a GitHub PR with a useful description
• /pre-push - Run all pre-push checks and offer to push if everything passes
• /review-changes - Spawn 6 parallel review agents on the current branch
• /scaffold - Generate new components, hooks, or tests following project conventions
• /test - Run tests for affected libs/apps based on git changes
• /lint-fix - Run linting and formatting with auto-fix on changed files
• /deploy-check - Run lint + build to verify the project is deploy-ready

The beauty of slash commands is that they encode your workflow. Instead of remembering "run prettier, then lint, then typecheck, then commit with no-verify", you just type /commit and it handles everything.

Custom Status Line

One of the most useful pieces of the setup is the custom status bar. It shows:

┃ main ┃ ✓ CI ┃ ● 2 reviews ┃ opus ┃ ctx: 45% ┃ 12.4k tok ┃ $0.82 ┃ 🔥 $4.20/hr ┃ api: 12% wait ┃

At a glance, I can see my git branch, CI status, pending PR reviews, which model is active, how much context window is used, token counts, cost, burn rate, and API wait ratio. When you're running multiple agents in parallel, this observability is essential.

Model Routing

Not every task needs the most powerful model. My setup routes tasks to the right model:

| Task Type                    | Model   |
|------------------------------|---------|
| Implementation, refactors    | Opus    |
| Verification, lint, prettier | Sonnet  |
| Code review, architecture    | Opus    |
| Trivial checks               | Haiku   |
| Codebase research            | Explore |

This isn't about saving money (though it does). It's about speed. Sonnet runs verification checks faster than Opus, and when you're running them after every implementation agent finishes, that speed adds up.

The Hook System

Hooks are automated checks that run before or after specific events. My setup includes 11 hooks covering everything from blocking .env files from commits to auto-formatting code after every edit. They're the guardrails that make it safe to let AI agents work unsupervised.

I've written a separate post diving deep into each hook - check out "11 Git Hooks That Make AI Agents Safe to Run Unsupervised" for the full breakdown.

Voice Announcements

This one's a bit fun. I have a voice hook that uses macOS say with the Zoe Premium voice to announce events:

• When I submit a prompt: "On it"
• When an agent finishes: announces the agent type and project
• When Claude stops: a haiku summarising the response
• When permission is needed: reads the permission message or says "Ready when you are"

It sounds gimmicky, but it's genuinely useful when you're running multiple agents in parallel. I can be looking at something else entirely and still know when an agent finishes or needs my attention.

How to Use It

The gist is designed to be adapted, not copied verbatim. My recommendation:

1. Start with the CLAUDE.md. Read through Team Lead Mode and decide if that pattern fits your workflow.
2. Pick the hooks that matter to you. The env-file blocker and auto-formatter are universally useful. Others are more specific to my setup.
3. Add slash commands incrementally. Start with /commit and /pr, then add more as you discover repetitive workflows.
4. Customise the status line. Remove metrics you don't care about, add ones you do.

The whole thing is at gist.github.com/Nathanavie/a23ebb0be2b4dcd3f1a99a65ea232277. Fork it, tweak it, make it yours. If you build something cool on top of it, I'd love to hear about it.