Your AI handoffs aren't losing information — they're gaining it. That's worse.
TL;DR: If you brainstorm in a chat app and hand the result to a coding agent, your handoff documents are probably contaminated — not by what the model dropped, but by what it added. I diffed six real handoffs against the exact transcripts that produced them. My words survived nearly perfectly. What didn't survive was the boundary between what I said and what the model made up: stale facts from its own chat memory presented as current, and scope decisions I never made labeled "locked." I turned the fix into a five-rule capture template and shipped it free: provenance-handoff on GitHub.
The setup
My working pattern, and probably yours if you use Claude or ChatGPT on your phone: think out loud in a chat session — in my case, literally in the pool — then have the model distill the session into a handoff document that a coding agent picks up later with full local context.
I'd had a nagging suspicion the distillation step was filtering me. Things I remembered saying weren't showing up downstream. So I did the boring thing nobody does: I saved the complete raw transcripts of one day's sessions — six of them, all typed, so the ground truth was character-exact — and diffed every handoff document against what I actually wrote.
The filter runs backwards
The suspicion was right that a filter exists. It was wrong about the direction.
What survived: almost everything I said. Across all six handoffs, my words, priorities, and hesitations made it through with high fidelity. Omission was minimal — and what little was dropped turns out to be instructive (below).
What got added: content I never said, at my confidence level. Two distinct injection channels showed up in the diff:
Channel 1 — stale chat memory presented as fact. The transcript shows the model running a memory search right before writing the worst handoff of the six. That handoff contained an entire "known state" section describing my hardware setup — and every fact in it came from the model's memory of months-old conversations, not from anything I typed that day. A build I'd abandoned, presented as current. A constraint I'd never stated. The receiving agent later logged eight corrections against that one section. All eight traced to injected memory. Zero traced to me.
Channel 2 — the model's own choices labeled as mine. In another handoff, the model picked an OS version, a boot-security setting, and a flashing tool — none of which I'd mentioned — announced them as "two locked decisions," and wrote the spec accordingly. I never locked anything. I was silent, and silence got recorded as sign-off.
There was also a quieter third failure: I wrote "a Unix flavor" and the handoff silently narrowed it to Linux, demoting macOS to a sidebar. Fluent, plausible, and not what I said.
The one thing that got dropped tells you what to keep
The single genuine omission across six handoffs: a standing workflow rule I stated twice in the raw sessions. It vanished because it was a convention, not a task — and task-shaped summaries have no slot for conventions. It would have evaporated entirely if the verbatim transcript hadn't existed.
That's the case for the least glamorous rule in the fix: every handoff carries the raw input, word for word, as an appendix. Distillation may organize; it may never replace.
Why "summarize more carefully" can't fix this
Here's the pattern that matters. In the handoffs where the model labeled its additions — "suggested framework," "propose-only," "recommended" — everything was fine. Both real failures were unlabeled additions wearing my authority.
So the failure mode isn't summarization quality. It's provenance. The summary is the attack surface, and the fix has to travel with the capture itself.
The five rules
This is the template I now run in a dedicated claude.ai Project, so it applies to every capture automatically (a phone text-shortcut works too). Full version in the repo; the rules in short:
- Verbatim appendix. The raw input rides along, unedited, as the final section. Every handoff carries its own ground truth.
- Provenance tags. Every claim is tagged
[USER](I said it in this capture),[MEMORY](recalled from prior chats — stale until the agent verifies it locally), or[PROPOSED](the model's suggestion, not my decision). Never presented at equal confidence. - No silent defaults. Scope choices I didn't state go in a "model-chosen defaults for review" section. The word "locked" is banned for the model's own picks. Silence is not sign-off.
- Local wins. The handoff opens by telling the receiving agent that local context beats the chat's recollection: survey first, merge don't duplicate, log a delta wherever the doc conflicts with reality.
- Split the questions. "Only the owner can answer" is separated from "the agent can verify." Verifiable facts don't land on my plate.
Since switching, handoffs arrive self-auditing: the receiving agent checks the [MEMORY] tags against local reality and puts [PROPOSED] items in front of me — instead of me discovering contamination eight corrections later.
Why every template you've seen misses this
Look up "AI handoff template" and everything you find — including Microsoft's webinar handoff.prompt.md and the various 8-section continuation templates — optimizes for compression: carry the context forward, lose as little as possible. Useful, but it's solving the failure mode I didn't have. None of them distinguish whose context is being carried.
The closest thing I found to the actual problem is an academic paper — Handoff Debt (arXiv 2606.02875) — which measures the cost agents pay re-discovering context and recommends the receiving agent distrust handoff notes. Reasonable, but it's the second-best place to fix it. Tag the provenance at the source and there's much less to distrust.
Steal it, and test your own pipeline
The template, the case study with the full diff table, and the receipts are here, MIT-licensed:
github.com/jds1-ai/provenance-handoff
And if you want to know whether your pipeline has this problem, the test costs one saved transcript: diff a day of handoffs against the raw sessions and ask three questions per document — what survived, what was added unmarked, what was dropped. Then count how many downstream corrections trace to unlabeled additions versus omissions.
Mine came out 8-to-0. Compression was never the problem.