home / skills / petekp / agent-skills / handoff

handoff skill

/skills/handoff

This skill generates a concise bootstrap prompt to resume a conversation in a new session while preserving essential context and decisions.

This is most likely a fork of the handoff skill from petekp
npx playbooks add skill petekp/agent-skills --skill handoff

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.5 KB
---
name: handoff
description: >
  Generate a smart bootstrap prompt to continue the current conversation in a fresh session.
  Use when (1) approaching context limits, (2) user says "handoff", "bootstrap", "continue later",
  "save session", or similar, (3) before closing a session with unfinished work, (4) user wants
  to resume in a different environment. Outputs a clipboard-ready prompt capturing essential
  context while minimizing tokens.
---

# Handoff

Generate a bootstrap prompt that enables seamless conversation continuity in a new session.

## Process

### 1. Analyze Current Session

Identify and categorize:

- **Goal state**: What is the user trying to accomplish? What's the end state?
- **Current progress**: What's been done? What's working?
- **Blockers/open questions**: What's unresolved? What decisions are pending?
- **Key artifacts**: Files modified, commands run, errors encountered
- **Critical context**: Domain knowledge, constraints, or preferences established

### 2. Apply Token Efficiency Heuristics

**Include:**
- Specific file paths, function names, error messages (hard to rediscover)
- Decisions made and their rationale (prevents re-discussion)
- Current hypothesis or approach being tested
- Exact reproduction steps for bugs

**Exclude:**
- General knowledge Claude already has
- Verbose explanations of standard concepts
- Full file contents (use paths + line numbers instead)
- Conversation pleasantries or meta-discussion

**Compress:**
- Use bullet points over prose
- Reference files by path, not content
- Summarize long error traces to key lines
- Use "established: X" for agreed-upon decisions

### 3. Structure the Bootstrap Prompt

```markdown
## Context
[1-2 sentence goal statement]

## Progress
- [Completed item with outcome]
- [Completed item with outcome]

## Current State
[What's happening right now - the exact point to resume from]

## Key Files
- `path/to/file.ext` - [role/status]

## Open Items
- [ ] [Next immediate action]
- [ ] [Subsequent action]

## Constraints/Decisions
- [Established constraint or decision]
```

### 4. Output

Copy the bootstrap prompt to clipboard using:

```bash
echo "PROMPT_CONTENT" | pbcopy  # macOS
```

Confirm with: "Bootstrap prompt copied to clipboard. Paste it to start a new session."

## Adaptive Sizing

**Simple tasks** (bug fix, small feature): 100-200 tokens
- Goal, current file, error/behavior, next step

**Medium tasks** (feature implementation, refactor): 200-400 tokens
- Goal, progress list, current state, key files, next steps

**Complex tasks** (architecture, multi-system): 400-800 tokens
- Full structure above, plus constraints and decision rationale

## Example Output

```markdown
## Context
Adding OAuth login to the Express app, Google provider first.

## Progress
- Installed passport, passport-google-oauth20
- Created `src/auth/google.ts` with strategy config
- Added `/auth/google` and `/auth/google/callback` routes

## Current State
Callback route returns "Failed to serialize user into session" - need to implement serializeUser/deserializeUser in passport config.

## Key Files
- `src/auth/google.ts` - strategy setup (working)
- `src/routes/auth.ts:45` - callback handler (error here)
- `src/app.ts` - passport.initialize() added, missing session serialize

## Open Items
- [ ] Add serialize/deserialize to passport config
- [ ] Test full OAuth flow
- [ ] Add session persistence (currently memory store)

## Constraints
- Using express-session with default memory store for now
- Google OAuth credentials in .env (GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET)
```

Overview

This skill generates a compact, clipboard-ready bootstrap prompt to continue a conversation in a fresh session. It captures the goal, progress, current state, key files, open items, and constraints while minimizing token use so a handoff is fast and actionable.

How this skill works

The skill inspects the current conversation and extracts goal state, progress, blockers, key artifacts, and decisions. It applies token-efficiency heuristics—favoring file paths, terse bullet points, and excluding general knowledge—to produce a structured markdown prompt sized for the task complexity. The output is formatted for easy copying (with an example pbcopy command) and includes a short confirmation message.

When to use it

  • Approaching model or session context limits and you need to continue later
  • User says “handoff”, “bootstrap”, “continue later”, or “save session”
  • Before closing a session with unfinished work or unresolved bugs
  • When resuming in a different environment, account, or toolchain
  • Switching from exploratory chat to a tracked issue or ticket

Best practices

  • Keep the goal to 1–2 sentences and state the desired end state explicitly
  • List only reproducible facts: file paths, error messages, commands, and recent outputs
  • Use bullet lists and short lines; avoid pasting full file contents
  • Mark decisions with “established:” and unresolved items as checkboxes
  • Choose adaptive sizing: 100–200 tokens for small tasks, 200–400 for medium, 400–800 for complex

Example use cases

  • Bug reproduction: include exact failing command, key error lines, and file path + line number
  • Feature continuation: summarize implemented pieces and next API endpoints to add
  • Session transfer: hand off session context to a colleague or different assistant instance
  • Environment change: resume work on a different machine or CI runner with paths and env vars
  • Pre-shutdown save: capture open todos and immediate next test to run before closing

FAQ

How long should the bootstrap prompt be?

Match the size to task complexity: ~100–200 tokens for small fixes, 200–400 for medium tasks, and up to 800 for large architecture or multi-system work.

What must I never include?

Avoid full file contents, long tutorial-style explanations, and conversational pleasantries. Include only what's hard to rediscover: paths, errors, decisions, and exact reproduction steps.