The Intelligence of Ignorance

The smartest thing you can do with an LLM is make it dumber.

If you’ve ever watched an agent perform brilliantly on simple tasks, then fall apart the moment you try to handle edge-cases, you’ve seen this firsthand. The problem isn’t a lack of context—it’s too much of it.

This is a fundamental constraint of their design.

LLMs are just pattern matchers. They can’t think and once trained, they can’t learn. They just match patterns really, really well.

They do this by taking some input, vectorizing it into a mathematical representation, and then passing it through hundreds of billions of parameters to determine what the most statistically appropriate response should be.

That input is the context window and how you use it critically affects the quality of LLM response you get.

As the context window expands, the “attention” mechanism of the LLM is spread thin. Each additional token introduces a potential distractor, making the core pattern harder to identify. This “Dilution Effect” is the first reason LLM performance tends to suffer when prompts expand.

Expand the context window further and you might hit the “Middle-of-the-Window” Problem. LLMs statistically struggle to recall information buried in the middle of long prompts, focusing instead on the very beginning or end. Those CRITICAL and REMEMBER notes start to get lost in the noise.

Expand the context window enough and you’ll pollute it. That earlier question about “do Belgian Malinois make good pets for busy people” is why your vibecoded SAAS just turned into Linkedin for Dogs.

LLMs are stateless. Conversations are “remembered” by sending the entire history to the model each turn. Every system prompt, MCP, and custom tool you load forms part of your context window. If you aren’t careful, your context window might already include 100k tokens before you even begin.

This is why “dumber” agents win. Less context means cleaner patterns means better output.

So put your LLM on a diet. Only load tools you actually need. Only feed it the exact snippet of documentation or code it needs for the current micro-task, not the whole library. Drop that MCP if it isn’t essential for the task at hand.

Embrace the benefit of amnesia. Rather than trying to solve the entire problem once, break it down into smaller distinct conversations. Reset context early and often. Start by discussing high-level approaches with your LLM, evaluate them, and select one. Then reset to discuss an implementation plan, and reset again for each step of the plan. Have your LLM update the plan at each step and this will provide the requisite “memory” between steps.

Then compose agents into an agentic system. Just enough context that a human could follow the instructions successfully but not so much to distract. Surface these agents via tool descriptions to an orchestrating agent that does nothing more than select the best tool for the job.

So build goldfish, not oracles. Agentic intelligence isn’t about capacity - it’s about focus.