You’re 30 messages into a conversation with an AI. It was perfect at message 5. By message 20, it’s contradicting earlier decisions. By message 30, it’s forgotten half of everything and you’re rage-typing corrections. You’re being gaslit by the robots. It’s context drift, and it happens to everyone.
The chatbot isn’t broken. You just hit the limits of what it can hold in active memory. Modern systems can hold the half-million tokens of the Harry Potter franchise like a boss, but context degrades before you hit those limits. The output stays coherent. It just gets generic. Loses the specifics you asked for. Drifts away from your constraints. All the colors mix to brown.
Here are three techniques that fix this. Whether you’re troubleshooting deployments, conducting research, or drafting documentation, these techniques work. How to go from “pretty good” to professional.
Why Context Management Still Matters
GPT 5.2, Claude 4.6, and Gemini 3 are dramatically better at maintaining context than models from even 6 months ago. You can have 20, 30, even 40 message conversations before drift becomes noticeable.
But even with ever-expanding context windows, the AI still doesn’t know what matters to YOU. It treats all tokens equally. When drift happens at message 25 of a critical project, it’s devastating. And crazy-making.
Context Window Mechanics
Think of the context window as the AI’s working memory - it has limited space.
Different models in 2026:
- GPT 5.2: ~200,000 tokens
- Claude 4.6: ~200,000 tokens
- Gemini 3: ~1,000,000 tokens
Drift becomes obvious around 50% of the advertised window size. Even with massive capacity, you’ll hit the wall long before you hit the limit.
When it fills up, the AI forgets earlier parts of your conversation. Sure, auto-compression kicks in to help. But the model loses your specific constraints, examples, corrections. You re-teach it the same damn things over and over.
The Whiteboard Analogy
You’re better off treating your context window like a classroom whiteboard. Finite space that needs active management. You can’t let random crap accumulate - core concepts stay on the board, working examples get erased when done. When it’s messy, you clean strategically: keep the framework, lose the clutter. Pass out from marker fumes.
Don’t let the AI manage its own whiteboard. You need to be the context manager. Active context management is a skill, like version control or documentation.
Proof: Drift in Action
Here’s what happens in a real creative writing session with modern chatbots. I built a short story as a test demo. Zombie accountant. 10 messages over about 15 minutes.
Message 1 had very specific constraints: Brenda Chen, age 42, TD Tower on Barrington Street in Halifax, exactly 500 words, darkly comedic. Messages 2-9 were normal iterative writing. I added complexity: a colleague named Marcus, a client meeting, a zombie support group subplot.
Message 10, I asked for the complete story. It blew past the word count, flattened Brenda’s character, and forgot all the setting details. It was a bland zombie woman at the office tale. Yawn.
Same pattern shows up with research citations, course learning objectives, or grant budget objectives.
Three techniques prevent or rescue this.
Technique 1: Output Formatting
This is the gateway drug. Start here. Use it at the beginning of any work session that’ll go past 5-10 messages.
The Problem with Conversational Output
Typical AI responses look like this:
- “Here’s what I think you should consider…”
- “Based on our discussion, I’d suggest…”
- “Let me help you with that. First, let’s…”
You have to parse and reformat before you can use it. That conversational wrapper text also consumes context tokens without adding value. Kinda like lettuce.
How It Works
Get the bot to produce results in formats you can immediately use, not pandering fluff. Specify output format upfront. This creates scannable structure. You won’t lose track in long conversations. It also forces the AI to explicitly state what it thinks you’re working on, which surfaces misalignment and grand malpuckery early.
Instead of scrolling through paragraphs of prose trying to figure out what just happened, you get clean sections you can skim. You immediately see if the AI is still on track or if it’s veered off into the rhubarb solving a different problem.
The Prompt Templates
Specify output format upfront for different use cases:
1. For creative writing:
"Write the complete 500-word story. Format it with a title at
the top, then the story. No introduction, no explanation, no
'Here's a draft' - just the finished story I can copy-paste
into a document. Story only."
2. For emails/documents:
"Write this as a finished email I can send directly.
Subject line, greeting, body, sign-off. No explanations
before or after. Just the email."
3. For planning:
"Output format: numbered task list with owner and deadline.
Like this:
1. [Task] - [Owner] - [Deadline]
No intro, no conclusion, just the list."
4. For data/analysis:
"Present this as a markdown table with these columns: [specify].
Include only the table, no preamble."
5. For code/scripts:
"Give me the complete working code with inline comments.
No explanations outside the code block. I should be able to
copy-paste and run it."
6. For meeting notes:
"Format as:
## Decisions
[Bulleted list]
## Action Items
[Who - What - When]
## Parking Lot
[Deferred items]
Nothing else."
Key constraint phrases:
- “No preamble” / “No introduction”
- “No explanations before or after”
- “Copy-paste ready”
- “Finished version, not a draft”
- “Just the [artifact], nothing else”
What Actually Happens
I use this when brainstorming or thinking through problems with AI. The structure forces the AI to explicitly state what we’re working on and what decisions we’ve locked in. I’m exploring options, but some constraints are fixed: budget, timeline, technical requirements.
Without Output Formatting, I’d be scrolling back through dozens of messages trying to remember: did we agree on that approach or was I just riffing? With the structure, every response shows what we’re exploring now and what’s decided. I can wander freely without losing track of what’s locked.
This is the lowest-friction, highest-return technique. Set it once at the start, get structured output for the whole session.
Same principle applies to SQL queries where you need executable code without explanation, executive summaries formatted for direct inclusion in reports, or task lists that go straight into your project management system. Copy-paste bliss.
Technique 2: Rolling Summary Strategy
This is your periodic checkpoint system for long conversations. Use it when you’re deep into a multi-session project and you can feel the conversation getting sprawling.
How It Works
Every 8-10 messages, ask the AI to summarize where you are. The AI generates the summary in its own output. That output becomes part of the context window. Because it’s recent, it has more weight in the AI’s processing. Your important constraints stay fresh without you copying and pasting anything.
Think of it like a save point in a video game. You’re not restarting from scratch. Reload from your last checkpoint with all your progress intact.
The Prompt Templates
Step 1: Set up the protocol in your first message
"I'm working on [specific project]. Key constraints: [list].
I need you to [specific outcome].
Throughout this conversation, I'll periodically ask you to update
a running summary. When I say 'Update summary,' create a bulleted
list of decisions we've made and current status."
Step 2: Trigger updates every 8-10 messages
"Update summary"
That’s it. The AI generates the summary. That summary is now in the context window, recent and weighted. Continue working.
Effective summary format:
## Current Status
- [What we've accomplished]
- [What we're working on now]
## Key Decisions
1. [Decision 1 + rationale]
2. [Decision 2 + rationale]
## Open Questions
- [What's still unresolved]
## Next Steps
- [Immediate next action]
What Actually Happens
I used this last month figuring out a weird plumbing issue - three-day troubleshooting saga. Around message 25, I asked for the rolling summary. Got back: what we’d ruled out (not the hot water tank, not the well pump pressure), current hypothesis (iron filter gear stack), parts needed, and next diagnostic step. Next day, fresh chat, pasted the summary, picked up where I stopped. The robot had full context from word one.
This works for multi-session projects where you need clean continuity. It’s also insurance - if the conversation drifts, you’ve got Rolling Summaries you can roll back to. Bonus: that summary becomes your record. When the water system company asked what we’d ruled out on the yellow water issue, I had the exact breakdown ready to share.
This exact workflow scales to research papers tracking sources and arguments across weeks, software development maintaining requirements and architecture decisions, or course planning where learning outcomes and assessment criteria stay aligned.
At the end of your session: Copy the final summary externally (OneNote, text file, whatever). Next session: Start fresh chat, paste that summary into message 1, continue.
Technique 3: AI-Directed Scratchpad
This is your ejector seat and parachute. Use it when you’re mid-conversation and you realize the wheels are off. The cursed AI forgot your constraints, contradicted earlier decisions, or just gave up the ghost and stopped tracking.
How It Works
When drift happens (or you need to switch contexts), prompt to extract what matters into a portable scratchpad. Instead of letting auto-compression decide what to keep, you direct it.
This is a rescue maneuver, not daily practice. When context is already slipping, this resets you cleanly without losing all the work you’ve done.
The Prompt Templates
Use the right scratchpad for your situation:
1. Decision/Constraint Scratchpad - When drift is happening
"Create a scratchpad of the 5 most important decisions and
constraints from this conversation. Format it as a bulleted
list I can copy-paste."
2. Continuity Scratchpad - End of session prep
"If I needed to start a fresh conversation about this topic
tomorrow, what context should I provide? Give me a 3-4 sentence
summary."
3. Load-Bearing Context - Distinguish signal from noise
"What's load-bearing context in this conversation vs.
scaffolding we can discard? List the must-keep elements."
4. Working Summary - Mid-session checkpoint
"Summarize where we are: what we've decided, what's still open,
and what I should focus on next. Make it copy-paste ready."
What Actually Happens
I used this last month getting GitHub Actions to build my Jekyll blog properly. Three sessions, multiple failed deployments. Around message 40, I realized the AI was suggesting fixes that were the exact opposite to what we’d already tried. I hit the rescue: asked for a handoff document.
Got back: the Ruby version issue we’d solved, the dependency conflict we’d worked around, the build path we’d corrected, and the current problem (deploy permissions). Fresh chat, pasted the handoff, immediately got the right fix without re-explaining three days of troubleshooting.
Don’t wait until it’s catastrophic - if you’re repeating yourself or the AI keeps forgetting, hit the eject button. The handoff document doubles as your documentation: a complete record of decisions, constraints, and progress.
Scratchpad rescue works when you’re deep in data analysis and the robot screwed up your filtering criteria, when you’re drafting policy documents and the tone shifts away from your original requirements, or when you’re troubleshooting technical issues and earlier diagnostic steps get compressed out.
Save scratchpads externally. Use them to start fresh conversations with clean context. Think of them as “save states” for AI conversations.
Choosing Your Technique
Start with Output Formatting. Make it your default for any work session. It’s preventative. Keeps things structured before drift becomes a problem.
Use Rolling Summary when you’re deep into a project and need periodic checkpoints. Every 8-10 messages, trigger an update. Save the final summary externally. That’s your reload point if you need to continue later or start fresh.
Pull the Scratchpad Rescue when things are already sideways. When you need a hard reset without losing your progress. Use it when the context is clearly degraded and toast.
Sometimes you should just start fresh entirely. If the goal changed, if you realized your approach was wrong, if the handoff document would be longer than just starting over. Don’t over-invest in a broken session. New chat, new start.
When to Start a New Chat vs. Continue
Continue if you’re under 15-20 messages on the same task with no major drift, especially when using Rolling Summary actively.
Use Scratchpad + fresh chat if context is drifting but you want to refocus without starting over (15-25 messages, same task).
Start fresh entirely if: different sub-task, chat exceeds 25-30 messages, you’ve corrected the same mistake 3+ times, or the conversation feels bloated despite techniques.
When starting fresh: paste your scratchpad or summary into message 1.
Beyond the Chat Window
At their core, these techniques apply data management principles to AI conversations: versioning (Rolling Summary), documentation (Scratchpad handoffs), and structured capture (Output Formatting). You’re treating context as an information system that needs to be managed.
These three techniques work in any chat-based AI tool. But you can make context management even more seamless.
Start simple: save your rolling summaries or handoff documents as text files. Upload them to start new sessions instead of pasting. Same effect, cleaner workflow.
Platform features like ChatGPT and Claude Projects take it further with context that persists automatically across chats within a project.
You can also bake context management into your custom instructions so the AI handles it automatically. Example from my setup:
If the topic shifts, interrupt with: 'We are drifting from [Original Topic].
Stay here or move to a new thread?' At conclusion, provide a concise summary
of insights/decisions in a markdown-formatted code block.
The chatbot tracks drift and generates summaries without prompting. For multi-session work where rework costs hours this automatic checkpointing is cheap insurance.
There are tools like MCP connections to external storage that can smooth out some wrinkles. But start with text files. The principle is what matters: your context lives outside the chat, portable across tools and time.
The Mindset Shift
Stop treating AI like Google.
Don’t over-value the conversation. Save the outputs and delete the chat.
Remember the whiteboard:
- Manage the space actively
- Keep what matters visible
- Erase strategically
- Save work states externally
You are the context manager, not the AI. This is a practiced skill.
One Thing to Try This Week
Add “Format as: [specify]. No preamble.” to one prompt this week. See if it saves you 15 minutes of editing. Once that becomes habit, add Rolling Summary to your next multi-message project.
Will This Improve Over Time?
Will this improve over time? Yes. The technology will improve. But these techniques scale with it. Managing a 500K token conversation still requires checkpointing, summaries, and structure. The skills compound. You’ll always need to know what deserves space in that context window, when to checkpoint, when to reset. That’s judgment. Human stuff.
Your context window is a whiteboard. And you’re the one holding the eraser.
