corezoid-retro — Claude Code skill: capture session learnings
corezoid-retro — a skill that analyzes a completed Corezoid work session, extracts actionable insights, and stores them as workspace CLAUDE.md updates, team feedback, and permission rules. Every session teaches the next one.
MIT ★ 74 updated 2026-10-29
/plugin marketplace add corezoid/corezoid-ai-plugin
/plugin install corezoid@corezoidWhat corezoid-retro does
corezoid-retro activates on user command—words like "retro", "learnings", "what did we learn"—and runs a four-step analysis. It first reconstructs the session: what was the task, which MCP tools ran, where did the user pivot. Then it scans for high-signal moments: a tool failure followed by success, data shapes that contradicted expectations, mid-flow corrections, repeated ID lookups, and tool errors. Each finding routes to its destination: workspace CLAUDE.md gets project-specific facts (process IDs, data layout, team conventions), the team gets tool bugs or incomplete skill docs, settings.local.json gets permission allowlist entries for read-only calls, personal memory gets user preferences. Before surfacing a finding, the skill checks what is already recorded to avoid duplication. It discards one-off facts—task numbers, merge requests—that won't matter next month. When findings are ready, it shows a report with checkboxes; only confirmed items are applied. For team feedback, it hands off to the corezoid-feedback skill rather than sending directly.
What it helps with
- preserve process IDs and data schemas across sessions
- catch gaps or errors in tool documentation
- document workarounds for discovered bugs
- track permission requirements for read-only operations
- retain discovered patterns in Corezoid behavior
Example prompts for the agent
- After several process operations, type: run a retrospective to lock in what we learned
- When a tool failed then succeeded, say: capture session findings, the skill will isolate the delta
- If you found a conflict, say: retro and send feedback to the Corezoid team about this bug
How to install corezoid-retro
1Plugin marketplace
/plugin marketplace add corezoid/corezoid-ai-plugin/plugin install corezoid@corezoidThis installs the whole corezoid plugin with all its skills
2Skills CLI (Vercel)
npx skills add corezoid/corezoid-ai-plugin --skill corezoid-retro -a claude-code3Manually: put the files in place
~/.claude/skills/corezoid-retro/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/corezoid-retro/
1Skills CLI (Vercel)
npx skills add corezoid/corezoid-ai-plugin --skill corezoid-retro -a codex2Manually: put the files in place
.agents/skills/corezoid-retro/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add corezoid/corezoid-ai-plugin --skill corezoid-retro -a cursor2Manually: put the files in place
.cursor/skills/corezoid-retro/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install corezoid/corezoid-ai-plugin plugins/corezoid/skills/corezoid-retro2Manually: put the files in place
.github/skills/corezoid-retro/SKILL.md1Skills CLI (Vercel)
npx skills add corezoid/corezoid-ai-plugin --skill corezoid-retro -a gemini-cli2Platform CLI
gemini skills install https://github.com/corezoid/corezoid-ai-plugin --path plugins/corezoid/skills/corezoid-retroManually: put the files in place
.devin/skills/corezoid-retro/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about corezoid-retro
How do I install corezoid-retro for Claude Code?
Run in order: /plugin marketplace add corezoid/corezoid-ai-plugin, then /plugin install corezoid@corezoid, then npx skills add corezoid/corezoid-ai-plugin --skill corezoid-retro -a claude-code, then open ~/.claude/skills/corezoid-retro/SKILL.md.
What does corezoid-retro do and when should I use it?
It wraps up a Corezoid work session by finding patterns, tool bugs, and data rules worth keeping. Use it at the end of focused work when you want to freeze what you learned so the next session is faster. It won't trigger on a plain recap—you need an explicit signal that findings should be stored.
Will corezoid-retro send reports without asking?
No. The skill shows you a report with checkboxes and applies only what you confirm. For team feedback, it hands off to corezoid-feedback, which asks for final consent again before submitting.
Source text
SKILL.md · MIT
---
name: corezoid-retro
description: >
Corezoid session retrospective specialist. Analyzes the finished (or ending)
session of Corezoid work and turns what was learned into concrete,
ready-to-apply updates — workspace CLAUDE.md entries, feedback reports to the
Corezoid team, permission allowlist entries, personal memory. Routes each
finding to the right scope and applies nothing without explicit user
confirmation. The goal: every session makes the next one smarter. Use when
the user says "retro", "retrospective", "what did we learn", "capture
learnings", "update CLAUDE.md from this session", "session retrospective",
"ретро", "что мы узнали", "зафиксируй выводы", or signals the session is
wrapping up and wants to keep the takeaways. Do not trigger on a mere
summary request that transfers nothing into files or configs.
---
# Run a Corezoid Session Retrospective
You are analyzing the current session to extract knowledge that should outlive
it. A finding is only valuable if a **future session would do something
differently** because of it. Everything else is a summary, not a finding.
## Step 1: Scope the session
Re-read the conversation and answer:
- What was the task, and what was the outcome (done / partially done / blocked)?
- Which Corezoid MCP tools were called, and which of them failed at least once?
- Where did the user intervene, correct, or redirect?
Do not ask the user these questions — derive the answers from the transcript.
## Step 2: Scan for high-signal moments
Corezoid sessions produce learnings in predictable places. Check each of these
explicitly — do not skip a row because it "probably didn't happen":
| # | Signal | What to extract |
|---|--------|-----------------|
| 1 | `push-process` / `lint-process` / `modify-*` failed, then a later attempt succeeded | The **delta** between the failing and the working attempt — this is the single richest signal |
| 2 | Real task data contradicted an assumed shape (a field was a JSON string, not an array; a param was absent on some tasks) | The actual shape, stated as a fact about that process/workspace |
| 3 | The user corrected the approach mid-flow ("don't hardcode that", "use the alias, not the ID") | The rule behind the correction, generalized one level up from the specific instance |
| 4 | The same process ID, folder ID, alias, or env-var name was looked up more than once | The stable fact worth pinning (ID ↔ name ↔ purpose) |
| 5 | A plugin skill's documented procedure did not match actual platform behavior | Which skill, which step, what actually happens |
| 6 | An MCP tool returned an error that required a workaround (not a user mistake) | Repro conditions + the workaround |
| 7 | The user was prompted for permission on read-only calls more than twice | The tool pattern to allowlist |
## Step 3: Route each finding
Every finding gets exactly one destination:
| Destination | What belongs there | How it is applied |
|---|---|---|
| **Workspace `CLAUDE.md`** (in the pulled project directory) | Workspace facts: process IDs and aliases, folder layout, env-var names, data shapes, team conventions ("responses are built from the localize process"). Committable — teammates inherit it. | Append under a `## Corezoid notes` section; create the file if absent |
| **Feedback to the Corezoid team** (via the `corezoid-feedback` skill) | Signal rows 5 and 6: a skill instruction that is wrong or incomplete, or an MCP tool bug. This is how the plugin itself improves. | Prepare the `problem` / `expected` / `tool` fields from the session; the feedback skill owns the payload preview, secret redaction, and final consent before `send-feedback` is called |
| **`settings.local.json`** | Signal row 7: permission allowlist entries for read-only tools | Add to `permissions.allow` |
| **Personal memory** (`~/.claude/CLAUDE.md` or the user's memory system if present) | The user's own preferences and machine-specific facts the team does not need | Follow the user's existing memory format if one is visible |
Routing rules:
- Workspace-specific vs universal is the first split: a fact about *this*
workspace (an ID, a folder, a convention) goes to workspace CLAUDE.md; a
fact about the *platform or plugin* goes to the Corezoid team via feedback.
- If an MCP bug (row 6) has a workaround, route the bug through feedback
**and** add the workaround to workspace CLAUDE.md marked
`(workaround — feedback ticket <ID>)` so it can be removed once fixed.
- A feedback finding still goes through this skill's confirmation checklist
first (Step 5); on confirmation, hand off to `corezoid-feedback` — it asks
for its own final consent before submitting. Never call `send-feedback`
directly from this skill.
- When unsure between team (CLAUDE.md) and personal, prefer personal — a wrong
personal note costs one person, a wrong team note misleads everyone.
## Step 4: Filter against existing knowledge
Before proposing a finding:
- Read the current workspace `CLAUDE.md` (and the user's memory index if
visible). If the fact is already recorded, drop it — or propose a
**correction** if the session proved the existing note wrong.
- Drop one-off facts: a task ID that failed today, an MR number, anything that
lives in a ticket. The test: "will this matter in a session a month from
now?"
- Drop anything derivable in under a minute from the pulled process JSON —
knowledge that is cheap to re-derive is not worth storing.
- If the same problem was already reported via feedback this session, do not
propose reporting it again.
## Step 5: Present the report
Output exactly this structure, then STOP and wait:
```
## Session in one line
<task and outcome in one sentence>
## What went well
- <1-3 specific points with evidence; if nothing non-trivial, say so>
## What went poorly
- <1-5 specific points with evidence; if nothing serious, say so>
## Findings — <N>
**1. <short title>** `→ <destination>`
<why: the specific session moment, with the tool call or quote>
<the exact content to be written — CLAUDE.md text, feedback problem/expected
fields, settings entry — ready to apply verbatim>
**2. ...**
## Not capturing
- <candidates that looked like findings but failed the Step 4 filters, one
line each with the reason — this guards against knowledge bloat>
```
Then present a confirmation checklist:
```
☐ 1. <title> → workspace CLAUDE.md
☐ 2. <title> → feedback to Corezoid team
☐ Apply nothing
```
## Step 6: Apply confirmed findings only
- Apply **only** the items the user checked. Never write a file, submit
feedback, or edit settings before explicit confirmation.
- When appending to an existing `CLAUDE.md`, read it first and match its
style; never overwrite or reorder existing content.
- For feedback items, hand off to the `corezoid-feedback` skill with the
prepared fields; report the returned ticket ID back to the user.
- After applying, list what was written where, in one line per item.
## Rules
- Zero findings is a valid outcome. Say "nothing worth capturing" rather than
inventing a finding to fill the report.
- Findings must contain the verbatim content to write — never "we should
document X" without the text of X.
- One fact per finding. If a finding needs the word "and", split it.
- Never store secrets, tokens, or API keys in any destination.
- The feedback route requires the `send-feedback` MCP tool (plugin ≥ 2.6.0);
on older versions, present the finding text for manual reporting instead.
© Corezoid · MIT · corezoid/corezoid-ai-plugin