Claude Code
The terminal agent that actually engineers — and the one I trust on the codebases I care about.
Why This Hits Different
Claude Code lives in your terminal. That's the whole game.
Every other tool in this guide is asking you to move into its environment. New IDE, new browser tab, new mental model, new keybindings. Claude Code says: nah, you keep your setup, I'll come to you. Open your terminal. Type claude. There it is.
For someone who's spent twenty years building their shell config, their tmux layout, their Neovim plugins — that respect for your existing setup is the most underrated thing about this product. Anthropic could have built a flashier IDE. They built an agent that fits inside the IDE you've already perfected. (There's a desktop app now, and Claude Code on the web for kicking off cloud sessions from anywhere. Fine. Useful, even. But the terminal is still the soul of the thing.)
But — and this is the part that matters — once it's there, it actually engineers. Reads files. Writes files. Runs commands. Executes your tests. Reads the output. Tries again. Commits when done. With your permission at every step that matters.
It's not autocomplete. It's a careful coworker who happens to type at terminal speed.
Who Should Be Using This
Terminal-native devs. If "I'd rather not leave Neovim" is something you've actually said out loud, this is your tool. Period.
Solo full-stack engineers and technical founders. Claude Code traces bugs through four layers and three files in one conversation. That capability changes what one person can maintain.
DevOps, data engineers, automation people. This is its sweet spot. Shell scripts, CI configs, data pipelines, infrastructure — work where the artifact is a config file or a command, not a React component. Nothing else in this guide is as good at this.
Newcomers who've never used a terminal: wrong tool. Genuinely. Go use Lovable for a few months, build the muscle, come back. No shame. Right tool, right time.
What Actually Matters
It actually executes. This is the difference. Other tools suggest. Claude Code does. Tells you what it's about to do, asks for confirmation when it matters, then does it. Watching it work through a multi-step problem in your terminal — read the file, run the test, see the failure, fix the code, rerun — feels like watching a senior dev work, not a chatbot perform.
CLAUDE.md. Same idea as .cursorrules but Anthropic built the workflow around it. Drop a CLAUDE.md at your project root. Fill it with your stack, your conventions, your test command, your dev server command, your architectural decisions. Every session reads it automatically. I'll bang the same drum here that I banged in Chapter 1: do this before you write a line of code, not after you've already explained it five times.
Whole-repo reasoning. Claude Code can index your entire codebase and reason across it. Refactors that touch a dozen files? It sees the whole graph. With a million tokens of context on the current models, it doesn't operate like it's looking through a keyhole.
Git-native, with brakes. It checks branches. Reads recent commits to understand what changed. Stages files. Writes commit messages that actually describe what happened. And it asks before doing anything destructive. You can configure how much autonomy it has — wide open for prototyping, locked down near production. That dial matters.
MCP servers. Anthropic's open standard for connecting agents to external tools. Hook Claude Code to your database, your Slack, your issue tracker, your custom internal tools. This is where it stops being "a coding tool" and starts being "an agent platform that happens to be great at code."
Subagents and hooks. Subagents are Claude Code spawning more Claude Codes — parallel workers with their own context windows, fanning out across a big refactor while your main session coordinates. Hooks are deterministic scripts that fire at lifecycle points: block a dangerous command before it runs, auto-lint after every edit. Prompts ask. Hooks enforce. Learn both.
Adaptive thinking. For the gnarly stuff. Architectural decisions. Subtle bugs that require holding three layers in your head. The model now decides on its own when a problem deserves deep reasoning, and you control the effort dial. You can feel the difference.
Headless mode. This one is sleeper. Claude Code can run non-interactively — accept input from stdin, run inside a CI pipeline, batch-process tasks. Almost nothing else in this guide does this. It opens up a whole category of "AI as a tool in your automation stack" that the IDE-shaped competitors literally cannot match.
Cost
Tied to your Claude subscription, plus a bring-your-own-API-key option.
Claude Pro — $20/month. Fine for moderate use. Sonnet by default, Opus when you're planning. You'll outgrow it during real sprints.
Claude Max — $100/month (5x) or $200/month (20x). This is where serious users land. The 5x covers most full-time engineering. The 20x is for people running Claude Code basically all day — migrations, big refactors, pair programming as a lifestyle. Compared to a contractor at $80/hr, even the $200 tier is a joke. Pay it. Stop counting tokens.
One mechanical note: Claude Code and the Claude apps now draw from a single shared pool — a five-hour session clock plus a weekly cap. Blow through the cap mid-sprint and you can keep going on usage credits billed at API rates, with a spending ceiling you set yourself.
API key, pay-as-you-go. Bring your own Anthropic key. Useful when you want token-level visibility or you're integrating Claude Code into automation. Sonnet 5 ($3/$15 per million tokens) is the workhorse. Opus 5 ($5/$25) is the flagship — it landed at the same price Opus 4.8 was, so heavy lifters just run Opus now.
Free tier: doesn't include Claude Code at all. Anthropic wants you on Pro before you type claude. Fair enough.
Real talk: long agentic chains burn tokens. That's physics, not a bug. Don't be surprised when a four-hour pair session costs more than a four-line autocomplete session. You're getting four hours of senior engineering work.
What It's Good At
Web apps: Four stars. Excellent on backend, APIs, databases, deploys. Loses a star because there's no built-in browser preview — for heavy frontend visual iteration, you'll want to pair it with a dev server you're watching in another window. For backend-heavy or design-system-defined web work, it's stellar.
Mobile: Three stars. React Native works fine. Native Swift/Kotlin works but you can feel the AI is less specialized, and the no-visual-preview thing matters more here.
Local apps, scripts, automation, infra: Five stars. This is the home turf. Best in this guide for this kind of work, and it's not close.
Hosting
None. Local agent. You deploy wherever you already deploy.
Claude Code can write your Dockerfile, debug your GitHub Actions, walk you through a Fly.io deploy, fix a broken CI pipeline. What it can't do is press a deploy button for you. You're working with real tools, the agent is your colleague, that's the deal.
If you're newer, pair it with Supabase + Vercel or Supabase + Fly.io. Claude Code knows those platforms cold.
The Story
I keep an internal codebase at AIEA — a tangle of utilities, ingestion scripts, dashboards, glue code. The kind of repo every team has and nobody loves. Tests had drifted. Some had been ignored for so long they'd developed their own ecosystem.
I sat down on a Sunday afternoon. Opened terminal. Typed claude. Said: "Run the test suite three times, find the flakes, group them by failure mode, propose a plan."
Twenty minutes later I had a categorized list. Timing flakes, order-dependent flakes, network flakes pretending to be timing flakes. Claude Code worked through them in order. For a few it found real bugs the tests had been hiding — not test issues, code issues. It flagged those, explained, asked me which direction.
By dinner the suite was green and stayed green.
That's the unlock. Not "the AI is fast." It's "the AI does the unglamorous engineering work the same way you would, just without getting bored." Flake hunting is exactly the kind of task that humans deprioritize forever and AI agents handle without complaint. That's a new economic equation.
Where It Bites
It still assumes you think like a terminal person. The desktop app and the web version soften the barrier, but the whole model — files, diffs, commands, permission prompts — assumes shell fluency. If you're not there yet, this is the wrong starting point. Not snobbery — just honesty. Build the muscle elsewhere first.
Agentic mistakes hit harder than autocomplete mistakes. When an autocomplete tool is wrong, you decline the suggestion. When an agent runs a wrong command, the command already ran. Claude Code is careful by default — it asks for confirmation on destructive stuff — but commit your work to Git before big agentic sessions. Git is your real undo button. This isn't optional.
Cost climbs faster than people expect during heavy use. Long agentic chains, big files, multi-step refactors — these eat tokens. Monitor it during your first month. Adjust your subscription tier when you've calibrated.
It works best on structured projects. Clean directories, a working test suite, a real CLAUDE.md. Drop it into a legacy disaster and you'll get legacy-disaster results. Garbage in, garbage out — even from the best agent.
Gavin's Rule: Treat CLAUDE.md Like A Real Document
Most people write a five-line
CLAUDE.mdand call it done. Don't.Treat it like onboarding documentation for a new senior hire. Stack and versions. How to run tests. How to start the dev server. The architectural decisions you've already made and why. The directories and what lives in them. The patterns you want followed. The patterns you want avoided ("we don't use lodash, we don't use class components, we don't add ORMs").
Spend an hour on it. Once. It will pay you back the first afternoon.
The teams I see at CodeDR.AI who get the most out of Claude Code share one trait: a real
CLAUDE.md. Not a token gesture. A living document. Update it when architecture shifts. Treat it as code.If you take one thing from this chapter, take this one.
Bottom Line
If you're a serious engineer, Claude Code is the highest-capability tool in this guide. Period. It will do real engineering work — agentic, careful, thorough — at a level the IDE-shaped competitors can't match because they're not actually agents in the same way.
The price of admission is being comfortable in a terminal. The reward is an AI collaborator that operates at the level of the work you actually do.
If that's you, this is your tool.
— Gavin