A third of the brainpower you're paying for might be gone before your AI coding agent reads a single line of your code.
That's the finding from Daniel Miessler's analysis of AI agent architectures, where he documented that system prompts, tool definitions, and skill registries consume roughly 33% of available context before any actual conversation begins. In his own heavily-customized Claude Code setup, the startup tax hit 67,000 tokens out of a 200,000-token context window (think of context as the agent's working memory - everything it can "see" at once). The system prompt alone ate 33,500 tokens. Add tool definitions, skill descriptions, and agent configurations, and you're down a third of your runway before typing "fix this bug."
The problem compounds fast. Power users running real codebases with multiple file reads and agent calls hit context compaction - where the model starts forgetting earlier parts of the conversation - within 15-20 exchanges. That's not a lot of back-and-forth when you're debugging a complex feature.
The Fix: Lazy-Load Everything
Miessler's solution was straightforward: stop loading everything upfront. By reorganizing into a tiered system with a "lean core" of about 7,000 tokens for essential behaviors and lazy-loading the rest only when needed, his v4.0.0 release cut startup context from 38% to 19%. That freed up roughly 26,500 tokens - equivalent to about 60 pages of text - for actual work.
This matters beyond one person's setup. Every AI coding tool faces the same tradeoff: richer system prompts make the agent more capable, but they steal from the finite pool of context the agent needs to understand your codebase. Cursor, Claude Code, Cody, Aider - they all navigate this tension.
Hill-Climbing: Small Bets, Measured Results
The broader concept Miessler advocates is "generalized hill-climbing" - an iterative loop where you define a testable ideal state, measure where you are, make a small change, and re-measure. His core argument: "You can't hill-climb towards something you can't test."
Cline put this into practice on their coding agent with concrete results. Starting from a 47% success rate on Terminal Bench's 89 coding tasks, they used systematic hill-climbing to reach 57%, surpassing Claude Code, OpenHands, and OpenCode on that benchmark. Their process was unglamorous but effective: run all 89 tasks in parallel, categorize failure types, fix the most common ones, retest. They found that about 25% of failures needed fundamental model improvements, but the rest responded to prompt tuning and configuration changes - things like extending a 600-second timeout that was killing long-running builds, or adding verification steps so the agent actually confirmed files were created instead of assuming success.
What This Means for Your Daily Workflow
If you use AI coding tools and notice quality degrading partway through a long session, context waste is likely a factor. A few practical takeaways:
- Shorter, focused sessions beat marathon ones. Start fresh conversations for new tasks rather than continuing a thread that's 30 exchanges deep.
- Simpler system prompts help. If you're customizing your agent's instructions, every token in your system prompt is a token not available for your code.
- The 200k context ceiling is softer than it looks. After system overhead, your effective working memory might be closer to 130-150k tokens.
The agents are getting better at managing this - Miessler's lazy-loading approach is the kind of optimization we'll see more tools adopt. But for now, understanding the hidden tax on your AI assistant's attention span is the first step toward getting more out of it.