# Chat Handoff

> Generate a handoff document that lets a NEW Claude conversation resume this one with full context. Use whenever the user asks to "write a handoff," "summarize this chat so I can continue elsewhere," "prep a handoff doc," says they're starting a new chat and want continuity, mentions running low on context/hitting a limit, or asks for a "context dump" or "resume doc" for this conversation. Always trigger this instead of a generic summary when the stated purpose is continuing the work in a different conversation.

- Skill: `connoryoushaei/chat-handoff` (Agent Skill)
- Install (CLI): `npx skillmds@latest add connoryoushaei/chat-handoff`
- Raw SKILL.md: https://api.skillmd.com/api/skills/connoryoushaei/chat-handoff/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Research & Search
- Author: connoryoushaei (https://skillmd.com/u/connoryoushaei)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/connoryoushaei/chat-handoff

---


# Chat Handoff Generator

Produces a markdown file that a fresh Claude instance (no memory of this conversation) can read and immediately resume work at full competence — not a human-readable recap, a resumption packet.

## Core principle

Optimize for the reader being Claude, not a person. That means:
- State over narrative. Don't tell the story of the conversation; state its current facts.
- Decisions and their reasoning, not the back-and-forth that produced them. If three options were considered and one was picked, record the winner and the one-line reason, not the deliberation.
- Explicit > implied. A new Claude has zero shared context. Anything assumed-but-unstated in the original chat must be spelled out.
- Dense. This is a working document, not prose to be enjoyed. Bullets and tables over paragraphs.

## Step 1: Scan the conversation for required components

Before writing, extract:

1. **Objective** — what is the user ultimately trying to accomplish? (Not "what did we talk about," but the actual goal/deliverable.)
2. **Current state** — what's done, what's in progress, what hasn't started. Be precise about "in progress" — what exactly is incomplete about it?
3. **Decisions made** — any choice between alternatives that was resolved. Format: decision + one-line rationale. Do not include decisions that are still open or that the user waffled on.
4. **Constraints and preferences established in this chat** — anything the user specified that should carry forward (format requirements, things to avoid, stated preferences) that a new chat wouldn't otherwise know. Do not duplicate global user preferences/memory Claude already has access to — only capture things specific to THIS conversation's task.
5. **Artifacts produced** — files, code, drafts, links. Embed the FULL content of each artifact produced in this conversation (code, drafts, generated documents), not just a description. Artifacts created in claude.ai conversations do not carry over to a new conversation, so the handoff doc is the only place this content will exist for the new chat. Exception: if an artifact is genuinely large (e.g. a long generated report) AND was also saved to a location the user can independently re-attach, note that explicitly instead of embedding — but default to embedding.
6. **Open questions / blockers** — anything unresolved that the new chat needs to either ask about or pick up.
7. **Next step** — the single most immediate next action. Not a list of everything left; the next one.

## Step 2: Identify gaps, ask before writing

If any of the following are ambiguous from the conversation alone, ask the user rather than guessing:
- Which of multiple parallel threads/sub-tasks is actually the priority to resume
- Whether an in-progress item is blocked, paused intentionally, or just not yet started
- Whether draft/exploratory content should be treated as decided or still open
- Whether a very large artifact should be embedded in full or trimmed/referenced (default is still to embed; only ask if it's unusually long)

Ask concisely, batch the questions, don't ask about things you can resolve by re-reading the conversation.

## Step 3: Write the handoff file

Use this structure. Omit any section that's genuinely empty (don't write "N/A") but keep the order.

````markdown
# Handoff: [short task name]

## Objective
[1-3 sentences: what's being built/solved/produced and for what purpose]

## Current state
[Precise status. What's done, what's partial and in what way, what hasn't started.]

## Decisions made
- [Decision]: [one-line rationale]
- ...

## Constraints / preferences (this task only)
- [Anything the user specified in this conversation that must carry forward]

## Artifacts
### [artifact name/filename]
[one-line description]
```
[full content]
```

## Open questions / blockers
- [Unresolved item the new chat should surface or resolve]

## Next step
[The single next action, stated concretely enough to act on immediately]
````

Keep the whole document as short as it can be while losing zero decision-relevant information. Target: a careful reader should be able to act correctly on the new chat's very first response after reading this alone.

## Step 4: Deliver

Save as a `.md` file (filename: short-task-slug-handoff.md) and present it to the user via file tools. Tell the user, in one line, to paste the file or its contents into the new chat to resume.

## Anti-patterns to avoid

- Don't write a chronological recap ("First we discussed X, then Y, then...").
- Don't include pleasantries, praise, or meta-commentary about the conversation.
- Don't restate things a new Claude would already know from general knowledge or from the user's memory/preferences — only this conversation's specific state.
- Don't hedge with vague status like "mostly done" — say what specifically remains.