Capture the session context so you can resume it cold.
An end-of-session brief: progress, decisions, unfinished items with next steps, and the fragile details, then it asks whether to save.
Inside: Progress and decisions, next steps, the would-be-lost pass, and a save gate.
Install it in one line, or paste it in.
~/.claude/skills/ and runs automatically when it is relevant.Connect your context. Set it to your motion.
it reads the diff so "what got done" is grounded in real changes, not memory.
it can append the brief where the next session will look, once you approve.
unfinished items become real tasks with next steps, once you approve.
This was built for an operator who resumes work across days and sessions. Set these to your rhythm:
The save is always yours to trigger. Change where it goes and how it reads. The close-out discipline does not change.
| Set this | What it is | Default / Example |
|---|---|---|
| CODE_HOME | where the build lives | a git repo |
| NOTES_HOME | where handoffs get saved | a notes/wiki toola doc |
| TASK_HOME | where open items become tasks | a task toola checklist |
| SAVE_MODE | how the brief gets kept | draft onlyappend to notesopen a task |
| FRAGILE_PROMPT | the "what would be lost" nudge | on by default |
| COMMIT_STYLE | how a code commit is framed | conventionalplain summary |
Everything the skill does, in full.
Writes the brief you wish the last session had left you. It captures what got done, the decisions made and why, what is still open with the actual next step, and the fragile details, the half-finished thought, the thing you were about to try, that never survive to the next session. Then it stops and asks whether to save or commit it. It never writes anything on its own.
- 1Progress capture
State what actually changed this session in plain terms. If a repo is connected, ground it in the diff, files touched, what they now do. No connector? Capture what you report, marked as your account, not verified fact.
- 2Decision capture
Every decision made this session gets a one-line why. These are the calls the next session must not silently reverse. If a decision log exists, offer to add them there, on approval.
- 3Unfinished items and next steps
List what is open, and for each, the specific next step, not "keep going." "Finish the parser" is not a next step. "Handle the empty-row case in the parser" is.
- 4The fragile-details pass
The point of a handoff. Capture what lives only in your head right now: the thing you were mid-thought on, the approach you were about to try, the dead end you already ruled out so nobody re-walks it. This is what a bare task list loses.
- 5The commit-or-save question
The brief is drafted and shown to you. Then, and only then, it asks: save this to notes, open these as tasks, commit the code, or just hand it back to you. Nothing happens until you choose.
- Nothing is committed or saved without your explicit approval. The skill drafts and asks; you decide. This is the rule, not a setting.
- No claimed progress the skill cannot support. If it is from your account and not a verified diff, it says so.
- Every unfinished item carries a real next step, not a restatement of the goal.
- The fragile-details section is never skipped, even on a short session. That is the part that would be lost.
SESSION HANDOFF · onboarding automation · end of session
DONE THIS SESSION
- Added domain-based dedupe (grounded in diff: dedupe.js, router.js).
- Cut the API calls per run roughly in half by batching.
DECISIONS
- Batch nightly instead of per-signup. Cost, not speed, was the constraint.
STILL OPEN -> NEXT STEP
- EU routing owner undecided -> ask the team lead who owns EU signups.
- Empty-row case in the parser -> handle the blank-domain row, it throws.
WOULD BE LOST IF I WALKED AWAY
- I was mid-way through testing the batch job against last week's data,
the 3rd run failed on a timeout, likely the sheet read, not the logic.
- Ruled out per-persona routing already. Do not revisit; it was too noisy.
SAVE THIS?
[ ] Append to notes [ ] Open the 2 open items as tasks
[ ] Commit the code [ ] Just hand it back to me
(nothing is saved until you choose)
Where an operator takes this next.
The handoff is step one. Here is where an operator takes it once the manual version proves out.
You write the close-out once; the system makes sure it gets read.
Connect the repo so "done this session" reads from committed changes, not memory, and the brief cannot overstate progress.
Once you approve, push the unfinished items into a task tool with the next step attached, not a restated goal.
Schedule a Claude task to re-surface yesterday's fragile-details section the next time you sit down, so it never gets skipped.
One skill is the on-ramp.
A single skill does one job. Chained into a playbook, or run as a full build, it becomes a system. Here is where this one plugs in.