欢迎光临
我们一直在努力

从零开始学AI201——AI驾驭工程1

深度讲解:《驾驭工程:在以代理为先的世界中利用 Codex》

Ref:https://openai.com/index/harness-engineering/

一、文章背景与核心主张

1.1 这篇文章在说什么

 OpenAI 内部工程师 Ryan Lopopolo 的一篇实践报告,描述了一个极端实验:

┌─────────────────────────────────────────────────────────────────────┐
│ 核心实验 │
│ │
│ 限制条件: 不编写任何一行人工代码 │
│ 工具: Codex(OpenAI的AI编码代理)+ GPT-5 │
│ 结果: 5个月内,从空仓库到百万行代码的可用产品 │
│ 团队: 最初3人 → 后扩展到7人 │
│ 产出: ~1500个PR合并,平均每人每天3.5个PR │
│ 效率: 约为纯人工编写相同代码所需时间的 1/10 │
│ │
│ 人类角色的转变: │
│ ┌──────────────┐ ┌──────────────┐ │
│ │ 传统工程师 │ → │ 新型工程师 │ │
│ │ 写代码 │ │ 设计环境 │ │
│ │ 调试bug │ │ 明确意图 │ │
│ │ 做code review│ │ 构建反馈循环 │ │
│ │ 部署运维 │ │ 赋能AI代理 │ │
│ └──────────────┘ └──────────────┘ │
│ │
│ 一句话总结:"人类掌舵,智能体执行" │
│ (Humans steer, agents execute) │
│ │
└─────────────────────────────────────────────────────────────────────┘

1.2 为什么这篇文章重要

这不是一个玩具项目或概念验证,而是:

  • 真实产品:有数百名内部用户,包括日常使用的高级用户
  • 完整生命周期:发布、部署、出故障、修复,全流程
  • 极端约束:零人工代码——所有代码、测试、CI、文档、工具全部由 AI 生成
  • 来自 OpenAI 内部:这是 Codex 团队自己"吃自己的狗粮"

二、逐段深度解析

2.1 从空仓库开始——"创世纪"

┌─────────────────────────────────────────────────────────────────────┐
│ 项目启动过程 │
│ │
│ Day 0: 空Git仓库 │
│ │ │
│ ▼ │
│ Codex CLI + GPT-5 生成初始框架: │
│ ├── 仓库结构(目录组织) │
│ ├── CI配置(持续集成管道) │
│ ├── 格式化规则(代码风格) │
│ ├── 包管理器设置(依赖管理) │
│ ├── 应用程序框架(基础代码骨架) │
│ └── AGENTS.md(指导AI代理如何在仓库中工作的说明文件) │
│ │
│ 甚至 AGENTS.md 本身也是 Codex 写的! │
│ │
│ Day 0 → Month 5: │
│ ├── ~100万行代码 │
│ ├── ~1500个PR │
│ ├── 3→7名工程师 │
│ ├── 数百名内部用户 │
│ └── 每人每天3.5个PR(且随团队扩大而提高!) │
│ │
│ 关键洞察: │
│ 传统认知:团队变大 → 人均效率下降(Brooks定律) │
│ 这里: 团队变大 → 人均效率反而上升 │
│ 原因: 人类不再互相协调代码,而是各自指挥AI │
│ │
└─────────────────────────────────────────────────────────────────────┘

解读:这颠覆了 Brooks 定律("向一个延期的项目增加人手只会使其更加延期")。因为人类之间的协调成本消失了——每个人都是独立地与 AI 代理交互,而不是互相协调代码。

2.2 工程师角色的重新定义

文章提出了一个深刻的观察:早期进展缓慢,不是因为 AI 能力不足,而是因为"环境"没准备好。

┌─────────────────────────────────────────────────────────────────────┐
│ 工程师的新工作内容 │
│ │
│ 传统工程师的一天: │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ 09:00 拉取最新代码 │ │
│ │ 09:15 阅读需求文档 │ │
│ │ 09:30 开始编写代码 │ │
│ │ 12:00 午饭 │ │
│ │ 13:00 继续编码 + 调试 │ │
│ │ 15:00 Code Review 同事的PR │ │
│ │ 16:00 修改自己PR的review意见 │ │
│ │ 17:00 提交PR │ │
│ │ 18:00 下班 │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
│ "代理优先"工程师的一天: │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ 09:00 审查昨晚AI代理生成的PR(AI夜间工作6+小时) │ │
│ │ 09:30 发现代理在某类任务上反复失败 │ │
│ │ → 分析原因:缺少什么上下文?缺少什么工具? │ │
│ │ 10:00 编写新的提示(prompt)让AI构建缺失的工具/脚手架 │ │
│ │ 10:30 更新AGENTS.md和文档,补充AI需要的上下文 │ │
│ │ 11:00 将用户反馈转化为验收标准 │ │
│ │ 11:30 启动一批新的AI代理任务 │ │
│ │ 12:00 午饭 │ │
│ │ 13:00 设计新的代码检查规则(linter)来防止AI走偏 │ │
│ │ 14:00 构建可观测性工具让AI能"看到"系统运行状态 │ │
│ │ 15:00 审查AI生成的架构决策,确认方向正确 │ │
│ │ 16:00 编码"黄金原则"(品味/风格偏好)到自动化规则中 │ │
│ │ 17:00 启动过夜的AI任务,设定验收条件 │ │
│ │ 18:00 下班(AI继续工作到凌晨) │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
│ 核心转变: │
│ ┌───────────────────────┬──────────────────────────────────┐ │
│ │ 旧思维 │ 新思维 │ │
│ ├───────────────────────┼──────────────────────────────────┤ │
│ │ "这段代码怎么写?" │ "AI缺什么能力才能完成这个任务?" │ │
│ │ "让我修复这个bug" │ "让我给AI构建能修复bug的工具" │ │
│ │ "再努力一点就好了" │ "环境中缺少什么信息/结构?" │ │
│ │ 编写实现代码 │ 设计约束和脚手架 │ │
│ │ 手动测试 │ 构建AI可自动验证的反馈循环 │ │
│ └───────────────────────┴──────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘

关键概念——"深度优先赋能":

当AI无法完成复杂任务X时:

✗ 错误做法:反复提示"再试一次"

✓ 正确做法:
1. 将X分解为更小的构建模块 A, B, C
2. 引导AI先构建 A(基础能力)
3. 在A的基础上构建 B
4. 在A+B的基础上完成 C
5. 最终AI具备了完成X的全部能力

类比:
你不会让一个新员工在第一天就设计整个系统
你会先教他基础工具、团队规范、代码结构
然后逐步委托更复杂的任务

2.3 让应用"可被AI阅读"

这是文章中最具技术深度的部分:

┌─────────────────────────────────────────────────────────────────────┐
│ 让AI能"看到"和"理解"应用的运行状态 │
│ │
│ 问题:AI写了代码,但怎么知道代码是否正确工作? │
│ │
│ 传统方式:人类打开浏览器查看 → 人力瓶颈 │
│ 新方式: 让AI自己能"看"应用 │
│ │
│ 解决方案1:每个Git工作树独立启动应用实例 │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Codex Agent #1 ──→ git worktree A ──→ 应用实例 A (端口3001) │ │
│ │ Codex Agent #2 ──→ git worktree B ──→ 应用实例 B (端口3002) │ │
│ │ Codex Agent #3 ──→ git worktree C ──→ 应用实例 C (端口3003) │ │
│ │ │ │
│ │ 每个AI代理有自己的独立应用副本,互不干扰 │ │
│ │ 任务完成后销毁(临时环境) │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ 解决方案2:Chrome DevTools Protocol (CDP) 集成 │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Codex Agent │ │
│ │ │ │ │
│ │ ├── 打开浏览器(headless) │ │
│ │ ├── 导航到应用页面 │ │
│ │ ├── 获取 DOM 快照(理解页面结构) │ │
│ │ ├── 截屏(视觉验证) │ │
│ │ ├── 执行用户操作(点击、输入) │ │
│ │ ├── 观察运行时事件 │ │
│ │ ├── 如果有bug → 修改代码 → 重启应用 → 重新验证 │ │
│ │ └── 循环直到通过 │ │
│ │ │ │
│ │ 效果:AI可以像QA测试人员一样"看到"和"操作"应用 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ 解决方案3:完整的可观测性堆栈(对AI可见) │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 应用实例 │ │
│ │ │ │ │
│ │ ├── 日志(Logs) ──→ Vector ──→ Victoria Logs │ │
│ │ ├── 指标(Metrics)──→ Vector ──→ Victoria Metrics │ │
│ │ └── 追踪(Traces) ──→ Vector ──→ Victoria Traces │ │
│ │ │ │
│ │ Codex Agent 可以: │ │
│ │ ├── 用 LogQL 查询日志 │ │
│ │ ├── 用 PromQL 查询指标 │ │
│ │ └── 用 TraceQL 查询追踪链路 │ │
│ │ │ │
│ │ 实际提示示例: │ │
│ │ "确保服务启动在800毫秒内完成" │ │
│ │ → AI查询启动耗时指标 │ │
│ │ → 发现启动耗时1200ms │ │
│ │ → 分析代码找到瓶颈 │ │
│ │ → 优化代码 │ │
│ │ → 重启验证 │ │
│ │ → 确认降到700ms │ │
│ │ → 提交PR │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ 关键细节:AI代理经常连续运行6+小时(通常在人类睡觉时) │
│ │
└─────────────────────────────────────────────────────────────────────┘

解读:这实质上是把传统 DevOps/SRE 的"可观测性"思想延伸到了 AI 代理。以前可观测性是给人看的,现在要给 AI 看。

2.4 知识管理——"给地图,不给手册"

这是文章中最深刻的方法论之一:

┌─────────────────────────────────────────────────────────────────────┐
│ 上下文管理:最大的挑战之一 │
│ │
│ ✗ 失败方案:"一个巨大的 AGENTS.md" │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ AGENTS.md (5000行!!!) │ │
│ │ ├── 第1-200行: 代码风格规范 │ │
│ │ ├── 第201-500行: 架构规则 │ │
│ │ ├── 第501-1000行: API设计原则 │ │
│ │ ├── 第1001-2000行: 各模块的业务逻辑说明 │ │
│ │ ├── 第2001-3000行: 测试策略 │ │
│ │ ├── 第3001-4000行: 部署流程 │ │
│ │ └── 第4001-5000行: 故障排查指南 │ │
│ │ │ │
│ │ 四大问题: │ │
│ │ 1. 上下文窗口被耗尽 │ │
│ │ → 这个大文件占据了AI的"工作记忆" │ │
│ │ → 留给实际代码和任务的空间不够了 │ │
│ │ │ │
│ │ 2. "什么都重要 = 什么都不重要" │ │
│ │ → AI做局部模式匹配,而不是理解性导航 │ │
│ │ → 类比:给新员工一本1000页手册 vs 给关键页码+导航图 │ │
│ │ │ │
│ │ 3. 信息快速过时 │ │
│ │ → 手册变成"过时规则的坟场" │ │
│ │ → AI无法分辨哪些规则已失效 │ │
│ │ │ │
│ │ 4. 无法机械验证 │ │
│ │ → 一个大文件无法自动检查覆盖率、时效性 │ │
│ │ → 偏移不可避免 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ ✓ 成功方案:"目录式"知识管理 │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ AGENTS.md (~100行!!! 仅作为"地图") │ │
│ │ │ │ │
│ │ ├── "架构概览? → 看 ARCHITECTURE.md" │ │
│ │ ├── "前端规范? → 看 docs/FRONTEND.md" │ │
│ │ ├── "设计文档? → 看 docs/design-docs/index.md" │ │
│ │ ├── "当前执行计划? → 看 docs/exec-plans/active/" │ │
│ │ ├── "安全要求? → 看 docs/SECURITY.md" │ │
│ │ └── "质量评分? → 看 docs/QUALITY_SCORE.md" │ │
│ │ │ │
│ │ docs/ 目录结构: │ │
│ │ ├── design-docs/ ← 设计决策记录(有索引+验证状态) │ │
│ │ │ ├── index.md ← 所有设计文档的索引 │ │
│ │ │ ├── core-beliefs.md ← 核心运行原则 │ │
│ │ │ └── … │ │
│ │ ├── exec-plans/ ← 执行计划 │ │
│ │ │ ├── active/ ← 进行中的计划 │ │
│ │ │ ├── completed/ ← 已完成的计划 │ │
│ │ │ └── tech-debt-tracker.md ← 技术债务追踪 │ │
│ │ ├── generated/ ← 自动生成的文档 │ │
│ │ │ └── db-schema.md ← 数据库Schema(自动从代码生成) │ │
│ │ ├── references/ ← 外部参考资料 │ │
│ │ │ ├── design-system-reference-llms.txt │ │
│ │ │ └── uv-llms.txt │ │
│ │ ├── DESIGN.md ← 设计系统规范 │ │
│ │ ├── FRONTEND.md ← 前端规范 │ │
│ │ ├── PRODUCT_SENSE.md ← 产品直觉/用户体验原则 │ │
│ │ ├── QUALITY_SCORE.md ← 质量评分标准 │ │
│ │ ├── RELIABILITY.md ← 可靠性要求 │ │
│ │ └── SECURITY.md ← 安全规范 │ │
│ │ │ │
│ │ 关键原则:渐进式信息披露 │ │
│ │ – AI从小的、稳定的入口点(AGENTS.md)开始 │ │
│ │ – 被"教"下一步该看什么 │ │
│ │ – 而不是一开始就被信息淹没 │ │
│ │ │ │
│ │ 维护机制: │ │
│ │ – 专用 linter 验证知识库是否最新、相互链接、结构正确 │ │
│ │ – 定期运行"文档维护"AI代理 │ │
│ │ → 扫描过时文档 │ │
│ │ → 检查文档是否反映实际代码行为 │ │
│ │ → 创建修复PR │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘

核心洞察:

"任何AI在运行时无法在上下文中访问的内容都相当于不存在。"

┌─────────────────────────────────────────────────────┐
│ AI代理的知识边界 │
│ │
│ ┌───────────────────────────┐ │
│ │ AI 可见的世界 │ │
│ │ │ │
│ │ ✓ 仓库中的代码 │ │
│ │ ✓ Markdown文档 │ │
│ │ ✓ Schema定义 │ │
│ │ ✓ 执行计划 │ │
│ │ ✓ 测试结果 │ │
│ │ ✓ 日志/指标/追踪 │ │
│ └───────────────────────────┘ │
│ │
│ AI 看不见的世界(= 不存在): │
│ │
│ ✗ Slack上的讨论 │
│ ✗ Google Docs中的设计文档 │
│ ✗ 会议中的口头决策 │
│ ✗ 工程师脑中的隐性知识 │
│ ✗ 邮件中的需求变更 │
│ │
│ → 必须将这些"不可见知识"编码到仓库中! │
│ │
│ 类比:对于远程工程师,如果知识只在总部茶水间 │
│ 的对话中存在,那这些知识对远程员工就是不存在的 │
│ AI代理 = 极端的"远程员工" │
│ │
└─────────────────────────────────────────────────────┘

2.5 架构强制执行——"约束即速度"

┌─────────────────────────────────────────────────────────────────────┐
│ 通过约束保证AI代码质量 │
│ │
│ 核心理念: │
│ "集中执行边界,允许本地自主" │
│ = 告诉AI"什么不能做",而不是"怎么做" │
│ │
│ 分层架构强制执行: │
│ │
│ 每个业务领域(如"应用设置")内部: │
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Types 只能依赖 无 │ │
│ │ ↓ │ │
│ │ Config 只能依赖 Types │ │
│ │ ↓ │ │
│ │ Repository 只能依赖 Types, Config │ │
│ │ ↓ │ │
│ │ Service 只能依赖 Types, Config, Repository │ │
│ │ ↓ │ │
│ │ Runtime 只能依赖 Service以上的层 │ │
│ │ ↓ │ │
│ │ UI 只能依赖 Runtime以上的层 │ │
│ │ │ │
│ │ ✗ 禁止反向依赖(UI不能被Service依赖) │ │
│ │ ✗ 禁止跨层跳跃(UI直接调Repository) │ │
│ │ │ │
│ │ 横切关注点通过 Provider 接口注入: │ │
│ │ ┌──────────┐ │ │
│ │ │Provider │── Auth(认证) │ │
│ │ │(接口) │── Connector(连接器) │ │
│ │ │ │── Telemetry(遥测) │ │
│ │ │ │── Feature Flags(功能开关) │ │
│ │ └──────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 强制执行方式: │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 1. 自定义Linter(由Codex编写!) │ │
│ │ – 静态检查依赖方向 │ │
│ │ – 检查命名规范 │ │
│ │ – 检查文件大小限制 │ │
│ │ – 检查结构化日志格式 │ │
│ │ │ │
│ │ 2. 结构化测试 │ │
│ │ – 验证层间依赖图 │ │
│ │ – 验证允许的连接数量 │ │
│ │ │ │
│ │ 3. 错误消息设计 │ │
│ │ → 自定义linter的错误消息直接包含修复指令 │ │
│ │ → AI读到错误 → 直接知道怎么修 │ │
│ │ → 人类不需要介入 │ │
│ │ │ │
│ │ 示例: │ │
│ │ ✗ "Error: Invalid dependency" │ │
│ │ ✓ "Error: settings/ui.ts imports from settings/repository.ts │ │
│ │ UI layer cannot depend on Repository layer directly. │ │
│ │ Please route through Service layer: │ │
│ │ UI → Service → Repository" │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ 关键洞察: │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ "这种架构通常要等到拥有数百名工程师后才会考虑。 │ │
│ │ 但对于AI代理来说,这是早期必备条件。" │ │
│ │ │ │
│ │ 原因:AI代理 ≈ 数百个初级工程师同时工作 │ │
│ │ – 如果没有清晰的边界,它们会朝各个方向发散 │ │
│ │ – 约束不是束缚,而是让AI快速且正确地工作的导轨 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ 对比: │
│ ┌──────────────────┬──────────────────────────────────────────┐ │
│ │ 对人类工程师 │ 这些规则可能显得繁琐或束缚 │ │
│ │ 对AI代理 │ 这些规则是"倍增器"——编码一次,处处适用 │ │
│ └──────────────────┴──────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘

2.6 合并理念的转变

┌─────────────────────────────────────────────────────────────────────┐
│ 高吞吐量下的合并策略变化 │
│ │
│ 传统工程团队的PR流程: │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ 开发者提交PR │ │
│ │ ↓ │ │
│ │ 等待CI通过 (30min) │ │
│ │ ↓ │ │
│ │ 等待2-3名reviewer审核 (数小时到数天) │ │
│ │ ↓ │ │
│ │ 修改review意见 │ │
│ │ ↓ │ │
│ │ 再次等待review │ │
│ │ ↓ │ │
│ │ 合并 │ │
│ │ │ │
│ │ 周期:数小时 → 数天 │ │
│ │ 原因:犯错成本高,修复代价大 │ │
│ └────────────────────────────────────────────────────────────┘ │
│ │
│ AI代理优先团队的PR流程: │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Codex生成PR │ │
│ │ ↓ │ │
│ │ Codex自我审查 (本地) │ │
│ │ ↓ │ │
│ │ 其他AI代理审查 (本地+云端) │ │
│ │ ↓ │ │
│ │ AI之间迭代直到所有代理审查者满意 │ │
│ │ ↓ │ │
│ │ (可选)人工快速审查 │ │
│ │ ↓ │ │
│ │ 合并(通常由AI自己合并) │ │
│ │ │ │
│ │ 周期:分钟 → 小时 │ │
│ │ │ │
│ │ 如果出问题? │ │
│ │ → 后续AI运行会修复 │ │
│ │ → 纠正成本低,等待成本高 │ │
│ └────────────────────────────────────────────────────────────┘ │
│ │
│ 新的经济学: │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 传统: 修复成本 >> 等待成本 → 慢速严格审查 │ │
│ │ AI优先:修复成本 << 等待成本 → 快速合并+后续修复 │ │
│ │ │ │
│ │ 因为: │ │
│ │ – AI可以在几分钟内生成修复PR │ │
│ │ – AI不会因为等待而"闲着"但人类的注意力会被浪费 │ │
│ │ – 每个阻塞的PR都是一个等待人类注意力的队列 │ │
│ │ – 人类注意力是唯一真正稀缺的资源 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 文章的原话: │
│ "在低吞吐量环境下,这样做是不负责任的。 │
│ 但在这里,这通常是正确的权衡之策。" │
│ │
└─────────────────────────────────────────────────────────────────────┘

2.7 熵与垃圾回收——AI代码的"技术债务管理"

这是文章中最富创意的类比:

┌─────────────────────────────────────────────────────────────────────┐
│ AI代码的"垃圾回收"机制 │
│ │
│ 问题:AI会复制代码库中的模式——包括不好的模式 │
│ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 早期:某处有一个次优的辅助函数 │ │
│ │ ↓ │ │
│ │ AI看到这个模式,在10个新地方复制了它 │ │
│ │ ↓ │ │
│ │ 现在有11个地方用了次优模式 │ │
│ │ ↓ │ │
│ │ AI继续看到这个"流行"的模式,在更多地方使用… │ │
│ │ ↓ │ │
│ │ ❗ 偏差指数级扩散! │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ ✗ 失败方案:人工"周五清理日" │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 每周五花20%时间清理"AI遗留代码" │ │
│ │ → 无法跟上AI的产出速度 │ │
│ │ → 不可持续 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ ✓ 成功方案:编码"黄金原则" + 自动化持续清理 │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 第一步:将品味偏好编码为机械规则("黄金原则") │ │
│ │ ┌────────────────────────────────────────────────────────┐ │ │
│ │ │ 示例规则: │ │ │
│ │ │ │ │ │
│ │ │ 1. "优先使用共享utility包,不要手写helper函数" │ │ │
│ │ │ → 保持不变式集中管理 │ │ │
│ │ │ │ │ │
│ │ │ 2. "不要YOLO式探测数据——在边界处验证,或使用类型化SDK" │ │ │
│ │ │ → 防止AI基于猜测的数据形状构建代码 │ │ │
│ │ │ │ │ │
│ │ │ 3. "结构化日志必须遵循特定Schema" │ │ │
│ │ │ 4. "文件不超过300行" │ │ │
│ │ │ 5. "所有公共API必须有类型定义" │ │ │
│ │ └────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ 第二步:定期运行后台AI代理扫描+修复 │ │
│ │ ┌────────────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ 定期任务(类似cron job): │ │ │
│ │ │ │ │ │
│ │ │ "GC Agent" 运行: │ │ │
│ │ │ 1. 扫描代码库,对比黄金原则 │ │ │
│ │ │ 2. 找到偏差 │ │ │
│ │ │ 3. 更新质量评分 │ │ │
│ │ │ 4. 创建针对性重构PR │ │ │
│ │ │ 5. 大多数PR一分钟内审查+自动合并 │ │ │
│ │ │ │ │ │
│ │ │ 效果: │ │ │
│ │ │ – 每天发现并修复不良模式 │ │ │
│ │ │ – 而不是让它们蔓延数天/周后才清理 │ │ │
│ │ │ – 人类的审美偏好:捕获一次,持续应用 │ │ │
│ │ └────────────────────────────────────────────────────────┘ │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ 类比: │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 编程语言的垃圾回收(GC): │ │
│ │ – 不是等到内存满了才清理 │ │
│ │ – 而是持续小量回收 │ │
│ │ – 避免"Full GC"导致的长暂停 │ │
│ │ │ │
│ │ 技术债务 = 高息贷款: │ │
│ │ – 持续小额偿还 >> 积累后集中偿还 │ │
│ │ – 因为利息(偏差扩散)会越滚越大 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘

2.8 AI代理的自主性级别

文章描述了AI代理最终达到的端到端自主能力:

┌─────────────────────────────────────────────────────────────────────┐
│ Codex 端到端自主工作流程 │
│ │
│ 仅凭一个提示,AI代理可以完成整个流程: │
│ │
│ 人类:"修复用户报告的X功能bug" │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 1. 验证代码库当前状态 │ │
│ │ └── 拉取最新代码,确认环境正常 │ │
│ │ │ │
│ │ 2. 重现已报告的bug │ │
│ │ └── 启动应用实例,执行bug触发步骤 │ │
│ │ │ │
│ │ 3. 录制bug演示视频 🎥 │ │
│ │ └── 作为bug存在的证据 │ │
│ │ │ │
│ │ 4. 分析原因并实施修复 │ │
│ │ └── 修改代码 │ │
│ │ │ │
│ │ 5. 验证修复效果 │ │
│ │ └── 重启应用,重新执行触发步骤 │ │
│ │ │ │
│ │ 6. 录制修复后的演示视频 🎥 │ │
│ │ └── 作为修复有效的证据 │ │
│ │ │ │
│ │ 7. 提交PR │ │
│ │ └── 附上两个视频(before/after) │ │
│ │ │ │
│ │ 8. 响应代理和人工反馈 │ │
│ │ └── 如果reviewer提出修改意见 → 修改 → 重新提交 │ │
│ │ │ │
│ │ 9. 检测并修复CI构建失败 │ │
│ │ └── 如果CI挂了 → 分析日志 → 修复 → 重新推送 │ │
│ │ │ │
│ │ 10. 判断是否需要人工介入 │ │
│ │ └── 如果遇到需要产品决策的问题 → 上报人类 │ │
│ │ └── 否则 → 继续 │ │
│ │ │ │
│ │ 11. 合并更改 ✅ │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ ⚠️ 文章的重要警示: │
│ "这种行为很大程度上取决于该仓库的具体结构和工具, │
│ 如果没有类似的投入,就不应假定其具有普遍性——至少目前还不行" │
│ │
│ 意思是:这不是Codex开箱即用的能力,而是5个月持续 │
│ 构建基础设施(可观测性/架构/文档/linter/工具)的结果 │
│ │
└─────────────────────────────────────────────────────────────────────┘


三、深层洞察与核心经验提炼

3.1 思维框架转变

┌─────────────────────────────────────────────────────────────────────┐
│ 五个核心思维转变 │
│ │
│ 1. 从"编写代码"到"设计环境" │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 旧:工程师的价值 = 写出高质量代码的能力 │ │
│ │ 新:工程师的价值 = 设计让AI能产出高质量代码的环境的能力 │ │
│ │ │ │
│ │ 类比:从"亲自种地"到"设计灌溉系统" │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ 2. 从"写文档给人看"到"写文档给AI看" │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 旧:文档是给新员工看的(可以口头补充) │ │
│ │ 新:文档是AI唯一的信息来源(不可见 = 不存在) │ │
│ │ │ │
│ │ 类比:从"面对面教学"到"编写完全自学教材" │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ 3. 从"避免犯错"到"快速纠错" │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 旧:严格门控,确保不出错才能合并 │ │
│ │ 新:快速合并,通过后续AI运行快速修复 │ │
│ │ │ │
│ │ 类比:从"手工质检每一件产品"到"流水线+自动检测+快速返工" │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ 4. 从"管理技术债务"到"垃圾回收机制" │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 旧:积累技术债务 → 定期重构冲刺 │ │
│ │ 新:编码品味偏好 → AI持续自动清理 │ │
│ │ │ │
│ │ 类比:从"每月大扫除"到"扫地机器人每天清扫" │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ 5. 从"人工审查"到"AI审查+人工仲裁" │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 旧:每个PR必须人工review │ │
│ │ 新:AI之间互审,只有需要判断时才上报人类 │ │
│ │ │ │
│ │ 类比:从"法官审每个案件"到"AI律师先筛选+辩论,法官终审" │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘

3.2 关键技术实践总结

┌─────────────────────────────────────────────────────────────────────┐
│ 可复制的关键实践 │
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 实践1: AGENTS.md 作为"地图"而非"百科全书" │ │
│ │ → ~100行入口文件,链接到详细文档 │ │
│ │ → 渐进式信息披露 │ │
│ │ → 自动化验证文档时效性 │ │
│ ├─────────────────────────────────────────────────────────────┤ │
│ │ 实践2: 自定义Linter的错误消息包含修复指令 │ │
│ │ → AI读到错误就知道怎么修 │ │
│ │ → 无需人类介入解释 │ │
│ ├─────────────────────────────────────────────────────────────┤ │
│ │ 实践3: 每个AI任务有独立的应用实例+可观测性堆栈 │ │
│ │ → 互不干扰 │ │
│ │ → 任务完成后销毁 │ │
│ ├─────────────────────────────────────────────────────────────┤ │
│ │ 实践4: 在边界处解析/验证数据形状 │ │
│ │ → 约束"什么"而非"怎么做" │ │
│ │ → AI自由选择实现方式 │ │
│ ├─────────────────────────────────────────────────────────────┤ │
│ │ 实践5: 知识库版本化并存储在仓库中 │ │
│ │ → 计划、决策、进度都是Git tracked的Markdown │ │
│ │ → AI无需外部系统即可运行 │ │
│ ├─────────────────────────────────────────────────────────────┤ │
│ │ 实践6: "GC Agent"定期扫描+修复代码偏差 │ │
│ │ → 编码品味偏好为规则 │ │
│ │ → 持续自动清理,不积累债务 │ │
│ ├─────────────────────────────────────────────────────────────┤ │
│ │ 实践7: 偏好"无聊的技术" │ │
│ │ → 可组合、API稳定、训练数据中有良好代表性的技术 │ │
│ │ → AI更容易正确使用 │ │
│ ├─────────────────────────────────────────────────────────────┤ │
│ │ 实践8: 有时重新实现优于引入外部库 │ │
│ │ → 自己实现的代码:AI可完全检查、验证、修改 │ │
│ │ → 外部库的不透明行为:AI可能误用 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘

3.3 文章承认的局限和未解问题

┌─────────────────────────────────────────────────────────────────────┐
│ 坦诚的未解问题 │
│ │
│ 1. 架构连贯性的长期演化 │
│ → 5个月后仍然OK,但2年后呢? │
│ → AI生成的架构能否保持长期一致性? │
│ │
│ 2. 人类判断在哪里发挥最大价值 │
│ → 还在探索 │
│ → 可能是:产品方向、用户体验直觉、伦理决策 │
│ │
│ 3. 如何编码人类判断使其"叠加" │
│ → 不是一次性的,而是持续增值的 │
│ → 类似"复利效应" │
│ │
│ 4. 模型能力提升后系统如何演化 │
│ → 当前很多基础设施是为了弥补AI的不足 │
│ → 如果AI变得更强,这些基础设施还需要吗? │
│ │
│ 5. 这个方法是否具有普遍性 │
│ → 文章明确说:不要假定具有普遍性 │
│ → 这依赖于特定的仓库结构和工具投入 │
│ → 对于已有大量遗留代码的项目,挑战完全不同 │
│ │
└─────────────────────────────────────────────────────────────────────┘


四、对车载软件/嵌入式领域的启示

思考这种方法论对车载软件的适用性:

┌─────────────────────────────────────────────────────────────────────┐
│ 对车载/嵌入式领域的可能影响 │
│ │
│ 高度适用的部分: │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ ✓ "地图式"文档管理 → AUTOSAR/ADAS代码库的知识管理 │ │
│ │ ✓ 严格的架构分层+自动验证 → 车载软件分层架构 │ │
│ │ ✓ 自定义Linter → MISRA-C/功能安全规则检查 │ │
│ │ ✓ 可观测性堆栈 → 车载诊断/日志系统 │ │
│ │ ✓ 持续代码质量清理 → 满足ASPICE/ISO 26262要求 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ 难以直接适用的部分: │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ ✗ "快速合并+后续修复" → 安全关键系统不允许 │ │
│ │ ✗ "零人工代码" → 功能安全认证需要人工审查证据 │ │
│ │ ✗ "AI自主合并PR" → ASPICE流程要求可追溯的人工审批 │ │
│ │ ✗ 百万行Web代码模式 → 嵌入式实时系统有完全不同的约束 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ 未来可能的融合点: │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ • AI代理生成AUTOSAR配置代码(arxml等大量样板文件) │ │
│ │ • AI代理生成测试用例(V模型中的测试设计) │ │
│ │ • AI代理生成诊断描述文件(ODX/CDD等) │ │
│ │ • "架构linter"强制执行SWC依赖规则 │ │
│ │ • AI代理辅助FMEA/HARA安全分析 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘


五、一句话总结

这篇文章的核心信息是:在AI代理时代,工程师的核心工作从"编写代码"变为"设计让AI能高效、正确工作的环境"——包括文档结构、架构约束、自动化验证、可观测性工具和品味偏好的编码化。人类提供方向和判断力,AI提供速度和规模。两者的分工不是"人做难的,AI做简单的",而是"人设计系统,AI在系统内执行"。

赞(0)
未经允许不得转载:171主机测评 » 从零开始学AI201——AI驾驭工程1
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址