Claude Opus 4.7 — first impressions after a week with 1M context

Anthropic released Claude Opus 4.7 with a 1M context window. I've been using it as my default in Claude Code for a week, on the same machine I had Sonnet 4.6 on. This post is concrete observations, what actually changed, where it's worth paying more, and where I stay on the cheaper model.

Framing: I'm writing from the perspective of a daily Claude Code terminal user, not benchmarks. I also run a home-lab setup (four machines, agent on a mini PC, I wrote about it here), so I push it on non-trivial work.

What you get in 4.7

Three things that actually change how you work:

The rest is incremental, better tool use and instruction follow-through. Small, but visible on long tasks.

1M context — when it matters

The most practical change. Three real situations from this week:

Mid-size repo refactor. I dump 60 files (~150k tokens) and ask about pattern consistency. Before, I'd split context or use sub-agents. Now the model holds everything and connects facts from different ends of the code.

Full PR review with discussion. PR + all review feedback + linked snippets from other branches. 4.6 would choke on the history alone. 4.7 walks through it.

Long debugging sessions. I no longer need to compact when running four hours on a single problem. This is the biggest quiet shift, productivity rises not because of "better answers" but because nothing falls out of context.

Watch the cache, though:

✅ < 200k tokens → cache hit, cost like Sonnet
⚠️ > 200k tokens → cache miss, every turn pricey

If a session crosses 200k, every prompt re-reads the whole context from scratch. Practical consequence: on big tasks I plan the context up front instead of dropping files in dynamically.

Plan mode — I stopped ignoring it

In 4.6 plan mode was "ok, sometimes useful." In 4.7 it's a separate mode with its own rules: can't edit files (besides the plan file), forces ExitPlanMode at the end, can't run destructive commands.

The workflow that works for me:

# 1. Opening a non-trivial task → start in plan mode
# 2. Model spawns explore agents in parallel, builds a map
# 3. Writes a plan with concrete file paths and a change list
# 4. Asks only about genuinely important forks
# 5. After approval it leaves plan mode and executes

What you gain: no more "quietly extended" scope. The plan is written down, if something drifts, I know where. What you lose: ~5 minutes per task. Overkill for fixing a typo, always worth it for a network refactor.

Fast mode toggle

The /fast command swaps Claude Code to Opus 4.6 with accelerated output. It's not a downgrade to a smaller model, same Opus 4.6 with a different sampling profile. I use it for three things:

• Doc lookups ("what does X do in my internal lib"), fast answer, low cost
• Boilerplate (unit tests, validation schemas)
• Architecture chat before I sit down to code

I do not use fast mode for: code review, debugging, refactors. Slower reasoning costs there, but loses less.

Cost: how I think about budget

Opus 4.7 is more expensive than Sonnet 4.6. At first glance. In practice:

10-min task on Sonnet 4.6: ~$0.40
Same task on Opus 4.7:    ~$0.85 (no cache)
                       → ~$0.45 (with prompt caching active)

Prompt caching is the key optimization. Cache TTL is 5 minutes, if I respond inside that window, prompt cost drops 90%. In practice: don't think about tokens, think about cadence.

The rule I follow:

• Short sessions (< 30 min, < 200k tokens) → Opus 4.7 default
• Long idle pauses (going to lunch) → save state before, fresh session after
• Batch processing thousands of similar requests → Sonnet 4.6 still wins

What 4.7 didn't fix

Three things still bug me:

1. Tool calling on long chains. After ~30 tool calls in a row, quality dropped on 4.6. In 4.7 it still drops, just from ~50. Compacting the conversation before continuing is still useful.

2. No real cross-session memory. Every new session starts blank. Claude Code's memory system (local files) is a workaround, not a solution. Waiting for Anthropic to ship this natively.

3. Hallucinations in niche areas. Ask about a library released in the last few months, model confabulates. Knowledge cutoff is still a fact, WebFetch against the docs saves you.

Concrete example: a refactor I did today

Dual-locale (PL + EN) for this very blog. The workflow that worked:

# 1. Plan mode — agent spawned 2 explore agents in parallel (blog + automation)
# 2. Result: precise file map, i18n pattern choice without next-intl
# 3. Second agent (Plan subagent) designed routes and loader
# 4. Questions: two real forks (posting mechanism, language)
# 5. ExitPlanMode → 30 minutes of implementation

Without 1M context the agent would be loading files on demand. With 1M it held all of lib/blog/ + 4 existing posts + components + sitemap at once. The plan was simply coherent.

Verdict

Opus 4.7 has been my default for a week and I'm not going back. Not because it's "magically smarter", single-answer quality difference is small. It wins on consistency across long tasks: doesn't drop context, plan mode genuinely guards against scope creep, fast toggle gives you a choice when you don't need full reasoning.

When NOT Opus 4.7:

• Batch processing scripts (token cost dominates)
• Trivial edits (clean up formatting, add a comment)
• Hard-cap budget environments (e.g. queued API calls without cache)

Everything else, Opus 4.7 wins by a hair, but it wins.

If you're building on Claude Code and want to talk model trade-offs, drop me a line. In the previous post about skills I covered which custom workflows I moved to 4.7, most without change, a few simplified using the 1M context.