Actually Using Large Context Windows: Strategies That Work

You've got 200k tokens now. Congratulations. You're also probably wasting half of them.

I've watched people spin up Claude with a massive context window, dump their entire codebase in there, and then wonder why the responses get weird or expensive. The context window isn't magic—it's a tool, and like most tools, you can use it poorly.

Here's what I've learned actually works.

Stop Treating Context Like a Trash Bin

Your first instinct: "I'll just paste everything and let the model figure it out."

Don't.

A 200k token window doesn't mean throw 200k tokens at every query. It means you can be strategic about what you include. The model still has to process all of it, which costs money and can hurt response quality.

Better approach: Include what matters for this specific task.

Building a feature? Include the relevant module, the API contracts it talks to, and maybe one example from a similar feature. Skip the entire test suite. Skip the deployment configs. Skip the parts you're not touching.

Think of it like a code review—you want the reviewer to see the change in context, not the entire repo.

Load Once, Reference Multiple Times

Here's a pattern that actually saves money: put your schema or architecture once at the beginning, then ask multiple related questions.

Here's our database schema:
[full schema]

Here's how we handle auth:
[auth module]

Question 1: How would I add a subscription tier?
Question 2: What would change in the auth flow?
Question 3: How does billing integrate?

The model keeps the schema and auth context across all three questions. You're not re-uploading the same stuff repeatedly. In a single conversation, this is way more efficient than three separate API calls.

Be Stupid About File Boundaries (In a Good Way)

You don't need to paste files in their "logical" form. Break them up strategically.

If you're debugging a performance issue in a 2000-line file, don't paste the whole thing. Paste the problematic function plus 10 lines of context on each side. That's usually 50-70 tokens instead of 800.

If you're writing a new feature, paste the exact interface definition, not the entire module.

The model doesn't care if it's a "complete" file. It cares about having enough context to help you.

Use Multiple Turns for Exploration

Don't try to ask ten follow-up questions in one message. Ask one thing, read the response, then ask the next.

Why? Because the model can track your goals better if you build on previous answers. It learns what you're actually trying to accomplish. Plus, you might realize mid-conversation that you're asking the wrong question—and you've saved the tokens you would've wasted.

One solid follow-up beats three speculative "what if" questions.

Manage Conversations Like Git Branches

For complex work, start a fresh conversation when you're pivoting to something new.

Worked through a database migration? Done. Start a fresh chat for the API changes that depend on it. This keeps each conversation focused and prevents the "I've been in this chat for 30 messages and the model is confused about what we're actually doing" problem.

Fresh context is cheap. Clarity is expensive when you don't have it.

Real Example: Adding a Feature

Let's say you're adding a notification system to an app.

Bad approach:

• Paste the entire codebase (60k tokens)
• Ask "how should I add notifications"
• Get back a generic 2000-word answer about architecture

Good approach:

• Paste the existing event system (the thing you'll hook into)
• Paste the user model (to understand what you're notifying)
• Paste one example of a similar feature (like email alerts)
• Ask: "I need to add in-app notifications. Here's our event system and a reference feature. What's the minimal change to add this?"
• Get back a focused answer about exactly what you need to add

The second one costs 5% of the tokens and is actually useful.

The Budget Mindset

Think about context windows like memory in a game. Just because you can hold 200k tokens doesn't mean you should load everything into RAM.

Consider:

• Does the model need this to answer correctly? Include it.
• Is this "nice to have" context? Skip it (or include it in a follow-up if needed).
• Can I phrase my question so I don't need this? Do that instead.

You're not being cheap—you're being intentional. The model performs better when it's not drowning in irrelevant information.

One More Thing

If you're using this for actual products (not just playing around), check out context caching if your API supports it. Reusing the same context across multiple requests gets you discounts. It's a game-changer for codebases you reference repeatedly.

---

Want more practical AI tips? Check out LearnAI Weekly newsletter for strategies that actually work in production.

Keep your context clean. Keep your questions focused. Keep shipping.