I keep having the same conversation.
Someone tells me Claude Code “forgets” their instructions. Or it hallucinates fixes that break things. Or it ignores rules they carefully wrote in CLAUDE.md. And when I ask what their setup looks like, it’s the same pattern every time: a massive system prompt containing every rule for every language, every edge case for every situation, thousands of lines of instructions stuffed into context.
Then they’re surprised when the AI starts confusing things.
To explain how this works, picture a handyman.
The Handyman and the Dishwasher
You hire a handyman to fix your dishwasher.
He walks into your kitchen. Before he starts, you hand him a binder. In this binder is the manual for the dishwasher. But it also contains the manual for the blender, the schematics for the toaster, the history of how the roof was thatched in 1998, and a guide on how to knit a sweater.
“Read this binder. Remember it all. Now fix the dishwasher.”
This is what most people do with AI context. One giant CLAUDE.md containing every rule for every language and every situation in their codebase. The handyman gets overwhelmed. Context is too noisy. He might start fixing the dishwasher using the blender instructions.
I don’t do this.
I treat context as a scarce resource, not a dumpster. The Handyman Principle: only pull the relevant information for the specific task.
Agents: The Job Description
The handyman doesn’t need the blender manual to fix the dishwasher.
He only needs the instructions relevant to his current task. I call this the Russian Doll approach: peel away everything that isn’t necessary, making the context as small and specific as possible.
In my setup, I almost completely ignore the global CLAUDE.md. Instead I use Agents.
An Agent is a specialized instructions file. If I’m working on a TypeScript problem, I switch to my TypeScript Agent. It knows TypeScript. It doesn’t know about Python deployment scripts or SQL. By removing the distraction of other languages, the handyman knows exactly what job he’s doing today.
35 agents now, each one dense with patterns for its domain.
A Go agent contains error wrapping conventions, concurrency patterns, testing idioms. A Kubernetes agent contains pod lifecycle states, common failure modes, debugging workflows. The agent is the job description, and when you narrow the context, you get better adherence to the rules that remain.
This is where the biggest confusion happens.
I see people arguing that “Skills” are just fancy prompts, just text files telling the AI what to do. If that’s all you’re doing, you aren’t adding value. You’re feeding in different steps. That’s it.
Think about the handyman again.
He doesn’t walk around holding a hammer, saw, drill, and wrench in his hands all at the same time. He keeps them in a toolbox. He pulls out the hammer when he sees a nail.
To me, a Skill is a program. A deterministic tool attached to a markdown file.
Bad Skill: “You are an expert at generating images.”
Good Skill: A markdown file that connects the AI to a Python script using Imagen to actually generate the file.
When my agent needs to do something, it shouldn’t be guessing how to do it. It reaches into the toolbox and calls a script I wrote, adding actual features to the system that the LLM didn’t have before.
68 skills in my current setup, and most wrap deterministic scripts.
Voice validation runs through a Python validator. Git commits follow a specific flow. Quality gates execute real linters. The AI orchistrates. The scripts execute. Variance is in the selection, not the runtime behavior.
Plans: The Clipboard
Finally, how does the handyman remember what he’s doing?
He doesn’t memorize every movement he’s made for the last four hours. He looks at his clipboard.
I use Plans as my memory abstraction. A plan is a list of steps stored in a file, and the Agent reads the plan, picks the right Skill to execute the next step, then updates the plan.
This is how you stop the AI from forgetting.
You don’t make it remember the past. You make it read the current status from the clipboard. When I start a complex task, I create a plan file. The agent checks the file to see what’s done and what’s next.
Progress is external state, not internal memory.
The plan is checkpointable. If the context window fills up and you have to compact, the plan survives and the agent picks up where it left off.
It’s Just Context Management
The funny part is that most “memory tools” being sold right now are barely doing anything. They’re over-engineering a problem solved by simple organization.
Don’t give the handyman the blender manual. Use granular Agents.
Give the handyman real tools, not advice. Use Skills with scripts.
Give the handyman a clipboard. Use Plans.
We’re in the early internet phase of this technology, essentially unsolved space. None of us know what the answers will be in six months. But if you treat context like a toolbox instead of a garbage dump, you’ll find the AI is more capable than you thought.