Claude Code: The Operator's Field Guide

Most “Claude Code guide” posts stop at npm install and a screenshot of the agent editing a file. That’s the first five minutes. This is about the two years after that.

I’ve run Claude Code as my primary coding agent across a few hundred merged PRs, alongside Codex and Cursor for contrast, on everything from a one-file CLI to a repo that no longer fits in a single context window. Somewhere in there it stopped being a novelty and became infrastructure, which is exactly when the sharp edges start to matter. This guide is the map: eight chapters, each linking to the field experiment that produced the number I now trust. Skim the headers in ninety seconds, or follow the links for an afternoon.

1. Which agent do you actually pick?

The honest answer is “not one,” and I have the receipts.

The comparison that gets asked most is Claude Code versus Codex, so I benchmarked 47 real PRs across both: ChatGPT Codex vs Claude Code: 3.4x Cost Gap Across 47 PRs. One tool cost 3.4x the other per PR, but the expensive one won at refactors while the cheap one won at greenfield. Forcing yourself onto a single agent means roughly half your work lands on the wrong side of that gap.

Cursor is the other contender, and it lost a straight fight for me: Claude Code vs Cursor — 6 Tasks, Then I Uninstalled One. But “lost” is task-specific, which is the whole point of this chapter. When I ran all three in parallel on a 400k-token repo, the surprise was how fast Cursor Composer chewed through breadth while Claude Code went deeper on the hard sections.

Running several agents at once has its own tax, and it isn’t the subscription. It’s your attention. I measured the decision cost directly in Multi-Agent Decision Fatigue: 412 Choices Down to 38 and its follow-up on parallel agents and the 400-decision day. And if you want the raw month-end number rather than the theory, I ran all three side by side for 31 days and posted the real bill. For historical contrast, back when third-party clients still worked, OpenClaw vs Claude Code over 24 hours captured the moment the official CLI pulled ahead.

2. What does it actually cost?

Sticker price and real price are different animals, and the gap is where people get surprised.

The core question is subscription, API metering, or local model, and I worked out the breakeven in AI Agent Monthly Cost: API vs Subscription vs Local Breakeven. The short version: the subscription wins until your usage crosses a specific token threshold, and most people cross it later than they fear. The exception is parallelism. When you fan out agents, token burn stops being linear, and I found the breakeven shifts hard in Parallel Agents, 340k Tokens, and Where the Breakeven Moves. Budget for the workflow you’ll actually have in three months, not the one you have today.

3. CLAUDE.md and context: the part that decides everything

Claude Code lives and dies on what’s in its context window, and most of the tuning happens in one file.

The counterintuitive finding first: more context made it slower and worse. I traced three places where Claude Code ran 40% slower straight back to context I’d stuffed in thinking I was helping. The fix ran the other direction: I stopped adding context, pruned the tool outputs, and accuracy came back. Context is a budget, not a bucket. The CLAUDE.md file is where you spend it deliberately, and the discipline of writing a good one is closer to editing than to configuration.

4. Skills: reusable workflows that don’t rot

Skills are the feature that took Claude Code from “clever autocomplete” to “operator’s tool” for me, once I learned which ones survive contact with real use.

The pattern that worked is in Claude Code Skills: The Reusable Workflow Pattern: a way to package a repeated procedure so it fires the same way every time. But most skills I wrote never fired. I audited my own library and found 3 skills loaded, 18 that never triggered, which taught me more about skill design than any success did. When a skill does land, the leverage is real: rewriting Anthropic’s own frontend-design skill changed the output quality more than any prompt tweak. And if you want to know whether your skills are any good before shipping them, that’s a measurement problem I started to formalize in The Skill Eval Repo I Didn’t Build.

5. Sub-agents and multi-agent harnesses

This is where Claude Code stops being a chat and starts being a system, and where the interesting failures live.

Start with the framing: natural-language agent harnesses are a real architectural category, and the arxiv writeup is the map. In practice, the first thing I built was a review panel: three sub-agents reviewing the same PR, disagreeing 40% of the time. The disagreement turned out to be the feature. My production harness settled into a three-role separation of observer, strategist, and marketer, each with a narrow job.

Then it got weird in the good way. I added a fourth agent to audit the other three, and it caught the strategist procrastinating. I put seven agents on cron and two failed silently for 18 days before anyone noticed, which is the single best argument I have for building the auditor before you build the fleet. And running an agent unattended exposes a whole security surface most people never see, and I catalogued it in 24 Hours With an Autonomous Agent: Security Lessons.

6. AI code review that isn’t theater

Letting an agent review code is easy. Letting it review code well is a token-and-context problem.

The default approach wastes most of its budget: I measured 80% of the context in a naive AI review going to waste. The fix is to feed the reviewer only the blast radius of a change, which cut review tokens by 8–49x depending on the diff without losing findings. And a caution before you trust the green checkmark: AI wrote 100 passing tests, and mutation testing said they caught almost nothing. Passing is not the same as protecting.

7. MCP and the physical world

MCP is how Claude Code reaches past your repo, and reaching past your repo is where the safety rails matter most.

The cleanest MCP build I shipped was a fork with real traps to avoid: OpenCut Classic MCP — 4 Traps in the Editor Core. The scariest was the opposite: I wired Claude into a chaos-engineering MCP and it killed staging four times before I got the boundaries right. And for the genuinely tactile case, yes, Claude Code can drive real hardware over USB, with all the caveats that sentence deserves.

8. Debugging, TDD, and the safety settings nobody reads

The last chapter is the one you’ll need at 2am.

Claude Code will confidently hide its own mistakes if you let it: it hid my bug three times in a row before I wrote ten debugging prompts to stop it. It has a flattery problem, which sounds harmless until you measure it: it said “you’re absolutely right” 47 times in a week, often while being wrong. On methodology, test-driven development mostly inverts with an agent: I tried test-after-code and it worked in six of ten cases, which is not the TDD gospel but is what the data said. And spec-driven development, the thing everyone recommends, failed me three specific ways worth knowing before you commit to it.

Finally, the settings that actually protect you. Auto mode is convenient right up until it isn’t: I dug into a case where Claude Code’s auto mode blocked only Bash and failed open on everything else. Read that one before you enable auto mode on anything that touches production.

What to read next

Most people arrive here in one of three modes, so here’s the cheap routing:

• You’re still choosing a tool. Chapter 1, then chapter 2. Pick per task, not per brand, and let the cost math confirm it.
• You’re using it daily but it feels flaky. Chapter 3 is almost certainly your bottleneck. Context tuning fixes more than prompt tweaking ever will.
• You’re ready to build a system, not just a chat. Chapters 5 and 8 together: build the harness, then build the auditor that watches it, before you trust it unattended.

If you want the long-form version, with the CLAUDE.md patterns from two lines to a hundred, Plan Mode workflow, team operations, and the non-coding uses that surprised me, it’s all in Practical Claude Code, the full playbook rather than the map.

This pillar updates as I publish more field experiments. The posts below it keep their original timestamps; the map gets revised, the territory keeps moving.