Real example: a handoff, and how the next session picked it up
By Soumen Sarkar · October 2026
Real example. 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.
What happened?
We build Campfyrr with Claude Code, and Campfyrr records our own work. On the morning of 19 October 2026, one long session was building a small feature: a page where a teammate can answer an agent's assumption from a shared link. At 06:19 UTC the context window filled and Claude Code compacted it.
Campfyrr's work hook runs at that moment. It wrote a handoff from the end of the session. The session that continued after compaction opened with this at the top of its brief, under "Pick up where it was left". It's quoted as it appeared, with the hyphens tidied:
Your unfinished work: Create a content marketing plan for SEO and geo targeting
- Done: Fixed missing test cookie in local /org requests; Added weekly
measures card and seat-count/trial-date fields to admin page; Created MCP
publish test and plugin skill definition; Implemented copy-link button
component in Activity page; Scaffolded answer page route and added its test
- Unfinished: Finish writing the answer-route test body; Verify copy-link
button UI works across browsers; Add server-side handling for assumptions
answering; Run full test suite including new answer route; Deploy latest
changes to staging
- Next step: Complete the answer-route test implementation and run the full
test suite to catch any regressions
- Watch out: Answer-route test will fail until the DB migration for question
tables is applied; Copy-link component requires "use client" and may break
SSR if imported incorrectly; MCP publish tests need the mock server
environment variable set
- Open questions: What exact data should be returned for an answered
assumption?; Should the copy-link button copy a short URL or full link?;
Are there any permissions needed for the answer endpoint?
The title line is the session's overall goal, which had grown far past marketing by then. The work in front of it was the answer page.
What did the next session do?
It checked before it trusted. Its first command, within seconds, was git status and a TypeScript check. That showed the answer page, its endpoint and its test were all written but not committed. The type check found two errors in the new test: it read a field called answered that the result doesn't have.
Then it did the next step:
- 06:20:11: fixed the test to read the result's
status. - 06:21:48: ran the full suite. All 521 tests passed.
- 06:21:54: committed "Answer an assumption from a shared link" and pushed it.
- 06:22:06: moved on to the next feature on the plan.
From compaction to shipped took about two minutes. Nobody had to reconstruct where the work stood.
What did the handoff get right?
- The next step. "Complete the answer-route test and run the full test suite" is exactly what remained, and exactly what the session did.
- The done list. The weekly card, the seat counts and trial dates, the publish test and the copy-link button had all shipped in a commit at 06:14. The answer page and its test were written, as it said.
- One useful trap. The copy-link button does start with
"use client". That warning was accurate, though nothing tripped on it this time.
What did it get wrong?
More than we'd like, and it's worth being plain about:
- It listed done work as unfinished. The test body was written, and it had passed on its own at 06:18. The endpoint ("server-side handling") was written too. Only a type error was left.
- One trap was false. No database change was needed. The test passed before and after, with no migration.
- "Staging" doesn't exist here. This project pushes straight to its production branch.
- It missed the most important fact: the work wasn't committed. Claude Code's own compaction summary said so; the handoff didn't.
This wasn't a one-off. On 16 October a handoff listed "exclude rule pages from navigation" as unfinished. That change had shipped at 06:10 the same morning, eleven hours before the handoff appeared. The next session went to different work, so it did no harm. A session that followed it blindly would have redone shipped work.
What does this change for how you pick up work?
A handoff is a fast way in, not the truth about the branch. Use it like this:
- Read the next step first. It's usually the most reliable line.
- Run
git status and git log before you act on "Unfinished". - Run the type check and the tests before you trust a "Watch out".
- Do the next step, then commit and push.
Your own handoffs open your next session under "Pick up where it was left", as this one did. Teammates see paused work on the Activity page, with its next step. To take over a teammate's handoff, paste it into your first prompt and tell the session to check the branch first.
For the problem this answers, read half-finished work loses its context. For what a handoff should hold, read what goes into a good handoff. For continuing someone else's work, read how do I continue another developer's agent session?
The problem this answers: Handoffs lose context: "Half-finished work loses its context when it changes hands."
The principle behind this: Keep moving: The work never waits, and neither do we.
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).