.------------------------------------------------.
| retro-bot says: "Always leave things better |
| than you found them!" |
'------------------------------------------------'
\
|
[■]
.----------.
|[══] [══]|
| |
| .------. |
| |======| |
'----------'
.-------------.
| |
| ✓ | ✗ | ↻ |
| retro-bot |
'-------------'
|| ||
_|| ||_
[__] [__]
retro-bot
"Always leave things better than you found them."
An agile retrospective skill for your Claude collaboration sessions.
Capture what you learned. Apply the fix. Make the next session better.
Continuous improvement = continuous tokenmaxxing.
How it fits into your workflow
You finish a Claude session — a document build, a data analysis, a code review, a content
draft, whatever the work was. Instead of closing the window and letting the friction
evaporate, you type:
"let's do a retro on that session"
Ten minutes later: the fix is applied, the snapshot is saved, and the next session starts
smarter. That's it. retro-bot handles the rest.
The problem
If you've worked in Agile, working with Claude should feel familiar. Especially as a
product owner, your core skill is articulating what you want built, and that maps
directly to getting great outputs from Claude. The clearer the brief, the better the
output. Same principle, different medium.
I've found one valuable element from Agile that was missing for me: the retrospective.
Retrospectives are the point of origination for iteration. It's where you clear the air,
get on the same page, align on what worked and what didn't, and commit to the specific
changes that carry those lessons forward. It invites self-reflection and a collective
approach to improvement. In a Claude workflow, its value can compound due to the more
rapid cycles of creation and iteration.
Without a deliberate improvement loop, every session carries the same overhead. You
re-establish context that should already be there. You hit the same friction you hit
last week. Learnings either evaporate or get dumped into one bloated file that creates
its own problems. Token budgets inflate. Output quality plateaus, and you end up with
an inflated, unwieldy prompt instead of a systemic approach to incremental improvement
in the right places.
Most people optimize the prompt. The best teams optimize the process.
retro-bot brings the retrospective loop to Claude.
What it does
After any Claude session, retro-bot runs a structured retrospective with you, and
then does something most people haven't thought about: it routes each improvement to
exactly the right layer of your Claude setup.
There are four places where context and instructions live in a Claude workflow:
| Layer | What lives here |
|---|
| 🔧 Skill | How a specific capability is configured |
| 📋 Project | What Claude knows about this engagement |
| 📝 Claude.md | Persistent context that applies across all sessions |
| 💡 Process | Behavioral agreements: how you and Claude work together |
Most people know they should "update their prompts" after a session. What's less
obvious is where the fix belongs. Without a clear answer, everything ends up
dumped into one bloated global file. retro-bot figures out the right scope and applies
the change on the spot, versioned and recorded. That's the part most retro frameworks
skip. retro-bot doesn't.
✓ What worked well → keep doing this
✗ What didn't work → find the root cause
↻ What to change → apply it to the right layer, right now
Every retro saves a dated snapshot. A running audit log tracks every session, every
improvement, every outcome: a permanent record of how your Claude setup has evolved
and why.
After ten retros, you can look back and see exactly how your setup has evolved. The
prompts are tighter. The skills are smarter. The sessions are faster. Your tokens go
further. That's compounding. Call it tokenmaxxing.
The audit trail
This is what your retro log looks like after a few sessions:
# Retro Log
