Przejdź do treści
Biblioteka skilli
AI i agenci · Pisanie

handoff

/handoff

Tworzy uporządkowany dokument przekazania sesji z decyzjami, postępem, zmianami w kodzie i następnymi krokami, aby przyszła sesja podjęła pracę bez utraty kontekstu.

Licencja
MIT
Ostatnia zmiana repozytorium
16.09.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 16.09.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Tworzy uporządkowany dokument przekazania sesji z decyzjami, postępem, zmianami w kodzie i następnymi krokami, aby przyszła sesja podjęła pracę bez utraty kontekstu.

Oryginalny opis (EN)

Create a structured session handoff document for continuity across sessions. Use when ending a work session, switching contexts, or before a break. Captures decisions, progress, code changes, and next steps so a future session can pick up where you left off without losing context.

Jak działa

  1. When to Use
  2. Handoff Process
  3. What to Capture
  4. Format Guidelines
  5. Quality Check
  6. Using a Handoff Document
  7. Example Handoff
  8. Key Reminders
Sekcje z nagłówków SKILL.md, w oryginale · 223 linii, 931 słów
Podgląd SKILL.md
---
name: handoff
description:
  Create a structured session handoff document for continuity across sessions.
  Use when ending a work session, switching contexts, or before a break.
  Captures decisions, progress, code changes, and next steps so a future session
  can pick up where you left off without losing context.
---

# Session Handoff Skill

Create structured documents that enable seamless continuity across Claude
sessions.

## When to Use

- Ending a work session for the day
- Before taking a break mid-task
- Switching to a different project temporarily
- When you want to capture state for a future session
- Before a context reset you know is coming

## Handoff Process

### Step 1: Assess Session State

Quickly assess:

1. **What phase are we in?** (exploration, planning, implementation, debugging,
   review)
2. **What's the active task?** (what we're trying to accomplish)
3. **How far along are we?** (just started, mid-way, almost done)

### Step 2: Ask What Matters

Ask the user:

> "I'll create a handoff document. Is there anything specific you want to make
> sure I capture? (Key decisions, code snippets, context about the problem,
> things you'll forget, etc.)"

### Step 3: Generate Handoff Document

Create a structured document:

```markdown
# Session Handoff: [Brief Description]

**Date:** [YYYY-MM-DD] **Project:** [project name/path] **Session Duration:**
[approximate]

## Current State

**Task:** [What we're working on] **Phase:**
[exploration/planning/implementation/debugging/review] **Progress:** [where we
are - percentage or milestone]

## What We Did

[2-3 sentence summary of the session's work]

## Decisions Made

- **[Decision]** — [Rationale]
- **[Decision]** — [Rationale]

## Code Changes

**Files modified:**

- `path/to/file.ts` — [what and why]
- `path/to/other.ts` — [what and why]

**Key code context:** [Critical snippets or patterns to remember]

## Open Questions

- [ ] [Question needing resolution]
- [ ] [Question needing resolution]

## Blockers / Issues

- [Issue] — [current status]

## Context to Remember

[Important background, constraints, user preferences, domain knowledge - things
that would take time to re-establish]

## Next Steps

1. [ ] [First thing to do next session]
2. [ ] [Second thing]
3. [ ] [Third thing]

## Files to Review on Resume

- `path/to/key/file.ts` — [why it matters]
```

### Step 4: Write the File

Write to: `.claude/handoffs/[YYYY-MM-DD]-[brief-description].md`

Confirm location with user:

> "I'll save this to `.claude/handoffs/[filename].md`. Want a different
> location?"

## What to Capture

### Always Include

1. **Decisions with reasoning** — The "why" is often more valuable than the
   "what"
2. **Code changes** — File paths, what changed, the intent
3. **Current progress** — Where in the task we stopped
4. **Next steps** — Clear, actionable items to resume with
5. **User context** — Constraints, preferences, domain knowledge they shared

### Include When Relevant

- **Errors encountered** — And how they were (or weren't) resolved
- **Dead ends** — Approaches tried that didn't work (saves re-exploration)
- **Key files** — Files to read to get back up to speed
- **External dependencies** — APIs, services, tools involved

### Skip

- Verbose tool output (file listings, grep results)
- Intermediate reasoning that reached conclusions
- Repeated similar operations
- Information that's obvious from the code

## Format Guidelines

- **Bullet points** — Scannable over narrative
- **File paths** — `src/foo.ts:42` not "that function"
- **Checkboxes for actions** — `- [ ]` for next steps and open questions
- **Specifics** — "Added retry logic to fetchUser()" not "made improvements"

## Quality Check

Before saving, verify:

1. **Could a fresh Claude pick up from this?** — Enough context to continue?
2. **Are decisions traceable?** — Clear why things were decided?
3. **Are next steps actionable?** — Know exactly what to do first?
4. **Is code work clear?** — Know which files matter?

## Using a Handoff Document

When starting a new session, the user can:

1. Share the handoff file at session start
2. Say "Resume from this handoff: [paste or path]"
3. Reference it with @ mention if supported

The handoff should let you hit the ground running without lengthy
re-explanation.

## Example Handoff

```markdown
# Session Handoff: Auth System Implementation

**Date:** 2025-01-15 **Project:** /Users/robert/projects/my-api **Session
Duration:** ~2 hours

## Current State

**Task:** Implementing user authentication for the API **Phase:** Implementation
**Progress:** ~60% - basic flow works, need refresh tokens

## What We Did

Built the core JWT authentication flow including token generation, validation
middleware, and login/logout endpoints. Hit an issue with key rotation that we
resolved by moving to config-based key paths.

## Decisions Made

- **JWT with RS256** — Stateless auth, works with distributed setup
- **Redis for refresh tokens** — Need revocation capability
- **15-min access token expiry** — Balance security/UX for mobile app

## Code Changes

**Files modified:**

- `src/auth/jwt.ts` — Token generation and validation logic
- `src/middleware/auth.ts` — Request authentication middleware
- `src/routes/auth.ts` — Login/logout endpoints
- `config/keys/` — RSA key pair storage

**Key code context:** Token validation uses RS256. Keys loaded from
`config/keys/` based on NODE_ENV.

## Open Questions

- [ ] Automatic vs opt-in refresh token rotation?
- [ ] Rate limit for login attempts? (User mentioned 10k DAU)

## Context to Remember

- Client is a mobile app - tokens need offline capability
- User has 10k daily active users - scale matters
- Using PostgreSQL for user storage
- User prefers explicit error messages over generic ones

## Next Steps

1. [ ] Implement `/auth/refresh` endpoint
2. [ ] Add rate limiting to `/auth/login`
3. [ ] Write tests for token expiry edge cases
4. [ ] Update API docs with auth flow

## Files to Review on Resume

- `src/auth/jwt.ts` — Core token logic
- `src/routes/auth.ts` — Current endpoint implementation
```

## Key Reminders

- Ask what matters to the user before generating
- Decisions need reasoning — capture the "why"
- File paths anchor the work — always include them
- Next steps should be immediately actionable
- Better slightly longer and useful than short and vague
Pliki w paczce (2)
  • README.md 3 KB
  • SKILL.md 6 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · robertguss/claude-code-toolkit100MIT
lumpen-mya/claude-handoff100MIT
generous-corp/pulp100MIT
Ovid/paad100MIT
Ovid/paad100MIT
Ovid/paad100MIT
webdevnerdstuff/claude-marketplace100MIT
terencebristol/terencebristol-toolkit100MIT
verkyyi/claude-fleet100MIT

Identyczna treść występuje jeszcze w 2 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.

Migawka bazy z 13.11.2026 · wersja paczki 9721d0d2e122 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 1 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100session-handoff
    Pisze na koniec sesji roboczej dokument startowy ze stanem prac, decyzjami, następnymi krokami i pułapkami, by kolejna sesja lub osoba wznowiła pracę w kilka minut.
  • 100session-handoff
    Tworzy ustrukturyzowane streszczenia kontekstu do kontynuowania pracy w kolejnych sesjach AI bez utraty kontekstu po zakończeniu sesji.
  • 90ring:creating-handoffs
    Tworzy dokument przekazania sesji z ukończoną pracą, decyzjami, otwartymi sprawami i następnymi krokami, gotowy do wznowienia w Plan Mode.
  • 100session-handoff
    Zapisuje plik przekazania, by zablokowana sesja wznowiła pracę w innym narzędziu bez utraty kontekstu, np. w Codex.
  • 100session-handoff
    Tworzy ustrukturyzowany dokument przekazania dla następnej sesji, gdy kontekst zbliża się do limitu, przed /clear lub /compact, przy zmianie zadań i na koniec sesji kodowania.
  • 100session-summary
    Podsumowuje kontekst sesji: wykonane zadania, decyzje techniczne i kolejne kroki, także jako dokument przekazania do nowej sesji.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.