神人拆解CC源码！源码里真正的高杠杆用法；ClaudeCode本质上是一个多Agent编排平台

Claude Code 源码泄露为业界一下子打开了 Agent 进化的大门。

就在刚刚，X上一位联合创始人@mal_shaik 将这次事故比做“反向产品发布”。

他在拆解完源码之后，给出了一个被严重低估的事实：Claude Code 从来就不是一个聊天式编程工具，而是一套已经成型的 Agent 编排系统，只是被包裹在一个过于“轻量”的终端界面之下。

从架构设计来看，这套系统的核心不在于模型能力本身，而在于一整套围绕上下文管理、任务并行、工具调度和系统扩展构建的工程体系。比如，CLAUDE.md 在每一轮对话中的重复加载，本质上是在用“持续注入上下文”的方式，将一次性 prompt 变成长期配置；而子 Agent 共享缓存的机制，则直接把并行执行的成本压缩到接近单线程水平，这在当前大模型产品中并不常见。

更值得注意的是，Claude Code 在多个关键环节都表现出明显的“平台化”倾向。Hook 系统提供了超过 25 个生命周期切入点，使其具备类似插件系统的扩展能力；MCP 工具的延迟加载机制，则意味着它天然可以接入外部服务生态，而不会牺牲基础性能；会话持久化与 session memory 的设计，让上下文不再是一次性资源，而是可以累积、复用的长期资产。

与此同时，CC源码也侧面印证了当前大模型工程的一个现实瓶颈：上下文管理已经成为系统复杂度的核心来源。五种压缩策略、分层权限控制、流式中断与重试机制，本质上都是在对抗“上下文膨胀”和“系统不稳定性”这两个问题。

综合来看，真正拉开用户差距的，并不是谁更会写 prompt，而是谁开始把 Claude Code 当作一套“可配置的开发基础设施”来使用——包括前置规则设计、并行任务拆分、自动化流程嵌入，以及跨会话的上下文经营能力。

话不多说，这份CC源码拆解，希望能给到大家以新的启发。

11层架构、CC本质上是伪装成聊天工具的Agent编排平台

大多数人打开 Claude Code，输入一个提示词，等待回复，再输入下一个提示词。

这就像买了一辆法拉利，却一直挂在一档开。

我想搞明白，为什么有些人从 Claude Code 里获得的效率比别人高 10 倍。于是我做了一个“正常人都会做”的决定：把它的全部源代码读了一遍（我说的“我”，当然是指 Claude Code 自己）。

11 层架构，成千上万行代码——一个伪装成终端聊天工具的 Agent 编排平台。

下面是源代码真正揭示的使用方法：

1. CLAUDE.md 每一轮都会被加载

这是你能做的杠杆最大的一件事，但几乎没人用对。

大多数人的 CLAUDE.md 不是空的，就是写成了一本“圣经”。

但源代码显示：Claude Code 会在每一次查询迭代中读取你的 CLAUDE.md，而不是只在会话开始时读取。这意味着——每次你发消息，它都会重新读一遍你的指令。

而且它有一整套层级结构：

• ~/.claude/CLAUDE.md —— 全局（你的编码风格、偏好）
• ./CLAUDE.md —— 项目级（架构决策、约定）
• .claude/rules/*.md —— 模块化规则
• CLAUDE.local.md —— 私有笔记（被 git 忽略）

你有 40,000 字符的空间，这非常多。但大多数人只用了 200。

把你的架构决策写进去。文件约定写进去。测试模式写进去。以及那些“绝对不要这样做”的规则。

模型会在每一轮读取它们。

这就是 Claude Code 从“一个通用助手”变成“一个真正懂你代码库的专属助手”的关键差别。

如果你读完只做一件事，那就做这个。

2. 子 Agent 共享 prompt 缓存（并行几乎是免费的）

这是最让我震惊的一点。

当 Claude Code fork 一个子 Agent 时，它会创建一个与父上下文字节级完全一致的副本。而 API 会对这个上下文做缓存。

所以——同时启动 5 个 Agent 处理不同任务，成本几乎和 1 个 Agent 顺序执行差不多。

再读一遍。

5 个 Agent，成本≈1 个。因为它们命中了同一个 prompt cache。

但大多数人是怎么用的？把 Claude Code 当成一个单线程打工人：

做一个任务 → 等 → 再给下一个任务。

而源码里，子 Agent 有三种执行模型：

• fork —— 继承父上下文，缓存最优
• teammate —— 在 tmux 或 iTerm 中开独立面板，通过文件“邮箱”通信
• worktree —— 每个 Agent 一个独立 git worktree，各自分支隔离

你完全可以让 Claude Code 同时跑 5 个 Agent：一个做安全审计，一个重构认证模块，一个写测试，一个更新文档，一个修 bug——全部并行执行，共享缓存。

这个架构本来就是为并行设计的。

你却把它当单线程用，简直是在浪费。

3. 权限系统是用来“配置”的，不是用来“点确认”的

每当 Claude Code 弹出“是否允许这个操作？”而你点了“是”，这不是一个功能，这是配置失败。

源码里有一个五层权限配置体系：

policy > flag > local > project > user

在 ~/.claude/settings.json 里，你可以用 glob 模式定义哪些操作默认允许，例如：

{

"permissions": {

"allow": [

"Bash(npm *)",

"Bash(git *)",

"Edit(src/**)",

"Write(src/**)"

]

}

}

有三种权限模式：

• bypass —— 完全不做权限检查（危险但极快）
• allowEdits —— 自动允许工作目录内的文件编辑
• auto（新模式）—— 每个操作都由一个 LLM 分类器判断（最平衡）

auto 模式也支持你自定义 allow / deny 列表。源码显示，它会并行触发多个“裁决器”：用户点击、hook 分类器、bridge 等，谁先返回就用谁的结果。

你每点一次“允许”，都是在浪费时间。

配置一次，就别再点了。

4. 一共有 5 种上下文压缩策略：

context 压力是个真实存在的问题

源码里提供了 五种在对话过长时压缩上下文的方式：

1. microcompact —— 基于时间清理旧的工具结果
2. context collapse —— 对一段对话进行摘要压缩
3. session memory —— 提取关键上下文到文件
4. full compact —— 对整个历史进行总结
5. PTL truncation —— 丢弃最早的一组消息

这其实在传递一个很重要的信号：上下文溢出是工程团队投入了大量精力解决的核心问题。

对你来说，这意味着：

• 主动使用 /compact。不要等系统自动压缩，把你在意的上下文一起“误杀”。
• 默认窗口是 200K tokens，但你可以通过使用 [1m] 模型后缀扩展到 100 万 tokens。在跨多文件的大规模重构中，这非常关键。
• 长会话会逐渐积累“session memory”——包括任务描述、文件列表、工作流状态、错误和经验总结的结构化信息。这也是为什么继续一个会话比重新开一个更有价值。
• 大型工具输出会被存储到磁盘，模型只会看到一个 8KB 的预览。如果你粘贴一个超大文件，模型可能只看到其中一小部分——所以输入要尽量聚焦。

真正把 Claude Code 用到极致的人，会把 /compact 当成游戏里的“手动存档点”：保留关键内容，清掉噪音，然后继续推进。

5. Hook 系统才是真正的扩展 API（25+ 生命周期事件）

这是一个几乎没人知道的“高手功能”。

源码显示，有超过 25 个生命周期事件可以被你挂钩（hook）：

• PreToolUse —— 任意工具执行前触发
• PostToolUse —— 任意工具执行后触发
• UserPromptSubmit —— 你发送消息时触发
• SessionStart / SessionEnd —— 会话开始 / 结束
• 以及另外 20 多个事件

同时支持 5 种 Hook 类型：

• command —— 执行 shell 命令
• prompt —— 通过 LLM 注入上下文
• agent —— 运行一个完整的 agent 校验流程
• HTTP —— 调用 webhook
• function —— 执行 JavaScript

你可以做什么？

• 每次写文件前自动跑 lint
• 每次修改后自动执行测试
• 自动把相关文档注入到每一个 prompt
• 任务完成后发 Slack 通知
• 在代码发布前校验安全规范

其中最离谱的是 UserPromptSubmit 这个 Hook：你可以在每一条消息发送时自动注入 additionalContext。

这意味着什么？

你可以在每次提问时，自动附带测试结果、最近的 git diff、当前项目状态——而不需要手动复制粘贴。

这才是你构建“自定义开发环境”的方式——不是写更好的 prompt，而是直接改造系统本身的行为。

6. 会话是持久化且可恢复的（别再每次都从零开始）

每一段对话都会以 JSONL 格式保存到：

~/.claude/projects/{hash}/{sessionId}.jsonl

源码支持：

• --continue —— 继续上一次会话
• --resume —— 指定恢复某个历史会话
• --fork-session —— 从过去的对话分叉一个新分支（这一点非常好用）

session memory 会在多次压缩中保留关键上下文：任务描述、文件列表、工作流状态、错误和经验。

但大多数人是怎么做的？

每次打开 Claude Code，都新开一个 session。

这相当于你每工作一小时，就把 IDE 关掉，再从零打开一次——之前做了什么、哪里失败了、学到了什么，全没了。

正确用法是：

用 --continue。一直用。

让上下文不断积累，让 session memory 持续沉淀经验。

源码已经把这套机制搭好了，你不用，才是真的浪费。

7. 工具系统：60+ 工具 + 智能批处理执行

Claude Code 内置了 60 多个工具，但更关键的是——它是怎么调度这些工具的。

源码把工具调用分成两类：

• concurrent（并发）——只读操作（读文件、搜索、glob 匹配）可以并行执行
• serial（串行）——有修改行为的操作（编辑、写入、bash 命令）必须逐个执行，避免冲突

这意味着什么？

当 Claude Code 需要读取 10 个文件来理解你的代码库时，它会同时读取这 10 个文件；但如果要修改 3 个文件，它会一个一个来，保证一致性。

在内置工具之外，你还可以接入 MCP Server 来扩展更多工具能力。源码里用了“延迟加载”（deferred loading）机制——只有在真正需要时才加载 MCP 工具，所以就算你接了 5 个 MCP Server，也不会拖慢每一次请求。

另外还有一个 ToolSearch 机制，用来动态发现 agent 还不知道的工具。

现实意义很直接：

如果你的工作流涉及外部系统（数据库、云服务、CI/CD），就把它们通过 MCP 接进来。底层架构会帮你处理复杂性，你只是在“白拿能力”。

8. 流式架构：随时打断，几乎没有成本

整个执行链路是基于 async generator 的，每一步都会以事件流的形式逐步输出。

按下 Escape，可以干净地中断当前响应，同时不会丢失已有上下文。

这听起来是个小点，但会彻底改变你的使用方式：

不要傻等一个你已经知道走偏的回答。立刻打断，重新引导。

源码就是这么设计的：之前的上下文保留，被打断的输出被干净丢弃——没有任何惩罚。

更好的类比是结对编程：

如果你的搭档开始写错方向，你不会等他写完，你会直接说：“等等，换个思路。”

就是这种节奏。

9. 重试系统，比你想象得更“抗打”

源码里这一块做得非常工程化：

• 最多 10 次重试，带指数退避 + 抖动（基准 500ms）
• 遇到 401/403 自动刷新 OAuth token
• 模型自动降级：如果 Opus 连续 3 次 529 错误，会自动切到 Sonnet
• 流式输出 90 秒无响应，会自动切换为非流式
• 持久模式下支持“无限重试”，最大退避 5 分钟

这背后的设计意图很明确：

Claude Code 是可以“放在那里跑”的系统。

API 抖动、限流、短暂故障——它会自己处理，你不需要盯着它。

让它在后台跑，过一会回来拿结果就行。

总结：源码里真正的高杠杆用法

• 写一个像样的 CLAUDE.md → 每轮都会加载，4 万字符，是最高杠杆配置
• 用子 Agent 并行 → fork 共享缓存，5 个 ≈ 1 个成本
• 在 settings.json 里配置权限 → 永久告别“点允许”
• 主动用 /compact → 5 种压缩策略的存在，本身就说明上下文是瓶颈
• 上 Hook → 25+ 事件、5 种类型，这才是真正的扩展 API
• 永远用 --continue → JSONL 持久化 + session memory = 上下文积累
• 接入 MCP Server → 延迟加载，几乎零成本扩展能力
• 随时打断 → 流式架构让你重定向没有代价

底层结论

Claude Code 本质上是一个披着终端 UI 外壳的 Agent 编排平台。

那些效率高 10 倍的人，不是更会写 prompt——而是：

他们做了配置、做了并行、接了 hook、让上下文持续积累。

源码已经把答案写得很直白了。现在你知道它底层到底在干什么了。

参考链接：

https://x.com/mal_shaik/status/2038918662489510273

文章来自于"51CTO技术栈"，作者 "mal"。