Automate Sprint Retrospective Reports with Claude Code

It's Friday afternoon. Your sprint ends in an hour. You've got 47 Jira tickets to sort through, half of them have vague titles like "Fix the thing" and "API updates," and you need to produce a retrospective report that actually tells the team what happened over the last two weeks.

So you start copying ticket titles into a Google Doc. You cross-reference the sprint board for carryover items. You dig through Slack for context on why that one ticket got blocked. You write a summary paragraph. You format the blockers section. An hour and a half later, you've got a document nobody will read carefully because the meeting starts in 10 minutes and everyone just skims it anyway.

I've watched this play out dozens of times with PMs in my ClaudeFluent training. The retro prep eats your Friday afternoons. The actual conversation (the part that matters) gets squeezed into whatever time is left. Claude Code flips that ratio by automating the report so you can spend your time on the discussion.

What Data You Need

A retro report needs four things: what shipped, what carried over, what blocked progress, and velocity trends. All of that data already exists in your project management tool. You just need to pull it out.

Here's what to export from Jira or Linear:

• Completed tickets: Key, title, assignee, story points, date completed, labels/epic
• Carryover tickets: Anything that was in the sprint but didn't get marked Done
• Blocked tickets: Anything flagged as blocked during the sprint, with the blocker reason if your tool tracks it
• Sprint metadata: Sprint name, start date, end date, team name

Both Jira and Linear let you export to CSV. Jira's board export grabs everything in the current sprint. Linear's cycle view does the same.

The CSV Export Format

Here's the format Claude expects. If your tool exports slightly different column names, that's fine; Claude will figure it out:

key,title,status,assignee,story_points,epic,labels,date_completed,blocker_reason
PROJ-142,Add CSV export to reports,Done,Sarah,3,Reporting,feature,2026-02-28,
PROJ-155,Fix pagination on customer list,Done,Marcus,2,Customer Portal,bug,2026-02-27,
PROJ-161,Salesforce OAuth integration,In Progress,Sarah,8,Integrations,feature,,
PROJ-163,Update billing webhook handler,Done,Alex,3,Billing,tech-debt,2026-03-01,
PROJ-170,Mobile responsive dashboard,Blocked,Marcus,5,Dashboard,feature,,Waiting on design specs from brand team
PROJ-172,Rate limiter for public API,Done,Alex,5,Platform,infrastructure,2026-02-26,
PROJ-175,Customer onboarding email sequence,In Review,Jordan,3,Onboarding,feature,,
PROJ-178,Fix timezone bug in analytics,Done,Sarah,1,Reporting,bug,2026-02-25,
PROJ-180,Database index for search queries,Done,Alex,2,Platform,performance,2026-03-01,
PROJ-183,Add filter by date range,Carry Over,Jordan,3,Reporting,feature,,

The Project Setup

Same pattern as any Claude Code workflow. Set up the folder once, reuse it every sprint:

sprint-retros/
├── CLAUDE.md
├── .claude/
│   └── skills/
│       └── retro-report-writer.md
├── data/
│   └── sprint-47-tickets.csv
└── output/
    └── (generated retro reports go here)

Your CLAUDE.md

Give Claude the context it needs about your team and how your sprints work:

# Sprint Retro Report Generator

## Our Team
- Product team: 2 squads (Platform and Product)
- Sprint cadence: 2-week sprints, Monday to Friday
- Point scale: Fibonacci (1, 2, 3, 5, 8, 13)
- Velocity target: 35-40 points per sprint per squad

## Report Audience
- Engineering managers want: velocity trends, blocker patterns, carryover rate
- Product leadership wants: what shipped (customer-facing), what's at risk
- The team wants: honest recap, recognition for hard work, clear action items

## Definitions
- Carryover: ticket was in sprint but not completed (In Progress or In Review)
- Blocked: ticket was flagged as blocked at any point during the sprint
- Velocity: total story points completed
- Completion rate: completed points / committed points

The Skill File

This goes in .claude/skills/retro-report-writer.md and defines the exact format of your retro doc. Customize this to match whatever your team actually uses. Read the skills guide if you haven't set these up before:

# Retro Report Writing Skill

## Report Structure

### 1. Sprint Summary (3-4 sentences)
- Sprint name, dates, team
- Total points committed vs completed
- Completion rate as a percentage
- One-sentence highlight

### 2. What Shipped (grouped by epic/area)
- List each completed ticket with: key, title, assignee, points
- Group by epic or label category
- Bold any customer-facing features
- Include total points per group

### 3. Carryover Items
- List each incomplete ticket with: key, title, assignee, points, current status
- Note why it carried over if context is available
- Flag any ticket that has carried over for 2+ sprints

### 4. Blockers
- List each blocked ticket with: key, title, blocker reason
- Categorize blockers: cross-team dependency, technical, design, external
- Suggest action items for recurring blocker categories

### 5. Velocity Snapshot
- Points committed vs completed
- Completion rate
- If historical data is provided, show trend over last 3-4 sprints

### 6. Discussion Prompts
- Generate 3-4 specific questions for the retro conversation
- Base these on patterns in the data (e.g., "3 of 4 blockers were
  cross-team dependencies — should we change how we coordinate?")
- Make them specific, not generic

## Formatting Rules
- Use markdown headers and bullet points
- Keep it scannable — no paragraphs longer than 2 sentences
- Bold the key numbers (velocity, completion rate, carryover count)
- Use tables only for the shipped items list

The Prompt That Generates the Report

Drop your sprint CSV into the data/ folder, open Claude Code, and run:

Read data/sprint-47-tickets.csv.

This is Sprint 47 (Feb 17 - Feb 28, 2026) for the Product squad.
We committed to 38 points at sprint planning.

Generate a full retro report following the retro-report-writer skill.
Save it to output/sprint-47-retro.md.

Pay special attention to blocker patterns — we've had recurring
cross-team dependency issues and I want to surface that clearly.

Claude reads every ticket, groups them, calculates velocity, categorizes blockers, and produces a formatted report. The whole thing takes about 60 seconds.

What the Output Looks Like

Here's a condensed version of what Claude produces:

# Sprint 47 Retrospective — Product Squad
**Feb 17 – Feb 28, 2026**

## Sprint Summary
Sprint 47 completed **27 of 38 committed points (71% completion rate)**.
The team shipped 6 tickets across Reporting, Billing, and Platform.
One ticket was blocked on cross-team design dependencies. Two items
carried over, including the date range filter that was originally
committed in Sprint 46.

---

## What Shipped

### Reporting (6 points)
| Key | Title | Assignee | Points |
|-----|-------|----------|--------|
| PROJ-142 | **Add CSV export to reports** | Sarah | 3 |
| PROJ-178 | Fix timezone bug in analytics | Sarah | 1 |

### Platform (7 points)
| Key | Title | Assignee | Points |
|-----|-------|----------|--------|
| PROJ-172 | Rate limiter for public API | Alex | 5 |
| PROJ-180 | Database index for search queries | Alex | 2 |

### Billing (3 points)
| Key | Title | Assignee | Points |
|-----|-------|----------|--------|
| PROJ-163 | Update billing webhook handler | Alex | 3 |

### Customer Portal (2 points)
| Key | Title | Assignee | Points |
|-----|-------|----------|--------|
| PROJ-155 | Fix pagination on customer list | Marcus | 2 |

**Total shipped: 18 points across 6 tickets**

---

## Carryover Items
- **PROJ-183** — Add filter by date range (Jordan, 3 pts)
  ⚠️ Second consecutive sprint as carryover. Originally Sprint 46.
- **PROJ-175** — Customer onboarding email sequence (Jordan, 3 pts)
  Currently in review. Should close early Sprint 48.
- **PROJ-161** — Salesforce OAuth integration (Sarah, 8 pts)
  In progress. Large scope; may need to be split.

**Total carryover: 14 points (37% of committed)**

---

## Blockers
- **PROJ-170** — Mobile responsive dashboard (Marcus, 5 pts)
  **Category: Cross-team dependency**
  Blocked on design specs from brand team. Requested Feb 19, still pending.

**Action item:** Schedule a weekly 15-min sync with Brand to unblock
design requests within 48 hours instead of letting them sit in a queue.

---

## Velocity Snapshot
- **Committed:** 38 points
- **Completed:** 27 points (includes 9 points of unplanned work pulled in)
- **Completion rate:** 71%
- **Carryover rate:** 37%

---

## Discussion Prompts
1. PROJ-183 has carried over two sprints. Is the scope right, or
   should we break it into smaller deliverables?
2. Cross-team design dependency blocked 5 points this sprint. What
   process change would prevent this from recurring?
3. We pulled in 9 points of unplanned work (PROJ-163, PROJ-180).
   Should we leave more buffer in sprint planning?
4. Jordan has 6 points of carryover. Is there a capacity or
   context-switching issue we should address?

Those discussion prompts at the bottom are what makes this valuable. Claude doesn't just summarize tickets. It spots patterns in the data and turns them into questions that actually drive a useful retro conversation.

Connecting to Jira or Linear Directly

If you want to skip the CSV export, Claude Code can pull data from APIs using MCP servers. For Jira, the prompt looks like this:

Connect to our Jira instance (credentials in .env) and pull all
tickets from sprint "Product Sprint 47".

Include: key, summary, status, assignee, story points, epic,
labels, resolution date, and any flagged blockers.

Then generate the retro report following the retro-report-writer skill.

For Linear, swap the Jira reference for Linear's cycle API. The output is identical either way.

Building a Velocity Trend Over Time

The retro report gets even better when you feed it historical data. After a few sprints, your data/ folder has multiple CSV files. Add this to your prompt:

Also read the retro reports from the last 3 sprints in the output/
folder. Add a velocity trend section comparing Sprint 45, 46, and 47.
Flag any declining trends or recurring blocker categories.

Now Claude produces a trend chart (in markdown table format) and highlights patterns across sprints. If cross-team dependencies blocked tickets three sprints in a row, it'll call that out explicitly.

Common Mistakes

Not including blocker reasons. If your CSV just shows "Blocked" without a reason, Claude can't categorize blockers or suggest action items. Take 5 minutes to add blocker notes before running the report. Or better yet, enforce blocker reasons in your Jira workflow so they're always captured.

Treating the report as the retro. The report is prep, not a replacement for the conversation. The best retros I've seen use Claude's report as a shared context doc that everyone skims in the first 2 minutes, then spend the remaining 28 minutes on the discussion prompts.

Forgetting to iterate. If Claude misgroups a ticket or the discussion prompts feel generic, tell it. "PROJ-161 should be in the Integrations group, not Platform. And make the discussion prompts sharper, specifically about the Jordan carryover situation." Two follow-up prompts and you've got exactly the report you want.

The Biweekly Workflow

1. Thursday afternoon: Export your sprint CSV from Jira or Linear (2 minutes).
2. Run Claude Code with the retro prompt (60 seconds).
3. Scan the output. Fix any misgroups or add context Claude missed (10 minutes).
4. Share the report with the team before the retro meeting.
5. Run the retro. Use Claude's discussion prompts as your agenda. Spend the full meeting on conversation, not status updates.

Total prep time: 15 minutes. You were spending 90 minutes. That's over an hour back every two weeks, which adds up to more than 25 hours a year. More importantly, your retros get better because you're walking in with data-driven questions instead of a hastily assembled ticket list.

Get Started

New to Claude Code? The step-by-step tutorial will get you set up in 10 minutes. Already running? Create the folder structure above and try it with your current sprint.

Want to build a full suite of PM automations like this? ClaudeFluent is the premium training program where I teach PMs, PMMs, and operators how to wire up real workflows with Claude Code. Retro reports, feature prioritization, competitive intel, and more. Join the next cohort and reclaim your Friday afternoons.