Skip to main content
skill CX Codex

Context Preserver — Claude Code skill: what it does, how to install

Context Preserver — a skill that saves your working state to .adhd/context.json and brings it back after a break: the file, the line, the next step.

MIT 139 installs ★ 39 updated 2025-12-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add daffy0208/ai-dev-standards --skill context-preserver -a claude-code
Open on GitHub

What Context Preserver does

The skill keeps a running file, .adhd/context.json, holding the path and line you are in, the function under your cursor, the git branch, what you finished, what comes next and any blockers. Saves happen on their own every 15 minutes. Before a break you call ./save-context.sh --break lunch yourself, and each save drops a WIP micro-commit.

Picking work back up takes one command: ./resume.sh. It reopens the file at the right line, brings the dev server up, and prints the notes plus how far along the task is. Every 30 minutes the skill asks three short questions about the current task, the next step and whatever is in the way.

It was built for developers with ADHD, where switching tasks carries a real cost. The WIP commits do land in git history, so plan on squashing them before a pull request.

What it helps with

  • pick a task back up after lunch without rereading half the codebase
  • record the exact file and line you stopped on
  • write down blockers before you walk away
  • restore the branch, dev server and terminal state
  • keep working memory free when you switch tasks often

Example prompts for the agent

  • Save my context before I take a break — file, line and next step.
  • Resume where I left off and open the file at the right line.
  • Ask me the three questions and write the answers to .adhd/context.json.

How to install Context Preserver

1Skills CLI (Vercel)

npx skills add daffy0208/ai-dev-standards --skill context-preserver -a claude-code

2Manually: put the files in place

~/.claude/skills/context-preserver/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/context-preserver/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about Context Preserver

How do I install Context Preserver in Claude Code?

Run npx skills add daffy0208/ai-dev-standards --skill context-preserver -a claude-code. The skill file lands at ~/.claude/skills/context-preserver/SKILL.md.

What does Context Preserver do?

It writes your working state to .adhd/context.json every 15 minutes and on a manual save before a break, then restores the file, cursor position and the notes about what came next.

Where does the saved context live?

In .adhd/context.json inside the project: the current file and position, related files, branch, plans, blockers and task progress.

Source text

SKILL.md · MIT
---
name: Context Preserver
description: Automatically save and restore development context to minimize cognitive load when resuming work. Use when switching tasks, taking breaks, or returning after interruptions. Captures mental state, file locations, and next steps. Designed for ADHD developers with high context-switching costs.
version: 1.0.0
---

# Context Preserver

**Never lose your place. Resume in 5 minutes. Eliminate "Where was I?" moments.**

## Core Principle

ADHD brains have high context-switching costs and limited working memory. Every interruption means 15-30 minutes of "getting back into it." The solution: Automatically capture and restore mental state so you can resume work in under 5 minutes.

**Key Insight:** The act of saving context is therapeutic - it signals "I can stop safely."

---

## The Context Problem

### Problem 1: High Context-Switching Cost

**Issue:** After breaks, spend 15-30 min remembering what you were doing
**Result:** Lost productivity, frustration, avoidance of breaks

###Problem 2: Working Memory Limits
**Issue:** Can't hold complex state in mind
**Result:** Constant re-reading code, forgetting next steps

### Problem 3: Interruption Anxiety

**Issue:** Fear of losing place prevents taking needed breaks
**Result:** Burnout, health issues, reduced quality

### Problem 4: "Where Was I?" Syndrome

**Issue:** Return to work with no idea what you were doing
**Result:** Thrashing, starting over, wasted time

---

## Phase 1: Automatic Context Capture

### What Gets Saved (Auto-Every 15 Minutes)

**File Context:**

- Current file path
- Line number and function
- Related files (imports, dependencies)
- Git branch

**Mental State:**

- What you were thinking
- What you just finished
- What you're about to do
- Blockers or questions

**Environment:**

- Dev server status
- Open terminals
- Database state
- API keys loaded

**Time Context:**

- When you started
- How long you've been working
- When you plan to stop

### Automated Saves

#### Trigger 1: Every 15 Minutes (Background)

```markdown
[15:30] Auto-save triggered

Context saved:

- File: src/components/login.tsx:42
- Function: handleSubmit()
- Status: Adding API call
- Next: Error handling for 401
- Time working: 45 min

✅ Saved to .adhd/context.json
✅ Micro-commit created (WIP)
```

#### Trigger 2: Before Breaks (Manual Command)

```bash
# You run: ./save-context.sh --break lunch

Context saved for lunch break:
- Current task: Implementing password reset
- Progress: 70% complete
- File: src/auth/reset.ts:67
- Next step: Test email delivery
- Resume command ready: ./resume.sh

✅ Safe to take break!
```

#### Trigger 3: On Claude Session End (Auto)

```markdown
[Session ending]

Preserving your context:

- Saved current task
- Created WIP commit
- Noted next 3 steps
- Logged session progress

Resume anytime: Just start new Claude session
Context will load automatically
```

#### Trigger 4: On Interruption (Auto-Detect)

```markdown
[No activity detected for 10 min]

Looks like you got interrupted!
Auto-saved context:

- Last active: 10 min ago
- Working on: Dashboard layout
- File: src/pages/dashboard.tsx:125
- Next: Add user stats widget

When you return: Context ready to resume
```

---

## Phase 2: Context Structure

### The .adhd/context.json File

```json
{
  "timestamp": "2025-10-22T15:30:00Z",
  "session": {
    "started": "2025-10-22T14:00:00Z",
    "duration_minutes": 90,
    "breaks_taken": 1,
    "focus_sessions": 3
  },
  "files": {
    "current": {
      "path": "src/components/login.tsx",
      "line": 42,
      "column": 12,
      "function": "handleSubmit",
      "content_preview": "async function handleSubmit(e: FormEvent) {"
    },
    "related": ["src/api/auth.ts", "src/types/user.ts"]
  },
  "mental_state": {
    "doing": "Adding API call to /auth/login endpoint",
    "just_finished": "Added email validation",
    "next_steps": [
      "Add fetch call to /auth/login",
      "Handle 401/500 errors",
      "Add loading state to button"
    ],
    "blockers": ["Need to check API error format"],
    "notes": "Using fetch (not axios) per team standard"
  },
  "environment": {
    "branch": "feature/auth-flow",
    "uncommitted_changes": true,
    "dev_server_running": true,
    "last_command": "npm run dev"
  },
  "progress": {
    "current_task": "Build authentication flow",
    "phase": "Phase 2: API Integration",
    "percent_complete": 60,
    "estimated_remaining": "45 minutes"
  }
}
```

---

## Phase 3: Automatic Context Restoration

### Quick Resume (< 5 Minutes)

#### One-Command Resume

```bash
# You run: ./resume.sh

╔══════════════════════════════════════╗
║  Resuming Work Session              ║
║  Last saved: 12:15 PM (1 hour ago) ║
╚══════════════════════════════════════╝

📂 Restoring context...

✅ Opened: src/components/login.tsx
✅ Cursor positioned: Line 42
✅ Dev server started
✅ Git branch: feature/auth-flow

💭 You were:
  - Adding API call to /auth/login
  - Just finished: Email validation
  - Next: Handle 401/500 errors

📊 Progress: 60% complete
⏱️ Estimated remaining: 45 minutes

🎯 Next micro-task: Add fetch call (15 min)

[Opens file at exact line in VS Code]
[Starts dev server]
[Shows mental state notes]

✅ Ready to code! Resume time: 4 minutes
```

### Claude Automatic Resume

When you start new Claude session:

```markdown
You: [start new session]

Claude: Welcome back! I see you were working on authentication flow.

Let me catch you up:

📍 Last Location:
File: src/components/login.tsx:42
Function: handleSubmit()

💭 Mental State (from 1 hour ago):

- You were adding API call to /auth/login
- Email validation is done ✅
- Next: Handle 401/500 errors

📊 Progress: 60% complete (Phase 2/3)

🎯 Quick options:
A) Resume where you left off (add fetch call)
B) See full context (detailed notes)
C) Start something new

What would you like to do?
```

---

## Phase 4: Mental State Capture Techniques

### Capturing "What Were You Thinking?"

#### The 3-Question Method (Auto-Prompted)

Every 30 minutes, Claude asks:

```markdown
[Quick context check - 1 minute]

To help you resume later:

1. What are you working on right now?

   > Adding password reset functionality

2. What's the next small step?

   > Test email delivery locally

3. Any blockers or questions?
   > Need to configure SendGrid API key

✅ Saved! This will help Future You.
```

#### Stream-of-Consciousness Notes

```markdown
## Mental State Notes (Auto-saved)

15:00 - Started password reset feature
15:15 - Generated reset token, stored in DB
15:30 - Building email template now
15:35 - Wondering if I should use SendGrid or Postmark
15:40 - Going with SendGrid (already have account)
15:45 - Configured API key, testing send...
[Break]

Resume thoughts:

- Was about to test email delivery
- SendGrid configured, key in .env
- Next: Trigger reset email from form
```

### Breadcrumb Trail

```markdown
## Breadcrumb Trail (Auto-generated)

14:00 ✅ Created reset-password.tsx
14:15 ✅ Added form with email input
14:30 ✅ Connected to /api/reset-password
14:45 ✅ Generated reset token
15:00 ✅ Stored token in database
15:15 🔄 Building email template ← YOU ARE HERE
15:30 ⬜ Test email delivery
15:45 ⬜ Add reset confirmation page

You're making great progress! 🎉
```

---

## Phase 5: Context-Aware Workflows

### Before-Break Checklist (Auto-Triggered)

```markdown
[You haven't saved context in 45 min]

⏸️ Taking a break soon?

Quick save checklist:

- [ ] Commit current work (WIP okay!)
- [ ] Write next step (one sentence)
- [ ] Note any blockers
- [ ] Close unneeded tabs (reduce clutter)

Takes 2 minutes, saves 20 minutes later!

[Save Context Now] [Remind Me in 15m] [I'm not taking a break]
```

### End-of-Day Ritual (Auto-Prompted at 5pm)

```markdown
[17:00] End of day approaching!

🌙 Let's wrap up for easy tomorrow start:

1. Current Progress:
   Built authentication flow
   Progress: 75% complete
   Status: Working well, needs testing

2. Tomorrow's First Task:
   → Test password reset flow (30 min)
   → File: src/auth/reset.ts
   → Should be quick!

3. Blockers for Tomorrow:
   None! Ready to go.

4. Wins Today:
   ✅ Completed login form
   ✅ Added validation
   ✅ Connected to API
   ✅ Fixed bug #234

5. Mental Dump:
   [Anything else to remember?]
   > Remember to check email error handling

✅ Context saved! Tomorrow You will thank you. 🙏

[Finish Day] [Keep Working]
```

---

## Phase 6: Git Integration

### Automated Micro-Commits

Every context save creates a WIP commit:

```bash
# Auto-runs every 15 min
git add .
git commit -m "WIP: $(cat .adhd/context.json | jq -r '.mental_state.doing') [15:30]"

# Example commits:
git commit -m "WIP: Adding API call to login endpoint [15:30]"
git commit -m "WIP: Testing password reset flow [15:45]"
git commit -m "PAUSE: About to add error handling [16:00]"
```

### Resume from Git History

```bash
# See what you were doing
git log -1 --pretty=%B

# Output:
WIP: Testing password reset flow [15:45]

# Context notes:
- File: src/auth/reset.ts:67
- Next: Add error toast for failed reset
- Blocker: None
```

---

## Phase 7: Interruption Handling

### Types of Interruptions

#### Type 1: Meetings (Scheduled)

```markdown
[14:45] Meeting in 15 minutes

Auto-save triggering:

- Current work committed
- Context snapshot created
- Resume script generated

After meeting: Run ./resume.sh
Estimated resume time: 5 minutes
```

#### Type 2: Urgent Bug (Unplanned)

```markdown
You: "Urgent bug in production, need to switch"

Claude: No problem! Let me save your context first.

✅ Saved: Authentication flow work
✅ Stashed: Uncommitted changes
✅ Switched: To main branch

Work on the bug, I'll help you resume after.

Resume command: ./resume-auth-work.sh
```

#### Type 3: Loss of Focus (ADHD Wander)

```markdown
[You've been browsing docs for 20 min]

💭 Gentle reminder:

You were working on: Password reset form
Current file: src/auth/reset.tsx:45
Next step: Add email input field (5 min)

Research is good, but maybe time to apply?

[Resume Coding] [Continue Research] [Take Break]
```

---

## Phase 8: Advanced Context Features

### Context Sharing

```bash
# Share context with teammate
./export-context.sh

Generated: context-snapshot.md

Send this to teammate for pairing:
- What you're working on
- Current progress
- What you need help with
- Exact file locations
```

### Context History

```markdown
# View past contexts

./context-history.sh

Recent Work Sessions:

1. 2025-10-22 14:00 - Auth flow (90 min) ✅ Completed
2. 2025-10-22 10:30 - Dashboard UI (2 hours) 🔄 In progress
3. 2025-10-21 15:00 - Bug fix #234 (45 min) ✅ Completed

[Load Context] [Delete] [Archive]
```

### Smart Context Suggestions

```markdown
[Starting new session]

Claude: I notice you often work on:

- Authentication (70% of time)
- Dashboard UI (20%)
- Bug fixes (10%)

Would you like to:
A) Resume auth flow (where you left off)
B) Continue dashboard work (60% complete)
C) Check open bugs
D) Start something new

Based on your patterns, auth flow is most likely.
```

---

## Phase 9: Context Patterns

### Pattern 1: Deep Work Session

```markdown
[Session Start]
Auto-save every: 15 minutes
Break reminders: Every 60 minutes
Context snapshots: On demand

[Session End]
Final save includes:

- Total focus time
- Tasks completed
- Progress made
- Tomorrow's start point
```

### Pattern 2: Context-Switching Project

```markdown
Project A → Project B

Auto-stash Project A:

- Commit WIP
- Save context
- Close related tabs

Load Project B:

- Restore last context
- Open relevant files
- Show next task

Switch time: < 5 minutes
```

### Pattern 3: Pair Programming

```markdown
Before pairing:

- Export current context
- Share with partner
- They see exactly what you're doing

After pairing:

- Update context with decisions made
- Log next steps
- Easy solo resume
```

---

## Automation Scripts

### Setup (One-Time)

```bash
cd your-project
mkdir .adhd
cp ~/ai-dev-standards/TEMPLATES/adhd/scripts/* ./
chmod +x .adhd/*.sh

# Scripts installed:
# - save-context.sh (manual save)
# - resume.sh (quick resume)
# - context-history.sh (view history)
# - export-context.sh (share with team)
```

### Daily Usage (All Automatic)

```bash
# Morning: One command start
./resume.sh

# During work: Auto-saves every 15 min
# (runs in background)

# Before break: Quick save
./save-context.sh --break lunch

# After break: One command resume
./resume.sh

# End of day: Auto-prompted at 5pm
# (saves automatically)
```

---

## Anti-Patterns

### ❌ Manual Context Notes

**Bad:** Expecting yourself to manually write notes
**Why:** ADHD brain won't do it consistently
**Good:** Automated saves every 15 min

### ❌ Perfect Documentation

**Bad:** Writing detailed status reports
**Why:** Wastes time, won't be maintained
**Good:** Stream-of-consciousness quick notes

### ❌ Single Context File

**Bad:** Overwriting same context file
**Why:** Loses history, can't go back
**Good:** Timestamped history, can browse past contexts

---

## Success Metrics

You're using this skill well when:

- ✅ Resume time < 5 minutes (from 30 minutes before)
- ✅ Never ask "where was I?"
- ✅ Take breaks without anxiety
- ✅ Context auto-saves (you don't think about it)
- ✅ Easy to switch between projects

---

## Related Skills

- **task-breakdown-specialist** - Breaks down next steps
- **focus-session-manager** - Manages work sessions
- **adhd-workflow-architect** - Designs automated workflows

---

**Save your place. Eliminate anxiety. Resume in 5 minutes.** 💾

© daffy0208 · MIT · daffy0208/ai-dev-standards

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set63

The whole set →
Task Breakdown Specialist Task Breakdown Specialist slices heavy development tasks into 2-minute and 15-minute micro-steps with built-in time buffers to lower activation energy and stop procrastination. CX Codex +1 149installs BMAD Method The BMAD Method skill connects a product’s business model to architecture, cost planning, and growth stages. Use it when starting a product, redesigning a system, or weighing a custom build against a service. CX Codex +1 149installs Deployment Advisor Deployment Advisor guides infrastructure selection and CI/CD setup based on runtime requirements, database needs, and traffic scale. CX Codex +1 145installs Go-to-Market Planner The Go-to-Market Planner skill structures product launches around positioning, messaging, channels, timing, and metrics. Use it when entering a market or preparing a campaign. CX Codex +1 145installs User Researcher User Researcher runs a full user research cycle, from research questions and recruitment to personas and a report. Useful when product assumptions need checking before code gets written. CX Codex +1 138installs System Diagnostician System Diagnostician runs automated repository diagnostics, spots structural and security gaps, and produces an action plan ranked by impact and effort. CX Codex +1 138installs Framework Orchestrator The Framework Orchestrator skill maps frameworks and other skills to project phases. Use it when you need a project pattern, an ordered plan, or phase checks. CX Codex +1 136installs release-manager release-manager turns a risky deploy into stages: internal team first, then 5% of beta users, then everyone. Comes with feature flags, canary deploys and rollback rules. CX Codex +1 135installs

Project sponsors

Companies that keep this analytics open