工程师还是按钮？循环工程里的终极选择
2026/6/18大约 9 分钟
要造那个循环。
但要像一个打算继续当工程师的人去造它，
而不是一个只负责按下启动键的人。
两种人，外表看一样
┌─────────────────────────────────────────────────────────┐
│ 工程师 vs 按钮：外表看一样 │
├─────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 共同点： │ │
│ │ · 都坐在循环外面 │ │
│ │ · 都让 agent 替自己干活 │ │
│ │ · 都享受着一个人干一个团队活的爽感 │ │
│ │ · 都用同一个工具 │ │
│ │ · 都按同一个按钮 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 区别： │ │
│ │ · 工程师：循环是他延伸出去的手，他始终知道手在做什么 │ │
│ │ · 按钮：按一下，等结果，结果好坏他也说不清 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘唯一的区别在于他们对自己的定位。
定位 1：工程师
循环是他延伸出去的手。
┌─────────────────────────────────────────────────────────┐
│ 工程师的视角 │
├─────────────────────────────────────────────────────────┤
│ │
│ 「这个循环是我的工具，是我能力的延伸。」 │
│ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 我知道： │ │
│ │ · 循环在做什么（逻辑） │ │
│ │ · 循环为什么这么做（原理） │ │
│ │ · 循环可能会在哪里出错（风险） │ │
│ │ · 如果出错了该怎么修（应对） │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 「我始终知道我的手在做什么。」 │
│ │
└─────────────────────────────────────────────────────────┘工程师的日常：
- 会花时间理解循环的设计
- 会定期抽查循环的输出
- 会主动思考如何改进循环
- 会保持对系统的理解
定位 2：按钮
按一下，等结果，结果好坏他也说不清。
┌─────────────────────────────────────────────────────────┐
│ 按钮的视角 │
├─────────────────────────────────────────────────────────┤
│ │
│ 「这个循环是我的替代品，它替我工作。」 │
│ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 我不知道： │ │
│ │ · 循环在做什么（太复杂了） │ │
│ │ · 循环为什么这么做（不重要） │ │
│ │ · 循环可能会在哪里出错（应该不会吧） │ │
│ │ · 如果出错了该怎么修（有人会修的） │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 「我只负责按下按钮，剩下的事情交给 AI。」 │
│ │
└─────────────────────────────────────────────────────────┘按钮的日常：
- 不会花时间理解循环的设计
- 不会抽查循环的输出
- 不会主动思考如何改进循环
- 逐渐失去对系统的理解
同一个工具，同一个按钮
循环工程给了每个人一个选择的机会。
┌─────────────────────────────────────────────────────────┐
│ 同一个工具，两种选择 │
├─────────────────────────────────────────────────────────┤
│ │
│ 工具：Triage Loop │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 五个动作： │ │
│ │ · 发现（Discover） │ │
│ │ · 交付（Handoff） │ │
│ │ · 验证（Verify） │ │
│ │ · 持久化（Persist） │ │
│ │ · 调度（Schedule） │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 选择 A：工程师 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ · 理解每个动作的设计原理 │ │
│ │ · 定期抽查循环的输出 │ │
│ │ · 主动思考改进空间 │ │
│ │ · 保持对系统的理解 │ │
│ │ → 变强 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 选择 B：按钮 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ · 不理解循环是怎么设计的 │ │
│ │ · 从不抽查循环的输出 │ │
│ │ · 不思考改进空间 │ │
│ │ · 逐渐失去对系统的理解 │ │
│ │ → 变成多余的人 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘你可以用它把自己变强，也可以用它把自己变成一个多余的人。
工具是同一个，按钮也是同一个。
区别在于你的选择。
这个选择不是一次性的
我自己的体会是，这个选择不是造循环那天一次性做完的，它每天都在重做。
┌─────────────────────────────────────────────────────────┐
│ 每日选择：工程师还是按钮？ │
├─────────────────────────────────────────────────────────┤
│ │
│ 周一早上 9:00 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ AI 提交了 5 个 PR │ │
│ │ │ │
│ │ 选择 A：花 30 分钟，仔细审查每个 PR │ │
│ │ → 你还在工程师那一边 │ │
│ │ │ │
│ │ 选择 B：看了一眼标题，直接点「合并全部」 │ │
│ │ → 你往按钮那边滑了一格 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 周二下午 3:00 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ AI 修改了核心业务逻辑 │ │
│ │ │ │
│ │ 选择 A：停下来，花 1 小时理解修改内容 │ │
│ │ → 你还在工程师那一边 │ │
│ │ │ │
│ │ 选择 B：「AI 应该是对的吧」，点「合并」 │ │
│ │ → 你往按钮那边滑了一格 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 周三晚上 8:00 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 你看到 AI 的代码，有一段不太理解 │ │
│ │ │ │
│ │ 选择 A：花 10 分钟查一下文档，弄懂它 │ │
│ │ → 你还在工程师那一边 │ │
│ │ │ │
│ │ 选择 B：「算了，应该没问题」，跳过 │ │
│ │ → 你往按钮那边滑了一格 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘你今天多读了一个 PR，多问了一句「这真的对吗」，你就还在工程师那一边。
你今天图省事，闭着眼合了，你就往按钮那边滑了一格。
没有天生的工程师
没有谁是天生的工程师，也没有谁一劳永逸地是。
┌─────────────────────────────────────────────────────────┐
│ 工程师身份的「每天续费」 │
├─────────────────────────────────────────────────────────┤
│ │
│ 身份不是一次性的证书， │
│ 它是个需要每天续费的订阅。 │
│ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 续费方式： │ │
│ │ · 每天至少认真审查 1 个 PR │ │
│ │ · 每天花 10 分钟学习 AI 修改的代码 │ │
│ │ · 每周花 1 小时思考如何改进循环 │ │
│ │ · 每次看到不懂的代码，花 5 分钟弄懂它 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 如果某天你没续费： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ → 你的工程师身份就会暂停一天 │ │
│ │ │ │
│ │ 如果你连续一个月没续费： │ │
│ │ → 你的工程师身份就会被取消 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘它是个需要每天续费的身份。
真正决定结局的
真正决定结局的，不是你造了多牛的循环，是你按下去的时候，心里还认不认自己是那个工程师。
┌─────────────────────────────────────────────────────────┐
│ 按下按钮的那一刻 │
├─────────────────────────────────────────────────────────┤
│ │
│ 情境：AI 刚刚提交了一个 PR，CI 全部通过 │
│ │
│ 内心独白 A（工程师）： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 「等等，我应该先看看它改了什么。」 │ │
│ │ 「这段逻辑真的对吗？」 │ │
│ │ 「有没有边界条件没考虑到？」 │ │
│ │ 「让我再想想...」 │ │
│ │ │ │
│ │ （花 15 分钟审查） │ │
│ │ │ │
│ │ 「嗯，看起来没问题，合并。」 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 内心独白 B（按钮）： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 「绿勾了，应该没问题。」 │ │
│ │ 「之前的都对，这次应该也对。」 │ │
│ │ 「算了，直接合并吧。」 │ │
│ │ │ │
│ │ （点「合并」，耗时 5 秒） │ │
│ │ │ │
│ │ 「搞定。」 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 同一个按钮，两种结局。 │
│ │
└─────────────────────────────────────────────────────────┘结局 A：
- 你保持了理解
- 你知道系统在做什么
- 你能快速定位问题
- 你能继续改进系统
- 你依然是工程师
结局 B：
- 你失去了理解
- 你不知道系统在做什么
- 你无法定位问题
- 你无法改进系统
- 你变成了按钮
一个具体的例子
假设你造了一个自动化的代码审查循环。
┌─────────────────────────────────────────────────────────┐
│ 代码审查循环：工程师 vs 按钮 │
├─────────────────────────────────────────────────────────┤
│ │
│ 工程师的做法： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 1. 设计循环时： │ │
│ │ · 仔细思考每个动作的逻辑 │ │
│ │ · 设计审查规则和阈值 │ │
│ │ · 预见可能的边界情况 │ │
│ │ │ │
│ │ 2. 循环运行后： │ │
│ │ · 第一周：每天抽查 3 个 PR │ │
│ │ · 第二周：每天抽查 1 个 PR │ │
│ │ · 第三周：每周抽查 5 个 PR │ │
│ │ · 持续关注审查质量指标 │ │
│ │ │ │
│ │ 3. 发现问题时： │ │
│ │ · 分析根本原因 │ │
│ │ · 调整审查规则 │ │
│ │ · 验证改进效果 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 按钮的做法： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 1. 设计循环时： │ │
│ │ · 用默认配置 │ │
│ │ · 不思考审查逻辑 │ │
│ │ · 不预见边界情况 │ │
│ │ │ │
│ │ 2. 循环运行后： │ │
│ │ · 第一周：「看起来没问题」 │ │
│ │ · 第二周：「应该还在正常工作」 │ │
│ │ · 第三周：「完全不需要管了」 │ │
│ │ · 从不查看审查质量指标 │ │
│ │ │ │
│ │ 3. 发现问题时： │ │
│ │ · 「AI 应该会自己修复」 │ │
│ │ · 「等下次循环吧」 │ │
│ │ · 「不知道怎么修」 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘三个月后：
工程师：
- 循环审查了 500 个 PR
- 你抽查了 50 个（10%）
- 发现并修复了 5 个审查规则的问题
- 循环的准确率从 85% 提升到了 95%
- 你依然掌控着循环
按钮：
- 循环审查了 500 个 PR
- 你抽查了 0 个（0%）
- 不知道有多少误判和漏判
- 不知道准确率是多少
- 循环已经掌控了你
如何保持工程师身份？
1. 每日最小续费
每天至少做一件工程师会做的事。
每日最小续费清单（5-15 分钟）：
□ 认真审查 1 个 PR
□ 学习 1 段 AI 修改的代码
□ 问自己 1 次：「这真的对吗？」
□ 花 5 分钟弄懂 1 个你不理解的逻辑
□ 查看 1 次循环的运行指标这不是负担，这是订阅费。
2. 每周深度维护
每周花 1 小时深度维护你的工程师身份。
每周深度维护清单（1 小时）：
□ 抽查 5 个 PR，验证循环的输出
□ 分析循环的运行指标，寻找改进空间
□ 阅读 AI 修改的核心代码，保持理解
□ 思考 1 个：「如果循环出错了，我该怎么修？」
□ 和团队讨论 1 次：「我们的循环还需要什么？」这是投资，不是成本。
3. 每月理解审计
每月强制自己进行一次理解审计。
每月理解审计清单（2 小时）：
□ 随机抽取 10 个 PR，重新审查
□ 回答：我能解释这段代码的逻辑吗？
□ 回答：如果出错了，我知道怎么修吗？
□ 标记所有「理解腐烂」的部分
□ 重新学习所有「理解腐烂」的部分这是体检，不是形式。
4. 保持「好奇心驱动」
好奇心是工程师最珍贵的品质。
┌─────────────────────────────────────────────────────────┐
│ 好奇心驱动 vs 惯性驱动 │
├─────────────────────────────────────────────────────────┤
│ │
│ 好奇心驱动： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 「咦，这段代码为什么这么写？」 │ │
│ │ 「让我查一下文档...」 │ │
│ │ 「哦，原来是这样！」 │ │
│ │ 「我学到了新东西。」 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 惯性驱动： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 「这段代码看起来有点复杂...」 │ │
│ │ 「算了，应该没问题。」 │ │
│ │ 「直接合并吧。」 │ │
│ │ 「我节省了 5 分钟。」 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘好奇心让你保持学习，惯性让你停止成长。
关键洞察
循环工程是一个放大器。
┌─────────────────────────────────────────────────────────┐
│ 循环工程的放大效应 │
├─────────────────────────────────────────────────────────┤
│ │
│ 如果你是工程师： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 循环 = 你的能力延伸 │ │
│ │ · 你能做 1 个人的工作 │ │
│ │ · 循环让你能做 10 个人的工作 │ │
│ │ · 你变得更强大 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 如果你是按钮： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 循环 = 你的替代品 │ │
│ │ · 你能做 1 个人的工作 │ │
│ │ · 循环替你做了 10 个人的工作 │ │
│ │ · 你变得多余 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘同一个工具，两种放大。
选择权在你手里。
你可以用它把自己变强，也可以用它把自己变成一个多余的人。
收尾金句
- 要造那个循环，但要像一个打算继续当工程师的人去造它
- 工程师：循环是他延伸出去的手，他始终知道手在做什么
- 按钮：按一下，等结果，结果好坏他也说不清
- 循环工程给了每个人一个选择的机会
- 你可以用它把自己变强，也可以用它把自己变成一个多余的人
- 工具是同一个，按钮也是同一个
- 这个选择不是造循环那天一次性做完的，它每天都在重做
- 你今天多读了一个 PR，多问了一句「这真的对吗」，你就还在工程师那一边
- 你今天图省事，闭着眼合了，你就往按钮那边滑了一格
- 没有谁是天生的工程师，也没有谁一劳永逸地是
- 它是个需要每天续费的身份
- 真正决定结局的，不是你造了多牛的循环
- 是你按下去的时候，心里还认不认自己是那个工程师
工程师还是按钮？
这是一个每天都要做的选择。
工程师 vs 按钮
循环工程里的终极选择
"