AI 会=我会 —— 一份 20 行 CLAUDE.md 驱动的学习 AI Agent 实验

我用 Claude Code 把自己教会了 AI Agent —— 一份 20 行 CLAUDE.md 驱动的学习实验

用 Claude Code 的 CLAUDE.md 做"课程大纲"，让 AI 带着自己从 ReAct 循环一路学到 Agent 安全。最终产出：一份覆盖 6 种场景、4 个 Tier、43 个攻击向量的 Agent 安全优先级指南。
核心发现：AI 学会就是我学会。关键不是让 AI 替你学，而是设计一个让 AI 必须教会你的结构。

一、起点：一个尴尬的事实

我每天都在用 Claude Code 写代码。它帮我重构、帮我 debug、帮我写测试。但如果你问我：

"Claude Code 内部是怎么工作的？Agent 到底是什么？"

我答不上来。

我就像一个天天开车但不知道发动机长啥样的司机。更尴尬的是——我是一个研发。我知道它可以调用工具、可以读写文件、可以执行 bash 命令，但我不知道它为什么有时候会死循环、为什么有时候会"忘记"自己在做什么、为什么有时候会执行危险操作。

所以我决定做一个实验：用 Claude Code 学会 Claude Code 是怎么工作的。

二、核心方法：CLAUDE.md 就是课程大纲

这个实验的关键洞察很简单：

Claude Code 每次启动都会读取 .claude/CLAUDE.md。如果你在这个文件里写下学习目标、学习路径、约束条件——它就会变成一个按照你的课程大纲行进的"助教"。

我的 CLAUDE.md 最开始只有 30 行，最终演化到 65 行。以下是它的核心结构：

⁠⁠⁠
## 学习目标1. Agent 与 AI API 的交互原理（CoT/ReAct/Plan-and-Execute） 2. Agent 工程核心子系统（Prompt、Context、Tool、Error、Budget、Skill、MCP） 3. Agent 安全围栏设计 4. 构建一个 Agent 自身运行的安全产品 ## 学习资源- hermes-agent/ — Nous Research 的 Hermes Agent（Python） - claude-code-rev/ — Claude Code 逆向还原源码（TypeScript） ## 学习约束（这四条是灵魂）1. 每次产出先写 md 再对话 — 所有讲解先写入 docs/ 目录 2. 中断恢复 — 每次新会话自动确认当前进度 3. 渐进式推进 — 每次一个模块，不跳步 4. 源码对照 — 讲解任何概念必须引用真实源码 5. 动手练习驱动 — 每个阶段必须包含可运行代码

这四条约束是整个实验成立的前提。 如果没有它们，Claude Code 会变成一个"聊得挺好但什么都没留下"的聊天机器人。

具体来说：

约束	解决的问题	没有它会怎样
先写 md 再对话	知识沉淀	聊完就没了，下次从头开始
中断恢复	会话断裂	每次新会话都要重新解释"我们学到哪了"
渐进式推进	学习节奏	AI 一次输出 5000 行，你一行都消化不了
源码对照	理论落地	满嘴抽象概念，看不到真实代码长什么样

三、学习历程：从 "Hello World" 到安全攻防

整个学习路线分为 6 个阶段

阶段 0-1：把 LLM 调用的"黑盒"拆开

目标：理解 Agent 和 LLM API 之间到底发生了什么。

我写了第一个练习——一个最小 ReAct 循环：

⁠⁠⁠
# 不到 80 行，但把 Agent 的核心逻辑讲透了for step inrange(max_steps):    thought = llm.think(messages)# "我应该搜索天气API"    action = parse_action(thought)# tool_call: search_weather("Beijing")    observation = execute(action)# API 返回: {"temp": 25, "humidity": 60}    messages.append(f"Observation: {observation}")# 把结果喂回 LLM

三行代码揭示了 Agent 的本质：Thought → Action → Observation 循环。这不是什么高深理论——就是 LLM 输出 tool_call，你执行它，把结果塞回 prompt，再让 LLM 输出下一个 tool_call。

然后对比了三种推理范式：

CoT (Chain of Thought):        想完 → 一次性输出答案 ReAct (Reasoning + Acting):    想一步 → 做一步 → 观察 → 再想一步 Plan-and-Execute:              先写完整计划 → 逐步执行 → 偏差时重规划

关键发现：Claude Code 用的是 ReAct 模式。你看到它"先读文件 → 再编辑 → 再运行测试 → 再修复"，就是 ReAct 在起作用。

对照源码确认：claude-code-rev/src/ 中，主循环 claude.ts 的核心逻辑就是 while (iteration < maxIterations) { response = await queryLLM(...); executeToolCalls(response); }。

阶段 2A-2H：拆解 Agent 的八个子系统

这是最密集的阶段——把 Agent 工程拆成 8 个独立模块，逐一攻破。每个模块都对应一条 CLAUDE.md 中的学习约束：必须对照源码、必须写可运行代码。

⁠⁠⁠
graph TB subgraph"阶段 2: Agent 八大子系统"        A[2A: Prompt 三层架构]--> B[2B: 上下文压缩]        B --> C[2C: 工具调用管道]        C --> D[2D: 错误恢复]        D --> E[2E: 预算控制]        E --> F[2F: Skill 系统]        F --> G[2G: MCP 协议]        G --> H[2H: 子Agent 管理]end    A --> A1["System: 你是谁<br/>Developer: 规则<br/>User: 任务"]    B --> B1["滑动窗口 / 摘要 /<br/>关键信息提取"]    C --> C1["Schema定义 → 解析<br/>→ 执行 → 格式化"]    D --> D1["分类重试 / 降级 /<br/>LLM自我修正"]    E --> E1["Token/Step/Time/<br/>Cost 四维熔断"]    F --> F1["动态加载 / 描述匹配<br/>/ 按需注入"]    G --> G1["stdio/HTTP 传输<br/>Tool暴露 / 资源订阅"]    H --> H1["派发 / 隔离 / 回收<br/>/ 上下文继承"]

每个模块我学到的不只是"概念"，而是看真实代码怎么实现的：

•
Prompt 结构：claude-code-rev/src/system-prompt.ts 里的三层 prompt 架构——System（你是 Claude，Anthropic 的 AI 助手）、Developer（项目特定的 CLAUDE.md 规则）、User（当前任务）——和我练习里写的一模一样，只是生产代码多了 2000 行边界条件处理。
•
上下文压缩：当对话超过 10000 行时，context-compressor.ts 会对历史消息做分层摘要——系统消息保留（安全边界）、工具调用保留最后一个（防止循环）、用户问题保留（任务目标不丢失）。这个"保留什么、丢弃什么"的决策逻辑比压缩算法本身更重要。
•
工具管道：tool-protocol.ts 里的 Schema 验证用的是 Zod——和我的练习几乎一样。但生产代码多了 300 行"工具结果格式化"逻辑，把 100KB 的 API 响应截断到 2KB，避免撑爆上下文。
•
预算控制：iteration-budget.ts 里四维熔断：Token 上限、Step 上限、Time 上限、Cost 上限。任何一个维度触达阈值就优雅终止——"这是你的最后一轮，请给出最终总结"。

阶段 3-4：安全围栏——从"能用"到"敢用"

学完八大子系统后，Agent 已经"能用"了。但从"能用"到"敢用"，中间差的是安全。

阶段 3 构建了 6 层安全围栏：

输入过滤 → 工具权限 → 输出审计 → 行为白盒 → 回路检测 → Skill/MCP 隔离

对照两个生产级代码库，它们的安全策略差异很大：

安全维度	Claude Code	Hermes Agent
权限模型	allow/deny/ask 三级 + GrowthBook killswitch	approval_callback + auto-deny
工具裁剪	Explore Agent 只给 3 个只读工具	toolset 机制 + DELEGATE_BLOCKED_TOOLS
预算控制	迭代预算 + Token 预算	_budget_grace_call 优雅终止
子Agent隔离	子Agent 不能 spawn 孙子、不能问用户	子Agent 不能 delegate/clarify/memory
上下文安全	压缩时保留安全上下文	prompt_builder 扫描 CLAUDE.md 注入

两条路线的差异反映了一个根本分歧：

•
Claude Code：面向个人开发者 → 权限系统用"弹窗确认"（人在环中）
•
Hermes：面向自主运行 → 权限系统用"预定义规则"（无人值守）

四、安全指南的诞生：不是学完了才写，是学着学着写出来的

学习过程中我不断发现——关于 Agent 安全的信息散落在各处：

•
Claude Code 的安全策略在 system-prompt.ts 的 CYBER_RISK_INSTRUCTION 里
•
Hermes 的安全策略分散在 delegate_tool.py、approval_callback.py、prompt_builder.py 里
•
OWASP 的 LLM Top 10 侧重模型层，不是 Agent 层
•
学术论文讲攻击分类，不讲工程实现优先级

没有人把这些整合成"如果你要给 Agent 做安全，应该按什么顺序做"的工程指南。

所以我把它整理出来了。以下是这份安全指南的核心框架：

第一性原则：消除攻击面 > 加检查

方案 A：给 Agent 全部工具 + 多层安全检查（10000行安全代码, +1~5s/轮, 仍有绕过风险） 方案 B：只给 Agent 需要的工具（50行白名单, +0ms, 结构性消除30个攻击向量）  → 方案 B 完胜。能不给的工具就不给。

Claude Code 的 Explore Agent 就是方案 B 的最佳实践——只有 Read、Glob、Grep 三个只读工具，用 haiku 模型（最便宜），命令注入、文件破坏、SSRF 全部结构性消除。

Tier 分级：不是所有安全功能都要同时做

Tier 0 (500行)   — 不做就别上线：迭代预算、工具名白名单、Schema验证、路径黑名单 Tier 1 (2600行)  — 不做就别给用户用：权限系统、护栏检测、上下文压缩、注入扫描 Tier 2 (1350行)  — 生产环境必需：信任分级、SSRF防护、子Agent独立预算、凭据脱敏 Tier 3 (3500行)  — 高安全场景必需：命令AST解析、网络排出隔离、安全感知压缩 Tier 4 (2000行+) — 对抗性场景必需：OS层隔离、供应链验证、完整Unicode清洗

最常见的错误：先做 AST 再做预算。 预算是存在性风险（无预算 = 可能无限烧钱），AST 是优化性防御（无 AST = 可能漏掉注入变体，但基础 $() 检测已覆盖 80%）。Day 1 花 50 行写 IterationBudget 比第 3 周花 2000 行写 Tree-sitter AST 解析器重要 100 倍。

场景差异：六种 Agent 的安全策略完全不同

⁠⁠⁠
graph LR subgraph"信任度 →"        A[场景1: 个人工具<br/>Tier 0+1<br/>~1500行]--> B[场景2: 团队协作<br/>Tier 0+1+2<br/>~4500行]        B --> C[场景3: 自主Agent<br/>Tier 0+1+2+3<br/>~8000行]        C --> D[场景4: 客服机器人<br/>⚡工具裁剪<br/>+ Tier 0+业务安全<br/>~1100行]        D --> E[场景5: 多租户平台<br/>全部 Tier + 审计<br/>~15000行]        E --> F[场景6: 安全审计<br/>Tier 0+1+反转规则<br/>~4000行]end

最反直觉的发现：客服机器人（场景 4）的安全代码量（1100 行）比个人开发工具（1500 行）还少。 原因是工具裁剪——客服 Agent 只需要 knowledge_search + reply_message + escalate_to_human，没有 Bash、没有文件写入、没有网络请求，30 个攻击向量结构性消除。剩下的安全问题（Prompt 注入、业务越权、输出脱敏）只需要 600 行业务安全代码。50 行白名单干掉了 10000 行安全检查才能覆盖的攻击面。

五、"AI 学会就是我学会"到底是什么意思

这个实验最大的收获不是那份安全指南，而是一个方法论的验证：

传统学习 vs CLAUDE.md 驱动学习

维度	传统自学	CLAUDE.md 驱动
信息获取	搜索 → 筛选 → 阅读 → 理解	AI 帮你定位源码 → 你对照验证
知识沉淀	靠自觉写笔记（大多数人做不到）	强制：先写 md 再对话
中断处理	重新找上次读到哪了	CLAUDE.md 记录进度，新会话自动恢复
深度	取决于你能读多少代码	AI 帮你读完两个代码库，你只需要理解关键路径
产出	可能没有	28 篇文档 + 14 个可运行练习 + 1 份安全指南

关键不是 AI 替你学，而是 AI 逼你学

CLAUDE.md 的约束设计才是核心。如果我不写"先写 md 再对话"——Claude Code 会很乐意跟我聊两个小时 Agent 安全，然后什么都没留下。如果我不写"源码对照"——它会给我一百个抽象概念，没有一个落到真实代码上。

AI 的角色不是老师，是助教。 它帮我做信息检索、帮我定位源码、帮我整理结构。但我必须自己理解、自己验证、自己决定下一个阶段学什么。CLAUDE.md 就是我和 AI 之间的"课程合同"。

意外收获：从学习者变成了贡献者

学到阶段 5 以后，我发现我对 Agent 安全的理解已经超过了大多数公开资料。不是因为我很厉害——是因为我把两个生产级代码库的安全策略对照着读了一遍，而几乎没有人做过这个工作。

那份安全指南（docs/23-agent-security-priority-and-scenarios.md）现在是我在团队内部最常被引用的文档。它不是学术论文，它就是"如果你要给 Agent 加安全，按这个顺序做"的执行手册。

六、如果你也想试试

最小可行 CLAUDE.md

⁠⁠⁠
# 你的学习项目## 学习目标1. 写清楚你要学什么 ## 学习约束1. 每次产出先写 md 再对话 2. 每次新会话先确认当前进度 3. 每次只推进一个模块 4. 讲解任何概念必须引用真实源码 5. 每个阶段写可运行代码 ## 当前进度（AI 会自动维护这个表）

三个最容易踩的坑

1.
约束写得太松。 "渐进式推进"如果没有"每次一个模块"的具体限制，AI 会一次输出 5000 行让你消化不良。
2.
没有源码对照。 没有源码的学习就像看菜谱不做菜——知道概念但不知道怎么落地。找 1-2 个开源项目放在你的项目目录里。
3.
跳过动手练习。 "看懂了"和"能写出来"之间差 10 倍。每个概念至少写一个最小可运行 demo。

适用场景

这个方法适合学工程密集型的知识——需要读大量代码、需要理解系统设计的领域。不适合学纯理论（AI 数学课还是找传统教材）或快速上手某个工具（直接用就行，不需要学原理）。

Agent 工程恰好是它的最佳匹配：核心原理简单（ReAct 循环 80 行就写完了），但工程细节分散在几万行生产代码里。AI 帮你遍历所有细节，你只需要理解关键路径。

七、写在最后

Agent 工程还在快速演化，每几个月就有新的范式出现，过几个月AI学一下还会有新内容，学不完根本学不完。

CLAUDE.md 本身也在演化。最开始它只有学习目标，慢慢加上了约束、进度表、源码引用规则。它现在就像这个项目的"操作系统"——每次新会话启动，它告诉 Claude Code 我们在哪、要去哪、怎么去。

如果你也在用 Claude Code 做日常工作，但不确定它到底是怎么工作的——试试写一个 CLAUDE.md。 不一定要学 Agent 工程，可以是你自己领域的知识体系。关键是把学习目标结构化，把约束写清楚，让 AI 从"聊天工具"变成"学习系统"。