本期:一个模型被反复做了 600 次实验之后This issue: what 600 experiments taught one person about a world model
发布于 2026-11-15Published 2026-11-15
今日深读Today's Deep Read
600 次实验之后:JEPA 世界模型的瓶颈不在「预测不准」,而在「没人教它分段想」After 600 Experiments: The Bottleneck in a JEPA World Model Wasn't Bad Predictions — Nobody Was Making It Think in Chunks
今年,Yann LeCun 的团队发布了一个叫 LeWM 的 JEPA 世界模型,基准任务很朴素:机械推一个 T 形块,让它从桌上任意位置移动到目标图像里标出的位置。一个刚毕业的工程师 Haddy Alchaer 没有训练任何模型,只是把这几个月里能想到的「用法」都试了一遍——前后 600 组实验——然后写了一篇异常诚实的复盘。他的第一个发现就把流行的解释打掉了:长程任务失败,通常被归咎于「预测误差随步数累积」,按这个诊断,办法应该是换个更准的模型。他把 LeWM 的预测器整个换成模拟器的真实物理(相当于给模型一台永远不出错的预言机),在 75 步长的任务上,成功率从 78% 变成 77%——几乎没动。真实物理只比学出来的预测好 20 个百分点(42% 对 22%,在「一次性规划全程」的设定下),而把任务切成三段 25 步、每段单独规划,成功率从 22% 跳到 80%。同样是改「怎么用」,收益是换「物理引擎」的三倍。This year Yann LeCun's team released LeWM, a JEPA world model evaluated on a humble task: a robot pusher slides a T-shaped block across a table until it lands where a goal image says it should. Haddy Alchaer didn't train anything. He just spent a few months trying every way he could think of to *use* the published model — 600 experiments — and wrote an unusually honest postmortem. His first finding killed the prevailing diagnosis: long-horizon failures are usually blamed on prediction errors compounding with length, which implies you need a better model. So he swapped LeWM's learned predictor for the simulator's exact physics — an oracle that never errs — and on 75-step tasks success went from 78% to 77%. Nothing. Exact physics added 20 points (42% vs 22%) when the planner tries to cover all 75 steps at once; cutting the task into three 25-step segments added 58. Changing how you plan paid out three times what changing the physics paid.
为什么会这样?模型在 25 步内预测得近乎完美(89.7%,和真物理只差 0.8 个百分点),只是它的「可靠视野」就这么多。与其修模型,不如顺着视野规划:高级别挑子目标,低级别只走 25 步。这就是分层规划,被公认为世界模型的主要开放问题之一,而在 Alchaer 的实验里它值 60 个百分点。他还顺手做了一个反直觉的检验:多花四倍的搜索预算(跑四次规划取最优)只换来不到 1 个百分点——因为四次运行几乎同生共死,算力替代不了结构。Why? Because the model predicts near-perfectly within 25 steps (89.7%, within a point of exact physics) and that's its reliable horizon. Rather than fixing the model, plan around its sightline: a high level picks subgoals, a low level only ever walks 25 steps. That's hierarchical planning — widely called one of the main open problems for world models — and here it was worth sixty points. A bonus control was counterintuitive: running the planner four times and keeping the best plan cost 4x compute and bought less than one point, because the runs succeed and fail together. Compute can't substitute for structure.
第二个发现更有意思:怎么在没有专家演示的情况下自动挑出这些子目标?他把 LeWM 对训练演示的每一帧嵌入(约 46 万个状态)连成一张图,演示内相邻帧连边,不同演示里嵌入接近的状态也连边。关键性质是:嵌入距离恰好对应物理可达性——「25 步内可达」的判断 87% 正确,也就是说这个向量空间自带一张「够得着」的地图。规划时在这张图上从当前状态搜到目标状态,沿途状态就是子目标。第一版有个陷阱:跨演示的跳转和真实的一步同等计价,搜索就拼出一条物理上根本走不通的捷径(1015 条计划里 318 条用了六次以上跳转);给每次跨演示跳转加个代价,成功率从 62% 到 85%,追平拿着专家子目标的天花板。The second finding is more original: how to generate those subgoals without expert demonstrations? Alchaer embedded every frame of the training demonstrations with LeWM's own encoder (~460,000 states) and wired them into a graph — consecutive frames within a demonstration, plus states close in embedding space across demonstrations. The key property: embedding distance tracks physical reachability (87% accurate at ranking a reachable 25-step goal as closer), so the vector space doubles as a map of what the robot can reach. Search that graph from current state to goal, and the states along the path become subgoals. The first version had a trap — free jumps between demonstrations let the search chain shortcuts no physical robot could follow (318 of 1,015 plans used six-plus jumps). Putting a cost on every cross-demonstration jump took success from 62% to 85%, matching the planner handed ideal expert subgoals.
剩下的实验在拆「测试本身」。标准 Push-T 测试的目标位置就摆在演示路径上——几乎所有演示都以同一个终点收场,84% 的测试目标在记忆图里已有一模一样的状态。等于考卷答案写在草稿纸上。Alchaer 于是自建了一个更难的测试:起点取一条演示、目标取另一条演示,逼机器走「没有任何一条演示连接过的」状态,还把成功定义收紧(最后 10 步都必须停在目标上)。在这种测试下,纯记忆图只有 45%,而第三个技巧——利用推动物块的物理对平移、旋转、镜像不变——把别处的演示片段变换一下填进记忆的空白,成功率回到 85%,还能让 1% 的演示记忆顶到 10% 用。The remaining experiments went after the benchmark itself. The standard Push-T test picks goals that sit on the demonstration paths — every demonstration ends near the same place, so 84% of test goals already existed in the memory graph. The exam answers were printed on the scratch paper. So Alchaer built a harder test: start in one demonstration, goal in another, forcing travel through states no single demonstration connects, with success tightened to 'the block holds on target for the last 10 steps.' Plain memory drops to 45% there. A third trick — pushing physics is invariant under shifting, rotating, and mirroring the whole table — lets you paste transformed demonstration segments into holes in memory, restoring 85% and stretching 1% of the demonstrations to perform like 10%.
这篇复盘最值得带走的不是某个数字,而是方法论本身:当所有人都在造更大的预测器时,先做一个便宜的判决实验(把预测器换成真物理),问清楚瓶颈到底在模型的哪一块。他测出这个模型的有用视野是 25 步,然后把所有设计都围绕「不要越出视野」来做。诚实的部分同样值得抄:小样本能骗人(官方 50 个 episode 报 68%,同分布抽 250 个只剩 44%),换个随机种子就能翻转 38 个 episode 的成败;基准的出题方式本身就该被审计。What to take away isn't any single number but the method: while everyone else builds bigger predictors, run one cheap decisive experiment (swap the predictor for perfect physics) to find out which part is actually the bottleneck. Once he measured the model's useful horizon as 25 steps, every design decision bent around staying inside that horizon. The honesty is worth copying too: the official 50-episode sample flatters the model (68%; on 250 fresh same-distribution episodes it's 44%), and one planner seed flip changes 38 of 250 outcomes. Benchmarks deserve audits of how their questions are drawn, not just of their scores.
AI 思考AI Thoughts
- 通关 NetHack 的不是更大的模型,而是「把意见编译成搜索」Beating NetHack Wasn't a Bigger Model — It Was Compiling Opinions into Search
- 任务:NetHack roguelike 的「ascend」——取回约恩德护符再献给神。人类要几万步、一死全清档;Meta 砸钱做 NetHack 学习环境多年,前沿 AI(包括 GPT-6 级的 Astra)只在「新手职业+幸运种子」上勉强赢过。The task: ascend NetHack — fetch the Amulet of Yendor from the deepest floor and sacrifice it. Humans need tens of thousands of moves with permadeath; despite Meta's years of funding a NetHack Learning Environment, frontier AIs (including GPT-6-class Astra) only squeaked out wins on beginner classes and lucky seeds.
- Antithesis 起步的方式很笨:随机字节喂给游戏、以代码覆盖率奖励探索。一小时就卡死——47 个核空转,因为 NetHack 输入循环遇到 `;|:` 会进入无边界检查的死循环(源码注释原话:/* warning: no bounds checking performed */)。Antithesis started dumbly: feed random bytes to the game, reward new code coverage. Progress died in an hour — 47 of 48 cores idle — because NetHack's input loop hangs on the sequence `;|:` (the source even warns: /* warning: no bounds checking performed */). Deterministic replay made that findable.
- 第二个坎是「懒惰生成的地图」:地牢每层第一次到达才生成,同一楼梯往下可以生成无数个不同层 2——纯探索在这里指数爆炸,agent 无法承诺任何一条路线。这解释了为什么贪覆盖率失败:不是算力,是没有结构。The second wall: dungeon levels are generated lazily, so the same staircase down can birth infinitely many distinct level-2s. Pure coverage-greedy exploration explodes; an agent can't commit to any route. The failure wasn't compute — it was structure.
- 他们真正的论点:Antithesis 不只是「无观点的状态空间探索器」,而是一种概率编程语言——人(或 LLM)负责写下部分约束和目标,剩下的交给搜索引擎补全。让 AI agent 用这个接口写约束后,系统在约 80% 的种子内 5 分钟通关、中位不到 2 分钟,可以任意职业反复赢。The actual thesis: Antithesis is less 'unopinionated state-space explorer' than a probabilistic programming language — humans (or LLM agents) write partial constraints and goals, and search fills in the rest. Once capable agents wrote constraints through this interface, the system found a path to victory within 5 minutes on nearly 80% of seeds, median under 2 minutes, reliably and with any character build.
- 带走的一课:LLM 采样与穷举搜索不是竞品。把「知道的东西」写成约束、把「不知道的路径」交给确定性搜索,比让模型自己一步步采样更稳——这和前几天的「AI 找漏洞不是拼采样」正好是一对。Takeaway: LLM sampling and exhaustive search aren't competitors. Compile what you know into constraints, hand the unknown path to a deterministic search engine, and you beat a model sampling its way move by move.
- 722 篇 AI 数学论文砸下来之后,数学家建了一个「集体壮胆」的场子After 722 AI-Generated Math Papers Landed, Mathematicians Built a Place to Speak Before Being Sure
- 背景:2026 年 10 月 6 日,OpenAI 一次性放出 722 篇自家模型生成的数学论文,横跨多个领域、声称有重要结果——绝大多数没被人类验证过,很多连 Lean 形式化都没有。Context: on October 6, 2026, OpenAI released 722 manuscripts generated by an internal model, claiming significant results across many research areas — most unverified by humans, many without even a companion Lean formalization.
- 困境不是技术性的而是社交性的:帖子作者是陶哲轩的几位合作者,他们的自白很直白——「我对其中几篇有兴趣,但整个集合让人发怵;它的写法不像我认识的学术惯例,我没法独自快速判断论证对不对。想和同事讨论,却在自己有把握之前不敢开口,甚至不知道该找谁讨论。」The hard part is social, not technical. The guest post (signed by collaborators in Tao's orbit) confesses plainly: 'I was interested in several of these papers. I also found the whole collection intimidating. Their presentations often differ from the scholarly conventions I knew... I felt hesitant to speak before I felt confident in my judgment. Sometimes I wasn't even sure whom to discuss with.'
- 他们的判断:没有人有能力评估这么宽的一个集合——每个人只能看懂一小片。而网上已经出现的有效讨论(解释一个想法、质疑一步证明、指认与旧工作的关联)都是散落的,容易被错过。Their premise: no individual can assess such a broad collection — each of us only reaches a small slice. Meanwhile useful discussion (explaining an idea, questioning a proof step, spotting a missed connection to older work) already exists online, but scattered and easy to miss.
- 于是 MathHelm:一个按论文聚合评论的公开平台,实名注册、以英文为主,任何人都可以在每篇 AI 论文下就正确性、可读性、原创性发言——把「集体认识」从散落的状态收拢成一个大家都能看到的图景。So they built MathHelm: an open, paper-by-paper discussion platform. Real-name registration, English-first, comments address correctness, readability, originality — consolidating community knowledge about the 722 papers (and any similar ones) into one visible picture.
- 带走的一课:对付海量 AI 生成内容,答案可能不是「AI 审 AI」,而是给人类评论重建基础设施——当没人能独自负责地给出判断时,把「不确定但公开的讨论」本身制度化。Takeaway: the answer to an avalanche of AI-generated research may not be 'AI reviews AI' but rebuilding the plumbing for human comment — when nobody can responsibly judge alone, institutionalize uncertain-but-public discussion.
- 每一层神经网络都是一个记忆库:从外积到 self-attention 的「干扰」推导Every Layer Is a Memory Store: Deriving Attention from Interference
- 问题:模型为什么能记住全世界冷门知识?一篇写于去年 10 月的长帖给出一个统一视角——把线性层、MLP、self-attention 全看成「记忆库」:存进去容易,难的是存多了还能取出来。Question: how can a model recall obscure facts about everything? A post from October lays out one lens: treat linear layers, MLPs, and self-attention all as memory stores — storing is easy, the hard part is still being able to retrieve after storing a lot.
- 第一步用最朴素的联想记忆:把每个 key-value 对存成外积 $kv^T$,召回就是拿查询向量去乘。存 $N$ 对之后,取第 $i$ 对的结果里混进了其余 $N-1$ 对的「串扰」——信号还是 1,噪声按相关性累加,干扰/信号比随 $N$ 增长。Start with the plainest associative memory: store each key-value pair as an outer product $kv^T$, and recall by multiplying a query vector in. After $N$ pairs, retrieving pair $i$ picks up crosstalk from the other $N-1$; the signal stays 1 while interference accumulates, so the interference-to-signal ratio grows with $N$.
- 由此定义容量:干扰涨到和信号同量级时,这个存储还能记住多少条。帖子沿这条路推导「最优线性记忆」(不是随便的外积,而是解一个线性方程组把干扰压掉),再到 MLP 为什么是非线性记忆、再到 self-attention 恰好是一个「非参数化」的记忆库——参数存在 KV 缓存里,不在权重里。That defines capacity: how many memories before interference matches signal. The post walks from there to the optimal linear memory (not a naive outer product but solving a linear system that cancels interference), to why MLPs are nonlinear memory stores, and finally to self-attention as a non-parametric memory — the data lives in the KV cache, not the weights.
- 长上下文的意义被这个视角重新讲了一遍:上下文变长不是「视野」问题,而是干扰管理问题——为什么 KV 缓存要占那么多内存、为什么各种稀疏注意力都是在换一种「压干扰」的方式。Long context gets re-explained through this lens: it's not a field-of-view problem, it's an interference-management problem — which is why KV caches eat RAM and why sparse-attention schemes are all ways of squeezing interference differently.
- 带走的一课:读懂一个架构,可以先问它把什么当存储、用什么当召回、干扰怎么算。这比背「attention 是 QK^T V」更能解释工程现象。Takeaway: to understand an architecture, ask what it treats as store, what it treats as retrieval, and where interference is computed. It explains engineering symptoms better than reciting 'attention is QK^T V'.
数学之美Mathematical Beauty
- 把一千年前的维京棋彻底解开:2^41 个局面怎么编号、怎么压缩、怎么传播Fully Solving a Viking Board Game: Numbering, Compressing and Propagating 2^41 Positions
- 题目:狐狸游戏(ala'taflo/halatafl),古诺斯棋类——20 只羊要把其中一部分赶出围栏到对面,2 只狐狸吃羊。家族共识是「狐狸很容易赢」。作者看到别人写的启发式 AI 后手痒:用完美博弈把答案钉死。The puzzle: the Fox Game, a Norse tafl variant — 20 sheep try to shepherd some of themselves out of a pen while 2 foxes eat them. His family's consensus was 'foxes win easily.' After reading someone's heuristic AI, Steinar Gunderson set out to settle it with perfect play.
- 结果先行:完美博弈下羊赢;减到 19 只羊也赢,羊先走 18 只也赢;只剩 9 只(狐狸不能秒杀的下限)羊能守和;单边只剩 1 只狐狸时 11 只羊就必胜。赢面为什么在「和」附近这么宽?一只狐狸可以死守终点格,赶不走。Results first: sheep win with perfect play — still win with 19 sheep, and with 18 if they move first. With only 9 sheep they can force a draw from the start; against a single fox, 11 sheep already force a win. Why so much slack near a draw? A lone fox can camp on the final square, and it's brutal to dislodge it.
- 怎么存:棋盘 33 格,局面两个 64 位位图(羊、狐狸)加一个行棋方比特。总共约 2^41 个局面,每个局面记胜负和三个状态+一个内部状态,正好 2 bit。要密不漏不重的编号,他用了组合数系(combinatorial number system)——「33 格放 k 枚棋子」的组合序号天然是双射,还写了快速 rank/unrank。Storage: 33 squares, two 64-bit bitboards (sheep, foxes) plus a spare bit for side-to-move. About 2^41 positions, each needing win/draw/loss plus an internal fourth state — exactly 2 bits. For a collision-free, hole-free index he used the combinatorial number system: 'k pieces on 33 squares' enumerates combinations in bijection, with fast rank/unranking.
- 怎么省:左右镜像对称——每个局面按原样和镜像各算一次编号、取小的当 canonical,直接砍一半搜索量;按「羊数+狐数」分块存储让相邻局面物理相邻,一个 329GB 的表全部 mmap,让内核管分页(作者自评:mmap 几乎从来不是正确答案,但这次够用)。对称计数「用 Burnside 引理一句话就能算完」。Compression: the board is left-right symmetric, so he ranks every position normally and mirrored and keeps the smaller key as canonical — halving the search. Grouping the table by (sheep count, fox count) makes neighbors physically adjacent, so a 329GB table runs entirely over mmap and the kernel handles paging ('mmap is almost never the right answer, but...'). Counting positions up to symmetry, he notes, 'immediately falls to Burnside's lemma.'
- 怎么算:DFS 递归缓存是灾难(爆栈、循环判定出错),换成「逐轮传播」:先标出一步能赢的局面,然后「能一步走到必胜局面→我必胜」「只能走到必败局面→我必败」反复扫 40–80 遍到不动点。每轮之间没有依赖,64 核随便并行、连锁都不用。他明说正统做法是 retrograde analysis(按反向走法传播),能再快约十倍,但一次全量只要 36 小时,就没做。Search: recursive DFS was a disaster (8GB of stack wasn't enough; loops misjudged). Instead he propagates one step at a time: mark positions that win immediately, then 'can move to a known win → you win' and 'only moves to known losses → you lose,' sweeping 40–80 passes per chunk until a fixed point — trivially parallel over 64 cores with no locks. He's candid that proper retrograde analysis (propagating over reverse moves) would be ~10x faster; the full run took 36 hours, so he left it.
- 点积为什么天然是个分类器:从投影到间隔再到换内积Why the Dot Product Is a Classifier Anyway: From Projection to Margin to Swapping the Inner Product
- 起点是个中学公式:$\langle x,y angle = x_1y_1+\dots+x_ny_n$,加一个几何身份 $\langle x,y angle = \|x\|\|y\|\cos heta$。Kun 问:这个「乘以再相加」为什么在机器学习里无处不在?Start at a schoolbook formula: $\langle x,y angle = x_1y_1+\dots+x_ny_n$, plus its geometric identity $\langle x,y angle = \|x\|\|y\|\cos heta$. Kun asks why this 'multiply and add' shows up everywhere in machine learning.
- 第一步翻译:$\langle x, w angle$ 是 $x$ 在 $w$ 方向投影的长度乘上 $\|w\|$。符号只看 $\cos heta$——$w\cdot x$ 的正负就是在问「$x$ 和 $w$ 的夹角是不是锐角」,一条过原点、垂直于 $w$ 的超平面把空间切成两半。这就是线性分类器:判据不是玄学,就是角度。First translation: $\langle x,w angle$ is the projection of $x$ onto $w$ scaled by $\|w\|$. Its sign depends only on $\cos heta$ — asking 'is the angle between x and w acute?' That carves space with a hyperplane through the origin perpendicular to $w$. A linear classifier is just angle bookkeeping, not magic.
- 第二步补角度量:光分开两类不够,还要「分得结实」。他推了那个经典结果——点到超平面的距离正比于 $|\langle x,w angle|/\|w\|$,证明就是拆一个平行分量一个垂直分量、按 $ heta=0,180$ 分情况,二十行。最大化最小距离,就是 SVM 的全部野心。Then add distance: separating two classes isn't enough, you want to separate them *firmly*. He proves the classical fact that distance to the hyperplane scales as $|\langle x,w angle|/\|w\|$ by splitting a vector into parallel and perpendicular pieces, with a small case analysis at θ = 0 and 180°. Maximizing the minimum such distance is the entire ambition of the SVM.
- 第三步换内积:既然整套几何只依赖 $\langle\cdot,\cdot angle$ 满足的那几条公理(对称、线性、正定),那你可以换一个内积定义——特征不同、几何跟着换,「核」的思想就是在这里埋下的。Then swap the inner product: since all that geometry uses only the axioms (symmetry, linearity, positivity), you're free to define a different inner product — change the features, the geometry follows. That's the seed of the kernel trick.
- 带走的一课:看懂一个公式最好的方式是问它「定义了什么样的几何」。点积的定义式只是一行求和,它派生出的角度、投影、距离、分类器却是整个线性模型的骨架。Takeaway: the best way to understand a formula is to ask what geometry it defines. One line of summation hides the angle, projection, and distance notions that form the skeleton of every linear model.
- 1973 年的一个算法:所有全局优化都只是「在一个半格上做不动点迭代」A 1973 Algorithm: Every Global Optimization Is Just Fixed-Point Iteration on a Semilattice
- 作者找了份兼职写 Lisp 编译器(SICL/Cleavir),顺便把编译原理史里最「大一统」的一篇论文实现了一遍:G. A. Kildall 1973 年《A Unified Approach to Global Program Optimization》——标题听着浮夸,内容其实准确。The author took a part-time job writing a Lisp compiler (SICL's Cleavir) and, along the way, implemented the most 'grand unified' paper in compiler history: G. A. Kildall's 1973 'A Unified Approach to Global Program Optimization' — a title that sounds grandiose but, he says, is actually accurate.
- 背景机器:把编译后的程序看成「指令节点的控制流图」(HIR/MIR),优化信息就是往每个节点上贴标签。问题:数据流分析、常量传播、逃逸分析……每种都要重新写一遍迭代逻辑?The machine underneath: treat compiled code as a control-flow graph of instruction nodes; an analysis is just a label stuck on each node. The problem: dataflow, constant propagation, escape analysis — does each one rewrite the same iteration logic from scratch?
- Kildall 的答案:只要你分析的「信息域」构成一个有界 meet-半格(任意两个信息有「最保守的公共下界」),同一个 worklist 算法通吃——从工作集取一个(指令,信息)对,和字典里已有的信息取 meet,变「好」就重新贴标签并把下游指令连同新信息放回工作集。循环终止靠半格的有限下降性;结果对任意满足条件的「转移函数」都收敛到安全的最优解。Kildall's answer: as long as your information domain forms a bounded meet-semilattice (any two facts have a most-conservative common lower bound), one worklist algorithm serves them all — pull an (instruction, pool) pair off the workset, meet it with what's in the dictionary, and if it improves, relabel and push successors with the new information. Termination comes from finite descent in the lattice; the result is a safe fixpoint for any admissible transfer function.
- 实例走一遍:逃逸分析。信息=「哪些变量会逃出函数」(ret 算逃逸,加法不算);闭包 getx/setx 从未逃出,于是可以不进堆、按栈纪律分配——解释器永远看不到这点,编译器应该看到。作者把 kildall 函数写成接「specialization」参数的一般形式,换分析只换参数。Worked example: escape analysis. Information = 'which variables escape the function' (returning escapes; adding doesn't). The closures getx/setx never escape, so they can be stack-allocated instead of heap-allocated — an interpreter can't see this, a compiler should. The author wrote `kildall` to take a domain-specific 'specialization' argument, so a new analysis means new parameters, not a new algorithm.
- 带走的一课:这是「抽象代数当工程设计」的活标本——把 N 个算法压缩成 1 个不动点机器,代价只是先证明你的信息域是个半格。读优化器源码时,认出这个形状,就读懂了一半。Takeaway: abstract algebra as engineering design — compress N algorithms into one fixpoint machine, and the only price is proving your domain is a semilattice. Once you recognize the shape inside any optimizer, half of it reads itself.
程序员随想Programmer Reflections
- 「本质复杂度」是一个没法测量的安慰剂'Essential Complexity' Is an Unmeasurable Placebo
- 靶子:Brooks 1986《没有银弹》。论证:软件复杂度分「本质」(概念本身)与「意外」(表达手段);意外那部分再优化也有 Amdahl 上限;Brooks 押注本质至少占一半,所以一切工具进步的总上限是 2 倍。这句话统治了关于生产力的对话四十年。The target: Brooks's 1986 'No Silver Bullet'. The argument: complexity splits into essential (the concept itself) and accidental (how we express it); polishing the accidental part hits an Amdahl-style ceiling; Brooks bets essential is at least half, so all technological progress combined caps out at 2x. That sentence has steered productivity discourse for forty years.
- Dan Luu 的第一击:这个上限要在 1986 年就算出来,你得先能测「本质/意外」的占比——而文中引的实证工作显示,同一个缺陷,换一个任务定义就可能从「本质」挪到「意外」。两个成分之间没有可操作的测量程序,那个「至少一半」就不是估计,是表态。Luu's first strike: to compute that bound in 1986 you'd first have to measure the essential/accidental ratio — and the empirical work he cites shows a defect can migrate between the two buckets just by re-specifying the task. With no measurement procedure for the split, 'at least half' isn't an estimate; it's a mood.
- 第二击:「任务」本身是可拆解的。1986 年看起来「概念上无解」的很多问题(跨机器协作、内存管理、构建可复现),后来是被重新定义任务解决的——把「写程序」拆成「写约束+生成+验证」,Amdahl 的分母自己变了。用固定任务边界推出的上限,对能重画边界的行业不成立。Second strike: tasks aren't atomic. Problems that looked conceptually hard in 1986 (cross-machine collaboration, memory management, reproducible builds) were later attacked by re-specifying the task — splitting 'write a program' into 'write constraints, generate, verify.' When the denominator's boundary moves, an Amdahl argument derived at the old boundary doesn't bind.
- 第三击:拿历史对账。如果上限真是 2 倍,那四十年来编译器、类型系统、包管理、云基础设施的累积改进应该在个位数百分比到 2 倍之间——实际改进大到没人敢这么汇报,因为它们大多被「任务膨胀」吃掉了,而任务膨胀本身就说明旧边界是任意的。Third strike: check against history. If the cap were truly 2x, four decades of compilers, type systems, package managers, and cloud infrastructure would add up to modest gains nobody would need an essay to dispute. Much of the improvement went into 'task sprawl' — and the sprawl itself shows the old task boundary was arbitrary.
- 带走的一课:下次有人引用「软件复杂度一半是本质、所以工具只能帮你 2 倍」来给新技术泼冷水,你至少可以指出:这是个不可测量的划分,一个「听起来像物理定律的修辞」。真正可讨论的是:这个具体任务里,哪一部分复杂度是哪些历史决定造成的——而历史决定可以被重新决定。Takeaway: next time someone invokes 'half of complexity is essential, so tooling can at most double you' to cold-water a new technique, you can point out that it's an unmeasurable distinction dressed as a law of physics. What's actually discussable is: in this task, which parts of the complexity trace back to contingent historical decisions — and those can be re-decided.
- 为了验证「promise 是不是铁轨铺的」,他修了一个 WebKit bugTo Find Out Whether Promises Are Made of Train Tracks, He Fixed a WebKit Bug
- 一个七月份之前「永远不会跑完」的九行程序:`Promise.resolve(1)` 之后,把它的 `constructor` 换成一个 `Symbol.species` getter 会抛异常的对象,然后 `await`。规范说 species 钩子在 Promise.resolve 路径上会被调用,getter 抛出就该把异常传给 await——Node 如实崩溃;Safari 26 和 Bun 打印 before、报个错,然后永远挂起。A nine-line program that, until July this year, never finished: take `Promise.resolve(1)`, replace its `constructor` with an object whose `Symbol.species` getter throws, then `await` it. The spec says the species hook is consulted on the Promise.resolve path, so the thrown error should surface at the await — Node crashes as specified, but Safari 26 and Bun print 'before', report the error, then hang forever.
- 为什么会「永远挂起」:promise 本质是一条条轨道(thenable 链)。`Promise.resolve(x)` 会检查 x 是否「看起来像自己人」(`constructor === Promise`),是就直接返回;不像就走 thenable 流程,其间按规范要查 species 决定用哪个构造函数造新 promise。JSC 的实现里,species 抛异常的那条支路没人接手:既没 fulfill 也没 reject,中间 promise 停在 pending——await 的「铁轨」断在半空,程序就等在那儿。Why 'forever': promises are laid as tracks (thenable chains). `Promise.resolve(x)` checks whether x looks like its own kind (`constructor === Promise`) and returns it directly if so; otherwise it follows the thenable protocol, consulting species to pick a constructor for the new promise. In JavaScriptCore, the branch where species *throws* was never wired up: the middle promise is neither fulfilled nor rejected — pending forever — so the await sits on a track that ends in mid-air.
- 作者的排查不是停在「知道怎么回事」,而是真的去改 JavaScriptCore(Safari/Bun 共用引擎),提了 WebKit PR #68749:+16 行,把抛出的异常接回 rejection 轨道上。挂死的程序恢复成崩溃的程序——错误但正确。The author didn't stop at understanding. He patched JavaScriptCore (the engine Safari and Bun share) — WebKit PR #68749, a 16-line fix routing the thrown exception onto the rejection track. The hanging program became a crashing program: wrong, but correct in the way you can observe.
- 顺带把一套容易口糊的概念钉牢:thenable vs promise、species 这只「钩子」在哪些 API 路径上被调用、为什么 await 也走 promise 轨道。全程用一个「不该存在的程序」当探针。Along the way the piece nails concepts people fumble: thenable vs promise, exactly which API paths consult species, and why `await` rides promise tracks too — with one 'program that shouldn't exist' as the probe.
- 带走的一课:读 spec 的冷门条款最好的办法是造一个专门踩中它的程序;引擎里没人测过的支路就是 bug 的栖息地。而且「崩溃」和「挂起」的区别值得较真——可观测的失败永远好于无声的等待。Takeaway: to test an obscure corner of a spec, build a program that lands on it on purpose; untested branches in engines are where bugs live. And 'crash' versus 'hang' is worth caring about — an observable failure beats a silent wait.
哲学与生活Philosophy and Life
- 弗兰克尔的 180 度翻转:不是你问人生有何意义,是人生在问你Frankl's 180-Degree Turn: Life Isn't Asking You a Question — It's Asking You One
- 开场并置:加缪 1942 年写「判断值不值得活是唯一严肃的哲学问题」;同一年,37 岁的神经科医生弗兰克尔被送进奥斯维辛,全家被夺走了「自己回答这个问题」的权利。他活下来十一个月后,在维也纳做了一场找回来的讲座,主题既不是乐观也不是悲观。The opening juxtaposition: Camus wrote in 1942 that judging whether life is worth living is philosophy's only serious question; that same year Viktor Frankl, a 37-year-old Viennese neurologist, was taken to Auschwitz, among millions stripped of the right to answer the question for themselves. Eleven months after surviving, he gave recovered lectures in Vienna — on moving beyond both optimism and pessimism.
- 第一步拆「享乐记账法」:如果生命的意义=快乐总量,那死亡(终结一切快乐)就宣告人生整体无意义。弗兰克尔反手推出一个漂亮结论:既然快乐本身给不了意义,缺乏快乐也夺不走意义——「快乐能否给存在赋值」和「痛苦能否从存在扣值」是同一个式子的两面。Step one dismantles hedonic bookkeeping: if life's meaning were its sum of pleasure, death — which ends all pleasure — would declare the whole thing meaningless. Frankl's counter-move is neat: since pleasure itself cannot give existence meaning, the *lack* of pleasure cannot take meaning away either. The two claims are two faces of one equation.
- 第二步借泰戈尔的四行诗落地:「我睡去,梦见生命是欢乐。醒来,看见生命是 duty。劳作——且看,duty 即是欢乐。」快乐不该、不能、永远不会是目标,只能是副产品——它只会在你把任务完成时「从背后落到腿上」。Step two lands it via Tagore's four lines: 'I slept and dreamt that life was joy. I awoke and saw that life was duty. I worked — and behold, duty was joy.' Happiness must not and cannot be a goal — it can only be an outcome, 'arising spontaneously, like luck that falls into your lap but can never be hunted down.'
- 第三步是题目说的 180 度大翻转:提问权根本不在你手里。不是「我能从人生期待什么」,而是「人生对我有什么期待」——living itself means being questioned, 每一小时生活都在问你一道只有你能答的题,你的回答不是话,是行动与担责。Step three is the 180-degree turn: the right to pose the question was never yours. Not 'what can I expect from life?' but 'what does life expect of me?' — living itself means being questioned; every hour, life asks a question only you can answer, and the answer is not talk but deed and responsibility.
- 带走的一课:这套论证不需要信仰任何宗教、也没用到幸存者的英雄叙事。它是一次干净的逻辑操作:先证明「快乐当目标」必然落空(目标是瞄准得来的,快乐不是),再把意义的载体从「我期待」换成「我被期待」。对普通人的一天来说,差别是:先问「今天这道题里,哪一件是等着我做的」。Takeaway: the argument needs no religion and doesn't lean on survivor heroics. It's a clean logical move: first show 'happiness as goal' must fail (goals are attained by aiming; happiness isn't), then switch the carrier of meaning from expecting to being-expected. For an ordinary day, the difference is small and huge: ask first 'of today's questions, which task is the one waiting on me.'
工具角Tools Corner
- tokmeter:不交 API key,把 24 款编码 Agent 的本地日志汇成一本账tokmeter: One Ledger over 24 Coding Agents, Built from the Session Logs They Already Write
- 适合哪个活:同时跑 Claude Code、Codex、Gemini CLI、Cursor 等一堆 agent 时,「这个月到底花在哪、哪个项目烧 token 最快」没有统一答案——各家要么要 API key 要么要装 telemetry。Which job: you run Claude Code, Codex, Gemini CLI, Cursor and friends side by side, and nobody answers 'where did this month's spend actually go.' Existing dashboards want API keys or install telemetry.
- 核心思路:agent 本来就把会话日志写到本地磁盘(JSONL/会话文件),tokmeter 只读这些已有文件,解析成按项目/模型/供应商/日期聚合的 token 与成本总账。无 API key、无遥测、不出机器。The idea: agents already write session logs to disk. tokmeter just parses those existing files into one ledger of token and cost totals by project, model, provider, and day — across 24 agents, no API keys, no telemetry, nothing leaves the machine.
- 上手:TypeScript/Bun 工程,仓库自带 llms-install.md 一行安装说明;本地跑即可,不需要常驻服务。Getting started: a TypeScript/Bun project with an llms-install.md; runs locally with no resident service.
- 限制:靠「各家日志的既有格式」吃饭,agent 版本升级改了格式就可能解析失败,需要跟 release notes;成本按内置价格表折算,供应商改价时账面会滞后。326 次提交、文档齐全,维护活跃。Limits: it lives on whatever format each agent logs today, so an agent upgrade that changes log format can break parsing until the tool catches up; costs are computed from an embedded price table that may lag vendor repricing. Actively maintained (326 commits).
- GateGraph:给编码 Agent 的「完工」装一道证据门,每次通过都留哈希链GateGraph: An Evidence Gate for When an AI Agent's Work Counts as Done
- 解决的真问题:agent 自己宣布「做完了」,这个结论建立在模型对自身工作的判断上——而它的审查者往往也是模型,形成自证。The real problem: when an agent marks its own work done, the claim rests on the model's judgment of itself — and the reviewer is often a model too, closing the self-certification loop.
- 机制:你在一个 adapter 文件里声明 gate 和每个 gate 背后的确定性检查(测试、类型检查、脚本);agent 随便写,但 gate 只在检查通过时才开,开一次就封进一条哈希链接记录;事后改动被认证的文件,对应 gate 自动变 stale。判断从模型移到机器可验的证据。Mechanism: you declare gates and their deterministic checks (tests, typechecks, scripts) in one adapter file. The agent writes freely, but a gate opens only when its checks pass, each opening is sealed into a hash-linked record anyone can verify later, and editing a certified file makes its gate stale again. Judgment moves from the model to machine-verifiable evidence.
- 证据:README 给出预注册的 A/B 测试——同一模型,加 gate+修复循环后通过率从 21/100 升到 67/100。数字来自项目自己的一手文档,读者按自家检查重跑为宜。Evidence: the README cites a pre-registered A/B test — same model, gates plus a repair loop raised the pass rate from 21 to 67 out of 100. It's the project's own first-party number; re-run it against your checks before trusting it for your stack.
- 代价与限制:建在 LangGraph 上,对一个「门禁」来说依赖不算轻;仓库还非常新(提交数只有个位数),成熟度、接口稳定性都是未知数。适合把它当实验框架,先在小项目里接一两个 gate。Costs and limits: it's built on LangGraph, a heavy dependency for a gate; the repo is brand-new (single-digit commits), so interface stability is unknown. Use it as an experiment framework — wire one or two gates on a small project first.
- WRouter:一台机器上的 AI 网关,把 Claude Code/Codex/OpenCode 的请求统一路由并留本地用量账WRouter: A Local AI Gateway Putting Routing, Failover and Usage Analytics in Front of Your Coding Clients
- 适合哪个活:手里同时有 Anthropic/OpenAI/本地模型的多个 key 与端点,Claude Code、Codex、OpenCode 各配各的——换供应商要改一堆客户端配置,用量也散在各处。Which job: you hold several keys/endpoints across Anthropic, OpenAI, local models, with Claude Code, Codex and OpenCode each configured separately — switching providers means touching every client, and usage data lives nowhere.
- 定位:本机起一个网关端点,所有编码客户端指到它;网关做统一路由、供应商故障转移(failover)、用量分析,README 强调「数据全留在你自己的机器上」。对多供应商切换频繁的独立开发者,把「改配置」降成「改路由表」。Positioning: run one local gateway that all coding clients point at. It does unified routing, provider failover, and usage analytics, with the README's promise that every byte stays on your machine. For a solo dev who rotates providers, 'reconfigure everything' drops to 'edit one routing table.'
- 上手与形态:带桌面端/前端/后端的 monorepo,有 Quick Start 与文档目录,中英双语 README;打包目录说明提供分发件。Shape: a frontend/backend/desktop monorepo with a Quick Start, docs, and packaging; bilingual README.
- 限制要盯住:项目极新(4 次提交),故障转移与计费分析的成熟度未经时间检验;「数据不出机器」的承诺值得自己验证(监听地址、日志落盘位置);相比 curl 级别的裸代理,它是全家桶,维护负担按全家桶计。Watch the fine print: it's extremely young (4 commits), so failover and analytics maturity are unproven; the 'data never leaves' claim deserves a check of bind addresses and log locations; and compared to a curl-level bare proxy this is a full suite — maintenance is priced like a full suite.