memory-management

What this skill does

# Memory Meta

## 🚨 MANDATORY: Invoke docs-management First

> **STOP - Before providing ANY response about Claude Code memory (CLAUDE.md):**
>
> 1. **INVOKE** `docs-management` skill
> 2. **QUERY** using keywords: CLAUDE.md, static memory, memory hierarchy, import syntax, or related topics
> 3. **BASE** all responses EXCLUSIVELY on official documentation loaded
>
> **Skipping this step results in outdated or incorrect information.**

### Verification Checkpoint

Before responding, verify:

- [ ] Did I invoke docs-management skill?
- [ ] Did official documentation load?
- [ ] Is my response based EXCLUSIVELY on official docs?

If ANY checkbox is unchecked, STOP and invoke docs-management first.

## Meta-skill for Claude Code memory system - 100% driven by official documentation

> **Zero Duplication Policy**
>
> This skill contains ZERO duplicated content from official documentation. ALL implementation details delegate to the `docs-management` skill using natural language queries. This skill provides stable principles and navigation that won't change, while docs-management provides current official guidance.

## Overview

This meta-skill provides stable principles, keyword registries, and patterns for working with Claude Code's memory system (CLAUDE.md files, static memory). It does NOT duplicate official documentation - instead, it teaches you how to efficiently query the `docs-management` skill for any memory-related information you need.

**What this skill provides:**

- Stable principles that won't change (timeless guidance)
- Keyword registry for efficient documentation lookups
- Common organization patterns
- Quick decision trees for navigation
- Troubleshooting guidance

**What this skill delegates to docs-management:**

- Current import syntax specifications
- Exact file locations and paths
- Version-specific behaviors
- Implementation details that may evolve
- Complete best practices documentation

## When to Use This Skill

This skill should be used when:

- **Working with CLAUDE.md files** - Creating, editing, or organizing memory
- **Memory hierarchy questions** - Understanding enterprise/project/user/local precedence
- **Import syntax questions** - How to import files, @ syntax, recursive lookup
- **Progressive disclosure patterns** - Organizing always-loaded vs on-demand content
- **Memory organization** - Hub-and-spoke, token budgets, cross-references
- **Best practices lookup** - Efficient queries to find official guidance

## Stable Principles (Won't Change)

These principles are fundamental to how LLMs and memory systems work. They won't change even as Claude Code's implementation evolves.

### 1. Progressive Disclosure

**Principle:** Load context on-demand, not everything upfront.

**Why stable:** Context windows are finite resources. This is a fundamental LLM constraint that won't change.

**Application:**

- Always-loaded content should be minimal and high-signal
- Detailed content loads only when needed
- Hub files link to detailed references

### 2. Strategic Emphasis

**Principle:** Use emphasis keywords (CRITICAL, NEVER, MUST, IMPORTANT) strategically for must-follow rules.

**Why stable:** Human communication patterns for priority signaling are universal.

**Application:**

- Reserve emphasis for truly critical rules
- Don't overuse (dilutes effectiveness)
- Use consistently across your memory files

### 3. Specificity Over Vagueness

**Principle:** "Use 2-space indent" beats "format code properly"

**Why stable:** Specific instructions are universally more actionable than vague ones.

**Application:**

- Concrete examples over abstract guidance
- Exact commands over general directions
- Measurable criteria over subjective standards

### 4. Structure Aids Parsing

**Principle:** Bullets, headings, and clear organization improve comprehension.

**Why stable:** Both humans and LLMs process structured content more effectively.

**Application:**

- Use markdown headings consistently
- Bullet points for lists of items
- Tables for structured comparisons
- Code blocks for commands/examples

### 5. Hierarchy/Layering

**Principle:** Configuration layers override each other (enterprise → project → user → local).

**Why stable:** Standard configuration pattern used across all software systems.

**Application:**

- Higher levels set defaults
- Lower levels can override
- Understand which level your changes belong to

### 6. Token Efficiency

**Principle:** Context is finite - be efficient with tokens.

**Why stable:** LLM context windows have limits. Even as they grow, efficiency matters.

**Application:**

- Remove redundant content
- Link instead of duplicate
- Use progressive disclosure
- Monitor token budgets

**Detailed explanations:** See [Stable Principles Reference](references/stable-principles.md)

## Quick Decision Tree

**What do you want to do?**

1. **Create a new CLAUDE.md file** → Query docs-management: "Find documentation about creating CLAUDE.md files and /init command"

2. **Organize memory for a project** → See [Common Patterns](references/common-patterns.md)

3. **Understand import syntax** → Query docs-management: "Find documentation about CLAUDE.md import syntax and @ references"

4. **Set up memory hierarchy** → Query docs-management: "Find documentation about memory hierarchy enterprise project user"

5. **Optimize token usage** → See [Stable Principles](#stable-principles-wont-change) + [Common Patterns](references/common-patterns.md)

6. **Fix memory not loading** → See [Troubleshooting](#troubleshooting)

7. **Find official best practices** → See [Keyword Registry](references/keyword-registry.md) for efficient queries

## Keyword Registry for docs-management

Use these keywords when querying the `docs-management` skill for memory-related documentation:

### Core Memory System

**Keywords:** `CLAUDE.md`, `static memory`, `memory hierarchy`, `memory system`

**Example query:**

```text
Find documentation about CLAUDE.md static memory system and memory hierarchy
```

### Import Syntax

**Keywords:** `import syntax`, `@ references`, `recursive lookup`, `file imports`

**Example query:**

```text
Find documentation about CLAUDE.md import syntax and @ file references
```

### Memory Commands

**Keywords:** `/init command`, `/memory command`, `# shortcut`, `memory commands`

**Example query:**

```text
Find documentation about /init and /memory commands for CLAUDE.md
```

### Best Practices

**Keywords:** `memory best practices`, `CLAUDE.md tuning`, `memory organization`

**Example query:**

```text
Find documentation about CLAUDE.md best practices and memory tuning
```

### Agent SDK Integration

**Keywords:** `settingSources`, `memory API`, `Agent SDK memory`

**Example query:**

```text
Find documentation about Agent SDK settingSources and memory integration
```

**Complete keyword registry:** See [Keyword Registry Reference](references/keyword-registry.md)

## Common Patterns

### Hub-and-Spoke Organization

**Pattern:** Central hub file (CLAUDE.md) links to detailed reference files.

```text
CLAUDE.md (hub)
├─ Quick Reference (essential, always loaded)
├─ Core principles (brief)
└─ Links to detailed docs
    ├─→ .claude/memory/architecture.md
    ├─→ .claude/memory/workflows.md
    └─→ .claude/memory/testing.md
```

**Benefits:**

- Hub stays small (token efficient)
- Details load on-demand
- Single entry point
- Easy navigation

### Always-Loaded vs Context-Dependent

**Pattern:** Separate critical content from detailed content.

**Always-loaded (@-prefixed imports):**

- Core principles that apply to every task
- Critical rules that must never be violated
- Quick reference for common operations
- ~10-15k tokens maximum recommended

**Context-dependent (loaded on-demand):**

- Detailed guides for specific topics
- Reference documentation
- Examples and templates
- Can be larger since loaded selectively

### Token Budget Strategy

**Pattern:** Allocate tokens intentionally across memory tiers.

| Tier | T