I Built an AI Reflection Coach from My Claude Code Prompts

The problem

My journal catches the fires. The meeting that went badly. The deadline that moved. What it doesn't catch is the thing that quietly ate 40% of my week because it never felt like a crisis.

I use Claude Code for most of my work — not just coding, but writing, planning, research, strategy. On any given week, that's 500+ prompts across half a dozen projects. That's a detailed record of what I was actually thinking about, and none of it gets reflected on.

I wanted a way to reflect on what I actually did, not what I think I did.

What I built

A weekly retrospective system. Three parts:

1. A script reads Claude Code's local session logs and extracts my prompts from the last two weeks — what I asked, when, in which project. Just my questions. What you ask reveals your priorities more honestly than what you're told.
2. A skill feeds that data to Claude with a coaching brief. The brief doesn't ask for a summary. It asks Claude to be a coach — notice patterns, challenge stuck points, identify what I might be avoiding, and pull specific quotes as evidence.
3. A conversation. The coach presents its initial observations, then we discuss. I correct things it got wrong, add context it couldn't have known, answer its questions. Only after the discussion does it write up the final notes. The conversation is the point — the notes are the record.

I type /personal-retro:retro on a Friday afternoon. A few seconds later, I get something like this:

Themes I noticed

A single project consumed 60% of your prompts this week. You knew it was significant — but the data shows it crowded out three things you'd described as priorities the previous week.

Question for you: You said these were priorities. What would it have taken to protect time for them?

And this, from a section called "what you might be avoiding":

You have a review meeting in three days. You prepared extensively for a different stakeholder conversation last week — built a full preparation document. This meeting has had nothing comparable. This is the meeting where the topic you identified as "the biggest issue" would naturally come up.

That was a real observation. It was right. I hadn't prepared, and I should have been.

We go back and forth for a few minutes. I explain the context behind some of the patterns. The coach pushes back where I'm rationalising. Then, when I'm done, it writes the retro notes.

The full output covers: themes it noticed across my week (with quoted evidence), decisions still in motion, friction points, what I might be avoiding, a momentum check, and a single question to sit with. The conversation usually takes 5–10 minutes. The notes capture what we arrived at together — not just the raw initial read.

Why it works

The gap between intention and behaviour is measurable. When I say "this is my priority" on Monday but spend 12 hours on something else by Wednesday, the data shows it plainly. My journal wouldn't catch that — I'd remember the priority, not the drift.

The conversation adds what the data can't. The coach only sees my prompts — not the full picture. When I explain why something dominated my week, or what was happening behind a pattern, the retro gets sharper. Sometimes the initial read is wrong, and correcting it is itself revealing. That back-and-forth is what turns prompt analysis into actual self-coaching.

Continuity between weeks compounds. When the system says "last week's notes flagged this, and you still haven't addressed it" — that lands differently from noticing it yourself. You can't pretend you didn't know. The "one question to sit with" at the end often hits something I'd rather not think about. That's how I know it's calibrated right.

Try it

I've released this as a Claude Code plugin called personal-retro. If you have Claude Code with plugin support and Python 3 installed:

/plugin marketplace add georgethomasuk/georgethomas-marketplace
/plugin install personal-retro@georgethomas-marketplace

Then type /personal-retro:retro (or /personal-retro:retro 14 to look back further).

You'll need existing Claude Code session history — the plugin reads from ~/.claude/projects/, so if you've been using Claude Code for a week or more, you'll have data. The richer and more varied your prompts, the more the coach has to work with.

When you run it: the coach will present observations and ask you questions first. Have the conversation. Add context. Push back. When you're ready, tell it to write up the notes. That's the workflow — discussion first, document second.

What it won't do

It won't change your behaviour. I've had weeks where the notes surfaced a clear pattern — working late every evening, avoiding a hard conversation, over-indexing on one project — and I did exactly the same thing the following week.

But it removes the excuse of not knowing. And over time, the patterns become harder to ignore when they're written down with dates and evidence, week after week. Self-awareness isn't behaviour change — but it's where behaviour change starts.

---

For a walkthrough of how it works under the hood, keep reading. For most people, the install commands above are all you need.

How it works

The extraction script

Claude Code stores sessions as JSONL files in ~/.claude/projects/. Each project gets a directory, and each session is a .jsonl file containing timestamped messages.

The script is about 100 lines of Python. It walks those directories, filters messages to the last N days, extracts only your prompts, and outputs them as markdown — grouped by day, with timestamps and project names.

The output looks like this:

# Session Extract - Last 14 days
Total prompts: 487
Days active: 10

## 2025-03-10
**10:23** (my-project)
> Can we restructure the API to handle batch requests?

**10:45** (my-project)
> What about rate limiting — does the current middleware support it?

**14:12** (company-docs)
> Summarise the key risks from last quarter's review

For a typical week, this produces 20–40 pages of raw material. You don't read it yourself — the coaching prompt does.

The skill

Claude Code supports plugins — installable packages that add skills (slash commands) and other capabilities. The personal-retro plugin registers a skill invoked as /personal-retro:retro.

The skill file is a markdown document with YAML frontmatter. When you invoke it, Claude reads the instructions, runs the extraction script, and follows the coaching process:

1. Extract — run the bundled Python script to pull session data
2. Present observations — share initial themes, patterns, friction points with probing questions
3. Discuss — back-and-forth conversation where you add context, correct misreadings, answer questions
4. Write retro notes — only when you signal you're ready

The coaching stance instructions matter more than the output structure. The first version I wrote asked Claude to "summarise themes." It produced bland, safe output. When I changed it to "identify what I might be avoiding" and "be direct when something keeps coming back unresolved" — the quality jumped. Tell it to be a coach, not a secretary.

Adding the interactive discussion step was equally important. The coach only sees your prompts — it doesn't know why you spent all week on one project, or that a pattern it flagged was a deliberate choice. The conversation fills those gaps, and the final notes are much sharper for it.

Storing the output

The skill figures out where to save notes based on your project structure — if you already have a reflection-notes/ or similar directory, it uses that. Otherwise it asks. The default filename is retro-notes-YYYY-WNN.md (year and ISO week number). Nothing fancy. The value is in accumulation — when the system can reference previous notes, the observations get sharper over time.

Putting it together

1. Type /personal-retro:retro in Claude Code
2. Claude extracts your recent prompts and presents coaching observations
3. Discuss — answer questions, add context, push back
4. When you're ready, Claude writes the retro notes

The coaching prompt takes a few iterations to tune — adjust the stance until the output makes you slightly uncomfortable. That's how you know it's right.

---

Most people treat AI interactions as disposable — you get the output, you move on. But the prompts you write are a record of what you were trying to figure out, what problems you were wrestling with, what decisions you were circling. That's valuable data about your own work, and it's just sitting there.

The most useful AI tool I've built doesn't generate anything new. It holds up a mirror. It shows me what I already did, and asks whether that's what I intended.