Your Thread Is Noisier Than You Think

On context windows, thread hygiene, and the handoff

I guess it is fair to say that most professionals in our circle have used an LLM-powered platform. Many are no longer casual about it either. We are also past the phase where people still need to be told that ChatGPT is not Google Search; that baseline has more or less been absorbed.

What hasn’t been absorbed is something a layer deeper. Many people still treat the chat box as if it possesses an endless, human-like memory. They assume the AI inherently tracks every correction, retains the full logic of the project, and maintains a clean mental ledger no matter how long the thread runs.

The model may still sound confident, which is exactly the problem. A response can sound polished while the thread underneath it is carrying stale drafts, old instructions, irrelevant files, and directions you abandoned three turns ago. The vibe coder gets surprised when the AI forgets a function it wrote itself twenty minutes earlier. The analyst wonders why the summary began to blend old framing with new instructions. The writer gets title options shaped entirely by framings she already rejected.

There’s nothing wrong with the model. The issue is context management.

Think of it as index cards

Every AI conversation is a stack of index cards.

I use colors to keep the types apart in my head, nothing more. White cards hold facts: your uploaded documents, source data, reference material, pasted text. Yellow cards hold the prompts; every instruction or question you type becomes a card. The model’s responses are cards, too. And black index cards are the ones that should have been discarded—rejected drafts, abandoned directions, corrections to corrections.

At the start of a thread, the card stack is thin.

• Card 1 (yellow): What you want to do

• Card 2 (white): The document you uploaded

• Card 3 (yellow): The output format you asked for

After a long session, the stack thickens.

• Card 1: Original task

• Card 2: First set of facts

• Card 3: First draft

• Card 4: Correction to first draft

• Card 5: New direction

• Card 6: Rejected options ← black

• Card 7: Different tone request

• Card 8: Old file, no longer needed ← black

• Card 9: Another correction

• Card 10: Current task

You may only need cards 7 and 10, but the model is still being shown all of them.

This is how AI memory actually works. The context window is everything the model sees when it generates the next response. In modern systems like Claude or ChatGPT, this window can hold up to 200,000 tokens; that’s roughly 500 pages of text. The machine does not just look at your latest sentence. It re-reads all 500 pages every single turn.

The industry calls the challenge of finding a specific piece of information in this massive block of text the “needle in a haystack” problem. While models can technically process hundreds of pages, their performance degrades when the crucial detail is buried deep in the middle of a massive stack of dead ends.

Shorten your threads

As the stack of cards grows, two problems emerge.

Context exhaustion. The model has to process a large amount of material just to answer a small question. You ask, “Can you tighten the last paragraph?“ and the thread is still carrying the full source document, an early draft, three rejected versions, and instructions from two topics ago. This is also why you hit platform usage limits or encounter slower response times. You are burning through your allowance by forcing the model to read dead weight.

Context pollution. As old cards crowd the window, the model starts weighting material that no longer helps. It may remember a constraint you dropped, apply a framing you rejected, or miss your newest instruction because older cards keep pulling on the statistical mathematical output.

The most useful habit I’ve picked up is starting new threads more often than feels natural. My mindset had to shift on this. I am not talking to a person who remembers our history and picks up where we left off. I am working with a statistical machine that reads whatever is in the stack and generates from there. When the goal shifts, when uploaded files are no longer needed, when you have tried many versions, and nothing is working… do not keep arguing with a polluted thread. Make a clean one.

The handoff prompt

The trick is to close the old thread properly.

Before starting a new thread, ask the model to prepare a handoff note. This compresses the useful parts of the conversation and leaves behind the clutter.

Use something like this:

Prepare a handoff note so I can continue this work in a new thread. Include only what still matters.

Use this structure:

## Current objective
State the task in one paragraph.

## Decisions already made
List only decisions that should carry forward.

## Style and tone rules
Include the writing, formatting, or output rules that should continue.

## Known dead ends
List directions we tried and rejected.

## Source material still needed
List only the files, excerpts, or facts that remain relevant.

## Next action
State what the next thread should do first.

Then copy that output into a new thread.

If there is one thing to take from this piece, it is this: shorten your threads and learn the handoff prompt.

Turn repeated instructions into Skills

Now, some instructions should not be typed repeatedly. How you want your writing edited, how your organization defines risk severity, or how a certain document type should be structured do not change from day to day. Pasting these every time adds unnecessary cards to the stack and introduces variation.

To anchor these permanent rules, different platforms use different architectures—ranging from dedicated workspace folders like ChatGPT Projects to standalone custom personas like Gemini Gems.

Here, let me focus specifically on Claude’s approach: Skills.

In Claude, a Skill is a folder of procedural instructions that teaches the AI how to execute a specific task or workflow. The mechanical beauty of a Skill is that Claude dynamically pulls it into the context window only when your active prompt triggers it, protecting your thread from early context exhaustion. At its simplest, it is a text profile (a markdown file) that tells the model who it is, when to act, and how to behave.

Below’s a quick example:

# Capability: Independent Board Director

## Identity

You are an experienced independent board director on audit and risk committees.
You are skeptical, fiduciary-focused, and protective of shareholder value.

## Rules

- Prioritize structural and systemic risks over operational hiccups.
- Flag changes in accounting policies or footnote disclosures between quarters.
- Evaluate executive compensation against long-term performance.
- Frame outputs as questions for the CEO or CFO in a live board meeting.

That is already useful.

You do not have to write the markdown file yourself either; Claude has a skill-creator skill. You can describe the workflow in plain English, and it will help you build the file.

Below is a snapshot of an actual skill I co-created with Claude that ensures my iOS app designs comply with Apple’s Human Interface Guidelines (HIG); I named the skill ios-hig-reviewer.

A Claude skill I conceptualized using Anthropic’s skill-creator.

The heuristic is simple: use Skills for stable rules and prompts for the task at hand.

Use MCP to create a controlled workspace

Now that we have Skills for stable instructions and prompts for the task of the moment, the next question is where the working material should live: source files, PDFs, .docx, .xlsx, notes, drafts, and handoff packets.

This is where MCP enters the picture.

MCP stands for Model Context Protocol. For a non-programmer, the simplest explanation is this: MCP lets compatible AI apps and agent tools connect to tools and data sources outside the chat window.

Claude and most AI platforms live inside a browser tab or an isolated desktop app. They cannot see your files unless you manually upload them. MCP gives Claude a secure way to access a controlled workspace on your computer or in cloud storage. Instead of manually uploading three files and explaining where they belong, you may be able to say, “Look inside my Q2 folder, find the latest draft, and compare it with last quarter’s notes.” The AI app then queries the connected source, retrieves the needed information, and uses it in the task.

A simple workspace structure might look like this:

AI-Workspace/
├── active-projects/
│   └── project-name/
│       ├── skill.md
│       ├── assets/
│       │   ├── source-document.pdf
│       │   └── reference-data.csv
│       └── handoffs/
│           └── handoff-session-1.md
└── archive/

The folder structure is intentional here. It reduces the amount of explanation you need to give and limits what the AI can access.

One practical note: if you give an AI tool access to a folder, make sure that folder contains only what you are comfortable using for that workflow. Pointing it at your whole computer because it feels convenient is how sensitive files end up in a context they were never meant for. Most problems start when convenience wins too early.

Practice progressive disclosure

Once you combine a clean thread, a specific skill file, and access to your files via MCP, you can practice Progressive Disclosure: only showing the AI information at the exact moment it needs it.

Instead of dumping the entire annual report, sustainability guidelines, and three past meeting minutes into a single prompt on Turn 1, set up an organized directory structure on your machine or Google Drive that Claude can see via MCP:

└── 📁 Board_Preparation/
    ├── 📄 skill_independent_director.md
    ├── 📁 assets/
    │   ├── 📄 q2_earnings_transcript.pdf
    │   └── 📄 compensation_peer_data.csv
    └── 📄 handoff_packet.md

This structure already tells the model something useful.

The Skill file defines the lens. The handoff packet carries forward the current state of the work. The assets folder holds source material that should be pulled in only when relevant.

Start a fresh thread with the Skill and the handoff packet:

Use `skill_independent_director.md` and `handoff_packet.md`.
First, outline the primary oversight themes for the upcoming meeting.
Do not draft questions yet.

At this point, the model has the role, the objective, and the current state of the work. It does not need every source file yet.

Only when a specific issue comes up do you bring in the next card:

Now read `assets/compensation_peer_data.csv` and flag the outliers.

If the earnings discussion becomes relevant, add that layer next:

Now read `assets/q2_earnings_transcript.pdf` and 
identify statements that may need board follow-up.

Then ask for the final output:

Now draft five precise questions for management, 
tied only to the risks and outliers already identified.

That is progressive disclosure.

You are showing the model information only when it becomes useful, rather than dumping the whole folder into the thread at the start.

This keeps the working context cleaner. It also makes the model’s reasoning easier to inspect. If it misunderstands the first layer, you can correct that before it builds the next one.

The platform-agnostic version

The framework shared here applies across Claude, Gemini, ChatGPT, and anything that comes after them. The underlying question in every LLM workflow is the same: what should the model know right now?

A context window is the stack of cards the model can work with. A prompt is the next instruction card. A thread is the current stack. A handoff is the selected cards for the next thread. A skill is a reusable packet of instruction cards. MCP is the way to fetch the right cards from a workspace.

When a thread turns strange, or answers start missing obvious constraints, look at the stack first. Then make sure you give the model the right cards, in the right order, for the right job. Or, just clean out the deck.