当产出不再证明理解：Agent 时代的个人认知系统重构

我过去很依赖一种笨重但可靠的学习方式：读论文，手推，写 Sage 或 Python，Debug，再把过程压成 Markdown、Notion 和 Blog。最后能运行的代码与能公开的文章，不只是成果，也是我用来判断“自己是否真的理解”的证据。

Coding Agent 改变了这个判断。今天，一个结构完整的项目、一篇公式齐全的讲义、一组跑通的实验，都可以在我尚未形成相应 Mental Model 时出现。Artifact 仍然漂亮，理解却可能没有同步发生。

这迫使我重写自己的学习系统：保留问题、预测、证据、纠错与判断，把搜索、实现、排版和实验吞吐交给 Agent；不再最大化产出数量，而是管理有限的认知算力，使机器生成的 Artifact 最终变成稳定、可迁移的 Mental Model。

一篇 LLL Blog 曾经怎样迫使我理解

我以前学习一个算法，经常从一个模糊但具体的目标开始。比如我想理解 LLL，不只是知道它是 lattice basis reduction algorithm，而是想知道：一个看起来很差的整数格基，为什么经过一组整数操作以后，会变得更短、更接近正交？这种变化在密码分析里又为什么有用？

实际路径通常很长：

1
2
3
4
5
6
7
8

论文 / Regev 讲义
-> 手推 Gram-Schmidt
-> Sage / Python 实现
-> Debug
-> 调参数与构造例子
-> 写 Markdown / Notion
-> 重写成 Blog
-> Hugo 预览与发布

这条链可能走一周，也可能拖两个月。表面看，很多时间消耗在生产劳动上：查 API、处理矩阵类型、修索引、改代码、组织语言、排版公式、调整 Hugo。后来我才意识到，旧系统的力量并不来自它“足够辛苦”，而来自这些劳动暗中承担了几种认知功能。

第一次阅读让我能够沿着作者的路线前进。写 Blog 却要求我离开作者的路线，决定先定义哪个对象、哪条因果链是主线、哪里必须举反例。它把“我能看懂作者”压成“我能脱离作者重建解释”。对我而言，Blog 是第二次认知压缩。

Coding 承担的任务不同。纸面上，我很容易把一次 lattice attack 写成：

1
2
3

construct lattice
-> LLL / BKZ
-> recover short vector

真正实现以后，问题会突然变成：dimension 到底是多少？缩放因子为什么这样选？目标向量的 norm 预计在哪个区间？HNF 是否改变了我正在观察的 basis representation？BKZ 为什么 timeout？输出的第一个向量为什么不是 candidate？Gaussian heuristic 给的是哪种尺度上的参照？

这些细节构成现实对 Mental Model 的纠错。代码能跑，只说明语法和接口大致闭合；实验结果不符合预测，才暴露我对对象的理解缺了一层。

因此，过去有三条经验相关性相当好用：

1
2
3

写得出代码 ~= 对代码和问题有一定理解
写得出文章 ~= 对知识完成过一次组织
做得出项目 ~= 对系统边界具有一定掌控

它们从来不是逻辑等价。有人可以抄代码，也可以在不理解时拼出文章。但在没有大规模生成模型的环境里，持续产出高质量代码或长文通常需要本人穿过足够多的约束。Artifact 是一个不完美、却成本很高的理解信号。

Agent 消灭的不是步骤，而是阻力

今天，同样的流程可以写成另一种样子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Prompt
-> Coding Agent
-> thousands LOC

Paper
-> LLM
-> 15000 字学习讲义

Repository
-> Agent
-> README / Blog / Documentation

步骤仍然存在，只是执行者变了。Agent 可以找到资料、生成推导、实现原型、运行实验、修测试、补文档，再把结果整理成一篇结构正确的文章。它主要压低了从 Idea 到 Artifact 之间的阻力。

这带来了一个我反复遇到的错觉。

Cognitive Artifact Illusion（认知产物幻觉）：我拥有一个高质量认知产物，于是误以为自己已经拥有与它对应的 Mental Model。

最典型的路径是：把一篇论文交给模型，让它生成详细讲义；得到一万多字、层次清楚、公式完整的笔记；阅读、收藏，然后产生“这个主题已经处理过”的完成感。几天后，如果有人问我为什么证明需要这个中间对象、假设改变以后哪里先失效，我却答不出来。

此时外部的 Knowledge Artifact 很完整，内部的 model 仍然很浅。Artifact 甚至会掩盖这种浅：流畅语言替我消除了概念之间本应暴露的裂缝。

Coding Agent 上的情况更明显。一个 Rust 密码学项目可以通过测试、拥有合理模块名、数千行实现和漂亮 README，但我可能只知道如何运行。于是下面两个量之间的相关性正在下降：

1
2
3

Code Output Quality

Engineering Understanding

Blog 也一样。语言风格、公式密度和结构完整性越来越容易生成，Beautiful Blog 对 Understanding 的证明力随之下降。

这里需要避免另一个极端：相关性下降不等于相关性归零。一个 Artifact 如果保留了问题如何形成、哪些 Prediction 被证伪、实验为何这样设计、什么 evidence 改变了判断，它仍然可以是强信号。真正贬值的是只展示终态、隐藏认知过程的 Artifact。成品还在，provenance 变得更重要。

Production-mediated Learning 为什么曾经有效

我把旧方法称为 Production-mediated Learning（产出媒介型学习）。它的核心可以写成一条具体因果链：亲手创造会产生生产摩擦，其中一部分摩擦迫使认知加工发生。“输出倒逼输入”只是这条链的粗略缩写。

1
2
3
4
5
6
7
8

Problem
-> Collect
-> Understand
-> Externalize
-> Reconstruct
-> Implement
-> Debug
-> Mental Model

Collect 迫使我判断哪些论文和文档相关；Understand 迫使我跟随定义和推导；Externalize 把模糊印象写成可观察的句子；Reconstruct 要求我改变知识顺序，用自己的语言重建；Implement 把抽象对象映射到数据结构和控制流；Debug 则让环境、类型系统、数值行为和测试结果反驳我。

这些环节并不等价。查 API 可能只是暂时的机械工作，写出一个反例却可能改变整个模型；修 frontmatter 通常没有认知收益，发现某个 scale 让 target vector 淹没在普通短向量中则有。旧流程把它们绑在一起，所以我很容易把耗时本身当作深度。

Agent 把这个绑定拆开了。过去是：

1
2
3

Thinking
-> Manual Production
-> Artifact

现在常常是：

1
2
3

Idea
-> Agent
-> Artifact

问题在于，原来藏在 Manual Production 里的外化、预测、比较和纠错，并不会自动迁移到新流程。它们可能和 boilerplate、排版、查 API 一起被删除。

所以我不想恢复所有旧劳动。继续手写八千行代码，并不会因为有 Agent 可用就突然变成更高尚的学习。真正要保留的是 Cognitive Friction（认知摩擦）：那些迫使我明确 prior、作出 prediction、面对 evidence、解释 failure、修改 model 的阻力。

Production Friction 降低是好事。错误发生在认知资源没有重新分配时。

从 Content-first 转向 Cognition-first

我暂时把新范式称为 Cognition-first Agentic Learning（认知优先的 Agentic Learning）。

“Cognition-first” 容易被误读为“看任何资料之前都必须自己想”。这在完全陌生的领域没有意义。如果我连 field、basis、witness 或 retriever 分别是什么都不知道，所谓独立 Prediction 只是在随机生成句子。

更准确的关系是：

1

Content <-> Thinking <-> Evidence

输入、思考和证据不断往返。控制权不体现在谁先出现，而体现在学习者能否持续回答：

• 我为什么要看这个？
• 我当前认为它是什么？
• 我预计条件改变后会发生什么？
• 哪种观察支持这个判断？
• 什么结果能够推翻它？
• 原模型错在对象、关系、尺度，还是边界？
• 更新以后，这个模型能迁移到哪里？

Thinking controls Content，不只意味着 Thinking before Content。它还意味着 Thinking 决定需要什么 Content、什么证据足够、Agent 应该生成哪种实验，以及生成结果是否被接受。

真正的学习事件是 Model Update

我现在更愿意把一次有效学习写成下面的循环：

1
2
3
4
5

Prior Model
-> Prediction
-> Observation
-> Prediction Error
-> Model Update

这和 Bayesian Learning 或机器学习有相似的结构：先有某种 prior，再接收 evidence，随后调整 model。Prediction 的价值是制造一个可观察的 error signal。如果我从未说清“我认为会发生什么”，现实与预期之间的差异就容易退化成一句“原来如此”。

但这只是类比，不是数学等价。人的 Mental Model 没有统一参数化；我通常不知道 evidence 的 likelihood；认知过程没有稳定、可观测的 loss，也不存在可以直接计算的 gradient。把错误沿解释链向前追踪，有一点像 backpropagation；它不意味着大脑在一张显式 computational graph 上求导，更不保证收敛。

这条边界很重要。类比可以帮助设计流程，不能替流程提供不存在的科学证明。

没有 Prediction 时，阅读很容易变成：

1

Fact -> Fact -> Fact -> Fact

外部信息量增加了，内部结构是否改变却不清楚。有 Prediction 时，至少会出现一个差分：

1
2
3
4

我认为 X
-> 现实是 Y
-> 差异来自哪里？
-> Mental Model v2

这也解释了为什么错误预测不是负反馈。只要错误被可靠证据击中，并且我真的修改了模型，它就是学习系统最有价值的事件之一。

Prediction-first 的 cold start

Prediction 也可能变成形式主义，甚至固化偏见。面对陌生领域，我会先做一个最小 bootstrap：

1
2
3
4

Vocabulary
-> Objects
-> Constraints
-> Observable Failure

先知道基本词汇指向什么对象，对象允许哪些操作，问题受什么约束，失败如何被观察。然后再写低置信度 Prediction，而不是强迫自己发明答案。

“我还不知道哪一个变量重要，但我猜测 failure 对 scale 比对 dimension 更敏感”是一条可测试的 Prediction。“我不知道”也可以是一条有效状态，只要后续知道需要什么 evidence 才能减少这部分不确定性。

Prediction 的职责是暴露可纠错接口，不是证明我比资料更聪明。它必须带置信度，必须允许反例，也必须允许被删除。

先成为一次失败的 LLL 设计者

LLL 很适合说明这种差异。传统学习路径很容易从定义开始：背 size reduction，背 Lovász condition，照伪代码实现。每一个组件都显得像“算法规定如此”。

我更想先问：给定一个很差的整数 lattice basis，我希望得到更短、更接近正交的 basis，可以尝试什么？

在二维里，设 Gram-Schmidt coefficient 为

因为 lattice basis 允许整数线性组合，一个自然操作是

这个 elementary unimodular basis operation 不改变 lattice。若目标是减少 (b_2) 在 (b_1^*) 方向上多余的投影，局部最自然的选择是

更新后，相应的 Gram-Schmidt coefficient 被压到靠近零的代表元，通常满足绝对值不超过 (1/2)。这就是 size reduction 的设计压力：整数约束下，删掉沿前一个方向可消去的投影冗余。LLL 的原始工作把这种 basis reduction 放进了有多项式时间保证的算法中。¹

但只做 size reduction 不够。一个 basis 可能局部投影已经很小，顺序却仍然很差：前面的 Gram-Schmidt vector 太长，后面的向量携带了本应更早出现的短方向。于是 swap 变得自然。

下一问才是关键：什么时候 swap？如果只要看到更短就换，如何保证进展？如何避免反复交换？这时才需要一条把局部正交长度、投影项和 progress measure 连接起来的条件。标准 LLL 中，Lovász condition 可以写成

其中 \(1/4<\delta<1\)。违反它时交换相邻 basis vectors，并更新 Gram-Schmidt 数据。

我不是通过这几步“重新发明了 LLL”。从局部去冗余到带势函数的多项式时间算法，中间还有真正困难的证明。Lovász condition 也不是从上述直觉中逻辑唯一地推出。这里获得的是 Designer View（设计者视角）：size reduction 解决什么约束，swap 解决什么约束，progress condition 为什么必须存在。

当我带着这些失败再读论文，问题从“作者给了我一个未知答案”变成“作者如何处理我刚才遇到的 termination、quality bound 和 bit complexity？”阅读密度完全不同。

这个视角还会自然打开周围问题：orthogonality 用 Gram-Schmidt 还是 QR 表达？LLL 给的是 shortest vector approximation 的什么 upper bound？candidate vector 为什么不一定出现在第一个位置？Minkowski bound 与 Gaussian heuristic 分别提供哪种尺度？lattice scaling 怎样改变目标结构与普通短向量的相对位置？HNF 是 lattice 的 canonical representation，还是当前攻击需要的好 basis？

这些对象不全是 LLL 的“组件”。它们属于 LLL 被实际使用时展开的 problem space。把它们混成一张术语表没有用；知道每个对象在什么 failure 之后出现，才形成结构。

Historical Information Boundary：主动限制后验信息

我把上面的做法概括为 Historical Information Boundary（历史信息边界）：暂时不给自己最终 architecture，只给当时已知的问题、约束、前置理论和 observable failure，然后问，如果我是设计者，下一步会尝试什么？

一个夸张的思想实验是：只给大模型 1910 年之前的数据，要求它尝试走向广义相对论。它大概率不会成为 Einstein；学习者也不可能靠隐藏答案复制历史突破。这个实验的价值不在于智力表演，而在于暴露 final theory 出现之前的 constraints：哪些观测与旧模型冲突，哪些不变量必须保留，哪些数学工具还缺失。

Designer View 在算法、协议、系统架构和可以快速实验的问题上通常很高效，因为设计选择与 failure 可以反复对照。它在另一些领域可能浪费巨大：

• 历史事实和规范约定并不是通过局部推理“自然出现”的；
• 记忆型知识不值得每次重新发现；
• 前置知识极厚的成熟理论，盲目探索可能只是在重演早已排除的死路；
• 医学、硬件安全和生产密码系统等高风险领域，错误实验的成本可能不可接受；
• 结果无法低成本验证时，Designer View 容易制造错误自信。

因此，我只在 Knowledge-Critical Path 上设置历史信息边界。权威资料、原始论文和专家校验并不与它冲突。它们负责给出可靠边界；受限设计负责让我理解边界为何存在。

RAG：先展开 Problem Space，再学习组件名

RAG 也可以用同样方式学习。若一开始看到的是：

1
2
3
4
5

chunk
-> embedding
-> vector DB
-> retrieval
-> reranker

我很容易记住一个 framework pipeline，却不知道每个组件在解决什么 failure。

更好的起点是一个真实问题：LLM 不知道公司内部安全知识，但现在要分析一场安全事件，怎么办？

最朴素的答案是搜索，把相关内容放进 context。RAG 最初的经典形式也正是把 parametric model 与可检索的 non-parametric memory 组合起来。²

一旦开始设计，问题空间会自己展开：

1. 怎么搜索？Incident 描述可能包含 CVE、内部资产名、日志片段和行为语义，semantic similarity 不必然等于任务 relevance。
2. BM25 是否比 embedding 更适合精确标识符？是否需要 hybrid retrieval？
3. metadata 能否表达资产、时间、密级、团队和数据来源？
4. 原始 query 是否足够，还是需要 decomposition 或 rewriting？
5. working environment 很脏时，未提交代码、临时 patch 与主分支文档哪个是当前事实？
6. retrieved knowledge 与模型内生知识冲突时，谁优先？来源和时间如何展示？
7. 旧 runbook、过期 CVE 结论和已撤销策略怎样失效？
8. retrieval miss 如何被观察？“没有检索到”不能自动等于“事实不存在”。
9. 用户是否有权看到被检索的文档？ACL 应在哪一层执行？
10. 检索内容如果包含恶意 instruction，模型能否区分 data 与 command？

最后两项会把 RAG 从 information retrieval 推到 security architecture。Indirect prompt injection 的攻击面正来自 LLM-integrated application 对外部内容的处理：攻击者不必直接控制用户输入，只要影响可能被检索的数据，就可能把 instruction 带入模型上下文。³ PoisonedRAG 进一步把 knowledge database 本身作为攻击面，展示少量恶意文本如何针对特定问题诱导目标答案。⁴

这并不意味着每个 RAG 都必然被攻破，也不意味着加一个 content filter 就解决问题。它说明 retrieved context 必须被当作带 provenance、权限和 trust level 的输入；访问控制、来源隔离、instruction/data separation、审计日志和结果验证属于同一设计空间。

此时，我正在亲自展开 RAG 的 Problem Space，而非记忆某个 framework 的模块列表。chunk size、reranker、query rewriting 只是对一组约束的具体回答。换一个问题、数据源或威胁模型，architecture 就可能改变。

Agent 的最大价值是缩短 Hypothesis 到 Reality

旧学习系统的反馈距离很长：

1
2
3
4
5

Hypothesis
-> 自己 Coding
-> Debug
-> Benchmark
-> 一天后看到结果

今天，我可以先明确假设和观测指标，再让 Agent 构造实验、补测试、运行几十组参数，十几分钟后返回结果。相较于 Typing Accelerator，我更愿意把它的学习价值理解为 Experiment Throughput Multiplier（实验吞吐放大器）。

真正应该增加的吞吐单位是闭合回路，而非 LOC：

1
2
3
4

Hypothesis
-> Evidence
-> Prediction Error
-> Revision

以 lattice scaling 为例，我不需要手工写十个近似相同的脚本。我可以先预测：某个 scale 区间会让目标向量进入可区分的 norm range；指定 dimension、basis construction、随机种子、候选判断和停止条件；让 Agent 批量实验；然后看 transition 出现在何处。一天内可以经历多次 model revision，而不是把大部分时间耗在复制参数。

这里也有危险。如果 hypothesis 由 Agent 提出，metric 由 Agent 选择，实验由 Agent 实现，异常由 Agent 过滤，结论仍由 Agent 总结，那么所谓高速反馈可能只是同一个偏差在系统内自我确认。实验数量增加了，independent evidence 没有增加。

我需要控制的至少包括：实验想区分哪两个 model、什么结果算 falsification、指标是否真的测量目标、哪些异常不能丢、什么时候停止、是否需要第二种实现或外部数据交叉验证。

Agent 可以扩大 Reality 的采样带宽，不能自动决定哪一部分 Reality 与我的问题有关。

Coding Agent 以后，我还需要读完所有代码吗

在 Sage 或 Python 小脚本里，我过去拥有很强的 implementation-level ownership：变量、控制流、API、错误、数学对象和代码结构都比较熟悉。这种掌控感部分来自代码规模小，也来自每个 bug 都经过我的手。

面对 Agent 生成的 Rust 或 C++ 密码系统，条件完全不同：

1
2
3
4
5
6

thousands LOC
traits / generics / lifetimes
FFT
serialization
field arithmetic
R1CS / QAP

逐行阅读不再现实，也未必合理。于是我开始把代码理解分层：

这不是能力等级排行榜。L4 并不总比 L2 更“认真”。如果我研究的是 R1CS 到 QAP，把 CLI parser 读到 L4 是认知预算浪费；如果我要维护一个公开网络服务，serialization、错误处理和并发边界就不可能只停在 L0。

不同代码值得不同深度。深度由问题重要性、failure impact、不确定性和未来复用决定，不由 Agent 生成了多少代码决定。

Semantic Coverage 大于 Line Coverage

Agent 时代的 Code Ownership 不再适合用看过多少行来衡量：

1
2

Code Ownership != Line Coverage
Code Ownership ~= Semantic Coverage

这里的 Semantic Coverage（语义覆盖），指我是否覆盖了承载目标知识和主要风险的对象、变换、不变量与失败路径。

假设 Agent 生成一个 R1CS/QAP Rust implementation。我的初始深度分配可能是：

1
2
3
4
5
6
7
8
9

CLI                     L0
Logging                 L0 / L1
Serialization           L1

Constraint IR           L3
Witness                  L3
R1CS satisfaction       L4
Interpolation            L3
QAP transform            L4

如果研究目标是 R1CS 到 QAP，我必须回答：为什么需要插值？(A_j(X))、(B_j(X))、(C_j(X)) 是什么？evaluation domain 是什么？vanishing polynomial 为什么出现？constraint satisfaction 为什么等价于 polynomial divisibility？代码对象如何对应数学定义？

这条真正承载知识的路径，就是 Knowledge-Critical Path（知识关键路径）。

生成代码之前，先预测 architecture

我不会先让 Agent “实现完整 R1CS”。我会先写出一个可能失败的 architecture：

1
2
3
4
5
6

Constraint
Witness
Field
Polynomial
EvaluationDomain
QAP

再预测核心数据流：

1
2
3
4
5
6
7

constraints
-> coefficient vectors
-> interpolation
-> A / B / C polynomial families
-> combine witness
-> construct P(X)
-> check P(X) mod Z(X)

其数学接口是：第 (i) 条 R1CS constraint 满足

选择互异 domain points (r_1,\ldots,r_m)，对每个 witness coordinate (j) 插值得到多项式族，使 (A_j(r_i)=A_{i,j})，并对 (B,C) 做同样构造。用 witness 组合后：

若全部 constraints 成立，那么

在所有 (r_i) 上为零。对

就有 (Z(X)\mid P_w(X))，即存在 quotient (H(X)) 使 (P_w(X)=H(X)Z(X))。这是 QAP 把 many-row constraint satisfaction 压成 polynomial divisibility claim 的核心接口；Pinocchio 一类系统沿着 QAP 接口把计算送入可验证计算协议。⁵

这条等价依赖正确构造：domain points 必须互异，插值与矩阵行必须一致，witness ordering 必须一致，field 运算必须落在同一语义中。它不是“把矩阵换成多项式”后自动成立。

因此我还会提前预测 failure points：

1
2
3
4
5

constraint indexing
constant wire
domain ordering
coefficient / evaluation representation
field normalization

Agent 生成代码以后，review 从逐行通读改成比较：

1
2
3

My Mental Model
       vs
Agent Implementation

Agent 为什么多出一个 intermediate representation？为什么 evaluation domain 被抽象成 trait？为什么常数 wire 放在 index 0？为什么 polynomial 在一处是 coefficient form，在另一处是 evaluation form？这些 architecture diff 本身就是学习材料。

Semantic Coverage 的反例

Semantic Coverage 很容易被滥用为“细节不用看”。在密码系统里，这可能直接出错。

Serialization 看似外围，但非 canonical field encoding 可能产生歧义；field normalization 看似实现细节，却可能破坏相等性判断；constant-time behavior、unsafe code、memory layout 和 concurrency 可能不改变数学公式，却改变 side-channel 与内存安全结论。若 threat model 包含恶意输入，parser 也可能从 L1 突然升到 L3。

所以 Knowledge-Critical Path 不是固定模块白名单。它必须随研究问题、威胁模型和 failure impact 动态重算。对安全关键代码，低层机制本身就是语义。

Cognitive Sovereignty：Agent proposes patch

在这套系统里，我最想保护的是 Cognitive Sovereignty（认知主权）。

AI 可以替我搜索、写代码、整理资料、排版、重构、跑实验、写文档和生成图表。但下面这些问题不能在我不知情时一起外包：

1
2
3
4
5
6
7
8

什么问题重要？
为什么这样设计？
我预计会发生什么？
什么结果可信？
什么 evidence 足够？
哪个 failure 最重要？
为什么接受这个结论？
什么证据改变了我的观点？

我喜欢用一句工程比喻压缩它：

Agent proposes patch. Human commits belief.

Agent 可以生成 hypothesis，甚至比我更快地列出十种解释。但 hypothesis 出现在对话里，不等于应该被写进我的 Mental Model。最终 epistemic commit 属于我：我必须知道接受了什么、依据是什么、还剩哪些不确定性，并且在新证据出现时能够撤销。

这也修正了我最初使用的 “Human-only Zone”。绝对禁止 AI 并不必要。更准确的是 Human-controlled Zone（人类控制区）：

AI 可以参与每一栏。认知主权强调对 commit 流程的控制、追溯和撤销，不要求孤立思考。

Assimilation Rate 才是新瓶颈

Agent Output Rate 的增长远快于 Human Assimilation Rate：

1
2

Agent Output Rate        ↑↑↑↑↑
Human Assimilation Rate  ↑

于是新系统的基本约束变成：

我不准备靠更快阅读或少用 AI 解决这个差距。关键是降低需要被完整内化的 Artifact 比例。

我有时用一组很粗的比例提醒自己：

1
2
3
4
5
6

Agent generated           100%
需要知道存在              100%
需要理解 interface         40%
需要理解 architecture      20%
需要理解 mechanism         10%
需要能够重新实现             3%

这些数字不是经验研究结果，更不是普遍配方。它们只表达一种预算关系：生成物可以全部进入外部系统，但只有少数部分进入 L3/L4。真正比例由问题重要性、风险、不确定性和未来复用决定。

这就是 Depth Allocation（深度分配）。如果当前目标是理解 R1CS/QAP，可以让 Rust syntax 停在 L1/L2，让 ownership model 和 trait abstraction 到 L2，让 R1CS semantics 与 QAP transformation 到 L4，让关键实现到 L3。若未来目标变成 Rust cryptography engineer，语言、内存模型、serialization 和 constant-time implementation 会进入新的 Knowledge-Critical Path。

认知预算跟着问题移动，不跟着 LOC 移动。

当一天全部变成高强度思考

旧的两个月学习，并不意味着每天八小时都在做数学推导。Coding、formatting、writing、waiting、refactoring 和 documentation 中有大量低认知负荷工作。过去的节奏更像：

1
2
3
4

High cognition
-> Low cognition
-> High cognition
-> Low cognition

Agent 清除大量低负荷劳动后，一天可能变成：

1
2
3
4
5
6
7
8

Design
-> Hypothesis
-> Prediction
-> Critical Review
-> Experiment
-> Model Revision
-> Design
-> ...

这不是纯收益。AI 解放了认知，也取消了旧流程里天然存在的休息区。过去我会在整理 bibliography、等待编译或重构 boilerplate 时降档；现在 Agent 在后台完成这些工作，我反而可以连续进入下一轮 G4，直到判断质量突然下降。

Cognitive Gearbox

我因此给工作状态划了几个 Cognitive Gear（认知档位）：

G4 — Deep Design

从零设计、数学推导、hypothesis、architecture、proof、hard debugging、cryptanalysis。它要求同时维持多个约束，适合成块时间，不适合无限续杯。

G3 — Active Verification

阅读论文关键段、review Agent architecture、验证推导、设计实验、找 counterexample、做 benchmark。负荷仍然高，但问题空间更受约束。

G2 — Integration

记录 Cognitive Delta、整理 experiment、画图、用自己的语言解释、复盘并重组已有理解。这类 integration 负责把短期更新写入长期模型，不能当成低价值整理。

G1 — Mechanical Production

Formatting、boilerplate、API glue、bibliography、migration、documentation。大部分可以 Agent 化。有时我会故意保留少量 G1 作为 cooldown，但不会把无意义劳动浪漫化为学习。

G0 — Recovery

散步、运动、吃饭、聊天、音乐、洗澡、睡眠、发呆。它们不直接生成 Artifact，却决定下一次 G3/G4 是否还有判断质量。

真正稳定的能力体现在正确切档，而非永远处于 G4。恢复可以用下面的训练类比理解：

1
2
3
4

Stimulus
-> Fatigue
-> Recovery
-> Adaptation

这个类比只服务于流程设计，不构成对个体认知的精确生理模型。它提醒我：Recovery 属于长期学习回路，不能简单记作 Productivity Failure。

不最大化 Cognition Density

如果只优化 Insight / Hour，Agent 会把每一分钟都填成高负荷活动。这种局部最优很容易破坏长期吞吐。

我更愿意用一个概念目标函数约束自己：

它不可直接测量，也不应被伪装成科学定律。分母相乘只是为了强调：同样数量的 insight，如果带来更高疲劳与更长恢复，长期价值可能更低。

一天得到十个 insight，第二天完全无法工作，可能不如每天六个、连续运行一个月。对复杂密码学问题尤其如此：疲劳往往先损坏边界判断、反例敏感度和对“看起来合理”答案的抵抗力，打字速度反而没那么关键。

Artifact 不再是经验值

旧学习系统的正反馈非常容易观察：

1
2
3
4
5

+1000 LOC
+1 Blog
+1 GitHub commit
+1 Notion page
项目跑起来

新的认知进展更隐形。如果不主动记录，我会因为“今天没有产出文件”而低估真正发生的更新，也会因为 Agent 生成了大量文件而高估进展。

我开始记录另一类事件：

1
2
3
4
5
6

+1 prediction confirmed
+1 prediction falsified
+1 counterexample found
+1 mental model revised
+1 design choice understood
+1 transfer succeeded

其中 Prediction 被证伪同样是正反馈：

1
2
3

Wrong Prediction
-> Error Signal
-> Model Update

但记录本身也会形式主义化。如果我每天强迫自己填写 Prediction、Cognitive Delta 和 Gear，最后只是为了完成模板，系统就又回到了 Artifact illusion。Metacognition 也必须被审计：这个字段最近是否真的改变过下一步行动？没有就删除。

Blog、Notes 与 Project 应该移动到后端

过去，Blog、Notes 和 Project 同时是学习方法与最终产物。现在我更愿意把它们放到 pipeline 后端：

1
2
3
4
5
6
7

Questions
-> Hypotheses
-> Predictions
-> Experiments
-> Cognitive Delta
-> Stable Mental Model
-> Blog / Notes / Project

Blog 不会消失。它变成 稳定 Mental Model 的编译产物。

这个比喻也限定了 AI 的角色。Agent 可以做语言润色、排版、引用、图表、代码整理和文档结构；但作者必须拥有 Thesis、Argument、Evidence、Counterargument 和 Judgment。否则编译器生成了一个可执行 Artifact，source model 却不在作者手里。

这篇文章本身也必须接受同一标准。拥有完整标题、概念和流程图不证明观点成立。真正需要检查的是：我是否说明了旧方法为什么有效、Agent 到底移除了什么、Prediction-first 在哪里失效、Semantic Coverage 如何避免成为偷懒借口、Recovery 为什么进入目标函数，以及这些判断能否迁移到下一个具体学习任务。

企业评价：Proxy 的解释力正在重分配

这个变化也会延伸到能力评价。

过去，持续写出高质量代码是一个很强的 Bayesian Signal。严格说，企业并不会真的计算

但在无法直接观察认知过程时，代码、学历、竞赛、论文、实习、本科背景和 GitHub 都可以被看成 proxy 或 prior。它们压缩了长期能力与执行记录。

AI 生成降低了 Artifact production 的成本以后，下面两种方向性相关都会下降：

1
2

Corr(Code Output, Engineering Understanding)
Corr(Beautiful Blog, Understanding)

这里没有可辩护的统一相关系数，也不能推出学历或 GitHub 彻底失效。传统 Proxy 仍然携带筛选、持续投入、团队协作和历史执行信息。改变的是相对解释力：当成品更容易生成，评价者会更需要追问成品背后的判断。

例如：

• 为什么这样设计？
• 条件改变后哪个模块先失效？
• 你预期最危险的 failure 在哪里？
• 怎么验证，不验证什么？
• 什么 evidence 足够接受结论？
• 为什么不用另一个 architecture？
• Agent 给出错误答案时，你怎样识别？
• 能否把当前模型迁移到一个新问题？

Artifact production commoditizes; Judgment becomes scarce.

真正变稀缺的能力正在从连续生产，迁移到 Problem Formulation、Prediction、Design、Judgment、Verification、Interpretation 和 Transfer。Execution ability 仍然重要，只是不再能用 LOC 或文章数量单独代表。

一个 Agent-era Personal Cognitive OS

把这些原则放在一起，我得到一个仍在实验的 Agent-era Personal Cognitive OS（Agent 时代个人认知操作系统）。它描述资源与控制权如何流动，不是一套固定 SOP：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

                 QUESTION
                    |
               PRIOR MODEL
                    |
                 PREDICT
                    |
             DEPTH ALLOCATION
                    |
                  DESIGN
                    |
                DELEGATE
                    |
          +---------+---------+
          |                   |
        AGENT              RECOVERY
          |                   |
          +---------+---------+
                    |
                 EVIDENCE
                    |
             SEMANTIC REVIEW
                    |
            PREDICTION ERROR
                    |
              MODEL UPDATE
                    |
                 TRANSFER
                    |
                INTEGRATE
                    |
                RECOVERY

它的目标不是最大化知识输入，也不是最大化 Agent 产出。它要管理一个人的有限认知算力，让 Agent 提供的大规模执行能力转化为长期、稳定、可迁移的 Mental Model。

Depth Allocation 决定哪些地方需要 L4，哪些停在 interface；Delegate 把生产和实验吞吐交给 Agent；Semantic Review 检查知识关键路径；Prediction Error 定位 prior 与 evidence 的差异；Transfer 测试更新是否只适用于当前例子；Recovery 维持下一轮判断质量。

这套系统仍然有失败模式。Prediction 可能变成模板，Designer View 可能浪费时间，Semantic Coverage 可能掩盖底层风险，Cognitive Gearbox 可能变成另一套自我量化表格。继续增加字段只会加重问题；metacognitive process 需要接受同样的收益审计：它是否产生了可识别的 Model Update？是否改变了 evidence threshold？是否帮助我停止了一条错误路径？

如果没有，就删掉形式。

八个暂时稳定的判断

经过这轮重构，我目前愿意保留八个可以继续被实践检验的判断。

第一，AI 主要降低的是 Production Friction。学习者需要主动保留 Cognitive Friction，即问题、预测、证据、解释和纠错造成的有效阻力。

第二，高质量 Artifact 不再是高质量 cognition 的可靠证明。它仍然可以是 evidence，但需要 provenance、失败记录和判断链来恢复信号。

第三，学习的核心指标应从 Output Volume 转向 Meaningful Mental Model Update。没有改变可迁移模型的输入和产出，价值需要重新审计。

第四，Agent 最强的学习价值之一，是压缩 Hypothesis -> Reality 的反馈距离并提高实验回路吞吐；代写只是其中较浅的一层。

第五，代码掌控需要从 Line Coverage 转向 Semantic Coverage，同时允许威胁模型把任何底层细节重新提升为 Knowledge-Critical Path。

第六，真正稀缺的能力正在向 Problem Formulation、Prediction、Design、Judgment、Verification、Interpretation 和 Transfer 移动。Artifact 的生成成本下降，不会自动生成这些能力。

第七，学习系统不能只优化 Cognition Density。它必须共同优化 Cognition、Feedback、Recovery 与 Sustainability；否则 Agent 只是把过载速度提高了。

第八，最终需要保护的是 Cognitive Sovereignty：

Agent 可以产生 Artifact，但 Human 必须保留对 Belief 的 commit 权。

机器仍然可以参与判断；每一次关键 commit 则要有可追溯的 evidence、明确的 uncertainty 和可撤销的路径。机器扩大执行，人保留问题与判断。对我而言，这才是 Agent 时代学习系统真正需要升级的地方。

References