---
title: "同样的话跟 Claude Code 说了八遍，是时候让它自己记住了"
author: deletexiumu
pubDatetime: 2026-02-19T01:00:00+08:00
featured: false
draft: false
tags:
  - Claude Code
  - AI 工具
  - 效率
description: "Claude Code 不是笨，是你没给它长期记忆。本文讲怎么把你反复教的东西写进 CLAUDE.md 和 rules 文件，让它自己记住。"
---

用 Claude Code 的人，大概都有过这种体验：

"别动 main 分支"——说了三遍，它还是往 main 上提交。"改完代码先跑测试"——每次都要我追一句才跑。"这个文件不要碰，是别人在改的"——转头就给你重构了。

你不是在写代码，你是在当复读机。

更要命的是，这些重复的"教学"挤占了上下文窗口。Claude 的 200K tokens 听起来很大，但反复纠正、反复解释、加上 Claude 读的文件和跑的命令，窗口很快就满了。满了之后它开始"忘事"——刚纠正过的问题又犯，刚确认的决策又丢，甚至在已经讨论过的坑上再翻一次车。

**问题不是 Claude 笨，是你没给它"长期记忆"。**

这篇文章聊的就是这件事：怎么把你反复教的东西，一次性写进 Claude Code 的记忆系统，让它自己记住。

---

## 一、Claude Code 的记忆放在哪

Claude Code 的记忆不是一个文件，而是一套分层体系。你反复教的那些东西，可以按类型放进不同的层：

| 层级 | 文件位置 | 什么时候生效 | 适合放什么 |
|------|----------|-------------|-----------|
| 全局记忆 | `~/.claude/CLAUDE.md` | 每次会话启动 | 你在**所有项目**中都想让 Claude 遵守的规矩 |
| 项目记忆 | `./CLAUDE.md` | 每次会话启动 | **这个项目**的架构、规范、常用命令 |
| 模块化规则 | `.claude/rules/*.md` | 自动加载，支持按路径过滤 | 按语言/模块拆开的细化规则 |
| 本地记忆 | `./CLAUDE.local.md` | 每次启动（不入 git） | 你个人的项目偏好（如沙箱 URL） |
| 自动记忆 | `~/.claude/projects/<project>/memory/` | 前 200 行自动加载 | Claude 自己记录的项目经验 |

举个例子回到开头的场景：

- "别动 main 分支" → 写进**项目 CLAUDE.md** 的 Git 规范
- "改完代码先跑测试" → 写进 `.claude/rules/testing.md`，或者做成 **Hook** 自动执行（后面会讲）
- "这个文件不要碰" → 写进**项目 CLAUDE.md**，注明哪些文件/目录不可修改

**写一次，每个新会话自动加载。你再也不用重复教了。**

下面这张图是我自己的全局 `CLAUDE.md` 配置——只有寥寥几行，核心规则指向外部文件：

![我的 CLAUDE.md 全局配置](/blog/claude-code-memory-rules/memory-overview.png)

它只做了三件事：定义语言风格、设置交互习惯、用路径引用指向详细规则。**CLAUDE.md 本身极简，详细内容全部外置。** 为什么要极简？下面讲。

---

## 二、规则怎么写才有效

### 核心原则：极简

CLAUDE.md 是每次会话的"首屏"。**它越长，Claude 越容易忽略其中的关键规则。**

社区实测数据很直接：

> 单个 CLAUDE.md 超过 500 行 → 平均每会话多烧 8-12 万 tokens。

更糟的是，规则多了以后你会发现：Claude 有时候"选择性失忆"——你明明写了不要直接往 main 提交，它还是提了。不是它故意的，是你写了 200 行规则，关键那条被淹没了。

Anthropic 官方建议：

> 对每一行规则问自己："去掉这行，Claude 会犯错吗？"如果不会，就删。

**该写的：** Claude 自己看不出来的事——猜不到的 Bash 命令、和默认不同的代码风格、项目特有的架构决策、团队的 Git 约定、开发环境的隐坑。

**不该写的：** Claude 读代码就能推断的事、标准语言规范（它本来就知道）、详细 API 文档（给链接就行）、"写干净的代码"这种废话。

### 用 `@` 引用，别把细节塞主文件

```markdown
# CLAUDE.md（项目根目录）
See @README.md for project overview and @package.json for available commands.

# Git workflow
- @docs/git-instructions.md

# Personal overrides
- @~/.claude/my-project-instructions.md
```

`@path` 语法让你把详细内容放在外部文件里，CLAUDE.md 只保留索引。**这是最简单有效的瘦身方法。**

### 规则多了就拆：`.claude/rules/`

把所有规则塞进一个 CLAUDE.md 是初学者常犯的错误。正确做法是用 `.claude/rules/` 目录按主题拆分：

```
.claude/
├── CLAUDE.md           # 极简，<20 行
└── rules/
    ├── code-style.md   # 通用代码风格
    ├── git-workflow.md  # Git 规范（比如"不准动 main"）
    ├── testing.md       # 测试规范
    └── frontend/
        ├── react.md
        └── styles.md
```

所有 `.md` 文件自动发现、自动加载，支持递归子目录。

**路径作用域更省心。** 规则文件支持 YAML 前置的 `paths` 字段，只有 Claude 操作匹配的文件时才加载：

```markdown
---
paths:
  - "src/**/*.ts"
  - "src/**/*.tsx"
---

# TypeScript 规则
- 使用 ES Modules，禁止 require
- 禁止 any，优先使用 unknown
- 每次修改后运行 `tsc --noEmit` 检查
```

改 `.ts` 文件时这些规则生效，改 `.py` 文件时不加载——**不相关的规则不占上下文，关键规则不被稀释。**

---

## 三、不知道该写什么规则？从历史会话里"炼"

很多人的困惑是：**我知道该写规则，但不知道写什么。** 对着空白的 CLAUDE.md 发呆。

你不需要凭空想。**你过去几周和 Claude Code 的对话里，已经藏着大量规则的原矿**——那些你反复纠正的习惯、反复确认的偏好、反复解释的上下文。

### 第一步：回顾历史会话

```bash
claude --resume
```

这个命令列出你最近的所有会话。选几个你做过重要项目的会话，恢复进去。

### 第二步：让 Claude 帮你"挖矿"

在恢复的会话里，直接给 Claude 下指令：

```
回顾我们这次会话的完整对话历史。找出以下内容：
1. 我纠正过你的地方（说明你做错了什么、我期望的行为是什么）
2. 我反复强调的偏好或约束
3. 我解释过的项目特有上下文（架构决策、技术选型、环境配置等）
4. 你踩过的坑（比如用错了命令、改错了文件、忽略了某个约定）

把这些整理成 CLAUDE.md 规则的格式，每条规则一行，用 bullet point。
只保留"下次会话如果不写进规则，你还会犯同样错误"的条目。
```

Claude 会翻阅整个会话历史，提炼出一份规则草稿。

### 第三步：多个会话交叉，新会话合并

对 3-5 个历史会话重复上面的操作，把结果收集到一个文件里。然后开一个新会话：

```
读取 @rules-draft.md，这是我从多个历史会话中提炼的规则草稿。
请做以下处理：
1. 合并重复项
2. 删除 Claude 本来就知道的常识（比如"代码要有缩进"）
3. 按主题分组（代码风格、测试、Git 工作流、项目架构等）
4. 每组生成一个 .claude/rules/ 下的规则文件
5. 通用规则留在 CLAUDE.md，控制在 20 行以内
```

### 第四步：持续迭代

规则文件不是一次写好就完事的。每次你在会话中纠正 Claude，问自己：**这条纠正值得写进规则吗？**

如果值得——当场让 Claude 写入：

```
把这条规则加到 .claude/rules/git-workflow.md 里：feature 分支命名用 feat/xxx 格式。
```

或者更简单，直接说"记住这个"，Claude 的自动记忆会帮你存到 `~/.claude/projects/<project>/memory/` 里。

**最好的规则来自真实的踩坑，不是凭空想象。** 从对话里提炼，比对着空白文件苦想，效率高十倍。

---

## 四、自动记忆：让 Claude 自己记笔记

除了你手动写规则，Claude 还有一套"自动记忆"系统——它会自己记录工作中发现的模式、调试经验和你的偏好。

```
~/.claude/projects/<project>/memory/
├── MEMORY.md          # 索引文件，前 200 行自动加载
├── debugging.md       # 调试笔记
├── api-conventions.md # API 设计决策
└── ...                # 其他主题文件
```

只有 `MEMORY.md` 前 200 行自动加载到上下文，其他文件按需读取。

你可以主动触发：

```
"记住我们用 pnpm 不用 npm"
"保存到 memory：API 测试需要本地 Redis 实例"
```

也可以用 `/memory` 命令在编辑器里直接查看和编辑所有记忆文件。

自动记忆目前灰度发布中，可以手动开启：

```bash
export CLAUDE_CODE_DISABLE_AUTO_MEMORY=0  # 强制开启
```

自动记忆和手动规则的分工：**规则文件放"必须遵守的纪律"，自动记忆放"顺手记下的经验"。** 前者是法律，后者是笔记。

---

## 五、写了规则还是不听？两个原因和解法

规则写好了，Claude 有时候还是不遵守。通常两个原因：

### 原因一：规则被上下文噪音淹没

你的会话积累了太多无关信息——之前的调试记录、读过的文件内容、跑过的命令输出——规则在这些噪音里被"挤"到了 Claude 注意力的边缘。

**解法：主动清理上下文。**

- **任务间用 `/clear`。** 每完成一个独立任务就清空上下文。最常见的问题是一个会话里聊了三个不相关的话题，上下文全是噪音。
- **上下文过半用 `/compact`。** 不要等满了才压缩。支持带指令：`/compact 重点保留修改文件列表和测试命令`。
- **探索任务用子代理。** 让 Claude "调查 X"时它可能读 20 个文件全灌进主上下文。用子代理隔离，只报总结回来。

官方文档原话：

> 如果你在同一个问题上纠正 Claude 超过两次，上下文已经被失败的尝试污染了。`/clear` 然后用一个更好的初始提示重新开始。

### 原因二：规则是"建议"，Claude 可以忽略

CLAUDE.md 和 rules 里的指令本质上是**建议性的**。Claude 大概率会遵守，但不是 100%。

**对于"必须执行，没有例外"的规则，用 Hook。**

Hook 是在 Claude 工作流特定节点自动执行的脚本，不需要 Claude "记住"也不需要它"配合"——它编辑完文件，Hook 自动跑 lint；它准备提交代码，Hook 自动检查分支。

```json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "command": "eslint --fix $CLAUDE_FILE_PATH"
      }
    ]
  }
}
```

**规则文件是"请你这样做"，Hook 是"不管你想不想，都会执行"。**

回到开头的三个场景：

| 场景 | 规则文件能解决？ | Hook 更适合？ |
|------|:---:|:---:|
| "别动 main 分支" | 大概率有效 | PreToolUse Hook 检查分支名，直接拦截 |
| "改完先跑测试" | 经常忘 | PostToolUse Hook 编辑后自动跑测试 |
| "这个文件不要碰" | 有效 | PreToolUse Hook 匹配文件路径，直接拦截 |

**能用 Hook 解决的，就别写在规则文件里。** 省了 Token，还 100% 生效。

---

## 六、快速上手

如果你是第一次配置，最快的路径：

```bash
# 1. 用 /init 生成项目 CLAUDE.md 初稿
claude /init

# 2. 从历史会话中挖规则（上面讲的方法）
claude --resume
# 选择会话 → 让 Claude 提炼规则 → 收集到 rules-draft.md

# 3. 让 Claude 帮你组织成 rules 目录
claude "读取 @rules-draft.md，按主题拆分到 .claude/rules/ 目录下"
```

或者更懒的方式——直接在当前会话里告诉 Claude：

```
分析当前项目的代码结构和技术栈，帮我生成 .claude/rules/ 目录，
每个规则文件带 paths 作用域，CLAUDE.md 只保留 20 行以内的索引。
```

---

## 七、我的配置参考

分享一下我自己的结构：

```
~/.claude/
├── CLAUDE.md                    # 全局指令（<20行）
├── rules/
│   ├── lessons-learned.md       # 通用经验教训
│   └── skill-development.md     # Skill 开发偏好
├── refs/                        # 按需引用的参考文件
│   ├── servers.md
│   ├── database-connections.md
│   └── notion-integration.md
└── skills/                      # 复杂工作流（按需懒加载）
    ├── blog-publisher/
    ├── x-tracker/
    └── ...
```

全局 `CLAUDE.md` 不到 20 行。核心规则指向 `rules/`。参考资料放在 `refs/` 里，CLAUDE.md 里标注"涉及相关任务时用 Read 读取"——Claude 需要时才去看，不预加载。

---

## 总结

回到开头的问题：你反复教 Claude 的那些东西，其实只需要教一次。

1. **写进规则文件。** CLAUDE.md 放核心规则（极简），`.claude/rules/` 按主题拆分。每次新会话自动加载。
2. **不知道写什么？从历史挖。** `claude --resume` 恢复旧会话，让 Claude 翻对话提炼规则。最好的规则来自真实踩坑。
3. **写了还不听？用 Hook。** 规则是"建议"，Hook 是"强制"。必须执行的纪律别靠文字，靠脚本。
4. **保持上下文干净。** 任务间 `/clear`，过半 `/compact`，探索用子代理。上下文越干净，规则越不容易被忽略。

**不要再当复读机了。教一次，让它自己记住。**

---

## 参考资源

- Anthropic 官方 Best Practices：https://code.claude.com/docs/en/best-practices
- 官方 Memory & Rules 文档：https://code.claude.com/docs/en/memory
- Anthropic Skills 完整指南（PDF）：https://resources.anthropic.com/hubfs/The-Complete-Guide-to-Building-Skill-for-Claude.pdf
- 社区最佳实践仓库：https://github.com/shanraisshan/claude-code-best-practice
- Token 优化实测案例（54% 降幅）：https://gist.github.com/johnlindquist/849b813e76039a908d962b2f0923dc9a

---

## 相关阅读

- [别让 AI 乱写代码：从方法论到实战，我的 Claude Code 工作流](/posts/claude-code-plan-before-code/) — 记忆规则配合工作流，效果翻倍
- [从单兵作战到团队协作：Claude Code Agent Team 深度解析](/posts/claude-code-agent-team/) — 规则配置好之后，试试让多个 Agent 协作
- [从需求到自动化：Claude Code Skill 工具链完整实战](/posts/claude-code-skill-toolchain/) — Skill 固化的完整实战案例，规则之外还可以固化整套操作流程