Half-finished work loses its context
By Soumen Sarkar · October 2026
Problem. "Half-finished work loses its context when it changes hands."
When a session stops partway, what it knew stays in a transcript on one machine: what's done, what's left, the traps it found. A short handoff written at the moment it stops (done, unfinished, next step, open questions, traps) lets you or a teammate continue in minutes instead of reconstructing it.
Why does half-finished work lose its context?
Because the context lives in the session, and the session stays where it ran. Claude Code saves every conversation locally, as a transcript file under ~/.claude/projects/ on your machine, and deletes transcripts after 30 days by default (Claude Code docs). The branch holds the code. It doesn't hold why the retry count is hardcoded, which approach was tried and dropped, or what the agent assumed about a field nobody had defined.
So when work stops halfway, whoever continues it starts by digging. That's true for a teammate, and it's true for you on Monday morning.
Why does this happen more now?
Because sessions stop all the time, and most stops aren't planned. A context window fills and compacts. A laptop closes. Something urgent pulls you into another session. With three or four sessions running at once, some piece of work is always paused somewhere.
Each stop is the moment the agent knows the most about the work. A few minutes later, nobody does.
Can't I just resume the session?
You can resume your own. claude --continue reopens the most recent session in the current directory, and claude --resume lets you pick one (Claude Code docs). That's good for picking up your own work on the same machine.
It doesn't help a teammate. Their machine doesn't have your transcript. And even for you, a resumed session after compaction continues from a summary of the earlier conversation, not the full history (Claude Code docs). What the next person needs isn't the conversation. It's the state of the work. The longer answer is in how do I continue another developer's agent session?
What do teams do about it?
- Write a note in the pull request or a channel. It works when people remember, which the unplanned stops rule out.
- Ask the person who started it. It works when they're online and remember the details.
- Read the diff and guess. The code shows what changed, not what was decided or what to avoid.
What works is a short handoff written every time work stops, kept where the next person starts. It answers five things: done, unfinished, next step, open questions and traps. See what goes into a good handoff and the handoff template.
What does Campfyrr do?
Campfyrr writes the handoff for you. In Claude Code, its work hook runs when the context is about to compact, when Claude stops (at most every half hour), and when the session ends. If the session changed files, the hook sends the end of the session to Campfyrr, which writes the handoff from it. The transcript itself isn't kept, only the handoff.
We built this on 14 October 2026. The commit that shipped it says:
Handoffs are written from the session when it stops unfinished
(PreCompact, Stop, SessionEnd), picked up from Activity, and given to
the taker's agent at its next start.
And this repository's own instructions to every session say: "Stopping unfinished: hand_off. Done: finish_work." Agents outside Claude Code call hand_off themselves.
Here's where the handoff shows up today:
- Your next session. Your own unfinished work opens your next session brief under "Pick up where it was left", with what's done, what's unfinished, the next step, the traps and the open questions.
- The Activity page. Teammates see "paused partway through", with the next step.
- The area brief. Approaches the session tried and dropped appear under "Tried here and dropped" for the next session that works in that part of the code.
What Campfyrr doesn't do: it doesn't keep or share your transcripts, and it doesn't move your branch, so push your code as usual. Activity doesn't yet put a teammate's handoff into your own session brief; paste it into your first prompt. For how area briefs work, read your teammates' sessions don't know about each other.
Where do I start?
- Connect Campfyrr from /connect. The paste installs the hooks.
- Push your branch before you stop.
- Start a fresh session to continue someone's work.
- Give it the handoff and tell it to do the next step first.
- Leave your own handoff when you stop.
The measure to watch is pick-up time: how long paused work waits before someone continues it. For the full method, read handoffs that write themselves.
Everything on this problem
- Real example: Real example: a handoff, and how the next session picked it up: On 19 October 2026 a session building Campfyrr ran out of context mid-task. The handoff Campfyrr wrote named the right next step, and the session that continued did it and shipped in about two minutes. It also listed work as unfinished that was already done, so the useful habit is to check the branch first.
- Comparison: Campfyrr vs Lore: show one agent run, or keep every session in step: If you want to show a teammate exactly how one agent run went, use Lore. If your team's sessions keep building on decisions that changed this morning, use Campfyrr. Many teams have both problems.
- For you: For engineers running three or four sessions at once: If you run three or four Claude Code sessions at once, Campfyrr works in the background: each session gets a brief on what the team knows the first time it reads or edits a part of the code, and a handoff is written when a session stops, so your next session opens on it. There's nothing to fill in.
- Comparison: Sharing a session link vs sharing what sessions know: what does the next person need?: If you want to show someone exactly how a run went, share the session: a Claude Code link, Lore or an exported transcript. If each new session starts without what the last one decided, tried and dropped, share what sessions know. Many teams need both.
Move as one at agent speed. Nobody waits. Add Campfyrr to Claude: it briefs every agent before it touches the code, keeps assumptions and handoffs where the team can see them, and never takes your code (what it keeps).