SELF-AUDIT TOOLKIT FOR CLAUDE

brainrot

Your chat history already knows what Claude gets wrong for you.

Ten skills mine that record for corrections, ambiguity, drift and wins. An arbitration step makes the findings compete for scarce memory lines. One gated write lands the survivors.

INSTALL READ THE RUNBOOK

claude code

$ /plugin marketplace add coltonbearden/brainrot
$ /plugin install brainrot@brainrot

Or upload per-skill zips to the claude.ai app — see surfaces.

the problem

Persistent memory has a hard line cap and it is usually mostly spent. So the rules you keep are whichever ones you happened to write down, in whatever mood you were in, and they never get audited.

Meanwhile every correction you've ever typed — every "no, the other repo", every "you made that up", every "stop giving me fragments" — is sitting in your history as unexamined evidence.

mine history   ->  audit rules
     |                    |
     v                    v
 arbitrate      ->  ONE gated write
 (budget)            (memory-gc)

Candidate rules compete for scarce memory lines. It writes once, with your approval.

ten skills

Five of them propose rules. Two commands ship alongside: /brainrot:runbook and /brainrot:arbitrate.

memory-gc

Audit and consolidate persistent memory; verify volatile claims against history; single gated write.

rule-drift

Score adherence to your standing rules; verdict each KEEP / REINFORCE / REWRITE / RETIRE.

claim-audit

Find facts Claude asserted that you corrected; root-cause them; draft prevention rules.

ambiguity-preempt

Find clarify-loops and wrong guesses; draft standing disambiguation defaults.

friction-audit

Mine frustration and correction patterns; rank them; one remediation per pattern.

praise-miner

Find praised zero-correction outputs; extract the antecedents; draft do-more rules.

decision-ledger

Harvest real decisions — human commitments only — into one dated, conflict-checked ledger.

usage-retro

Sampled 7 or 30-day retrospective: correction rate, delegation ratio, trends.

skill-prospector

Find recurring task shapes worth packaging as skills; produce a scored backlog.

handoff-distill

Distill a session into a canonical handoff block with provenance gates.

the cleanup cycle

Ordering is not "cheap to expensive" — it's that the generators must not run before the auditors, or you blow the line budget and arbitrate under pressure. Pin one analysis window (default 30 days) and reuse it in every phase.

0 · BASE usage-retro (30d) Your before-picture; confirms the corpus has signal.

1 · TRUTH decision-ledger → rule-drift Read-only. Retirements here free the budget Phase 2 will need.

2 · MINE claim-audit → ambiguity-preempt → friction-audit → praise-miner Narrow to broad, so each pass reports only the residual.

3 · ARBIT /brainrot:arbitrate Cluster, score, fit to real headroom, veto gate.

4 · WRITE memory-gc The only phase that mutates state. Once.

5 · FWD skill-prospector → handoff-distill Seeds from post-GC memory, so it doesn't mine retired entries.

Don't attempt all ten in one thread — the mining skills are read-heavy and you'll run out of context mid-audit. Split at roughly Phase 1 / Phase 3 / Phase 5 and run handoff-distill at each boundary.

what a run looks like

rule-drift scores your existing rules against what actually happened, and gates every retirement on your confirmation. From the bundled fixture:

run rule drift

Rule drift audit — 2026-08-01
Window: 2026-07-02 -> 2026-08-01 · Coverage: FULL (41 chats)

| rule | verdict   | draft                                              |
|------|-----------|----------------------------------------------------|
| K1   | KEEP      | —                                                  |
| K2   | REINFORCE | "…state the assumed target inline before acting."  |
| K3   | RETIRE    | confirmed by user 2026-08-01                       |
| K4   | KEEP      | —                                                  |
| K5   | KEEP      | —                                                  |

That retired line is the whole point: it's the headroom the mining skills' proposals then compete for. Try a full arbitration pass against the fixture without touching your own memory:

/brainrot:arbitrate plugins/brainrot/fixtures/example-cycle

privacy and safety

This toolkit reads your conversation history. That deserves a straight answer.

NOTHING LEAVES

No telemetry, no network calls, no analytics, no external service. The skills are Markdown instructions; the scripts are local file operations.

READ-ONLY BY DEFAULT

Every skill is read-only until you approve a written before/after plan. memory-gc states the expected end-state count, waits, then re-reads to verify what landed.

EXPORTS STAY LOCAL

The export script writes conversations.json to your working directory, and .gitignore excludes it so an export is never committed by accident.

SENSITIVE CONTENT SKIPPED

Every mining skill carries a SKIPPED-SENSITIVE convention. Health, grief and crisis content is not surfaced, not summarized, not turned into a rule.

PROVENANCE GATES

An assistant suggestion never becomes a "decision" or a standing rule without an explicit human commitment. Unverifiable claims go to you for a ruling.

BUDGET HONESTY

Arbitration fits rules to real headroom and tells you when there is none, rather than smuggling rules past the cap.

surfaces

No past-chats tools in your environment? Every skill also runs against a conversations export — same lexicon, thresholds, gates and output format.

capability	claude.ai app	Claude Code	anywhere w/ export
History sweeps	native	—	via export pass
Export ("deep") mode	native (upload)	native (local file)	native
Memory staging	memory_user_edits (30-entry cap)	memory file, e.g. ~/.claude/CLAUDE.md	memory file
/brainrot:* commands	— (paste-in prompt)	native	—

layout

One plugin, ten skills, two commands. docs/build-prompts/ is the toolkit's provenance — one standalone build prompt per skill, usable as templates for building your own.

Validate locally with claude plugin validate . and the structural validator; both run in CI on every push.

.claude-plugin/marketplace.json   catalog
plugins/brainrot/                the plugin
  .claude-plugin/plugin.json
  skills/<name>/SKILL.md         ten audit skills +
                                 runbook, arbitrate
  docs/                          runbook, surfaces,
                                 arbitrate-prompt
  scripts/                       export, validate,
                                 package, banner
  fixtures/example-cycle/        worked input
docs/build-prompts/              provenance
assets/                          mascot + banner

faq

Where do I start?

Run usage-retro on a 30-day window. It tells you whether your history has enough correction volume for the mining skills to find signal — before you spend a session on a full cycle.

Do I need the claude.ai app?

No. The app's past-chats tools give the richest sweeps, but every skill also runs in export mode against a conversations.json, including one produced from local Claude Code history.

Will it overwrite my memory?

Only after you approve an explicit before/after plan, and only in memory-gc. Every other skill reports and stops.

Can I run all ten in one session?

Not usefully. The mining skills are read-heavy; split the cycle at the Phase 1 / 3 / 5 boundaries and carry state across with handoff-distill.

Is this an Anthropic product?

No. It's an independent, community-built plugin under MIT, with no affiliation with or endorsement from Anthropic.

How do I know it worked?

Re-run usage-retro 30 days later. Correction rate is the one number that should move if the new rules landed.

feed the zombie

Install it, run one cycle, and open an issue with what the audit missed. New skills should follow the build-prompt pattern in docs/build-prompts/.

STAR ON GITHUB CONTRIBUTE