Register for Pioneer: A summit for AI customer service leaders
Join the brightest, most innovative voices in customer service at Pioneer, a summit for exploring the latest opportunities and challenges transforming service with AI Agents.
Hear from leaders at companies like Anthropic, Boston Consulting Group, and more on how they’re building smarter support systems and why customer service will never be the same.
Why optimal AI performance happens at 40% context utilization — and how to build the systematic workflow that ships production code faster.
Everyone building with AI coding assistants is asking the wrong question.
Stop asking “How do I fit more context into my AI agent?” Start asking “How do I fit LESS context with higher signal?”
After Dexter Horthy fixed a 300,000-line Rust codebase in 7 hours instead of 5 days, one thing is clear: constraints don’t limit AI agents — they enable precision.
Here’s what most developers miss about context engineering.
1. The 40% Advantage
Most developers treat context windows like unlimited storage. Load the entire codebase. Include all documentation. Add every relevant file. More context means better AI performance, right?
The data says no.
Anthropic’s research reveals optimal AI agent performance at 40–60% context window utilization, not 100%. Performance actually degrades as you approach maximum capacity.

Source: Anthropic
Dexter Horthy proved this in production. His 7-hour fix of a 300k-line Rust codebase — originally estimated at 3–5 days — used constrained context at roughly 50% utilization.
The context problem hierarchy matters more than most teams realize:
Incorrect information (catastrophic failures)
Missing information (fixable gaps)
Too much noise (annoying but manageable)
Most developers optimize for #2 and #3 while ignoring #1’s catastrophic impact.
Why Constraints Work
Think of context windows like your brain’s working memory during a conversation, not long-term storage.
You can technically track everything everyone ever said, but actively holding it all degrades your ability to respond thoughtfully. The best conversations happen when you focus on what matters most — not when you’re overwhelmed by every detail.
Context windows aren’t RAM — they’re attention budgets. Attention is a scarce cognitive resource, not unlimited storage. Flood the context with noise and the AI struggles to identify signal. Performance degrades. Code quality suffers.
2. The FIC Principle (Frequent Intentional Compaction)
Most AI-assisted development follows vibe coding. It works for simple scripts. It fails in complex projects.
Here’s why
A bad line of planning creates hundreds of bad lines of code.
Planning errors compound exponentially in implementation. That quick “just add this feature” prompt leads to architectural misalignment, broken tests, hours of debugging.

The industry’s focus on implementation speed misses the real bottleneck: upstream precision.
The Evidence
Dexter’s 7-hour Rust fix followed meticulous adherence to the FIC workflow: Frequent Intentional Compaction.
Three systematic stages:
Research (understand the codebase)
Plan (define the approach)
Implement (execute with compaction checkpoints)

Practitioners report 60% reduction in AI-generated code revisions using this workflow. The time investment shifts from debugging to planning — where it compounds.
How Compaction Works
Frequent Intentional Compaction means regular context summarization. At each checkpoint, create a structured artifact:
End goal (what you’re building)
Current approach (how you’re solving it)
Completed steps (what’s done)
Current challenges (what’s blocking you)

How Intentional Compaction works.
This becomes the foundation for continued progress. It forces precision. It maintains signal quality. It transforms AI from unpredictable experiment into reliable engineering practice.
The compaction checkpoint isn’t a limitation — it’s a forcing function for clarity.
3. The Isolation Pattern
Single-agent architectures create context pollution. The same agent researches the codebase, plans the implementation, and writes the code.
Research floods context with file snippets, documentation, Stack Overflow threads. By implementation time, the context is 90% noise, 10% signal. Architectural coherence suffers.
Worse: you’re optimizing for the wrong context problem. Adding information (#2 on the hierarchy) while ignoring potential incorrect information (#1).
The Architecture
Dexter’s approach uses subagent architecture with isolated context windows for specialized tasks. Separate agents handle search, research, and summarization. The main agent maintains architectural coherence.
This mirrors fundamental software engineering principles: separation of concerns, modular design, bounded contexts. The pattern isn’t new — the application to AI workflows is.
What Most Engineers Do:
# Single agent handles everything
agent.research("How does auth work in this codebase?")
# Context now: 50 file snippets, Stack Overflow threads, docs
agent.plan("Integrate OAuth")
# Planning context polluted with research details
agent.implement()
# Implementation context: 90% noise, 10% signal
What Actually Works:
# Research in isolated context
research_agent = Agent(context="search_only")
summary = research_agent.summarize("Auth patterns in codebase")
# Planning with clean context
plan_agent = Agent(context=summary)
implementation_plan = plan_agent.create_plan()
# Implementation with focused context
main_agent = Agent(context=implementation_plan)
main_agent.implement()
# Context: 60% signal, 40% breathing room
Notice the compression protocol? Summaries, not raw data.
The Broader Insight
These three patterns — constrained context, systematic workflow, architectural isolation — form the foundation of production AI coding.
But here’s why the industry gets it wrong: the AI marketing narrative optimizes for demo appeal, not production reality.
“Unlimited context windows!” sounds impressive but fails in complex projects where signal quality matters more than raw capacity.
Production AI systems require the same discipline as production software systems: systematic approaches, architectural boundaries, evidence-based optimization.
The shift from vibe coding to context engineering represents the maturity transition every discipline undergoes.
The core principle: Constraints don’t limit complex systems — they enable precision through forced optimization.