I used to start every AI session the same way: a paragraph of apology. "Sorry, this is a Next.js app with..." Then the stack. Then the bug. Then what I'd already tried. By the third tool of the day, I was spending more time briefing the AI than using it.
Turns out I'm not alone. A builder on Hacker News described the exact loop: months of bouncing between ChatGPT, Claude, and a pile of VS Code extensions, constantly re-explaining his codebase to each one. The real punch came when he checked the bill: $40 a month on random API calls scattered across tools that shared nothing with each other. He ended up building his own assistant with semantic search and memory just to stop the bleeding.
Another builder went the manual route after hitting the same wall switching between AI platforms: a tool that exports the whole conversation to markdown so you can paste it into the next AI and pick up where you left off.
Two different builders, two different fixes, one diagnosis: the models aren't the problem. The handoff is.
Why switching hurts more than you think
Let's count the ways this costs you, because most of it is invisible.
First, the briefing itself. Ten to twenty minutes per session of "here's my stack, here's the bug, here's what we tried." Do that three times a day and you've burned an hour on context that should have traveled with you.
Second, the scattered spend. That $40 a month wasn't one big bill, it was a dozen small ones. Extensions, side tools, API calls from helpers you forgot you installed. None of them talk to each other, so none of them can tell you what the total is.
Third, the quiet lock-in. You stop switching tools not because your current one is best, but because retraining a new one costs a day. Your history becomes a hostage.
Fourth, the guesses. An AI without your context doesn't admit ignorance. It invents. Wrong library versions, conventions you never used, refactors of things that worked. Each one costs you a correction round.
Four fixes that real people use
Instruction files are the free win. CLAUDE.md, AGENTS.md, .cursorrules, whatever your tools read. Write down the stable facts: the stack, the conventions, the parts nobody is allowed to touch. This costs nothing and handles a surprising share of the problem. The ceiling is obvious: they're static snapshots. They don't remember last Tuesday's debugging session, every tool wants a different filename, and none of it helps when you jump from a web chat to your editor.
The markdown handoff is manual but real. Export the conversation, paste it into the next tool, continue where you left off. The whole thread travels, reasoning included, not just the conclusions. The catch is discipline: you have to remember to export before you switch, the dumps go stale fast, and a giant pasted transcript eats the context window you were trying to fill. Still, manual beats amnesia.
Rolling your own is the power-user move with a power-user bill. Your own assistant, semantic search over your own history, exactly your workflow. The builder who found that $40 a month went this way. It works, but you're now the maintainer of a second product. Unless your workflow is genuinely unusual or your data can't leave your own machines, the maintenance usually costs more than the problem did.
A shared memory layer is the laziest option that works. Connect your AI clients to one memory store over MCP, and they all read the same context. I use Vilix AI for this, so here's the honest version: you wire up each client once, then calls like get_context pull relevant history into the conversation and save_turn stores it. Plan in Claude, build in Codex, the context follows. The tradeoffs are real: it's hosted, so your context sits on someone else's servers (though you can export everything in a portable format and delete it all instantly). Each client needs its own setup, and it only covers MCP-compatible tools. Free tier exists; paid starts at $10 a month, Pro is $20 a month or $200 a year, with a 7-day trial that doesn't ask for a card.
What I'd actually do
Start free. Instruction files cost nothing and get you halfway there. If you switch tools a few times a week, add the markdown handoff and accept the friction. If you're switching daily, or you've got scheduled agents running across different tools, that's when a shared layer earns its keep: the briefing tax has become the biggest line item in your week.
The models keep getting smarter. The bottleneck was never their intelligence. It's that every time you change chairs, they forget who you are.
Top comments (0)