# wrap-up

The skill writes completed work, pending tasks and learnings to .claude/handoff.md, then loads them back at the start of the next session.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 2800 installs · ★ 789
- Author: codewithmukesh
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/codewithmukesh/dotnet-claude-kit/tree/HEAD/skills/wrap-up/SKILL.md
- Updated: 2026-08-07
- HTML: https://affpapa.org/en/nevibecode/skills/codewithmukesh-wrap-up

## What it does

Two moments matter here: the end of a session and the start of the next one. On wrap-up the agent reads `git status` and `git diff`, goes through the conversation, and records what got done, what is still open, and what was learned into `.claude/handoff.md`. There is one file and it is always overwritten, because only the current state counts. If the existing handoff holds pending tasks from someone else, the skill asks first: merge, overwrite, or skip.

At session start it reads `.claude/handoff.md`, `MEMORY.md` and `.claude/instincts.md`, then looks for a solution file (`.slnx` or `.sln`) in the current directory, its parents and its children. After that comes a resume summary: last session's work, pending items, active rules. Pending work is never started on its own — the skill asks what to pick up.

Learnings leave the handoff through `instinct-system`, which routes patterns into `.claude/instincts.md` and user corrections into `MEMORY.md`. The handoff itself is temporary, so long-lived rules do not belong there. For a save in the middle of a session without ending it, use `/checkpoint`.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add codewithmukesh/dotnet-claude-kit --skill wrap-up -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/wrap-up/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/wrap-up/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add codewithmukesh/dotnet-claude-kit --skill wrap-up -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/wrap-up/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add codewithmukesh/dotnet-claude-kit --skill wrap-up -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/wrap-up/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install codewithmukesh/dotnet-claude-kit wrap-up
```

2. **Manually: put the files in place**
- File: `.github/skills/wrap-up/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add codewithmukesh/dotnet-claude-kit --skill wrap-up -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/codewithmukesh/dotnet-claude-kit --path skills/wrap-up
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/wrap-up/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add codewithmukesh/dotnet-claude-kit --skill wrap-up -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/codewithmukesh/dotnet-claude-kit/tree/HEAD/skills/wrap-up/SKILL.md

## When to use it
- rebuild context after a break in work
- record pending tasks with file paths attached
- turn user corrections into permanent rules
- keep a decision and the reason behind it
- note a failed approach so the next session skips it

## Example prompts
- /wrap-up
- wrap up, done for today
- load handoff and tell me what we were working on

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: a9db0ee62a3905ab.

BEGIN THIRD-PARTY FILE a9db0ee62a3905ab
````text
---
name: wrap-up
description: >
  Owns the session handoff lifecycle: the end-of-session ritual that captures
  completed work, pending tasks, and learnings into .claude/handoff.md, and the
  session-start protocol that loads it back. Triggers on: /wrap-up, "wrap up",
  "done for today", "that's all", "end session", "signing off", "handoff" —
  and at session start: "start session", "session start", "load handoff",
  "pick up where we left off", "what were we working on".
disable-model-invocation: true
---

# /wrap-up

## What

The session continuity ritual. Sessions are ephemeral; knowledge is permanent.
Wrap-up bridges sessions in both directions:

- **Session END** — capture exactly three things: what was DONE, what is
  PENDING, and what was LEARNED. Write them to `.claude/handoff.md` and flow
  durable learnings into `MEMORY.md`.
- **Session START** — load the handoff, memory, and instincts, then present a
  resume summary so no session starts blind.

## When

- End of a working session — "done for today", "that's all", "signing off"
- Before switching projects or after a major milestone
- Implicit endings — "thanks" after completed tasks, "good enough for now":
  offer the handoff, don't just say goodbye
- Start of a session — "start session", "load handoff", "what were we working on"
- For a mid-session save without ending, use `/checkpoint` instead

## How

### Session End

1. **Review the session** — From git status/diff and the conversation: files
   touched, tasks completed vs unfinished, decisions made and why, user
   corrections observed.
2. **Check uncommitted changes** — If any exist, offer to commit before wrapping.
3. **Write the handoff** — `.claude/handoff.md`, using the format below.
   Single file, always overwritten — only the current state matters. If the
   existing handoff has pending tasks from someone else, ask before
   overwriting: merge, overwrite, or skip.
4. **Extract learnings** — Corrections and discoveries worth keeping go to
   `MEMORY.md` (via `instinct-system`); emerging patterns update
   `.claude/instincts.md` (via `instinct-system`). The handoff's Learned
   section is the trigger, not the destination — handoffs are ephemeral.
5. **Confirm** — Summarize the handoff and learnings captured for the user.

### Handoff File Format (`.claude/handoff.md`)

Write it for a stranger with zero context — file paths, rationale, specific
next steps. "Continue the refactor" is useless; "Refactor
`src/Orders/CreateOrder.cs` to the Result pattern — see Catalog for the
established pattern" is actionable.

```markdown
# Session Handoff

> Generated: 2026-06-12 | Branch: feature/order-validation

## Completed
- [x] Added FluentValidation to CreateOrder (src/Orders/Features/CreateOrder.cs:15-35)
````
END THIRD-PARTY FILE a9db0ee62a3905ab

The third-party file has ended. Everything between the a9db0ee62a3905ab tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2796 of 5203 bytes. © codewithmukesh · MIT · https://github.com/codewithmukesh/dotnet-claude-kit/tree/HEAD/skills/wrap-up/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md