A visual, example-driven guide to Claude Code — from basic concepts to advanced agents, with copy-paste templates that bring immediate value.
Update memory doc with the update from offical claude code website
Luong NGUYEN27ad9da05eb4
diff --git a/02-memory/README.md b/02-memory/README.mdindex 40e65b8..303030e 100644--- a/02-memory/README.md+++ b/02-memory/README.md@@ -16,6 +16,176 @@ Memory in Claude Code provides persistent context that carries across multiple sThe memory system operates at multiple levels, from global personal preferences down to specific subdirectories, allowing for fine-grained control over what Claude remembers and how it applies that knowledge.+## Memory Commands Quick Reference++| Command | Purpose | Usage | When to Use |+|---------|---------|-------|-------------|+| `/init` | Initialize project memory | `/init` | Starting new project, first-time CLAUDE.md setup |+| `/memory` | Edit memory files in editor | `/memory` | Extensive updates, reorganization, reviewing content |+| `#` prefix | Quick single-line memory add | `# Your rule here` | Adding quick rules during conversation |+| `# new rule into memory` | Explicit memory addition | `# new rule into memory<br/>Your detailed rule` | Adding complex multi-line rules |+| `# remember this` | Natural language memory | `# remember this<br/>Your instruction` | Conversational memory updates |+| `@path/to/file` | Import external content | `@README.md` or `@docs/api.md` | Referencing existing documentation in CLAUDE.md |++## Quick Start: Initializing Memory++### The `/init` Command++The `/init` command is the fastest way to set up project memory in Claude Code. It initializes a CLAUDE.md file with foundational project documentation.++**Usage:**++```bash+/init+```++**What it does:**++- Creates a new CLAUDE.md file in your project (typically at `./CLAUDE.md` or `./.claude/CLAUDE.md`)+- Establishes project conventions and guidelines+- Sets up the foundation for context persistence across sessions+- Provides a template structure for documenting your project standards++**When to use `/init`:**++- Starting a new project with Claude Code+- Establishing team coding standards and conventions+- Creating documentation about your codebase structure+- Setting up memory hierarchy for collaborative development++**Example workflow:**++```markdown+# In your project directory+/init++# Claude creates CLAUDE.md with structure like:+# Project Configuration+## Project Overview+- Name: Your Project+- Tech Stack: [Your technologies]+- Team Size: [Number of developers]++## Development Standards+- Code style preferences+- Testing requirements+- Git workflow conventions+```++### Quick Memory Updates with `#`++You can quickly add information to memory during any conversation by starting your message with `#`:++**Syntax:**++```markdown+# Your memory rule or instruction here+```++**Examples:**++```markdown+# Always use TypeScript strict mode in this project++# Prefer async/await over promise chains++# Run npm test before every commit++# Use kebab-case for file names+```++**How it works:**++1. Start your message with `#` followed by your rule+2. Claude recognizes this as a memory update request+3. Claude asks which memory file to update (project or personal)+4. The rule is added to the appropriate CLAUDE.md file+5. Future sessions automatically load this context++**Alternative patterns:**++```markdown+# new rule into memory+Always validate user input with Zod schemas++# remember this+Use semantic versioning for all releases++# add to memory+Database migrations must be reversible+```++### The `/memory` Command++The `/memory` command provides direct access to edit your CLAUDE.md memory files within Claude Code sessions. It opens your memory files in your system editor for comprehensive editing.++**Usage:**++```bash+/memory+```++**What it does:**++- Opens your memory files in your system's default editor+- Allows you to make extensive additions, modifications, and reorganizations+- Provides direct access to all memory files in the hierarchy+- Enables you to manage persistent context across sessions++**When to use `/memory`:**++- Reviewing existing memory content+- Making extensive updates to project standards+- Reorganizing memory structure+- Adding detailed documentation or guidelines+- Maintaining and updating memory as your project evolves++**Comparison: `/memory` vs `/init`**++| Aspect | `/memory` | `/init` |+|--------|-----------|---------|+| **Purpose** | Edit existing memory files | Initialize new CLAUDE.md |+| **When to use** | Update/modify project context | Begin new projects |+| **Action** | Opens editor for changes | Generates starter template |+| **Workflow** | Ongoing maintenance | One-time setup |++**Example workflow:**++```markdown+# Open memory for editing+/memory++# Claude presents options:+# 1. Enterprise Policy Memory+# 2. Project Memory (./CLAUDE.md)+# 3. User Memory (~/.claude/CLAUDE.md)+# 4. Local Project Memory++# Choose option 2 (Project Memory)+# Your default editor opens with ./CLAUDE.md content++# Make changes, save, and close editor+# Claude automatically reloads the updated memory+```++**Using Memory Imports:**++CLAUDE.md files support the `@path/to/file` syntax to include external content:++```markdown+# Project Documentation+See @README.md for project overview+See @package.json for available npm commands+See @docs/architecture.md for system design+```++**Import features:**++- Supports both relative and absolute paths+- Enables recursive nesting up to 5 levels deep+- Helps avoid duplication by referencing existing documentation+- Automatically includes referenced content in Claude's context+## Memory ArchitectureMemory in Claude Code follows a hierarchical system where different scopes serve different purposes:@@ -35,6 +205,26 @@ graph TB## Memory Hierarchy in Claude Code+Claude Code uses a four-tier hierarchical memory system. Memory files are automatically loaded when Claude Code launches, with higher-level files taking precedence.++**Complete Memory Hierarchy (in order of precedence):**++1. **Enterprise Policy** - Organization-wide instructions+ - macOS: `/Library/Application Support/ClaudeCode/CLAUDE.md`+ - Linux: `/etc/claude-code/CLAUDE.md`+ - Windows: `C:\ProgramData\ClaudeCode\CLAUDE.md`++2. **Project Memory** - Team-shared context (version controlled)+ - `./.claude/CLAUDE.md` or `./CLAUDE.md` (in repository root)++3. **User Memory** - Personal preferences+ - `~/.claude/CLAUDE.md`++4. **Local Project Memory** - Personal project-specific preferences (deprecated)+ - `./CLAUDE.local.md`++**Memory Discovery Behavior:**+Claude searches for memory files in this order, with earlier locations taking precedence:```mermaid@@ -54,11 +244,14 @@ graph TD| Location | Scope | Priority | Shared | Access | Best For ||----------|-------|----------|--------|--------|----------|+| `/Library/Application Support/ClaudeCode/CLAUDE.md` (macOS) | Enterprise | Highest | Organization | System | Company-wide policies |+| `/etc/claude-code/CLAUDE.md` (Linux) | Enterprise | Highest | Organization | System | Organization standards |+| `C:\ProgramData\ClaudeCode\CLAUDE.md` (Windows) | Enterprise | Highest | Organization | System | Corporate guidelines || `./CLAUDE.md` | Project | High | Team | Git | Team standards, shared architecture || `./.claude/CLAUDE.md` | Project | High | Team | Git | Alternative project location || `./subdir/CLAUDE.md` | Directory | Medium | Team | Git | Directory-specific rules || `~/.claude/CLAUDE.md` | Personal | Low | Individual | Filesystem | Personal preferences |-| `~/.claude/my-project.md` | Personal | Low | Individual | Import | Project-specific personal notes |+| `./CLAUDE.local.md` | Project Local | Deprecated | Individual | Git (ignored) | Personal project notes (deprecated) |## Memory Update Lifecycle@@ -322,7 +515,9 @@ Claude has not save the rule because I did not have any `Claude.md` file anywher### Example 4: Memory Update During Session-**Session Interaction:**+You can add new rules to memory during an active Claude Code session. There are two ways to do this:++#### Method 1: Direct Request```markdownUser: Remember that I prefer using React hooks instead of class components@@ -347,6 +542,38 @@ Added to ./CLAUDE.md:- Use useMemo for expensive computations```+#### Method 2: Using "# new rule into memory" Pattern++You can also use the explicit pattern "# new rule into memory" to trigger memory updates:++```markdown+User: # new rule into memory+ Always validate user input with Zod schemas before processing.++Claude: I'm saving this rule to memory. Which memory file should I use?+ 1. Project memory (./CLAUDE.md)+ 2. Personal memory (~/.claude/CLAUDE.md)++User: Project memory++Claude: ✅ Memory saved!++Added to ./CLAUDE.md:+---++### Input Validation+- Always validate user input with Zod schemas before processing+- Define schemas at the top of each API handler file+- Return 400 status with validation errors+```++#### Tips for Adding Memory++- Be specific and actionable in your rules+- Group related rules together under a section header+- Update existing sections instead of duplicating content+- Choose the appropriate memory scope (project vs. personal)+## Memory Features Comparison| Feature | Claude Web/Desktop | Claude Code (CLAUDE.md) |@@ -406,29 +633,110 @@ graph LR### Do's - What To Include-- **Keep organized**: Structure memory files with clear sections-- **Keep up-to-date**: Review and update memory regularly as standards change-- **Use project memory for**: Team standards, architecture, coding conventions-- **Use personal memory for**: Preferences, communication style, tooling choices-- **Use directory memory for**: Module-specific rules and overrides-- **Version control**: Commit CLAUDE.md files to git for team benefit-- **Import docs**: Reference external files with @docs/file.md syntax-- **Be specific**: Provide concrete examples and clear expectations+- **Be specific and detailed**: Use clear, detailed instructions rather than vague guidance+ - ✅ Good: "Use 2-space indentation for all JavaScript files"+ - ❌ Avoid: "Follow best practices"++- **Keep organized**: Structure memory files with clear markdown sections and headings++- **Use appropriate hierarchy levels**:+ - **Enterprise memory**: Company-wide policies, security standards, compliance requirements+ - **Project memory**: Team standards, architecture, coding conventions (commit to git)+ - **User memory**: Personal preferences, communication style, tooling choices+ - **Directory memory**: Module-specific rules and overrides++- **Leverage imports**: Use `@path/to/file` syntax to reference existing documentation+ - Supports up to 5 levels of recursive nesting+ - Avoids duplication across memory files+ - Example: `See @README.md for project overview`++- **Document frequent commands**: Include commands you use repeatedly to save time++- **Version control project memory**: Commit project-level CLAUDE.md files to git for team benefit++- **Review periodically**: Update memory regularly as projects evolve and requirements change++- **Provide concrete examples**: Include code snippets and specific scenarios### Don'ts - What To Avoid-- **Don't store secrets**: Never include API keys, passwords, or credentials-- **Don't duplicate**: Avoid repeating content across memory files-- **Don't create too many**: Keep subdirectory overrides minimal and focused-- **Don't make it too long**: Keep memory files under 500 lines+- **Don't store secrets**: Never include API keys, passwords, tokens, or credentials+- **Don't include sensitive data**: No PII, private information, or proprietary secrets-- **Don't forget to update**: Memory becomes stale if not maintained-- **Don't over-organize**: Use hierarchy strategically, not excessively++- **Don't duplicate content**: Use imports (`@path`) to reference existing documentation instead++- **Don't be vague**: Avoid generic statements like "follow best practices" or "write good code"++- **Don't make it too long**: Keep individual memory files focused and under 500 lines++- **Don't over-organize**: Use hierarchy strategically; don't create excessive subdirectory overrides++- **Don't forget to update**: Stale memory can cause confusion and outdated practices++- **Don't exceed nesting limits**: Memory imports support up to 5 levels of nesting++### Memory Management Tips++**Choose the right memory level:**++| Use Case | Memory Level | Rationale |+|----------|-------------|-----------|+| Company security policy | Enterprise | Applies to all projects organization-wide |+| Team code style guide | Project | Shared with team via git |+| Your preferred editor shortcuts | User | Personal preference, not shared |+| API module standards | Directory | Specific to that module only |++**Quick update workflow:**++1. For single rules: Use `#` prefix in conversation+2. For multiple changes: Use `/memory` to open editor+3. For initial setup: Use `/init` to create template++**Import best practices:**++```markdown+# Good: Reference existing docs+@docs/architecture.md++# Avoid: Copying content that exists elsewhere+# Instead of copying README content into CLAUDE.md, just import it+```## Installation Instructions### Setup Project Memory+#### Method 1: Using `/init` Command (Recommended)++The fastest way to set up project memory:++1. **Navigate to your project directory:**+ ```bash+ cd /path/to/your/project+ ```++2. **Run the init command in Claude Code:**+ ```bash+ /init+ ```++3. **Claude will create and populate CLAUDE.md** with a template structure++4. **Customize the generated file** to match your project needs++5. **Commit to git:**+ ```bash+ git add CLAUDE.md+ git commit -m "Initialize project memory with /init"+ ```++#### Method 2: Manual Creation++If you prefer manual setup:+1. **Create a CLAUDE.md in your project root:**```bashcd /path/to/your/project@@ -458,6 +766,20 @@ graph LRgit commit -m "Add project memory configuration"```+#### Method 3: Quick Updates with `#`++Once CLAUDE.md exists, add rules quickly during conversations:++```markdown+# Use semantic versioning for all releases++# Always run tests before committing++# Prefer composition over inheritance+```++Claude will prompt you to choose which memory file to update.+### Setup Personal Memory1. **Create ~/.claude directory:**@@ -525,6 +847,37 @@ graph LR3. **Test with Claude Code** by starting a new session in your project+## Official Documentation++This guide is based on official Claude Code documentation. For the most up-to-date information, refer to:++- **[Memory Documentation](https://code.claude.com/docs/en/memory.md)** - Complete memory system reference+- **[Slash Commands Reference](https://code.claude.com/docs/en/slash-commands.md)** - All built-in commands including `/init` and `/memory`+- **[Quickstart Guide](https://code.claude.com/docs/en/quickstart.md)** - Getting started with Claude Code+- **[Documentation Map](https://code.claude.com/docs/en/claude_code_docs_map.md)** - Complete documentation index++### Key Technical Details from Official Docs++**Memory Loading:**++- All memory files are automatically loaded when Claude Code launches+- Claude traverses upward from the current working directory to discover CLAUDE.md files+- Subtree files are discovered and loaded contextually when accessing those directories++**Import Syntax:**++- Use `@path/to/file` to include external content+- Supports both relative and absolute paths+- Recursive nesting supported up to 5 levels deep+- Automatically includes referenced content in Claude's context++**Memory Hierarchy Precedence:**++1. Enterprise Policy (highest precedence)+2. Project Memory+3. User Memory+4. Local Project Memory (deprecated, lowest precedence)+## Related Concepts Links### Core Memory Concepts