Back to Skills

conduct-retrospective

pjt222
Updated 2 days ago
1 views
17
2
17
View on GitHub
Metadata

About

This Claude Skill automates project or sprint retrospectives by analyzing status reports and metrics to identify successes and areas for improvement. It generates structured, actionable items with assigned owners and due dates. Use it after sprints, milestones, incidents, or during quarterly reviews to systematically capture lessons learned.

Quick Install

Claude Code

Recommended
Primary
npx skills add pjt222/agent-almanac -a claude-code
Plugin CommandAlternative
/plugin add https://github.com/pjt222/agent-almanac
Git CloneAlternative
git clone https://github.com/pjt222/agent-almanac.git ~/.claude/skills/conduct-retrospective

Copy and paste this command in Claude Code to install this skill

Documentation

Conduct a Retrospective

Facilitate structured retrospective → review recent project exec, ID what worked + what didn't, produce actionable improvements w/ owners + due dates. Transforms raw project data → evidence-backed learnings w/ specific actions, owners, due dates.

Use When

  • End of sprint (sprint retrospective)
  • End of project phase / milestone
  • Post significant incident, failure, or success
  • Quarterly review of ongoing project procs
  • Before starting similar project (lessons learned review)

In

  • Required: Period under review (sprint number, date range, or milestone)
  • Optional: Status reports from review period
  • Optional: Sprint velocity + completion data
  • Optional: Prev retrospective actions (check closure)
  • Optional: Team feedback / survey results

Do

Step 1: Gather Retrospective Data

Read available artifacts from review period:

  • STATUS-REPORT-*.md files for period
  • SPRINT-PLAN.md for planned vs actual
  • BACKLOG.md for item flow + cycle times
  • Prev RETRO-*.md for open action items

Extract key facts:

  • Items planned vs completed
  • Velocity trend
  • Blockers encountered + resolution time
  • Unplanned work entering sprint
  • Open action items from prev retros

Data summary w/ quantitative metrics (velocity, completion %, blocker count).

If err: No artifacts → base retro on qualitative observations.

Step 2: Structure "What Went Well"

List 3-5 things that worked, w/ evidence:

## What Went Well
| # | Observation | Evidence |
|---|------------|---------|
| 1 | [Specific positive observation] | [Metric, example, or artifact reference] |
| 2 | [Specific positive observation] | [Metric, example, or artifact reference] |
| 3 | [Specific positive observation] | [Metric, example, or artifact reference] |

Focus on practices to continue, not outcomes. "Daily standups kept blockers visible" > "We delivered on time."

3-5 evidence-backed positive observations.

If err: Nothing went well → look harder. Small wins matter. At min, team completed period.

Step 3: Structure "What Needs Improvement"

List 3-5 things needing improvement, w/ evidence:

## What Needs Improvement
| # | Observation | Evidence | Impact |
|---|------------|---------|--------|
| 1 | [Specific issue] | [Metric, example, or incident] | [Effect on delivery] |
| 2 | [Specific issue] | [Metric, example, or incident] | [Effect on delivery] |
| 3 | [Specific issue] | [Metric, example, or incident] | [Effect on delivery] |

Specific + factual. "Estimation was off" = vague. "3 of 5 items exceeded estimates by >50%, adding 8 unplanned days" = actionable.

3-5 evidence-backed improvement areas w/ stated impact.

If err: Team claims everything fine → compare planned vs actual metrics → gaps reveal issues.

Step 4: Generate Improvement Actions

Each improvement area → actionable item:

## Improvement Actions
| ID | Action | Owner | Due Date | Success Criteria | Source |
|----|--------|-------|----------|-----------------|--------|
| A-001 | [Specific action] | [Name] | [Date] | [How to verify success] | Improvement #1 |
| A-002 | [Specific action] | [Name] | [Date] | [How to verify success] | Improvement #2 |
| A-003 | [Specific action] | [Name] | [Date] | [How to verify success] | Improvement #3 |

Each action must be:

  • Specific (not "improve estimation" but "add estimation review step to grooming")
  • Owned (one person accountable)
  • Time-bound (due date w/in next 1-2 sprints)
  • Verifiable (success criteria defined)

2-4 improvement actions w/ owners + due dates.

If err: Actions too vague → apply "how would you verify this was done?" test.

Step 5: Review Previous Actions + Write Report

Check prev retrospective actions for closure:

## Previous Action Review
| ID | Action | Owner | Status | Notes |
|----|--------|-------|--------|-------|
| A-prev-001 | [Action from last retro] | [Name] | Closed / Open / Recurring | [Outcome] |
| A-prev-002 | [Action from last retro] | [Name] | Closed / Open / Recurring | [Outcome] |

Flag recurring items (same issue appearing 3+ retros) → escalation or different approach needed.

Write complete retrospective:

# Retrospective: [Sprint N / Phase Name / Date Range]
## Date: [YYYY-MM-DD]
## Document ID: RETRO-[PROJECT]-[YYYY-MM-DD]

### Period Summary
- **Period**: [Sprint N / dates]
- **Planned**: [N items / N points]
- **Completed**: [N items / N points]
- **Velocity**: [N] (previous: [N])
- **Unplanned Work**: [N items]

### What Went Well
[From Step 2]

### What Needs Improvement
[From Step 3]

### Improvement Actions
[From Step 4]

### Previous Action Review
[From Step 5]

---
*Retrospective facilitated by: [Name/Agent]*

Save as RETRO-[YYYY-MM-DD].md.

Complete retrospective doc saved w/ actions, evidence, prev action review.

If err: Retro has no improvement actions → not driving change → revisit Step 3.

Check

  • Retro file created w/ date-stamped filename
  • Period summary includes quantitative metrics
  • "What Went Well" has 3-5 evidence-backed items
  • "What Needs Improvement" has 3-5 evidence-backed items
  • Improvement actions have owners, due dates, success criteria
  • Prev retro actions reviewed for closure
  • Recurring issues flagged

Traps

  • Blame game: Retros review procs + practices, not people. Frame issues systemic, not personal.
  • Actions w/o follow-through: Biggest retro failure. Always review prev actions before creating new.
  • Too many actions: 2-4 focused > 10 vague. Team can only absorb so many changes.
  • No evidence: "We feel estimation bad" = opinion. "3 of 5 items exceeded estimates by 50%" = data. Always attach evidence.
  • Skip positives: Only discussing problems demoralizing. Celebrating wins reinforces good practices.

  • generate-status-report — status reports provide data for retros
  • manage-backlog — improvement actions feed back into backlog
  • plan-sprint — retro learnings improve sprint planning accuracy
  • draft-project-charter — review charter assumptions + risk accuracy
  • create-work-breakdown-structure — review estimation accuracy vs. WBS

GitHub Repository

pjt222/agent-almanac
Path: i18n/caveman-ultra/skills/conduct-retrospective
0
agentsagentskillsai-assisted-developmentclaude-codeskillsteams

Related Skills

content-collections

Meta

This skill provides a production-tested setup for Content Collections, a TypeScript-first tool that transforms Markdown/MDX files into type-safe data collections with Zod validation. Use it when building blogs, documentation sites, or content-heavy Vite + React applications to ensure type safety and automatic content validation. It covers everything from Vite plugin configuration and MDX compilation to deployment optimization and schema validation.

View skill

polymarket

Meta

This skill enables developers to build applications with the Polymarket prediction markets platform, including API integration for trading and market data. It also provides real-time data streaming via WebSocket to monitor live trades and market activity. Use it for implementing trading strategies or creating tools that process live market updates.

View skill

creating-opencode-plugins

Meta

This skill helps developers create OpenCode plugins that hook into 25+ event types like commands, files, and LSP operations. It provides the plugin structure, event API specifications, and implementation patterns for JavaScript/TypeScript modules. Use it when you need to intercept, monitor, or extend the OpenCode AI assistant's lifecycle with custom event-driven logic.

View skill

sglang

Meta

SGLang is a high-performance LLM serving framework that specializes in fast, structured generation for JSON, regex, and agentic workflows using its RadixAttention prefix caching. It delivers significantly faster inference, especially for tasks with repeated prefixes, making it ideal for complex, structured outputs and multi-turn conversations. Choose SGLang over alternatives like vLLM when you need constrained decoding or are building applications with extensive prefix sharing.

View skill