Claude Code Just Went 5x: 1M Context Window Changes Everything for Builders

Shawn Tenam·Mar 13, 2026·5 min read·context-engineering

tl;dr: 5x context window, same price. Sessions stop being fragile. Entire codebases fit in working memory. The 1M token upgrade in Claude Code v2.1.75 means you can run full feature builds, multi-file refactors, and deep debugging in a single continuous session without compaction anxiety.

Friday afternoon. Claude Code v2.1.75 lands. I open the changelog and do a double take.

1 million token context window. 5x what we had. Same price.

If you've been building seriously with Claude Code, you already know the constraint that defined every session: context compaction. That invisible ceiling where your agent starts forgetting what it was doing, where you have to re-explain architecture, where long sessions degrade into confusion. That constraint just got blown wide open.

The 1M context window means an entire codebase, all your CLAUDE.md rules, skill files, voice systems, and session history can fit in working memory simultaneously. The agent stops forgetting. The sessions stop breaking.

what actually changed in Claude Code v2.1.75?

The numbers are simple:

Before: ~200k context window
Now: 1M context window
Price difference: Zero. Same Max subscription.

The implications are not simple at all.

why does 1M context change how you work?

200k felt like this in practice: you could explore a codebase, plan an approach, implement a feature, and maybe run tests before things got tight. Complex multi-file refactors? You'd burn through context just reading the files. Full-stack features touching frontend, backend, database, and deployment? You'd manage compaction anxiety the entire time.

At 1M, that math changes fundamentally.

Sessions stop being fragile. I used to structure work around context limits. Break tasks into smaller chunks, write handoff docs between sessions, babysit the compaction counter. Now I can start a feature, hit complications, explore alternatives, refactor, test, fix edge cases, and deploy. All in one continuous session. The agent doesn't lose the thread.

Entire codebases fit in working memory. My monorepo has 3 Next.js apps, shared packages, i18n across 3 languages, a GTM operations layer, and automation scripts. Before, the agent could hold maybe one app's context at a time. Now it reasons across the full system. Cross-cutting changes that touch everything go from multi-session marathons to single-session sprints.

Complex debugging actually works. The hardest bugs live at intersections: the middleware interacting with the i18n config interacting with the deployment pipeline. Debugging those requires holding a lot of context simultaneously. At 200k, you'd lose earlier findings as you explored deeper. At 1M, you trace a bug from the browser console through the middleware stack through the build config and back. The agent remembers what it found three files ago.

No more babysitting. I already run with permissions auto-approved. The context limit was the last thing I had to actively manage. Now I hand off ambitious tasks and actually walk away. Come back to finished work instead of a confused agent that compacted away the important bits.

what does this mean for weekend builds?

It's Friday. Which means it's time for the builds that don't fit into weekday slots. The ambitious ones. The ones that start with "I wonder if I could..."

With 200k context, those projects required careful session management. Break it into phases. Write handoff docs. Re-orient the agent each session. Lose momentum to overhead.

With 1M context, I can sit down Saturday morning and say "build me an entire feature from spec to deploy" and have genuine confidence the agent will maintain coherence from start to finish. Not because the model got smarter. Same Opus 4.6. But because it can finally hold enough context to use its intelligence on real problems instead of spending capacity re-reading its own earlier work.

how does the larger context window compound?

This isn't just 5x more tokens. It's a qualitative shift in what's possible per session:

Refactors that touch 20+ files without losing track of the dependency graph
Full feature development from database schema through API through UI through tests
Multi-codebase operations in a single session
Deep architectural exploration before committing to an approach, without burning context on the exploration itself
Longer autonomous runs where the agent course-corrects on its own because it remembers its mistakes from earlier in the session

Each of these was theoretically possible before. In practice, context limits made them fragile at best, impossible at worst.

what's the builder's advantage?

If you're shipping real products with Claude Code... not writing blog posts about AI, not making demo videos, actually shipping... this update is the single biggest quality-of-life improvement since the tool launched.

The builders who figure out how to use this space effectively will pull ahead fast. Not because they have access others don't (same subscription), but because they'll restructure their workflows around what's now possible. Bigger tasks per session. Less overhead. More shipping.

Same Opus 4.6. Same pricing. Same tool. Just 5x more room to actually use it.

Happy Friday. Time to build.

frequently asked questions

how big is Claude Code's context window? As of v2.1.75, Claude Code has a 1 million token context window. That's roughly 5x the previous ~200k limit. It's large enough to hold an entire monorepo, all your instruction files, and a full session history simultaneously.

did Claude Code's pricing change with the 1M update? No. The 1M context window ships at the same price as the previous 200k window. Same Max subscription. 5x more room for zero additional cost.

what model does Claude Code use? Claude Code runs on Opus 4.6. The 1M context update didn't change the underlying model. Same intelligence, more working memory.

how does a larger context window help with coding? The context window is the agent's working memory. A larger window means the agent can hold more of your codebase, more of your instructions, and more of the current session's history without forgetting. This eliminates the compaction problem where long sessions degrade because the agent loses track of earlier work. Bigger context means longer, more coherent sessions and fewer re-explanations.

Boris Cherny designed Claude Code's architecture to treat context as the primary programming surface. The 1M window is the logical extension of that philosophy. Full breakdown: Boris Cherny and Claude Code context engineering.

For how this fits into a daily building practice: 6 weeks of building with Claude Code.

The same shift applies beyond coding. Solo GTM engineers running full pipelines on this stack: from SDR to solo GTM engineer.

Building with Claude Code daily at shawnos.ai. GTM OS is open for builders who want to see how AI-native operations actually work.