Claude Code Review: The Terminal Agent That Made My Editor Feel Like a Text Box

What it’s actually good at

The thing that changes how you work isn’t a single feature, it’s the context window. At 1M tokens of usable context, Claude Code can hold thousands of source files, entire monorepos, and full documentation sets at once, without you manually managing which files are loaded. The first time I asked it to trace how a Stripe webhook flowed through a repo I’d been onboarded to three days earlier, and it named the file, the middleware, and the two downstream jobs in one turn, I stopped tab-hopping through the codebase forever.

Subagents are the second load-bearing feature, and they solve the problem every long agent session eventually has. You’re three hours into a refactor. The main Claude Code session has read 40 files, summarized two ADRs, and is now drafting a migration script. You ask it to “also check whether any of these touch the auth pipeline,” and you watch the context window balloon past 70%. Two prompts later, it’s auto-compacting, and you’ve lost the thread. This is what subagents fix. Instead of pouring every research detour into the same conversation, you delegate the side quest to a child instance with its own context window, tools, and model. The parent session stays focused on the work that pays the bills.

That architecture also gives you sharper permissions than a single-model workflow ever will. A documentation agent may only need file reads and markdown edits. A deploy agent may need shell access but not secrets. A database agent may need MCP tools that other agents shouldn’t touch. You end up designing the agent like you’d design a team, and it turns out that’s the right mental model.

Agent Teams is where Claude Code stops feeling like a fancier Copilot and starts feeling like something new. One session acts as the team lead, coordinating work, assigning tasks, and synthesizing results. Teammates work independently, each in its own context window, and they talk directly to each other. Unlike subagents, which run within a single session and can only report back to the main agent, you can interact with individual teammates without going through the lead. On a payments refactor last month I ran a three-teammate team (API, migrations, tests) and it landed a working PR in about the time it usually takes me to write the plan.

MCP is the other reason this thing has quietly moved past the competition. That’s the line between coding assistant and operator. For a small repo, filesystem plus shell may be enough. For a real product, the agent needs context from GitHub, Linear, Sentry, analytics, docs, and the database. MCP is how those systems become part of the same working loop. Wire your Linear and your Postgres in, and “implement CS-482” stops being a prompt and starts being an instruction.

Hooks round it out with the deterministic control that actually makes this safe to run against a real codebase. Hooks fire around tool calls, session starts, stop events, and subagent completion, which means teams can enforce project-specific rules. Mine block writes outside src/, force a test run before /stop, and refuse to touch anything under infra/prod.

Where it lets you down

The pricing model is the rough edge, and pretending otherwise would be doing you a disservice. Three mechanics underneath the sticker price determine how much capacity you actually get. First, the 5-hour rolling session window: your budget rolls over a 5-hour window starting from your first prompt. Burn it early and you wait. Second, a weekly active-compute cap on top, which only counts when Claude is actively processing or reasoning. Idle browsing is free. The weekly cap is the single biggest reason Max users feel like they ran out early. Third, a peak-hour burn multiplier. Weekdays 5am to 11am Pacific (8am to 2pm Eastern) burn faster, with community-reported multipliers of 1.3-1.5x. Anthropic hasn’t published the exact figure.

The good news is the ceiling moved this year. On May 6, 2026, Anthropic doubled the usage limits on Claude Code for all paid plans: Pro, Max, Team, and Enterprise. The change came alongside a big compute expansion through a partnership with SpaceX’s Colossus 1 data center. In plain terms, you can do roughly twice as much in a single session before hitting a usage limit. The doubling applies to the per-session limit, not the weekly one. Weekly limits stayed the same in that announcement, though a separate temporary promotion from May 13 through July 13, 2026 added another 50% on top across all plans.

After that change I stopped hitting Pro’s ceiling for regular Sonnet work. That doesn’t mean the system is calm. Bad releases have hit hard. Users reported 3-50x faster rate-limit consumption starting with Claude Code v2.1.89 in March 2026. Max 20x plans were exhausted within 70 minutes of reset. If your bill suddenly looks wrong and nothing about your workflow changed, check the release notes and version-pin until Anthropic ships a fix. Pin your Claude Code version in CI and in onboarding docs so a team-wide silent upgrade can’t happen overnight.

Agent Teams is the other place to be careful. It’s genuinely impressive, but it isn’t free. In practice, teammates spawn within 20-30 seconds and start producing results within the first minute. A 3-teammate team uses roughly 3-4x the tokens of a single session doing the same work sequentially, but the time savings on complex tasks more than justify the cost. The trap is running a team when a subagent (or, honestly, a single well-scoped session) would’ve done. Agent Teams add coordination overhead. They work best when teammates can operate independently. For sequential tasks, same-file edits, or work with lots of dependencies, a single session or a subagent is more effective.

The other quiet gotcha is that the model you’re running isn’t what you think it is. Claude Code doesn’t run one default model for everyone. Per Anthropic’s model configuration docs, the default resolves differently depending on how you pay. Max, Team Premium, Enterprise pay-as-you-go, and direct Anthropic API accounts default to Claude Opus 5. Pro, Team Standard, and Enterprise subscription seats default to Claude Sonnet 5. So a $20 Pro user following a $100 Max user’s tutorial is running a different model, and the same prompt can produce different results and different costs. Learn /model early.

Managing the meter

The optimization playbook isn’t rocket science, but it’s the difference between Pro being enough and Pro throttling you by Wednesday. The biggest win is prompt caching. Cached reads cost 10% of input price, so any system prompt or document you reuse should be cached. Claude Code does this automatically for CLAUDE.md and recently-read files, but you can extend it by keeping conversation history short and stable.

The second-biggest win is picking the right model. Sonnet 5 handles the vast majority of coding tasks at $2/$10 per million tokens (introductory, rising to $3/$15 after Aug 31 2026), versus Opus 5’s $5/$25 and Fable 5’s $10/$50. Use Opus only for hard architectural decisions, multi-step reasoning, or critical refactors. Run /model to switch mid-session, and configure subagents to use Haiku 4.5 for simple lookups.

The third lever is proactive context management. Run /clear when you switch tasks instead of letting stale context pile up. Use /compact to summarize long sessions.

Two more habits are worth burning in. Keep CLAUDE.md under 200 lines. It injects into every request. A 5,000-token CLAUDE.md is a 5,000-token tax on every turn. Document decisions and conventions, not aspirations or things Claude can already infer. And when you do reach for a team, start small: three to five teammates. That range balances real parallelism against coordination overhead, and beyond it, you hit diminishing returns. Three focused teammates usually beat five scattered ones.

Should you pay for it?

If you write code in a terminal for a living, yes, and Pro is the right entry. Claude Code costs $20/month on Pro, $100 or $200/month on Max, or pay-per-token via the Anthropic API. There’s no free Claude Code plan. You need at least a Pro subscription or API credits to access it. Start on Pro, get your CLAUDE.md tight, default to Sonnet, and reach for /model opus-5 only when the task actually earns it. Subscription easily beats API billing at this volume; you’ll rarely hit limits.

Max is a real answer for a narrow audience. If you’re working on large codebases, running Agent Teams workflows, or using Claude Code as your primary coding partner for 6+ hours a day, you’ll hit the 5-hour window limits regularly. Max 5x gives you roughly 5x Pro’s usage, translating to about 88,000 tokens per 5-hour window. You also get priority access during high-traffic periods and early access to new Claude features, including things like Claude in PowerPoint that aren’t available on Pro. Best for: developers working full-time with Claude Code on mid-to-large codebases, or anyone who regularly hits Pro’s limits two or three times a week.

Max 20x at $200 is the tier for people who run Agent Teams as a daily driver. That’s roughly 220,000 tokens per 5-hour window, 20x Pro’s allowance. At this level, rate limits stop being a practical concern for most professional development work. Best for: power users treating Claude Code as their primary coding environment all day, teams piloting heavy usage before committing to a business plan, or anyone running Agent Teams workflows regularly. Agent Teams spawn multiple Claude Code instances at once, each consuming its own token budget.

For teams, the seat model is the honest lever. Premium seats add Claude Code and Cowork, plus 5x more usage than Standard seats. Claude Code is only included at the Premium seat level. If your team has developers who need it and others who don’t, you can mix seat types within the same plan, which is a useful cost control. Don’t give every seat Premium reflexively. Premium seats belong to engineers whose agent usage is a daily primary tool and who benefit from frontier-model escalation, while Standard fits reviewers, occasional users, and Cowork-first staff.

The bottom line

Claude Code is the AI coding tool the rest of the field is now being measured against. The 1M context makes it fluent in your repo instead of a file. Subagents keep the main session sane on long work. Agent Teams turn one CLI into a squad that can actually collaborate. MCP makes it an operator instead of an assistant. Hooks let you keep it on a leash. The pricing mechanics are the ugly part, and it’s not an editor (pair it with Cursor or Zed if you want inline completion), but if you’re doing serious work that spans more than one file, it’s the sharpest tool in this category by a real margin. It’s the one to beat, and it earns the Editors’ Choice.