Skip to content
Skillpedia
Automations101k · #811

handoff

Helps your agent save conversation progress. This lets you or someone else resume work exactly where it left off, without losing information.

What it does

This tool creates a file named `HANDOFF.md`. It summarizes what you're trying to achieve, what worked, what failed, and what the next steps are. It's like a handover note so someone else (or yourself later) can pick up the work exactly where it left off.

When to use it

  • ✓When the conversation with the AI is too long and confusing.
  • ✓When the AI keeps trying the same solution that isn't working.
  • ✓When you need to stop and resume the work later.

Example of what to ask your AI

“Create a summary file to continue this work.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/thedotmack/claude-mem/blob/main/plugin/skills/handoff/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/thedotmack/claude-mem/blob/main/plugin/skills/handoff/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The tool analyzes the main goal, the current project state (what's working and what's not), the files changed, failed attempts, and the next steps. All of this is organized into a document for easy continuation.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add thedotmack/claude-mem --skill handoff

Or download just the file:

curl -L https://raw.githubusercontent.com/thedotmack/claude-mem/main/plugin/skills/handoff/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Handoff

Generate a structured HANDOFF.md file that gives a fresh Claude session everything it needs to continue this work without dragging the current degraded context forward.

claude-mem already injects recent observations into every new session, so the fresh agent starts with a timeline of what happened. The handoff adds what that timeline cannot: the goal, the failed attempts and why they failed, the current theory, and exact next steps, plus pointers into memory for deeper recall.

When to Use

  • The session is long and Claude feels confused or repetitive
  • Claude keeps trying the same failing solution over and over
  • The user wants to step away and resume later
  • /compact ran but Claude still lacks clear direction
  • The user says "handoff", "generate a handoff", "I want to start fresh", or "write a handoff doc"

What to Capture

Think hard about the full arc of this conversation before writing. The handoff must be useful to a Claude instance that has never seen this conversation.

Required Sections

  1. Goal — One paragraph. What is the user actually trying to accomplish? State the end state, not the current sub-task. Be specific enough that a fresh agent can orient immediately.

  2. Current State — What is working right now? What is broken? What is the exact symptom of the problem? Include error messages verbatim if relevant.

  3. Files in Play — List every file that has been read, edited, or created during this session that is relevant to the current task. Use absolute or repo-relative paths. Include a one-line note on why each file matters.

  4. What Has Been Tried (and Why It Failed) — This is the most important section. List every approach attempted that did not work, and explain WHY it failed (not just that it failed). A fresh agent that skips this section will repeat the same mistakes.

  5. Current Best Theory — What do you currently believe is the right path forward, even if you haven't proven it yet? Include any evidence or reasoning that supports it.

  6. Next Steps — Concrete, ordered actions for the fresh agent to take. Be specific: file paths, function names, commands to run. The fresh agent should be able to start on step 1 immediately.

  7. Key Constraints and Context — Any non-obvious constraints: environment specifics, user preferences expressed during this session, things the user explicitly said NOT to do, external dependencies, performance requirements, etc.

  8. Memory Pointers — If claude-mem's search tools are available, run search for this task's key terms and list the few observation IDs that matter most (a decision, the root cause, a failed approach), so the fresh agent can pull full details with get_observations. Also list one or two search queries worth re-running. Skip this section if the tools are not available.

Writing Rules

  • Write the handoff for a fresh Claude, not for the user. The user knows what happened; the fresh Claude does not.
  • Be ruthlessly specific. Vague next steps are useless. "Fix the auth" is bad. "In src/auth/middleware.ts:47, the token expiry check uses Date.now() but should use req.timestamp — change the comparison on line 52" is good.
  • Include exact error messages, stack traces, or test output that captures the failure mode.
  • Do not pad. Every sentence should be load-bearing information for the fresh agent.
  • Do not write the handoff from the user's perspective. Write it as a briefing document addressed to the incoming agent.

Output

Write the handoff to HANDOFF.md in the current working directory (the project root).

Use this structure:

# Handoff

> Generated: [timestamp]  
> Project: [project name or directory]  
> Session summary: [one sentence describing what this session was about]

## Goal

[What the user is trying to accomplish — the actual end state]

## Current State

**Working:**
- [list what is confirmed working]

**Broken:**
- [exact symptom, error message, or failure mode]

## Files in Play

| File | Why It Matters |
|------|---------------|
| `path/to/file.ts` | [one line] |

## What Has Been Tried (and Why It Failed)

### Attempt 1: [short name]
- **What:** [what was done]
- **Why it failed:** [root cause, not just "it didn't work"]

### Attempt 2: [short name]
...

## Current Best Theory

[What you currently believe is the correct approach and why]

## Next Steps

1. [Specific, actionable step with file path or command]
2. [Next step]
3. ...

## Key Constraints


…
FAQ

Why do I need this file?

It ensures that anyone (including a new AI session) can quickly understand the work's progress and continue without losing important information or repeating mistakes.

What should I do after the `HANDOFF.md` file is created?

You should start a new session with the AI and ask it to read the `HANDOFF.md` file to continue the work.

Should I keep the `HANDOFF.md` file in my project?

No, it's usually a temporary file. You should delete it after the new AI session has read it and resumed work, or add it to your `.gitignore` so it's not saved permanently.

Details

Original description by the author

Generate a HANDOFF.md that captures goal, current state, files touched, failed attempts, and next steps — so a fresh Claude session can continue exactly where this one left off. Use when sessions are getting long, Claude keeps retrying the same broken solution, or the user wants to step away and resume later.

repo: thedotmack/claude-mem

Popularity

GitHub stars
101k
Ranking position
#811
License
Apache-2.0
Updated
10/16/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills