Every time you start a new chat and retype who you are, what project you’re working on, and what tone you need — you’re not being thorough. You’re burning the good part of the context window before the actual work starts, and wearing down your own patience before you’ve typed a single substantive thing.
Most people treat context as something you assemble freshly each session. It’s not. Context is capital. Spending it on setup every single time is like paying rent on a storage unit and also buying the same furniture again each month.
Why Starting From Zero Costs More Than You Think
ChatGPT and Claude both have finite context windows — GPT-4o at around 128k tokens, Claude Sonnet 3.5 closer to 200k. Those numbers sound large until you’re doing something actually complex: feeding in a long document, asking for multi-step analysis, maintaining a consistent voice across a writing project. The window fills up faster than the headline number suggests, because the model holds everything simultaneously — your preamble, its own previous responses, the actual work.
When you burn 300-500 tokens on backstory at the top of every session (“I’m writing a newsletter for small business owners, the tone is conversational but not fluffy, avoid bullet points…”), you’re crowding out the substantive part of the conversation before it even starts. And because that setup is always improvised, it’s never quite the same twice — which means the model’s behavior drifts slightly each session depending on exactly how you phrased it today.
The drift is subtle but real. Same task, same underlying intent, but one phrasing gets you a response with subheadings and the other doesn’t. One version of your background paragraph makes the model treat you as a beginner; a slightly different one and it pitches its explanations at the right level. This isn’t the model being inconsistent — it’s doing exactly what you told it, and you told it slightly different things each time.
What to Actually Do Instead
Build a context file. A plain text document — doesn’t matter if it’s a Notion page, a Google Doc, a local .txt file — that you paste in once at the start of a session, not reassemble from memory. Keep it short: 200-400 words covering who you are, what you’re working on, standing preferences (format, tone, things to avoid), and any project-specific terminology the model would otherwise guess at.
The key is that it stays stable. You update it when something genuinely changes, not to reflect your mood today. This single habit is worth more than most “advanced prompting” advice, because it solves a consistency problem that no amount of clever in-session engineering touches.
For longer projects — a series of posts, a product description library — go further. Keep a running decisions log alongside the context file: things you’ve already tried and rejected, directions you’ve already ruled out. Feed that in too. The model has no memory across sessions, which means without it, the model will earnestly suggest the same approaches you discarded two sessions ago. Not because it’s bad at the task. Because it genuinely doesn’t know.
Where This Gets More Interesting: Structured Context vs. Prose Context
Not all context files are equal. Prose context (“I’m a freelance copywriter working on a campaign for a mid-size SaaS company…”) works, but structured context — where you explicitly label each piece — tends to perform better, especially with Claude.
Something like:
Role: freelance copywriter
Client: mid-size SaaS, project management vertical
Tone: direct, no jargon, skeptical of hype
Avoid: bullet-point-heavy outputs, rhetorical questions, passive voice
Current task: product page rewrite, homepage and three feature pagesThat’s not elegant writing, but it’s unambiguous. The model doesn’t have to infer what’s most important from a paragraph of prose — you’ve told it explicitly. And when one thing changes (the current task, say), you change one line instead of rereading and editing a whole paragraph.
One genuine caveat: structured context works best when your tasks are relatively consistent. If every session is different in kind — some days drafting, some days debugging code, some days analyzing data — a single structured block can be too rigid. A short “base” section that stays constant plus a short “session” section you swap out handles this better than trying to cram everything into one block.
The Failure Mode This Creates (And How to Avoid It)
Context files go stale. This is the main thing to watch for. You write one, it works well for a month, and then the project evolves but the file doesn’t — and now you’re feeding in context that’s half-accurate and subtly misleading. The model will follow that stale context faithfully, which is in some ways worse than no context at all: at least with no context, the model will sometimes ask a clarifying question.
Set a simple rule: any time you catch yourself manually correcting something the model got wrong because of what’s in the context file, that’s a signal to update the file, not just fix the output in chat. The output is a symptom. The file is the actual problem.
Running automated pipelines on top of Claude — where a scheduled script has to produce consistent outputs across many runs without a human in the loop — makes this painfully obvious. A small ambiguity in a context block that a human would mentally smooth over gets interpreted slightly differently each run, and across enough iterations that variance compounds into real inconsistency. Precision in the context file isn’t perfectionism; it’s what keeps unattended automation from drifting in ways you only notice three weeks later.
A Practical Starting Point
Open a blank document and write three things: who you are in relation to AI tasks (not your job title — your role as a user), the one standing preference you find yourself re-explaining most often, and one thing you always end up correcting in AI outputs. That’s the skeleton. It doesn’t need to be comprehensive on day one.
Paste it at the start of your next five sessions. Notice whether you’re reaching for it instead of retyping. If you are, build it out from there. If you’re not, that’s a signal your sessions are too varied for a single file — and the right response is a different structure, not abandoning the idea.
The model doesn’t remember you. That’s not changing anytime soon. The only real question is whether your setup reflects that or just keeps paying the tax.
