AI Engineer
大模型在长上下文中必入性能衰退的愚笨区,工程团队唯有重拾经典垂直切片与测试驱动开发,将模糊需求盘问至极小任务,才能摆脱AI盲写产生的代码垃圾。
AI-assisted summary of Full Walkthrough: Workflow for AI Coding — Matt Pocock — original source. Check the original for full context.
Source published:
Key ideas
- 大语言模型的代码生成能力受限于上下文窗口,当累积消耗达到约 100k tokens 时模型会因注意力机制的二次方爆炸而滑入“愚笨区”,因此任务颗粒度必须严格限制在聪慧区内。 (3:00)
- Matt Pocock 提出“Grill Me”(刨根问底)技能,通过多轮单题盘问与模型主动推荐,在进入编码前与 AI 达成统一的“设计概念”,从源头消除意图错位。 (13:48)
- 在任务拆解中应弃用按层推进的横向切片,改用贯穿数据库、服务和 UI 的“曳光弹”垂直切片,从而为 AI 提供即时的端到端反馈回路。 (43:44)
- AI 辅助开发下工程师应遵循深模块(Deep Modules)架构,仅把控简洁的外部接口并委托内部实现,依靠严格的 TDD(红-绿-重构)杜绝 AI 测试作弊。 (76:55)
Detailed notes
## Background 本内容由 YouTube 频道“AI Engineer”于 2026 年 4 月 24 日发布,主讲人为知名开发者导师 Matt Pocock。工作坊视频聚焦 AI 辅助编码的全生命周期,涵盖将模糊需求转化为适合智能体执行的 PRD、通过垂直切片拆解任务、利用 TDD 指导自主编码智能体实现功能,以及构建适合 AI 协作的高效代码库架构。
## TL;DR Matt Pocock 系统性拆解了一套摆脱“氛围编码”与“规格即代码”陷阱的严肃 AI 工程流。在前期规划中,他通过高强度的“Grill Me”连续质询与 AI 达成心智对齐,将模糊需求沉淀为清晰的 PRD,并拒绝过度通读文档,转而将其垂直切分为具备“曳光弹”特质的独立看板任务。在实现阶段,他演示了利用测试驱动开发(TDD)约束离线运行的自主 Agent(如 Ralph 循环与自研的 Sandcastle 并行架构),让模型在低上下文负担的“聪慧区”内稳定交付端到端切片。最后,他主张将代码库重构为对外接口精简、内部实现完备的“深模块”,由人类掌控顶层架构与代码审查,将脏活累活放手委托给 AI。
## Atmosphere & style 现场座无虚席、气氛热烈且极具实战沉浸感,Matt Pocock 风格干练幽默、直言不讳,面对 Windows 笔记本弹窗卡顿与会场闷热频频自嘲,迅速拉近了与台下工程师的距离。整场工作坊节奏紧凑,在终端敲代码、白板手绘逻辑图与 Slido 互动答疑之间丝滑切换,既有反驳流行概念时的辛辣犀利,又有调试遇到报错时的真实坦率。观看全程就像坐在黑客松现场接受一场高密度的工程思想洗礼,既能感受到前沿 Agent 自动化带来的生产力震撼,又被反复拉回对经典软件工程底层的深刻敬畏之中。
## Bulletin - [03:00](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=180s) 大语言模型的代码生成能力受限于上下文窗口,当累积消耗达到约 100k tokens 时模型会因注意力机制的二次方爆炸而滑入“愚笨区”,因此任务颗粒度必须严格限制在聪慧区内。 - [13:48](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=828s) Matt Pocock 提出“Grill Me”(刨根问底)技能,通过多轮单题盘问与模型主动推荐,在进入编码前与 AI 达成统一的“设计概念”,从源头消除意图错位。 - [43:44](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2624s) 在任务拆解中应弃用按层推进的横向切片,改用贯穿数据库、服务和 UI 的“曳光弹”垂直切片,从而为 AI 提供即时的端到端反馈回路。 - [01:16:55](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4615s) AI 辅助开发下工程师应遵循深模块(Deep Modules)架构,仅把控简洁的外部接口并委托内部实现,依靠严格的 TDD(红-绿-重构)杜绝 AI 测试作弊。
## Key takeaways - [00:15](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=15s) 人类协作中的软件工程基本功(如任务拆分、接口隔离)在 AI 时代依然高度有效,并非所有规则都被全新范式颠覆。 - [03:00](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=180s) LLM 存在明显的“聪慧区”与“愚笨区”,无论标称窗口多大,超过 100k tokens 后的注意力衰减会导致低级错误频发,需通过频繁清空上下文(Memento 模式)保持确定性。 - [11:06](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=666s) “规格即代码”(specs to code)是一种企图脱离代码细节的偷懒流派,代码本身仍是工程博弈的核心战场,开发者必须掌控代码骨架。 - [19:51](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=1191s) 利用 Grill Me 技能进行长达 40 至 100 轮的密集问答,可以挖掘出如“历史数据回填”等隐性边界条件,沉淀为高质量的设计概念资产。 - [24:59](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=1499s) 人机协同应实行二分法:需求规划与对齐属于必须有人在回路(HITL)的高认知任务,而代码实现与测试编写应转变为远离键盘(AFK)的自主任务。 - [35:10](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2110s) 前期充分对齐后无需肉眼逐字审阅生成的 PRD,因为总结归纳是 LLM 最擅长的能力,审阅文档实质上是在低效检验模型的表达。 - [40:44](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2444s) AI 天然倾向于横向分层编码(先写完 Schema 再写 API),这会导致反馈严重滞后;必须强制切分为“曳光弹”垂直切片以尽早获得端到端验证。 - [49:31](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2971s) 将 PRD 拆解为具有依赖阻塞关系的有向无环图(DAG)看板任务,是释放多 Agent 并行流水线开发吞吐量的前提。 - [01:08:41](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4121s) 代码库底层的自动化反馈回路(类型检查、测试套件)是 AI 编码能力的硬天花板,缺乏即时反馈的 AI 相当于在“盲写代码”。 - [01:06:42](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4002s) 推行测试驱动开发(TDD)能迫使 AI 在写业务代码前确立断言,有效杜绝 AI 在后补测试时弱化断言的作弊行为。 - [01:13:39](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4419s) 充斥浅模块的混乱架构会导致依赖图膨胀与测试过度 Mock,使 AI 迷失;应设计具有小接口、厚实现的“深模块”,把内部实现作为灰盒委托给 AI。 - [01:23:09](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4989s) 功能交付后应从代码库中清理 Markdown 格式的 PRD,防止代码演进后陈旧文档腐烂(Doc Rot)误导后续的 Agent 决策。 - [01:27:40](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=5260s) 编码规范应实施推拉分离策略:实现阶段让 Agent 按需拉取(Pull)以保持上下文轻量,自动化审查阶段则强制全量推送(Push)规范进行比对。 - [01:29:47](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=5387s) 离线并行架构(如 Sandcastle)可通过 Git worktree 与 Docker 容器实现多任务环境隔离,并利用独立 Reviewer 和 Merger Agent 自动修复合并冲突。
## Detailed walkthrough ### [00:15](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=15s) 开场与 AI 工程的核心论点
工作坊开场时现场已经座无虚席。Matt Pocock 登台宣布直接开始,不再为了凑齐某个任意设定的时间表让大家干等 25 分钟。他自我介绍是一名教师,如今也教授 AI。本次工作坊预计进行约两个小时,现场提供了一个包含全套实践练习的链接供学员同步操作。
在阐述过去六个月左右指导自己工作的核心论点时,Matt 指出,虽然人人都认为 AI 是一种正在重塑一切的“全新范式”,但人们往往忽视了一个至关重要的事实:人类协作中不可或缺的软件工程底层基本功,在配合 AI 工作时同样表现得极其出色。关于这一点,他在大会第二天的 Keynote 中会有更深入的展开,而今天的实操工作坊旨在通过具体的代码实践,让大家亲眼验证这些经典软件工程原则在 AI 时代的威力。
为了解台下听众的背景,Matt 做了一轮现场举手互动:全场绝大部分人都在编码中使用过 AI;随后他让大家继续举着手,询问有多少人“每天”都在用 AI 编码;最后他让“曾被 AI 搞得抓狂、挫败过”的人继续保持举手,台下几乎所有人依然举着手。看到全场整齐的反应,Matt 调侃感谢大家的“顺从”。此外,活动还向分会场的 Gielgud 厅进行了实时转播。为了避免传统 Q&A 环节沦为少数健谈者的独角戏,Matt 采用了一个异步线上提问平台,让大家在上面提交问题并相互点赞投票,以便最优质的问题能够民主地浮现出来供全场探讨。
- 参会者调查:绝大多数人使用过 AI 辅助编程,相当比例的人每天使用,且几乎所有人都曾遭遇过 AI 带来的挫败感。 - 互动机制:舍弃传统的现场话筒提问,采用异步提问加点赞投票的线上系统,防止现场被麦霸垄断。
> Matt Pocock:“And I feel that when we talk about AI being a new paradigm, we forget that actually software engineering fundamentals, the stuff that's really crucial to working with humans, also works super well with AI.”(“我觉得,当我们谈论 AI 是一种新范式时,我们忘记了软件工程的基本原则——那些对人类协作至关重要的东西——在配合 AI 时同样非常有效。”)
---
[03:00](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=180s) 聪慧区与愚笨区:LLM 的上下文衰减困境
Matt 深入剖析了制约大语言模型(LLM)行为的核心硬约束。他引用了 HumanLayer 公司负责人 Dex Horvath(原语音误作 Dex Hardy)提出的核心概念:大模型在处理任务时存在“聪慧区”(Smart Zone)和“愚笨区”(Dumb Zone)。当刚开启一个全新的对话上下文时,上下文环境没有任何历史噪音,注意力机制的负担最轻,模型处于最佳的聪慧区,能产出极高质量的代码和决策。
然而,每向上下文窗口中塞入一个新的 token,注意力机制的复杂度就会剧增。Matt 用足球联赛打比方:每在联赛中增加一支新球队,需要增加的比赛场次就会呈二次方(quadratic)规模爆炸式增长。因为 token 之间不仅存在绝对位置关联,还存在语义上的交叉注意力交互。因此,不管底层模型标称拥有 200K 还是 100 万的超长上下文窗口,实际上一旦上下文消耗累积到大约 40% 或者 100K tokens 左右,模型就会开始显著变笨,逐步滑入“愚笨区”,并开始做出各种低级愚蠢的决策。现场不少人举手对这种现象表示感同身受。
这也解释了为什么经典软件工程原则在此依然适用。正如 Martin Fowler 在《重构》中强调的,或者《程序员修炼之道》(The Pragmatic Programmer)所建议的,开发者永远不要“一口咬下超过咀嚼能力的大饼”(Don't bite off more than you can chew),必须把任务切分得足够小,防止人类大脑由于信息超载陷入混乱。对 AI 而言更是如此:任务的颗粒度必须严格限制在模型的聪慧区之内。
```mermaid flowchart LR accTitle: LLM Smart Zone vs Dumb Zone accDescr: A comparison showing performance degradation as context window fills up.
subgraph SZ["聪慧区 (Smart Zone: ~0 - 100K Tokens)"] A["全新上下文会话"] --> B["注意力负担极轻"] B --> C["高精度决策与高质量编码"] end
subgraph DZ["愚笨区 (Dumb Zone: > 100K Tokens)"] D["上下文持续堆积"] --> E["注意力关系呈二次方爆炸"] E --> F["上下文漂移与频繁低级错误"] end
SZ -.->|"不断追加 Token"| DZ ```
- 上下文缩放代价:注意力网络随着 token 增加呈二次方级扩展,模型性能退化在约 100K tokens 时尤为明显,与总上下文窗口大小无关。 - 任务拆分准则:必须将大型工程任务拆解为小颗粒任务,强制让模型的每次操作都停留在聪慧区内完成。
> Matt Pocock:“Every time you add a token to an LLM, it's kind of like you're adding a team to a football league. You think of the number of matches that get added every time you add a team to a football league, it just goes it scales quadratically.”(“每次向大模型添加一个 token,就有点像往足球联赛里增加一支球队。想想每次加入一支队伍会增加多少场比赛,这完全是呈二次方级规模扩大的。”)
---
[05:01](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=301s) 任务拆解:从多阶段计划到 Ralph Wiggum 循环
如何将克隆一家公司或者构建复杂系统这样庞大的宏伟目标,切碎成能够稳定落在聪慧区里的小型任务?Matt 指出,很多 AI 公司的默认做法或用户的自然习惯是“硬抗到底”:在同一个对话流里不停地写,一路冲进愚笨区,花费天价的 token 费用,然后被迫执行“上下文压缩”(compacting),稍作清理后继续往里塞,直到再次变笨。但这种不断留下认知沉积物的方式效果极差。
Matt 分享了自己直到去年 12 月之前一直采用的方案:多阶段计划(Multi-phase plans)。即先立足于第四阶段的庞大终极目标,向前拆解为 Phase 1、Phase 2、Phase 3 等独立切片,确保每个阶段的工作都在聪慧区内独立交付。然而,任何合格的软件工程师一眼就能看出这本质上就是一个程序循环(Loop)。既然有 Phase 1 到 Phase 4,为什么不直接抽象成“Phase N”的自动循环?
由此衍生出了被称为“拉尔夫·维古姆”(Ralph Wiggum,以《辛普森一家》角色命名)的软件实践方法。该方法主张只需定义好旅程的终点——编写一份详尽的 PRD(产品需求文档),然后把 AI 扔进一个简单的外层循环中,告诉它:“每次只做一次微小的改动,让当前代码离这份 PRD 更近一步。”尽管 Ralph Wiggum 模式可行,但 Matt 坦言自己更偏好结构化程度更高的任务切分体系,而不是任由其漫无目的地渐进试探。
- 多阶段计划本质:将巨型任务分段以适配聪慧区,其实质是一个在上下文之间轮转迭代的循环过程(Looping)。 - Ralph Wiggum 实践:只规定初始 PRD 目标,由自动化 Agent 循环执行单步微小修改以逼近终点,但其缺乏确定性的工程引导结构。
> Matt Pocock:“And any developer worth their salt will look at this and go, 'This is a loop.' Right? This is a loop. We've just got phase one, phase two, phase three, phase four. Why don't we just have phase N?”(“任何有点真本事的开发者看到这个都会说:‘这不就是一个循环吗?’对吧?这就是一个循环。我们既然有一阶段、二阶段、三阶段、四阶段,为什么不直接搞个 N 阶段呢?”)
---
[07:27](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=447s) 会话生命周期与 Claude Code 上下文监控
Matt 指出,LLM 的另一个严重约束是“健忘”——它就像电影《记忆碎片》(Memento)里的男主角,每隔一段时间就会丧失短期记忆,重置回到初始的空白状态。他在 TLDraw 无限画布上画出了典型的 Agent 单次工作流周期:
1. **System Prompt(系统提示词)**:这部分是常驻上下文的基础底座,必须极其精简。Matt 强调,曾见过有人把 250K tokens 的内容塞进系统提示词,这种做法相当于让 Agent 还没开始执行任何业务操作,就已经半只脚踏进了愚笨区。 2. **Exploratory Phase(探索阶段)**:Coding Agent 在代码库中穿梭、搜索相关文件并理解现有逻辑。 3. **Implementation Phase(实现阶段)**:针对具体目标修改或新增业务代码。 4. **Testing Phase(测试验证阶段)**:运行自动化测试、执行反馈循环并修正代码错误。
一旦在开发工具中选择清空上下文(Clear Context),整个进程就会瞬时打回原形,除了极薄的 System Prompt 之外,此前所有的上下文和试错记忆全被擦除。针对那些不熟悉“上下文压缩”(Compacting)的学员,Matt 打开自己的命令行演示了这一机制。他在本次演示中使用了 Anthropic 的 Claude Code 工具(虽然他指出大家完全可以使用任何其他 Agent 客户端)。在与模型对答规划功能细节的同时,Matt 调出了终端底部的实时状态监控行,清晰显示出当前会话消耗的精确 token 数量,以此作为防止滑入愚笨区的警报器,并推荐大家在他的 AI Hero 网站上查阅具体配置教程。
- 单会话四阶段模型:System Prompt(系统提示) $\to$ Exploration(代码库探索) $\to$ Implementation(功能实现) $\to$ Testing(测试与反馈回路)。 - 系统提示词膨胀警告:若在 System Prompt 中堆叠过多规则(如高达 250K tokens),模型将在零输出状态下直接陷入愚笨区。 - 状态栏 token 监控:在 Agent 终端配置高频刷新的是否接近愚笨区的精确 token 计数器,是保障工程严密性的必备习惯。
> Matt Pocock:“Another weird constraint of LLMs is LLMs are kind of like the guy from Memento, right? They just continually forget. They could just keep resetting back to the base state.”(“大模型的另一个奇特约束在于,它们有点像电影《记忆碎片》里的那个男主角,对吧?它们总是不停地遗忘,只能一次又一次地重置回基础状态。”)
[09:52](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=592s) 掌控 Token 上下文:清空 vs 压缩与“记忆碎片”模式
在任何 AI 辅助编程会话中,实时了解当前使用的 Token 数量都是一项生死攸关的基本功。开发者必须清晰洞察自己距离“变笨区间”(dumb zone)到底还有多远。当上下文窗口开始拥挤时,通常有两种处理路径:要么直接“清空”(clear),一切归零重新开始;要么执行“压缩”(compact)。压缩机制会把此前所有的对话历史——无论规模多小——提炼硬塞进一个狭小的摘要空间中,在逻辑图上就表现为将整个会话的所有细节转化为一段浓缩的书面历史记录。
```mermaid flowchart TD accTitle: 上下文管理模式对比 accDescr: 对比 Clear 彻底重置模式与 Compact 压缩提取模式
subgraph CompactMode["压缩模式 (Compact)"] A["长会话原始上下文"] -->|"信息摘要 / 挤压"| B["压缩历史记录"] B -.->|"存在信息损耗与噪音"| C["变笨区间风险"] end
subgraph ClearMode["重置模式 (Clear / Memento)"] D["当前会话结束"] -->|"彻底清空上下文"| E["干净的初始状态"] E -->|"重新载入高精度 Prompt"| F["稳定处于 Smart Zone"] end ```
许多开发者出于某种执念非常迷恋 Compact 操作,但 Matt Pocock 对此极为反感。他更倾向于让 AI 像电影《记忆碎片》(Memento)的主角那样行动——即通过频繁清空回到完全一致的白纸状态。只要你能优化自己的工作流以适应这种无状态的重置模式,开发效率就会处在一个极佳的水平。
> “I much prefer my AI to behave like uh the guy from Memento because this state is always the same. Always the same every time you do it.” —— Matt Pocock
- **两大底层约束**:大语言模型同时受制于两项客观规律——它们拥有截然分明的“聪明区间”(smart zone)与“变笨区间”(dumb zone),并且天然具备类似《记忆碎片》主角般的失忆特质。 - **上下文清零的优势**:每次 Clear 都确保了环境的确定性,消除了历史长会话中潜藏的幻觉噪音与注意漂移。
---
[11:06](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=666s) 告别“规格即代码”陷阱与实战环境准备
结束简短的概念讲授后,工作坊进入真机实操环节。在场学员(包括副会场 Gilgud 厅的观众)通过指定链接克隆演示仓库并跟随演练。演练所基于的项目来自于真实课程系统:一个名为 Cadence 的课程管理平台(CMS),专门面向讲师与学员服务。本次演练的目标是带领大家完成从一个模糊的产品设想到撰写 PRD、再到最终实现落地功能的全流程。
Matt Pocock 借此尖锐地批判了当下盛行的“规格即代码”(specs to code)思潮。这种流派主张开发者只需编写一份高层规范文档,直接扔给 AI 生成代码;如果生成的代码出现缺陷,开发者不应该去排查代码,而是反向修改规格文档,再重新交给 AI 迭代。Matt Pocock 认为这本质上就是换了个马甲的“氛围编码”(vibe coding),是一种企图对底层实现撒手不管的偷懒做法。
> “And I tried this. I really tried it. And it sucks. It doesn't work. Because you need to keep a handle on the code. You need to understand what's in it. You need to shape it because the code is your battleground.” —— Matt Pocock
- **演示项目**:Cadence,包含学生端与讲师端的课程学习管理 CMS 平台。 - **为何“规格即代码”不可行**:完全脱离代码细节会导致对系统掌控力的崩塌。代码本身才是工程博弈的核心战场,开发者必须理解其骨架与细节,而非盲目指望文档提示词能自动抹平工程实现的鸿沟。
---
[13:48](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=828s) 引入“Grill Me”机制与对齐设计概念
实操的第一步是从仓库根目录下的 `client-brief.md` 开始。该文件记录了一条来自“Sarah Chen”的真实 Slack 消息(Matt Pocock 吐槽 Claude 似乎对 Sarah Chen 这个名字有某种谜之偏爱)。消息反映出 Cadence 平台的痛点:学员的留存率十分惨淡,往往注册学习几节课后就彻底流失,因此 Sarah 提议为平台增加游戏化(gamification)积分机制以提高黏性。在紧迫的预算与工期限制下,若需求方(如 Sarah Chen)发完消息后立刻休假失联,传统的“Plan 模式”往往急于求成,在缺乏关键信息的情况下凭空编造一份虚胖的执行方案。
为了从根源上消灭这种 AI 与人类意图的错位(misalignment),Matt Pocock 引入了他最倚重的工作流工具——`grill-me` 技能(Grill Me skill)。在清空上下文后,只需输入 `/grill-me client-brief.md` 即可唤起该流程。
```mermaid flowchart TD accTitle: Grill Me 技能对齐流程 accDescr: 展示 Grill Me 如何拆解模糊需求,通过子代理探索与单题循环达成共识
Brief["Client Brief 模糊需求 (Sarah Chen Slack)"] --> Launch["/grill-me client-brief.md"] Launch --> SubAgent["Explore 子代理 (独立上下文,深挖仓库)"] SubAgent --> Summary["返回精炼仓库上下文摘要"] Summary --> QuestionLoop{"单题多轮盘问循环"} QuestionLoop -->|"提问 + AI推荐答案"| HumanInput["开发者确认 / 纠偏决策"] HumanInput --> QuestionLoop QuestionLoop -->|"所有决策分支闭环"| SharedUnderstanding["达成统一的 Design Concept"] ```
`grill-me` 的内部指令极其短小精悍:它要求模型像一名极其严格的考官,针对方案的方方面面进行毫不留情的盘问,沿着决策树的每一个分支逐一理清依赖关系,直到双方达成“共同理解”(shared understanding)为止。每次提问只允许抛出一个问题,并且模型必须主动附上自己的推荐选项。Matt Pocock 援引了 Frederick P. Brooks 在经典名著《设计的设计》(*The Design of Design*)中关于“设计概念”(design concept)的论述:在多人协作攻坚新事物时,最核心的资产是在所有人脑海中形成完全对齐的精神构想。
> “I didn't need an asset, I didn't need a plan, I needed to be on the same wavelength as the AI, as my agent. And this is an extremely effective way of doing it.” —— Matt Pocock
- **`grill-me` 核心 Prompt 规则**: 1. 严格针对计划展开不间断的面试盘问,直到达成共识; 2. 沿决策树顺次梳理依赖,一次只问一个问题; 3. 提问的同时,模型必须主动给出自己的倾向性推荐选项。 - **子代理(Sub-agent)的隔离作用**:执行过程中,主 Agent 唤起了一个 Explore 子代理,在 Claude 3 Opus 上快速消耗了 93.7k Token 用于扫描仓库代码。子代理在独立的隔离上下文窗口中运行,最终只将压缩后的核心结论汇报给主调度 Agent(orchestrator agent),从而避免主会话过早滑向“变笨区间”。
---
[18:41](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=1121s) 首轮对齐决策:积分经济学与回溯难题
完成对代码仓库的自动化探索后,`grill-me` 抛出了第一个对齐问题:“积分经济学(Points economy):哪些学员行为可以赚取积分?各值多少分?”同时模型主动附带了它的推荐策略:初期保持架构简单,仅设置两种基础积分来源,并建议直接剔除“观看视频事件”(video watch events),因为视频进度的监听噪音极大且极易被脚本刷取作弊。Matt Pocock 对该推荐完全赞同,明确指出由于 Sarah 的诉求是解决完课率,课程本身的完成动作才是核心主干。
紧接着,AI 抛出了第二个极其尖锐的工程抉择:“积分是否具有追溯性(retroactive)?当前系统中已有大量带有 `completion_at` 时间戳的历史课程进度记录。”这一提问直指数据层面的痛点:平台到底需不需要为了新机制去编写复杂的历史数据回填(backfill)逻辑。
- **积分来源决策**:采纳 AI 的精炼建议,首发版本仅保留两种基础加分动作,坚决过滤掉容易被作弊且打点繁杂的视频播放事件。 - **开发交互姿态**:Matt Pocock 说明在日常工作中他通常借助语音听写(dictation)工具直接与 AI 对话,而非敲键盘;本次因更换了新笔记本且受制于 Windows 系统的语音兼容性,才退回使用手动打字输入。
[19:51](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=1191s) 刨根问底式对齐与历史数据回填决策
在与 AI 进行功能对齐时,系统抛出了一个关键问题:是否要追溯历史学习进度事件(lesson progress events)?Matt Pocock 指出,这类边界问题是确保功能完整交付不可或缺的前提,但在此之前,不管是作为工程师的他自己,还是产品经理 Sarah Chen,都完全没有考虑到这一点。面对是否要回填所有历史数据的问题,Matt Pocock 现场发起了一场举手投票,发现台下许多人处于举棋不定的观望状态(fence-sitters)。考虑到自身处于演示状态,他半开玩笑地表示因为自己偷懒,决定直接接受 AI 给出的建议方案。
```mermaid flowchart TD accTitle: 现实输入转对齐资产工作流 accDescr: 展示从外部会议录音到刨根问底审查再到设计概念资产的转化流程
subgraph Inputs["外部输入采集"] A["领域专家访谈 (如 Sarah Chen)"] B["会议录音/转录本 (Gemini Meetings 等)"] end
subgraph Grilling["刨根问底会话 (Grill Me Skill)"] C["AI 深度审查未明假设"] D["40 到 100 轮交互式追问"] end
subgraph Output["沉淀设计资产"] E["高价值对话历史上下文"] F["严密的功能设计概念 (Design Concept)"] end
A --> B B --> C C <--> D D --> E E --> F ```
这种交互模式的优势在于能够让工程师始终保持在思考回路中(keep in the loop),AI 迅速连续抛出问题,用户根本不需要在等待期间分心去刷社交媒体。针对等级进阶曲线(progression curve)等推导,工程师只需快速确认。Matt Pocock 强调,在实际业务场景中,“Grill Me”技能往往是一场漫长而深度的会话,AI 可能会连续抛出 40、80 甚至 100 个问题,让人坐在屏幕前与 AI 密集讨论一整个小时。最终生成的完整对话历史并非一次性废弃的聊天记录,而是作为新功能设计概念(design concept)的核心输入资产。这种工作流还可以用来转化外部输入:将与领域专家的会议转录文本直接喂给 AI 发起盘问,进而把外界所有模糊的信息源转化为经过严格验证的规范。
- 功能设计盲区:是否追溯历史进度事件(retroactive backfill)是技术方案中极易被忽略的边界条件。 - 交互规模:一次扎实的 Grill Me 盘问会话通常需要 40 到 100 轮问答,持续近 1 小时。 - 资产化价值:长问答沉淀下来的对话历史构成了高质量的设计概念资产。
---
[22:05](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=1325s) 规划技术栈掌控权与 Slido 现场答疑
为了让现场观众动手尝试本地配置,Matt Pocock 开启了互动答疑环节,一边处理场地空调偏热、麦克风收音等现场杂音,一边在屏幕上快速敲定连击积分(streaks are standalone)以及游戏化界面归宿(集成在 dashboard 中)等细节。在 Slido 提问看板上,有观众提问:是否尝试过用 Spec Kit、Open Spec 或 Taskmaster 等现成框架来代替 Grill Me 技能?这些框架到底更冗长还是提供了更结构化的替代方案?
针对层出不穷的新型规划框架,Matt Pocock 阐述了自己的技术哲学:在当前 AI 工程化尚无定论、没有公认唯一标准(no one true way)且技术迭代日新月异的阶段,工程师应当尽可能牢牢掌控自己的规划技术栈(planning stack)。他观察到很多学生过度依赖特定的封装框架,一旦在黑盒中遇到故障,由于缺乏对整个调用链路的可观测性,往往只会抱怨工具难用而无法定位根因。Matt Pocock 明确指出:“I believe in inversion of control and you should be in control of the stack.”(我相信控制反转,你应该牢牢掌握技术栈的主导权。)
- 业务细节落地:明确连击为独立机制(standalone),游戏化 UI 统一收敛至用户仪表盘(dashboard)。 - 技术栈控制权:在行业缺乏既定赢家时,拒绝黑盒框架,保持规划流程的全链路可观测性与控制力。
---
[24:59](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=1499s) AI 时代的结对编程与人机协同分工
针对观众提出的“Grill Me 技能提出的许多问题更适合产品负责人(PO)而非普通开发者,在大型团队中到底该由谁来使用”这一问题,Matt Pocock 借由现场观众对传统结对编程(pair programming)以及 AI 结对编程的举手调查展开了探讨。他认为,与 AI 进行结对编程极具价值,因为 AI 就像房间里第三个不知疲倦、持续发起深度追问的协作者。当遇到业务盲区时,应当由工程师、领域专家和 AI 坐在同一间屋子里对齐;遇到技术实现细节时,则由开发人员与 AI 共同审视,这种模式实质上可以演进为由 AI 催化的群体编程(mob programming with AI)。
谈及人与 AI 在软件工程中的边界划分,Matt Pocock 提出了核心任务二分法:
| 任务类型 | 代表阶段 | 特性与执行方式 | |:--- |:--- |:--- | | **HITL 任务**(Human-in-the-Loop) | 需求规划与假设对齐(如 Grill Me 会话) | **必须有人介入**:涉及复杂利益权衡、业务定位与终局定义,无法通过自动化循环(Ralph loop)代替。 | | **AFK 任务**(Away From Keyboard) | 代码具体实现与测试编写 | **可完全脱离人工**:机器在既定上下文约束下自主编写测试、实现代码并提交,人类离开键盘也不影响运行。 |
Matt Pocock 极其严肃地断言:“Implementation, as we'll see, can be turned into an AFK task. But planning, this alignment phase, has to be human in the loop. Has to be.”(正如我们稍后所见,代码实现可以被转变为完全离开键盘的 AFK 任务;但规划——这个对齐阶段——必须有人在回路中,必须如此。)
---
[27:09](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=1629s) 规划闭环的两大核心文档:终局与路径
由于工作坊演示时间的限制,Matt Pocock 无法在台上耗费数小时逐一回答 AI 的每一个追问,他不得不向 Claude 下达元指令,声明自己正在带领现场工作坊,要求 AI 自行罗列出全部推荐决策以加速推进。与此同时,针对观众问及为何不使用 Claude Code 内置的 `ask_user_question` 交互组件,Matt Pocock 现场演示并吐槽了该原生 UI 存在的诸多体验缺陷,直言虽然自己选用 Claude 作为演示引擎,但在实际方法论体系下,开发者完全可以自由替换任何底层的 LLM 交互系统。
在 AI 自动回答了自身提出的 22 个边界问题后,会话上下文迅速消耗了约 25k tokens。Matt Pocock 强调,这 25k tokens 的多轮问答全都是高价值沉淀(gold tokens)。规划阶段的核心任务就是利用好 Grill Me 技能,明确任务的整体轮廓与交付目的地。要将这一长串盘问结果转变为 AI Agent 可独立执行的任务,必须产出两份不可或缺的核心文档:
1. **记录“终局”(Destination)的文档**:定义系统最终的全貌、详尽的用户故事(user stories)以及清晰的交付完成定义(Definition of Done, DoD)。 2. **记录“路径”(Journey)的文档**:对整体交付进行纵向切分(vertical slice),梳理出推进顺序与任务拆解蓝图。
[30:25](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=1825s) 自动化生成 PRD:将设计共识固化为“终点文档”
在经历需求盘问(Grilling)之后,接下来的练习是将所有讨论出的设计共识总结并沉淀为一份“终点文档”(destination document),即产品需求文档(Product Requirements Document, PRD)。Matt Pocock 指出,PRD 的具体格式或形状因人而异、因团队而异,只要采用自己或公司习惯的模板即可,核心目标是将此前探讨的设计概念完整汇总。
```mermaid flowchart TD accTitle: PRD 生成工作流 accDescr: 展示从输入详细问题描述、自动化多轮访谈,到生成包含测试决策的 PRD 模板流程。
subgraph Phase1["输入与对齐"] A["详细问题描述"] --> B["Relentless 深度访谈 (Grilling)"] end
subgraph Phase2["结构化输出"] B --> C["PRD 模板生成"] C --> D["问题定义与解决方案"] C --> E["18 条 User Stories"] C --> F["实现决策与测试决策"] end ```
在终端中,Matt 直接执行了自定义的 `write a PRD` skill。该技能的执行流程包含: 1. 提示用户提供问题背景的详尽描述(尽管它可以单独运行,但 Matt 强烈推荐在经历充分的 Grill Session 之后再生成); 2. 检查并适配目标代码库; 3. 对用户进行多轮不依不饶的追问访谈(Relentless Interview),再次核对细节; 4. 将讨论结果套用进开源仓库中预设的 PRD 模板中。
该模板包含标准的问题陈述(用户正面临什么困难)、解决方案、一系列用户故事(User Stories,类似 Cucumber 风格或纯手写的故事列表),以及极为关键的“实现决策”(Implementation Decisions)与“测试决策”(Testing Decisions)。
- 调试插曲:在执行生成时,Matt 的 Windows 笔记本弹窗卡顿,引来他一阵自我调侃:“I don't know why I bought a Windows laptop. I think I just I like the challenge.”(我不知道自己为什么买了台 Windows 笔记本,我猜我就是喜欢挑战)。
---
[32:46](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=1966s) 保持对代码的感知:为什么生成 PRD 时必须同步圈定修改模块
PRD 生成过程中,AI 代理首先输出了一份它提议修改的代码模块清单。Matt 强调,这背后有一个极为深刻的系统设计考量:在需求对齐完成、进入编码前夕,绝不能陷入纯粹“脱离代码谈规范”(specs to code)的陷阱。
“This is not specs to code. This is not where we're ignoring the code. We actually keep the code in mind throughout the whole process.” Matt Pocock 如是强调。
AI 代理在分析代码结构后指出:推荐为 `gamification-service`(游戏化服务)编写测试,因为它是整个代码库中唯一包含实质复杂逻辑的深层模块(deep module)。Matt 对此判定表示认可,并确认模块范围无误。
为了便于工作坊演示,该工具会在本地的 `issues` 目录下直接生成 PRD 文本。而在实际生产环境中,Matt 则直接与 GitHub 集成。他展示了自己的核心工作仓库 `github.com/mattpocockuk/course-video-manager`(一款支撑他录制了上千条视频的日常工具),该项目通过这种 AI 流程累计关闭了多达 744 个 Issue,所有 PRD 和后续任务拆解均以 GitHub Issue 形式真实归档与推进。
---
[35:10](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2110s) 为什么不需要肉眼审查生成的 PRD?
PRD 落地后,内容囊括了课程报名流失的问题陈述、解决方案、整整 18 条详尽的用户故事,以及等级经验阈值(level thresholds)等工程决策。Matt 随即向现场观众抛出一个极具颠覆性的问题并要求举手表态:“Should I be reviewing this document? Raise your hand if you think I should be reviewing the documents.”
看到台下有人举手,Matt 明确给出了否定回答:“Yeah, I don't I don't look at these. I don't look at these.”(我不看,我根本不看这些文档)。
他不逐字逐句审阅 PRD 的底层逻辑如下: 1. **测试目标的本质**:审阅 PRD 到底是在测试什么失效模式(failure modes)?大语言模型(LLM)最无可争议、最擅长的底层能力恰恰就是“文本归纳与总结”(Summarization)。 2. **共识已在前期建立**:通过上一阶段严苛的 `grill me` 互动,人类与 AI 已经达成了同频的心智模型(shared design concept)。既然设计共识已经在对话中确立,事后阅读文档实质上只是在反复检验 LLM 的总结表达能力,属于低效消耗。
---
[36:00](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2160s) 现场 Q&A:Claude Code 评价、代码质量与上下文“愚蠢区”(Dumb Zone)
在 PRD 生成完毕后,Matt 开启了 5 分钟的中场问答与休息环节,回应了观众抛出的几个犀利技术问题:
- **对 Claude Code 的真实评价**:面对“如果不喜欢 Claude Code,你更青睐哪款工具”的提问,Matt 引用丘吉尔名言回答:“Have you ever heard the phrase democracy is the worst way to run a country apart from all the other ways? That's how I feel about Claude Code.”(你听过那句话吗?‘民主是除了所有其他方式之外最糟糕的国家治理方式’。我对 Claude Code 也是这种感觉——它毛病很多,但依然是当下最好的选择)。 - **AI 时代深入理解 TypeScript 和底层代码的必要性**:Matt 坚决驳斥了“AI 会修代码,工程师无需懂代码”的论调。他指出坏代码库与差劲 Agent 之间存在必然因果:“Bad code bases make bad agents. If you have a garbage code base, you're going to get garbage out of the agent that's working in that code base.” 只有深厚理解代码结构和工程原则,才能约束并最大化发挥 AI 的能力。 - **100 万(1M)超大上下文窗口在写代码时有用吗?**:Matt 坦言,自己录制 Claude Code 课程时使用的是 200k 上下文窗口,结果课程上线当天官方就宣布支持 1M 上下文。但他警告不要盲目迷信超长上下文,因为模型在长上下文中会出现认知下降: - 超大上下文本质上是厂商向你“交付了更多愚蠢区”(shipped a lot more dumb zone to you); - 这种长窗口非常适合信息检索(Retrieval),比如喂给模型 5 本《战争与和平》去检索特定角色细节; - 但在处理精密、高密度的代码生成(Coding)任务时,超长上下文表现欠佳。Matt 认为目前写代码的“聪明区”(Smart Zone)大约依然维持在 **100k tokens** 左右,未来这个范围会逐步扩大。
---
[39:32](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2372s) Phase 4:将 PRD 拆解为看板依赖任务(Kanban Board)
5 分钟休息过后,工作流推进至第四阶段(Phase 4):**任务切片(Slicing Work into Issues)**。
当前工程师手中已有一份宏观的 PRD 作为终点指南。面对“如何抵达终点且不让模型滑入上下文愚蠢区”的问题,传统的做法往往是一句简单的提示词:“Claude,给我生成一个多阶段达成此目标的计划”。但 Matt 指出,更为系统化、适合 Agent 自主执行的方案是引入**敏捷看板(Kanban Board)机制**。
看板的核心在于将复杂的宏观目标拆散为一组具有明确“依赖与阻塞关系”(blocking relationships)的独立工单卡片。AI 代理根据系统依赖关系,提议将本次需求精准切分为 5 个独立的实施任务(Tasks),以此形成清晰的垂直切片,准备交由编码 Agent 逐一领单执行。
[40:44](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2444s) 拆解任务与识别横向切片陷阱
```mermaid flowchart TD accTitle: Issue Dependency Graph accDescr: 展示根据 PRD 拆解出的任务依赖关系,说明任务之间的前后阻塞关系与可并发性。 subgraph Phase1["第一阶段 (无依赖)"] T1["任务 1: Schema 与 Gamification Service<br/>(类型: AFK, 阻塞: 无)"] end subgraph Phase2["第二阶段"] T2["任务 2: Streak Tracking"] T4["任务 4: Retroactive Backfill<br/>(仅被 1 阻塞)"] end subgraph Phase3["第三阶段"] T3["任务 3: Wire Points & Streaks into Quizzes<br/>(被 1 和 2 阻塞)"] end subgraph Phase4["第四阶段"] T5["任务 5: 最终收尾任务<br/>(被全部任务阻塞)"] end
T1 --> T2 T1 --> T4 T1 --> T3 T2 --> T3 T3 --> T5 T4 --> T5 ```
在审查 AI 根据产品需求文档(PRD)生成的 Issue 列表时,系统展示了清晰的依赖结构:首先是 Schema 和游戏化服务(Gamification Service),该任务没有被任何前置项阻塞,并被明确标记为“AFK”(远离键盘/自主运行模式),意味着人类无需干预,可直接派发给 AI Agent 独立执行;接下来是连续打卡追踪(Streak Tracking);随后是将积分与连续打卡接入课程测验完成流程(受任务 1 和 2 阻塞);历史数据追溯补录(Retroactive Backfill)仅依赖任务 1;而最后的收尾任务则被前面所有任务阻塞。
面对这套看似合理的任务规划,Matt Pocock 提出了一个关键疑问:既然 AI 已经生成了结构良好的工具与任务集,为什么我们不直接全权交给 AI 处理,而是非要人类介入去审查和规划下一步?Matt 的答案是,在完成 PRD 之后,人工审查这步操作极其廉价且迅速,但他一眼就看出了其中的硬伤。现实中的系统存在各种物理或逻辑分层,例如数据库、独立的 API 层、部署在 CDN 上的前端,抑或是代码库内部相互依赖的服务(如测验服务 Quiz Service、团队服务 Team Service、用户服务 User Service、优惠券服务 Coupon Service 和核心服务 Core Service)。
Matt 指出,当前 AI 存在一个严重的默认行为缺陷:“AI 喜欢横向写代码(AI loves to code horizontally)。”它倾向于按架构层逐层推进:第一阶段先把所有数据库和 Schema 全写完,第二阶段再去写所有 API,第三阶段才在最上方搭建前端。Matt 随即向现场观众提问这种做法的弊端,现场观众立刻指出这会导致整个反馈回路被严重拉长。正如 Matt 所强调的,直到进入或彻底完成第三阶段之前,开发者根本无法获得任何关于系统是否端到端正常工作的反馈,底层逻辑从未在集成状态下经历过真实验证。
- 任务类型分类:标记为 AFK 的任务代表无需人类交互介入(Human-in-the-Loop),完全适合委托给自主 Agent 独立运行。 - 代码库现有架构:包含 Quiz Service、Team Service、User Service、Coupon Service、Core Service 等多层服务,层与层之间存在紧密依赖。 - 横向切片的本质风险:按层推进(Schema → API → UI)导致直到最终集成阶段前,所有代码都处于“未经验证的孤立假设”状态。
[43:44](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2624s) 曳光弹(Tracer Bullets)与垂直切片法则
```mermaid flowchart LR accTitle: Horizontal vs Vertical Slicing accDescr: 对比横向分层开发模式与垂直切片(曳光弹)开发模式的路径差异。 subgraph Horizontal["横向切片 (反馈滞后)"] direction TB H1["阶段 1: 仅数据库 / Schema"] --> H2["阶段 2: 仅后端 API"] --> H3["阶段 3: 仅前端 UI"] end subgraph Vertical["垂直切片 / 曳光弹 (即时反馈)"] direction TB V1["切片 1: 最小 Schema + 服务 + 仪表盘 UI 可见"] V2["切片 2: 扩展功能 + 端到端测试"] V3["切片 3: 边缘情况与历史数据回填"] end ```
为了从根本上规避反馈滞后的困境,Matt 引入了来自经典著作《程序员修炼之道》(The Pragmatic Programmer)的核心概念——“曳光弹”(Traceable/Tracer Bullets),即垂直切片(Vertical Slices)。Matt 形象地解释了这个比喻:就像防空炮手在漆黑的夜空中射击,如果发射普通子弹,射手完全不知道弹道射向何方,只能盲目开火;而曳光弹在弹药中混入了荧光物质,每隔几发就能在空中划出一道清晰可见的光迹,让炮手能够即时看到弹道并修正瞄准。在软件工程中,垂直切片正是开发者的曳光弹:通过贯穿系统各个必要层级(数据库、服务、UI)的极薄功能切片,开发者和 AI 能在完成第一阶段时就获得对整个端到端流程的即时反馈,防止 AI 处于“盲写代码”的危险状态。
在 Matt 的工作流中,专门包含一个名为“PRD to issues”的 Skill,其规则明确要求将 PRD 拆解为保存在本地 Markdown 文件中、可被独立认领的垂直切片任务。然而,审查 AI 当前给出的第一版方案时,AI 仍然倾向于在第一个切片中“单独创建游戏化服务(Gamification Service)”。Matt 敏锐地抓出了这个伪装成垂直切片的横向切片:“第一个切片太横向了(The first slice is too horizontal)。”他真正期望看到的第一个切片,必须包含一部分 Schema 变更、新创建的核心服务逻辑,以及在前端界面上的最小化呈现。
Matt 幽默地调侃自己本想把 AI 臭骂一顿(给它一个 rollicking),但随即表示不会浪费 Token 去纯粹情绪化发泄,而是直接向 AI 提出精准反馈:“第一块切片太横向了。”AI 随即调整了规划,将第一个任务修正为:“完成课程后发放积分并在仪表盘上可见(award points for lesson completion visible on dashboard)。”这正是一个教科书式的垂直切片——虽然包含了较多故事点,但它在末端产生了真实可见的 UI 呈现,为后续迭代奠定了牢固的脚手架。Matt 感叹,现代软件工程尝试用英语重新表述最佳实践,而那些二三十年前的经典书籍早已将这些逻辑阐述得极为透彻,堪称构建 Prompt 的宝藏。
> “曳光弹之所以叫曳光弹,是因为它们附带了一点点荧光物质或磷光体,让它在飞行时发光。这意味着大约每六发子弹你就能在天空中看到一条光线,从而获得瞄准的反馈。这就是这里的核心思想:我们提升了反馈水平,对我们所构建的东西获得近乎即时的反馈。因为没有这个,AI 就像在盲目编码,直到进入后期阶段。” —— Matt Pocock
[47:11](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2831s) 现场答疑:调优审讯式提问与放弃极简 Prompt
在等待本地 Issue 文件生成的间隙,Matt 与现场观众展开了互动答疑:
一位开发者提问:“AI 往往会无休止地追问,我们是否有更聪明的方式决定何时停止‘审讯环节’(Grilling Session)?”Matt 承认审讯会非常激烈甚至令人窒息,但这些交互规则都是封装在 Skill 提示词内的。如果开发者频繁遭遇 AI 纠缠不休的失败模式(Failure Mode),完全可以调整 Skill 内部的规则,为它设定明确的停止触发点或强制拉回提问烈度。
另一位观众提到了 Matt 在五个月前分享过的一条知名技巧:“与我对话时,为了极致简洁可以牺牲语法规则(When talking to me, sacrifice grammar for the sake of concision)。”观众询问他现在是否仍在使用这一配置。Matt 现场打开编辑器检查,发现自己现在的全局配置中甚至没有 `Claude.md`。他解释道,当初使用“牺牲语法换取简洁”是为了在 AI 的“规划模式”(Plan Mode)下提升计划的可读性,让输出的计划极短、干练、便于肉眼扫读。
然而,Matt 坦言自己现在已经彻底放弃了这一做法,转而全身心投入“审讯环节”。转变的原因在于,他发现自己根本不想被动去阅读长篇大论或极度压缩的计划文档,他渴望的是与大语言模型(LLM)处于“同一波长”上,需要 AI 用激进、尖锐的提问来主动挑战自己的架构假设。一旦将重心转移到双向推敲并把最终生成的 PRD 视为目标终态文档,开发者就不再需要中间计划刻意压缩成短句了。此外,面对现场关于“未来产品经理(PM)与工程师角色交融对峙”的宏大预测提问,Matt 幽默且干脆地回绝道:“我完全不知道,我又不是行业预言家。”
> “我后来放弃了这个想法,转而偏向于采用审讯环节,因为我注意到自己其实根本不想去读那些计划。我想要的是和大语言模型处于同一个波长上,我希望它向我提出极具侵略性的问题。当我不再去阅读那些计划时,我也就不再需要它们保持极简了。” —— Matt Pocock
[49:31](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2971s) 独立可认领的 Issue 与有向无环图(DAG)并行架构
随着一轮确认与批准完成,系统生成了一批被设计为“可独立认领”(Independently Grabbable)的本地 Issue 文件。Matt 在白板上形象地画出了这类任务的看板流转形态:每一个 Ticket 之间并非单向线性串联,而是具有清晰的依赖与解耦关系。
```mermaid flowchart LR accTitle: Parallel Agent Execution DAG accDescr: 展示将垂直切片任务组织为有向无环图(DAG),利用并发 Agent 在不同阶段并行推进的流水线。 subgraph P1["阶段一 (串行基石)"] A["任务 A (基础垂直切片)"] end subgraph P2["阶段二 (多 Agent 并行推进)"] B["任务 B (Agent 1 认领)"] C["任务 C (Agent 2 认领)"] end subgraph P3["阶段三 (集成与依赖收敛)"] D["任务 D (依赖任务 B)"] end
A --> B A --> C B --> D ```
当任务具备垂直切片和独立认领的属性后,整个任务看板就自然演化成了一个有向无环图(Directed Acyclic Graph, DAG)。在这种架构下: 1. 阶段一:必须优先由单点或特定任务奠定基础。 2. 阶段二:依赖解除后,系统会暴露出多个互不阻塞的独立分支。此时开发者可以真正开启多 Agent 并行开发模式,派出多个自主 Agent 同时抓取各自的 Issue 并发编码。 3. 阶段三:后续依赖这些分支的任务再依次收敛合并。
Matt 向现场调查有多少人曾经尝试过 Agent 的并行化工作流,并强调:只有通过科学的垂直切片将复杂 PRD 拆解为具备 DAG 依赖拓扑的 Issue 集,才能在真正意义上释放 AI Agent 团队的吞吐量,将单线等待彻底改造为高效的流水线并发作业。
[50:51](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=3051s) 看板式并行与离线执行架构的设计
Matt Pocock 阐述了将需求切分成看板模式(Kanban board)而非传统顺序执行计划(sequential plan)的核心技术考量。在顺序计划中,各个步骤被标注为有序的阶段(如第一阶段执行顶部任务,第二阶段处理其下的两个任务,第三阶段再叠加后续内容),这种带有阶段编号的线性流程本质上只能绑定一个循环(loop),这意味着只能由单个智能体按部就班地操作。相反,看板结构的解耦设计支持多条分支计划同时推进,为未来由多智能体协同提供极佳的并行化能力(parallelization)。
```mermaid flowchart TD accTitle: 规划与执行的昼夜交替架构 accDescr: 展示从想法、PRD到看板任务的日班流程,以及交由自主智能体完成的夜班离线执行架构。
subgraph DayShift["日班(人工评审与规划)"] A["原始想法 (Idea)"] --> B["严苛问询 (Grill Session)"] B --> C["目标文档 (PRD)"] C --> D["看板任务 (Kanban Issues)"] end
subgraph NightShift["夜班(AI 离线执行 AFK)"] D --> E["任务抓取与优先级排序"] E --> F["测试驱动开发 (TDD)"] F --> G["反馈循环验证与提交"] end
DayShift -.->|"交接进入离线状态"| NightShift ```
在现场演示生成 Issue 时,系统误尝试将任务推送到 GitHub 上,Matt Pocock 及时叫停并修正指令,要求其在本地 Markdown 文件中创建 Issue,明确引用本地版本。以此为节点,工作流正式完成从人工设计到全自主执行的交替。Matt Pocock 梳理了前置全貌:从最初构思(Idea)、严苛质询(Grill Session)、形成产品需求文档(PRD),再到拆解为看板任务,所有环节均由人类主导并经过审查;一旦推进至实现阶段,人类便完全退出循环(leave the loop),将积累的待办工作交给自主智能体运作。
- 顺序规划(Sequential Plan)受制于依赖关系,仅能由单个智能体通过单循环逐步执行。 - 看板模式(Kanban Setup)能够将任务解耦,允许多个智能体在不同任务分支上实现高并发作业。 - Matt Pocock 形象地将这种工作机制概括为白班与夜班的配合:“This is the day shift for the human, right? Planning everything, getting all the stuff ready. And then once we kick it over to the night shift, the AI can just work AFK.”
---
[53:42](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=3222s) 离线智能体运行机制:Ralph 循环与本地脚手架
进入实际操作阶段,Matt Pocock 演示了名为“Ralph”的自主循环执行器(Ralph loop)。为了展示其工作机理,他详细解析了本地脚本 `once.sh`。该脚本负责为 Claude 运行时装配初始上下文:首先通过 `cat` 命令读取本地 `issues/` 目录下所有的 Markdown 任务描述,塞入名为 `issues` 的本地变量;随后抓取最近 5 次的 Git 提交记录以便提供代码演进上下文;最后以 `accept-edits` 的权限模式运行 Claude Code,促成无交互的连续代码编辑。
相较于直接单次运行的 `once.sh`,生产环境下的纯离线执行(AFK)在 Docker 沙箱环境中以循环方式反复触发。出于保障现场大会 Wi-Fi 带宽的考虑,Matt Pocock 并未让现场参会者下载庞大的 Docker 镜像,而是亲自做运行演示。他强调,在放手让 AI 完全脱离人工之前,频繁使用 `once.sh` 观察智能体的动作路径并对 Prompt 进行针对性微调至关重要。
- 上下文注入机制:脚本动态搜集所有本地 Issue 文件,并提取 `git log -n 5`,让智能体理解当前工程状态与近期变更。 - 自动化权限模式:通过对 Claude Code 赋予自动接受代码修改(accept edits)的权限,免除单次执行中的人工确认敲击。 - 人工在环排查价值:反复手动运行单次脚本能够暴露 Prompt 的缺陷与逻辑盲点,为纯离线运行建立可靠基石。
---
[56:06](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=3366s) 任务调度策略与现场实测
在 Ralph 循环的核心 Prompt 中,内置了智能体在无人值守时选取任务的优先逻辑。当系统确认有待办工作时,若所有 AFK 任务均已完毕,它会主动输出任务清空标志;而在常规轮询中,它会依序优先挑选“关键 Bug 修复(critical bug fixes)”、“开发基础设施支撑(development infrastructure)”、“贯通式垂类切片(tracer bullets)”,最后才是“界面润色、微小改进与代码重构(polishing quick wins and refactors)”。智能体锁定任务后,必须按照“仓库探索”、“TDD 编写测试驱动开发”以及“执行反馈闭环”三步完成闭环。
```mermaid flowchart LR accTitle: 智能体任务选取优先级 accDescr: 展示离线智能体在没有人工干预时自动拣选任务的优先级阶梯。
P1["1. 关键 Bug 修复"] --> P2["2. 基础设施建设"] P2 --> P3["3. 贯通式切片 (Tracer Bullets)"] P3 --> P4["4. 润色与重构 (Refactors)"] ```
随后,Matt Pocock 在终端内敲下 `Ralph once.sh` 命令正式触发流程。屏幕上 Claude 瞬间开始解析传入的上下文与任务描述,自动展开测试套件与代码编写。
- 任务拣选排序保证了核心骨干系统和阻断性缺陷优先于边角需求完成。 - 任务执行强制绑定测试驱动开发(TDD)规范,利用测试结果作为核心客观验证手段。
---
[57:56](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=3476s) 现场问答:负向决策留存、代码审查膨胀与团队协同
在智能体自主编码的间隙,现场参会者通过 Slido 及举手形式抛出一连串现实工程问题。针对“在经历了严苛问询后,那些被否决的方向与论据(negative decisions)如何持久化留存”,Matt Pocock 解释称,在 PRD 模板的尾部专门设有“超出范围(out of scope)”区块,清晰列出本次迭代绝不涉及的内容,这对于锁定“完成的定义(definition of done)”具有决定性作用。
随后现场探讨了最尖锐的痛点:“当智能体疯狂产出代码,人类的代码审查(Code Review)能力被严重击穿怎么办?”Matt Pocock 邀请现场感到现在审查工作量显著增加的开发者举手,台下纷纷响应。他坦率承认,当人类把编码全盘托付给 AI 时,编码之外的人工审查与质检(QA)是不可避免的关卡。如果让 AI 一口气冲完 4 个 Issue,这与软件工程中倡导的“小而自闭合的 PR(small self-contained PRs)”理念产生严重冲突;而如果是堆积成山的分支 PR(stacked PRs),审查体验同样令人痛苦。面对这种矛盾,Matt Pocock 直言:“I don't honestly know what the answer to this yet. I think we just need to be ready to be doing more code review, essentially.”
面对另一位参会者关于“单人线性推进模型如何应对真实团队中需求并行、插单 Bug 以及信息割裂等复杂混乱(messiness)”的提问,Matt Pocock 指出,从最初模糊概念到确定目的地的整个规划上半场(想法质询与 PRD 撰写),本质上就是必须由团队全员协作对齐的场景,正是通过这些前置讨论来消化外界变化与混乱度。
- 负向决策机制:通过在 PRD 显式设立 Out of Scope 章节,防止智能体在无人监管时出现范围蔓延(scope creep)。 - 开发者职能重心转移:AI 并未消灭工作总量,而是将工程精力从敲击实现代码大规模转向架构审查与 Pull Request 验收。 - 真实团队适应性:前期对想法的反复“烤问”并非单人自嗨,而是把团队的隐性知识与协同共识固化成智能体可执行资产的必要过程。
[01:01:22](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=3682s) 原型设计与团队反馈循环
在将模糊想法推导至正式的产品需求文档(PRD)的过程中,不可避免会遇到无法仅凭个人经验解答的疑问。Matt Pocock 强调,在这一阶段必须积极拉入团队协作。开发人员常常需要迅速构建一个可供领域专家亲自上手试验的原型,或者调研并试用第三方库与云服务。收集到的所有信息与经验都会反哺回早期的构思阶段。整个直到输出 PRD 的旅程,都依赖跨团队共享文档资产与发起意见征求(RFC),这是一个持续研磨的循环过程。只有彻底明确了技术与产品方向,团队才能正式进入看板式的敏捷任务实施阶段。
针对现场观众提问“构建原型本身是否也需要先写一份 PRD”,Pocock 给出了否定答案。他特别以对人眼极其敏感的前端开发为例:前端是一个天然的多模态领域,但现有的 AI 缺乏真正的“眼睛”。尽管可以通过接入 Headless Browser、Agent Browser 或 Playwright MCP 等工具给 AI 赋予查看截图与解析 DOM 的能力,但实际体验表明,目前的 AI 依然无法在成熟复杂的代码库中直接生成优雅、健壮的前端界面。高效的做法是让 AI 在一次性路由(throwaway route)上快速抛出两到三个可交互的粗糙原型方案,由人类工程师点击对比以判断最佳视觉与交互路径。这种粗糙而快速的原型,核心价值在于尽早在流程前期拿到真实反馈,从而为后续的 PRD 细化或质疑会(Grill Session)提供依据。
```mermaid flowchart TD accTitle: 前端原型与需求循环流程 accDescr: 展示从想法、多方案原型、人类评估到反馈循环的迭代过程。
subgraph Exploration["探索与原型阶段"] A["初始想法 / 未决问题"] --> B["AI 快速生成 3 种粗糙原型"] B --> C["临时路由 / Throwaway Route 测试"] end
subgraph Feedback["团队评估与回流"] C --> D["领域专家与人类工程师试用"] D --> E["回流至质疑会 (Grill Session)"] E --> A D --> F["达成明确方向,输出最终 PRD"] end
subgraph Execution["工程实现阶段"] F --> G["看板拆解与 Agent 落地实施"] end ```
- 原型的本质是快速、粗糙的验证载体,绝对不需要事前为它编写复杂的 PRD。 - “前端界面天然是多模态的(Front end is multimodal),AI 缺乏真正的审美眼睛”,给它装上 Playwright MCP 等浏览器工具,仍难以在成熟代码库中直接吐出合乎标准的高质量前端代码。 - 应对架构规范、API 契约和安全合规限制的提问,Pocock 表示将在后续专门讲解系统化约束代码库的架构方案。
---
[01:04:44](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=3884s) 智能区与愚蠢区:清除上下文的自动化审查
现场有观众提问:“为什么不让 AI 去做全套 QA,自己测试自己的代码?”Pocock 解释道,AI 绝对应该参与自动化审查,但这必须依赖合理的上下文管理机制。在实施阶段,AI 编写完代码后应当立即执行一次自动化代码审查(Automated Review Step),因为 Token 的成本足够低,且大模型在代码审查方面表现异常出色,能够在人工介入前捕捉到大量隐蔽 Bug。
然而,审查机制能否成功取决于它所处的“智商区域”。Pocock 现场画图分析了 LLM 的上下文衰减现象:如果让执行代码生成的同一个 Agent 会话直接继续进行审查,此时该会话在生成代码的过程中已经消耗了大量 Token,从模型推理能力充沛的“智能区”(Smart Zone)掉落到了因上下文过长而出现信息漂移和逻辑混乱的“愚蠢区”(Dumb Zone)。这会导致“审查者比编写者还要愚蠢”。正确的做法是在代码生成结束后清空会话上下文(Clear the context),让审查 Agent 拿着干净的上下文本重新在“智能区”中运行,以此保证审查的严谨性与发现缺陷的能力。
```mermaid flowchart LR accTitle: 上下文窗口管理对审查能力的影响 accDescr: 对比连续上下文导致审查落入愚蠢区,与清理上下文保持在智能区的两种模式。
subgraph DepletedContext["错误模式:连续上下文"] A1["代码实现阶段<br/>(智能区 / Smart Zone)"] -->|"消耗大量 Token"| A2["同一会话继续审查<br/>(愚蠢区 / Dumb Zone)"] end
subgraph FreshContext["推荐模式:清理上下文"] B1["代码实现阶段<br/>(智能区 / Smart Zone)"] -->|"清空上下文 / Reset"| B2["独立审查会话<br/>(重回智能区 / Smart Zone)"] end ```
- 当模型上下文窗口被生成过程的日志与历史堆满时,推理能力显著下降,在“愚蠢区”执行审查往往流于表面或错过核心缺陷。 - 引入单独的审查步骤能够拦截绝大部分基础语法、逻辑与边缘用例疏漏,有效为人工 QA 减负。
---
[01:06:42](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4002s) TDD:测试驱动开发在 Agent 编码中的核心地位
在后台实施 Agent 自动生成数据库迁移文件并推进第 2 号任务时,Pocock 重点解析了贯穿其工作流的基石技术——测试驱动开发(TDD)。Pocock 在代码库中嵌入了专门的 Skill 提示词,教会 AI 严格遵循经典“红-绿-重构”(Red-Green-Refactor)的开发闭环:AI 必须首先根据拆解出来的最小逻辑单元编写一个明确失败的测试(Red),确认断言失败或模块缺失后,再编写业务实现代码让该测试通过(Green),最后进行结构优化(Refactor)。现场演示中,Agent 启动已有的测试环境初始化数据库,如预期般因缺少业务逻辑模块运行失败,成功确认处于 Red 状态。
Pocock 指出,大部分工程师都经历过 AI 写出垃圾测试(Bad Tests)的惨痛教训。当 AI 被要求“在写完整体实现之后再补测试”时,它往往会在实现层之下敷衍地糊上一层表面的单元测试,甚至故意弱化断言以使测试通过,本质上是在测试上作弊。而通过严格执行 TDD,AI 被迫在动任何业务逻辑前先把规范和约束写死在测试中,大大杜绝了作弊空间。Pocock 强调,TDD 对 Agent 提效的作用是如此巨大,以至于他“彻底重构了整套开发体系以全力配合 TDD 运转”。
> “使用这种技术,它作弊的难度会高得多,因为它是在编写实际代码之前就对代码进行了度量与约束。” —— Matt Pocock
- 传统的“后补测试”会导致 AI 依据已写好的代码缺陷去反向适配测试,产生无效测试。 - 红-绿-重构流程让 AI 在每一个编码步骤中都有极短、明确的验证目标。
---
[01:08:41](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4121s) 交付可验收垂直切片与反馈回路的天花板效应
在短暂休息并与后台运行的 Agent 交互(允许其执行 `npx vitest` 测试命令)之后,Ralph 循环顺利收敛并自动提交了代码。屏幕上展示出了本次任务(Issue #02)完成的简要汇总,并在仪表板(Dashboard)层级完成了端到端实现。因为前期严格落实了追踪弹(Tracer Bullets)的垂直切片拆分原则,每一项独立任务完成时,系统都留下了一个真正能够直接启动、人工验收的完整功能切片。
Pocock 指出,Agent 在提交之前自动跑通了所有测试与类型检查(Feedback loops)。他着重强调:在 AI 时代,工程反馈回路就是 AI 编码能力绝对的天花板。代码库如果缺乏即时的类型检查、测试管道和自动化校验,AI 就相当于完全“盲写代码”(Coding blind)。如果开发者发现 AI Agent 总是写出质量低劣、无法运行的代码,最根本的原因往往不是模型的提示词不够花哨,而是代码库底层的自动化反馈回路质量太差。提升 AI 输出质量的第一法则,是提升工程系统提供确定性反馈的能力。
> “如果你的代码库没有反馈回路,你永远永远都不可能从 AI 那里获得体面的输出。……那是一道硬天花板:如果你从 AI 获得的代码很差,你通常需要提高反馈回路的质量。” —— Matt Pocock
- 追踪弹策略保证了 Agent 产出的每一个 Commit 都包含完整垂直切片,随时可进行人工 QA。 - 反馈回路主要由自动化测试套件与静态类型系统(如 TypeScript、Vitest)构成,为模型提供立即可观测的运行依据。
[01:10:35](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4235s) 测试通过、代码审查与人工 QA 的必要性
智能体在终端中先后执行了 `npm run test` 和 `npm run typecheck`。虽然中途出现了一个类型错误,但它通过巧妙的 TypeScript 类型技巧(如提取 `typeof LEVEL_THRESHOLDS`)自行修复了问题。看到这一幕,Matt Pocock 忍不住开玩笑说:“你们看明白我为什么不再教 TypeScript 了吧,因为现在的 AI 什么都懂。”至此,测试套件全部跑通,仓库中的测试总数达到了 284 个。
在前端开发中,纯界面往往极难进行自动化单元测试,因此这里的策略是主要测试核心服务层(Service Layer)。智能体创建了一个独立的游戏化服务(`gamification-service`)以及对应的测试用例。Matt 强调了自己的代码审查逻辑:进行 Code Review 时,必须先看测试代码,确认测试覆盖的场景是否合理,然后再去审视具体的业务实现,确保没有做出任何出格的逻辑。
```mermaid flowchart TD accTitle: 代码审查与质量把控流程 accDescr: 展示了从智能体自动化运行测试到开发者人工测试与审查的完整过程。
subgraph Agent["智能体自动化交付"] T1["运行测试与类型检查"] --> T2["自动修复类型错误"] T2 --> T3["284 个测试全部通过"] end
subgraph Review["人工把控与验证"] R1["第一步:审查测试用例"] --> R2["第二步:审查业务代码"] R2 --> R3["第三步:人工手动 QA 操作"] end
Agent --> Review R3 --> F1["捕捉运行时缺陷 (如 SQLite 表缺失)"] F1 --> F2["将品味与设计标准回注系统"] ```
随后,Matt 启动本地应用,试图以学生账号(Emma Wilson)登录系统进行真实的手工 QA。在点击进入课程、继续学习并完成一个课时后,界面抛出了一个 SQLite 数据库报错,提示缺少 `point_events` 数据表。这说明数据库迁移尚未执行(需要运行相应的数据库迁移或推送命令),同时也暴露了智能体在命名数据表时选择了一个略显怪异的名称。Matt 随即指出,手工 QA 虽然在演示时看起来枯燥,但却是整个闭环中绝不可省略的关卡。
- 仓库测试规模:通过本次新增的游戏化服务测试,整个仓库的自动化测试数量达到了 284 个。 - 运行时报错:学生端完成课时时抛出 SQLite 错误,根源在于尚未执行数据迁移创建 `point_events` 关联表。 - 自动化与品味的矛盾:“如果你试图将创意构思、QA、研究、原型全部自动化,最终做出的应用在我看来只会缺乏品味,沦为劣质品。”Matt Pocock 强调,“在构建这些系统时,你离不开人的参与;失去人的触觉,你最终得到的就只是一堆数字垃圾(slop)。”
---
[01:13:39](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4419s) 混乱代码库的死局:浅模块与碎片的测试边界
在演示完实际功能后,Matt 转向了大家普遍面临的现实痛点:如果手头接手的是一个架构极其混乱、依赖错综复杂的糟糕代码库,AI 往往无法在此类环境下写出好代码,甚至连人类工程师在里面也束手无策。针对如何改造这一局面,Matt 引用了 John Ousterhout 在经典著作《软件设计的哲学》(*A Philosophy of Software Design*)中提出的核心理念:浅模块(Shallow Modules)与深模块(Deep Modules)的对比。
所谓的“糟糕架构”,通常充斥着大量浅模块。在这类代码库中,系统被拆解成无数零碎的小文件,每个文件只做一丁点事情,却向外暴露出大量的接口和导出项。模块之间互相强耦合,依赖网错综复杂,宛如一团乱麻。
```mermaid flowchart LR accTitle: 浅模块架构的问题 accDescr: 浅模块由大量琐碎文件和复杂依赖组成,测试边界难以界定且易导致过度 Mock。
subgraph ShallowArchitecture["浅模块架构 (Shallow Modules)"] A["小模块 A<br/>(细粒度导出)"] B["小模块 B<br/>(细粒度导出)"] C["小模块 C<br/>(脆弱的调用方)"] A --> C B --> C end
subgraph TestingDilemma["测试困境"] T1["细粒度单元测试<br/>(大量 Mock 依赖)"] T2["调用时序或组合失效<br/>(难以端到端覆盖)"] end
ShallowArchitecture -.-> TestingDilemma ```
这种碎片化架构对 AI Agent 而言是极大的灾难: 1. **依赖图谱过大**:AI 难以推断模块之间的层级关系,不得不逐个遍历跟踪整张依赖图,极易在上下文窗口中迷失。 2. **测试边界模糊**:如果为每一个微小函数都画上单独的测试边界,测试就会沦为毫无价值的浅层单元测试。 3. **Mock 泛滥与时序风险**:一旦上层模块依赖了两个下层细碎模块,下层函数调用顺序颠倒或内部逻辑稍有变动,单测就无法捕捉异常;而若想测试上层,开发者又必须写出大量极其别扭的 Mock 代码。
Matt 总结道:“如果我们的代码库易于测试,我们的反馈循环就会更高效,AI 在我们代码库里的表现也就会更好。”
---
[01:16:55](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4615s) 打造深模块:在 AI 时代掌控代码库认知负载
针对浅模块的缺陷,Matt 展示了优秀代码库应当具备的模型——深模块(Deep Modules)。深模块的特征是具有极其简洁小巧的对外接口(Small Interface),但在内部却封装了大量丰富的逻辑与功能(A lot of functionality inside)。
```mermaid flowchart TD accTitle: 深模块架构与测试模型 accDescr: 深模块具备简洁的小接口和厚重的内部实现,外层包裹着稳固的端到端测试边界。
subgraph DeepModule["深模块 (Deep Module)"] I["简洁调用接口 (Interface)"] subgraph Internal["厚重内部实现 (Hidden Logic)"] F1["核心业务规则"] F2["状态转换与计算"] F3["数据存取细节"] F1 --> F2 --> F3 end I --> Internal end
TestBoundary["大测试边界 (Test Boundary)"] TestBoundary -.->|"覆盖完整功能路径"| DeepModule ```
深模块对于 AI 协作具有颠覆性的优势:调用方只需面对极简的契约,测试时开发者只需在深模块的外部边界套上一个完备的测试用例,就能稳定捕获其内部大量功能的行为变化。如果不对 AI 施加严格的设计引导,未经约束的 AI 生成的代码往往会自动滑向细碎松散的浅模块泥潭。
因此,在编写 PRD(产品需求文档)时,必须提前锁定系统的模块蓝图。Matt 回溯了 PRD 中的架构定义部分:文档中白纸黑字地将 `gamification-service` 明确定义为一个全新的“深模块”,规范好它的暴露接口,同时指明它需要联动修改进度服务(Progress Service)、课程路由(Lesson Route)以及仪表盘路由(Dashboard Route)。在整个规划与实现流程中,工程师脑海中必须时刻保有这幅模块全景图。
在演讲尾声,Matt 倒了一杯水,向在场听众抛出了两个触及灵魂的问题: - “如果你觉得在有了 AI 之后,自己比以往任何时候都干得更辛苦,请举手。”(台下纷纷举手) - “如果你觉得相比过去,你对自己代码库的熟悉程度反而变低了,请举手。”(台下同样大面积举手)
Matt 直言,伴随 AI 带来的高交付速度,工程师开始大范围让渡控制权,进而逐渐丧失了对代码整体骨架的把握;如果不加遏制,代码的形态终将被完全委托给 AI。要摆脱这种认知过载与失控感,唯一的解法就是由人类负责把控模块边界与宏观架构:“我认为大家应该做的是,为这些模块设计接口,然后把具体的实现委托出去。”通过定义顶层接口并由 AI 负责细节填充,工程师才能在解放生产力的同时,牢牢守住软件架构的护城河。
[01:20:28](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4828s) 深模块与“灰盒”委托:在 AI 时代保全工程心智
Matt Pocock 继续深入阐述深模块架构(Deep Modules)对开发者心智负荷的解脱。他将这些深模块比喻为“灰盒”(gray boxes):作为人类工程师,你只需要清晰地知道它们的外部形状、职责边界以及在特定条件下的行为表现,至于模块内部的具体代码实现,完全可以直接委托给 AI Agent。他直言这种协作方式极具舒适感,自己根本不需要去逐行 Code Review 模块内部的每一处细节,只要确保接口和行为契约成立即可。
```mermaid flowchart LR accTitle: 灰盒架构与委托开发模型 accDescr: 展示人类工程师仅把控顶层架构与外部接口,模块内部实现委托给 AI 编写并测试。 subgraph Mindset["工程师心智视图"] A["顶层全景架构<br/>(System Overview)"] --> B["精简的外部接口<br/>(Interface & Shapes)"] end subgraph DeepModule["深模块 (灰盒实现)"] B --> C["端到端黑盒/灰盒测试"] C -.-> D["由 AI Agent 委托生成的<br/>复杂内部实现"] end ```
这种架构模式的核心收益在于:工程师掌控全局架构脉络,而让 AI 处理脏活累活。Matt Pocock 总结道:“I found that has been a really nice way to retain my sense of the code base while preserving my sanity.”(我发现这是一种既能保持对代码库掌控感、又能保全自己理智的绝佳方式。)
- **灰盒思维**:只定义模块外部契约与验证条件,内部逻辑全部委托给 AI 自动生成。 - **免于微观审查**:由于外部行为有严密测试守护,开发者无需被迫成为 AI 每一行生成的语法审查员。
---
[01:21:12](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4872s) 架构重构技能实战:浏览器端视频编辑器的“端到端深模块”
面对如何将薄模块(Shallow Modules)代码库重构为深模块架构的疑问,Matt Pocock 演示了一个专门的工作流技能(Skill)——`improve codebase architecture`。该技能的设计初衷是让 Agent 扫描整个代码库,自主探索现有架构结构,并找出可以进一步加深模块化程度的薄弱环节。现场观众也被鼓励在自己的练习项目中同步运行该技能。
Matt Pocock 分享了他在开发自己的课程视频管理应用(Course Video Manager)时的真实案例。该应用内置了一个完全运行在浏览器中的视频编辑器,工程复杂度极高。在此之前,AI 每次改动该模块都极易破坏逻辑;后来他借助该架构技能,将从前端 UI 到后端持久层的全链路收拢进一个巨型复合模块中,并通过 TypeScript 的可辨识联合(Discriminated Union)将两端类型绑定,让模块仅对外暴露出一个可测入口。
这种重构带来的成效是立竿见影的。Matt Pocock 惊叹道:“And honestly, it was just night and day in terms of the ability of AI to actually make changes, cuz AI working on a video editor is pretty brutal if you don't give it good tests.”(老实说,在 AI 做出实际修改的能力上,这简直是天壤之别,因为如果不给它完备的测试,让 AI 去改视频编辑器简直是场灾难。)他向全场建议,如果当天只能带走一个收获,那就把这个架构技能在自己的代码库里跑一遍。
---
[01:23:09](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4989s) 文档腐烂陷阱与“用完即扔”的 PRD 生命周期
在等待架构技能扫描执行期间,Matt Pocock 转到 Slido 提问看板,并挑出了一个核心问题:“功能实现后,是否应该在仓库中保留 Markdown 格式的需求文档(PRD)和任务规划?”他在现场发起举手调查,发现部分人倾向永久留存作为资产,另一部分人则希望立刻清理。
Matt Pocock 坚定地站在“清除派”一边,并详细解释了原因——**文档腐烂(Doc Rot)**。他指出,如果把 PRD 留在代码库里,一个月后开发者想对同一模块做二次修改,Claude 或其它 Agent 很可能会检索到这份陈旧的 PRD 并将其当成事实源(Source of Truth)。但此时,实际代码往往早就脱离了最初的方案,文件路径重组、函数重命名乃至需求本身都已天翻地覆,过期的 Markdown 文档只会对 Agent 产生灾难性的误导。
```mermaid flowchart TD accTitle: 文档腐烂对 Agent 的误导风险 accDescr: 说明残留的历史 PRD 如何随时间腐烂,并导致 AI Agent 产生幻觉与错误实现。 A["初始阶段:完成 PRD 并交付代码"] --> B["代码库持续演进:重构 / 重命名 / 迭代"] B --> C["历史 PRD 未同步更新<br/>(产生 Doc Rot)"] C --> D["后续任务中 AI 检索到过时 PRD"] D --> E["AI 产生错误认知与幻觉<br/>执行错误指令"] ```
Matt Pocock 强调,在自己的真实工作流中: - 一旦功能在 GitHub Issues 中交付完毕,他便直接将其标记为 Closed,而不是在代码目录里永久留存 Markdown 说明书。 - GitHub 闭合的 Issue 依然留存历史痕迹,Agent 若有硬性需求仍可调取,但明确的“Closed”状态能向 Agent 发出强信号:该文档属于过去,不代表现状。 - 现场有观众联想到数据库迁移文件(Migrations)是否也需要合并压制(Squash),Matt Pocock 坦言迁移历史是确定性的执行增量日志,与文档腐烂机制不完全相同,二者性质有所差异。
---
[01:26:11](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=5171s) 过度打磨计划的边际递减效应
现场观众提出疑问:是否应该使用具备深度思考能力(Deep Think / 类似 OpenAI o1、ChatGPT 思考模式)的模型,在早期规划阶段花上一个小时反复打磨和优化 PRD,直到无懈可击?
Matt Pocock 明确表示并不推崇这种做法。他解释称,在前期阶段试图无休止地追求“完美 PRD”收益极低。PRD 和旅行目的地文档的本质只是给开发指明大方向的粗粒度指引(Journey hints),把过多的工程精力耗费在纸面方案的过度微调上,往往得不偿失。真正的核心工作量应当分配给下游的自动化 QA 与测试防护网。只要在最初的“严审问答”(Grilling Session)环节与 AI 达成了共识对齐,粗粒度的路线图就已经足够支撑后续的垂直切片开发。
---
[01:27:40](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=5260s) 编码规范的 Push 与 Pull:实现期与审查期的分离
针对观众关于“如何在工作流中强约束 Agent 遵循个人喜好的编码风格与三方库选用”的问题,Matt Pocock 提出了 **Push(推)** 与 **Pull(拉)** 的工程规范控制体系。
| 机制类型 | 交互本质 | 典型载体 | 适用角色与时机 | |:--- |:--- |:--- |:--- | | **Push(推)** | 将硬性提示词强制注入到上下文窗口中,消耗 Token 预算 | `CLAUDE.md`、系统提示词(System Prompts) | **Automated Reviewer(自动审查 Agent)**:在审查代码时注入,比对代码与规范差异 | | **Pull(拉)** | 仅保留轻量描述头部,由 Agent 视需要主动按需读取完整规则 | 存放于仓库中的 Skills / 规则文档库 | **Implementer(执行/编写 Agent)**:在遇到不确定的特定技术选型时按需加载,避免干扰上下文 |
```mermaid flowchart LR accTitle: 编码规范的 Push 与 Pull 架构 accDescr: 展示实现者 Agent 按需拉取规范,而自动化审查 Agent 被强制推入规范进行比对。 subgraph Dev["实现阶段 (Implementation)"] Imp["Implementer Agent"] Skills["编码规范库 / Skills"] Skills -.->|"Pull: 遇到疑问按需加载"| Imp Imp --> Code["生成的 PR / 代码变更"] end subgraph Review["审查阶段 (Review)"] Code --> Rev["Reviewer Agent"] Standards["编码规范规则集"] -->|"Push: 强制注入上下文"| Rev Rev --> Verdict["审查反馈 / 规范遵从结论"] end ```
Matt Pocock 强调,在代码编写阶段(Implementer),切忌盲目把所有的规范一股脑推给 Agent,而应让规范作为 Skills 处于 Pull 状态,保持写代码时的上下文精简专注;而到了后续的代码审查阶段(Reviewer),则必须采取 Push 策略,将所有的团队编码规范全量推送给 Reviewer Agent,令其对照规范对生成的代码进行严格扫描与把关。
[01:29:47](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=5387s) Sandcastle:基于 TypeScript 的离线并行 Agent 运行架构
趁着思路清晰,Matt Pocock 介绍了自己最近花了一周左右时间构建的开源工具——**Sandcastle**。之所以要亲自写这个工具,是因为他对市面上现有的离线(AFK, Away From Keyboard)自动化运行 Agent 的方案感到很不满意。Sandcastle 本质上是一个用于驱动自动化循环的 TypeScript 库。在底层设计中,它通过一个 `run` 函数创建 Git worktree,并将其严格隔离在 Docker 容器构建的沙箱环境中,接着在容器内运行指令 Prompt。每个 worktree 本身就是一个独立的 Git 分支,不仅代码完全隔离,还能轻松并行化管理并在后续阶段按需合流。
```mermaid flowchart TD accTitle: Sandcastle 并行运行循环流程图 accDescr: 展示 Planner 分析待办并分发分支,在 Docker 沙箱中并行 Implement,经 Reviewer 评审后由 Merger 解决冲突并合入主线的全过程。
subgraph Planning ["任务规划阶段"] A["待办任务 Backlog / 看板"] -->|"分析依赖与阻塞关系"| B["Planner Agent"] end
subgraph SandboxExecution ["并行沙箱执行"] B -->|"Issue A + 分支"| C1["Docker 容器沙箱 A"] B -->|"Issue B + 分支"| C2["Docker 容器沙箱 B"] C1 -->|"运行实现 Prompt"| D1["Implementer Agent"] C2 -->|"运行实现 Prompt"| D2["Implementer Agent"] end
subgraph VerificationMerge ["评审与合并阶段"] D1 -->|"提交 Commit"| E1["Reviewer Agent"] D2 -->|"提交 Commit"| E2["Reviewer Agent"] E1 --> F["Merger Agent"] E2 --> F F -->|"解决类型与测试冲突"| G["合并入主分支"] end ```
打开 `main.ts` 入口文件后,Matt 详细拆解了如何将此前展示的单向顺序循环升级为多 Agent 并行执行: 1. **规划器(Planner)**:运行一个专门的 `plan prompt`,读取积压的待办列表(Backlog),梳理前面看板中确立的所有依赖和阻塞关系(Phases),精准挑选出一批可以同时启动的 Issue,为每个 Issue 分配编号、标题以及专属 Git 分支。 2. **实现器(Implementer)**:针对每个 Issue 分别启动一个独立的沙箱环境,传入 Issue 元数据与分支名,在容器内自主跑循环并生成 Commit。 3. **评审器(Reviewer)**:检查每个沙箱内生成的 Commit 是否达标。 4. **合并器(Merger Agent)**:集中接收所有产出分支与对应 Issue,运行 `merge prompt` 执行自动化合流。如果合并时遇到类型报错或测试失败,Merger Agent 会自动定位并就地修复冲突。
Matt 进一步针对观众提问解答了代码规范的注入时机以及底层模型的选型分工:“And to answer your question properly is that in the reviewer I would push the coding standards. In the implementer, I would allow it to pull.” 他在实现阶段(Implementer)使用成本更低、反应敏捷的 Claude 3.5 Sonnet,而在审查阶段(Reviewer)则专门换用推理能力更强的 Claude 3 Opus,因为代码审查容不得半点敷衍,必须借助顶级模型的深度分析能力来严格把关。
- **隔离机制**:基于 Git worktree 与 Docker 容器组合,杜绝了多 Agent 并行跑代码时的文件系统污染。 - **冲突自愈**:Merger Agent 不仅执行 Git merge,还会主动运行类型检查和单元测试套件,发现 break 立即自行修复。
---
[01:32:44](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=5564s) 架构自检结果展示:识别高耦合模块与测试盲区
在回答更多现场提问之前,Matt 切回前几个小节留在后台执行的“改进代码库架构(Improve Codebase Architecture)”流程。此时后台任务已经全部跑完,并在终端中整齐地输出了一组有待优化的候选架构改进项(Architectural Improvement Candidates)。
模型精准捕获到了代码中高度耦合的一组相关模块,并建议将它们抽离出来作为独立单元进行系统性测试。分析结果中首当其冲的是测验计分服务(`quiz scoring service`),工具不仅指出了其中应提取的重排序逻辑,还给出了翔实的耦合成因论据,并将依赖项分类标注(例如归类为“可本地替换的依赖”,建议在内存测试数据库中使用 SQLite 进行置换)。最关键的一项发现是:测验计分服务目前的单元测试覆盖率为零。Matt 强调,这种由 Agent 全盘扫描得出的模块边界漏洞和测试盲区报告,正是开发者在编写实际业务前重塑代码库形态的绝佳依据。
---
[01:33:39](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=5619s) 总结与回顾:重返经典软件工程内核
看着仅剩约 17 分钟的会场倒计时,Matt 坦诚地舒了一口气,笑着向台下倾诉自己的疲惫:“I don't know about you guys, but I'm knackered.” 现场随即爆发出一阵笑声。虽然他承诺在剩余时间内继续留在台上接受大家的一对一交流,但在这个节点,他更希望为这场高强度的全流程工作流做一个终极收拢与定调。
Matt 带领大家回顾了从头至尾的核心工程哲学。他神情严肃地指出,这套体系绝不是把自然语言当成编译指令、让 AI 肆意倾倒垃圾代码的“规格说明转代码编译器(spec to code compiler)”:“This is not a spec to code compiler. This is not an AI that's sort of just like churning out code. We are being very intentional with the kind of modules and the shape of the code base that we want.” - **严控边界与意图**:开发者自始至终都要清醒掌控代码库的架构形状与模块划分。 - **高强度对齐(Grill Session)**:在需求分析阶段通过高压盘问把产品模糊点彻底榨干,而不是盲目撰写冗长的 PRD;工程师根本无需通读并过度推敲几十页的文档。 - **切分并行任务**:迅速将方案拆解为具备垂直穿透性(Tracer Bullet)且相互正交的并行 Issue,交给后台 Agent 独立认领并实现。 - **极限 QA 与滚动追加**:实现阶段必须施加严苛的代码审查与质检。Matt 特别补充道,QA 环节的核心价值恰恰在于为看板源源不断地发现并创建新的阻塞 Issue,形成一个在开发过程中不断自我修正的闭环;待全部验收达标后,再拉入团队人类同事进行最终的全面代码审查(PR Review)。
在演讲尾声,Matt 强调这套工作流纯粹是他个人在大量实战中摸索出的一家之言,绝无强行推销之意。如果大家在听完这场讲座后只能带走一件行动项,他给出的终极建议竟然是远离 AI 的喧嚣,回归经典:“What I recommend if you take one thing away from this session is that you should head back, you should head to Amazon and just buy a ton of those old books because I mean, I just found it so enlightening reading them.” 在他看来,AI 时代之前先驱们写下的经典软件架构著作充满了历久弥新的洞见,字里行间处处都是极具营养的工程思想。最后,Matt 幽默地感谢现场所有听众在闷热的房间里坚持听完,打趣希望大家的人体体温能够尽快降温复原,讲座在全场热烈的掌声中顺利收官。
## Notable quotes > [36:00](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2160s) Bad code bases make bad agents. If you have a garbage code base, you're going to get garbage out of the agent that's working in that code base. — Matt Pocock
> [24:59](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=1499s) Implementation, as we'll see, can be turned into an AFK task. But planning, this alignment phase, has to be human in the loop. Has to be. — Matt Pocock
> [01:08:41](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4121s) 如果你的代码库没有反馈回路,你永远永远都不可能从 AI 那里获得体面的输出。 — Matt Pocock
> [00:15](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=15s) And I feel that when we talk about AI being a new paradigm, we forget that actually software engineering fundamentals, the stuff that's really crucial to working with humans, also works super well with AI. — Matt Pocock
> [01:10:35](https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=4235s) 如果你试图将创意构思、QA、研究、原型全部自动化,最终做出的应用在我看来只会缺乏品味,沦为劣质品。 — Matt Pocock
## Mentioned Matt Pocock, Sarah Chen, Dex Horvath, Martin Fowler, Frederick P. Brooks, John Ousterhout, Claude Code, Anthropic, Claude 3 Opus, Claude 3.5 Sonnet, Sandcastle, Ralph Wiggum, Cadence, Docker, Vitest, TypeScript, SQLite, Playwright, The Pragmatic Programmer, The Design of Design, A Philosophy of Software Design, Refactoring
## Video description A hands-on workshop covering the full lifecycle of AI-assisted development, from turning ambiguous requirements into agent-ready plans to running autonomous coding agents that ship production features.
You'll learn to stress-test vague briefs into structured PRDs, slice work into thin "tracer bullet" vertical slices, and run an AI agent with TDD. You'll watch it select tasks, write tests, implement code, and commit. You'll then refine your prompts based on where it struggles, graduate to fully autonomous (AFK) runs, and learn to design codebases that maximize agent effectiveness.
You'll walk away knowing how to:
- Turn ambiguous requirements into agent-ready issues - Slice work into vertical tracer bullets an agent can grab independently - Run AI agents human-in-the-loop and autonomously with TDD - Design codebase architectures that AI agents love to work in
For: Engineers ready to move beyond chat-based AI assistance and build a real workflow for shipping features with autonomous coding agents.
Speaker info: - https://x.com/mattpocockuk - https://www.linkedin.com/in/mapocock/ - https://youtube.com/@mattpocockuk
Timestamps: 00:00:00 - Introduction 00:00:14 - The Thesis of AI Engineering 00:04:20 - Phase 1: Research & Prototyping 00:12:45 - Phase 2: The Grill Session 00:22:10 - Phase 3: Writing the PRD 00:35:50 - Phase 4: Slicing Work into Issues 00:48:15 - Phase 5: Implementation with AI Agents 01:05:30 - Phase 6: Human-in-the-Loop Review 01:18:45 - Phase 7: Deployment & Monitoring 01:28:10 - Designing Codebases for AI Effectiveness 01:34:06 - Final Takeaways & Summary
---
Explore this talk's slides, transcript, key takeaways and resources on its official AI Engineer page: https://ai.engineer/talks/-QFHIoCo-Ko-ai-coding-workflow
---
[Source](https://www.youtube.com/watch?v=-QFHIoCo-Ko)