The Hand-Off Skill.

Claude Code sessions are stateless except for CLAUDE.md and memory. Every new chat starts fresh. CLAUDE.md and memory carry project-level context across sessions, but session-specific state — what you just tried, what failed, what decisions you made, what's half-done — is lost the moment the chat ends.

The handoff skill is a 90-second ritual that captures exactly that.

You can download this skill from github.com/bogdanbaciu21/skills.

What it produces

A single copy-pasteable block the next session can drop in as its first message. Structured like this:

## Session Handoff — [brief title]

### GitHub Issue
#123 — title and URL

### Original Task
What the user asked for.

### What Was Done
- Concrete completed items

### What's Left
- [ ] Actionable items the next session can execute without clarification

### Key Decisions & Findings
- What was tried and rejected, and why

### Files Changed
git diff --stat output

### Uncommitted Work
git status, or "None"

### Gotchas & Context
- Non-obvious things the next session needs to know

Sample handoff

## Session Handoff — Fix forecast override drift

### GitHub Issue
#214 — Fix weekly override persistence bug

### Original Task
User reported that manual overrides disappear after the nightly refresh.

### What Was Done
- traced refresh path to `refreshWeeklyForecast()`
- confirmed overwrite happened during merge of derived values
- patched merge logic to preserve manual override rows

### What's Left
- [ ] run the full nightly-refresh test fixture
- [ ] verify the admin UI shows preserved overrides after refresh
- [ ] close the issue after manual verification

### Key Decisions & Findings
- the derived forecast is not the source of truth for override rows
- preserving override rows at merge time is safer than rehydrating later

### Files Changed
- `server/forecast/refresh.ts`
- `server/forecast/refresh.test.ts`

### Uncommitted Work
Changes staged but not committed; tests not yet run.

### Gotchas & Context
- one fixture still uses the old schema and will fail until updated

What the skill automates

The skill auto-populates the following before asking any clarifying questions:

1. The session's GitHub issue from /tmp/.claude-session-issue-number
2. The git diff and log since the session's start commit
3. Working-tree state from git status --short
4. An LLM pass over the conversation history — a full read, not a search — to extract decisions, dead ends, and remaining work

Only after that does it ask the user 1–2 targeted questions: anything it couldn't infer, and a pass for "did I miss anything."

Why it works

Three things make handoffs land:

1. Actionable What's Left. Each item should be something Claude can pick up without asking a clarifying question. This is the section the next session will execute against first, so it's the one that earns the scrutiny.
2. Specificity. "Fixed calcOrigination() to normalize Infinity in tier bounds" is useful. "Fixed a calculation bug" is not. File paths, function names, exact error messages.
3. Issue continuity. By including the GitHub issue number, the next session picks up the existing tracker instead of creating a duplicate.

A minimal template you can steal

## Session Handoff — [title]
### Original Task
### What Was Done
### What's Left
### Files Changed
### Gotchas & Context

The tradeoff

The handoff costs 60–120 seconds and saves 10–30 minutes per session — a ratio that improves as the project scales.