复合工程终极实战指南：让代码像钱一样利滚利

核心就四步：规划、干活、复盘、复合。规划占四成时间，复盘占四成，真正敲代码只占两成。
最狠的是第四步"复合"——每次干完活都要把经验教训喂给系统，让下次更聪明。这帮人用这个方法，五个人干出了五个产品，每个产品就一个工程师伺候着。

这不是魔法，这是把经验变成代码，把直觉变成规则，把个人的小聪明变成团队的大智慧。

为什么你的代码库越来越像垃圾场

想象你有一个房间，每买一件新衣服就随手扔进去，从不整理。十年后你打开门，里面堆成山，找条内裤都要翻半小时。这就是传统代码库的命运。每加一个功能就像往房间里扔一件新衣服，表面上衣服多了，实际上房间废了。代码越来越复杂，功能之间相互打架，改一行代码可能引爆十个bug。十年后，团队百分之八十的时间花在跟自己的代码斗智斗勇，只有百分之二十的时间在真正创造价值。这就像一个厨师把厨房搞得一团糟，最后花大部分时间找铲子而不是炒菜。

复合工程彻底颠覆了这个逻辑。每加一个功能，系统就变得更聪明一点。修复一个bug，整个类别的bug都被消灭。总结一个模式，这个模式就变成未来的工具。代码库越用越顺手，越改越轻松，越老越值钱。这就像你请了一个超级管家，每次你干完活，它都默默学习你的习惯，下次自动帮你把房间整理好。五年后，这个管家比你还会伺候你自己。

四个步骤组成的永动机

Every公司跑了五个产品——Cora、Monologue、Sparkle、Spiral，还有他们自己的网站Every.to。每个产品背后主要就一个人。这不是因为他们找到了超级程序员，而是因为他们搞出了一套四步循环的永动机：规划、干活、复盘、复合，然后重复。

前三步所有程序员都熟悉，第四步才是复合工程的独门秘籍。跳过第四步，你就是在用AI辅助传统开发，用了个寂寞。这个循环不管是修一个五分钟的bug，还是搞一个持续几天的功能，逻辑完全一样，只是每步花的时间长短不同。

规划加复盘应该占你百分之八十的时间，干活和复合只占百分之二十。换句话说，真正值钱的是键盘没动之前的思考，和键盘停下之后的复盘。敲代码只是中间那个微不足道的环节，就像炒菜本身只占做饭时间的很小一部分，买菜、备菜、洗碗才是大头。

第一步：规划——把想法变成蓝图

规划就是把一个模糊的想法变成一张清晰的施工图。规划做得越好，结果越漂亮。这一步你要干这些事：搞清楚需求——到底要造什么？为什么要造？有什么限制条件？研究现有代码库——类似功能怎么实现的？有什么现成的模式可以用？研究外部资料——框架文档怎么说？业界最佳实践是什么？设计解决方案——具体怎么搞？要改哪些文件？验证规划——这玩意儿靠谱吗？完整吗？

这一步就像你要去旅行，先查攻略、看地图、订酒店、规划路线，而不是直接跳上车乱开。很多人急着敲代码，结果开到一半发现没油了、路封了、目的地搞错了。规划就是让你的AI agent（智能代理）在动手之前先当一回侦探，把案发现场摸清楚，把线索找齐全，把行动计划写明白。这样当它开始"犯罪"（写代码）的时候，每一步都胸有成竹。

第二步：干活——让代理去搬砖

执行阶段就是按照规划干活。代理负责实现，你负责监督。这里面有几个小环节：设置隔离环境——用Git工作树（仓库的隔离副本）或者分支把活儿分开干，免得把主分支搞炸了。执行规划——代理一步步实现。运行验证——每次改完都跑测试、代码检查、类型检查。跟踪进度——看看干了多少，还剩多少。处理问题——出bug了就调整规划。

如果你信任规划，根本没必要盯着每一行代码看。这就像你请了个装修队，只要你给的施工图够详细，你不需要站在旁边看工人拧每一个螺丝。你可以去喝咖啡、打游戏、睡觉，偶尔过来看看进度就行。代理就是你的装修队，而且是一群永不疲倦、不会偷懒、不要工资的超级工人。你要做的就是在开工前把图纸画清楚，在验收时把关。

第三步：复盘——抓住问题，更重要的是抓住经验

复盘阶段在问题上线前抓住它们。更重要的是，它为下一个循环捕捉经验教训，这才是复合工程的基础。这一步你要：让多个代理并行复盘输出——十几个专业复盘员同时审查代码。给发现的问题排优先级——P1（必须修）、P2（应该修）、P3（可以修）。解决问题——代理根据复盘反馈修bug。验证修复——确认修对了、修完整了。捕捉模式——记录哪里出错了，防止下次再犯。

这一步就像你考完试不是只看分数，而是把错题本整理出来，分析为什么错、什么题型容易错、下次怎么避免。传统开发也有复盘，但通常就是"哦这里有个bug，修了"，然后就没有然后了。复合工程的复盘是把这次的经验变成系统的记忆，让下次遇到类似情况时，系统自动提醒"嘿，上次这里栽过跟头，小心点"。

第四步：复合——这才是印钞机

传统开发到第三步就结束了，但复合阶段才是赚钱的地方。前三步（规划、干活、复盘）产出了一个功能，第四步产出了一个每次都能更好造功能的系统。

在这一步，你要：捕捉解决方案——问问自己：什么管用了？什么没管用？有什么可以复用的洞见？让它能被找到——加上YAML frontmatter（元数据标记），确保打上正确的标签、分类，方便以后检索。更新系统——把新模式写进CLAUDE.md（代理每次会话都会读的文件），有必要时创建新代理。验证学习成果——问问自己：下次系统能自动抓住这个问题吗？

这一步就像你每次炒完一道菜，都把配方、火候、注意事项写进一本秘籍。下次再做这道菜，或者做类似的菜，直接翻秘籍就行。更狠的是，你把这本秘籍给你的徒弟（AI代理）看，它直接就能炒出跟你一样味道的菜。时间久了，你积累的不是一道道菜，而是一本本武功秘籍，徒弟越带越聪明，你越来越轻松。

开箱即用的神器

这套复合工程流程被打包成了一个插件。装上它，整套系统立即可用。盒子里有什么？26个专业代理，每个都针对特定工作训练过。23个工作流命令，包括主循环加上各种工具。13个技能，提供领域专业知识，比如代理原生架构技能、风格指南技能，随叫随到。

安装方法如下，零配置 required（需要）。

Claude Code安装：

claude /plugin marketplace add https://github.com/EveryInc/every-marketplace 
claude /plugin install compound-engineering

OpenCode安装（实验性）：

bunx @every-env/compound-plugin install compound-engineering --to opencode

Codex安装（实验性）：

bunx @every-env/compound-plugin install compound-engineering --to codex

文件都该放哪儿

你的项目目录应该长这样：

your-project/
├── CLAUDE.md              # 代理指令、偏好设置、模式记录
├── docs/
│   ├── brainstorms/       # /workflows:brainstorm 输出
│   ├── solutions/         # /workflows:compound 输出（已分类）
│   └── plans/             # /workflows:plan 输出
└── todos/                 # /triage 和复盘发现
    ├── 001-ready-p1-fix-auth.md
    └── 002-pending-p2-add-tests.md

CLAUDE.md是最重要的文件，代理每次会话都会读。把你的偏好、模式、项目上下文都放这里。出问题了就在这里加备注，让代理学习。

docs/solutions/构建你的机构知识，因为每个解决的问题都变成了可搜索的文档。未来的会话会自动找到过去的解决方案。

todos/跟踪工作项的优先级和状态。复盘阶段发现问题时，用它们来决定什么值得修，然后用解决命令来处理。

插件内部结构

插件本身包含：

agents/
├── review/      # 14个代码复盘专家
├── research/    # 代码库和文档研究员
├── design/      # 用户界面和Figma同步代理
├── workflow/    # 自动化代理
└── docs/        # 文档代理
commands/
├── workflows/   # 核心循环命令
└── *.md         # 工具命令
skills/          # 领域专业知识（14个技能）

核心命令详解

/workflows:brainstorm——当你不确定要造什么时，从这里开始。

/workflows:brainstorm 添加用户通知功能

/workflows:plan——描述你想要什么，拿回一个怎么造的规划。

/workflows:plan 用户收到新评论时添加邮件通知

开启ultrathink模式（扩展推理加深度研究）可以在规划创建后自动运行/deepen-plan——这会启动超过40个并行研究代理。

/workflows:work——代理真正写代码的地方。

/workflows:work

/workflows:review——让十几个专业代理同时复盘你的PR。

/workflows:review PR#123

复盘代理阵容

安全方面：安全哨兵——扫描开放全球应用安全项目（OWASP）定义的十大漏洞、注入攻击、认证缺陷、授权绕过。

性能方面：性能先知——检测N+1查询、缺失索引、缓存机会、算法瓶颈。

架构方面：架构策略师——评估系统设计决策、组件边界、依赖方向。模式识别专家——识别变更集中的设计模式、反模式、代码异味。

数据方面：数据完整性守护者——验证迁移、事务边界、引用完整性。数据迁移专家——检查ID映射、回滚安全性、生产数据验证。

质量方面：代码简洁性复盘员——强制执行YAGNI（你不会需要它），标记不必要的复杂性，检查可读性。Kieran-rails复盘员——Rails约定、Turbo Streams模式、模型/控制器职责。Kieran-python复盘员——PEP 8合规、类型提示、Pythonic习惯用法。Kieran-typescript复盘员——类型安全、现代ES模式、整洁架构。DHH-rails复盘员——37signals约定：简洁优于抽象，Omakase技术栈。

部署方面：部署验证代理——生成部署前检查清单、部署后验证步骤、回滚计划。

前端方面：Julik前端竞态复盘员——检测JavaScript和Stimulus控制器中的竞态条件。

代理原生方面：代理原生复盘员——确保功能对代理可访问，不只是对人类。

复盘输出格式

P1 - 关键（必须修）：
[ ] 搜索查询中的SQL注入漏洞（安全哨兵）
[ ] 用户创建周围缺失事务（数据完整性守护者）

P2 - 重要（应该修）：
[ ] 评论加载中的N+1查询（性能先知）
[ ] 控制器做业务逻辑（Kieran-rails复盘员）
P3 - 次要（可以修）：
[ ] 未使用变量（代码简洁性复盘员）
[ ] 可以用卫语句（模式识别专家）

自动解决

/resolve_pr_parallel命令自动处理所有发现。先修P1问题，然后P2。每个修复隔离运行，互不干扰，但最后你还是要手动审查生成的修复。

/triage命令逐个呈现每个发现供人类决策：批准（加入待办清单）、跳过（删除）、自定义（修改优先级/详情）。批准的项目获得status: ready状态，可以用/resolve_todo_parallel处理。想先筛选发现再承诺修复时用。

/workflows:compound——把解决的问题记录下来供将来参考。

/workflows:compound

/lfg——用这个命令，你描述功能，代理干剩下的——规划、构建、复盘、交给你一个准备好合并的PR。

/lfg 给设置页面添加深色模式切换

该扔掉的八个执念

我们都受过传统软件开发的训练，有些信念现在成了绊脚石。以下是八个该扔掉的执念。

"代码必须手写"——你作为软件工程师干好工作的实际要求只是写出好代码，好代码就是可维护的代码解决正确的问题。谁打字——人类还是代理——不重要。

"每行都必须人工复盘"——同样，成为好工程师的核心要求是写出高质量代码。人工逐行复盘是一种方法，自动系统抓住同样问题也是方法。很多开发者还依赖人工复盘是因为不信任结果。如果不信任结果，修系统，而不是通过什么都自己干来补偿。

"解决方案必须来自工程师"——当AI能研究方法、分析权衡、推荐选项时，工程师的工作变成了添加品味——知道哪个解决方案适合这个代码库、这个团队、这个上下文。

"代码是主要产物"——一个产生代码的系统比任何单个代码片段更有价值。一个 brilliant 的实现不如一个持续产生好实现的过程重要。

"写代码是核心工作职责"——开发者的工作是交付价值。代码只是这个工作的一个输入——规划、复盘、教系统都算。有效的复合工程师比以前写更少代码，交付更多。

"第一次尝试就应该好"——根据经验，第一次尝试百分之九十五是垃圾。第二次尝试还有百分之五十。这不是失败——这是过程。期望第一次就完美就像期望初级开发者在没上下文的情况下搞定复杂功能。所以把目标定为第一次就搞对。专注于迭代够快，让第三次尝试比第一次花更少时间落地。

"代码是自我表达"——开发者潜意识里把AI辅助开发看成对自己身份的攻击。感觉像 ego 被打击。但代码从来不是你的。它属于团队、产品、用户。放下代码作为自我表达是解放。没依恋意味着你更好地接受反馈，毫不犹豫地重构，跳过关于代码够不够好够不够的争论。

"打字多等于学得多"——很多开发者担心不打字就没在学。但现实是，今天理解比肌肉记忆更重要。你通过复盘、抓住错误、知道AI什么时候错了来学习和建立理解。审查10个AI实现的开发者比手写两个的理解更多模式。

转变中的挑战

打字少感觉像干活少。其实不是。指挥代理需要比实现更多思考，因为你花更少时间在按键上，更多时间在思考重要决策上。

放手感觉有风险。自主执行——把东西交给代理——在很多开发者中触发焦虑。一旦你认识到你不是在放弃控制，而是在把控制编码进约束、约定、复盘流程，这些流程比人工监督更好地扩展，这种焦虑就消退了。

"谁造的这个？"——功能在没有直接写代码的情况下上线感觉像作弊。但规划、复盘、确保质量标准就是工作。你做了思考。AI只是做了写字。

这些反应表明工作方式的根本转变，它们是正常的。通过在Every公开讨论它们，希望让其他人更容易谈论他们的经历。

该采纳的新信念

把你的品味提取进系统。每个代码库都反映造它的开发者的品味，从命名约定到错误处理模式到测试方法。那种品味通常没文档化在任何地方。它活在资深工程师脑子里，通过代码复盘传递。这既无法扩展，也不让团队其他人学习。

解决方案是提取和记录这些选择。把这些偏好写进CLAUDE.md或AGENTS.md，让代理每次会话都读。建专门的代理用于复盘、测试、部署，以及反映你品味的技能。添加斜杠命令编码你喜欢的方案。指向代理到你现有的风格指南、架构文档、决策记录，这些都包含你喜欢怎么造的例子。

一旦AI理解你喜欢怎么写代码，它会产出你真正批准的代码，而不是你得修的代码。

50/50法则

之前我建议了一个建功能的80/20法则：百分之八十时间规划和复盘，百分之二十干活和复合。当你看作为开发者更广泛的责任时，你应该把百分之五十的工程时间分配给建功能，百分之五十给改进系统——换句话说，任何帮助建立机构知识而不是交付特定东西的工作。

在传统工程中，团队把百分之九十时间投入功能，百分之十投入其他。非功能工作感觉像分心——有空才做的事，而你永远没空。但那个"其他"让未来功能更容易：比如创建复盘代理、记录模式、建测试生成器。当你把这些工作当开销而不是投资，代码库就积累债务。

花一小时创建复盘代理节省接下来一年十小时的复盘。你可以花时间建测试生成器节省几周手工写测试。系统改进让工作 progressively 更快更容易，但功能工作不会。

信任过程，建安全网

如果每行都需要人工复盘，AI辅助就无法扩展。你需要信任AI。

信任不是盲目信仰。它意味着设置护栏，比如测试、自动复盘、监控，标记问题，让你不必盯着每一步。

当你感觉无法信任输出时，不要通过切换到人工复盘代码来补偿。加一个让那步可信任的系统，比如创建一个标记问题的复盘代理。

让你的环境代理原生

如果开发者能看到或做什么，代理也应该被允许看到或做。

运行测试。检查生产日志。用截图调试。创建拉取请求。任何你不让代理处理的，你都得自己手工做。目标应该是人类和AI开发者之间的完全环境平等。

并行化是你的朋友

你以前是人类注意力一次只能干一件事的瓶颈。新瓶颈是计算——你能同时运行多少代理。

同时运行多个代理和多个功能。同时执行复盘、测试、文档。当你卡在一个任务上时，开始另一个，让代理干活同时规划下一步。

规划是新代码

规划文档现在是你产生的最重要的东西。不是像传统那样先编码后文档，从规划开始。这成为代理用来生成、测试、验证代码的真相源。

有规划帮助在变成bug前捕捉决策。在纸上修想法比在代码里修便宜。

核心原则总结

总之，支撑这种软件开发新方法的核心信念是：

每个工作单元让后续工作更容易。代码、文档、工具应该相互构建，让未来工作更快，而不是更慢。

品味属于系统，不属于复盘。把你的判断烘焙进配置、模式、自动检查。如果你不这样做，你会花时间人工检查，这无法扩展。

教系统，不要自己干活。给代理更多上下文的时间付出指数级红利，但打字代码的时间只解决面前的任务。

建安全网，不要复盘流程。用AI建信任的方式是建验证基础设施，而不是在每步人工把关。

让环境代理原生。构建项目让AI代理能自主导航和修改。

到处应用复合思维。每个产物——代码、文档、测试、提示——都应该让下一次迭代更快。

拥抱放手的 discomfort。当你委托给AI工具时，你得接受不完美的结果能扩展，而不是完美的结果不能。

交付更多价值。敲更少代码。你的产出应该按解决的问题数量衡量，不是你敲了多少键。

这些原则延伸到工程之外的设计、研究、甚至写作——任何编码品味和上下文帮助未来工作更快更容易的领域。步骤一样：规划、执行、复盘、复合。

五个阶段——你在哪一层

复合工程循环——规划、干活、复盘、复合——是过程。但让AI拥有这个过程的多少取决于你对AI的熟悉度和能力。有五个阶段，开发者可以对照自己，理解自己坐在哪。

大多数在AI辅助开发上挣扎的开发者不知道自己在这个梯子的哪一层。他们听说多代理复盘系统、并行云执行，感到 overwhelmed，要么放弃，要么试图跳级。跳级没用，因为你会感到不舒服、不信任工具。每一级都建立下一级需要的心智模型和习惯。所以慢下来，搞清楚你在哪，专注于从那里开始建。

阶段0：手工开发。你在逐行写代码，没用任何AI。你通过文档和Stack Overflow做研究。你的调试过程通过读代码和print语句。手工开发几十年造出了伟大的软件，但 sadly 2025年它不够快了。

阶段1：聊天辅助。你在用AI当智能参考工具，查ChatGPT、Claude或Cursor，收代码片段，复制粘贴有用的。AI加速了你的研究和样板生成，但你仍然完全控制，审查每行。

阶段2：带逐行复盘的代理工具。代理工具——能读文件并直接修改的AI助手——进入工作流：Claude Code、Cursor Composer、Copilot Chat。你允许AI基于你提供的上下文直接读文件并在代码库做修改。你是 gatekeeper，批准或拒绝代理提议的一切，这仍然是个 painstaking 过程。大多数开发者 plateau 在这里，没能享受到把更多交给AI的好处。

阶段3：规划优先，仅PR复盘。这是 everything changes 的阶段。你和AI协作制定详细规划，包括需求、方案、边界情况。然后开发者走开，允许AI无监督地实现规划。输出是一个拉取请求，你然后复盘。最后，你脱离了代码行级别，可以在PR复盘抓问题，而不是 babysit AI 建造时。

复合工程从这里开始，因为每个规划、建造、复盘的循环都教系统一些东西，让下一个循环更容易更快。

阶段4：想法到PR（单机）。你提供一个想法，代理处理一切：代码库研究、规划、实现、测试执行、自我复盘、问题解决、PR创建。在这个阶段，你的参与缩小到三步：构思、PR复盘、合并。然而，你仍然在自己的电脑上一次运行一件事。

阶段5：并行云执行（多设备）。这是最终阶段。你把执行移到云端，并行运行东西。因为你不受笔记本束缚，你可以从任何地方指挥代理——咖啡店、巴拿马海滩、或你的手机。

你 kick off 三个功能，三个代理独立工作，你复盘PR当它们完成。如果你推得更远，你允许代理开始监控反馈并主动提议修复，无需被问。你不再是个体贡献者。你在指挥一支舰队。

三个必问问题

即使你没有花哨的多代理复盘系统在手边，你仍然可以通过在批准任何AI输出前问这三个问题获得好处：

"你在这里做的最艰难的决定是什么？"这迫使AI揭示 tricky 部分在哪，它必须在哪里做判断。

"你拒绝了什么替代方案，为什么？"这显示它考虑的选项，帮助抓住它是否做了坏选择。

"你对什么最没信心？"这让AI承认它可能哪里错了。大语言模型知道它们的弱点在哪，但你得问。

代理原生架构

代理原生架构意味着给代理和你一样的能力。如果代理不能跑测试，你得跑。如果它不能看日志，你得调试。你 withheld 给AI的每个能力都变成你得自己做的任务。

代理原生检查清单：要检查你是否以代理原生方式工作，检查代理的能力。你的代理能：开发环境——本地运行应用、跑测试套件、跑代码检查器和类型检查器、跑数据库迁移、种子开发数据。Git操作——创建分支、做提交、推送到远程、创建拉取请求、读PR评论。调试——查看本地日志、查看生产日志（只读）、给UI截图、检查网络请求、访问错误跟踪（Sentry等）。

渐进式代理原生：你不需要立即百分百代理原生。给你的代理或代理 gradual 访问越来越多东西：级别1：基础开发。代理有文件访问，能跑测试和git提交。这是解锁基础复合工程的基础。级别2：完全本地。代理能访问你的浏览器和本地日志，能创建拉取请求。这启用上述采用量表的第三到第四阶段。级别3：生产可见性。代理能访问生产日志（只读）、错误跟踪、监控仪表板。这启用代理主动调试代码。级别4：完全集成。在这个阶段，代理能访问工单系统，有部署能力，与外部服务集成。这启用AI采用梯队的第五阶段。

代理原生心态：除了技术设置，代理原生也是一种心态。建功能时记住这个问题："代理将怎么与这个交互？"调试时："代理需要看到什么？"文档化时："代理能理解这个吗？"

跳过权限

默认情况下，Claude Code在每次操作前询问权限，比如创建文件，作为安全措施。--dangerously-skip-permissions标志关掉这些提示。名字故意吓人，让你使用前思考。但对于第三阶段以上的复合工程，持续的权限请求会 kill 你的 flow。

什么时候用：你信任过程。你有好规划和好复盘系统。你在安全环境。你在沙盒里，不会伤害真实用户或在线产品。你想要速度。权限请求拖慢工作流。跳过它们以快速移动。

什么时候不用：你在学习。AI的权限请求帮助你理解发生了什么。你在生产环境。永远不要在生产代码上跑跳过权限，因为那影响真实用户。你没有好的回滚。如果你不能轻易撤销错误，保持提示。

怎么用：我总是用跳过权限跑：alias cc='claude --dangerously-skip-permissions'。我在一个帮助避免风险的特定设置里做。我在笔记本上，不在生产服务器上。我在完全独立于主代码库的分支上工作。我有测试。我能回滚任何东西。真实用户永远不会看到这段代码，直到我准备好。"危险"标志在这里其实不危险——它只是帮我更快。

没有提示的安全：如果你不用权限提示，你需要其他安全机制。Git是你的安全网。代理做的一切都在git里。git reset --hard HEAD~1，你就回来了。测试抓住错误。合并前跑测试。如果代理搞坏了什么，测试会抓住。合并前复盘。跳过权限跳过实现提示，不是最终复盘。总是复盘PR。工作树隔离风险。用git工作树做 risky 工作。实验在隔离目录里发生。

生产力计算：你跳过权限的决定也取决于你想建多快。不用跳过权限，你可能每30秒看到一个提示。每次你得打"y"，失去 focus。想象这每次会话乘以几百次。

用跳过权限，你能维持 flow 状态，因为你不会被权限请求打断。看着工作发生（或做别的，比如跳进太平洋游泳）。这会解锁5到10倍更快的迭代，节省的时间可以 dramatically 超过偶尔回滚的风险。

标志叫--dangerously-skip-permissions是有原因的。它意在让你第一次 pause。但一旦你有经验，你可以对风险容忍度做知情决策，选择跳过。

设计工作流

设计在代码里比在 mockup 里更容易迭代——你可以点击 through 它，感受交互。但你不想在生产代码库里实验。这节讲如何在一次性项目里原型设计，用用户测试，捕捉你的设计品味让AI能复制。

婴儿应用方法：创建一个一次性项目——一个"婴儿应用"——你可以自由迭代，不用担心测试、架构、或搞坏任何东西。一旦设计感觉对了，提取模式，带回真实项目。

工作流：创建原型仓库。mkdir baby-myapp && cd baby-myapp。Vibe code 设计。"创建一个带深色模式切换的设置页面。让它看起来现代。"迭代直到看起来对。"更多间距。切换更突出。内联，不要堆叠。"捕捉设计系统。一旦你有满意的东西，提取颜色、间距、排版、组件模式。转移到主应用。用原型当参考建真实功能时。

用户体验发现循环：当你不知道建什么时，vibe coding 很适合探索：生成多个版本。告诉代理想五个不同版本的设置页面，看它想出什么。每个都点击 through。用它们，看感觉对。分享给用户。给他们看原型，问："这个流程会迷惑你吗？"在功能原型上收集反馈。不像Figma mockup，他们真能点击 around。删除一切，用 proper 规划重新开始。原型只用于学习，不用于发货。

与设计师协作：传统流程——设计师和开发者之间的协作通常长这样：设计师创建 mockup。开发者解释它并建东西。设计师说，"不太对。"来来回回直到最终匹配——也许。

复合流程——用复合工程，来回缩小。设计师在Figma里创建 mockup。你用Figma链接跑/plan，告诉AI精确实现它。AI建造它。figma-design-sync代理检查实现是否匹配 mockup。设计师复盘 live 版本，不是截图。迭代直到完美。

编码设计品味：一旦你和设计师合作过几个功能，你会注意到模式，比如他们喜欢的颜色、他们喜欢表单怎么布局。把那些写下来放进技能文件。用这个，AI现在能产出匹配设计师品味的设计——即使设计师不参与。

技能文件示例：

# 技能：我们的设计系统

颜色
- 主色：#4F46E5
- 背景：#F9FAFB
间距
- 用4px基础单位
- 区块：32px间隙
模式
- 按钮：12px水平内边距
- 卡片：微妙阴影，不要边框
- 表单：单列，最大宽度400px

设计代理：design-iterator——给当前设计截图，分析什么不管用，做改进，重复。每轮进一步精炼设计。figma-design-sync——从Figma拉设计，与建的比较，识别差异，自动修复。

Vibe Coding（氛围编程）

Vibe coding 是给不在乎代码本身的人——他们要结果。也许你是原型想法的产品经理。也许你是测试交互感受的设计师。也许你在建个人项目，你永远不会看代码。你只想确保东西管用——这是 vibe coder 的哲学。

Vibe coder 的哲学：这节关于跳过梯子，直接到第四阶段，你描述想要什么，让代理建造。

快速路径：跳过梯子。直接去第四阶段。描述你想要什么。/lfg 创建一个网页应用让我用复选框跟踪日常习惯。等待。代理想出建什么，创建代码，跑测试，自我复盘，做PR。检查是否管用。如果行，完成。如果不行，说哪里不对。让代理修复。

你不需要在乎的：代码质量——复盘代理处理它。架构——代理做合理选择。测试——测试自动写。最佳实践——编码在代理里。

你专注于你想要什么。系统处理怎么做。

什么时候用 vibe coding：完美用于——个人项目、原型、实验、"这能行吗？"调查、内部工具、用户体验探索。

不 great 用于——有用户的生产系统、别人要维护的代码、安全敏感应用、性能关键系统。

Vibe coding 悖论：Vibe coding 实际上能让你的规划更好。当你不知道想建什么时，生成原型。分享给用户，收集反馈。点击 through 它们。然后删除一切，用 proper 规划重新开始。

最优分割：Vibe code 发现你想要什么，然后 spec 来 proper 建造它。Spec 总是赢最终实现，但 vibe coding 加速发现。

示例会话：你：/lfg 我想要一个网站，我可以粘贴 YouTube 链接，它提取字幕。代理工作五分钟……你：管用，但文字难读。把字体弄大点。代理修复……你：完美。发货。

团队协作

当AI处理实现时，团队动态转变。你需要新约定：谁批准规划，谁拥有PR，代理做了第一遍后人类应该复盘什么。

新团队动态：传统：在传统设置里，开发者这样协作：A写代码→B复盘→PR评论里讨论→批准后合并。复合：在复合工程设置里，开发者这样协作：A创建规划→AI实现→AI代理复盘→B复盘AI复盘→人类批准后合并。

团队标准：规划批准——读规划并同意是决策。沉默不是批准——是缺席决策。标准：标准应该要求实现前明确签字，不管是评论、提交消息里的标签、或其他批准标记。

PR所有权：发起工作的人拥有PR，不管谁（或什么）写的代码。你负责规划质量、复盘工作、修复任何问题、合并后的影响。

人类复盘焦点：当AI复盘代理已经分析过PR时，人类复盘员专注于意图，不是实现。问问自己：这匹配我们同意建的吗？方案有意义吗？有业务逻辑问题吗？别费心检查语法错误、安全漏洞、性能问题、风格——那是复盘代理已经做的。

沟通模式：默认异步——复合工程很好地异步工作。规划可以创建、复盘、批准，无需安排会议。不是告诉同事"我们见面讨论方案"，试试"我创建了规划文档——请在今天结束前评论。"

明确交接：交接给别人的工作时，包含他们需要的一切：状态、什么做完了、什么剩下了、上下文、怎么继续，如下例所示：

交接：邮件通知
来自：Kieran → 给：Dan
状态：规划批准，实现百分之五十
剩下了：用户偏好设置、退订流程
怎么继续：在功能分支跑/work

扩展模式：明确所有权加异步更新——每个主要功能应该有一个所有者。那个人创建规划，监控AI实现，复盘发现，准备好时合并，异步更新团队。功能标志加小PR——当每个人发货更快时，合并冲突增加。发小块，用功能标志，频繁合并到主分支，立即解决冲突。复合文档等于部落知识——你不应该需要问同事本可以烘焙进系统的知识。不是说"问Sarah，她知道 auth 怎么工作"，Sarah在实现功能后跑/compound。现在解决方案文档化了，任何人都能找到。

用户研究

构建研究让AI能用。建 persona 文档，把洞察链接到功能，关闭研究和实现之间的循环。

研究-开发鸿沟：传统：在传统软件开发里，用户研究员和开发者协作长这样：研究员进行访谈→写报告→报告躺在Google Drive里→开发者建功能→开发者从不读报告→功能不匹配用户需求。复合：在复合工程里，那协作长这样：研究生成结构化洞察→洞察变成规划上下文→AI参考洞察规划→功能由研究 informed→使用数据验证洞察→洞察复合。

结构化研究：原始访谈笔记对AI难用。结构化它们：

# research/interviews/user-123.md

participant: 营销经理，B2B SaaS
date: 2025-01-15
focus: 仪表板使用模式

关键洞察

洞察：早晨仪表板仪式
引用："每天早上第一件事，我检查红旗。"
含义：仪表板需要快速 surface 问题。
信心（4/5参与者）

建 persona 文档：创建AI能参考的 persona 文档：

# personas/marketing-manager.md

目标
1. 向领导证明营销投资回报率
2. 快速识别表现不佳的活动
挫折
1. 数据太多，难找重要的
2. 导出报告很繁琐
引用
- "我需要看到问题，不是所有东西。"
- "我老板要PDF，不要链接。"

研究 informed 规划：

/workflows:plan 添加导出调度

研究上下文：
- 3/5访谈用户提到每周导出
- 营销经理 persona 每周五导出
- 当前痛点：手工导出流程
设计为：自动每周导出到邮件

数据模式提取

你的用户已经通过他们怎么用产品告诉你建什么。每次点击都是线索。你只需要注意。

要找的模式类型：重度使用模式——这些是用得比预期多得多的功能。另一个信号可能是用户反复返回同一页面。挣扎模式——找简单页面上的高停留时间或同一动作的重复尝试。错误→重试→错误循环。变通模式——这是用户发明自己的解决方案，因为产品不做他们需要的。找从一个地方导出数据并重新导入另一个地方的用户。用户可能在屏幕之间复制粘贴，或保持多个标签打开并排比较东西。放弃模式——这是用户在流程中 drop off。功能开始了但没完成。

从模式到功能：以下是你注意到的用户模式如何变成产品决策：你注意到用户每周50次从一张表复制数据粘贴到另一张表。洞察：他们需要表之间的自动化。功能：一个"同步到表B"按钮。你注意到用户创建"模板"项目并复制它们用于新工作。洞察：他们想要项目模板但没有。功能：一流模板支持。

文案写作

大多数团队把文案当 afterthought——功能建好后填的东西。但文案是用户体验的一部分。它值得和代码一样的关注。

文案是规划的一部分：从一开始就在规划里包含文案，编码你的声音让AI能跟随，像复盘其他输出一样复盘它：

功能：密码重置流程

面向用户的文案
- 邮件主题："重置你的密码"
- 成功消息："检查你的邮件。我们发了重置链接。"
- 错误（未找到）："我们找不到用那个邮箱的账户。
  想创建一个吗？"

编码你的声音：创建一个定义你文案声音的技能，比如：

# 技能：我们的文案声音

原则
1. 像人类对用户说话，不要像机器人
2. 错误消息应该帮助，不要指责
3. 短句子。清晰的词。
避免的词
- "无效" → "不管用"
- "错误" → 描述发生了什么
- "成功" → 直接说发生了什么
- "请" → 直接问
示例
坏："无效凭证。请重试。"
好："那个密码不对。重试或重置它。"

像代码一样复盘文案：添加文案复盘到你的/workflows:review流程：copy-reviewer代理——清晰度：非技术用户能理解吗？有帮助：这帮助用户成功吗？语气：这匹配我们的声音指南吗？一致性：这匹配其他地方类似文本吗？

产品营销

恭喜，你发货了东西。现在是时候告诉世界了。建功能的同一系统可以宣布它们。从规划生成发布说明，创建社交帖子，自动捕捉截图。

复合流程：工程师创建包含产品价值主张的规划。AI实现功能。AI从规划生成发布说明。AI从发布说明生成社交帖子。AI用Playwright生成截图。工程师复盘并一起发货。一切都从一个地方流出来。没人需要交接， nothing slips through the cracks。

生成发布说明：实现功能后：基于[功能]的规划和实现，写发布说明：1. 以用户利益开头（他们现在能做什么？）2. 包含一个具体例子 3. 提到任何破坏性变更 4. 保持在200字以内。AI有规划、代码变更、测试。它确切知道建了什么。

生成变更日志：对于多个功能，用/changelog：/changelog 查看最近合并到主分支的，读每个的规划/PR，生成 engaging 的变更日志。

自动截图：用Playwright捕捉营销截图：截图显示新通知设置：1. 带通知部分的设置页面 2. 示例通知邮件 3. 应用内通知徽章。不再需要找工程要截图，也不再有过时截图。

开始使用

复合工程循环——规划、干活、复盘、复合——是过程。但你允许AI拥有这个过程的多少取决于你对AI的熟悉度和能力。有五个阶段，开发者可以对照自己，理解自己坐在哪。

大多数在AI辅助开发上挣扎的开发者不知道自己在这个梯子的哪一层。他们听说多代理复盘系统、并行云执行，感到 overwhelmed，要么放弃，要么试图跳级。跳级没用，因为你会感到不舒服、不信任工具。每一级都建立下一级需要的心智模型和习惯。所以慢下来，搞清楚你在哪，专注于从那里开始建。

复合工程不是未来，它是现在。Every公司已经用五个人干出了五个产品，每个产品一个工程师。这不是因为他们找到了超级程序员，而是因为他们搞出了一套让程序越写越聪明的系统。你也可以。

Kieran Klaassen是Every公司的Cora（AI邮件助手）总经理，Dan Shipper是Every的CEO和联合创始人。Every是一家专注于AI工具的媒体和产品公司，旗下拥有Cora（AI邮件助手）、Spiral（AI写作工具）、Sparkle（AI文件整理）、Monologue（AI语音转文字）等多款产品。Kieran是从零开始用AI构建Cora的，在这个过程中发展出了复合工程方法论。这套方法论在GitHub上获得了超过7000颗星，已经成为AI辅助开发领域最具影响力的实践框架之一。

独特性评价

这篇指南的独特价值在于它不仅仅是一套技术流程，更是一次思维范式的革命。最狠的是"复利"这个概念，把金融领域的复利思维引入软件开发，让每一行代码都产生利息。