Claude Code's Default Settings Are Slowing You Down — What We Changed After 60 Days on Opus 4.7

Forty-one of the sixty-seven flags exposed in Claude Code's settings surface do nothing measurable for architect-shaped work. Concede the strongest point Anthropic made when it shipped Claude 4.7 Opus on 2026-04-15: 82.4% on SWE-bench Verified, a 4.9-point jump over Sonnet 4.6's 77.5, and a 1.6-point lead on GPT-5.5's 80.8 at less than half the reasoning depth. The model earns its $15/$75-per-million tier on the reasoning axis. What the launch note did not say — and what sixty days of daily use across four repos surfaced — is that the CLI's default configuration ships against the workflow the model itself is best at. The settings that matter are buried below the fold in docs written for a different reader.

Methodology

We ran Claude Code against four production repositories between 2026-04-16 and 2026-06-15: a TypeScript API surface (~180k LOC), a Rust systems binary (~40k LOC), a Python data pipeline (~90k LOC), and a mixed-language monorepo (~310k LOC). Each repo was worked in two configurations — the CLI's shipped defaults and a modified profile — with the same architect-shaped tasks routed to each: schema migrations, cross-file refactors, dependency substitutions, and greenfield module scaffolding. Anthropic exposes 67 discrete flags across `settings.json`, `.claude/config`, environment variables, and CLI switches as of the 2026-05 build. We logged wall-clock time to first-usable-diff, token spend against the Anthropic dashboard, and whether the produced change compiled and passed the repo's existing test suite.

Two limitations. First, our sample is four repos in the hands of three engineers — not a laboratory-controlled benchmark. Second, several flags interact non-linearly, so the "41 do nothing measurable" figure applies to the tasks we ran, not to every conceivable workload. Speech-to-text, screenshot-ingest, and notebook flags were excluded because none of us used those surfaces.

Finding #1: The Model Selector Default Underspends Opus 4.7's Reasoning Budget

Claude Code ships with the model selector set to route the majority of tool-use turns through Sonnet 4.6 and reserve Opus 4.7 for the top of the reasoning tree. On paper the split is defensible — Sonnet at $3/$15 per million tokens is a fifth of Opus's $15/$75 rate. In practice, for architect-shaped work, the split costs more than it saves.

Here is what the numbers force. Sonnet 4.6 scores 77.5% on SWE-bench Verified. Opus 4.7 scores 82.4%. A 4.9-point delta is inside the noise band for a single unit test, but across a 40-minute session of chained edits it compounds. In our TypeScript refactor runs, the default split produced a compiling diff on the first attempt in 61% of sessions. Forcing Opus 4.7 as the primary agent — via the model override in `settings.json` — moved that number to 79%. The token bill on Opus-primary sessions was 2.3x the Sonnet-primary bill. The engineer-hour bill on the Sonnet-primary sessions was 1.7x, because the failed first attempts had to be re-driven.

At a $180-per-hour blended engineering rate, the arithmetic inverts. The reasoning-heavy tier pays for itself on any task where the first-attempt failure mode is "the diff does not compile" rather than "the diff has a minor bug." Anthropic's default is tuned for the second failure mode. Architects live in the first.

Finding #2: Auto-Compact Ships On, and It Erases the Context Window You Paid For

Claude 4.7 Opus is priced against a 1,000,000-token context tier. That is the number on the pricing page. The number the CLI enforces by default is closer to 200,000, because the auto-compact routine — the summarizer that fires when the running conversation crosses a threshold — is set to trigger aggressively and to compress with a low fidelity preset.

We caught this by accident. A Rust refactor session that had loaded a `Cargo.toml`, three module files, and a 4,000-line test suite into context began producing edits that referenced function signatures the loaded files no longer contained. The signatures had been paraphrased away during a compact pass. The model was not hallucinating — it was reading its own lossy summary of a file that was still nominally in scope. The 1M-token tier we were paying for at $15 in-token had been compressed down to roughly 140k of usable working memory without any user-facing signal that a compact had occurred.

Disabling auto-compact and letting the context genuinely reach 1M restored fidelity. It also raised per-session input spend by roughly 3.4x — you are now paying the sticker price for the tier you thought you had. That is the trade. But the trade is legible; the default is not. A tool that quietly downgrades the capability its parent model was built to deliver is running against the release note. The auto-compact toggle is one line in `settings.json` and it is the single highest-leverage change we made.

Finding #3: The Permission Prompt Ceiling Is Where Architect Latency Actually Lives

Every tool call — read a file, write a file, run a shell command — funnels through a permission prompt gate unless the user has pre-authorized the tool. The default allowlist is small: read, grep, and a narrow set of shell commands. Everything else surfaces a prompt.

The prompt latency is not the model. It is the human between the terminal and the coffee cup. Across our 60-day window we logged permission-prompt idle time separately from model latency. On a 40-minute Opus session with defaults, the model was actively generating for 11 minutes; the human was clicking "approve" for the other 29. That ratio inverts the value the $75-per-million output tier represents. You are paying frontier prices for a model that spends most of the wall clock waiting for you.

The fix is `settings.json.permissions.allow` — a per-repo allowlist that pre-authorizes writes, tests, and the specific shell tools your workflow depends on. In our TypeScript API repo we added seven entries and cut prompt idle time by 78%. The counter-argument is safety: an auto-approved shell tool can be pointed at destructive commands. This is real, and it is why Anthropic ships the conservative default. But the conservative default is not the correct default for a repo you have version-controlled, sandboxed in a worktree, and reviewed via `git diff` before commit. The safety envelope is the surrounding tooling, not the prompt gate.

Finding #4: Prompt Caching Is Default-On but Silently Off for the Config Path Most Teams Use

Anthropic added default prompt caching to the Claude 4.6 Sonnet family on 2026-03-10 and extended it to 4.7 Opus at launch. The pricing implication is significant: cached input tokens are billed at roughly a tenth of standard input rate. On a session that loads a large `AGENTS.md`, a `CLAUDE.md`, or a big project brief into every turn, the delta is the difference between a $12 session and a $1.30 session.

The catch: default-on applies to the SDK. In Claude Code specifically, cache hits require the system prompt block to be stable across turns — and the CLI's default configuration re-injects a workspace summary into the system block on every turn, which invalidates the cache before the model sees it. We measured this against the Anthropic billing dashboard by running identical sessions with the workspace summary flag on and off. Sessions with the flag on registered zero cached input tokens. Sessions with it off registered 82% cache hit rate on the second turn onward.

The workspace summary is a useful feature. It is not useful enough to burn 10x the input token bill for it. In our accounting, this single misconfiguration was worth roughly $340 per engineer per month across the four repos. The flag is `settings.workspaceContext.autoInject` — set to `false`, then hand-roll the context you actually need into `CLAUDE.md`, which sits inside the cacheable region.

Claude Code vs the Adjacent CLIs at Comparable Settings

Once Claude Code is reconfigured, the comparison against the other CLIs looks different than the launch-week takes suggested. Codex, released as the #1 coding tool in April 2026 and running GPT-5.5 at $5/$25 per million, benchmarks lower on SWE-bench Verified (80.8 vs 82.4). Gemini CLI, open-sourced in the same month, runs Gemini 3.1 Pro at $2.5/$10 with a 2M context window and a 75.3 score. Aider stays BYO-key and posts no model of its own.

The table hides the argument. On raw SWE-bench, Claude Code with Opus 4.7 leads. On dollars per successful diff at architect-shaped tasks, it also leads once cache is fixed. On dollars per successful diff at the routing-heavy, small-edit workload the CLI ships for by default, Codex on GPT-5.5 is competitive and Gemini CLI on the 2M context is genuinely cheaper for repos that fit inside one prompt. The pricing tiers are not directly comparable and the Codex subscription bundles usage in a way the Anthropic API tier does not.

What This Does NOT Prove

Four repos and three engineers is a working sample, not a laboratory result. We cannot isolate what fraction of the delta between default and modified profiles came from the specific flags versus the ambient effect of two months of learning to prompt the tool better. The token-spend numbers were pulled from the Anthropic dashboard, which aggregates per-day, and we did not instrument the CLI to log per-turn.

Nothing here proves Claude Code is the wrong tool for a routing-heavy small-edits workload. If your typical session is "add null check to five files, run tests," the shipped defaults are close to correct and the modifications above will cost you money without adding value. The audit was scoped to architect-shaped work — cross-file design, migration authoring, greenfield scaffolding at the module or higher granularity. The findings apply to that shape.

The Takeaway

Anthropic shipped a frontier reasoning model and a CLI defaulted for a different job. Fix four flags — model override to Opus 4.7, auto-compact off, per-repo permission allowlist, workspace auto-inject off — and the tool matches the release note. We would reverse this position if Anthropic shipped a `--profile architect` preset that flipped those defaults; until they do, the four-line edit is the actual product.

FAQ

Does forcing Opus 4.7 as the primary agent break the Claude Pro subscription's included allowance?

Not directly. The Claude Pro tier at $20/month includes Claude Code CLI access with a rate-limited allowance across models, and running Opus-primary sessions consumes that allowance faster. Heavy architect users typically exhaust the Pro tier and either upgrade to Team at $25/month per seat or attach an API key for overage. Our four-repo sample burned through the Pro allowance in roughly 14 working days per engineer at Opus-primary usage.

Will disabling auto-compact cause errors when the conversation actually exceeds 1M tokens?

Yes — the model returns a context-length error rather than silently degrading. This is the correct failure mode for architect work because it forces you to make an explicit choice about what to drop. In sixty days we hit the 1M ceiling twice, both on sessions that had accidentally loaded the wrong directory. The auto-compact default hides the same problem behind a summarizer, which is worse: you get a working session that quietly stops referencing your actual code.

How do I verify prompt caching is actually hitting after changing `workspaceContext.autoInject`?

The Anthropic billing dashboard reports cached input tokens as a separate line item per API key. Run an identical two-turn session — same files loaded, same question rephrased — and check the second turn's line. A working cache should show cached input tokens at roughly 90% of that turn's total input. Zero cached tokens means something in the system prompt block is mutating between turns; the workspace context injector is the usual culprit, but custom hooks or MCP servers that write into the prompt can do the same.

Is Gemini CLI's 2M context window a reason to switch off Claude Code for large-repo work?

For monorepos that fit entirely inside 2M tokens and where the task is "read everything and answer a question," yes — Gemini 3.1 Pro at $2.5/$10 per million is genuinely cheaper and the 75.3 SWE-bench score is adequate for retrieval-shaped work. For monorepos where the task is architectural change and requires the reasoning depth to hold cross-file invariants during a refactor, the 82.4 Opus score and the surrounding tool-use quality still lead. The context window is not the binding constraint on that class of task; the reasoning tier is.