Context Window Sizes in 2025: What They Mean for Developer Workflows
Claude can now hold 200K tokens in context. GPT-4o goes to 128K. What do these numbers actually mean for day-to-day development, and when does a bigger context window stop helping?
What Is a Context Window, Actually?
A context window is the amount of text an LLM can "see" at once — both the input you provide and the output it generates. Everything outside the context window is invisible to the model. It has no memory of previous conversations unless you explicitly include them.
In early GPT-3 deployments, context windows were around 4,000 tokens (roughly 3,000 words). Today, Claude 3.5 Sonnet supports 200,000 tokens — about 150,000 words, or a full-length novel.
Why This Matters for Developers
For code work, the context window limit determines:
- How much of your codebase you can include in a prompt
- How long a conversation you can have before the model "forgets" early context
- Whether you can paste an entire file vs. needing to selectively include relevant sections
In practical terms, going from 4K to 128K tokens changed LLM-assisted development from "useful for snippets" to "useful for entire modules." Going from 128K to 200K+ is more incremental, but still meaningful for very large codebases.
The Useful Range for Development Tasks
From my experience, most development tasks fit comfortably in 8–16K tokens:
- A single Drupal module (custom code only): typically 2–10K tokens
- A set of related module files + the relevant Drupal core APIs: 10–30K tokens
- An entire small application: 30–100K tokens
The 200K window becomes relevant when you need to reason across an entire large application — reviewing a pull request that touches 50 files, understanding how data flows through a complex system, or debugging an issue that requires seeing both the module that produces data and the module that consumes it.
The Needle-in-a-Haystack Problem
Larger context windows come with a known limitation: models perform worse at retrieving information from the middle of a very long context than from the beginning or end. This is called the "lost in the middle" problem.
Practically: if you dump 150K tokens of code into a prompt and the relevant section is in the middle, the model may produce a less accurate response than if you'd trimmed the context to include only what's relevant.
More context isn't always better. The best prompt includes exactly what the model needs to answer accurately — no more, no less.
Retrieval-Augmented Generation for Large Codebases
For very large codebases where even 200K tokens isn't enough, the emerging solution is RAG (Retrieval-Augmented Generation): embed your codebase as vectors, retrieve the semantically relevant sections at query time, and inject only those sections into the LLM's context.
Tools like Continue.dev and Cursor implement this automatically. The result is that the LLM "knows" your entire codebase even when it can't fit in a single context window — because the retrieval system surfaces the right pieces on demand.
What to Actually Do With This
For most day-to-day Drupal development, you don't need to think about context limits — individual module files and the associated tests comfortably fit in any modern LLM's window.
Where it matters: when debugging cross-module issues, doing architecture reviews of large systems, or trying to understand an inherited codebase. In these cases, choosing a model with a larger context window (Claude or GPT-4o over smaller models) and being deliberate about what you include in your prompt will meaningfully improve output quality.