10.8 全局视图：8 种核心机制的协奏 · 波仔的 AI 编程实战课

📄 一句话概括

八种机制放进一次二十步的任务里数一遍，全部出现，但分布极不均。出现最多的是钩子（四次），最少的是无人值守模式（一次）。 最少的那个不在「跑起来之后」，在「怎么启动」。

📝 本章和前面几章的关系

这一节是全书的收尾。前面九章讲机制，第 10 章讲工程化，这一节把它们放回一次任务里看。这一节有真跑：一条二十步的时间线，逐步标出动用了哪个机制，最后统计。

一、真跑：二十步里数一遍

任务形状：改一个跨模块的功能，从启动到收尾二十步。第一步读指令文件、第二步拿到技能清单、第三步触发发布检查技能，第四步钩子拦下一条危险命令。中间调两次 MCP、派三次子代理、执行两次插件带来的动作、走两次 SDK 回调。

最后定时器触发下一轮巡检，收尾写审计。八种机制全部出现。这张表的价值在于：它把「八种机制」从清单变成了一条时间线上的位置。

二、统计：八个都在，分布极不均

一共二十次。钩子四次最多，技能、子代理、插件各三次，指令文件、MCP、SDK 各两次，无人值守一次。钩子最多不是巧合：它是唯一一种「每次工具调用都可能触发」的机制。无人值守最少也是必然：它决定的是「要不要有人坐在前面」，这件事一次任务只决定一次。

所以次数多少不说明重要性。它说明的是「这个机制在什么粒度上起作用」。

三、按出场位置分三组

第一组：本来就有的——指令文件、技能、子代理、钩子、MCP。跑起来就在。第二组：从外面装进来的——插件、SDK。它们改变的是「能力的来源」。第三组：决定怎么启动的——无人值守。它一旦打开，前两组都变成后台进程。

三组的分法比「八种并列」有用：前五种是「日常调」，中间两种是「一次性接」，最后一种是「换工作方式」。遇到问题时也按这三组排查：日常的不对查配置，接进来的不对查版本，换了工作方式不对查权限。

四、八种机制的一句话定位

指令文件：长期规矩，每次都在，占常驻预算。技能：按需展开的方法，平时只有名字，用到才读正文。子代理：隔离出来的上下文，过程不留主线，只回结论。

钩子：一定会执行的拦截与记录，不靠模型自觉。 MCP：接外部系统的通道，工具越多常驻越贵。插件：把一堆配置打成包，装、升、审都靠版本号。

SDK：把 agent 嵌进自己的程序，控制点最多，也最重。无人值守：不用人坐在前面，用于定时、CI、批量。八句话里有一半在讲代价，这是有意的：每个机制都是拿一样东西换另一样。

五、本章小结

第 10 章讲工程化，八节收在一句话上：前面九章是「能做」，这一章是「敢用」。 10.1 成本：四个价；先换模型、再开缓存、再砍上下文、最后才管输出。 10.2 调试：三层证据从外往里看；日志最划算，完整流答得出「为什么」。

10.3 安全：六条准则落到字段上，最松的过一条、最严的也漏一条。 10.4 大仓库：全量读是基准，搜索省到一成，子代理再省到五十分之一。 10.5 指令：能落成检查的才叫要求，落不成的只是希望。

10.6 团队：四级配置各按各的规则合；禁止清单只能加不能减。 10.7 生态：四层不必全上，层数是任务越界逼出来的。 10.8 全局：八种机制在一次任务里都出现，但位置分三组。

全书到这里收尾。真正要带走的是那句：每个机制都在回答「谁来做这个决定」。把这些决定一个个交出去，你才敢让它自己跑。

六、动手 Demo：一次任务二十步，八种机制各出现几次

一条二十步的时间线，逐步标出动用的机制，最后统计各出现几次、第一次在第几步。这一节也是第 10 章和全书的收尾。

cnt = {}
for _i, _what, mech in TIMELINE:
    cnt[mech] = cnt.get(mech, 0) + 1

for mech, n in sorted(cnt.items(), key=lambda kv: (-kv[1], kv[0])):
    first = [i for i, _w, m in TIMELINE if m == mech][0]

实跑输出：

--------------------------------------------------------------------
一次任务二十步，八种机制各出现几次
--------------------------------------------------------------------

  全书的八种机制，放进一次真实任务里数一遍，看它们各在什么时候出场。
  这一节也是第 10 章和全书的收尾。

  ① 真跑：二十步里数一遍
  --------------------------------------------------------------------
| 步 | 发生了什么 | 动用的机制 |
|---:|---|---|
|  1 | 启动，读 CLAUDE.md | CLAUDE.md |
|  2 | 拿到技能清单 | Skills |
|  3 | 触发「发布检查」技能 | Skills |
|  4 | PreToolUse 拦下危险命令 | Hooks |
|  5 | 调 MCP 查订单表 | MCP |
|  6 | 派子代理去查支付模块 | 子智能体 |
|  7 | 子代理回三行结论 | 子智能体 |
|  8 | PostToolUse 记一条审计 | Hooks |
|  9 | 调 MCP 查库存表 | MCP |
| 10 | 执行插件带来的命令 | Plugin |
| 11 | 插件里的钩子触发 | Plugin |
| 12 | 再派一个子代理 | 子智能体 |
| 13 | 触发「写测试」技能 | Skills |
| 14 | PostToolUse 拦下改 .env | Hooks |
| 15 | SDK 流式回调吐一条 | SDK |
| 16 | SDK 权限回调问一次 | SDK |
| 17 | 定时器触发下一轮巡检 | Headless |
| 18 | 压缩后重新注入 CLAUDE.md | CLAUDE.md |
| 19 | 插件的技能被调用 | Plugin |
| 20 | 收尾写审计日志 | Hooks |


  ② 统计：八个都在，分布极不均
  --------------------------------------------------------------------
| 机制 | 出现几次 | 什么时候 |
|---|:---:|---|
| Hooks | 4 次 | 第 4 步首次出现 |
| Plugin | 3 次 | 第 10 步首次出现 |
| Skills | 3 次 | 第 2 步首次出现 |
| 子智能体 | 3 次 | 第 6 步首次出现 |
| CLAUDE.md | 2 次 | 第 1 步首次出现 |
| MCP | 2 次 | 第 5 步首次出现 |
| SDK | 2 次 | 第 15 步首次出现 |
| Headless | 1 次 | 第 17 步首次出现 |

  八种机制全部出现，一共 20 次。出现最多的是 Hooks。
  最少的只有一次，它不在「跑起来之后」，而在「怎么启动」。

  ③ 按出场位置分三组
  --------------------------------------------------------------------
  - 本来就有的：CLAUDE.md 2 次、Skills 3 次、子智能体 3 次、Hooks 4 次、MCP 2 次
  - 从外面装进来的：Plugin 3 次、SDK 2 次
  - 决定怎么启动的：Headless 1 次
  第一组是 agent 本身带的，跑起来就在。第二组是从外面接进来的能力。
  第三组决定「要不要有人坐在前面」——它一旦打开，前两组都变成后台进程。

  ④ 八种机制的一句话定位
  --------------------------------------------------------------------
| 机制 | 一句话定位 | 你要付的代价 |
|---|---|---|
| CLAUDE.md | 长期规矩 | 每次都在，占常驻预算 |
| Skills | 按需展开的方法 | 平时只有名字，用到才读正文 |
| 子智能体 | 隔离出来的上下文 | 过程不留主线，只回结论 |
| Hooks | 一定会执行的拦截与记录 | 不靠模型自觉 |
| MCP | 接外部系统的通道 | 工具越多，常驻越贵 |
| Plugin | 把一堆配置打成包 | 装、升、审，都靠版本号 |
| SDK | 把 agent 嵌进自己的程序 | 控制点最多，也最重 |
| Headless | 不用人坐在前面 | 定时、CI、批量 |


  ⑤ 本章小结
  --------------------------------------------------------------------
  第 10 章讲工程化，八节收在一句话上：前面九章是「能做」，这一章是「敢用」。
  10.1 成本：四个价；先换模型、再开缓存、再砍上下文、最后才管输出。
  10.2 调试：三层证据从外往里看；Hook 日志最划算，完整流答得出「为什么」。
  10.3 安全：六条准则落到字段上，最松的过一条、最严的也漏一条。
  10.4 大仓库：全量读是基准，搜索省到一成，子代理再省到五十分之一。
  10.5 指令：能落成检查的才叫要求，落不成的只是希望。
  10.6 团队：四级配置各按各的规则合；deny 只能加不能减。
  10.7 SDD 生态：四层不必全上，层数是任务越界逼出来的。
  10.8 全局：八种机制在一次任务里都出现，但位置分三组。
  全书到这里收尾。真正要带走的是那句：每个机制都在回答「谁来做这个决定」。
  把这些决定一个个交出去，你才敢让它自己跑。
  ! 二十步的时间线是为演示编排的，不是一次真实会话的完整记录；次数按编排统计。

①二十步里八种机制全部出现：钩子四次最多，技能、子代理、插件各三次，指令文件、MCP、SDK 各两次，无人值守一次。 ②次数多少不说明重要性，说明「在什么粒度上起作用」：钩子每次工具调用都可能触发，无人值守一次任务只决定一次。 ③按出场位置分三组：本来就有的（前五种）、从外面装进来的（插件、SDK）、决定怎么启动的（无人值守）。 ④八句话里有一半在讲代价：每个机制都是拿一样东西换另一样。全书那句总结是——每个机制都在回答「谁来做这个决定」。

30 秒实验

把「无人值守」那一步去掉，重跑一遍。统计表里少了什么？少了它，这次任务还能跑完吗？
把子代理那三次换成主线直接读，重跑一遍。哪一组的次数会大幅上涨？这说明子代理在替谁干活？
给自己最近一次用 agent 干的活列一条时间线，标出用到了哪几种机制。哪一种完全没出现？是没必要，还是没想到？

常见误区

把八种机制当成并列的清单去背。它们按出场位置分三组，组内才可比。
以为出现次数多就重要。次数说明粒度，不说明重要性。
八种全上。每一种都有代价，用不上的就是纯成本。
只盯着机制，忘了它们都在回答同一个问题：这个决定谁来拍。
学完机制就以为会用了。会用的标志是「知道什么时候不用」。

自测三问（点开对答案）

1. 八种机制按出场位置分哪三组？ —— 本来就有的（指令文件、技能、子代理、钩子、MCP）、从外面装进来的（插件、SDK）、决定怎么启动的（无人值守）。 2. 为什么钩子出现次数最多、无人值守最少？ —— 钩子每次工具调用都可能触发，粒度最细；无人值守一次任务只决定一次，粒度最粗。 3. 全书那句总结是什么？ —— 每个机制都在回答「谁来做这个决定」。把这些决定一个个交出去，才敢让它自己跑。

全书到此完结。接下来最值得做的一件事：挑一个你手上的真实任务，按 10.7 那四层过一遍，看缺哪层。

☐ （全书完）