# Wrap Up

> End-of-task wrap-up routine. Run after completing a feature or fix to verify, review learnings, update backlog, commit+push, and suggest the next task.

- Skill: `vbrevik/wrap-up` (Agent Skill)
- Install (CLI): `npx skillmds@latest add vbrevik/wrap-up`
- Raw SKILL.md: https://api.skillmd.com/api/skills/vbrevik/wrap-up/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Product & Planning
- Author: vbrevik (https://skillmd.com/u/vbrevik)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/vbrevik/wrap-up

---


Run this checklist sequentially after completing a task. Each step must finish before the next begins.

## Step 1: Verify & Test

- Run `cargo build` and confirm it compiles cleanly (warnings are OK, errors are not).
- If the task touched UI, take a Playwright screenshot of the affected page(s) to visually verify.
- If there are automated tests, run them. If no tests exist for the changed code yet, note that as a gap but do NOT write tests unless the user asks.
- Summarize: **Build status**, **Test status**, any issues found.

## Step 2: Learnings Review

Reflect on the task just completed. Be honest and specific, not generic. Cover:

- **What went well?** — approaches that saved time or produced clean results.
- **What should have been done differently?** — wasted effort, wrong assumptions, dead ends.
- **Patterns worth remembering** — new gotchas, Askama quirks, Actix-web behaviors, CSS tricks, D3.js lessons, or other reusable knowledge.

Present this as a short bullet list (3-6 bullets), not a wall of text.

**Action required:** Don't just list learnings — persist them. For each learning, apply the highest-matching tier:

| Tier | Destination | Bar |
|------|-------------|-----|
| **1. CLAUDE.md** | `CLAUDE.md` Gotchas or Key Patterns section | New framework quirk, workflow pattern, or architectural rule that would save ≥1 hour for *any* future developer/session in this repo. High bar — only framework-level or project-wide gotchas belong here. |
| **2. Auto-memory** | `MEMORY.md` or a topic file | Session-recurrent patterns, project-specific conventions, or architectural insights that are more specific to how this project is structured and how we work. |
| **3. Backlog** | `docs/BACKLOG.md` Architecture Decisions | Project-level design decisions worth tracking but not broad enough for CLAUDE.md. |
| **4. Skip** | — | Truly session-specific; won't help future work. |

When writing to **CLAUDE.md**: place the learning in the most relevant existing section (Gotchas & Quirks, Key Patterns, etc.). If no section fits, add a minimal new subsection. Keep it concise — one short example or one-liner is enough.

State which tier was applied for each learning.

## Step 3: Update Backlog

- Read `docs/BACKLOG.md`.
- Move the completed task from "Remaining Backlog" to "Completed Work" (or update its status).
- If the task revealed new work items, add them to the appropriate section.
- If the implementation order diagram needs updating, update it.
- Summarize what changed in the backlog.

## Step 4: Commit & Push

- Run `git status` and `git diff --stat` to see what changed.
- Stage relevant files (be specific, avoid `git add .`).
- Write a concise commit message that focuses on what was added/changed and why.
- Commit and push to the current branch.
- Show the commit hash and push result.

## Step 5: Suggest Next Task

- Re-read the "Implementation Order" and "Remaining Backlog" sections of `docs/BACKLOG.md`.
- Recommend the single highest-priority next task with a 1-2 sentence rationale.
- Ask the user if they want to proceed with it.

## Step 6: Clear Context Window

- Inform the user that you're clearing the context window to start fresh.
- Use the `/clear` command to clear the conversation context.
- This ensures a clean slate for the next task without accumulated context weight.

## Step 7: Run Catch-Up

- Invoke the `catch-up` skill to initialize fresh context for the next session.
- This loads current project state, recent changes, and prepares for the next task.
- The catch-up skill will read the updated backlog and recent commits to understand what was just completed.

## Output Format

Use this structure so the user can scan quickly:

```
### Verify
[build/test summary]

### Learnings
- bullet 1 → [CLAUDE.md | memory | backlog | skip]
- bullet 2 → [CLAUDE.md | memory | backlog | skip]
- ...

### Backlog Updated
[what moved/changed]

### Committed
[commit hash] [message]
Pushed to [branch]

### Next Up
[task name] — [rationale]
Proceed?

### Clearing Context
Clearing context window for a fresh start...
/clear

### Starting Fresh
[Running catch-up skill to initialize next session]
```

ARGUMENTS: Optionally pass a short description of what was just completed, e.g. `/wrap-up added graph toolbar to concepts tab`. If no argument is given, infer from recent conversation context.