home / skills / athola / claude-night-market / catchup

catchup skill

This skill helps you quickly grasp what changed and why, enabling smooth handoffs and informed sprint planning.

npx playbooks add skill athola/claude-night-market --skill catchup

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

Files (4)

SKILL.md

4.0 KB

---
name: catchup
description: 'Use this skill to quickly understand "what changed and what matters".
  Use when resuming work after absence, preparing handoff documentation, reviewing
  sprint progress, analyzing git history for context. Do not use when doing detailed
  diff analysis - use diff-analysis instead. DO NOT use when: full code review needed
  - use review-core instead.'
category: analysis-methods
tags:
- summarization
- context-acquisition
- insights
- follow-ups
dependencies:
- imbue:evidence-logging
tools:
- git
- log-tools
usage_patterns:
- context-catchup
- handoff-preparation
- progress-review
complexity: intermediate
estimated_tokens: 700
progressive_loading: true
module_strategy: context-based
---
## Table of Contents

- [Overview](#overview)
- [When to Use](#when-to-use)
- [Activation](#activation)
- [Progressive Loading](#progressive-loading)
- [4-Step Methodology](#4-step-methodology)
- [Output Format](#output-format)

# Catchup Analysis Methodology

## Overview

Structured method for quickly understanding recent changes in git repositories, meeting notes, sprint progress, document revisions, or system logs. Answers "what changed and what matters?" efficiently.

## When To Use
- Joining ongoing work or returning after absence
- Before planning or reviewing handoffs
- Any "what happened and what's next" context

## When NOT To Use

- Doing detailed
  diff analysis - use diff-analysis instead
- Full code review needed
  - use review-core instead
- Doing detailed
  diff analysis - use diff-analysis instead
- Full code review needed
  - use review-core instead

## Activation
**Keywords**: catchup, summary, status, progress, context, handoff
**Cues**: "get me up to speed", "current status", "summarize progress"

## Progressive Loading

Load modules based on context:

**Git**: Load `modules/git-catchup-patterns.md` for git commands. Consider `sanctum:git-workspace-review` for initial data gathering.

**Documents/Notes**: Load `modules/document-analysis-patterns.md` for meeting notes, sprint tracking, document revisions.

**Logs/Events**: Load `modules/log-analysis-patterns.md` for time-series and metric analysis.

**Always Available**: `imbue:evidence-logging`, TodoWrite workflow, structured output.

## Required TodoWrite Items
1. `catchup:context-confirmed` - Boundaries established
2. `catchup:delta-captured` - Changes enumerated
3. `catchup:insights-extracted` - Themes identified
4. `catchup:followups-recorded` - Actions captured

## 4-Step Methodology

### Step 1: Confirm Context
Define scope (git branch, sprint, meetings), baseline (last state), and current target. See modules for commands.

### Step 2: Capture Delta
Enumerate changed items with metrics. Prioritize source/config/docs over generated artifacts. See modules for strategies.

### Step 3: Extract Insights
Per item: **What** (change), **Why** (motivation), **Implications** (tests/risks/deps). Rollup into themes.

### Step 4: Record Follow-ups
Capture: Tests, Documentation, Reviews, Blockers, Questions. If none, state explicitly.

## Output Format
```
## Summary
[2-3 sentence theme + risk overview]

## Key Changes
- [Item]: [what/why/implication]

## Follow-ups
- [ ] [Action with owner]

## Blockers/Questions
- [Item requiring resolution]
```
**Verification:** Run the command with `--help` flag to verify availability.

## Integration
Use `imbue:diff-analysis` for risk assessment, `imbue:evidence-logging` for reproducibility, `sanctum:git-workspace-review` for git data. Feed to `brainstorming` or `writing-plans` as needed.

## Token Conservation
Reference paths + lines (don't reproduce). Summarize outputs. Defer deep analysis. Use progressive loading.

## Exit Criteria
- Four TodoWrite items completed
- Context/delta/insights/follow-ups captured
- Stakeholders understand state without re-reading sources
## Troubleshooting

### Common Issues

**Command not found**
Ensure all dependencies are installed and in PATH

**Permission errors**
Check file permissions and run with appropriate privileges

**Unexpected behavior**
Enable verbose logging with `--verbose` flag

Overview

This skill helps you quickly understand “what changed and what matters” across code, documents, meeting notes, or logs. It summarizes recent deltas, highlights risks and implications, and captures concrete follow-ups so you can resume work or prepare handoffs without deep diffing. Use it for fast orientation rather than exhaustive review.

How this skill works

The skill loads only the modules needed for the context (git, documents, or logs) and runs a four-step method: confirm context, capture the delta, extract insights, and record follow-ups. It prioritizes source/config/docs, produces concise themes and itemized implications, and outputs a short checklist of actions and blockers. It defers deep diffs to a dedicated diff-analysis workflow and integrates with evidence logging and workspace review modules.

When to use it

Returning to a project after days or weeks away
Preparing handoff notes for a teammate or next sprint
Quickly assessing recent git history for context before planning
Reviewing meeting notes and sprint updates to find action items
Scanning logs or events to surface recent impactful changes

Best practices

Define clear scope and baseline before analysis (branch, time window, or sprint)
Prioritize source, config, and docs over generated artifacts
Capture metrics for each changed item (lines, tests affected, files) to aid triage
Summarize per-item: what changed, why it likely happened, and implications/risks
Record explicit follow-ups and owners; if none, state that none are needed

Example use cases

Get up to speed on a feature branch before taking over development
Create a concise handoff summary when leaving a sprint mid-cycle
Summarize recent PRs and commits for a standup or planning meeting
Turn meeting notes and design docs into a prioritized follow-up list
Rapidly surface risky changes from recent deploy logs to inform quick rollbacks

FAQ

When should I not use this skill?

Do not use it for detailed diff-by-diff code review or security audits; use the dedicated diff-analysis or review-core workflows instead.

What outputs can I expect?

A short summary with 2–3 theme sentences, an itemized list of key changes with implications, a follow-up checklist with owners, and any blockers or open questions.

How much detail will it include?

It provides focused context and risks sufficient to resume work or create handoffs. It intentionally omits deep line-by-line diffs and long reproductions to conserve tokens.