claude-anti-mem
Claude gets things wrong in patterns. It invents library methods by analogy. It wraps a one-liner in argparse and logging. It assumes Snowfl
Open source Open in the app JSON README (API)
About
Claude gets things wrong in patterns. It invents library methods by analogy. It wraps a one-liner in argparse and logging. It assumes Snowflake when you said "dbt". Each mistake is usually obvious in hindsight, but Claude repeats the shape of the mistake across sessions because it has no record of them. claude-anti-mem fixes that with two skills working as a pair. anti-mem-collector writes: when you correct Claude, it logs the failure pattern to ~/.claude-anti-mem/anti-mem.md with a concrete Check: for next time. anti-mem-checker reads: before Claude commits to a substantive response, it consults the rap sheet and revises any draft that matches a logged failure. Plain markdown, no database, no daemon. Commit the rap sheet to a repo to share it with your team.
Details
- Kind
- Plugins
- Topic
- Databases
- Publisher
- markiv25
- Origin
- marketplace
- Category
- ferramentas
- Stars
- 1
- Last push
- 2026-04-21T03:21:18Z
- Repository state
- ativo
- License
- MIT
- Added
- 2026-08-30 01:48:58
- Updated
- 2026-08-30 01:48:58
- Origin id
markiv25/claude-antimem/claude-anti-mem
README
# claude-anti-mem
> A rap sheet for Claude. The opposite of memory — a persistent log of hallucinations, overkill, confusions, and wrong assumptions, consulted *before* Claude commits to an answer so it can course-correct away from its own known failure modes.
Where [claude-mem](https://github.com/thedotmack/claude-mem) remembers what went **right**, `claude-anti-mem` remembers what went **wrong** — and uses that log as a pre-flight check.
## Why
Claude gets things wrong in patterns. It invents library methods by analogy. It wraps a one-liner in argparse + logging. It assumes Snowflake when you said "dbt". It adds retries you never asked for. Each mistake is usually obvious in hindsight — but Claude makes the same *shape* of mistake over and over across sessions because it has no record of them.
`claude-anti-mem` fixes that with two skills that work as a pair:
- **anti-mem-collector** — when you correct Claude ("that's overkill", "you hallucinated that", "I didn't ask for that"), it appends a structured entry to the rap sheet.
- **anti-mem-checker** — before Claude commits to a response, it reads the rap sheet, checks whether the current plan matches a past failure pattern, and revises if so.
The rap sheet lives at `~/.claude-anti-mem/anti-mem.md` as plain markdown. You can read it, edit it, commit it to a repo, share it with a team.
## Install
### Claude Code (plugin)
```bash
/plugin marketplace add markiv25/claude-anti-mem
/plugin install claude-anti-mem
```
That's it. Both skills are registered, and the rap sheet directory is created on first use.
### Claude.ai (skills only)
Upload each skill from `skills/` individually via the skills UI:
- `skills/anti-mem-collector/`
- `skills/anti-mem-checker/`
The rap sheet in Claude.ai lives in the skill's own working area instead of `~/.claude-anti-mem/` — see [`docs/claude-ai.md`](docs/claude-ai.md) for details.
### Manual (any agent)
```bash
git clone https://github.com/<your-org>/claude-anti-mem ~/.claude-anti-mem/repo
ln -s ~/.claude-anti-mem/repo/skills/anti-mem-collector ~/.claude/skills/anti-mem-collector
ln -s ~/.claude-anti-mem/repo/skills/anti-mem-checker ~/.claude/skills/anti-mem-checker
```
## Quick start
1. Install (above).
2. Work normally with Claude. The checker runs silently before substantive responses.
3. When Claude gets it wrong, **tell it**. Natural phrases are enough:
- "that's overkill"
- "you made that function up"
- "I never said Snowflake"
- "you confused polars with pandas"
- "stop adding logging I didn't ask for"
4. The collector logs the failure. Next time Claude hits a similar-shaped task, the checker catches it.
## What the rap sheet looks like
```markdown
# Anti-Memory: Claude Failure Log
## [0001] 2026-04-20 — Overengineered a one-liner dedupe request
- **Category**: overkill
- **Trigger**: User said "quick script" for a task solvable in one expression.
- **Failure**: Produced 60 lines with argparse and logging for what was a single dict-comprehension.
- **Correction**: Match scaffolding to stated scope. "Quick" + obvious one-liner → give the one-liner.
- **Check**: If the user's request uses "quick", "simple", "one-liner", or has an obvious ≤5-line solution, do not add argparse, logging, error handling, or type annotations unless explicitly asked.
---
## [0002] 2026-04-20 — Invented polars method `pivot_wider` by analogy to tidyr
- **Category**: hallucination
- **Trigger**: User asked if library A has a feature from library B.
- **Failure**: Claimed `polars.DataFrame.pivot_wider` exists. Actual method is `.pivot(...)`.
- **Correction**: When asked whether library A has a feature from library B, don't assume naming parity.
- **Check**: Before asserting that a specific method/function exists on a library, confirm it matches the library's actual naming conventions; if cross-library analogy is involved, flag uncertainty.
---
```
## How the two skills interact
```
┌──────────────────────────────────────────────────────────────┐
│ You give Claude a task │
└───────────────────────────┬──────────────────────────────────┘
│
▼
┌─────────────────────────────┐
│ anti-mem-checker fires │
│ (reads ~/.claude-anti-mem/ │
│ anti-mem.md) │
└─────────────┬───────────────┘
│
┌─────────────┴───────────────┐
│ │
▼ ▼
draft matches a draft does NOT match
logged failure any logged failure
│ │
▼ ▼
Claude revises Claude responds
before responding normally
│ │
└─────────────┬───────────────┘
▼
┌─────────────────────────────┐
│ Claude's response │
└─────────────┬───────────────┘
│
▼
you say "that was wrong / overkill /
hallucinated / etc."
│
▼
┌─────────────────────────────┐
│ anti-mem-collector fires │
│ (appends new entry to │
│ anti-mem.md) │
└─────────────────────────────┘
```
## Repo layout
```
claude-anti-mem/ ← repo root = marketplace
├── .claude-plugin/
│ └── marketplace.json ← marketplace catalog
├── plugins/
│ └── claude-anti-mem/ ← the plugin itself
│ ├── .claude-plugin/
│ │ └── plugin.json ← plugin manifest
│ ├── skills/
│ │ ├── anti-mem-collector/
│ │ │ ├── SKILL.md
│ │ │ └── README.md
│ │ └── anti-mem-checker/
│ │ ├── SKILL.md
│ │ └── README.md
│ └── README.md ← plugin install notes
├── README.md ← you are here
├── LICENSE
├── docs/
│ ├── design.md ← why two skills, not one
│ ├── rap-sheet-format.md ← entry schema
│ ├── curation.md ← cleanup guide
│ └── claude-ai.md ← claude.ai install notes
└── examples/
└── anti-mem.md ← sample rap sheet
```
This follows the official Anthropic layout: the repo root is the marketplace, each plugin lives under `plugins/<name>/`, and plugins auto-discover `skills/` inside themselves.
## Design choices
- **Two skills, not one.** Writing happens on user correction; reading happens before every substantive response. Different triggers, different moments in the loop — keeping them separate keeps each SKILL.md focused and reduces false-triggers.
- **Plain markdown rap sheet.** Human-readable, greppable, diffable, commitable. No database, no daemon, no sync protocol.
- **One shared file** at `~/.claude-anti-mem/anti-mem.md` by default. Override with `CLAUDE_ANTI_MEM_PATH` env var if you want per-project rap sheets.
- **Append-only.** The collector only appends. Editing, reorganizing, and retiring entries is a manual (or future-curator-skill) job. This keeps the write path simple and the file auditable.
- **The `Check:` field is the whole game.** Every entry ends with an imperative the checker can apply. Vague entries ("be more careful") are useless — the skill's examples show how to write checks that actually prevent repeats.
See [`docs/design.md`](docs/design.md) for the longer version.
## Contributing
PRs welcome. The most useful contributions are:
- New anti-patterns with well-written `Check:` fields (drop them in `examples/anti-mem.md`).
- Sharper triggering descriptions — if you see the checker under-fire or the collector over-fire, open an issue with the transcript.
- A curator skill (the third skill this project doesn't have yet): periodically dedupe entries, retire stale ones, tag by domain.
## License
MIT. See [LICENSE](LICENSE).