You've Had This Conversation With Claude Code 47 Times

“We use TypeScript with ESM modules. Deploy only through the staging workflow, never push to main. We use Zod for validation, not Joi. The auth service lives in services/auth, not src/auth. Tests go next to the source file, not in a tests directory.”

If you use Claude Code daily, you’ve said this. You’ve said it in every new session. You’ve said it yesterday, last week, and two months ago. At this point you’ve typed the same paragraph forty-seven times.

This is not onboarding. This is a tax you pay for using the tool.

The shape of the tax

Let me be specific about what the tax actually costs. Not in dollars, not in tokens, in minutes.

A typical explanatory opening is 200 to 400 words. Typing that block at the start of a session takes two to three minutes if you have it memorized and five to eight if you’re composing it fresh. Call it four minutes average.

Then there’s the re-correction loop. You open a session, start working, and after 20 minutes the agent does something that contradicts a convention you forgot to include in the opening. You correct it. You explain why. You say “remember this for next time.” The agent confirms. Both of you know it won’t remember.

If you run four sessions a day, you pay sixteen minutes in opening taxes and another ten to twenty minutes in correction loops. That’s half an hour per day of re-explaining things you’ve already explained.

Over a month that is roughly ten hours of your life spent repeating yourself to a tool that can’t retain the conversation.

The fix that doesn’t work: a bigger CLAUDE.md

Everyone’s first idea is the same. Write it down. Put it in CLAUDE.md. Let the agent read it at session start.

This works for about two weeks.

Then your CLAUDE.md is 180 lines long. Half of it is outdated because you changed your mind about the auth layout. A third of it contradicts itself because you edited the bottom without rereading the top. And the important rules are buried under the merely preferential ones, so when the agent does read the file it weights them all equally.

CLAUDE.md is a static artifact. Your project is a moving target. A static file written by hand cannot track a moving target without constant maintenance that nobody does.

I know nobody does it because I tried. I maintained a careful CLAUDE.md for three weeks. Every time I had a conversation with the agent that corrected something, I switched to a browser tab, opened CLAUDE.md, added a line, saved, and came back. After three weeks I was editing that file once a day and it was still drifting.

The maintenance cost is the same shape as the original re-explaining cost. You just moved it from “before the conversation” to “after the conversation.” You are still typing the same things twice.

The actual problem

The problem is not that Claude Code forgets. Forgetting is the obvious shape. The real problem is that every correction I give the agent is ephemeral data. I said it, the agent heard it, and the moment the session ends that exchange is gone. The next session starts from the same baseline as the first one.

I’m not losing the agent’s memory. I’m losing my own memory of what I taught it.

If I had a system that recorded every correction as structured data the moment I made it, and injected that data back into the next session automatically, the re-explaining tax would drop to zero. I’d still have to correct the agent occasionally. But I’d do it once, not forty-seven times.

What this looks like in practice

Here’s what an actual session opening looks like for me now, using AXME Code:

Me: "start session"

Agent: (reads .axme-code/ context automatically)
       "Project stack loaded: TypeScript, Astro, Vercel.
        Active decisions (12 required, 4 advisory):
        - Use Zod not Joi for validation
        - Never push to main directly
        - Session end must call axme_finalize_close
        ...
        Last session handoff:
        - Finished: refactor auth middleware to use Zod
        - In progress: migrate user service to new types
        - Open question: should we version the API before beta?
        Proceed?"

Me: "yes, continue the user service migration"

That’s the whole opening. I said eight words. The agent already knew everything I would otherwise have typed.

The “Use Zod not Joi” rule didn’t come from a hand-written file. It came from a correction I made in session 23 when the agent generated Joi. I said “we use Zod, not Joi.” The agent wrote that to the decision log. Every session since then has started with that rule already loaded.

The point of this post

If you have this tax and you think the fix is “I need to write better CLAUDE.md files,” you’re fighting the wrong battle. The fix is to stop writing things by hand and start letting the tool remember them structurally, the way you remember a git commit history. You don’t re-enter commit messages every session. You shouldn’t re-enter project conventions either.

There’s more than one way to do this. You can build it yourself with a simple SQLite database and a hook. You can use a memory plugin. You can use AXME Code, which is what I use because I built it to solve my version of this problem.

The mechanism is not the point. The point is that you stop paying the tax.

After two months of running this I can count on one hand the number of times I’ve had to re-explain a project convention. Every conversation about how the project works now starts with the agent already knowing.