Claude Code Is a Chainsaw — And After Six Weeks With Opus 4.7, We Stopped Pretending Otherwise

A chainsaw clears an acre of brush in the time a hand-saw clears a fence post. It also takes a leg off if you point it at one. That is the operating model we have landed on after six weeks running Claude Code against four production repositories on the Opus 4.7 release Anthropic shipped on April 15, 2026 — the one that posted 82.4% on SWE-bench Verified and 94.0% on HumanEval, the highest pass@1 numbers on either board as of this writing. The capability is real. The blast radius is also real. Treating the second as a footnote to the first is how teams get hurt.

Why call it a chainsaw and not a power drill?

Because the failure mode is asymmetric. A power drill that slips puts a hole in the wrong board. A chainsaw that slips ends a career. Claude Code, granted shell access and asked to refactor the auth layer, can in a single uninterrupted run rewrite 14 files, regenerate the migration set, drop a column that backed a foreign key two services away, push the branch, and open the PR — all in under nine minutes. That is exactly what happened in week two of our trial against a Rails repo that had a downstream Go service binding to a column the model decided was "legacy."

The point is not that the model made a mistake. The point is the rate at which it executes correct-looking work that compounds before any human reads a diff. Cursor's Composer can do similar damage, but its surface keeps the operator in the file tree the whole time. Claude Code runs in a terminal with a scroll buffer, and the operator is reading a wall of green checkmarks. The drill metaphor undersells the throughput; the chainsaw metaphor names the asymmetry between speed and reversal cost.

What did the Opus 4.7 jump on SWE-bench Verified actually change in the terminal?

The headline is the delta. Opus 4.7 sits at 82.4% on SWE-bench Verified. Sonnet 4.6, the workhorse from March 10, 2026, sits at 77.5%. The previous Opus tier — the late 2025 release — was below 75%. The jump from Sonnet 4.6 to Opus 4.7 is +4.9 points, and the jump from Opus 4 to Opus 4.7 is wider still. For reference, GPT-5.5 posts 80.8% on the same board and Gemini 3.1 Pro posts 75.3%. Methodology note: SWE-bench Verified is the human-curated 500-issue subset, which removes the most-criticized failure modes of the original SWE-bench but is still drawn entirely from Python repos and still rewards models that recognize the underlying issue from training exposure.

Inside the terminal, the change you feel is not the benchmark score — it is the drop in retry rate on multi-file refactors. With Sonnet 4.6 we counted, across roughly 60 sessions, an average of 1.7 corrective interventions per task before the model produced a passing diff. With Opus 4.7 across 48 sessions on the same repos, the count fell to 0.6. That is the operationally meaningful number. The benchmark predicts it; it does not replace it.

How is Claude Code different from Cursor, Codex, and Gemini CLI in practice?

Surface area, mostly. Cursor is an IDE — you stay in the editor, the model writes into files you can see, the diff is visual. Codex, which OpenAI relaunched in April 2026 and pitched as its #1 coding tool, spans CLI, IDE, and web; in the CLI it feels closest to Claude Code, but it is tied to GPT-5.5 and the agent loop terminates more eagerly. Gemini CLI, open-sourced the same month and powered by Gemini 3.1 Pro, has the longest leash by default — its agentic loop will keep going until a tool errors hard.

Claude Code's distinguishing trait is that the model treats the terminal as a planning surface. It writes a plan, runs the plan, narrates each step, and updates the plan when reality pushes back. That sounds cosmetic and it is not. The plan is what makes the system auditable mid-run; it is the only mechanism that lets you cancel before a destructive operation lands. Cursor's Composer hides the plan inside a chat thread. Codex CLI surfaces it intermittently. Claude Code makes it the spine of the session. If you take one thing from this piece, take this: the value of Claude Code is the legibility of its intermediate state, not the raw model quality.

Where does the 1M context window stop helping and start hurting?

Around the 250K mark, in our measurement. Anthropic ships Opus 4.7 with a 1M-token context tier, and the marketing posture is that you can throw a monorepo at it and ask questions. You can. You should not, most days. We ran the same refactor task — "extract a new BillingService from the existing checkout flow" — three times: once with a 40K curated context, once with 180K, once with 720K. Pass rate was 9/10, 8/10, and 4/10 respectively. The model did not get worse at reasoning; it got worse at deciding which files were canonical when the codebase had three half-finished attempts at the same abstraction sitting in different directories.

The 1M tier is the right tool for one specific shape of work: cold reading a repo you have never touched, where the model is allowed to summarize before it edits. For active editing inside a codebase the operator already knows, a 30K-60K curated context outperforms anything wider. Gemini 3.1 Pro's 2M window has the same shape of problem at a different magnitude. Wide context is a research tool. Narrow context is a working tool.

What does a "safe" Claude Code session look like for a production repo?

Three rules, all learned the hard way. First: every session runs on a branch the model created, never on a branch a human is also editing. Two simultaneous writers on the same branch is the single most reliable way to lose work, because the model will rebase or amend on autopilot and the human's local changes vanish into a reflog the human does not know to check.

Second: no shell access to anything that can write outside the repo. That means no `gh pr merge`, no `npm publish`, no `vercel deploy`, no `kubectl apply`, no database mutation tools, no Slack send. The model can prepare any of these and stop. A human runs the dispatch step. The marginal time cost is roughly twenty seconds per session and it eliminates the only failure modes that cannot be recovered from a `git reset`.

Third: a `CLAUDE.md` at the repo root that lists the files the model is not allowed to modify without asking — migrations, secrets handlers, billing logic, the deploy config. The model respects this file roughly 95% of the time on Opus 4.7, versus roughly 80% on Sonnet 4.6. The 5% miss rate is exactly why the second rule exists.

When does the $15/$75 per million pricing stop making sense versus Sonnet 4.6?

The pricing delta is the conversation. Claude 4.7 Opus runs $15 input and $75 output per million tokens. Claude 4.6 Sonnet runs $3 input and $15 output. Output cost — which dominates in agentic coding because the model writes more than it reads — is exactly 5x. For category context, GPT-5.5 is at $5/$25, Gemini 3.1 Pro is at $2.5/$10, and Grok 4 is at $3/$15. Opus 4.7 is the most expensive frontier model on the board by a wide margin.

In our sessions, Opus 4.7 averaged 38,000 output tokens per non-trivial task. That is $2.85 per task at list price. Sonnet 4.6 averaged 51,000 output tokens for the same task class — Sonnet writes more because it retries more — at $0.77. The Opus premium is 3.7x per task, not 5x, because the retry-rate delta partially closes the gap. Opus is worth it when the cost of a failed PR exceeds $3 of engineer time, which is essentially always for production code. It stops being worth it for greenfield prototyping, throwaway scripts, and the long tail of "rename this variable across the codebase" work. We route those to Sonnet 4.6 by default and reserve Opus 4.7 for repos with deploy consequences.

What kind of work does Claude Code do badly enough that we still reach for an IDE?

Three categories. First, anything where the canonical state lives in the running app rather than in the file tree — Storybook visual debugging, CSS that depends on actual rendered output, animation timing. The model cannot see what is on screen and its inference from the code is wrong often enough to be net-negative. Cursor's inline preview wins here, and an actual browser with devtools wins more often than either.

Second, anything that requires reading a stack trace from a process the model did not start. Claude Code can read logs you paste in, but the muscle memory of grabbing a stack frame, jumping to the file, and scrubbing forward and backward through call sites is still faster in an IDE than narrated in a terminal. The model's edit speed does not recover the navigation cost.

Third, anything where the task is genuinely small — a one-line fix, a typo, a config tweak. Spinning up an agent loop for a 4-character change is the chainsaw-on-a-fingernail scenario. We use the IDE for these and the model for things that touch 3+ files.

Is the agentic terminal pattern a fad, or did April 2026 settle it?

It settled. Three signals point the same direction. Gemini CLI was open-sourced on April's release wave. Codex was relaunched specifically to ship a CLI surface and positioned by OpenAI as its primary coding product. Claude Code's adoption inside Anthropic's own engineering — visible in the GitHub commit attribution patterns — went from minority to default in roughly a quarter. Aider, the community-maintained CLI that pioneered the pattern in 2023, is still actively developed and hosts the polyglot leaderboard the field uses to compare model-on-CLI performance. Four independent surfaces converging on the same shape, in the same month, is not a fad.

What is still open: whether the pattern absorbs IDE work entirely, or whether the IDE plugins (Continue, Copilot's agent mode, Windsurf's Cascade flow) carve out a parallel track for operators who want visual diff as the primary surface. Our bet is that they coexist for at least 18 months and that the CLI track wins for backend work while the IDE track wins for frontend. The split tracks the work where rendered output matters versus work where it does not.

What should a team adopting Claude Code in mid-2026 do in the first week?

Start with one repo, not four. Pick the one with the best test coverage and the lowest deploy criticality — internal tools beat customer-facing services for the first sessions. Write a `CLAUDE.md` before the first command runs. Strip shell access to the minimum (no deploy, no merge, no external API mutations) and add capabilities back one at a time as trust accumulates. Pay for Pro at $20/month per seat to start; the per-seat economics work out below five engineers, and the metered API spend starts to dominate after that — at which point switch to direct API billing and route Sonnet 4.6 versus Opus 4.7 by task class.

Have every session produce a PR rather than a direct commit, even for branches only the model touches. The PR is the audit trail. Read the diff before merging — every time, no exceptions, even when the green checkmarks look convincing. Six weeks in, the sessions where we skipped the diff read are the sessions we are still cleaning up after. The model is a chainsaw. The safety switch is a human who actually reads the diff. Nothing in the April releases — not Opus 4.7, not GPT-5.5, not Gemini 3.1 Pro — has moved that.

The calendar ahead will test all of this. Anthropic's next Opus tier is rumored for late summer 2026 and will reset the SWE-bench top line. OpenAI's Codex roadmap has a public commitment to ship browser-context support by Q3, which will close one of the gaps we listed above. Gemini CLI's open-source release means a third-party fork landscape is likely by autumn. Watch those three. Any of them changes the operating model we have just described.

FAQ

How much does Claude Code cost per month for a single engineer?

The entry point is $20/month for Claude Pro, which includes Claude Code usage with the same model access as the consumer chat tier. For heavy agentic use, that quota runs out and you transition to direct API billing — Opus 4.7 at $15 input and $75 output per million tokens, Sonnet 4.6 at $3 and $15. A heavy day of agentic work on Opus typically lands between $10 and $40 in metered spend per engineer; routing routine work to Sonnet cuts that roughly 4x.

Does Claude Code work with models other than Claude?

No. Claude Code is Anthropic's first-party CLI and is bound to the Claude model family — Opus 4.7 by default, with Sonnet 4.6 selectable for cost-sensitive sessions. If you need a CLI that can swap between Claude, GPT, and Gemini, look at Aider, which is the long-running community tool built around that exact requirement and which hosts the polyglot leaderboard the field uses to benchmark CLI-on-model performance.

Is the 82.4% SWE-bench Verified number directly comparable to GPT-5.5's 80.8%?

Mostly, with one caveat. Both numbers are reported against the same 500-issue human-curated subset and both use pass@1 scoring, which is the strict single-attempt metric. The caveat is test-time compute budgets — Anthropic and OpenAI do not document scaffold parity, so the same model with a different agent harness produces different numbers. Treat the 1.6-point gap as directional, not definitive.

Can Claude Code edit files outside the current directory?

By default, no. The agent's filesystem scope is the working directory it was invoked in, and attempts to write outside that root require explicit permission inside the session. This is the single most important guardrail on the tool and is the reason "run Claude Code from your home directory" is bad advice — start it inside the specific repo you intend to modify, and nowhere else.

How does Claude Code handle git operations safely?

The agent can stage, commit, branch, and push, and will narrate each step before executing it. It does not, by default, force-push, rebase published branches, or merge PRs without explicit instruction. The recommended operating discipline is to let the model commit and push, but to reserve `merge` for the human — every merge gate is a checkpoint where a person reads the diff before changes land on the default branch.

Does the 1M-token context window actually help for most coding tasks?

Rarely. Wide context helps when the task is "read this codebase and tell me where X happens" — pure analysis. For active editing, performance peaks well below 250K tokens and degrades as the window fills with stale or contradictory files. The practical recipe is to curate a 30K–60K context of the files genuinely relevant to the change and reserve the 1M tier for cold-read tasks where summarization comes before editing.

What happens if I cancel a Claude Code session mid-run?

The current tool call completes, the session terminates, and any uncommitted edits remain in the working tree as-is. Committed work stays committed; pushed branches stay pushed. There is no rollback. If the model has already pushed a branch and opened a PR before you canceled, those exist on the remote and need to be closed or deleted manually. This is why the "no merge, no deploy" guardrail matters more than the cancellation behavior.