Gemini's 1M Token Context Sounds Amazing. But We're Only Using 12% of It. Why?

Our product team recently adopted Gemini CLI specifically for its 1M token context window. The pitch was irresistible: “Analyze your entire codebase in a single query!”

Three months in, here’s the uncomfortable truth: We’re only using 12% of that massive context window. And context preparation is the actual bottleneck.

The Promise vs. The Reality

The promise: Feed the AI your entire 500K LOC codebase, ask architecture questions, get comprehensive answers.

The reality: Most developer tasks need <100K tokens. Feeding 1M tokens takes 5-10 minutes of preparation time. Developers quickly learned to feed minimal context to save time.

The Data

I tracked our team’s Gemini CLI usage for 8 weeks:

  • 88% of sessions use <200K tokens (not even close to 1M)
  • Average context prep time: 4 minutes per session
  • Multiplied across team: ~15 hours/week just gathering and feeding context
  • Actual “huge context” usage: Maybe 3-4 times total for legacy codebase analysis

The Behavioral Pattern

Developers initially tried to use the full context capability. But they discovered:

  1. Preparation overhead kills flow: Selecting files, structuring context, waiting for indexing
  2. Response time increases: Larger context = slower AI responses (sometimes 30+ seconds)
  3. Diminishing returns: Adding more context doesn’t always improve answer quality
  4. Cognitive load: Managing what to include/exclude is mentally taxing

So they adapted: Feed only what’s immediately relevant, ignore the 1M capability.

The Question Nobody Asks

Is massive context a marketing feature or an actually useful daily tool?

For us, it’s an emergency capability. When we need to understand a monolith migration or analyze cross-service dependencies—yes, invaluable. But that’s 5% of our work.

The other 95%? We’re paying for 1M tokens and using 100K.

Questions for the Forum

  1. Have you found large context windows actually useful daily? Or is it occasional “emergency use”?
  2. What’s the optimal context size for typical development work? Is 1M overkill?
  3. Context prep time—hidden cost? Do you factor this into productivity calculations?
  4. Does knowing you CAN analyze everything change behavior? Even if you don’t actually do it?

I’m starting to think the psychological benefit (“I could feed it everything if I needed to”) matters more than the actual usage. Like having a truck—you almost never haul anything, but knowing you could feels valuable.

Am I missing something? Or is this the 2026 version of “640K ought to be enough for anyone”—but in reverse?

David—I agree but with a major exception: legacy codebase migrations.

We used Gemini CLI’s full 1M context exactly once: analyzing our 500K LOC monolith before microservices extraction. That one session justified the entire tool for me.

The Discovery Use Case

Pattern I’m seeing: Large context for discovery/analysis, small context for execution.

  • Planning phase: Feed everything, ask “what are all the places we touch user authentication?”
  • Execution phase: Feed only auth module (20K tokens), implement changes

But Your Point About Prep Time Is Critical

4 minutes average per session × 50 sessions/week = 200 minutes = 3.3 hours/week just on context preparation across our team.

That’s real cost we weren’t tracking.

Question Back to You

What’s the optimal context size for daily work? You said 100K—is that empirical or gut feel?

I’d love to see benchmarks: context size vs answer quality vs response time. Maybe there’s a sweet spot we’re all missing.

Love the truck analogy! Design perspective: Having the capability changes your mental model, even if you rarely use it.

The Psychological Benefit Is Real

When I know I CAN analyze my entire design system (200+ components), it reduces anxiety. I don’t have to carefully curate what to feed the AI—I can just throw everything at it when stuck.

That’s worth something, even if I only do it monthly.

But Context Prep Time Compounds

Your 4-minute average across a team is brutal. That’s the context-switching penalty I mentioned in the other thread.

Question: Have you tried pre-built context profiles? Like “auth context” or “API context” that are pre-indexed and reusable?

Could cut prep time from 4 min to 30 seconds if you’re reusing common context bundles.

Strategic angle: Should we pay premium for large context if it’s rarely used?

Gemini CLI pricing tiers are based on context window size. If you’re only using 12%, you’re potentially overpaying.

Cost-Benefit Analysis

Question for David:

  • What do you pay for 1M context tier?
  • What would 200K context tier cost?
  • Is the price delta worth the “emergency capability”?

For us, we analyzed this and decided: Keep the large context tier because the 5% of use cases (architectural analysis, migration planning) are business-critical.

But if those were lower priority, we’d downgrade and save the budget.

The Architecture Insight Pattern

Luis’s point is key: Large context enables new types of analysis that are impossible otherwise.

Cross-service dependency mapping. Security audit across entire codebase. Performance bottleneck discovery.

These are strategic questions that justify occasional high context usage, even if daily work doesn’t need it.

Team scaling perspective: Context prep time is hidden onboarding cost.

When we bring on new engineers, they don’t know what context to feed. They either:

  1. Feed too little (get wrong answers)
  2. Feed too much (waste 10+ minutes per query)

It takes 2-3 weeks to learn “optimal context selection” for our codebase. That’s training overhead we didn’t account for.

Solution We’re Testing

Maya’s suggestion about pre-built context profiles is brilliant. We’re creating:

  • Common scenarios: “auth debugging”, “API changes”, “frontend component work”
  • Pre-indexed context bundles for each
  • Documentation: When to use which profile

Early results: Reduced context prep from 4 min to 1.5 min average.

Question for the group: Has anyone automated context preparation? Scripts that build context based on Git branch or file patterns?