wrap-up

codewithmukesh/dotnet-claude-kit

Capture session work, pending tasks, and learnings into a handoff file for continuity across sessions.

What is wrap-up?

The wrap-up skill owns the session lifecycle: at session end, it captures completed work, pending tasks, and learnings into .claude/handoff.md; at session start, it loads that context back so no session begins blind. Use it when ending a working session or starting a new one to maintain project continuity.

Captures completed work, pending tasks, and learnings at session end into .claude/handoff.md
Loads handoff, memory, and instincts at session start to resume context
Detects uncommitted changes and offers to commit before wrapping
Extracts learnings and corrections into MEMORY.md and .claude/instincts.md via instinct-system
Presents a resume summary at session start with pending tasks and active rules

How to install wrap-up

npx skills add https://github.com/codewithmukesh/dotnet-claude-kit --skill wrap-up

Claude Code

Cursor

Windsurf

Cline

How to use wrap-up

1.At session end, trigger with /wrap-up or phrases like "done for today", "signing off", or "that's all"
2.Review the session from git status/diff and conversation to identify completed tasks, unfinished work, and decisions made
3.Confirm any uncommitted changes and commit if needed before wrapping
4.The skill writes .claude/handoff.md with Completed, Pending, and Learned sections, formatted for a stranger with zero context
5.At session start, trigger with "start session", "load handoff", or "what were we working on"
6.The skill loads .claude/handoff.md, MEMORY.md, and .claude/instincts.md, then presents a resume summary of pending work and active rules

Use cases

Good for

End of a working session to document what was done and what remains
Starting a new session to load prior context and pending work
Before switching projects or after major milestones to preserve continuity
Mid-project handoff between developers to ensure actionable next steps
Implicit session endings (after "thanks" or "good enough for now") to offer continuity without forcing it

Who it's for

Solo developers working across multiple sessions on the same project
Teams sharing a codebase who need to hand off work between sessions
Developers who want to preserve learnings and patterns across sessions
Anyone working on long-running projects that span multiple coding sessions

wrap-up FAQ

What format should the handoff file use?

Write .claude/handoff.md with sections for Completed (with file paths and line numbers), Pending (with specific next steps and references), and Learned (non-obvious discoveries and corrections). Include metadata like branch, last commit, and solution file. Write for a stranger with zero context—"Continue the refactor" is useless; "Refactor src/Orders/CreateOrder.cs to the Result pattern" is actionable.

When should I use wrap-up vs. checkpoint?

Use /wrap-up to end a session and capture work for the next session. Use /checkpoint for a mid-session save (commit + brief note) without ending the session.

What counts as a learning worth capturing?

Capture user corrections, non-obvious discoveries (e.g., "EF compiled queries don't work with Include()"), decisions with rationale, and failed approaches. Skip vague learnings like "Worked on Orders module" or already-known facts like "Used TimeProvider".

What if multiple developers share the project?

Add a Decisions Made table (Decision | Choice | Rationale) and Open Questions section to the handoff so the next developer understands the context and trade-offs.

What if .claude/handoff.md already exists from another developer?

Ask before overwriting: merge the pending tasks, overwrite with your session's work, or skip the wrap-up entirely.

Full instructions (SKILL.md)

Source of truth, from codewithmukesh/dotnet-claude-kit.

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

Review the session — From git status/diff and the conversation: files touched, tasks completed vs unfinished, decisions made and why, user corrections observed.
Check uncommitted changes — If any exist, offer to commit before wrapping.
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.
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.
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.

# Session Handoff

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

## Completed
- [x] Added FluentValidation to CreateOrder (src/Orders/Features/CreateOrder.cs:15-35)
- [x] Fixed N+1 in GetOrderDetails (src/Orders/Features/GetOrderDetails.cs:28)

## Pending
- [ ] Add validation to UpdateOrder (src/Orders/Features/UpdateOrder.cs)
  - Reference: CreateOrder validator for the established pattern
- [ ] Full test run — 2 pre-existing Catalog failures, not from today

## Learned
- FluentValidation validators must be registered in the module's DI setup
- Test fixture seeds 1 item per order, which hides N+1 queries

## Context
- Branch: feature/order-validation | Last commit: "Add CreateOrder validation"
- Uncommitted changes: no | Solution: src/MyApp.slnx

When multiple developers share the project, add a ## Decisions Made table (Decision | Choice | Rationale) and ## Open Questions.

Learning Extraction Checklist

Did the user correct anything? → MEMORY.md via instinct-system
Did we discover something non-obvious? → Learned section
Did we decide something with rationale? → document the "why"
Did a tool/approach fail? → note it so the next session doesn't retry it

Good learning: "EF compiled queries don't work with Include()". Bad learning: "Worked on Orders module" (vague) or "Used TimeProvider" (already a rule).

Session Start

Load context — Read .claude/handoff.md (pending work), MEMORY.md (permanent rules), .claude/instincts.md (patterns at 0.7+ confidence). Missing files are fine: note it and start clean — never block on them.
Detect the solution — Find .slnx/.sln (current dir, then parents, then children) so Roslyn MCP tools work from the first prompt.
Present a resume summary — Last session's work, pending tasks, active rules/instincts count, detected solution. Then ask what to work on — never auto-start pending work.

Example

User: /wrap-up

Claude: Wrapping up session...

## Session Summary
- Implemented OrderService with validation pipeline
- Fixed N+1 query in GetOrdersByCustomer

## Pending
- [ ] Add retry logic to payment gateway calls (OrderService.cs:42)

## Learnings Captured
- User prefers explicit mapping over AutoMapper → MEMORY.md

Written to .claude/handoff.md. See you next session.

/checkpoint — Mid-session save (commit + brief note) without ending the session
instinct-system — Routes session learnings: patterns become instincts, user corrections become permanent MEMORY.md rules