AI Engineering

Claude Opus 4.7's 1M token context window is a category shift. You can now paste your entire codebase — 50 files, 30k lines, 250k tokens — and ask it to refactor across the whole tree without losing context or iteration cycles. Sonnet maxes out at 200k. Opus at 1M fundamentally changes what "auditing a codebase" or "implementing a cross-file feature" means: instead of batching files and bouncing across 5 chats, you load everything once and reason coherently. Cost is $15 input / $75 output per million tokens. So a 250k-token audit costs $3.75 input, ~$2.50 output. Cheap enough to do weekly. Whole-codebase comprehension in one shot is no longer theoretical.

1M Context vs 200k: What Actually Changes

Sonnet's 200k window fits a typical mid-size app: ~50 files at 4k tokens each = 200k total. Sounds fine until you hit real projects. FleetRoute is 120 files across 8 folders. TradePilot is 95 files. Load 50 at a time in Sonnet, and coupling patterns between the unloaded 70 don't exist in the model's mind. It sees file A and file B separately, reasons about each, then misses the hidden dependency — the shared Zustand store that would break if you refactor both. Opus loads all 120 at once. It doesn't miss the coupling. It doesn't drop context halfway through a refactor plan. It reasons holistically. Sonnet can reach the same answer, but it takes 4–5 chats, each one asking "did we break anything in files X, Y, Z?" and you validating manually.

That validation step is the real time killer. With 1M context, no validation loop — Opus has seen every file, every import, every state mutation. One chat, one coherent plan, one implementation. Ship it, test it, done. The time savings for multi-file refactors: 30 minutes down to 5. The cost? $6–8 per refactor instead of $1.50. ROI is clear when your refactor scope touches 20+ files.

Four Use Cases Where 1M Context Wins

Full Codebase Audit + Refactor Plan

Load the entire repo, ask: "What's the tech debt? What should we refactor first? What's coupled wrong?" Opus reads the whole tree, spots patterns (e.g., "you have 12 Zustand stores that should be one"; "this folder is imported by 8 others but doesn't export a public API"). A full audit that takes 3 hours manually takes 2 minutes in one Opus chat. Output: prioritised refactor roadmap with zero false positives.

Cross-File Feature Implementation

Building a new auth flow? Payment integration? Real-time sync? These touch auth module, API routes, database schema, UI components, hooks, stores. With 200k context, you load 4 files at a time, propose changes, iterate. With 1M, you load every touched file once. Opus reasons: "if I add a new permission type here, I need to update the Supabase RLS here, the UI validation there, and the API endpoint check there." It sees the cross-file impact before writing the first line. One coherent implementation vs 5 partial attempts.

Regression Analysis on Large Diffs

You've got a 2000-line diff touching 30 files. Did it break anything? Sonnet reviews the diff in isolation — good at spotting syntax errors, not at "wait, that function signature changed but this caller is still using the old signature." Opus loads the entire pre-diff and post-diff codebase, sees the change in context of every caller, spots all breaking changes. One pass. No surprises in QA.

Onboarding a New Dev (or AI Dev)

Newest feature dev workflows involve loading the full codebase once, establishing conventions, and then using smaller contexts for isolated tasks. Opus eats the entire repo in the first message: "here's the style guide I found, here's the state pattern, here's why the folder structure is that way." New dev context is now coherent. Saves 40% of learning ramp time.

The Cost Math: When 1M Justifies Itself

Sonnet: $3 input, $15 output per million tokens. Opus: $15 input, $75 output. A typical 250k-token codebase audit in Sonnet (5 chats, 50k tokens each) costs ~$0.75 total. In Opus (1 chat, 250k tokens) costs ~$3.75 input + ~$2.50 output = ~$6.25 total. That's 8x more expensive per audit. But you save 25 minutes of iteration time, validation bounces, and re-reading files. If your billable rate is $100/hour, 25 minutes = $42 of labour saved. Opus pays for itself in labour savings on the first audit. After that, every audit is pure profit in time. Run weekly audits; Opus saves $40/week. Annual: $2,080. Cost: $52/year in Opus-specific spending. Clear win.

When 200k (Sonnet) Is Still Enough

You don't need 1M for single-file or shallow-dependency work. Renaming a variable across 5 files? Sonnet. Fixing a bug in a single component? Sonnet. Building a form in isolation? Sonnet. The 200k window is plenty. Use Opus when: (1) your change scope is 20+ files, (2) you need regression coverage across the whole tree, (3) you're planning architecture and can't afford to miss coupling, (4) you're doing a full repo audit. Otherwise, Sonnet is faster and cheaper.

Six FAQs

Do I actually paste the entire codebase?

Yes. Use a CLI tool to tar your src folder, run `wc -m` on the text, feed it to Opus. Opus reads 250k tokens like you read 10 pages. No strain. Some people use tree view instead of full files for faster indexing. Either works.

Doesn't Opus "get worse" with longer context?

Not measurably. Opus's context is effectively infinite; it doesn't degrade at 500k the way older models did at 50k. Tests show Opus retrieves equally well at 200k and 900k. The context window is a feature, not a trade-off.

What if the repo is 600k tokens? Does Opus choke?

It fits in the window (1M = 1 million). But cost scales linearly: 600k input = $9 input cost, ~$5 output = $14 total. Still cheaper than Sonnet's multi-chat iteration. If budget is tight, split the repo into domains (auth module vs UI vs database) and run domain-specific audits.

Can I cache a large codebase to make it cheaper?

Yes. Prompt caching costs 90% less for repeated reads. Load your 250k-token codebase once ($3.75), cache it (costs 10% of input = $0.375), then every repeat audit reads the cache for $0.25. Breakeven at 2–3 audits. For teams doing weekly codebase reviews, caching is mandatory.

Should I audit my codebase weekly?

Yes. Drift is real. After 2–3 sprints, folder structure gets messy, tech debt accumulates, conventions bend. A weekly 5-minute Opus audit ($6 cost, but catches $500 in rework) is pure profit. Most teams don't do it because the tooling was expensive (older API costs). 1M context + caching makes it friction-free.

Does Opus refactor code better than Sonnet?

No — on a single file, they're equivalent. On 50 files, Opus is better because it doesn't miss dependencies. It's not "better code"; it's "whole-tree-consistent code." The quality difference is structural, not syntactic.

The Bottom Line

1M context is a tool unlock. You can now audit entire codebases in one chat, implement cross-file features without losing coupling context, and catch regressions with 100% tree coverage. For mid-to-large repos (50+ files), 1M pays for itself in labour savings. For small projects, 200k (Sonnet) is enough. The mental model is clean: if your change scope is under 20 files, use Sonnet; if it spans 20+, escalate to Opus 1M context. Layer prompt caching on top, and weekly audits become a $6 habit that catches thousands in tech debt. Stop batching files across 5 chats. Load the whole tree once. Reason coherently. Ship it.

Curious how Opus stacks up against Sonnet across production tasks? See Sonnet 4.6 vs Opus 4.7 — Production Model Comparison. Or explore how Aidxn Design uses 1M context for full-codebase client refactors.