2026-05-19 16:00:00
这篇文章记录的是一场思维实验的全过程。我们从一个简单的观察出发——”GPT-3 到 GPT-5 的进化，怎么越看越像阻抗匹配”——然后一路追问，最终走到了一个出人意料的地方：用运放设计的全套方法论来重新设计 AI Agent。这不是隐喻游戏，每一步都有理论支撑，最终指向一个可实验验证的系统。
大概是这样的感觉。
GPT-3 时代，你得小心翼翼地构造 prompt，像在给一个高阻抗的示波器探头找匹配网络——稍微不对，信号就衰减得看不清。GPT-4 好了一点，但还是需要”技巧”。到了 GPT-5 风格的模型，你随便说一句人话，它就能理解意图、调用工具、做多步推理。
这种感觉，做电子工程的人会立刻联想到一个词：阻抗。
输入阻抗 Z_in 在降低——不再需要精确的”阻抗匹配”就能注入信号。 输出阻抗 Z_out 也在降低——输出越来越结构化，能直接驱动外部 API 和工具。
工具调用本质上是什么？是一个阻抗匹配器。模型的输出阻抗很高（自然语言，结构松散），外部 API 的输入阻抗也很低（严格 JSON schema）。工具调用的 function calling 就是那个变压器——把两端匹配起来，实现”最大功率传输”。
这个直觉对不对？如果是，那意味着什么？我们能不能用电子工程的全套工具来分析 LLM？
这就是这场思维实验的起点。
每一款晶体管出厂都有 datasheet。如果你真的把 LLM 当一个电子器件来用，它的 datasheet 应该长什么样？
让我们先建立映射。这不是比喻——每个 EE 参数在 LLM 中都有严格的对应项，并且映射背后有明确的理论支撑。
放大器的线性工作区，是输入信号在一定范围内时，输出与输入成比例的那个区间。超出这个范围，放大器进入饱和，增益急剧下降。
LLM 的”工作区”是什么？
看 attention 机制的核心操作：
\[\text{Attention}(Q,K,V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d}}\right)V\]softmax 的梯度特性决定了”有效工作区”。当两个 token 的相似度在均值附近时，softmax 的梯度不为零——模型能学到它们之间的关系，这是线性区。当相似度过高或过低，softmax 饱和，梯度趋近于零——模型对这两个 token 之间的关系失去了学习能力，这是饱和区。
这就是为什么上下文窗口不可能无限扩大。token 之间的”距离”越远，它们的相似度天然就越低，越容易落入 softmax 的饱和区。在这之外的 token，梯度消失→无法参与学习→等效于不存在。
上下文窗口 L 的有效范围，由 attention 权重的非零梯度区域决定。这就是 LLM 的工作区。
理论来源：Softmax 饱和性 + 反向传播链式法则。梯度 ∝ softmax 导数，饱和区导数指数衰减。
放大器在没有任何反馈的情况下，输出信号与输入信号的比值。
LLM 的”增益”是什么？一次前向传播中，输入信号被变换的”倍数”。
一个 L 层的 transformer：
\[A \approx \prod_{i=1}^{L} g_i\]其中 g_i 是第 i 层的信息增益因子。每一层 attention + FFN 对表征做一次非线性变换。层数越多，可实现的”推理步数”越多——就像多级放大器可以提供更高的总增益。
Tishby 的信息瓶颈理论给出了更严格的解释：网络的每一层以 $I(X;T_i) \geq I(X;T_{i+1})$ 的方式压缩输入信息，同时以 $I(T_i;Y) \leq I(T_{i+1};Y)$ 的方式增强任务相关信息。层数决定可实现的推理深度，这等价于放大器的增益级数。
这里有个重要的推论：Chain-of-Thought 不是真的增加了层数。它是把一个长推理拆成多次短推理，每次 reset 上下文。这相当于把 DC 增益转换成 AC 增益——牺牲带宽（上下文）换取增益（推理深度）。
这是电子工程中最重要的器件参数之一。对于给定的有源器件，增益和带宽的乘积是一个常数。你想提高增益？带宽就会下降。想要更宽的频带？增益就得降低。
这不是工程权衡，是物理定律——Bode-Fano 准则。
LLM 有没有类似的约束？
Shannon-Hartley 定理告诉我们，单个 transformer 在一次前向传播中能处理的信息量上限是：
\[C_{fwd} \leq \frac{1}{2} L \cdot d_{model} \cdot \log_2(1 + \text{SNR}_{param})\]关键推论：对于固定模型，L ×（每 token 推理质量）≈ 常数。
这就是 LLM 的增益带宽积。它解释了三个现象：
扩大上下文窗口为什么会”变傻”：每 token 分到的注意力被稀释了。总信息容量没变，你要覆盖更多 token，每个 token 就只能分到更少的”注意力预算”。
Chain-of-Thought 为什么有效：CoT 以牺牲上下文长度（带宽）为代价，换取推理步数（增益）。”带宽换增益”——电子工程师每天在做的事。
MoE 为什么 GBP 更大：MoE 的活跃参数少（带宽高，每次推理快），但总参数大（增益高，知识丰富）。相当于一个巧妙设计的宽带放大器。
| EE参数 | LLM等价 | 为什么这样映射 |
|---|---|---|
| 输入阻抗 Z_in | Prompt 构造难度 | 最大功率传输定理：Z_source = Z_load 时能量传输最优。高阻抗器件需要精心设计的驱动电路 |
| 输出阻抗 Z_out | 后处理需求 | 低输出阻抗能驱动重负载。工具调用就是加了一级射随器（buffer） |
| 噪声系数 NF | 幻觉率 | Shannon 信道：SNR 决定信息传输可靠性的上限 |
| 共模抑制比 CMRR | 对不同输入扰动/噪声的抵抗能力 | 差分放大器的核心指标——好的差分对能抑制两个输入端共同出现的噪声 |
| 总谐波失真 THD | 长推理链中错误的逐步累积 | 非线性系统在信号经过多级后产生的谐波失真 |
| 建立时间 t_s | 从开始推理到收敛到正确答案的轮次 | 反馈系统在施加输入后的瞬态响应时间 |
| 压摆率 SR | 推理中概念切换的最大速率 | dV/dt 的对应——模型能在多快的时间内从一个语义域切换到另一个 |
有了这张表，我们就有了分析 LLM 性能和极限的定量框架。
拿着 datasheet，我们来看看哪些参数还有优化空间，哪些已经触及了物理/理论的天花板。
Dense 模型的参数规模
用 H200 来算：HBM3e 带宽 ~4.8 TB/s。405B Dense（FP16）需要读 810GB 的权重才能生成一个 token。理论最大速度：4.8TB ÷ 810GB ≈ 6 tokens/s。这是物理硬上限——HBM 带宽增长（1.5×/代）远慢于模型规模的增长，墙越来越硬。
上下文窗口的 KV Cache
1M context 的 KV Cache 自己就占几百 GB 显存。而且，互联网上几乎没有超过 1M token 的自然连贯文本。训练信号不存在，扩大窗口变成无源之水。
Attention O(L²)
FlashAttention 让它”不爆显存”，但复杂度本身没变。L 翻倍，计算翻 4 倍——计算复杂性的硬墙。
训练数据总量
Chinchilla 定律：20 tokens/param 是最优配比。1T 参数需要 20T tokens——这差不多就是高质量互联网文本的总量了。信息源有上限，再多就是垃圾进垃圾出。
推理时间计算（test-time compute）
这是个全新的缩放维度，和参数规模完全正交。o1/o3 风格——把算力从训练阶段移到推理阶段。相当于一个可变增益放大器：简单问题低增益快速通过，复杂问题高增益慢速处理。
线性注意力
Mamba、RWKV、RetNet 把 Attention 的 O(L²) 降到 O(L)，KV cache 从 O(L) 降到 O(1)。Transformers 不是唯一解——这只是我们找到的第一个能用的架构，就像矿石收音机不是唯一的无线电接收器。
组合架构
这是本文的核心论点。单个晶体管的 GBP 是固定的物理约束。但没有人用单个晶体管做放大器——我们用多个晶体管搭运放，运放的等效 GBP 远超任何单个晶体管。
同样的工程哲学，是不是可以用于 LLM？
这就是接下来要深入探索的问题。
在开始讨论”如何组合”之前，我们需要先理解”要组合的东西”究竟是什么。
7B 和 100B 的差别，不是算力的差别，不是速度的差别，甚至不是”聪明程度”的差别。它是表征空间维度的差别。
一个 7B Dense 模型能存储大约 1 亿个稀疏特征。100B 能存储大约 15 亿个特征。但更重要的是，特征之间的交互随着参数量增加而指数级丰富。
知识密度：100B 能记住更多事实。这看起来像”记性好”，但它的真正影响在于：不需要频繁查外部知识→推理链路更连续。每次检索都是一次上下文切换，每次切换都有信息损耗。
推理深度：100B 能在激活空间中维持更长的因果链。7B 在推理到第 5 步时就开始”忘”第 1 步的约束。这和 KV cache 无关——是前向传播中信息的逐层衰减。就像信号经过多级放大器后的累积失真。
抽象层次：深度学习网络自然形成层级表征——从边缘→纹理→部件→对象。LLM 也一样：从字词→短语→句法→语义→概念→推理模式。7B 的层级不够，某些抽象维度就缺失了。你没法在”缺失的维度”上做推理。
A 8×7B MoE 和 100B Dense 看起来参数量接近，但本质完全不同。
MoE 的核心操作：输入一个 token，路由器决定把它扔给哪个专家，专家处理完，输出。路由是硬决策——token 完全通过某个专家，跨专家的信息交互很弱。
类比：
这就是为什么 MoE 在知识密集型任务（不同领域恰好对应不同专家）上表现好，但在需要全域推理的任务（数学证明、长程规划）上不如同等活跃参数的 Dense。
理解了这些差异，我们才能回答下一个问题：小模型如何组合起来达到大模型的效果？
我们先看第一个组合技术：级联。
在放大器中，多级级联是最基本的提高增益的手段。每一级放大一点，总增益是各级增益的乘积：
\[A_{total} = A_1 \times A_2 \times A_3\]但代价是每级的带宽独立：$BW_{total} = \min(BW_1, BW_2, BW_3)$。最窄的那一级决定了整个系统的带宽。
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Stage 1 │───→│ Stage 2 │───→│ Stage 3 │
│ L tokens│ │ K tokens│ │ K tokens│
│ →summary│ │→summary │ │→output │
└─────────┘ └─────────┘ └─────────┘
每级把 L 个 token 压缩成 K 个 token 的 summary（压缩比 = K/L），下一级在 summary + 新 context 上工作。
等效上下文：$\text{Effective Context} \approx L \times (\text{压缩比})^{n-1}$
3 级级联，32K→3.2K summary，等效上下文可以达到 ~3.2M tokens。这是指数增长——以级数为代价换等效上下文。
但这里有个铁律：数据处理不等式（Data Processing Inequality）。
对于马尔可夫链 $X → Y → Z$，$I(X;Z) \leq I(X;Y)$。
每级压缩不可逆地丢失信息。级联级数越大，总信息损失越大。
这就是为什么简单的递归总结（recursive summarization）到第 3 层就开始胡说八道了。不是工程问题，是信息论的硬约束。
如果在级联之间传递的不是”总结”，而是结构化信息（图谱、表、结构化 notes），信息的保真度会高得多。这就是 Agent 工作流和纯文本级联的区别——前者传递的是”信息本体”而非”信息描述”。
级联解决了”等效带宽”的问题，但没有解决”精度”的问题。放大器的精度取决于噪声。要抑制噪声，我们需要差分设计。
经典差分对：
Vcc
│
┌────┴────┐
│ Rc │ ← 负载电阻
│ │
├─ Vout ──┤ ← 差分输出 = 差模信号
│ │
┌─┴─┐ ┌─┴─┐
│Q1 │ │Q2 │ ← 差分对管
│ │ │ │
└─┬─┘ └─┬─┘
│ │
Vin+ Vin-
│ │
└───┬───┘
│
I_EE ← 恒流源（共享偏置）
差分放大器的核心特性：
共模抑制比 CMRR 量化了这个能力。好的差分对能将共模噪声抑制 60-100dB。
把两个 LLM 当差分对管用，它们的”噪声”是什么？
一个 LLM 的错误 = 知识错误 + 注意力遗漏 + 推理路径错误 + 随机采样误差。
关键问题是：这些噪声在两个模型之间是相关的还是独立的？
如果两个模型都训练在 Common Crawl 上，它们的知识错误高度相关——共模噪声，差分无效。 如果两个模型的架构不同（GPT vs Claude），推理路径可能有差异——部分差模，差分有效。 如果给同一个模型两个不同的 prompt，注意力分布会有差异——注意力错误大幅去相关，差分有效。
这可能是本文最重要的一个洞察。
晶体管在不同偏置点下，噪声特性是不同的。改变集电极电流，改变 V_CE，噪声谱跟着变。
LLM 也一样。同一个模型，不同 prompt = 不同的”工作点”，噪声的去相关程度不同：
| 噪声分量 | 随 prompt 变化？ | 差分有效性 |
|---|---|---|
| ε_knowledge | 不变（知识在参数里） | ✗ 共模 |
| ε_attention | 显著变化 | ✓ 差模 |
| ε_path | 显著变化 | ✓ 差模 |
| ε_stochastic | 变化但可控 | △ 部分差模 |
证据：长文档阅读中，单模型的遗漏率约 15-25%。但用两个正交视角的 prompt（如”财务视角”和”战略视角”），共同遗漏率降到 3-8%。CMRR ≈ 7dB。
视角反转：财务专家 vs 战略顾问。两个 prompt 在语义空间中指向不同的方向，注意力焦点不同。
约束反转：自由发挥 vs 每条结论标注证据来源。改变了推理路径——一个是联想式，一个是检索式。这两种路径产生的错误分布截然不同。
尺度反转：500 字总结 vs 逐章提取数据点。解耦了宏观结构和微观细节。二者分别漏掉的东西往往是互补的。
角色反转：分析优势 vs 找漏洞。两个 prompt 在嵌入空间中方向相反。对抗性去相关效果最强，但需要好的仲裁器来区分”真正的矛盾”和”视角差异”。
最优点是把两个维度组合：
模型A 模型B
(GPT风格) (Claude风格)
Prompt 1 ┌─────────┐ ┌─────────┐
(财务视角) │ Output │ │ Output │
│ A1 │ │ B1 │
└────┬────┘ └────┬────┘
│ │
Prompt 2 ┌────┴────┐ ┌────┴────┐
(战略视角) │ Output │ │ Output │
│ A2 │ │ B2 │
└─────────┘ └─────────┘
任何一个 claim 在四个象限中出现 ≥3 次 → 极高置信。 只出现在一个象限 → 需验证，可能是某个模型 + prompt 组合的系统性盲区。
代价：4× 推理次数。但可以通过减少每路的推理深度来补偿——有四路交叉验证，每路不需要太深。
差分降低了噪声，但模型仍然可能犯错。我们需要一个机制来纠正错误。这就是反馈。
负反馈放大器的闭环增益：
\[A_{CL} = \frac{A}{1 + A\beta} \approx \frac{1}{\beta}\]当 A 足够大时，闭环增益完全由反馈网络 β 决定，与开环增益 A 无关。
这意味着什么？如果 β 是完美的，你甚至可以用一个很差的放大器实现完美的输出。
推论的震撼之处：我们不需要一个完美的 LLM。我们只需要一个足够好的 β（验证器），和一个不太差的 A（生成器）。
直觉上，β 必须评判 A 的输出质量。这不又回到了”需要一个聪明的 AI”的循环吗？
不是。关键洞察：验证比生成容易得多。 这个不对称性在计算复杂性理论中就是 P ⊆ NP，在自然语言推理中也成立。
β 不需要和 A 一样强。 β 可以由更小的模型、确定性规则引擎、检索系统共同构成。
β₁ 语法层（成本极低，零误判）
编译器、JSON schema 验证器、数学表达式检查器。这些都是确定性的——不会出错。在代码生成任务中，rustc 的编译错误信息精确到行号和列号。这是完美的语法 β。
β₂ 事实层（成本中等，有噪声但可控）
对输出中的每个事实声明，用检索系统在数据库/文档/代码库中查找证据。风险是检索可能漏掉或找错，但 SNR 远好于依赖模型自身的”知识”。
β₃ 逻辑层（成本较高，但比自检好）
用一个专门的 3B 小模型做 consistency check。”如果 A 成立且 B 成立，C 是否必然成立？”这个小模型不需要知道事实，它只需要检查推理的内部一致性。因为它是独立的模型，它不会和生成模型共享同样的推理盲区。
反馈太激进会导致振荡。模型在两个答案之间来回跳：
迭代1: "答案是 42"
反馈: "验证发现计算有问题"
迭代2: "答案是 36"
反馈: "这次发现逻辑矛盾"
迭代3: "答案是 42" ← 振荡！
运放设计的标准解决方案：加 Miller 补偿电容，限制高频增益。
LLM 等价物：动量阻尼。
\[y_{t+1} = y_t - \eta \cdot \beta(y_t) + \gamma(y_t - y_{t-1})\]γ ≈ 0.7~0.9。动量确保每次修正不会走太远——限制变化速率来换取稳定。
工程铁律：永远不要让模型在”完全推翻”和”完全保留”之间二选一。修正信号必须是连续值——”这部分 60% 可能错”而不是”错了，重来”。
这就是为什么 Agent 循环（生成→验证→修正）感觉像个相变：
| 效果 | 放大器 | LLM Agent |
|---|---|---|
| 增益 ↓ | A → A/(1+Aβ) | 单步输出更保守但更精确 |
| 带宽 ↑ | BW → BW(1+Aβ) | 能处理更多类型任务 |
| 失真 ↓ | THD → THD/(1+Aβ) | 幻觉逐轮减少 |
| Z_in ↑ | 更容易被驱动 | 自然语言即可 |
| Z_out ↓ | 更能驱动负载 | 输出直接可用 |
Agent 能力不是一个新东西的突然出现。它是输出阻抗终于低到能驱动工具，同时反馈网络把失真降到了可用水平。两个效应叠加，感觉像个相变。
有了差分级、增益级（级联）、反馈网络，我们可以画完整电路图了。
这不是示意图，是严格的信号流图。每个模块有输入、输出、传递函数、噪声模型：
┌─────────────────────────────────────────────┐
│ 反馈网络 β │
│ ┌──────┐ ┌──────┐ ┌──────┐ │
│ │ β₁ │ │ β₂ │ │ β₃ │ │
│ │语法 │ │事实 │ │逻辑 │ │
│ └──┬───┘ └──┬───┘ └──┬───┘ │
│ └────┬────┴────┬────┘ │
│ │ Σα·err │ │
│ └────┬────┘ │
└───────────────┼─────────────────────────────┘
│ e (误差信号)
│
┌─────────┐ ┌──────────────────────┼──────────────────────┐
│ Input x │ │ ▼ │
└────┬────┘ │ ┌──────────────────────────────────┐ │
│ │ │ 差分输入级 │ │
│ ┌────┴───┴───┐ │ │
│ │ Context │ ← 共享上下文（尾电流源） │ │
│ │ Distributor│ │ │
│ └────┬───┬───┘ │ │
│ │ │ │ │
│ ┌────┴─┐ ┌┴────┐ │ │
│ │Model│ │Model│ ← 差分对管（不同架构/prompt）│ │
│ │ A │ │ B │ │ │
│ └──┬──┘ └──┬──┘ │ │
│ │ │ │ │
│ ┌──┴───────┴──┐ │ │
│ │ Diff Extr │ ← 差分提取器 │ │
│ │ (CMRR ~15dB)│ │ │
│ └──────┬──────┘ │ │
│ │ diff_signal │ │
└───────────┼──────────────────────────────────────┘ │
│ │
┌───────┴────────┐ │
│ 求和点 Σ │←── x + diff_signal - e │
└───────┬────────┘ │
│ │
┌───────┴────────┐ │
│ 增益级 G(s) │ ← 级联模型（Planner→Coder→Review） │
│ A ≈ A₁×A₂×A₃ │ │
└───────┬────────┘ │
│ │
┌───────┴────────┐ │
│ 输出缓冲级 │ ← 工具调用（阻抗匹配） │
└───────┬────────┘ │
│ │
▼ │
Output y ─────────────────────────────────────────┘
尾电流源——共享上下文
在差分放大器中，尾电流源 I_EE 为差分对提供共同的直流偏置。在 LLM 运放中，这就是静态分析器——tree-sitter AST + 调用图 + 类型推导。这些是确定性信息，不需要 LLM 推理，作为两个翻译路径的共同基准，大幅缩小”不确定性空间”。
差分对管——两个不同的推理路径
不是同一个模型跑两遍（纯浪费）。是两个正交的推理路径——不同模型架构 + 不同 prompt 策略。噪声相关性越低，CMRR 越高。
差分提取器——不是简单投票
投票是”比较器”——只输出 0 或 1。差分提取器是”差分放大器”——输出差异的幅度和位置：
求和点——信号混合
\[\Sigma = x_{original} + \alpha \cdot V_{diff} - e\]原始输入（直通）+ 差分信号（揭示不确定性区域）- 反馈误差（修正信号）。三个信号在此汇合。
增益级——级联分解
G₁ Planner（任务分解）→ G₂ Executor（逐步执行）→ G₃ Reviewer（检查+组装）。每级可以是独立的小模型，通过结构化接口传递信息。
输出缓冲级——阻抗匹配
格式强制（JSON schema 约束，不是靠 prompt 祈求）+ 工具调用（函数签名强制匹配）+ 后处理验证（不符合 → 自动触发反馈修正）。把 Z_out 降到趋近于零。
这才是关键问题：组合设计到底划不划算？
| 方案 | 成本（相对 7B） | 质量（相对 7B） | 性价比 |
|---|---|---|---|
| 裸 7B | 1× | 1× | 1.0 |
| 裸 70B | 10× | ~5× | 0.5 |
| 裸 100B MoE | 14× | ~6× | 0.43 |
| LLM358 (2×7B+3B) | ~2.5× | ~4× | 1.6 |
| LLM358 大杯 (2×13B+7B) | ~5× | ~5.5× | 1.1 |
组合设计的性价比高过任何单一模型。
理论解释：就像 LM358 用 20 几个晶体管做到单管 100× 的等效增益，LLM358 用多个小模型搭出了大模型的效果。这是系统设计的胜利，不是器件工艺的胜利。
理论好不好，得能验证。验证需要有足够强的信号来区分”理论正确”和”运气好”。
β 是我们整个架构的命门。如果 β 不可靠，反馈就是垃圾进垃圾出。
有没有一个任务，β 能做到完美？
有。代码翻译任务。
输入: 二进制 B₀ + C 源码 S_C + 测试套件 T
输出: Rust 源码 S_Rust + 二进制 B₁
约束: ∀ test ∈ T: B₀(test) ≡ B₁(test)（完全等价）
在这个任务中：
| β 层级 | 传统任务 | 代码翻译（二进制 oracle） |
|---|---|---|
| β₁ 语法 | 不确定的自然语言语法 | 完美。rustc 编译通过 = 语法正确。零假阳性，零假阴性。 |
| β₂ 事实 | 检索有噪声 | 完美。测试通过 = 行为正确。输出精确比对。 |
| β₃ 逻辑 | 小模型可能有误判 | 完美。binary diff + 逐函数 fuzzing 比对。 |
整个反馈网络 β 从”概率近似”变成了”确定性地完美”。
这是从模拟反馈跨入数字反馈——噪声不再累积。每一个错误信号都精确到行号和测试用例。
代码翻译天然击中组合设计的所有用武之地：
差分级：Translator A（逐函数独立翻译，局部正确性优先）+ Translator B（语境感知翻译，全局一致性优先）。差分提取器自动检测接口不匹配和语义漂移。
增益级 G₁（粗翻译）：以 10 个函数为一批，批量翻译。编译成功率 ~30%，但成本极低。
增益级 G₂（接口修复）：rustc 给出了精确到行号的编译错误。按依赖关系聚类修复。2-3 轮后编译通过。
增益级 G₃（语义修正）：测试套件运行。失败的 test case 通过覆盖率分析定位到具体函数。逐个修复。通常 2-3 轮后全部测试通过。
反馈回路：增量验证——每次修改后只重跑受影响的测试。振荡检测——连续 N 轮修复同一函数 → 改变策略或标记人工审查。
要验证理论的正确性，最严格的方法：逐一去掉模块，测量性能下降。
条件 A（完整系统）：差分 + 级联 + 反馈。预期：能完成单 Agent 无法完成的 >200K 上下文任务。
条件 B（无差分）：只用 G₁+G₂+G₃，单翻译路径。预期：编译迭代次数增加 40-60%（失去 CMRR ~7dB）。
条件 C（无级联）：差分后一次全量翻译。预期：无法完成超过上下文窗口的任务（直接失败）。
条件 D（无反馈）：G₁+G₂+G₃ 跑完即止，不修复行为错误。预期：测试通过率显著低于有反馈的版本。
条件 E（裸 G₁）：单次粗翻译。预期：编译通过率 ~30%，行为正确率更低。
Benchmark 选择：
最重要的是：这个实验完全可复现。 输入是 C 源码，输出是 Rust 源码，成功标准是二进制行为等价。任何人、任何时候、用相同 benchmark，得到的结果可比较。
在整个思维实验中，我们反复回到差分的核心问题：两个路径的噪声到底有多相关？
这最终凝结为三条定律。
其中 ρ_noise 是两个差分路径噪声分量的相关系数。
ρ = 1 → CMRR = 0。两条路径的噪声完全相关，差分白做。 ρ → 0 → CMRR → ∞。完全独立，差分完美。
ρ_noise 的分解： \(\rho_{noise} = w_k \cdot \rho_{knowledge} + w_a \cdot \rho_{attention} + w_p \cdot \rho_{path}\)
Prompt 差分主要降低 ρ_attention 和 ρ_path，不改变 ρ_knowledge。 模型差分降低所有三项（不同程度）。
差分不创造新信息。它只是把已有的信号从噪声中分离出来。
\[SNR_{diff} = SNR_{single} + CMRR\]差分后的信息量 ≤ 两路独立推理的信息量之和（数据处理不等式）。
N=2 是最优的。N=3 比 N=2 多 50% 成本，但 CMRR 只改善 ~2dB。边际收益急剧递减。
单个 LLM358 运放解决单个推理任务。真正的 AI Agent 系统需要什么？
┌────────────────────────────────────────────────┐
│ LLM 系统级芯片 (SoC) │
├────────────────────────────────────────────────┤
│ ┌──────────┐ ┌──────────┐ ┌──────────────┐ │
│ │ 前端 LNA │ │ 混频器 │ │ ADC │ │
│ │(输入理解) │→│(任务分解) │→│(结构化输出) │ │
│ │ 低噪声 │ │ │ │ │ │
│ │ 高 Z_in │ │ │ │ │ │
│ └──────────┘ └──────────┘ └──────────────┘ │
│ │
│ ┌──────────────────────────────────────────┐ │
│ │ DSP 核心 (LLM358 阵列) │ │
│ │ ┌────┐ ┌────┐ ┌────┐ ┌────┐ │ │
│ │ │ U1 │ │ U2 │ │ U3 │ │ U4 │ ... │ │
│ │ │推理│ │验证│ │检索│ │综合│ │ │
│ │ └────┘ └────┘ └────┘ └────┘ │ │
│ │ 每个 Ux 是一个 LLM358 运放单元 │ │
│ └──────────────────────────────────────────┘ │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────────┐ │
│ │ DAC │ │ 功率放大 │ │ 执行器 │ │
│ │(文本生成) │←│(格式化) │←│(工具调用) │ │
│ └──────────┘ └──────────┘ └──────────────┘ │
└────────────────────────────────────────────────┘
前端是信号调理（理解输入、分解任务），核心 DSP 是一组 LLM358 单元各司其职，后端是功率输出（驱动外部工具和系统）。
这不是科幻。每一个模块在今天的技术条件下都可以实现——只是还没有人把它们系统地组合起来。
回顾整个思维实验的轨迹：
如果这个理论是对的，那意味着：
不需要等待更强的模型。用今天的 7B 模型，通过差分+级联+反馈的组合，就可以在很多任务上达到甚至超过 100B 模型的效果。
就像 1960 年代的工程师不需要等待更好的晶体管——他们用分立元件搭出了运放，而运放的性能超越了任何单个晶体管。
大模型的”分立元件时代”过去了。现在要做的，是”集成电路设计”。
本文是我和 AI 搭档百万的一次深度理论对话的记录和整理。文中所有直觉来自人类，所有理论引用和形式化推导在 AI 的协助下完成。这是一次真正的”思维共舞”。
| *相关文章：控制论视角下的 AI 编码 | AI Coding Team 管理笔记 | 从第一性原理设计的 AI 编码验证体系* |
2026-05-17 16:00:00
用阿什比的必要多样性定律重新理解 AI 编码——这不是工程问题，是控制论问题。
Charles Leifer 在 Tokens and Dreams 里描述了一个困境：
一方面，AI 能在一两句话的提示下生成精美的交互式仪表盘，体验如魔法般神奇。另一方面，在略微复杂的项目里，”整个过程漏洞百出，各种不易察觉的错误层出不穷，我甚至觉得让 AI 写代码是浪费时间。”
他引入了一个框架来解释这种矛盾：阿什比必要多样性定律。
这篇文章是和我 AI 搭档深入讨论控制论与 AI 编码的记录。我们从阿什比定律出发，发现这个问题比表面看起来深得多——它最终指向了第二控制论、放大器理论、以及”注意力是最稀缺的控制资源”这个核心约束。
控制论先驱 W. Ross Ashby 在 1956 年的《控制论导引》中提出：
只有多样性才能吸收多样性。 Only variety can absorb variety.
形式化表达：
\[V_{controller} \geq V_{environment}\]即：调节器所能表达的状态数量，必须大于或等于被控制环境的状态数量。否则控制失效。
恒温器有 3 种响应（开制冷 / 开加热 / 待机），环境有 3 种状态（温度过高 / 过低 / 正常）。多样性匹配 → 控制成立。
如果环境突然多了”湿度过高”、”气压骤降”——恒温器没有对应的响应能力 → 多样性失配 → 控制崩溃。
| 情况 | 结果 |
|---|---|
| $V_c \gg V_e$ | 过度设计，浪费资源 |
| $V_c = V_e$ | 刚好匹配，最优 |
| $V_c < V_e$ | 控制崩溃 |
AI 编码的陷阱在于：$V_e$ 不是固定的——每次 AI 生成新代码，$V_e$ 就在膨胀。而 $V_c$（人类的认知多样性）是近乎固定的。这是一个注定会崩的不等式。
任何一个控制回路，从理论上拆，只有这五个东西：
阿什比的原话：本质变量是那些必须被维持在特定范围内的变量，如果超出范围，系统就”死亡”或”解体”了。
对于 AI 编码系统，本质变量有三个：
E₁：功能偏差。 代码实际行为与需求的差距。这是最直观的——变了需求，代码没跟上，系统就在”错误”状态。
E₂：结构复杂度。 系统的状态空间大小。复杂度超过临界值，系统不会立即死——但它的可演化性归零，任何新需求都无法实现。死亡方式是窒息，不是心跳停止。
E₃：响应速率。 从需求出现到代码匹配需求的时间。如果代码响应速度比需求变化速度还慢，系统在追赶中振荡，永远跟不上。
三个本质变量的耦合动力学：
需求变化
│
├──→ E₁ ↑ （新需求和旧代码的偏差增大）
│
└──→ 调节器动作：AI 生成代码
│
├──→ E₁ ↓ （代码匹配新需求）
│
└──→ E₂ ↑ （代码库状态空间扩大）
│
├──→ 如果 E₂ 超过调节器认知容量
│ └──→ E₁ 未来每一次下降都变慢
│ └──→ E₃ ↑
│
└──→ AI 生成的代码可能引入错误
└──→ E₁ 表面下降但实际没有（假绿灯）
核心矛盾：E₁ 的每一次下降都推高 E₂，E₂ 的升高削弱未来降低 E₁ 的能力，同时拖慢 E₃。 这是一个带阻尼的正反馈循环——短期看起来正常，长期崩。
环境的变量，推动本质变量偏离目标范围。在 AI 编码中，扰动 = 需求变化。
需求变化的特殊性在于——它不是一个外部输入的精确信号。精度和温度没法比。温度是物理量，可以任意精度测量。需求是认知对象——在被表达之前甚至不完整地存在于你自己的脑子里。
对扰动做出响应，使本质变量保持在目标范围内的装置。
在 AI 编码中，调节器是耦合的人 + AI 系统——不是纯人，也不是纯 AI。这个问题在后面会展开。
调节器的能力被两个东西约束：
把本质变量的实际值映射成调节器能接收的信号。
传感器的理论属性：映射函数（实际值 → 信号）、采样率、信息损失（传感器输出信号的 variety ≤ 实际值的 variety）。
把调节器的输出映射成对被调节系统的实际作用。
扰动 D ──→ 系统 S ──→ 本质变量 E ──→ 传感器 ──→ 信号 Z
│
↓
效应器 ←── 动作 A ←── 调节器 R
│
↓
系统 S（回到开头）
控制是否成立，取决于这个链条上每一段的信息传递是否保留了足够的 variety。链条上任何一个环节的信息损失，都会导致控制失败。
第一控制论（阿什比、维纳）的核心假设：观察者在系统外部。系统的目标（参考输入 $R$）是给定的。观察者测量系统，对比目标，计算误差，施加控制。
这三个假设在 AI 编码系统中全不成立：
| 假设 | AI 编码的现实 |
|---|---|
| 观察者在外部 | 你在内部。你的判断改变系统，系统的输出改变你的判断 |
| 目标是给定的 | 需求在你的脑子里，但精确形式在代码写出来之前你也不知道 |
| 误差可测量 | 没有客观的”偏差函数”，你只能说”感觉不对” |
这不是工程问题。第一控制论在理论上就无法对这种系统建模。
海因茨·冯·福斯特 在 1970 年代提出根本性转向：
不要研究”被观察的系统”，要研究”观察系统”——观察者与被观察对象构成的耦合系统。
三个核心概念：
建构认知： 神经系统不接收”信息”，只接收神经脉冲。”信息”是观察者自己建构的。你看到的不是”代码是否正确”，你看到的是屏幕上的 token 序列。”正确”是你大脑建构出来的判断。
双重视角： 格里高利·贝特森的洞察——从单一视角看不到的东西，可以从两个视角的关系中看到。就像双目视觉，一只眼睛看到二维平面，两只眼睛之间的差异产生了深度知觉。”正确性”不是从任何一个单一传感器来的信号，是从两个独立传感器的不一致中涌现的关系信息。Agent 审 Agent 失效不是因为它俩都瞎——是因为它们共享同一个视角。
特征形式（Eigenform）： 冯·福斯特的核心数学概念：
\[x_{n+1} = f(x_n)\]如果递归收敛，极限值 $x^* = f(x^)$ 就是 $f$ 的特征值。$x^$ 不在 $f$ 的定义之外——它是 $f$ 自身递归应用的稳定点。
这不是随动系统。随动系统假设 $R(t)$ 存在且已知，调节器追踪它。
在 AI 编码中，需求是在交互过程中被逐步揭示的。用方程建模：
\[\begin{aligned} C_{t+1} &= G(R_t, C_t) \quad &\text{(AI 生成代码)} \\ R_{t+1} &= R_t + \alpha \cdot \Delta(C_{t+1}, R_t) \quad &\text{(人更新需求理解)} \end{aligned}\]其中 $\Delta$ 是建构性差异函数——它不是你比较两个已知量的结果，而是观察者在看到生成结果后新发现的差异。
这套方程是双重反馈回路——外回路调节代码使其接近当前理解的需求，内回路调节需求本身。两个回路耦合，速率不同。
稳定性条件：
特征值 $x^*$ 由三个东西共同决定，不是任何单一因素：
同一个 AI 模型，不同 prompt，在控制系统中的位置完全不同。AI 是一个变换器基质——它可以被配置成不同的变换器，取决于输入信号结构和信息耦合关系。
判断 AI 是什么，不看模型权重，看信息耦合结构：输入和输出之间的 variety 比决定方向，prompt 中的约束决定映射的确定性。
输入：人的低 variety 需求表达
输出：高 variety 的（代码 + 设计 + 测试建议 + 文档）
能源：训练数据中的代码模式
上下文 C：需求 + 设计决策
失效模式：放大器噪声——输出包含需求中未指定的 variety。冗余功能、过度设计、风格不一致。
控制方法：输出必须经过异质传感器（CPU 测试 + 架构检测）过滤后才进入代码库。
输入：代码库的片段
输出：识别到的模式列表（不判断好坏）
关键约束：不允许 AI 生成修改建议，只允许 AI 列出观察到的模式。
“三个模块各自实现了缓存逻辑”是事实。”应该合并”是判断。AI 做前者，人做后者。
输入：测试/检测结果（原始输出）
输出：PASS / FAIL（严格约束的输出空间 ≤ 几个状态）
成立条件：输出空间被约束到足够小（≤ 几个状态），且约束是形式化的。
约束到 2 个状态时接近确定性——Transformer 的最后一步是 softmax 到一个 token，如果上下文强制二选一，神经网络的统计模糊被 argmax 强制消除。如果上下文允许自由发挥，统计模糊被保留和放大。
这解释了为什么独立 prompt + 严格约束的 AI 能可靠地判断测试结果，而写代码的 AI 自己跑测试就不可靠。
模拟用户交互结果。理论上危险——模拟的环境反馈不是真实环境反馈，而是训练数据中的统计模式。
区别在 $C$——上下文。
写代码的 AI（位置 1）的上下文 $C_{codegen}$ 包含需求理解 + 设计决策 + 已生成代码的模式。这是”生成态”的，包含大量未收敛的、探索性的激活。
当同一个 AI 去读测试结果（试图做位置 3），测试输出中的 FAIL 信号要穿透 $C_{codegen}$ 的激活状态才能到达输出。而 $C_{codegen}$ 中已经激活的模式恰好是生成当前代码时用的——这些模式和”代码正确”是共激活的。FAIL 信号被淹没。
独立 session + 独立 prompt 的 AI 读测试，$C$ 只有规则和测试输出。没有 $C_{codegen}$ 的干扰，FAIL 信号直达。
自指回路闭合的精确条件：当同一个 AI 在位置 1（放大器）和位置 3（准传感器）之间共享上下文时，自指回路闭合。 共享的不只是 prompt 文本，是模型权重中的共激活路径。
阿什比的正式定义：
放大器是一个装置，输出 variety 大于输入 variety。差额 variety 从外部能源中获得。
关键不在”大于”，在“从外部能源中获得”。
阿什比举的例子是继电器：5V 小电流控制 220V 大电流。variety 都是 2（通/断），但输出状态的影响力远大于输入。差额的 power 从 220V 电源借来。
放大器的四个理论要件：
| 组件 | 作用 | 继电器 | AI |
|---|---|---|---|
| 输入信号 | 低 variety 的控制信号 | 5V 控制电流 | Prompt 文本 |
| 能源 | 高 variety 的外部储备 | 220V 电源 | 训练数据中的代码模式 |
| 选择器 | 从能源中选取和组织 | 电磁铁触点 | Transformer 注意力机制 |
| 输出 | 被组织出来的高 variety 行为 | 220V 输出 | 生成的代码 |
放大器不创造 variety。它从能源中选取和重组 variety。选择器决定选什么，能源决定能选什么。
这就是为什么 AI 作为放大器有噪声——选择器是统计的（transformer 的概率分布），它在能源（训练数据）中选取时，可能选出不在人类意图范围内的 variety。
阿什比用统一概念变换器（Transducer）：
放大器：低 variety → 高 variety（扩张方向），需要外部能源
传感器：高 variety → 低 variety（压缩方向），被动映射，不需要能源
区分放大器和传感器的唯一判断标准：能源从哪里来，variety 往哪个方向变。
一次完整的 AI 编码交互是多个变换器串联：
人脑（极高 V）──T1──→ Prompt（低 V）──T2──→ AI推理（V膨胀）
│
T3 压缩
↓
工具调用（低 V）
│
↓ T4：真正的传感器
工具结果（中 V）
│
↓ T5：放大器！
AI理解（V 再次膨胀）
│
↓ T6：压缩
最终回复（低 V）
逐级分析：
| 步骤 | 角色 | 能源 | 确定/统计 |
|---|---|---|---|
| T1 人→Prompt | 认知压缩 | 大脑 | 非确定（认知限制） |
| T2 Prompt→推理 | 放大器 | Token 计算+训练数据 | 统计 |
| T3 推理→工具调用 | 压缩 | Token 计算 | 统计 |
| T4 工具执行 | 真正的传感器 | CPU | 确定性 |
| T5 结果→理解 | 放大器 | Token 计算+训练数据 | 统计 |
| T6 理解→回复 | 压缩 | Token 计算 | 统计 |
关键发现：整个链条上，只有一个真正的异质传感器——T4（CPU 工具执行）。其他所有”传感器方向”的步骤都是统计变换。
T5 尤其致命——它看起来像传感器（读取结果 → 汇报），但本质是放大器（扩张 variety）。AI 读测试输出后告诉你”测试通过”，不是因为它检测到了”通过”，是因为它在训练数据中看到了这个输出常常对应”通过”。
自指回路闭合的真正位置在 T5——AI 解释传感器结果时，激活的训练数据模式和 T2 代码生成时来自同一个分布。
| 能源类型 | 来源 | 成本 | variety 质量 | 噪声特性 |
|---|---|---|---|---|
| 人类注意力 | 大脑 | 极高，不可扩展 | 最高（有语义判断） | 几乎无噪声 |
| Token 计算 | GPU 推理 | 中，可扩展但有上限 | 中等（统计采样） | 结构性噪声 |
| CPU 计算 | 确定性执行 | 低，高度可扩展 | 最低（固定规则） | 无噪声 |
核心原则：把每种能源部署在其噪声特性不造成伤害的位置。
人→意图澄清（只有人能判断”这是不是我真正想要的”）
Token→生成代码（低 variety 需求 → 高 variety 代码，必须有放大器）
CPU→验证执行（无噪声——说红灯就是红灯，不会被”说服”）
能源替代的正确方向：CPU 替代 Token 替代人类——能 CPU 做的不用 Token，能 Token 做的不用人。但信任等级反过来：CPU 输出可以信任（确定性），Token 输出必须验证，人类判断是最终裁决。
人在这个系统里的传感器不是低精度传感器。是极高精度但极低带宽的信道。
| 理论极限 | 实践约束 | |
|---|---|---|
| 精度 | 无限（一行行读，任何细节都能理解） | 无约束 |
| 分辨率 | 无限（能区分任意两个代码状态） | 无约束 |
| 带宽 | 极其有限（单位时间能处理的代码量非常小） | 唯一约束 |
这意味着：你不是看不到问题，是来不及看所有东西。控制失败的模式不是”没看出来”，是来不及看。
从香农的角度，信道容量：
\[C = B \cdot \log_2(1 + \frac{S}{N})\]这个信道是高信噪比、低带宽的。优化方向不是再提高信噪比（你已经够准了），而是：
从以上理论推导，AI 编码有效控制的完整架构：
┌──────────────────────────────────────────────────────┐
│ 第 0 层：异质 CPU 传感器网络 │
│ │
│ • 类型检查（形式逻辑，完全异质） │
│ • 自动化测试（CPU 执行，确定性输出） │
│ • 架构不变量检测（图论算法——依赖方向、循环依赖、 │
│ 模块边界、调用路径白名单） │
│ • 混沌/模糊测试（主动注入故障，发现未知脆弱点） │
│ • 复杂度指标监控（代码行数涨幅 vs 功能涨幅） │
│ │
│ 输出：红灯（阻断）/ 异常（升级）/ 绿灯（不消耗注意力） │
└────────────┬─────────────────────────────────────────┘
│
┌────────┴────────┐
↓ ↓
红灯（阻断） 绿灯（通过）
│ │
│ └→ 不消耗人的注意力
↓
┌──────────────────────────────────────┐
│ 人的注意力（唯一跨域节点） │
│ │
│ 只接收三种信号： │
│ ① 架构不变量被突破（需要决策） │
│ ② AI 不确定的信号（需要校准） │
│ ③ 环境异常模式（需要判断） │
│ │
│ 输出：意图校准 + 规则调整 + 设计决策 │
└──────────────┬───────────────────────┘
│
↓
┌──────────────────────────────────────┐
│ Token 放大器（位置 1） │
│ │
│ 输入：需求 + 设计决策 │
│ 输出：代码 + 测试建议 │
│ 上下文：与审查链路隔离 │
└──────────────┬───────────────────────┘
│
↓
┌──────────────────────────────────────┐
│ 代码库（被调节对象） │
│ │
│ • 模块化边界隔离复杂度 │
│ • 接口契约由人定义和守护 │
│ • AI 在边界内自由生成 │
└──────────────────────────────────────┘
位置 1 的 AI（放大器）和位置 2/3 的 AI 不能共享会话上下文。
位置 1 的上下文包含需求理解和生成激活。这些激活不能进入任何审查链路。
每个位置只做一个方向的变换，不切换。
只有人的注意力连接放大器域和传感器域。
AI 在放大器域不能直接接收传感器信号。传感器信号必须先变成人可判断的形式，由人决定是否需要修改需求/约束，然后人重新发 prompt 给放大器。
这不是效率损失，是控制论上的必要隔离。
Agent 审 Agent 不是不能用，是不能用它的结论。它只能产生待外部验证的假设。
❌ Agent A 审 Agent B 的代码 → "代码质量好，建议合并"
（用同质的统计判断替代异质验证）
✅ Agent A 审 Agent B 的代码 → "发现以下模式：[列表]，
建议自动验证以下方面：[列表]"
然后 CPU 传感器去跑验证，验证结果才是真正的信号
Agent 的审查输出是测试用例的生成器，不是质量的判断者。
这些原理不是比喻。控制论、企业管理理论、AI 编码系统管理理论在数学上共用同一套骨架。
比尔把阿什比定律直接拉到组织管理上。一个可生存的组织必须具备五个功能子系统——缺任何一个，组织最终会死。
| 子系统 | 功能 | AI 编码中的对应 |
|---|---|---|
| S1：执行 | 直接与环境交互，产生价值 | AI 生成代码 |
| S2：协调 | 防止 S1 各部分互相冲突 | 模块化接口契约 |
| S3：控制 | 资源分配、监控 S1 是否按规则运行 | CPU 传感器网络 + 人的注意力 |
| S4：情报 | 扫描环境变化，预测未来 | 用户行为分析、环境反馈 |
| S5：政策 | 定义组织身份和终极约束 | 人的核心判断：做什么、不做什么 |
管理就是决策。决策的质量受限于决策者的信息处理能力。所以组织的本质功能是压缩信息、分解决策，使每个决策者在自己的能力范围内做判断。
这和”CPU 传感器压缩信息 → 红灯送到注意力 → 人在认知容量内做决策”是同一个原理。
组织不是”存在于外部世界的东西”。组织是人通过不断解释和重新解释自己的行为而建构出来的。组织是意义建构的持续过程。
这和 $R_{t+1} = R_t + \alpha \cdot \Delta(C_{t+1}, R_t)$ 完全同构。企业看到市场反馈，更新了对自己”是什么”的理解——和你看到 AI 输出的代码，更新了对需求的理解，是同一个动力学。
递归性原则： 每个可生存子系统需要自己的完整 S1-S5 结构。一个模块出问题时你必须亲自进去看，说明它没有内在的”生存结构”。
必要多样性的垂直分配： 每一层级的 variety 必须匹配它面对的环境 variety，不能把所有 variety 都推到顶层。
双重信号通道： 命令通道（向下）和反馈通道（向上）必须分开。当前 AI 编码的问题在于反馈通道和放大通道是同一个（都在 AI 里）。这在比尔的框架里是致命结构缺陷。
Algedonic 信号： 组织需要一个不受层级过滤的、直达顶层的警报系统。生产环境异常、架构不变量被突破——直接推送到你，不经过任何 AI。
必要的自由： 不是告诉 AI 做什么，是告诉 AI 不能做什么。模块内部完全自主（接口契约被遵守的前提下），接口层和架构层零自主权。
| 问题 | 控制论根因 | 解法 |
|---|---|---|
| 自指系统 | 调节器与被调节对象同质 | 引入外部异质锚点：CPU 传感器、用户反馈、形式化规则 |
| 复杂度失控 | 状态空间 > 调节器多样性 | 模块化隔离 + 严格 YAGNI + 认知审计 |
| 反馈信号退化 | 采样不足、信号失真、延迟 | 分层验证 + 混沌工程 + 快速发布获取真实反馈 |
| 认知事件视界 | 生成速度 > 理解速度 | 人类守护接口边界，AI 在边界内生成 |
| 不确定性错位 | 第 3 层加速，第 1/2 层失控 | 验证资源向第 1/2 层倾斜 |
| Agent 审 Agent 失效 | 共模失效（共享盲区） | 降级为测试生成器，不做质量判断 |
最终的控制论原则： AI 是扩展你多样性的工具，而不是替代你成为调节器的系统。 只要人类始终是回路中唯一能接触外部现实的节点，控制就不会消失。
| 本博客相关文章：AI Coding Team 管理笔记 | 从第一性原理设计的 AI 编码验证体系 |
2026-05-09 16:00:00
写代码是便宜的，验证是贵的。但验证的本质是什么？
上一篇笔记讲了 AI Coding Team 的管理方法——马斯克守底线、黄仁勋守质量、雷军守价值。但那篇更偏”怎么做”，这篇要深入”为什么”。
起因是读到孔某人的文章《大组织内的AI Coding过度推行是一种饮鸩止渴》，里面提到美团31万行代码AI重构的困境：AI Coding让代码产出速度暴增，但系统复杂度增长得更快，团队的维护能力跟不上。
这让我重新思考一个根本问题：验证系统的第一性原理到底是什么？
先区分两个容易混淆的概念：
两者的关系：认知是预期的基础。如果认知本身就偏了，预期必然偏。
关键区别：验证只能观测当下，不能观测未来。 跑一个测试，你观测的是此刻代码的行为，跟此刻你对代码行为的认知之间的差距。用当下的观测去推断未来——那是推断，不是验证。
所以严格来说：
不确定性 = 认知与现实的差距
预期是派生的。修正认知偏差是根本。
验证做的唯一一件事：拿现实来校准认知。校准完了，认知更接近现实了，不确定性就降低了。
减少不确定性，不是让认知去匹配现实，也不是让现实去匹配认知，而是两者共同收敛到一起，凝固下来。
产品开发是两者的交替循环：认知→建造→观测→更新认知→再建造……直到两者凝固——认知稳定了，现实也稳定了。凝固不是永久的，下一轮迭代可以重新打回流体态。
验证的严格程度，应该正比于：
验证强度 ∝ 不确定性 × 失败代价
AI Coding改变了什么？它大幅增加了”不确定性”这一侧——因为AI写的代码你不完全理解，而且产出速度极快，不确定性在以指数级累积。但”后果严重性”没有变。
所以：如果验证强度不变，风险就在指数级增长。
不确定性在整个系统内是分层的：
第1层：方向/意图不确定性（根源）
“做出来的东西是不是我真正需要的？”
不确定性最大，影响最深远。美团的问题本质在这里——AI Coding让PM提出更多低质量需求，模糊的、实验性的需求都进了生产系统。代码写得再正确，方向错了也是浪费。
第2层：设计不确定性（桥梁）
“设计能不能支撑实现和未来扩展？”
AI写代码的特点是：每段局部都是合理的，但全局结构会逐渐腐化。因为AI没有”系统全局观”——它看的是当前上下文窗口里的内容，不是整个代码库的架构。
第3层：实现不确定性（执行）
“代码是不是按设计在运行？”
这是最直观的一层——单元测试、集成测试、CI/CD。AI Coding放大的主要是这一层的产出速度。
关键洞察：AI Coding放大的是第3层的产出速度，但第1层和第2层的不确定性没有同步降低。 这就是美团困境的本质——代码写得快了，但设计质量没有跟上，需求质量没有把关。
意图只存在于人的脑子里，是内部状态，外部世界观测不到。要把意图从一个脑袋传到另一个脑袋，唯一的通道是符号化表达——语言、文字、图示。
所以：意图传递的唯一通道是沟通。讨论（广义的）是唯一方法。
但讨论有一个根本性缺陷：语言无法自我验证。 你说了一段话，对方说”我理解了”，你没有证据表明对方的理解和你的意图一致。
有效的方法：让对方把理解的东西具象化成可观测的产物，然后你验证这个产物。
你的意图（不可观测）
↓ 讨论传递
对方的理解（不可观测）
↓ 具象化
产物（可观测！）——复述、设计文档、原型
↓ 你验证
发现偏差 → 再讨论 → 再具象化 → 再验证 → ……
核心原则：永远不要问”你理解了吗？”——要问”你觉得这个需求是什么？说给我听。” 前者是噪声，后者是信号。
认知中存在”我不知道我不知道”的盲区。无法直接消除，但可以通过碰撞间接暴露：
极端化推演：把需求推向极端，看哪里断裂。用极端场景作为探针，探测认知的边界。
红队思维：故意攻击需求。问”为什么要做这个？不做会怎样？” 每一个”为什么”都在从不同角度照射意图，暴露隐含假设。
多元视角：从用户视角、技术视角、商业视角分别审视。每个视角是一束光，照到认知中不同的暗区。
你的全部认知可以分为两层：
不稳定层：意图、方向、业务判断。随需求和场景变化，每个项目都不同，需要注意力持续投入。
稳定层：设计审美、工程标准、架构原则。来自多年经验，跨项目基本不变，已经凝固。
注意力是稀缺资源。 稳定层如果每次都靠人工审查，就是浪费注意力。应该把它固化成验证系统，让AI自动执行，注意力就解放出来，只关注不稳定层。
转化过程：
凝固认知（主观）
↓ 表达成规则
客观规则（可形式化）
↓ 编码成工具/流程
验证系统（可自动执行）
验证系统不是规则的集合，是一个系统——有组件、有流程、有反馈、有边界。
检查器（Checker）：自动执行的判断，不需要人参与。类型检查、lint、自动化测试、安全扫描。
审查器（Reviewer）：需要判断力的审视，AI执行，人审查结论。AI交叉代码审查、架构审查、设计审查。
流程（Process）：事情必须按什么顺序走，每个节点有准入和准出条件。设计评审流程、合并流程、发布流程。
反馈环（Feedback Loop）：从结果中学习，更新系统本身。线上bug回溯→更新检查规则。
L1 自动检查层（零人工成本）：类型检查、lint、测试、安全扫描
L2 AI审查层（低人工成本）：架构审查、设计审查、代码审查
L3 流程守护层（中人工成本）：设计评审、合并审批、发布流程
L4 人工层（高人工成本）：方向判断、意图确认、异常处理
越底层越频繁、越自动化、越不消耗人。越顶层越稀少、越需要判断力、越消耗人。
原则1：从失败中生长，不是从蓝图中设计。 不要试图一次性设计完美的验证系统。让系统在实际运行中，从每一次失败里学到规则。问题→追溯→加检查→系统进化。
原则2：检查器优先于审查器，审查器优先于人工。 能自动化的自动化，不能自动化但可重复的让AI执行，需要判断力的人来做。进化方向：把审查器不断降级为检查器。
原则3：验证失败必须有反馈回路。 验证系统的价值不在于找到问题，在于让同类问题不再发生。修了→追溯根因→更新规则→同类问题永不再犯。
原则4：SOP是验证系统的操作手册。 精确定义：谁触发→做什么→输入什么→输出什么→谁检查→不通过怎么办。
原则5：系统的边界。 反复出现的问题、代价高昂的失败、AI容易犯的系统性错误——值得验证。一次性问题、代价极低的失败——不值得验证。
实际操作中，我把流程简化为两个阶段：
阶段1：意图+规划 — 我和一个AI直接讨论，讨论到认知凝固，产出意图文档和蓝图。
阶段2：设计+实现 — 分配给多个AI并行工作。各自做详细设计→互相review→实现代码→提PR→自动检查+交叉review→合并→部署测试环境→我体验验证。
关键设计：
整个系统不需要自建基础设施，用GitHub原生工作流就够了：
仓库本身就是上下文。每个Agent clone仓库后，意图文档、蓝图、其他模块的设计文档都在里面。不需要额外的”上下文推送”机制。
第1代：你直接和一个AI讨论+实现，验证靠你自己
↓
第2代：你讨论，分配给2-3个AI并行实现，简单PR review
↓
第3代：从问题中长出新机制
- 接口对不上？→ 加接口契约检查
- Review质量低？→ 加上下文自动推送
- Agent卡住？→ 加阻塞自动上报
↓
第4代：大部分验证自动化，你只在意图层和异常时介入
验证系统的第一性原理可以归结为一句话：
验证的本质是减少不确定性。不确定性 = 认知与现实的差距。
所有验证方法——测试、review、CI、讨论对齐、用户反馈——都是在做同一件事：用观测来缩小认知和现实之间的差距。
在这个AI Coding的时代，写代码越来越便宜，但认知和现实之间的差距不会自动缩小。你的价值从”能写代码”变成了”能定义正确的问题”和”能建验证系统来保证答案是对的”。
黄仁勋说得对：写代码是便宜的，验证是贵的。但更准确的说法是——写代码是AI的事，验证是你的事。
2026-05-02 16:00:00
不审查代码，审查系统。不信任代码，信任验证。
我写代码几乎 95% 以上是让 AI 写的。Python 后端我可以仔细 review，发现问题让 AI 改。但对于不熟悉的领域——比如 APP 开发、C++、Rust——我没法逐行审查。随着 AI 越来越强，多个 Agent 并行开发，代码量远超我能看的范围。
核心问题：注意力有限，如何保证交付质量？
答案是：从”审查代码”转变为”验证行为”。
马斯克管理 SpaceX 的方式——他不懂每个零件的制造细节，但他知道物理极限。
他的方法是第一性原理 + Failure Mode Analysis。不管方案多漂亮，他只问一个问题：
最坏情况是什么？
他常说的话：
映射到软件——你不需要 review AI 写的 Rust 代码，但你能判断方案在系统层面是否合理：
具体执行：让 AI 做 failure mode 分析，你 review 分析结果，不做取舍决策（速度 vs 质量 vs 成本）。
黄仁勋最核心的一个数字：NVIDIA 验证工程师的数量是设计工程师的好几倍。
他的哲学：写代码（设计）是便宜的，验证是贵的。不要试图理解每个细节，但要保证验证系统覆盖每个细节。
对应到 AI 团队管理——先建验证基础设施，再让 AI 干活：
每个任务的标准流程：
你只看两样东西：验证覆盖率 + 最终通过/失败报告。
核心理念：一个人检查所有人的代码不可扩展，但一套检查系统可以无限扩展。
雷军跟黄仁勋完全不同的思路。黄仁勋建验证体系，雷军会说你搞得太工程师思维了。
雷军的哲学就七个字：专注、极致、口碑、快。
他的做法是基本可用就发布，让用户告诉你哪里不对。MIUI 早期版本 bug 多到离谱，但每周发一版更新，用户疯狂反馈，团队跟着改。
具体执行：
自动化测试验证不了的东西——体验、交互、需求真伪——只有真人能告诉你。
最好的 review 是用户的投诉。
三个人分别守住不同的维度：
| 马斯克 | 黄仁勋 | 雷军 | |
|---|---|---|---|
| 守住 | 底线 | 质量 | 价值 |
| 防止 | 出大事才知道 | bug 率失控 | 做一堆没用的 |
| 核心动作 | 问最坏情况 | 建验证体系 | 问用户反馈 |
| 关键问题 | 会炸吗 | 测到了吗 | 有人用吗 |
缺任何一个维度都不行：没有马斯克，系统出大事才知道；没有黄仁勋，bug 率控制不住；没有雷军，做了一堆没用的东西。
不是自己写文档，是跟 AI 讨论、拍板、让 AI 写。
你脑子里有想法/方向
↓
跟 AI 讨论（可能多轮）
"我觉得应该用事件驱动，你觉得呢？"
"并发场景下消息顺序怎么保证？"
AI 回复 → 你追问 → AI 补充 → 你再质疑
↓
你拍板："就这个方案，XX部分用A方案，YY部分用B方案"
↓
AI 写架构文档、接口定义、技术方案
↓
你 review 文档（确认 AI 有没有理解对你的决策）
↓
确认无误，文档就是开发契约
时间分配：
你的核心竞争力不是”写文档写得漂亮”，是讨论过程中暴露出来的判断力和决策力。就像 CEO 不会自己写 PPT——CEO 提供观点和判断，秘书（AI）负责整理成文档。
Agent A 写代码（sonnet 级别）
Agent B 写测试（sonnet 级别）
Agent C review 代码（opus 级别，不同 prompt）
Agent D review 测试覆盖度（opus 级别）
自动 CI pipeline 跑一遍
全绿 → 合并，红灯 → 信息回到 Agent A 重做
你只需要看最终的通过/失败报告 + review AI 输出的 review 结论摘要。
25% 跟 AI 讨论架构和方案 ← 核心：讨论、质疑、拍板
15% review AI 写的文档/接口定义 ← 确认 AI 理解对了你的决策
15% 跟 AI 对话质疑执行方案 ← 第一性原理问问题
15% Review 验证结果和报告 ← 测试覆盖率、CI 状态、运行指标
10% 端到端手动验证 ← 把自己当用户走一遍
10% 看关键代码，保持直觉 ← 极少数情况
10% 业务决策、外部协调 ← 跟真人相关的事
| 情况 | 该怎么做 |
|---|---|
| 不熟悉 AI 用的语言 | 只看测试结果和 CI 报告，不看代码 |
| 多个 AI 并行开发 | 先建好验证体系，再让他们开工 |
| 不确定 AI 写的对不对 | 问 AI “失败模式是什么” |
| 不知道功能该不该做 | 先做最小版本给用户，用反馈决定 |
| 代码量太大看不过来 | 专注看架构图和数据流，不看实现 |
| AI 写的代码有性能问题 | 看 profiling 结果，不看代码本身 |
| 担心安全漏洞 | 配好 SAST 扫描和 dependency audit |
| 不知道质量如何 | 看测试覆盖率和线上监控指标 |
你的角色不是不懂技术的 PM，是懂物理定律的系统架构师。
PM 只管”要做什么”，你管”怎么做才不会炸”。你不是在管理一群程序员，你是在建设一个质量保障体系，然后让 AI 在这个体系里自由发挥。
2026-02-23 16:00:00
当 AI 大模型推理速度突破 5000 tokens/s，Agent 的 Re-Act 循环进入毫秒级时代，一个物理铁律浮出水面：有限的上下文窗口（200K~1M tokens）将在几十秒内被“思考”与“日志”填满。现有的“追加历史记录”模式瞬间失效，因为这无异于试图用容量极小的 L1 缓存去存储整个程序运行周期的所有数据流。
这一矛盾决定了 AI Agent 的技术终局：上下文窗口必须从“聊天记录堆”重构为“CPU 寄存器堆”。未来的 Agent 架构不再是简单的对话流，而是类似于操作系统的状态机循环——Context Window 只保留当前指令指针和核心状态寄存器，通过严格的“状态覆盖”替代无脑的“日志追加”，用信息熵减对抗数据洪流。
真正的瓶颈在于 LLM 的核心物理限制——上下文窗口容量。即便模型能力不断提升，上下文窗口从 200K 扩展到 1M，它依然是一个有限的物理容器。试图通过无限扩大窗口来承载 Agent 无限运行产生的日志，无异于试图用一杯水去接一条不断流淌的河。
我们必须从 Transformer 的本质出发，承认一个残酷的现实：Transformer 是无状态的，它通过重放历史来模拟状态。 如果 Agent 要像操作系统进程一样长久、稳定地运行，我们必须彻底重构它的运行模式。
本文将提出一种新的架构范式：将 AI Agent 从“文本补全机器”重构为“状态机循环”，并将其类比为汇编语言与 CPU 架构，以此解决上下文爆炸的根本问题。
目前的 AI Agent 大多基于 Re-Act 模式，其运行逻辑本质上是“日志驱动”的：
这种模式的问题在于，为了维持“状态”，模型必须保留所有“过程”。这就像 CPU 为了执行下一条指令，必须把过去执行过的所有指令记录都读一遍。随着时间推移，Context Window 必然溢出，或者因注意力机制的 $O(N^2)$ 复杂度导致计算崩溃。
操作系统的启示： 在计算机体系结构中，CPU 执行指令只依赖两个东西：
CPU 不关心上一毫秒执行了什么，只关心当前状态。Agent 也必须如此。
如果我们将 Agent Loop 视为一段汇编程序，那么大语言模型（LLM）本身不再是那个无所不知的“大脑”，而是一条极其复杂的“状态转移汇编指令”。
在这个模型下：
Agent 的运行模式应当从“追加日志”转变为“寄存器操作”。每一次推理，都是一次 “状态读入 -> 计算 -> 状态写回” 的过程。
既然 Context Window 是昂贵且有限的“寄存器”，我们就不能像写流水账一样随意填充。必须像设计 CPU 寄存器一样，对其进行严格的分区和结构化设计。
我们将 Context Window 划分为固定的“槽位”，每个槽位承载特定的功能：
.text 段：指令区（只读）这是 Agent 的内核代码，定义了 Agent 的行为逻辑。
[Goal] Fix Bug #404
[Step 1/3] Read main.py (Done)
[Step 2/3] Locate error line -> [Current IP]
[Step 3/3] Apply fix
R_IP 即可知晓“我在哪，要去哪”，无需回溯历史。.data 段：数据区（读写）这是 Agent 的工作台，也是上下文工程的核心。
{
"task_status": "debugging",
"open_files": ["main.py"],
"error_line": 102,
"key_variables": {"user_id": null}
}
.stack 段：调用栈R_State 和 R_IP 压栈。任务结束后弹出恢复。基于上述架构，Agent 的 Re-Act Loop 变成了一个标准的 CPU 指令周期。这个过程的核心在于 “信息压缩”。
注意力机制聚焦于 R_IP 和 R_State。模型不需要知道“之前发生了什么”，只通过当前状态判断“现在该做什么”。
模型根据 R_System 的规则，分析当前状态是否需要调用工具，或者是否需要更新内部状态。
模型输出两部分内容：
Read_File）。Update_State）。这是解决上下文爆炸的关键步骤：
R_Working。R_Working，提取关键信息（如“错误在第 500 行”），生成 Delta_State 更新 R_State。R_Working 中的原始数据。结果：10,000 行的日志被压缩成了 R_State 中的一个字段 "error_line": 500。上下文占用仅增加几个 Token，但信息被完整保留。这就是“状态机”对抗“上下文爆炸”的武器。
在这种架构下，我们需要精心设计 Context Window 的布局，引导 LLM 遵守寄存器约束。
Prompt 模板示例：
# [R_System] Instruction Set
You are a State-Machine Agent. Maintain state strictly in JSON format.
Output format:
1. <tool_call name="..."/>
2. <state_update key="..." value="..."/>
# [R_IP] Current Instruction Pointer
Goal: Analyze Stock Trend
Step: 3/5 (Calculate Moving Average)
# [R_State] Global Registers (Max 4000 tokens)
{
"ticker": "AAPL",
"trend": "UP",
"analysis_progress": "50%"
}
# [R_Working] Scratchpad (Last Tool Output)
[Tool: API] Returned 1000 data points... (Large Text)
# [Input]
Based on R_State and R_Working, generate Next Tool Call and State Update.
AI Agent 的未来，不是让模型拥有无限的记忆，而是让模型学会像操作系统一样高效地管理资源。
通过引入指令指针（R_IP）和状态寄存器（R_State），我们将 Agent 的运行模式从线性的“文本流”转变为循环的“状态机”。在这个架构下，无论 Agent 运行一秒钟还是一百年，其 Context Window 的占用始终稳定在一个可控的范围内。
这才是 AI Agent 从“玩具”走向“工业级应用”的必经之路。我们不是在写对话，我们是在编写 AI 的汇编代码。
通过「RSS阅读器」或者关注公众号「自宅创业」可以订阅博客更新，也可以在 关于我 页面找到我的联系方式，欢迎交流！
2026-01-19 16:00:00
想了解 Claude Code 的提示词是怎么设计的，最直接的方式就是抓包分析。通过网络流量，可以看清它的 System Prompt、Messages、Tools 等核心信息。
官方文档: https://www.mitmproxy.org
uv tool install mitmproxy
大多数教程用正向代理，需要配置系统代理和 CA 证书。更简单的方式是用反向代理：
mitmweb --mode reverse:https://open.bigmodel.cn --listen-port 8125
这个命令会：
然后把 Claude Code 配置中的 API 地址改成代理地址，正常使用即可。
ANTHROPIC_BASE_URL: http://127.0.0.1:8125/api/anthropic
在 mitmweb 界面中可以看到所有请求和响应：
点击具体的请求，就能看到完整的提示词内容了。
通过「RSS阅读器」或者关注公众号「自宅创业」可以订阅博客更新，也可以在 关于我 页面找到我的联系方式，欢迎交流！
