session-continuity

fangdev24's avatarfrom fangdev24

Ensures smooth handoff between AI sessions by capturing context and next steps before session ends.

⭐0stars🔀0forks📁View on GitHub🕐Updated Jan 8, 2026
[Memory and Context Management]

When & Why to Use This Skill

The Session Continuity skill is designed to bridge the gap between AI interactions by systematically capturing project state, architectural decisions, and pending tasks. It optimizes workflow efficiency and prevents information loss caused by context window limitations, ensuring a seamless transition and sustained momentum across multiple AI sessions through structured handoff documentation.

Use Cases

  • Case 1: Managing long-running software development projects where the AI's context window is nearing its limit, requiring a structured state capture to resume in a fresh session.
  • Case 2: Documenting major milestones and architectural decisions during a session to ensure the next session starts with a clear understanding of the 'why' behind the code.
  • Case 3: Creating a detailed 'Next Steps' roadmap and environment setup guide (including CLI commands) to minimize friction when restarting work after a break.
  • Case 4: Facilitating collaborative handoffs where one user or agent needs to pass a complex, in-progress task to another with full context of blockers and current progress.
namesession-continuity
descriptionEnsures smooth handoff between AI sessions by capturing context and next steps before session ends.

Session Continuity Skill

Ensures smooth handoff between AI sessions.

Purpose

AI sessions have context windows that eventually fill. This skill:

  • Captures current state before session ends
  • Creates handoff documents for next session
  • Preserves momentum across sessions

When to Activate

Activate when:

  • User mentions "end of session" or "wrapping up"
  • Context appears to be getting long
  • User asks for a summary
  • Major milestone completed

Handoff Document

Create at session end:

Location: knowledge-base/sessions/YYYY-MM-DD-handoff.md

# Session Handoff: {Date}

## Current State

### What We Built
- {Feature/component 1}
- {Feature/component 2}

### Key Files Modified
- `path/to/file1.ts` - {brief description}
- `path/to/file2.ts` - {brief description}

### Architecture Decisions Made
- {Decision 1}: {brief rationale}

## In Progress

### Current Task
{What was being worked on when session ended}

### Blockers
- {Blocker 1}
- {Blocker 2}

## Next Steps

1. **Immediate**: {Next thing to do}
2. **Soon**: {Follow-up task}
3. **Later**: {Future consideration}

## Context for Next Session

### Key Understanding
{Critical context the next session needs}

### Watch Out For
- {Gotcha or consideration}

### Commands to Run
```bash
{Any setup commands needed}
  • {Link to relevant doc}
  • {Link to relevant code}

## Quick Handoff

For shorter sessions, use abbreviated format:

```markdown
# Quick Handoff: {Date}

**Working on**: {Current task}
**State**: {Ready to test | In progress | Blocked}
**Next**: {Immediate next step}
**Files**: `path/to/main/file.ts`

Usage

End of Session

/handoff

Resume Session

Read the latest handoff document:

/resume

Automatic Prompts

At natural breakpoints or when session is long:

"We've covered a lot. Should I create a handoff document in case we need to continue later?"

Integration with Scribe

Session continuity complements the scribe skill:

  • Scribe: Captures permanent knowledge (patterns, decisions, solutions)
  • Session Continuity: Captures temporary state (current work, next steps)

Best Practices

  1. Create handoff before ending - Don't wait until context is lost
  2. Be specific about state - "In progress" is less useful than "Added component, need tests"
  3. Prioritize next steps - Make it clear what to do first
  4. Include commands - Reduce friction for next session
  5. Reference files - Make it easy to find relevant code