解码 Claude Code(六)— 实战技巧:从 Boris 和团队偷师的 30 条黄金法则

不是官方文档,不是营销话术。这是一个每天用 AI 写 100% 代码的人,用半年时间摸索出来的真实经验。

写在前面

前五期我们聊了 Claude Code 的起源、架构、记忆系统、技能和多代理协作。这一期换个节奏——不讲理论,只讲实操。

这篇文章的素材来自 Boris Cherny(Claude Code 创造者)在 2026 年 1-4 月发布的四组技巧分享,以及 Anthropic 团队成员 Thariq 关于会话管理的深度指南。我把它们重新组织成 6 个主题,30 条具体可执行的建议。

每一条都有出处,每一条都经过 Anthropic 内部团队的日常验证。

Coding Tips

一、并行是一切的起点

Boris 反复强调:并行是最大的生产力提升,没有之一。

1. 同时跑 5 个 Claude

Boris 的日常:5 个终端窗口,每个运行一个独立的 Claude Code 实例。一个重构代码,一个写测试,一个搜索依赖,一个审查 PR,一个处理 bug 报告。

具体操作:用 git worktree 创建 5 个独立的工作树,每个窗口一个。这样 5 个 Claude 互不干扰,各自操作各自的代码副本。

# 创建 worktree
git worktree add ../feature-a feature-a
git worktree add ../feature-b feature-b

# 在每个 worktree 里启动 Claude
cd ../feature-a && claude
cd ../feature-b && claude

或者用更简单的方式:claude -w 一键在 worktree 中启动。

2. 本地 + 云端双线作战

5 个本地 Claude 还不够?再开 5-10 个云端实例。claude.ai/code 支持在浏览器里运行 Claude Code,用 /teleport 可以在本地终端和云端之间无缝切换。

Boris 的组合拳:5 个本地 + 10 个云端 = 同时 15 个 Claude 在干活。

3. 把”每天做两次的事”变成斜杠命令

如果某个操作你一天要做两次以上,把它变成一条斜杠命令。

---
name: commit-push-pr
description: "提交代码、推送、创建 PR"
---

执行以下步骤:
1. 运行测试
2. git add 所有变更
3. 根据变更内容生成 commit message
4. git push
5. 创建 Pull Request

Boris 的 /commit-push-pr 命令可能是他用得最多的一条——每天执行几十次。

4. 用 /loop 把重复工作自动化

/loop 是 Boris 最喜欢的"隐藏功能"之一。它可以让 Claude 按固定间隔自动执行任务,最长持续一周。

他的日常配置:

/loop 5m /babysit          → 每5分钟自动处理PR review
/loop 30m /slack-feedback  → 每30分钟把Slack反馈变成PR
/loop 1h /pr-pruner        → 每小时清理过期PR

把技能和 loop 组合起来,就变成了一个 7x24 小时工作的 AI 助手。

二、验证闭环:最重要的一条

Boris 说过一句话,被整个社区反复引用:

给 Claude 验证自己工作的方式,效果提升 2-3 倍。这是获得高质量输出的最重要单一因素。

5. Claude 测试每一次变更

Boris 每次让 Claude 写完代码后,都会让它自己测试。不是"帮我看看有没有问题"——而是"运行测试,确保通过"。

这是他从 Meta 带来的习惯:代码质量不是审查出来的,是验证出来的。

6. 前端必须给 Claude 浏览器

让 Claude 写前端代码但不给它浏览器,就像让设计师蒙着眼睛画画。

Chrome 扩展是 Boris 做前端时的标配。Claude 写完代码后自动打开浏览器截图,对比设计稿,发现差异后自动修复。这个循环一直持续到页面看起来"对了"为止。

7. 用”挑战式提示”逼迫 Claude 自审

不要只说"帮我写这个功能"。试试这样说:

"审查这段代码,不要创建 PR,直到我通过你的测试。"

或者:

"向我证明这个方案有效。对比 main 分支和当前分支的行为差异。"

Boris 把这叫做"让 Claude 当你的审查者"——反向利用 AI 的能力来提升输出质量。

8. 失败后不要纠正,要重写

当一个修复方案"勉强能用"时,Boris 会说:

"基于你现在知道的一切,扔掉这个方案,实现那个优雅的解法。"

这个技巧的底层逻辑是:Claude 在尝试过程中学到了很多关于代码库的上下文,但它当前的实现可能只是在最初的错误假设上打补丁。让它带着新知识重新来过,往往能得到更好的结果。

9. 让 Claude 修复大多数 bug

不需要手把手教。直接说"修复失败的 CI 测试",或者把 Slack 里的 bug 线程贴给 Claude,只说一个字:"修。"

Claude 可以读日志、分析堆栈、定位代码、提出修复方案、运行测试验证。整个过程你只需要审查最终结果。

三、会话管理:对抗”上下文腐烂”

这一节的素材来自 Thariq(Anthropic 团队成员),他给出了目前最系统的会话管理指南。

10. 理解 Context Rot

即使有 1M token 的上下文窗口,模型性能也不是线性的。大约在 300-400k token 时,模型开始被无关信息干扰——注意力被分散到越来越多的 token 上,旧的不相关内容开始影响当前的判断。

这就是 Context Rot(上下文腐烂)。

11. 每个回合结束都是一个决策点

Claude 完成一个回合后,你有 5 个选择:

选项 上下文保留 适用场景
Continue 保留全部 同一任务,上下文仍然相关
Rewind 保留前半,丢弃后半 Claude 走错方向了
/compact 有损摘要 中期任务,需要清理冗余
/clear 只保留你写的 brief 全新任务
Subagent 主上下文 + 最终结果 会产生大量中间输出的任务

12. Rewind > 纠正

这是 Thariq 最推荐的习惯。

当 Claude 尝试方案 A 失败了,你的直觉可能是说"不对,试方案 B"。但这会把失败的方案 A 和你的纠正都留在上下文里。

更好的做法是 Rewind(双击 Esc):回退到失败尝试之前,用你学到的信息重新提示。

纠正后:上下文 = 5个文件读取 + 2次失败尝试 + 2次纠正 + 最终修复
回退后:上下文 = 5个文件读取 + 1个有经验的提示 + 最终修复

上下文更干净,模型的注意力更集中。

13. Compact 是中期任务的救星

当会话变长但你不想从头来过,/compact 是最好的选择。它会要求 Claude 摘要当前对话,然后用摘要替换历史。

关键技巧:用提示词引导 compact 的方向

/compact 保留认证重构的细节,丢弃测试调试的过程

不引导的 compact 可能会丢失重要信息——因为模型在做 compact 时处于"最不聪明"的状态(上下文已经很满了)。

14. 主动 compact,不要等到自动触发

等到自动 compact 触发时,模型已经处于 Context Rot 状态,摘要质量会下降。

正确做法:在你觉得上下文开始膨胀但模型还没变笨的时候,主动执行 /compact,带上方向提示。

四、CLAUDE.md:投资回报率最高的 5 分钟

15. 每次纠错后更新 CLAUDE.md

Boris 的原话:

每次你纠正 Claude 后,以这句话结尾:"更新你的 CLAUDE.md,确保你不再犯这个错误。"

Claude 非常擅长为自己写规则。它会精确地提取错误的模式,写成可执行的指令。

16. 团队共享,通过 PR 协作更新

CLAUDE.md 不应该是某个人的私有文件。Boris 的团队把它检入 git,通过 PR 协作更新。

一个更有趣的做法:在同事的 PR 上 @claude,让 Claude 在 review 过程中自动更新 CLAUDE.md。Boris 把这叫做"复利工程"——每次代码审查都在为未来的 AI 辅助投资。

17. 持续迭代直到错误率可测量地下降

CLAUDE.md 不是写一次就完事的。Boris 建议:

  1. 用一周时间记录 Claude 犯的所有错误
  2. 为每类错误添加一条规则
  3. 再用一周观察错误率是否下降
  4. 重复直到效果显著

这个过程可能需要几轮迭代,但每一轮都在让 Claude 变得更好。

18. 用 notes 目录积累项目知识

一个 Anthropic 工程师的做法:让 Claude 为每个任务/项目维护一个 notes 目录,每次 PR 后更新。然后在 CLAUDE.md 里指向这个目录。

这样 CLAUDE.md 本身保持简洁(只放规则和约定),而详细的项目知识存在 notes 里,按需加载。

五、工具和环境优化

19. 用 Opus + Thinking 处理一切

这听起来违反直觉——Opus 比 Sonnet 慢,为什么还要用?

Boris 的解释:虽然单次响应更慢,但因为 Opus 犯错更少、工具使用更准确,你需要纠错的次数大幅减少。总耗时反而更短。

这就像开车走高速 vs 走小路:高速看起来绕远了,但因为不用等红灯,总时间更短。

20. 用 PostToolUse Hook 自动格式化代码

Claude 生成的代码通常格式良好,但最后 10% 可能和项目的 lint 规则不一致。一个简单的 Hook 就能解决:

"PostToolUse": [{
  "matcher": "Write|Edit",
  "hooks": [{
    "type": "command",
    "command": "bun run format || true"
  }]
}]

每次 Claude 写入或编辑文件后自动格式化,CI 再也不会因为格式问题失败。

21. 预授权权限,不要跳过权限检查

--dangerously-skip-permissions 看起来很方便,但 Boris 坚决反对。正确做法是用 /permissions 预先授权已知的安全操作:

{
  "permissions": {
    "allow": [
      "Bash(npm test*)",
      "Bash(npm run lint*)",
      "Bash(git status*)",
      "Bash(git diff*)"
    ]
  }
}

把这些规则检入 settings.json,整个团队共享。

22. 给 Claude 接入你所有的工具

通过 MCP,Claude 可以访问 Slack、BigQuery、Sentry、GitHub 等所有团队工具。Boris 已经 6 个月没写过一行 SQL 了——所有数据查询都通过 Claude + BigQuery 完成。

配置方法:在 .mcp.json 中定义 MCP 服务器,检入 git 共享。

23. 语音输入:说得比打得快 3 倍

Boris 大部分代码是"说"出来的,不是"打"出来的。

语音输入的好处不只是速度——它让你的 prompt 自然变得更详细。打字时你会下意识压缩信息,说话时你会自然补充更多上下文。而 prompt 越详细,Claude 的输出越好。

终端里运行 /voice,然后按住空格键说话。macOS 上也可以双击 fn 键触发系统听写。

24. --bare 让 SDK 启动快 10 倍

用 Claude Code 做 CI/CD 或自动化时,默认会搜索所有 CLAUDE.md、settings 和 MCP 配置。加上 --bare 跳过这些搜索,启动速度提升 10 倍:

claude -p "总结这个代码库" \
  --output-format=stream-json \
  --bare

Boris 透露,未来的版本会把 --bare 变成默认行为——因为它在非交互场景下几乎总是更好的选择。

六、高级工作流

25. /batch:大规模变更的核武器

需要把一个重构应用到几十甚至几百个文件?/batch 会先和你确认方案,然后自动分发到数十/数百个 worktree agent 并行执行。

每个 agent 在独立的代码副本上工作,完成后自动合并。这是 Claude Code 处理大规模代码迁移的终极工具。

26. 用 Hooks 挂载到 Agent 生命周期

Hooks 让你在 Claude 的关键节点执行自定义逻辑:

  • SessionStart:每次启动时动态加载上下文
  • PreToolUse:记录模型执行的所有 bash 命令
  • Stop:Claude 停止时"戳"它一下让它继续

第三个特别有用——长时间运行的任务中,Claude 有时会过早停止。用 Stop Hook 自动推送它继续,直到任务真正完成。

27. 子代理不只是”分工”,更是”上下文隔离”

子代理最大的价值不是并行执行——而是上下文隔离。

当你知道接下来的一块工作会产生大量中间输出(20 次文件读取、12 次 grep、3 条死路),而这些输出你之后不再需要——把它交给子代理。只有最终结论会返回主上下文。

判断标准很简单:我之后还需要这些工具输出吗?不需要就丢给子代理。

28. 会话分支:探索不同方向的安全网

/branch 从当前会话分叉出一个新方向。原来的会话完好无损,你可以随时切回来。

适用场景:一个方案不确定能不能走通?先 branch 一下,在分支里试。失败了切回来,零损失。

29. 跨仓库工作:--add-dir

当你需要同时操作多个代码仓库时,用 --add-dir 把其他目录加入 Claude 的工作范围:

claude --add-dir ../shared-libs --add-dir ../api-gateway

这不仅让 Claude "看到"这些仓库,还自动授予了操作权限。

30. 用 Explanatory 模式学新东西

Claude Code 不只是写代码的工具,也是学习工具。在 /config 里切换到 "Explanatory" 或 "Learning" 输出风格,Claude 会在每次变更时解释"为什么这么做"。

还可以让它:
- 生成 HTML 幻灯片解释不熟悉的代码
- 画 ASCII 图描述新协议和代码架构
- 构建间隔重复学习技能——你解释理解,Claude 提问补漏洞


总结:30 条法则的底层逻辑

把 30 条技巧摊开看,你会发现它们都围绕三个核心原则:

原则一:给 AI 反馈闭环。 验证工作(5-9)是最重要的一组技巧。没有反馈的 AI 就像没有方向盘的车——动力再强也没用。

原则二:管理上下文就是管理 AI 的"智商"。 会话管理(10-14)、CLAUDE.md(15-18)、子代理(27)都在做同一件事——确保模型的注意力集中在正确的事情上。

原则三:自动化一切重复操作。 斜杠命令(3)、/loop(4)、Hooks(26)、权限预授权(21)——把人类从重复劳动中解放出来,让 AI 处理 AI 最擅长的事。

这三条原则不只适用于 Claude Code。它们是 2026 年"AI 辅助开发"这个领域的通用方法论。不管你用什么工具,只要你记住这三条,就能显著提升 AI 编程的效率和质量。


系列导航

下期预告:真正的项目是怎么用 Claude Code 完成的?从天气应用到大规模重构,从个人 side project 到 Anthropic 内部的生产系统。第七期,我们走进真实案例。

Views: 6

Views: 27

解码 Claude Code(五)— 多代理协作:从单兵作战到 AI 军团

一个人走得快,一群人走得远。这句老话在 AI 编程的世界里有了新的含义——只不过"一群人"变成了"一群 AI"。

Boris Cherny 的日常工作方式是这样的:同时打开 5 个终端窗口,每个窗口运行一个独立的 Claude Code 实例。一个负责重构代码,一个负责写测试,一个负责搜索依赖,一个在审查 PR,还有一个在处理 bug 报告。它们并行工作,互不干扰,像一支训练有素的开发团队。

这不是科幻。这是 2026 年 Anthropic 内部的日常。

Team Collaboration

为什么需要多个 AI

要理解多代理协作的价值,先要理解单代理的局限。

大语言模型有一个被低估的特征:上下文是它的全部记忆,也是它的全部认知边界。你在一次对话中塞进去的东西,就是它"知道"的全部。它不知道你上一次会话做了什么,不知道隔壁终端在跑什么,不知道代码库的全貌——除非你显式地告诉它。

这意味着,当任务变得复杂时,单个 AI 会遇到三个硬墙:

1. 上下文污染
你让 Claude Code 做一个复杂功能。它在尝试方案 A,失败了。换方案 B,又失败了。换方案 C,成功了。但这时候上下文窗口里已经塞满了 A 和 B 的失败记录、错误日志、来回讨论。Claude Code 开始被这些噪声干扰——它会反复引用已经放弃的方案,或者陷入自我怀疑的循环。

TypeScript 社区知名开发者 Matt Pocock 给出了一个精准的类比:LLM 像电影《记忆碎片》的主角——每次上下文被压缩或清除,它就回到初始状态,忘记之前的探索和失败。唯一的记忆是你写在 CLAUDE.md 里的笔记。

2. Smart Zone 和 Dumb Zone
Matt 还提出了一个关键概念。LLM 的性能不是均匀的。会话开始时,上下文窗口干净、信号密度高,模型处于 Smart Zone——推理准确,输出质量高。但随着上下文增长到约 100K tokens,噪声开始淹没信号,模型进入 Dumb Zone——开始重复自己、忽略指令、犯低级错误。

这个分界线不是精确的 100K,而是取决于任务类型和上下文质量。但趋势是明确的:上下文越长,质量越差。

3. 注意力稀缺
即使上下文没有溢出,单个 AI 也很难同时处理多个不同维度的思考。它在写代码的时候,很难同时做架构评审。在做架构评审的时候,很难同时思考用户体验。人类团队之所以需要分工,不是因为我们笨,而是因为深度思考需要排他性的注意力——AI 也一样。

三个层次:从子代理到军团

Claude Code 的多代理系统不是一个功能,而是三个逐渐升级的协作层次。

层次一:子代理(Subagent)

子代理是最基础的多代理形式。主会话保持清洁,把特定任务委托给一个临时创建的独立 AI 实例。

想象你在写一个复杂功能。你需要先了解现有代码的结构。你可以自己逐个文件翻看(浪费主会话上下文),也可以派出一个子代理:"去搜索代码库中所有与支付相关的模块,整理出调用关系和数据流"。

子代理在独立的上下文窗口中运行。它可能读了几十个文件,产生了大量中间输出——但这些不会污染你的主会话。它最终只返回一个精炼的结果:一张清晰的调用关系图和一段摘要。

Anthropic 的工程师 Thariq 说得直白:子代理首先是上下文管理工具,其次才是任务执行工具。它最大的价值不是"帮你干活",而是"把干活的噪声隔离在另一个窗口里"。

每个子代理都可以精确配置:

参数 作用 示例
model 使用哪个模型 Explore 用 haiku(便宜快速),审查用 opus(深度思考)
tools 允许使用哪些工具 代码搜索代理只需 Read,不需要 Edit
maxTurns 最多执行多少步 防止代理陷入死循环
color 终端里的颜色标识 绿色 = 数据获取,红色 = 代码修改
memory 记忆作用域 project 级让代理跨会话积累经验

这种精细控制揭示了一个设计哲学:不是所有代理都需要同样的能力。探索代码的代理只需要读权限,用最便宜的模型就行。写代码的代理需要完整权限,用最强的模型。就像人类团队里,实习生做调研,资深工程师做架构——能力和权限匹配角色。

层次二:Agent Teams

Agent Teams 是 Claude Code 最令人兴奋的实验性功能。和子代理不同,每个 teammate 是一个完全独立的 Claude Code 会话——拥有自己的完整上下文窗口、自己的 CLAUDE.md、自己的 MCP 服务器、自己的技能。

如果子代理是"你派出去的临时工",Agent Teams 就是"你组建的正式团队"。

Boris 在分享中演示了一个实际案例:用三个 teammate 协作构建一个"时间编排器"命令。

Command Architect(命令设计师):负责设计用户交互流程和命令结构。它思考的问题是"用户怎么触发这个功能?需要什么参数?输出是什么格式?"

Agent Engineer(代理工程师):负责实现具体的数据获取代理。它关注"怎么获取时区数据?怎么处理错误?模型用什么?"

Skill Designer(技能设计师):负责创建可视化技能。它的任务是"怎么把时区数据渲染成漂亮的 SVG?"

三个 teammate 通过共享任务列表协调工作。它们约定了数据契约——比如 Agent Engineer 输出的数据格式必须是 {time, tz, formatted},Skill Designer 据此设计渲染逻辑。

这种协作需要 iTerm2 + tmux 环境来实现分屏显示。三个 Claude Code 实例在三个终端面板中同时运行,你可以实时看到每个 teammate 在做什么。需要 CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 环境变量来启用。

Agent Teams 和子代理的关键区别是独立性和完整性。子代理是主会话的延伸——它从主会话获取任务,返回结果后就消失。而 Agent Teams 的每个成员都是一个完整的 Claude Code 实例,有自己的上下文和记忆,可以独立做出复杂决策。

层次三:/batch 大规模并行

这是 Boris 最喜欢炫耀的功能。/batch 可以把一个操作并行分发到数百个独立的 git worktree 中,每个 worktree 由一个独立的代理处理。

实际例子:Boris 需要在 200 个仓库中统一升级某个依赖版本。过去这需要一个人花一周时间,逐个仓库修改、测试、提交 PR。用 /batch,他只需要描述一次操作——"在每个仓库中把 package X 从版本 2.x 升级到 3.x,运行测试,如果通过就提交 PR"——然后 200 个代理同时开工。

每个代理在独立的 git worktree 中工作,不会互相冲突。每个代理独立测试、独立提交、独立创建 PR。整个过程可能只需要几十分钟。

Boris 自己的数据更有说服力:某天他提交了 266 个贡献(141 个 PR),全部使用 squash merge。PR 的中位数只有 118 行。也就是说,绝大多数修改都非常小而专注——这正是大规模并行最擅长的场景。

一个更深的设计原则

多代理协作背后有一个常被忽略但极其重要的设计原则:独立上下文窗口是发现 bug 的好方法

Boris 在一次分享中透露了一个内部发现:同一个模型,在不同的上下文窗口中,能发现自己引入的 bug

如果你让一个代理写代码然后自己审查,它往往会陷入"创作者盲点"——因为它知道自己的意图,所以会不自觉地假设代码是正确的。

但如果你让代理 A 写代码,然后把代码交给代理 B(在独立上下文中)审查,代理 B 没有"意图包袱",更容易发现逻辑漏洞。

这就像人类工程团队的交叉审查——你更容易发现别人代码里的问题,而不是自己的。AI 也是如此。

这个原则催生了 Claude Code 的代码审查功能:自动派出一组独立代理对每个 PR 进行深度审查。Anthropic 内部数据显示,引入多代理审查后,代码审查不再成为瓶颈,同时每位工程师的代码产出同比增长了 200%。

另一种跨模型验证更进一步:用 Claude 做初始实现,用 GPT(通过 Codex CLI)做独立审查。Plan(Claude Opus)→ QA Review(Codex GPT)→ Implement(Claude Opus)→ Verify(Codex GPT)。不同模型的盲点不同,交叉验证比单模型自审更可靠。

RPI:让多代理不是乱来

多代理协作最怕的不是技术问题,而是协调问题。五个代理各干各的,结果比一个代理更差——这种事经常发生。

Claude Code 社区发展出了一套系统化的多代理工作流,叫 RPI:Research → Plan → Implement

Research 阶段是可行性分析。六个专业代理串行工作:

  1. 需求解析器:把模糊的需求变成结构化的功能描述
  2. 产品经理:写出 PRD,定义用户故事和验收标准
  3. 代码探索器:在现有代码库中搜索相似功能的实现(用 haiku 模型,只读权限)
  4. 高级工程师:评估技术可行性,选择实现方案
  5. CTO 顾问:从战略层面审查决策,防止过度工程
  6. 文档分析师:把所有分析整合成一份清晰的 Research 报告

完成之后,系统给出一个 GO / NO-GO 决策。如果不可行,到此为止,不浪费更多资源。如果可行,进入 Plan 阶段。

Plan 阶段产出四份文档:产品需求(pm.md)、用户体验设计(ux.md)、技术规格(eng.md)和实施路线图(PLAN.md)。每份文档由不同的专业代理负责。

Implement 阶段按路线图分步执行,每一步都有严格的六步验证门:

代码发现 → 实现 → 自验证 → 独立代码审查 → 用户确认 → 文档更新

其中"独立代码审查"和"用户确认"是两个强制停止点。代码审查由独立的 review 代理执行(不是实现者自己审查)。用户确认要求人类明确批准才能继续下一步。

这个流程的核心思想是:多代理协作的价值不在于"更多 AI",而在于"更多独立视角"。六个代理串行分析需求,不是因为一个代理做不了,而是因为六个不同角色的代理能从产品、技术、战略、UX 四个维度交叉验证,发现单一视角的盲点。

RPI 的创建者 Dexter Horthy 在 MLOps Community 分享时坦承了他们犯过的错误:研究阶段不应该告诉模型"要构建什么"——那会导致 opinions 而非 facts。正确的研究应该"压缩真相"——只包含客观信息,让下游代理自己得出结论。他还强调了一个核心原则:"不要外包思考"——工程师在 AI 辅助编码中仍然是关键环节,不能让 AI 替代所有决策。

为什么这个设计有效

回过头来看,Claude Code 的多代理系统为什么有效?因为它遵循了三个基本原则。

原则一:能力匹配角色

不是所有代理都需要最强的模型。Explore 代理用 haiku(便宜、快速),code-review 代理用 opus(深度、准确),Command 入口用 sonnet(均衡)。模型选择像金字塔——底层大量调用用便宜模型,顶层关键决策用贵模型。

原则二:上下文隔离

每个代理在独立的上下文窗口中工作。一个代理的中间输出、失败尝试、调试日志不会污染其他代理。主会话保持干净,只接收精炼后的结果。

原则三:独立验证

实现者和审查者是不同的代理。写代码和审代码的 AI 实例在不同的上下文中运行,没有"创作者盲点"。这是多代理系统最重要的安全机制——它让 AI 具备了"自我纠错"的能力,只不过纠错的"自己"是另一个独立的实例。

Anthropic 内部有个说法:2026 年的编程不是"一个人写代码",而是"编排一支 AI 军团"。Boris 本人每天 10-30 个 PR,100% 由 AI 生成,141 个 PR 的中位数只有 118 行。这不是一个人在写代码——这是一个指挥官在调度一支精锐部队。

而他的武器只有一个:终端里并排打开的五个 Claude Code 窗口。

下期预告

下一篇,我们将从理论走向实战。Boris 分享的 50 条黄金法则——从并行工作到计划模式,从 CLAUDE.md 迭代到验证闭环——每一条都来自 Anthropic 内部数百工程师的真实经验。这不是教科书上的建议,这是战场上总结的生存法则。

下期见。

Views: 29

解码 Claude Code(四)— 技能系统:用 Markdown 打造可复用的 AI 能力

如果 AI 编程助手只能做一件事,它永远比不上能做一百件事的助手。但如果这一百件事每次都要你手把手教,那也不比自己做快多少。真正的效率飞跃,来自把"教过一次的经验"变成"随时可调用的能力"。

这就是 Claude Code 技能系统要解决的问题。

Code Skills

从一个真实场景说起

Anthropic 内部有数百个活跃技能,每天都在被工程师使用。这些技能不是什么高深的 AI 黑科技——它们就是 Markdown 文件。

一个典型的技能长这样:

---
name: code-review
description: "当用户要求审查代码变更时使用此技能"
when_to_use: "用户说'审查这段代码'、'review这个PR'、或提到代码质量时"
model: sonnet
effort: high
---

你是一名高级代码审查者。请检查以下内容:

1. 逻辑错误和潜在 bug
2. 安全漏洞
3. 性能问题
4. 代码风格一致性

对于每个发现,给出严重程度(🔴 严重 / 🟡 警告 / 🟢 建议)和修复建议。

就这么简单。一个 YAML 头部描述元数据,一段 Markdown 正文描述指令。没有 JSON schema,没有 Python 插件系统,没有 npm 依赖——纯文本。

Anthropic 的工程师 Thariq 在分享中提到一个有趣的数据:内部最受欢迎的技能不是那些复杂的工作流编排,而是最简单的几行规则——比如"每次保存文件后自动格式化",或者"提交代码前检查有没有遗留的 console.log"。

技能的九种类型

Thariq 把 Anthropic 内部的数百个技能归纳为九大类型,覆盖了软件开发的几乎所有环节:

1. 库/API 参考
把常用库的 API 文档整理成技能,让 Claude 不用每次都去查文档。比如"React Server Actions 最佳实践",里面包含了完整的用法示例和常见坑。

2. 产品验证
定义什么是"好的用户体验",让 Claude 在写代码时有判断标准。比如"移动端适配检查清单",列出了触摸目标大小、字体层级、断点处理等标准。

3. 数据获取与分析
教 Claude 如何连接内部数据库、如何写特定格式的查询、如何解读结果。

4. 业务流程自动化
把重复的业务操作封装成技能——生成周报、同步状态、发送通知。

5. 代码脚手架
项目初始化模板、新组件创建规范、文件命名约定。

6. 代码质量审查
这是使用最频繁的类型。代码审查、安全扫描、性能检查。

7. CI/CD 部署
定义构建、测试、部署的完整流程。

8. Runbooks
故障排查手册——出问题时 Claude 照着步骤走就行。

9. 基础设施运维
Kubernetes 配置、服务器管理、日志分析。

这九种类型揭示了一个关键洞察:技能的本质不是"教 AI 新能力",而是"把团队的最佳实践固化成可复用的知识单元"

两种技能模式

技能系统有两种工作模式,它们看起来相似,但设计哲学完全不同。

模式一:主动技能(Skill)

这是最常见的模式。用户通过斜杠命令或自然语言触发,技能像一个独立的工具被调用。

比如"天气 SVG 生成器"技能——你问"今天天气怎么样",Command 组件收到请求后,让 Agent 去获取天气数据,然后调用这个技能把数据渲染成一张漂亮的 SVG 图表。

关键特征:

  • 用户可见,可以主动调用
  • 接收对话上下文中的数据作为输入
  • 独立执行,产出自包含的结果
  • 类比:工具箱里的专用工具

模式二:代理技能(Agent Skill)

这种技能不直接被用户调用。它被注入到某个代理的启动上下文中,作为该代理的"领域知识"。

比如一个"天气数据获取"技能——它不会被用户直接使用,而是被预加载到天气代理的知识中。当天气代理启动时,这个技能的完整内容已经被塞进了上下文窗口。代理知道该调用哪个 API、参数格式是什么、怎么解析返回值。

关键特征:

  • 用户不可见(user-invocable: false
  • 在代理启动时注入,不是运行时调用
  • 提供指令性知识而非可执行操作
  • 类比:新员工的入职手册

这两种模式的配合方式很优雅:代理技能负责"怎么获取数据",主动技能负责"怎么呈现结果"。获取和渲染解耦,各管各的。

写好技能的九条铁律

根据 Thariq 分享的 Anthropic 内部经验,写好一个技能需要遵循九条最佳实践。

1. 不说废话

技能正文里不要写"你是一个优秀的 AI 助手"之类的客套话。每一行都应该是有信息量的指令。模型不需要鼓励,它需要规则。

❌ "请仔细检查代码,你很棒的!"
✅ "检查以下三项:空指针引用、SQL 注入、未处理的 Promise"

2. 建 Gotchas 区

这是整个技能系统里价值最高的部分。Gotchas 就是"踩坑记录"——记录那些看起来正确但实际会出错的地方。

## Gotchas
- Stream API 的 `.collect()` 在空流上不会抛异常,但会返回空集合
- `@Transactional` 只对 public 方法生效,private 方法上的注解会被静默忽略
- Docker 多阶段构建中,COPY 指令的路径是相对于前一个阶段的

Thariq 特别强调:在技能被 Claude 加载时,Gotchas 区域的信号量(即注意力权重)最高。因为这些是来自真实失败的经验,模型会优先参考。

3. 文件系统渐进式披露

不要把所有内容塞进一个巨大的 SKILL.md。告诉 Claude 文件结构,让它按需读取。

## 参考文件
- `api-spec.yaml` — 完整的 API 规格
- `examples/` — 使用示例
- `gotchas.md` — 常见陷阱

这样 Claude 在处理简单问题时只读 SKILL.md 本身,遇到复杂场景才去翻参考文件。上下文更精简,响应更快。

4. 不要过度约束

这是最常见的错误。给目标和约束,不要给步骤式指令。

❌ "第一步打开文件,第二步找到函数,第三步修改参数..."
✅ "将所有 API 调用从 REST 迁移到 GraphQL,保持向后兼容"

原因很简单:模型比你更擅长规划执行步骤。你规定步骤反而限制了它的优化空间。

5. 描述字段是触发条件,不是摘要

技能的 description 字段不是给人类看的简介,而是告诉模型"什么时候该用这个技能"的触发条件。

description: "当用户提到部署、发布、上线、或者需要将代码推送到生产环境时使用"

模型会根据这个描述判断是否激活技能。写成摘要就失去了这个功能。

6. 想清楚设置流程

有些技能依赖外部配置——API 密钥、数据库连接、MCP 服务器。在技能里明确写出设置步骤,避免 Claude 盲目尝试。

7. 记忆与数据存储

告诉 Claude 技能产出的数据应该存哪里。是写入文件、更新数据库、还是只在对话中返回。这避免了结果丢失或重复计算。

8. 脚本与代码生成

技能不只是文字指令,可以包含完整的脚本模板。比如一个"数据库迁移"技能,里面可能包含 SQL 模板、回滚脚本、验证查询。

9. 按需 Hooks

Hooks 是确定性挂载到代理生命周期的钩子函数。比如 PostToolUse Hook 可以在每次文件写入后自动运行格式化。不是每个技能都需要 Hook,但在需要自动化流程时它非常强大。

编排的艺术:Command → Agent → Skill

技能不是孤立使用的。Claude Code 的架构推崇一种三层编排模式:

Command(入口)→ Agent(执行者)→ Skill(能力单元)

以"天气查询"为例:

  1. Command 收到用户请求"今天天气怎么样",先用轻量模型(haiku)询问用户偏好(摄氏还是华氏)
  2. Agent 被派出去获取天气数据,它启动时已经预加载了天气获取技能(Agent Skill),知道该调用哪个 API
  3. Skill 被调用来把数据渲染成 SVG 图表(主动技能)

每一层各司其职:Command 负责交互和路由,Agent 负责执行和获取数据,Skill 负责专业输出。这种分离让每个组件可以独立替换——换一个城市的天气 API?改 Agent Skill。换一种图表风格?改主动 Skill。用户交互流程变了?改 Command。互不影响。

Boris 在分享中提到一个深刻的设计原则:入口轻,执行重。Command 用便宜快速的模型,Agent 用中等模型处理逻辑,只有在真正需要深度思考的时候才用 Opus 这种顶级模型。整个调用链的模型选择像一个金字塔——底层频繁调用用便宜模型,顶层复杂决策用贵模型。

10 个官方内置技能

Claude Code 自带 10 个内置技能,覆盖了最常见的开发场景:

技能 用途
code-review 深度代码审查
batch 大规模批量操作
debug 系统化调试
loop 定时循环任务
claude-api SDK 开发辅助
fewer-permission-prompts 减少权限弹窗
run 启动应用服务
verify 验证代码变更
run-skill-generator 生成新的启动配方
simplify 代码精简

其中最值得细说的是三个:

/batch 是 Boris 最喜欢炫耀的功能。它能把一个大规模变更并行分发到数百个独立的 git worktree 中,每个 worktree 由一个独立的 Agent 处理。Boris 曾经一次性让 Claude 在 200 个仓库中统一升级依赖版本——整个过程全自动,每个仓库一个独立 PR。

/loop 是定时任务的优雅实现。/loop 5m /simplify 会每 5 分钟运行一次代码简化技能,最长持续 3 天。任务绑定在会话上,退出 Claude 就自动停止。底层使用 CronCreate/CronList/CronDelete 工具,但用户完全不需要知道这些。

/simplify 的设计很有意思。它不是让一个 Agent 去简化代码,而是同时派出 4 个独立的 review Agent,从不同角度审查代码质量。4 个 Agent 各自给出简化建议,然后汇总决策。这种"多视角并行审查"的模式,比单个 Agent 反复检查更有效。

从个人技能到团队知识库

技能的威力在于它的分发方式。

小团队把技能文件夹检入 Git 仓库,所有人共享。每次有人踩了新坑,就更新 Gotchas。技能在 PR review 中不断迭代,越用越精准。

大团队用插件市场。Anthropic 内部有一个技能商店,工程师可以发布、搜索、安装技能。好的技能会自然浮上来——不是因为有人推广,而是因为用的人多。

Boris 有一个观点值得深思:技能系统的终极目标不是让 AI 更聪明,而是让团队的知识不再只存在于个人的脑子里。 每个人的经验、踩过的坑、总结的最佳实践——都变成一个 .md 文件,可以版本控制、可以 review、可以传承。

当资深工程师离职时,他留下的不是空荡荡的工位,而是一套经过千锤百炼的技能文件。新来的工程师不需要"跟老人学习三个月"——Claude 已经学会了所有前人的经验。

这可能是技能系统最深远的影响。

下期预告

下一篇,我们将深入 Claude Code 最令人兴奋的能力:多代理协作。Boris 怎样同时指挥 5 个 AI 实例并行工作?Agent Teams 和 Subagent 有什么区别?从单兵作战到 AI 军团的组织方法是什么?

下期见。

Views: 21

解码 Claude Code(三)— 记忆与上下文:让 AI 不再健忘

当 AI 遇上金鱼脑

你有没有经历过:跟 Claude Code 讨论复杂功能,聊了半小时,上下文越来越长,突然它开始忘记之前的约定,重复已做过的修改,甚至"反悔"之前的共识。

这不是 bug,这是大语言模型的天性。

记忆与碎片

TypeScript 社区知名开发者 Matt Pocock 做过精妙的比喻:LLM 就像电影《记忆碎片》的主角——每隔几分钟失去短期记忆,只能靠纹身和照片维持对世界的理解。每次上下文窗口被清除,AI 就回到初始状态。

理解了这一点,你就明白了 Claude Code 上下文管理的设计哲学:不是消灭遗忘,而是对抗遗忘

Smart Zone 与 Dumb Zone:上下文窗口的隐形红线

当上下文 token 数量低于 10 万时,模型处于 "Smart Zone"——反应敏捷、逻辑清晰。一旦越过这条线,模型跌入 "Dumb Zone":遗漏指令、重复自身、矛盾判断。

这不是渐进式的衰退,而是断崖式的。就像一个人从清醒到醉酒,中间没有"微醺"的过渡。

标准会话经历四个阶段:系统提示 → 探索 → 实现 → 测试。每个阶段都在往上下文塞信息,不管理就会从 Smart Zone 滑向 Dumb Zone。

记忆与上下文管理系统,正是维持 AI 代理长期有效性的基础设施。

CLAUDE.md:项目的灵魂文件

代码与文档

如果说提示词是给 AI 的指令,那么 CLAUDE.md 就是给 AI 的"世界观"。它定义了项目的编码规范、架构偏好、技术决策背景——所有那些让一个新成员快速融入团队的"潜规则"。

CLAUDE.md 的加载分两条路径:

  • 祖先加载(Ancestor Loading):Claude Code 启动时,从项目根目录开始向上遍历目录树,依次加载每一层的 CLAUDE.md。这意味着项目根目录的全局规则会在第一时间注入上下文。
  • 后代加载(Descendant Loading):当你在操作某个子目录时,Claude Code 会向下遍历并懒加载该子目录的 CLAUDE.md。这保证了子模块的特定规则只在需要时才被激活。

三层配置形成了一个优雅的层级:全局(~/.claude/CLAUDE.md)→ 项目根 → 子目录。全局配置管通用偏好(比如"用中文注释"),项目配置管架构约定(比如"使用 Repository 模式"),子目录配置管局部细节(比如"这个模块用 Rust 编写")。

更贴心的是 CLAUDE.local.md。个人偏好写在这里——喜欢的调试方式、本地环境配置——加入 .gitignore 即可避免团队冲突。兄弟目录的 CLAUDE.md 互不加载,避免无关上下文污染。

Rewind:与其修补,不如重来

很多开发者的习惯:AI 犯错了,立刻在当前上下文中纠正它。

回退与重置

这是一个陷阱。

每一次修补都在上下文留下错误痕迹。之前的错误推理链依然占据空间,随着修补次数增加,上下文越来越脏——恶性循环。

Claude Code 提供了更好的方案:/rewind 命令。它允许你回退到之前的任意一个正确状态,就像 Git 的 revert 一样,彻底抹去错误操作的影响。按两次 Esc 键可以撤销上一步操作,简单粗暴但极其有效。

回退到正确状态,永远比从错误状态修补更高效。这不是偷懒,这是工程智慧。

Compact 还是 Fresh?上下文的两个出口

面对一个膨胀的上下文窗口,Claude Code 提供了两条出路:

  • Compact(紧凑化):将当前上下文压缩为摘要,保留关键信息,丢弃冗余细节。适合正在进行中的任务,你不想丢失整体进展,但需要腾出空间。
  • Fresh Session(全新会话):彻底重开一个干净的上下文。适合切换到新的子任务,或者当前会话已经被严重污染。

一个常见的误区是认为"长上下文 = 更好的理解"。事实恰恰相反。在上下文窗口中,信息的密度比总量更重要。一个被紧凑化后的摘要,往往比包含所有对话历史的原始上下文更能引导模型做出正确判断。

不要咬下比你能咀嚼的更大的东西。—— Matt Pocock

这条建议对人类和 AI 都适用。把复杂任务拆分成可以在单个会话中完成的子任务,每个子任务结束后 compact 或开新会话,远比试图在一次超长会话中搞定一切要高效得多。

子代理的真正价值:隔离,而非并行

很多人理解子代理(Subagent)时,第一反应是"并行执行、提升速度"。但 Claude Code 团队的设计意图远比这深刻:子代理的核心价值是隔离

系统架构与隔离

想象一下:你需要在一个大型代码库中搜索所有使用了废弃 API 的地方。如果把搜索结果全部堆在主会话的上下文里,会急剧消耗 token 预算,把主会话推向 Dumb Zone。但如果用一个专门的 Explore 子代理来做这件事——它使用更轻量的模型,只配备只读工具,完成后只把精炼的结果返回给主会话——主会话的上下文始终保持干净。

更强大的是 isolation: worktree 模式。子代理在一个临时的 Git 工作树中运行,可以自由修改代码而不影响主工作区。任务完成后,如果结果令人满意,就合并回来;如果不满意,直接丢弃——临时工作树会被自动清理。这种"沙箱"式的隔离,让 AI 代理可以大胆尝试而不怕搞砸。

RPI 方法论中的上下文哲学

RPI(Research-Plan-Implement)是使用 AI 编程代理的最佳实践框架。在上下文管理方面,它有一个常被忽视的原则:Research 阶段应该"压缩真相"

什么是"压缩真相"?就是在研究阶段只收集客观信息——代码结构、API 签名、数据流向——而不掺杂任何关于"应该怎么构建"的主观判断。常见错误是在研究阶段就告诉模型"我们要用 Redux 重构状态管理",这会导致模型在后续阶段带着预设观点去工作,产出的是 opinions 而非 facts。

不要外包思考。—— Dexter Horthy

这句话的核心意思是:研究阶段的工作应该由你来主导方向,AI 负责收集信息和执行。把"思考"外包给 AI,往往得到的是听起来合理但脱离实际的方案。只有当你自己对问题有清晰的理解,才能有效地引导 AI 产出真正有价值的代码。

三级记忆:让 AI 具备跨会话经验

最后,让我们把视角从单次会话拉到长期项目的维度。Claude Code 的记忆系统分为三级:

  • User 级别:个人偏好和通用习惯,跨项目生效。比如"我偏好函数式编程风格"。
  • Project 级别:项目特定的知识和约定,同一项目的所有会话共享。比如"认证模块使用 JWT + Refresh Token 方案"。
  • Local 级别:本地环境特有信息,不入版本控制。比如"本地数据库端口是 5433"。

项目级记忆是其中最有价值的。它让 AI 代理具备了跨会话记忆能力——昨天讨论的架构决策、上周发现的技术债、上个月踩过的坑,都可以被持久化存储并在新的会话中被激活。对于长期维护的项目来说,这几乎是必需品。

一个新人加入项目需要数周才能建立起的"项目常识",AI 代理通过项目级记忆几秒内就能加载完毕。

写在最后

理解 Claude Code 的记忆与上下文管理,本质上是在理解一件事:AI 的智能是有限的,但通过好的工程实践,我们可以让有限的智能发挥出最大的效用

CLAUDE.md 是灵魂,/rewind 是兜底,compact 是效率保障,子代理是隔离利器,三级记忆是经验传承。它们共同让 AI 代理从"每次重新开始"进化为"持续积累"。

下一期,我们将深入 Claude Code 的安全模型——当 AI 拥有文件系统读写权限时,如何确保它不失控。敬请期待。

Views: 4

Views: 49

解码 Claude Code(二)— 架构哲学:为什么 CLI 形态赢了

从一个周末项目到 Anthropic 最受关注的开发者工具

2024 年 9 月,Anthropic 的工程师 Boris Cherny 为了测试 API,随手写了一个终端工具。这个工具没有花哨的界面,没有精心的产品规划,甚至连"做成终端形态"都不是有意为之。然而就是这个"随手一写"的东西,在不到一年时间里成了全球开发者圈子里讨论热度最高的 AI 编程工具之一。

在 Every 播客上,Claude Code 的产品经理 Cat 坦言:"我们没打算把终端做成最终形态。"但现实比计划更有说服力——CLI 形态不是退步,而是一次被偶然发现的进化。

终端代码界面

为什么开发者不愿意离开终端?答案藏在注意力流里。一个开发者写代码时,终端、编辑器、浏览器文档构成一个紧凑的工作三角。每一次切换到新的窗口,都在打断深度思考的状态。Copilot 和 Cursor 把 AI 嵌入编辑器是对的,但它们把开发者框在了 AI 定义的世界 里——你得在 AI 的聊天窗口里提问,在 AI 的面板里审查代码,按照 AI 设定的交互模式工作。

Claude Code 做了一件截然不同的事:它让 AI 进入开发者的世界。你不需要去任何新的界面,AI 就在你每天敲命令的地方,用你熟悉的工具,操作你熟悉的文件系统。这个方向性的差异,决定了两个截然不同的能力上限。

给 AI 一个 Bash Shell,等于给它整个世界

Claude Code 团队经历过一个被内部称为"第一个 AGI 时刻"的故事。当他们把 bash 工具交给 Sonnet 3.5 时,模型做了一件没人预料到的事:它写了 AppleScript,去查询 Boris 正在听的 Spotify 音乐。

没有人教过它写 AppleScript。没有人给它配置过 Spotify API。它只是拥有了一个 shell,然后自己找到了答案。这个瞬间揭示了一个深刻的架构哲学:通用工具 > 专用工具。

当你给 AI 一个 bash shell,你不是给了它一个工具——你给了它一个可以自己制造工具的工具。

这种哲学直接体现在 Claude Code 的工具设计上。你可能以为,这么强大的工具一定集成了几十种专用能力。事实恰恰相反——Claude Code 只有大约十几个核心工具,而且团队每周都在评估,该添加哪些、该移除哪些,以保持工具集的简洁。

同样的"少即是多"原则也体现在 MCP(Model Context Protocol)生态中。社区经过大量实践后形成了一个共识:日常使用 4 个 MCP 服务器就够了,装 15 个反而会让模型选择困难,效率直线下降。这和人类面对太多选择时的决策疲劳完全一样。

代码与架构

五层配置:从混乱到秩序

一个严肃的 CLI 工具如果不解决配置问题,很快就会在企业环境中碰壁。Claude Code 设计了一套五层配置架构,每一层都有明确的优先级和适用场景:

  • 托管设置(Organization Managed)——组织级强制策略,所有下级无法覆盖。企业的安全团队在这里锁定红线。
  • CLI 参数——单次调用的临时覆盖,适合实验和调试。
  • 本地项目配置(.claude/settings.local.json)——个人开发偏好,不提交到 Git。
  • 共享项目配置(.claude/settings.json)——团队统一规范,提交到 Git 仓库,所有人共享。
  • 用户全局配置(~/.claude/settings.json)——跨项目的个人默认设置。

这个设计的精妙之处在于:它同时满足了 企业管控、团队协作和个人自由 三个往往互相矛盾的需求。安全团队可以在托管层禁止一切网络访问,团队负责人可以在共享层规定允许的文件目录,而个人开发者仍然可以在本地层加入自己喜欢的别名和快捷方式。

权限系统同样遵循清晰的优先逻辑:deny > ask > allow。如果任何一层设置了 deny,无论其他层怎么配置,这个行为都会被拒绝。这和防火墙的"默认拒绝"理念一致——安全永远是第一优先级。

沙箱模式进一步加固了安全边界:文件系统读写隔离、网络域名白名单和黑名单、进程执行的精细控制。Claude Code 可以在严格受限的环境中运行,这对于企业场景至关重要。

还有一个容易被忽略但非常实用的设计:模型的 effort level 可以跨会话持久化。你设置了 high effort,关掉终端再打开,它还记得。这个细节说明 Claude Code 不把每次交互当成孤立的请求,而是当成一个持续的工作会话。

系统架构设计

为未来六个月构建

Boris Cherny 有一个被团队反复引用的产品理念:"不要针对今天的模型能力设计产品。为未来 6 个月的模型构建。"

这句话听起来像是冒险——如果 6 个月后的模型没有如预期进步怎么办?但如果你仔细想想,这恰恰是 AI 产品成功的核心逻辑。AI 模型的能力在以季度为单位飞速迭代,如果你按照今天的限制来设计产品架构,6 个月后你的产品就会被模型的能力甩在后面,成为"旧范式"。

大多数软件产品的设计假设是:底层能力是稳定的。但 AI 产品必须假设底层能力是快速进化的。架构的职责不是适配今天的模型,而是为模型的成长预留空间。

这个理念直接影响了 Claude Code 的功能取舍。很多"今天的模型做不到"的功能,团队依然保留了接口和架构支持。他们赌的不是今天的 Sonnet 能完成,而是 6 个月后的新模型能完成。而历史证明,这个赌注到目前为止是赢的。

Command → Agent → Skill:三层分离架构

Claude Code 的内部架构遵循一个清晰的三层模型:

  • Command 层——用户交互入口。它负责理解用户意图、编排任务流程、决定调用哪个 Agent。
  • Agent 层——执行引擎。Agent 使用预加载的技能获取数据、调用工具、执行具体操作。
  • Skill 层——能力单元。每个 Skill 独立生成输出,专注于单一任务。

这种分离的好处是显而易见的:每一层都可以独立迭代。你可以新增一个 Skill 而不影响 Command 层的编排逻辑;你可以优化 Agent 的工具选择策略而不改变 Skill 的输出格式。

更有意思的是模型选择策略:"入口轻、执行重。"Command 层只需要理解意图和分发任务,可以用更快、更便宜的模型;Agent 和 Skill 层需要深度推理和代码生成,值得投入更强的模型。这种分层资源配置的思路,和微服务架构中"网关用轻量实例、核心服务用高配实例"如出一辙。

未来科技架构

与 Copilot 和 Cursor 的本质区别

最后回到那个最根本的问题:Claude Code 和 GitHub Copilot、Cursor 到底有什么不同?

表面上看,差异是界面形态——一个在终端,一个在 IDE。但真正的差异是权力方向

  • Copilot / ChatGPT / Cursor:用户在 AI 的世界里工作。AI 提供了一个聊天框、一个面板、一个侧边栏,你进入它的领地,按照它的规则交互。
  • Claude Code:AI 在用户的世界里工作。AI 进入你的终端,读取你的文件,运行你的命令,融入你已有的工作流。

这不是一个微小的产品偏好差异,而是一个根本性的架构分叉。前者的上限是"AI 能构建多好的交互环境";后者的上限是"用户已有的环境有多强大"——而答案显然是,用户的真实环境(终端 + 文件系统 + 所有已安装的工具 + 互联网)比任何 AI 能构建的沙箱都要强大得多。

Claude Code 的架构哲学可以用一句话概括:不要把用户带到 AI 的世界,把 AI 带到用户的世界。从这个起点出发,CLI 不是退步,不是技术选型的妥协,而是通往更高能力上限的必经之路。

一个 bash shell,胜过一百个专用 API。少即是多,开放优于封闭。为未来构建,而非为现在妥协。这些不是口号,而是 Claude Code 用代码验证过的架构真理。

Views: 8

Views: 32