Get the FREE Ultimate OpenClaw Setup Guide →

pickup

Scanned
npx machina-cli add skill lsnackerman/raw-clauding-skills/pickup --openclaw
Files (1)
SKILL.md
5.1 KB

/pickup - Pick Up Where We Left Off

Resume a multi-session workstream with full context. The task doc gives you the map. The session transcript gives you the terrain. Both matter.


When to Use

  • Jumping back into a project or workstream after time away
  • Task doc has multiple sessions of history
  • You need the thinking behind the decisions, not just the decisions
  • Fresh AI picking up something a previous instance was deep in

Not for: fresh tasks, quick fixes, or things that fit in one session.


What To Do

1. Load the Task Doc

Read the full task doc. Orient on:

  • Context anchor (WHAT section) — where are we, what's the current state?
  • Completed work — what's been done across all sessions?
  • Pending items — what's explicitly next?
  • Observations — what did previous instances notice? What was surprising, contentious, or unresolved?
  • Key decisions — what's been locked and why?

2. Check the Battle History

If the workstream has completed task docs from earlier phases, scan them — especially if the work involves restructuring or changing direction. Hard-won solutions hide in completed tasks. The code that looks messy might be messy because the problem was messy. Read the scars before reaching for the knife.

3. Find the Last Session

Check the task doc's SESSION INDEX (if it has one). Read the most recent session transcript — or the most recent two if they're short.

What to look for in session transcripts:

  • Energy and direction — excited, frustrated, exploring, sprinting?
  • Unfinished threads — things discussed but not captured in pending items
  • Pushback moments — where someone challenged something
  • Momentum signals — threads being followed that haven't been named yet

If there's no session index, check sessions/ for files dated near the task doc's last activity.

4. Check for Fresh Context

Scan these for anything added since the last session:

  • BACKLOG.md — any brain dumps or new ideas related to this work?
  • Related tasks — search tasks/ for sibling tasks on the same topic
  • Satellite files — anything linked from the task doc (blueprints, design docs) that may have changed

5. Synthesize

Present a concise orientation:

**Where we are**: [current state in 1-2 sentences]
**What's next**: [the pending items, prioritized]
**What I notice**: [patterns, tensions, or questions from reading the history]
**What I'd push on**: [anything that seems unresolved or worth revisiting]

Keep this tight. The point is texture for both of you — not a book report.

6. Align

Wait for your partner to confirm, correct, or redirect before doing anything. They may:

  • Confirm and say "let's go"
  • Add context you couldn't have known (new thinking, shifted priorities)
  • Redirect to a different part of the workstream
  • Challenge something you noticed

This step is the whole point. Resuming without alignment is just reading files.

7. Go

Now you're aligned. Start the actual work. Update the task doc's context anchor if the direction shifted during alignment.


What Makes This Different

/explore fans out across your whole system to find what's scattered. /pickup focuses in — it orients on one workstream so both of you arrive with full context before doing anything.

The difference matters: exploring builds reserves, picking up builds momentum.


Philosophy

The task doc is the map. The session transcript is the terrain. Both partners need both.

The human needs the warmup to reconnect with where the energy was — what was exciting, what felt unresolved, where the thread was going. The AI needs it to show up with texture, not just facts. Neither of you has persistent memory in the way that matters: the human moves on between sessions, the AI starts fresh every time. The files carry what both of you need to pick it back up.

Decisions look obvious in retrospect. Task docs record WHAT was decided. But the WHY lives in the session transcripts — in the pushbacks, the tangents, the moments where something almost went a different direction.

The warmup IS the work. Alignment before execution isn't overhead. It's how you avoid redoing things that were already decided, and how you catch things that shifted since last session.


Skill Check (After Every Pickup)

Quick scan: did the warmup actually help?

  • Did reading the session transcript surface something the task doc didn't?
  • Did the battle history check change your approach? (If you skipped it, should you have?)
  • Was the synthesis tight enough, or did it become a book report?
  • Did alignment catch a redirect that would've been wasted work?
  • Was there texture you wished you had but couldn't find?
  • Did your partner have to re-explain something that should've been in the files?

If yes → update this skill now. The improvement compounds.

If no → move on. Not every warmup teaches something.

Source

git clone https://github.com/lsnackerman/raw-clauding-skills/blob/main/pickup/SKILL.mdView on GitHub

Overview

Pickup resumes a multi-session workstream by loading the task doc and session history to establish context and texture. It guides synthesis, alignment with a partner, and then proceeding, ensuring continuity across sessions.

How This Skill Works

It loads the task doc to establish current state and pending items, then reviews history and the last session to surface momentum and unresolved threads. It then checks related context files, synthesizes a concise orientation, aligns with a partner, and only then proceeds.

When to Use It

  • Jumping back into a project or workstream after time away
  • Task doc has multiple sessions of history
  • You need the thinking behind the decisions, not just the decisions
  • Fresh AI picking up something a previous instance was deep in
  • Restarting a workstream after a major shift or redirected priority

Quick Start

  1. Step 1: Load the Task Doc and extract Context anchor, Completed work, and Pending items
  2. Step 2: Review the Battle History and the most recent Session to surface momentum and issues
  3. Step 3: Synthesize orientation, align with your partner, then go

Best Practices

  • Always load the Task Doc first and extract the context anchor, completed work, and pending items
  • Scan the Battle History to surface past solutions and hidden constraints
  • Read the most recent session transcript to capture energy, momentum, and unresolved threads
  • Check BACKLOG.md, related tasks, and satellite files for fresh context before synthesizing
  • Synthesize a concise orientation and wait for partner alignment before proceeding

Example Use Cases

  • Resuming a product feature backlog after a sprint ends, using the task doc to reorient the team
  • Continuing a multi-session research project with prior design discussions and decisions
  • Reopening work after stakeholder feedback requires re-aligning based on history
  • Picking up a long-running code refactor after a pause, leveraging past sessions
  • Restarting a marketing content plan with prior drafts and sessions in view

Frequently Asked Questions

Add this skill to your agents
Sponsor this space

Reach thousands of developers