Why You Keep Re-Explaining Yourself to AI (The Cold-Start Problem)
Every new AI session, you start over
Every new AI session, you start over. Who you are, what you're working on, how you like things done — you type it all again, or paste it from a doc, or spend the first ten messages course-correcting until the AI finally gets it. One person on Reddit described it perfectly: it feels like onboarding a new hire every single day. There's a name for this, and a way out.
Why do you keep re-explaining yourself to AI?
Because the model has no standing knowledge of you, and most of what you tell it doesn't persist in a way the next session can use. Every conversation begins from roughly the same blank slate, so every conversation needs the same setup: your role, your project, your preferences, your constraints.
One Reddit user, a solo founder, put numbers on it — around ten minutes per session re-explaining context across Claude, ChatGPT, and Cursor. Another described writing the same setup every session: how they like code structured, how to handle errors, to stop asking for confirmation on every step. The phrase that keeps coming up is "onboarding a new hire every day." That recurring tax has a name.
What is the cold-start problem?
The cold-start problem is the AI beginning each session with zero context about you, forcing you to supply it from scratch before the tool becomes useful. "Cold" because there's no warmth of prior knowledge — no sense of who you are or what you've been doing. Every session opens at zero.
It's the gap between what you expect (a tool that knows you, since you've used it for months) and what you get (a brilliant stranger you re-brief daily). The capability is there; the continuity isn't — and the missing continuity is what you pay for in re-explanation every time.
Why does every session start cold?
Two reasons stack up:
LLMs are stateless by default. The model itself retains nothing between conversations. Whatever you said yesterday is gone today unless some system outside the model stored it and feeds it back. "Memory" is never the model remembering — it's an application layer re-injecting context.
Platform memory is shallow and siloed. The built-in memory features help, but they tend to store high-level preferences rather than a real working model of you — one user's complaint was that it "remembers facts about me, not how I actually think." And it's locked to each platform: what ChatGPT knows, Claude doesn't, so switching tools restarts the cold-start cycle. Work across two or three AIs and you're re-explaining yourself to each.
Why doesn't platform memory fully fix it?
Because it's both too thin and too walled-in. Too thin: it captures preferences, not the depth of context that actually makes the AI useful for your work — your current projects, your standards, the state of things. Too walled-in: it doesn't travel, so every new tool, and every tool you already use alongside your main one, still starts cold.
So even with memory switched on everywhere, the founder juggling Claude, ChatGPT, and Cursor still re-explains — because three siloed shallow memories don't add up to one portable understanding of them. The cold start shrinks a little inside each tool and stays fully intact between them.
How do you start every session warm?
By loading your context automatically at the start, instead of typing it. There are three common approaches — they're not mutually exclusive, and people often graduate from one to the next:
1. Markdown context files. Keep your context in plain .md files (who you are, your projects, your preferences) and feed them in at session start — pasted, uploaded to a project, or auto-read by tools like Claude Code via CLAUDE.md. Dead simple, fully yours, no dependencies. The limits: you maintain them by hand so they drift, and getting them into each tool is still a manual habit.
2. A context repo in Git. Put those files in a Git repository so they're versioned, shareable across machines, and a single source you point tools at. Better portability and history than loose files, and developers like it. But it's still manually maintained, still developer-flavored, and "point every tool at the repo" isn't seamless for non-technical work.
3. A context layer. Keep structured context in a dedicated layer that extracts it from your real sources, stays current automatically, and serves it to any AI tool through MCP. The upside over the first two: it doesn't go stale (it updates from your sources), it loads into every connected tool without per-session pasting, and it's owned and portable rather than locked to one platform. The tradeoff is initial setup — connecting your sources up front — which pays back fast if you work across tools daily.
The honest comparison: files are the cheapest start and great for a single project; a Git repo adds versioning and portability for the technically inclined; a context layer is the most durable for working across many tools without the upkeep. All three beat re-typing. The question is how much manual maintenance you want to keep doing.
However you do it, the goal is the same: stop opening each session cold. Load your context once, automatically, and the AI starts every conversation already knowing who it's working with — no onboarding the new hire all over again.
→ The portable approach in depth: What Is Personal Context for AI?
→ The time it gives back: How Context Speeds Up Your Work with AI
→ Start every session warm with Unabyss →
