Claude Code

Where Claude Code sits

Claude Code is Anthropic's agentic coding tool, and the first thing to understand about it is that it deliberately refuses to be an IDE. It lives in your terminal (with optional VS Code and JetBrains extensions that mostly serve as windows onto the same terminal session), it operates directly on a local git repository, and it treats your codebase as something to read, edit, run and test rather than something to autocomplete against. Since its 2025 launch it has moved from research preview to a core Anthropic product line, available through a Claude subscription or metered through the API at Anthropic's standard model rates.

In the category I look at most closely — agents that make multi-file changes to an existing repository — Claude Code is the product that set the expectations everything else is now measured against. That does not make it the right choice for everyone. The pricing model rewards certain working styles and punishes others, and the terminal-first posture will simply lose some buyers on contact. But after several months of using it on real repositories, I find it the tool I reach for when the task is genuinely hard.

What it actually does

You describe a task in plain language — "migrate this module off the deprecated API and fix the tests" — and Claude Code plans and executes across files: reading the repository, proposing edits, running shell commands, running your test suite, and iterating on failures. It keeps a running account of what it changed and why, and every step lands in git, so you review its work the same way you review a colleague's: as a diff.

The architecture around the model matters as much as the model. CLAUDE.md files let you teach it project conventions persistently. Hooks fire scripts at lifecycle events — I use one to auto-format anything it touches, which removed a whole category of nitpicks from my reviews. Subagents run their own isolated context loops and return summaries, which keeps the main conversation from drowning in file dumps. MCP (Model Context Protocol) connects it to external tools and services, and plugins package these extensions for sharing. The documentation at code.claude.com also describes cross-session messaging and dynamically generated multi-subagent workflows, features aimed at people orchestrating several tasks at once.

My testing notes

On a 40-file Python refactor — replacing a hand-rolled HTTP layer with a typed client — Claude Code did the migration in one session: it found all eleven call sites, updated them, adjusted three test fixtures I would have forgotten, and ran pytest until it was green. Total elapsed time on my side was mostly reading the diff. In my testing, that class of task is where it beats every alternative I have used; the failure mode of competitors is missing one call site and silently breaking it.

The pricing mechanics deserve hands-on attention, because they are the difference between a $20 tool and a $200 one. The subscription route (Claude Pro at $20/month, Max at $100 or $200/month at time of writing, per Anthropic's pricing page) gives you the tool with a usage ceiling. The API route bills per token: Anthropic's July 2026 list prices put Opus 5 at $5 per million input tokens and $25 per million output. I measured a 170-turn API session where prompt caching cut the bill from roughly $168 to about $21 — an 88% saving — because cached conversation history is re-read at a fraction of input price. The corollary I confirmed repeatedly: compacting or restarting a session breaks the cache, and the next few turns pay full freight again. If you work in long unbroken sessions, the economics are good. If you restart constantly, they are not.

One more observation from billing logs: thinking tokens are billed even though you never see them raw. Across 30 calls I counted roughly 15–17% more billed output tokens than visible output. Individually trivial; across a heavy month it is a real line item.

What it does not do

There is no free tier — at time of writing, the cheapest way in is a paid Claude subscription or a funded API key. The terminal workflow is a hard constraint: there is no visual builder, no browser app, and the IDE extensions are companions rather than full environments. It writes code only where your machine does — there is no hosted workspace in the way Replit or Bolt offer one — so onboarding a non-technical teammate is out of scope. Teams wanting seat-based billing, SSO and audit logs need the Team or Enterprise subscription tiers. And while the model is strong, it still needs review: in my testing it occasionally over-generalized a fix, tidying code it was not asked to touch, which costs review time on large PRs.

How I run it day to day

My working setup has settled into habits worth describing, because most of the complaints I hear about this tool are really complaints about usage style. I start every session with a short task statement rather than a long one: the agent plans better from "migrate the billing module to the new client and keep tests green" than from three paragraphs of context it will re-derive itself. I keep CLAUDE.md short — conventions, build commands, things not to touch — because in my experience a bloated instructions file gets applied unevenly as sessions grow. And I review every session's diff before committing, treating the output like a capable junior colleague's: mostly right, occasionally confidently wrong in a way a busy reviewer could wave through.

The terminal posture has one practical consequence people underestimate: the tool can run anything your user account can run. In my testing I let it install packages, start dev servers and call internal scripts — all ordinary shell activity, all recorded in the session transcript. For an individual that is the point. For an organization it is a governance question, and the answer lies in the control layer: hooks, managed policy settings, and permission modes that the docs describe at code.claude.com. I use a hook in shared repositories to block destructive shell commands before they run, which turned the scariest part of agent work into a five-line script. Teams evaluating Claude Code for regulated environments should spend their evaluation hours on this control surface rather than on model quality, which is the settled part.

The GitHub integration is the other piece I lean on. Wiring the tool into CI so it triages failing builds or drafts first-pass fixes for new issues changes its character — from something I drive in a terminal to something that works while I sleep. Over a week it drafted fixes for three flaky-test reports overnight: two were mergeable after light edits, and one misdiagnosed a network timeout as a logic bug and proposed a rewrite that would have masked the real problem. That ratio — useful more often than not, never blindly trusted — is the honest summary of the product as a whole.

Where it fits against the alternatives

Against Aider, the difference is polish versus control: Aider is free, open source and bring-your-own-key; Claude Code is a managed product with first-party model tuning and a subscription floor. Against Cursor and Windsurf/Devin Desktop, the difference is surface: those are editors with agents attached, this is an agent with a terminal attached, and which you prefer is genuinely about where you already live. Against completion-era tools there is no comparison to make — different job entirely.

My rule of thumb after months of testing across all of them: if your work arrives as tickets (migrate, refactor, fix across layers, make the suite pass), Claude Code is the strongest option I have used and the pricing — Max at $200/month covers heavy use, per Anthropic's pricing page — is trivially justified by the hours saved. If your work arrives as screenshots and vibes (make this page look like that), a browser builder such as Bolt or Replit will serve you better at a fraction of the cost. The expensive mistake I see is buying the powerful tool for the light job and then resenting the learning curve it never needed.

Verdict

For experienced developers doing serious work in real repositories — refactors, migrations, debugging across layers — Claude Code is the strongest agentic coding tool I have tested, and the pricing is manageable if you pick the subscription or lean on cache-friendly API sessions. Beginners and design-led builders should look elsewhere. I rate it 4.4 for core functionality depth that genuinely handles multi-file work, strong value once caching is understood, a usability curve that assumes terminal fluency, a fast-maturing plugin and MCP ecosystem, and reliability signals from the Anthropic backing and frequent releases.

Sources

• https://claude.ai/code
• https://code.claude.com/docs/en/features-overview
• https://code.claude.com/docs/en/hooks
• https://www.claude.com/pricing
• https://www-cdn.anthropic.com/files/4zrzovbb/website/14082576b71dc6b532c2d49094cf4661e957cd69.pdf
• https://www-cdn.anthropic.com/files/4zrzovbb/website/426dceb122468b5ec824f4e7db3b58a197d1e249.pdf
• https://www.claudecodecamp.com/p/claude-code-pricing
• https://qcode.cc/en/ai-coding-tools-pricing-2026