Skip to content
Skills Library
AI & agents · Writing

session-save

/session-save

Use when ending, pausing, or running low on context in a working session and you want to resume cleanly later — phrases like "save our spot", "before I close this session", "pick this up tomorrow", "make a follow-up file", "so we can continue", "write a continuation doc", or when a session is about to compact/expire mid-task. Writes the continuation file consumed by session-resume. Not for mid-session checkpoints (use grounding) or storing standalone facts (use repo-memory).

Repository
huhhb ↗
Licence
MIT
Last repository change
11.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 11.08.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when ending, pausing, or running low on context in a working session and you want to resume cleanly later — phrases like "save our spot", "before I close this session", "pick this up tomorrow", "make a follow-up file", "so we can continue", "write a continuation doc", or when a session is about to compact/expire mid-task. Writes the continuation file consumed by session-resume. Not for mid-session checkpoints (use grounding) or storing standalone facts (use repo-memory).

Triggers from the description

save our spotbefore I close this sessionpick this up tomorrowmake a follow-up fileso we can continuewrite a continuation doc
Original author description

Use when ending, pausing, or running low on context in a working session and you want to resume cleanly later — phrases like "save our spot", "before I close this session", "pick this up tomorrow", "make a follow-up file", "so we can continue", "write a continuation doc", or when a session is about to compact/expire mid-task. Writes the continuation file consumed by session-resume. Not for mid-session checkpoints (use grounding) or storing standalone facts (use repo-memory).

How it works

  1. Overview
  2. When to use
  3. Procedure
  4. Required sections
  5. Quick template
  6. Common mistakes
Original SKILL.md headings · 94 lines, 713 words
SKILL.md preview
---
name: session-save
description: >
  Use when ending, pausing, or running low on context in a working session and you want to resume
  cleanly later — phrases like "save our spot", "before I close this session", "pick this up
  tomorrow", "make a follow-up file", "so we can continue", "write a continuation doc", or when a
  session is about to compact/expire mid-task. Writes the continuation file consumed by
  session-resume. Not for mid-session checkpoints (use grounding) or storing standalone facts (use
  repo-memory).
---

# Session Save

## Overview

Write a durable continuation file so the next session — you, a teammate, or a fresh agent — resumes
in seconds instead of re-reading everything.

**Core principle:** capture the *exact next action* and the *context that lives nowhere else* —
conversation decisions, working-tree state, gotchas — and link to the source of truth rather than
copying it.

## When to use

- A session is ending, or about to compact/expire, mid-task.
- The user says "continue later", "save our spot", "make a follow-up file".
- A long session produced decisions, gotchas, or state that commits alone won't preserve.

**Skip** for trivial one-off tasks, or work already fully captured by commits plus an up-to-date
plan/tracker.

## Procedure

1. **Find, don't duplicate.** Look for an existing `.claude/CONTINUE.md`. Also check the repo root
   for a legacy `CONTINUE.md` or `HANDOFF.md` — if found, fold its content into
   `.claude/CONTINUE.md` and delete the legacy file. Exactly one continuation file per worktree;
   update it, never spawn a second.
2. **Ensure it stays out of git.** Check `.gitignore` for a `.claude/CONTINUE.md` line; append it
   if missing (that edit is a normal, committable change). **Never stage or commit the continuation
   file itself** unless the user explicitly asks — then use `git add -f`.
3. **Link the source of truth.** If a plan/tracker/ROADMAP holds full status, point to it. The
   continuation file is a *pointer + the volatile bits*, not a copy — copies drift out of sync.
4. **Self-stamp.** Record save date, branch, and HEAD sha in the header — `session-resume`
   verifies against these.
5. **Fill the required sections** (table below). The make-or-break ones are the **exact next
   action** and the **conversation context**.
6. **Save the file.** Do not stage it. Do not commit it.

## Required sections

| Section | Must answer |
|---------|-------------|
| Stamp | Save date · branch · HEAD sha · pushed y/n |
| Where we stopped | What's done **and verified** vs merely planned |
| ▶ Next action | The ONE exact next step **and its entry point** (file / task #) — never just "continue" |
| Conversation context | Decisions made and alternatives rejected **in chat only** — the highest-value section |
| Non-obvious learnings | Gotchas and dead-ends not visible in code or commits |
| Working-tree state | Uncommitted/untracked files and what each is mid-change · stashes · open PRs + review state · background processes · in-flight task list |
| How to resume | What to read first (1–3 links) · how memory/context loads next session |
| Environment & commands | dev / test / build commands used this session + key versions; mark ONE as the **baseline command** for session-resume to re-run |
| Blockers / human steps | Anything waiting on a person or external system (and what to do) |

## Quick template

```markdown
# Continue Here
> Saved <YYYY-MM-DD> · branch: <name> @ <short-sha> · pushed: y/n
> Authoritative status lives in <tracker>. This file = where we stopped + the exact next action.

## Where we stopped
- <done & verified> · <planned>

## ▶ Next action
<one concrete step> — entry point: <file / task #>

## Conversation context (chat-only decisions)
- <decision + rejected alternative + why>

## Non-obvious learnings (not in code/commits)
- <gotcha / dead-end + why it matters>

## Working-tree state
- uncommitted: <file — what's mid-change> · stashes: <n> · PRs: <# + state> · background: <process> · tasks: <in-flight list state>

## How to resume
1. Read <tracker/plan link>   2. <memory/context note>

## Environment & commands
- dev: <cmd> · test: <cmd> ← baseline · build: <cmd> · versions: <key versions>

## Blockers / human steps
- <waiting-on person/external + what to do>
```

## Common mistakes

- **Vague narrative** ("we worked on X") instead of the *exact* next action and entry point.
- **Duplicating the full plan/status** into the continuation file → it drifts. Link the tracker;
  keep only volatile bits here.
- **Creating a second continuation file** when one already exists — update the existing one.
- **Omitting conversation context and non-obvious learnings** — the parts git can't recover.
- **Committing the continuation file** — never, unless the user explicitly says to.
- **Leaking secrets/PII** into the file.

Versions

RepositoryScoreLicence
This page · uhstray-io/huhhb100MIT
hongdangmoo49/oh-my-obsidian100MIT

Database snapshot: 13.11.2026 · package version ec67370caf66 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90session-resume
    Use when starting a session that should continue prior work — phrases like "resume the session", "pick up where we left off", "continue from where we stopped", "where were we", "load the continuation file". Consumes the .claude/CONTINUE.md written by session-save: verifies it…
  • 84handoff
    Mid-session save-point for /clear-and-resume: a durable handoff file (default) or a copy-paste resume prompt. Use when: 'handoff', 'save state', 'checkpoint this', 'pause', 'come back later', the session is heavy, a context-measuring mechanism says to fork, or responses are…
  • 90handoff
    Use when the user asks to hand off or transfer the session to another agent, checkpoint the session, or save its context or continuation notes for later. Write a durable, self-contained handoff file that lets a fresh agent resume this session's work without chat history. Do not…
  • 100baton-pass
    Generates a self-contained continuation prompt ("baton") so work can resume in another session, IDE, model or platform without losing context. Use when plan or session usage is high (weekly/5-hour limit near), when the context is about to be compacted and the owner wants a fresh…
  • 100session-handoff-prompt
    Create a concise continuation prompt that a fresh agent session can paste in to resume a long or degraded session. Use when the user asks for a handoff prompt, restart prompt, continuation prompt, context transfer, fresh-session resume, or a compact summary for opening a new…
  • 100context-manager
    Manage the context window and session handoffs for long-running and multi-agent builds — watch usage, choose a compaction strategy, and write and validate a structured handoff file so a fresh session or continuation agent picks up cleanly. Use when the context is filling —…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.