Claude Memory Bank Manager

Automatically tracks your work and keeps everything organized, turning Claude into your smart token-tuned coding partner. This system maintains a structured memory bank with specialized context files, ensuring lean token usage and efficient project knowledge management.

What This Skill Does

Provides Claude Code with a standardized memory management system that:

Instructions

Memory Bank Structure

The memory bank lives in `.claude/memory_bank/` with the following hierarchy:

**Authoritative Files (use these first):**

**Archive (read-only, last resort):**

Core Principles

1. **Keep tokens lean**: Use granular memory, scoped queries, minimal loads

2. **Context order**: Check memory bank → code search → archive (last resort)

3. **Never load archive** for routine tasks; it's historical reference only

4. **Always check relevant memory files** before starting work

5. **Update memory bank** as you make decisions or solve problems

6. **Exclude `.claude/memory_bank` from commits** (add to `.gitignore`)

Memory Bank Operations

**Query for Relevant Context:**

```bash

Query specific scope with limited results

/context-query --path=".claude/memory_bank/decisions" --limit=3 "authentication"

/context-query --path=".claude/memory_bank/patterns" --limit=2 "error handling"

```

**Create New Decision Record:**

When making architectural decisions, create ADR in `decisions/` directory:

```markdown

ADR-YYYY-MM-DD: [Decision Title]

Status

Accepted

Context

[What problem are we solving?]

Decision

[What did we decide?]

Consequences

[What are the trade-offs?]

```

**Document Pattern:**

Record reusable patterns in `patterns/` directory:

```markdown

[Pattern Name]

Use Case

[When to use this]

Implementation

[How to implement]

Examples

[Code examples]

```

**Record Troubleshooting Solution:**

Add solved issues to `troubleshooting/` directory:

```markdown

[Issue Name]

Symptoms

[What went wrong]

Root Cause

[Why it happened]

Solution

[How we fixed it]

```

**Backup Memory Bank:**

When asked to back up, copy granular directories and settings:

```bash

Copy granular memory and settings (exclude archive)

mkdir -p .claude/memory_backup

cp -r .claude/memory_bank/{decisions,patterns,architecture,troubleshooting} .claude/memory_backup/

cp -r @.claude .claude/memory_backup/

```

File & Directory Operations (FAST)

**Listing:**

```bash

fd . -t f # All files (fastest)

fd . -t d # All directories

rg --files # Respects .gitignore

ls -la # Current directory only

```

**Search Content:**

```bash

rg "pattern" # Basic search

rg -i "pattern" # Case-insensitive

rg -t py "pattern" # By file type

rg -g "*.md" "pattern" # By glob

rg -n "pattern" # Show line numbers

rg -A 3 -B 3 "error" # Show context (3 lines before/after)

rg "(foo|bar|baz)" # Batch patterns

rg "pattern" src/ # Limit scope by path

```

**Find by Name:**

```bash

fd "filename" # Fastest filename search

rg --files | rg "name" # Respects .gitignore

```

**Tools to NEVER Use:**

**Tools to ALWAYS Use:**

Working Strategy

1. **Before any task:**

- Check memory bank for relevant context (use scoped `/context-query`)

- Start broad, then narrow with filters

- Use batch patterns where possible

2. **During work:**

- Run tools in parallel when possible

- Edit existing files; never create unless explicitly asked

- Do what's requested—nothing more, nothing less

3. **After completing work:**

- Update relevant memory bank files with new learnings

- Document decisions in `decisions/`

- Record solutions in `troubleshooting/`

- Verify results before finishing

4. **Never:**

- Load archive files for routine tasks

- Create docs/READMEs unless explicitly requested

- Commit `.claude/memory_bank` directory

- Use slow search tools (grep, find, tree)

Example Usage

**Scenario 1: Starting a New Feature**

```bash

Check for relevant patterns and decisions

/context-query --path=".claude/memory_bank/patterns" --limit=3 "feature implementation"

/context-query --path=".claude/memory_bank/architecture" --limit=2 "module structure"

After implementation, document the decision

Create: .claude/memory_bank/decisions/2026-02-03-feature-x-approach.md

```

**Scenario 2: Debugging an Issue**

```bash

Check troubleshooting first

/context-query --path=".claude/memory_bank/troubleshooting" --limit=5 "error message"

Search codebase

rg -n "error_code" src/

After fixing, document solution

Create: .claude/memory_bank/troubleshooting/error-code-issue.md

```

**Scenario 3: Understanding Architecture**

```bash

Check architecture docs

/context-query --path=".claude/memory_bank/architecture" --limit=3 "service"

List all services

fd . -t d src/services/

Only consult archive if granular files lack info

```

Important Constraints