shift-notes

name	shift-notes
description	Write and read the between-session handoff file so a fresh agent with no memory can pick up where the last one stopped without re-deriving context. Structured prose, not JSON — the model writes prose better.
when_to_use	end of any session in a multi-session project, start of the next one; pairs with broken-window-check and feature-list state files

Shift Notes

The hard problem in long-running agents is not doing work in one session — it's bridging the context gap between sessions. Every fresh agent starts with zero memory. If it has to reconstruct project state from the code, it burns 5-10 minutes and a chunk of context before writing a line. If it has a well-shaped handoff file, that drops to 30-60 seconds.

That handoff file is claude-progress.txt (or equivalent). Prose, not JSON. The model writes prose more naturally, and the read is cheap.

The format — write into this shape

# Project: <name>
# Last updated: <ISO timestamp> by session <id>

## What's done
- <feature> [feature-list index: N]
- ...

## What's in progress
- <feature> [feature-list index: N]
  Status: <one paragraph — what works, what doesn't>
  Files touched this session: <list>
  Known open issues: <list>

## What's next (recommended)
- <feature> [feature-list index: N]
  Reason: <why this one>

## Notes for the next session
<free-form prose: gotchas, flaky tests, environment quirks>

Enforced softly by the prompt, not by validation. Free text is the point — the notes section is where the previous shift warns the next one about the thing that isn't captured anywhere else.

Writing the notes — at end of session

• Move the completed feature from "in progress" to "done".
• Recommend the next feature in "what's next" with a one-line reason (unblocks-N, low-risk, prerequisite-for-M).
• Notes-for-next-session is the highest-leverage field. Use it for: flaky tests you hit, dependencies that surprised you, spec ambiguities you resolved one way (so the next agent doesn't re-litigate), env vars that need to be set.
• Do not delete "done" entries. They're audit trail. If the section gets long, that's a signal to compact the whole notes file at v0.2 milestones, not to prune mid-project.

Reading the notes — at start of session

• Read the whole file. It's small.
• If shift notes and git log disagree, trust the git log. The notes can be truncated by a crashed session; the log can't. This is a load-bearing rule.
• Cross-reference "what's done" against the feature list. If the notes claim done but the feature list says not-done, run broken-window-check.
• Pick work from "what's next" unless it's stale (a new session already picked it).

Red flags

• Notes rewritten every session from scratch. Lose history, lose audit trail. Append and edit in place, don't overwrite.
• "What's done" section grows unboundedly. Fine up to ~40 entries. Past that, compact by feature milestone.
• Ambiguous "in progress" prose. The next session will misread "the button is wired but the state doesn't refresh" as "done" if you write "button works". Be precise about what fails.
• Notes drift out of sync with the feature list. Feature list is source of truth for pass/fail state; notes are the prose gloss. When they disagree, the list wins.
• JSON handoff file. Tried and abandoned — the model wrote shorter, less useful notes when forced into JSON. Prose wins for prose.

What NOT to put in the notes

• Full file contents. Reference paths, not blobs.
• Chain-of-thought for the session. Compact it into a status line.
• Anything that belongs in the feature list (pass/fail state) or in git (what changed).

Pairs with

• broken-window-check — reads the "what's done" list to know what to smoke-test.
• spec-first — the spec is the contract; the notes are the ledger against it.
• context-budget — the notes are the compact recap the context-budget skill wants.

The shift-notes file is the memory of the project. Treat it as load-bearing.