四个判据：必须每次做吗、能用规则判吗、失败了要不要阻断、慢不慢。 四个答案决定三件事：做不做钩子、用哪种处理器、同步还是异步。 顺序不能反。先判「是不是每次都要做」，不是就出局；再挑最便宜的处理器；最后定同步异步。
前十节是零件和实战，这一节收口。这一节也是第 5 章的最后一篇，本章小结并在末尾。 这一节的东西可以直接当决策清单用：来一个需求，四条问一遍，结论就出来了。
一、第一判据：必须每次做吗
问法：漏一次会不会出事？ 会 → 钩子。不会 → 技能或子智能体。 这是第一判据，因为钩子的价值全在「不漏」。能不遗漏地做一件事，是它唯一的优势。
如果一件事漏了也不出事，做成钩子只是白占一条配置——而且每次执行都要花时间。 反过来，一件事漏一次就出事，那它必须是钩子，哪怕它很慢、哪怕它不好写。 演示里八个需求，五个过了这一关，三个没过。 没过的三个有个共同点：它们的产出是一份内容，不是一个动作。
二、第二判据：能用规则判吗
问法：一行命令写得出来吗？ 能 → command。不能，但能用一段话描述判断标准 → prompt。需要看多个文件、跑测试 → agent。 这一条决定成本。command 不花 token，prompt 一千二，agent 九千起（5.4 节）。
顺序不能反：先挑 agent 再去找活，会写出很贵的东西。 一个具体的检验办法：把你的判断标准写成一句话，然后问「一个初级工程师照这句话能不能做对」。 能，就是规则；不能，才需要模型。
三、第三判据：失败了要不要阻断
问法：这个钩子出错，会不会影响这次改动的正确性？ 会 → 同步，等它。不会 → 可以异步（5.9 节）。 这一条决定的是「能不能异步」，而异步是解决慢的唯一办法。
注意「阻断」有两个层次：一是它的返回值要影响主流程（拦、注入、门控），二是它失败了要让人知道。 前者必须同步，后者可以异步加告警。 分清这两层，很多纠结就没有了：审计失败要告警，但不必阻断。
四、第四判据：慢不慢
这一条不是判据，是提醒：如果一个钩子必须同步、又很慢，那就得回去改它的工作量。 办法有两个：缩小作用域（只跑受影响的测试），或者换位置（放到更稀疏的事件上）。 演示里八个需求有一个是「慢」的：语义判断类的，用 prompt 或 agent，本身就慢。所以它被归到异步。
但如果一个语义判断的结论必须阻断主流程， 那它就不能异步——这时候要考虑的是「这个判断真的必须每次都做吗」，回到第一判据。 四个判据是个闭环：第四关过不去，就往回走一层。
五、本章小结
第 5 章讲钩子。十一节收在一句话上：模型决定做什么，钩子决定什么必须做、什么时候不许做。 5.1 定位：三种机制里只有钩子的触发权不在模型手上。 5.2 生命周期：事件分五组，最关键的维度是「能不能阻止」。
5.3 配置：六个位置，钩子是合并的——重复注册会重复执行。 5.4 三种处理器：命令、单次评估、多轮验证，是确定性的阶梯也是成本的阶梯。 5.5 协议：一段 JSON，字段错一个就静默失效，reason 是给模型看的指令。
5.6 安全：拦危险命令和敏感文件，误拦比漏拦更贵。 5.7 质量：格式化归工具、规则归 lint、能不能交归测试。 5.8 子智能体钩子：进去注入什么、出来验收什么。
5.9 异步：能异步的前提是「失败不影响正确性」。 5.10 调试：钩子不报错，所以必须有日志。 5.11 方法论：四个判据，先判「是不是每次都要做」。
下一章换一块：MCP。前面讲的都是「本地怎么组织」，下一章讲「怎么把外部系统接进来」。
六、动手 Demo：八个需求，用四个判据决定做成什么
八个需求，四条判据逐个问一遍，最后给出结论：做不做钩子、用哪种处理器、同步还是异步。 四个判据的顺序不能反，反了会写出很贵的东西。
REQ = [(u"改完 py 文件自动格式化", True, u"规则", False),
(u"危险命令拦截", True, u"规则", False),
(u"这次改动有没有引入逻辑错误", True, u"语义", True)]
if not must:
what = u"技能或子智能体" # 第一判据出局
else:
what = u"钩子·%s" % kind
实跑输出：
--------------------------------------------------------------------
八个需求，用四个判据决定做成什么
--------------------------------------------------------------------
四个判据：必须每次做吗、能用规则判吗、失败了要阻断吗、慢不慢。
四个答案决定三件事：做不做钩子、用哪种处理器、同步还是异步。
① 四个判据
--------------------------------------------------------------------
| 判据 | 问什么 | 怎么用 |
|---|---|---|
| 必须每次做吗 | 漏一次会不会出事 | 会 → 钩子；不会 → 技能 |
| 能用规则判吗 | 一行命令写得出来吗 | 能 → command；不能 → prompt 或 agent |
| 失败要阻断吗 | 错了要不要停下来 | 要 → 同步；不要 → 异步 |
| 慢不慢 | 会不会拖住主流程 | 慢 → 仔细想要不要挂 |
② 八个需求逐个过
--------------------------------------------------------------------
| 需求 | 每次 | 判定 | 慢 | 结论 |
|---|---|---|---|---|
| 改完 py 文件自动格式化 | 是 | 规则 | 否 | 钩子·规则·同步 |
| 危险命令拦截 | 是 | 规则 | 否 | 钩子·规则·同步 |
| 提交信息少于十个字就提醒 | 是 | 规则 | 否 | 钩子·规则·同步 |
| 这次改动有没有引入逻辑错误 | 是 | 语义 | 是 | 钩子·语义·异步 |
| 每次会话开始注入当前分支 | 是 | 规则 | 否 | 钩子·规则·同步 |
| 生成一份本周改动摘要 | 否 | 语义 | 是 | 技能或子智能体 |
| 审两百个文件汇总问题 | 否 | 语义 | 是 | 技能或子智能体 |
| 解释这段代码什么意思 | 否 | 语义 | 否 | 技能或子智能体 |
八个里五个该做成钩子，三个不该。不该的那三个有个共同点：它们的产出是一份内容，不是一个动作。
③ 为什么「每次都要做」是第一判据
--------------------------------------------------------------------
因为钩子的价值全在「不漏」。能不遗漏地做一件事，是它唯一的优势。
如果一件事漏了也不出事，那做成钩子只是白占一条配置——而且每次执行都要花时间。
反过来，一件事漏一次就出事，那它必须是钩子，哪怕它很慢、哪怕它不好写。
④ 三个判据的先后
--------------------------------------------------------------------
先判「是不是每次都要做」，不是就出局；再判「能不能用规则判」，能就用最便宜的 command；
最后判「失败了要不要阻断」，决定同步还是异步。
顺序反了会写出很贵的东西：先挑了 agent，再去找一个其实一行 grep 就能干的活。
⑤ 本章小结
--------------------------------------------------------------------
第 5 章讲钩子。十一节收在一句话上：模型决定做什么，钩子决定什么必须做、什么时候不许做。
5.1 定位：三种机制里只有钩子的触发权不在模型手上。
5.2 生命周期：事件分四组，最关键的维度是「能不能阻止」。
5.3 配置：六个位置，钩子是合并的——重复注册会重复执行。
5.4 三种处理器：命令、单次评估、多轮验证，是确定性的阶梯，也是成本的阶梯。
5.5 协议：输出是一段 JSON，字段错一个就静默失效，reason 是给模型看的指令。
5.6 安全：拦危险命令和敏感文件，误拦比漏拦更贵。
5.7 质量：格式化归工具、规则归 lint、能不能交归测试。
5.8 子智能体钩子：进去时注入什么、出来时验收什么。
5.9 异步：能异步的前提是「失败不影响正确性」。
5.10 调试：钩子不报错，所以必须有日志。
5.11 方法论：四个判据，先判「是不是每次都要做」。
下一章换一块：MCP。前面讲的都是「本地怎么组织」，下一章讲「怎么把外部系统接进来」。
①第一判据「每次都要做吗」是闸门：八个里五个过，三个出局。 出局的三个有个共同点——它们的产出是一份内容，不是一个动作。 ②第二判据「能用规则判吗」决定成本：command 不花 token、prompt 一千二、agent 九千起。 顺序不能反，先挑 agent 再找活会写出很贵的东西。 ③第三判据「失败了要不要阻断」决定同步还是异步。它有两层：返回值要影响主流程，还是只需要让人知道。 前者必须同步，后者可以异步加告警。 ④第四判据不是判据，是提醒：必须同步又很慢的钩子， 该改的是它的工作量——缩小作用域或者换到更稀疏的事件上。 四个判据是个闭环：第四关过不去，就往回走一层，重新问「这个判断真的必须每次都做吗」。
30 秒实验
- 给八个需求加一条「提交时跑全量测试（三分钟）」，四条判据走一遍。它该做成什么？ 如果必须同步，第四判据会要求你改什么？
- 把「这次改动有没有引入逻辑错误」的结论改成「只记录不阻断」，重跑一遍。它从同步变成什么？ 风险是什么？
- 拿你自己项目里的一件烦事，四条判据走一遍。结论和你现在的做法一样吗？不一样的话，差在哪一条？
常见误区
- 跳过第一判据直接挑处理器。会写出很贵的东西：先选了 agent，再去找一个 grep 就能干的活。
- 把「产出内容」的需求做成钩子。钩子管动作，不管内容；产出内容是技能或子智能体的活。
- 让必须阻断的钩子走异步。异步返回不了决定，拦不住。
- 把慢的钩子直接改成异步。该改的是工作量，不是跑法。
- 四个判据只看前两个。忘了「失败要不要阻断」，就会写出一个「拦了但没拦住」的钩子。
自测三问（点开对答案）
1. 四个判据分别决定什么？ —— 必须每次做吗（做不做钩子）、能用规则判吗（哪种处理器）、失败要不要阻断（同步还是异步）、 慢不慢（要不要改工作量）。 2. 为什么第一判据是闸门？ —— 因为钩子的价值全在「不漏」。漏了不出事的需求做成钩子，只是白占配置还要花时间。 3. 一个必须同步又很慢的钩子，该怎么处理？ —— 改它的工作量：缩小作用域（只跑受影响的测试），或者换到更稀疏的事件上。 也可以回头问「这个判断真的必须每次都做吗」。第 5 章到此收尾。下一章讲 MCP：前面都是「本地怎么组织」，下一章讲「怎么把外部系统接进来」。
- ☐ （本篇完，下一篇 6.1 从 M×N 到 M+N：标准化的力量）
相关笔记
- 处理器类型：三种处理器的成本
- 异步 Hooks：什么情况下能异步
- Claude Code 橙皮书 · 索引
- 🐎 Claude Code 实战 · 索引