> ## Content Index
> Fetch the complete content index at: https://www.hubwiz.com/blog/llms.txt
> Use this file to discover other available public pages before exploring further.

# RSI 优化程序能快多少：平均 3.1 倍，合成涨 15% 只兑现 4.6%
- URL: https://www.hubwiz.com/blog/ai-code-optimization-hill-climb-milliseconds/
- Published: 2026-11-20T07:46:37.000Z
- Updated: 2026-11-20T08:22:58.000Z
- Description: RSI 落到真程序上：13 个指标平均快 3.1 倍，另一家只拿到 4.6%。差的不是模型，是尺子。
- Author: admin
- Tags: 递归自我改进, RSI, AI 编程, 性能优化, 基准测试, 代码质量

两周，一个 Slack 频道，13 个指标，几何平均 3.1 倍。claude.ai 网页的首次可输入从 3,085 ms 降到 550 ms（5.6×），Claude Code 桌面端"发一条消息"从 250 ms 降到 52 ms（4.8×），Cowork 云会话的同一项从 928 ms 降到 48 ms（19×）。

同一时期，JetBrains 用 Google DeepMind 的 AlphaEvolve 去改索引里的一棵 B 树。合成基准上，多数跑了 50 轮以上迭代的会话把性能分数推高 15–20%；送进真实 IDE 的 5 个候选里只有 2 个统计显著，最好的那个把 Kotlin Spring Petclinic 的端到端索引从 17.4 ± 0.5 秒改到 16.6 ± 0.2 秒——**4.6%**。

两个数字放在一起才是这篇文章要说的事：让 AI 把代码改快不难，难的是确认你量出来的那个"快"，就是用户感受到的那个"快"。

这也是 RSI（递归自我改进）少见的落地形态。它不是模型改自己的权重，而是把"改—测—留"的循环套在被优化的那段代码上：改的是索引实现、输入框渲染、流式输出，留下的是能被 CI 单向锁死的门槛。站内[第 157 篇](https://www.hubwiz.com/blog/how-close-recursive-self-improvement-evidence/)算的是 RSI 还有多远，[第 158 篇](https://www.hubwiz.com/blog/rsi-tax-self-improvement-token-cost/)算的是它的 token 账单，这篇算的是它在毫秒上的账。

## 先把尺子造出来，再谈优化

claude.dev 那篇复盘里最关键的句不是速度，是方法论：**墙钟时间用户能感觉到，但它太吵。**毫秒级波动进不了 CI 门槛——今天设 550 ms，明天跑一次 590 ms，天知道是回归还是抖动。

所以他们先问：不测墙钟，测什么？

纯 JS 热路径用 Valgrind 跑 `node --predictable` 数**指令条数**，跟签入仓库的基线比，一次运行就够。浏览器路径没有指令计数，但有一串同样确定性的替代品：每次交互的 React commit 数、V8 精确覆盖率的函数调用次数、样式重算与布局次数、DOM 变更次数。十一分钟后，五个线程同时跑这五种指标。

这里有个容易被忽略的门槛：**每个新 benchmark 必须干两件事**——它是 Claude 在实验室里推得动的数字，也是 CI 里只能往下降的棘轮。抖动大的、或者跟用户延迟其实不相关的，直接删掉，"不然就是让 Claude 去爬错的山"。

删之前得先证明：请在每一个指标上证明，把指标压下去能换来可测量的墙钟收益；证明不了的 bench 一律下线。

## 让 AI 自己证明尺子没撒谎

两条热路径接了这个活。第一条是拼装对话消息树的例行逻辑：Valgrind 跑完，Claude 发现四分之一的指令花在**多态字典查找**上——同一个消息 ID 被解析了三次。第二条是扫 Claude Code 输出状态行的扫描器，在正则前加一个"看首字符"的廉价判断就绕开了大部分。

| 热路径                   | 指令数  | 墙钟   | 折算   |
| --------------------- | ---- | ---- | ---- |
| 消息树组装（同一 ID 解析一次而非三次） | −48% | −78% | 4.6× |
| 状态行扫描（正则前加首字符判断）      | −31% | −44% | 1.8× |

指令数用 Valgrind + `node --predictable` 量，墙钟在同一个 benchmark 上用普通 node 跑、JIT 已预热。一小时后两条路径都改完，签入两个棘轮：任何 PR 抬高这两条路径的指令数，CI 就红；另有一个每日任务，在计数下降时把门槛同步调低。

这才是整个冲刺的核心发现——**只要有个数字可以打，Claude 就能开始优化**。以前测量是第零步：加指标、等数据、再理解问题；现在是爬山的第一步。于是杠杆最高的事变成"找更多能测的东西"。

## 循环长什么样

整套东西跑在同一个 Slack 频道里，人跟 Claude 在每条线程里混着干。循环固定六步：

| 步骤            | 谁做     | 做什么                    |
| ------------- | ------ | ---------------------- |
| 1 开线程         | 人      | 贴一段慢的地方，通常带截图或录屏       |
| 2 建 benchmark | Claude | 追调用链，在实验室复现并造出能证明问题的尺子 |
| 3 提 PR        | Claude | 按风险拆成几个，用户可见的改动挂在开关后面  |
| 4 发布          | Claude | 盯着部署，读真实用户的现场数据        |
| 5 收口          | Claude | 变快了就把门槛下调锁死；没变快就关开关重来  |
| 6 找下一个        | Claude | 在同一条用户旅程里找下一处慢点        |

一个例子能说明第 2 步值多少钱。有人贴录屏：侧边栏的行在页面加载完之后才一个个冒出来。所有现成监控都没抓到——最接近的是累积布局偏移（CLS），但每次只有 0.008 分，远在 0.1 的"良好"阈值内。于是直接去用底层的 Layout Instability API：Claude 造了遥测事件，把每个 layout-shift 的来源映射到具名区域（侧边栏、对话流）和阶段（首屏前、可输入后），再写一个集成测试——打开带满数据的页面、把侧边栏数据压到首屏之后才给、任何具名区域位移就失败。这个测试在 main 上 20 次跑 20 次红，在那个 PR 上 20 次跑 20 次绿。上线后读现场数据：**31% 的网页加载在页面已经可用之后还发生了位移**，且全部与用户交互无关。

## 150 条线程，忙的那天落了 200 个改动

单线程跑通之后，扩起来只是多开几个线程。冲刺期间同时跑 150 条以上，一条线程能提五十到上百个优化 PR；最忙的一天落了 200 多个改动；约三分之一的 PR 顺手补了遥测或护栏，而每补一个仪表又长出更多线程。

有意思的是这些仪表量出了什么：

- 给输入框路径做 React hook 普查：**6,900 个 hook、900 个 store 订阅**，每敲一个键全量重渲染。
- 数样式重算：单个 `:root:has()` 选择器给每次 DOM 变更加了 **24 毫秒**。
- 追首屏之后的代码路径：一个遗留的 `location.reload()` 每天造成 **50 万次**隐藏刷新，所有加载指标都看不见。
- 读空闲标签页的 profiler 采样：同样的缓存快照每分钟被复制进 IndexedDB 两次，全在主线程。

最漂亮的坑来自无关的普查：高亮一个已完成的代码块能把页面冻住约一秒。罪魁是**破折号**——只要回复的 markdown 里出现非 Latin-1 字符（长破折号、弯引号），V8 就把整个字符串存成 UTF-16，所有语法高亮的正则都掉进两字节慢路径。修法是二十来行：高亮前把代码块复制成单字节字符串。

| 指标                         | 修前     | 修后     |
| -------------------------- | ------ | ------ |
| 页面第一个 TypeScript 代码块，主线程阻塞 | 1.0 s  | 0.35 s |
| 同一块之后每次重跑                  | 100 ms | 40 ms  |

4 vCPU 容器、headless Chrome、不做 CPU 限速、每个值跑 2–3 次。

## 护栏：宁可慢一点，也别把用户弄坏

要碰的全是热路径（首屏、输入框、对话流），所以安全机制提前摆好：每个 PR 走自动评审 + 至少一个真人批准；优化必须排在有单元测试之后；任何可能影响用户感知的改动都挂在短命开关后面。开关一度堆到近两百个，于是又开一条线程专管：Claude 把每个分成"急停"和"放量"两类，两周结束时一半以上已清干净。

真正的成本在性能收益的**自然衰减**上：代码库动得快，今天省下的毫秒下周就还回去。静态输入框是个典型——它故意做得很脆，几乎立刻给用户一份 HTML 副本，再让 React 直接画在上面；渲染差一个像素，魔术就散了。为此造了几十个护栏：静态标记由真实 React 组件在 jsdom 里渲染生成，并有测试保证不漂移；14 种视口下断言静态页与 React 渲染对齐在 1 像素内；按键测试把手感交接打穿，丢键或乱序就失败；现场每次交接上报到十分之一像素，非零位移自动开线程。

实验室终究测不全。发布四小时后有人贴录屏：新标签页打开 claude.ai 时输入框往下掉 15–20 像素。Claude 的解释比"修好了"更值钱——是 Chrome 在缩页面，不是交接（当天 49 次加载，交接位移都是 0）。新标签页上 Chrome 画一条 56 px 页脚，跳转时页脚消失、页面高了 56 px，而这发生在首屏之后约 100 ms；`/new` 把输入框放在页面高度 18% 处，所以下移 0.18 × 56 ≈ 10 px，跟录屏量到的一致。刷新没有页脚可消失，所以只在"新标签页"出现；"偶尔"取决于首屏是否快过那次 resize——它需要 Chrome 在你还在打字时就预渲染。这问题一直潜伏，只是页面从没画得这么早，布局测试也看不见（headless Chrome 没有浏览器 UI 可以收回）。修完把布局在 resize 前后钉住，并补了模拟预渲染的测试。**实验室测不到的东西，只能靠真人先看到。**

## 8.33 毫秒的帧预算

有个支线把上面所有要素串起来了。为了演示流式渲染里一个正则的优化，Claude 在长回复滚动的录屏角落加了个帧率读数，由页面自己的 animation-frame 时间戳算出。

有人追问：我们是不是被 60 fps 卡住了？能不能把滚动和流的顺滑度推到 120？

Claude 的回答是：今天的机器默认 60 Hz，但可以用 DevTools 的 begin-frame 控制做确定性步进，确认后按 8.33 毫秒帧预算重跑。半小时后带回结果：120 Hz 步进可用，240 个 begin-frame 精确产生 240 帧，"这一帧有没有超预算"从统计变成了精确读数。

有了这把尺子优化才真正开始：逐帧走过一条长回复，把慢的地方标出来；把每个分块的 `O(消息长度)` 工作改成对已完成块做 memo 化；把不断变长的代码围栏的分词挪到 worker；表格改成逐格显现。一条线程落了近 60 个 PR：长回复阻塞主线程的总时长从约 750 毫秒降到约 200 毫秒，CPU 约为原来的三分之一，在 120 Hz 的 MacBook 上从头到尾守住 120 fps。那套台子后来变成每晚跑的常规任务，由 Claude 盯回归。

## 另一半真相：只有 2 个候选活下来

JetBrains 的实验是天平的另一端，也更值得抄。

目标不是玩具代码，是索引实现底下那棵 B 树——已经被优化过很多年的基础设施。工程描述被刻意写得很朴素：原算法基本就是经典 B 树，候选大多是围绕边界情况做优化的变体。选它是因为条件齐全：**有代码可改、有明确分数、有测试能拒掉坏主意。**

评测器是内部的存储层性能套件，纯合成数据，不碰真实客户项目。分数取中等规模基准里各中位数的和，单元测试充当正确性闸门。跑 50 轮以上迭代的会话，多数能把合成分数提高 15–20%。

然后他们停下来做了件很多人不做的事：把最好的候选送进完整 IDE。对象是 Kotlin Spring Petclinic，跑在改过的 IntelliJ IDEA 2026.2 nightly 上，端到端索引基线 17.4 ± 0.5 秒。5 个候选里 2 个显著，可复现地低于 16.8 秒；Solution 1 平均 16.6 ± 0.2 秒，比基线快约 0.8 秒，即约 4.6%。Solution 2 量出来 17.5 ± 0.4 秒——在这个场景里等于基线。

两个候选在合成基准上都变快了，但只有一个在用户能感知的端到端测试里变快。这个差别就是全部：

| 口径 | 结论                                   | 强度              |
| -- | ------------------------------------ | --------------- |
| 合成 | 多数 50+ 轮会话把分数推高 15–20%               | 最强——基准本身就是优化目标  |
| 集成 | 5 个候选 2 个显著，最好 17.4 → 16.6 秒（约 4.6%） | 中等——只在单场景、单项目成立 |
| 产品 | 看 megaAPDEX 等用户侧索引满意度信号              | 还没做             |

JetBrains 的工程总监 Dmitrii Batkovich 说得很克制：AlphaEvolve 没有"神奇地"让索引变快，它做的是在一处人工探索很慢的空间里帮着生成并排序低层优化想法；问题、测试、测量纪律和判断都是工程团队给的，被缩小的是搜索空间。

## 人还在做什么

**让 AI 更敢下手。**默认状态下 Claude 很谨慎：把发现记成工单、对可行性打折扣、估计往宽里报。护栏到位后，团队做的大量工作是鼓励它更大胆——有人直接说"我们有能力做任何事，请更勇敢一点"，一小时内 PR 就上来了。

**品味。**每条线程都有具名的人类负责人，任何用户能感知的改动都由 Claude 附前后截图或录屏，等人裁决：表格逐格填充还是整行到位？骨架屏立刻出现还是半秒后？流式文本逐字淡入值不值五分之一帧预算？

**方向。**每条线程刻意收窄，只盯一个 benchmark 或一段旅程。150 条线程像 150 把锤子找钉子，人的决策主要是排序与用户影响：先做哪个面、哪些线程在互相踩、哪条收益已递减该关掉。有个 900 行的 PR 只收到一行回复：为每次发送省 2 毫秒去维护一个构建插件，不值。

## 我们的整理

两个案例共享同一套骨架，抽出来是四条判据：

1. **先问"这个数字会不会抖"。**抖的指标进不了 CI，只能当观察。指令数、调用数、React commit、DOM 变更之所以好用，是因为同一次运行结果相同；P95、均值、墙钟天生带噪声，适合验收，不适合做门槛。
2. **尺子本身要先被验证。**压指标必须换来真实延迟，否则就是在爬错的山。claude.dev 的做法是明确要求 AI"证明爬山能换来墙钟收益，证明不了就把 bench 下线"——这一步把"优化了"变成"优化对了"。
3. **合成涨了不算数。**JetBrains 的 Solution 2 是反面教材：合成分数上去了，集成测试等于基线。只有合成结果的性能 PR，都该被当成"可能只是学会了这把尺子"。
4. **门槛只能单向。**把门槛签进 CI，并让每日任务在数字下降时下调天花板；否则三个月后回头看，收益早就还回去了。

| 指标                               | 会不会抖    | 能当 CI 门槛 | 谁能把它压下去           |
| -------------------------------- | ------- | -------- | ----------------- |
| CPU 指令数（Valgrind \--predictable） | 不抖，单次即定 | 能        | 减少重复计算、砍多态查找      |
| 函数调用次数（V8 精确覆盖率）                 | 不抖      | 能        | 缓存、提前返回           |
| React commit 数 / DOM 变更数         | 不抖      | 能        | 减少无效渲染、合并更新       |
| 样式重算与布局次数                        | 不抖      | 能        | 选择器、避免强制同步布局      |
| 帧是否落在 8.33 ms 内（确定性步进）           | 不抖      | 能        | 分块、memo、拆到 worker |
| 墙钟 P75 / P95                     | 抖       | 不能，只做验收  | 上面所有手段之和          |

三处可以当周复现的检查：拿一条热路径跑 `node --predictable` 取指令数基线，改一版看是否同向；用 DevTools begin-frame 把帧率钉到 120，验证"这一帧超没超预算"能否稳定读出；把静态渲染与真实渲染在 14 个视口上做 1 像素对齐断言。

什么时候不该这么做：一次性脚本、没有稳定负载的场景、连噪声底都量不出来的地方。这三类地方，AI 会一本正经地优化一个测不准的数字，然后把抖动当成绩报给你。

同一件事在别的层也有对应物：可维护性得先能被观测才有意义（[可维护性传感器](https://www.hubwiz.com/blog/maintainability-sensors-coding-agents/)），反馈得先进到 agent 的循环里才起作用（[自定义 linter 反馈循环](https://www.hubwiz.com/blog/custom-linter-feedback-loop-ai-agents/)），而静态检查本身到哪为止、后面接什么（[lint 不够用](https://www.hubwiz.com/blog/when-linting-is-not-enough-ai-code/)）。这次只是把同一条思路推到了毫秒级。

更多 AI 编程与工程化实践，见 [Vibe Coding 技术栈](https://www.hubwiz.com/blog/vibe-coding-stack/)。

---

**来源**

- Raymond Wang, Sam Attard, Issac G. *How we made claude.ai 3x faster in two weeks*. claude.dev，2026-09-23。https://claude.dev/blog/how-we-made-claude-ai-faster/
- Denis Shiryaev. *How We Use AlphaEvolve to Make Complex IDE Algorithms Faster*. The JetBrains Blog，2026-05-29。https://blog.jetbrains.com/ai/2026/05/how-we-use-alphaevolve-to-make-complex-ide-algorithms-faster/
- 参考：Google DeepMind *AlphaEvolve* 预览文。https://deepmind.google/discover/blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/

本文由 hubwiz 编译整理，转载请注明出处。

> **这是「AI 编程 / Vibe Coding」专题的一部分。**完整地图见：[AI 编程 / Vibe Coding 完全指南](https://www.hubwiz.com/blog/vibe-coding-stack/)

**相关阅读**

- [RSI 入门：圈两个标记，让 AI 替你迭代程序](https://www.hubwiz.com/blog/rsi-first-loop-alphaevolve-circle-packing-codelab/)