I’ve written about why having your AI coding assistant plan before it codes lets you ship faster than jumping straight to code. It’s my method for making my AI smarter with every feature.
我写过为什么要在编码之前拥有AI编码帮助计划，因为这样和直接跳转到编程环节相比能更快地交付。这样能让我的AI在每个特点上更聪明，这是我的办法。
For example, when I needed to implementCora’semail bankruptcy feature—clearing 53,000-email inboxes without deleting anything important—I didn’t start by coding. I created a research agent to plan instead.
比如，当我需要运行Cora的电子邮件破产功能-在不删除任何重要邮件的前提下清理53000封电子邮件收件箱-我并没有从编码开始。而是创建了一个研究代理来计划。
I thought this would be an easy feature. Bulk archive 53,000 emails—how hard could it be? I asked the research agent to analyze our own bulk operation patterns, check API limits for mass actions, and propose three implementation approaches with tradeoffs.
我以为这会是一个简单的功能。批量归档53000份邮件-这能有多难？我询问研究助理来研究我们自己的批量操作模式，为大量行动检查API，权衡之下提出三个执行办法。
Twenty minutes later, it came back with a reality check: Gmail rate limits would kill us at 2,000 emails, our system would timeout on long operations, and the user would have to wait too long for the result. I thought it would be a quick feature, but it turned into a three-day architectural challenge. Planning had saved me from wasting time building the wrong thing entirely.
20分钟之后，它返回了一个事实检查：如果Gmail的每日邮件发送上限设定为2000封，那对我们来说是个噩耗，我们的系统在长时间操作时会超时，为了结果，用户必须等待过长时间。我以为这会是一个快的特点，但是结果是三天的建筑挑战。规划让我免于完全地构建错误而节省了时间。
You can avoid building the wrong thing, too. I’ll show you the concrete tactics that turn a planning philosophy into working systems, starting with how to run parallel research operations that teach your AI how you think. Look out for Github links throughout the article—I’ve added them so you can copy and adapt the exact agents and commands I use, rather than building everything from scratch.
你也可以避免构建错误的事情。我将给你展示将计划哲学转为工作系统的具体策略，我们会从如何运行研究计划以教你AI如何思开始。通篇寻找Github链接-我已经添加了它们这样你就可以复制和适应我使用的确切的代理和命令，而不是从零开始构建一切。
The eight planning strategies
八个计划策略
When you’re planning with AI, you’re running parallel research operations—each one a specialized agent gathering different kinds of knowledge. Then you work together: The agents bring findings, you make decisions, and together you combine and distill everything into one coherent plan.
当你用AI计划，你正在运行平行研究操作-每一个都是专门的收集不同种类知识的代理。然后你们一起工作：代理带来发现，你做决定，然后你们把一切都合并并提炼到一个连贯的计划中。
It’s much faster for five agents to research in parallel than for a human to plan step by step. Your contribution to the process is taste, judgment, and context about what matters for your product and users.
与一个人一步步地计划相比，五个代理并行研究速度更快。你对这个过程的贡献是对你的产品和用户而言重要的品味、判断和情境。
I use eight research strategies, depending on the fidelity level, which refers to the degree of difficulty. Fidelity One is quick fixes like one-line changes, obvious bugs, and copy updates. Fidelity Two covers features spanning multiple files with clear scope but non-obvious implementation. Fidelity Three covers major features where you don’t even know what you’re building yet.
取决于忠诚度级别，我使用八个研究策略，他们指向困难程度。忠诚度一是快速修复像一行的改动，明显的漏洞和拷贝更新。忠诚度2包括的范围覆盖到有明显范围但是不明显实施的多样化的文档。忠诚度三覆盖的主要特征是甚至是你也不知道你正在构建的东西。
Strategy 1: Reproduce and document
策略1:重新生产和文档
What it does:Attempts to reproduce bugs or issues before planning fixes
它做什么：在计划修复之前试图重新生产漏洞和问题
When to use it:Fidelity One and Two, especially bug fixes
什么时间使用：忠诚度一和二，特别是漏洞修复
The agent’s job:Create a step-by-step reproduction guide
代理的工作：创造一步步的再生产指导
Prompt:“Reproduce this bug, don’t fix it, just gather all the logs and info you need.”
Right after the launch ofCora’semail bankruptcy feature, 19 users were stuck. They’d clicked “archive everything,” but the job failed. Instead of guessing the reason for the problem, I told Claude Code: “Loop through the AppSignal logs and diagnose this.” (AppSignal logs are our error tracking system that records what goes wrong in production.)
提示：“重新生产这个漏洞，不要修复它，只是收集你需要的所有的日志和信息。”在Cora的电子邮件破产功能发布后不久，19个用户陷入困境。他们点击了按钮“归档一切文件，”但是这个任务失败了。不是让Claude Code猜测问题的理由，我告诉它：“循环遍历AppSignal的日志然后诊断这个。”（AppSignal日志是我们的错误追踪系统，它记录了我们生产过程中的错误。）
Five minutes later, I had a reply: Rate limit errors were being swallowed in production. The job hit Gmail’s limit, failed silently, and never resumed. Users would click “archive everything,” see a loading spinner, and wait forever—because when one batch failed, the entire job stopped, but we never told the user. That reproduction showed we needed batch processing and job resumption, not just retries.
五分钟之后，我获得了一个回复：在生产过程中速度限制错误被忽略了。这项工作触及了Gmail的限制，静悄悄地失败了，而且从来没有回复。用户会点击“归档一切，”看着那个加载进度条，永远就这么等下去-因为当一批结束了，整个工作停下了，但是我们永远不会告诉用户。那个再生产过程表明我们需要批处理和工作恢复，而不仅仅是重新操作。
The agent reproduced the bug, found the root cause in production logs (records of what's happening on the live site users interact with), and documented everything automatically. (All screenshots courtesy of the author.)
代理重新生产漏洞，在生产日志中找到根源（当前页面用户互动的记录），自动记录下一切。（所有截图由作者提供。）
How to make this compound:To make sure that this issue wouldn’t happen in the future, I updated my @kieran-rails-reviewer agent—one of the specialized reviewers that automatically checks plans and code as part of my compounding engineering flow. I added to its checklist: “For any background job that calls external APIs—does it handle rate limits? Does it retry? Does it leave users in partial states?” We forgot to retry once. The system won’t let us forgetagain.
怎么做这个复合工作：为了确保这个问题未来不再发生，我更新了我的代理-专业代理之一，作为我复合工程流的一部分自动检查计划和代码。我把这个加到检查表中：“对于任何被称为外部API的背景工作-它处理速度限制问题吗？它会再次尝试吗？它会让用户处在部分状态吗？”我们曾经忘记重新尝试。这个系统不会再让我们忘记了。
Strategy 2: Ground in best practices
策略2:根植于最好的实践中
What it does:Searches the webfor how others solved similar problems
它做什么：上网搜索别人怎么处理相似的问题
When to use it:All fidelities, especially unfamiliar patterns
什么时候使用：所有的忠诚度，特别是不熟悉的模式
The agent’s job:Find and summarize relevant blog posts, documentation, and solutions
代理的工作：找到并总结相关的播客发文，文件和解决措施
Agent:“@agent-best-practices-researcher”
This strategy works for anything where someone else has already solved your problem—things like technical architecture, copywriting patterns, pricing research, or upgrade paths.
代理：这个策略适用于别人早已解决了你的问题的领域-比如技术建筑，文案写作模式，价格研究或者更新路径。
When I needed to upgrade a gem—apre-built code libraryI use—that was two versions behind, I had an agent search: “upgrade path from version X to Y,” “breaking changes between versions,” “common migration issues.” It found the official upgrade guide, plus three blog posts from engineers who’d done the same upgrade and hit edge cases. That research took three minutes and prevented hours of trial-and-error debugging.
当我需要升级-我使用的提前构建的代码图书馆-已经落后了两个版本了，我有一个代理寻找：“从版本X到版本Y更新路径，”“在版本之间打破变化，”“常见的迁移问题。”它发现了官方的更新指导，以及从处理了同样更新并处理极端案例的工程师的三个博客发文。那项研究花费了三分钟并且避免了数小时的尝试和错误漏洞消除工作。
I’ve also used this for non-technical decisions: “SaaS pricing tiers best practices” returned frameworks for structuring pricing plans. “Email drip campaign conversion copy” found proven email templates. “Background job retry strategies” surfaced patterns in how other companies solved that problem at scale.
我也使用了这个非技术性的决定：“SaaS 价格排列最好的实践”返回了结构化价格计划的框架。“电子邮件持续推送式营销转化文案”发现被证实的电子邮件模版。“背景工作重试策略”别的其他公司如何大规模处理那个问题的模式出现。
The best-practices agent found: the library's official documentation, changelogs (lists of what changed between versions), and upgrade guides showing how to move my code to the new version—all with source links automatically included.最好实践的代理发现：图书馆的正式文件，改变日志（版本之间什么改变了的清单），更新指导表明怎么将我的代码移动到新版本中-所有都自动包括源链接。How to make this compound:When the agent finds a particularly useful pattern, I have it automatically save the key findings to `docs/*.md` files in my project. For instance, I’ve saved “docs/pay-gem-upgrades.md” for migration patterns and “docs/pricing-research.md” for pricing insights. Next time a similar question comes up, the agent checks these documents first before searching the web. My knowledge base is constantly growing and improving.
怎么做这个复合：当代理发现了特别有用的模式，我让它自动存储关键发现到我项目文件中。例如，我把前者存为迁移模式后者存为价格洞见。下一次相同的问题会出现，在上网搜索之前代理首先检查这些文档。我的知识基础不断增长和提升。
Strategy 3: Ground in your codebase
策略3:根植于你的代码基础
What it does:Finds similar existing patternsin your code
它做什么：在你的代码中找到相似的存在模式
When to use it:Anything that might duplicate existing functionality
什么时候使用：在任何可能复制现有功能时
The agent’s job:Search through your existing code for related implementations
Before adding event tracking—the system that tracks what users click and when—to a new feature, I had an agent search our codebase: “How do we currently handle event tracking? What’s our pattern for analytics calls? Where do we send events?”
It found we already had a tracking system that I’d forgotten about, complete with helper methods, which are reusable bits of code that handles repetitive tasks (in this case, adding tracking). If AI doesn’t ground itself in your codebase, it often thinks it needs to create a solution from scratch. In this case, instead of reinventing event tracking, we extended the existing pattern. The search prevented building a second, incompatible tracking system and saved time.
代理的工作：搜遍你先有的代码来进行相关实施。在增加事件追踪到新功能之前之前，系统追踪用户点击什么什么时候点击，我让一个代理搜索我的代码基础：“我们现在如何处理事件追踪？我们对分析号召的模式是什么？我们发送事件到哪里？”它发现我们早就有了一个我已经忘记的追踪系统，用助手方法完成，那是可再用的代码碎片能处理重复性的任务（在这个例子中，添加追踪）。如果AI并不把自己深入你的代码基地，它经常会认为它需要从零开始创造一个解决方法。在这个例子中，除了重新创建事件追踪，我们拓展了现有的模式。这个研究组织构建一个二手的不兼容的追踪模式并且节省了时间。
How to make this compound:I created an “@event-tracking-expert” agent that distills everything about how we do tracking—our helper methods, our event format, when to track versus when not to. Now when it’s planning any feature that needs tracking, that specialist agent runs automatically. I don’t search the codebase from scratch anymore—the expert already knows our patterns.
怎么做这个复合体：我创建了一个代理并且总结了我们怎么做追踪的一切事物-我们的助手方法，我们的事件格式，什么时候追踪什么时候不追踪。现在当正在计划任何需要追踪的特点时，那个专家代理自动运行。我不再从零开始搜索代码库了-那个专家早就知道我们的模式了。
Strategy 4: Ground in your libraries
策略4:根植于你的图书馆中
What it does:Reads source codeof installed packages and gems
它做什么：读取已安装软件包和插件的源代码
When to use it:When using fast-moving or poorly documented libraries
什么时候使用：当使用快速更新或缺乏详细文档的库时
The agent’s job:Analyze the source code to understand what’s possible
代理的工作：分析源代码以理解可能的事情
I use a Ruby gem called RubyLLM for AI API calls. It updates constantly with new models, new parameters, and new capabilities, but documentation lags behind. So when I need to use it, I have an agent read the gem’s source code: “Look through the RubyLLM source. What model options are available? What parameters can I pass? Are there any undocumented features in the latest version?”
我使用名为Ruby LLM的Ruby gem来调用AI API。它随着新模型、新参数和新能力而不断更新，但是文档落后。所以当我需要使用它，我有一个代理来读gem的源代码：“遍览Ruby LLM源。什么模型选择是可用的？我能通过什么参照？在最新的版本中有没有任何未被归档的特点？
The agent comes back with: “Version 1.9 added streaming support but it’s not in the docs yet. Here’s the parameter name and example usage from the test suite.”
代理回复道：“19版本添加了流媒体支撑但是现在没在档案中显示。这是参照名称和从测试套件中来的例子使用。”
Why this compounds:Every time you update a dependency (a library your code relies on), the knowledge auto-updates. You’re never working with stale information.
为什么这个复合：每次你更新一个依赖（你的代码依赖的库），知识自动更新。你从不和过时信息共事。
Strategy 5: Study git history
策略5:学习git历史
What it does:Analyzes commit history(the log of all past changes to your code) to understand intent
它做什么：分析提交历史记录（对你的代码的所有过去改变的记录）来理解企图
When to use it:Refactors, continuing work, understanding “why”
什么时候使用：重构、继续工作、理解“为什么”
The agent’s job:Research past decisions and their context
代理的工作：搜索过去的决定和他们的情境
I was working on a feature and noticed we were using an outdated version of our EmailClassifier feature, which identifies what a given email is and whether it should stay in the inbox or get briefed. My first thought was: “Why haven’t we upgraded this? Let me update it.”
我正在忙于一个特征并且注意到我们正在使用我们EmailClassifier特征的一个过时版本，它明确了一个给定的邮件是什么以及它是否应该呆在收件箱里或者被简要告知。我第一个想法是：“为什么我们还没有更新这个？让我来更新一下。”
Before making the change, I had an agent search the git history: “Why are we using v1? Has anyone tried upgrading to v2?”
在做出改变之前，我让一个代理搜索了git历史:“为什么我们正在使用版本1？没人试着更新到版本2吗？”
It found a pull request from three months ago—from a different team member—that had upgraded to version two, discovered that version two put inbox emails in the archive and archive emails in the inbox (the opposite of what we want), and deliberately rolled back with detailed reasoning in the PR discussion. Version two changed how it handled edge cases, which would have broken our email scheduling.
它从三个月以前发现了一个拉取请求-从一个不同的团队成员那里-那已经更新到版本2了，发现那个版本二将收件箱放到档案库中并且在收件箱里归档（我们想要的反面），然后故意运行到最开始讨论的详细推理中。版本二改变了它如何处理极端案例，那可能破坏我们的电子邮件日程安排。
That five-minute git search saved me from reintroducing a bug someone else had already debugged and fixed.
五分钟的git搜索使我免于重新介绍一个别人早已发现和解决的漏洞。
Why this compounds:Institutional memory gets preserved and searchable. New team members inherit the reasoning behind past decisions.
为什么是这个复合：机构记忆被储存变得可被寻找。新的团队成员从过去的决定中继承理由。
Strategy 6: Vibe prototype for clarity
策略6:为了清晰的氛围原型
What it does:Rapid prototyping in a separate environment to clarify requirements
它做什么：在不同的环境中快速构建原型来明确要求
When to use it:Fidelity Three, UX uncertainty, exploratory work
什么时间使用：忠诚度3，UX不确定性，探索性的工作
The agent’s job:Quickly build throwaway versions you can interact with
代理的工作：快速构建你可以与之互动的抛弃型版本
Prompt:“Create a working prototype, in the style of a mockup using React and Next, grayscale of XYZ”
提示：创建一个工作模型，用一种使用React和Next的模型风格，XYZ的灰度”
For a redesigned email Brief interface, I didn’t know what layout would feel right. So I vibe coded five different prototypes in Claude, each of which took five minutes to build. I clicked through them, noticed what annoyed me, and showed the best one to a few users.
对于一个重新设计的电子邮件简洁界面，我不知道什么样的布置会感觉良好。所以我用Claude氛围编程了五个不同的原型，每个都花了五分钟来构建。我挨个点击它们，注意什么使我恼怒，给几个用户展示最好的一个。
One user said, “This layout feels overwhelming and I don’t know how to archive emails.” That insight became a requirement in the real planning: “Archive button must be in top-left corner—user muscle memory expects it there from Gmail.”
一个用户说，“这个布置看起来太漫溢了，我不知道怎么给电子邮件归档。”那个洞见成为真实计划中的一个要求：“归档按钮必须在左上方的角落里-人们使用Gmail的肌肉记忆让人们默认位置在那儿。”
The prototypes got deleted. The knowledge went into the plan.
原型被删除。知识进入计划。
Why this compounds:Vibe coding turns uncertainty into concrete specifications. You’re not guessing what users want—you’re showing them options and documenting their reactions.
为什么这个复合：氛围编程将不确定性变为具体的明细单。你不是在猜测用户想要什么-你是展示给他们选择并记录他们的反应。
Strategy 7: Synthesize with options
策略7:用选择综合
What it does:Combines all research into one plan showing multiple approaches with tradeoffs
它做什么：将所有的研究在权衡取舍中组合成一个计划表
When to use it:End of the research phase, before implementation
什么时候使用：在研究阶段最后，在实施之前
The agent’s job:Present 2-3 solution paths with honest pros and cons
代理的工作：用最诚实的优缺点呈现2-3个解决路径
After running strategies 1-6, I have an agent synthesize everything: “Based on all this research, show me three ways to solve this problem. For each approach, tell me: implementation complexity, performance impact, maintenance burden, and which existing patterns it matches.”
在运行了1-6策略之后，我有一个代理总结一切：“基于所有这些研究，给我展示解决这个问题的三个方法。对于每个方法，告诉我：实施复杂性、性能影响、维护负担，以及它匹配哪个现存的模式。”
For syncing users’ Gmail inboxes with Cora so we could display their emails, the synthesis came back with:
将用户的Gmail收件箱与Cora同步所以我们能展示他们的Gmail，综合回复道：
Option A—Use existing sync system: Fast to implement, but creates overlap with current code and muddies separation of concerns 选择A：使用现存的同步系统：快速实施，但是用现存代码覆盖并模糊关注的划分。
Option B—Real-time sync: Clean architecture, but slow and potential reliability issues
选择B-实时同步：清晰建筑，但是缓慢有潜力的依赖性问题
Option C—Build mirror caching system: Best long-term solution, cleanest separation, but most upfront work
选择C：构建镜像内存系统：最好的长期解决办法，最清晰的分离，但是最预付的工作
In other words, it was suggesting I either: bolt Gmail syncing onto our current system (quick but messy—like duct-taping a second mailbox to your existing one), fetch emails from Gmail every single time a user opens Cora (clean but slow—like calling the post office to check your mail instead of having a mailbox), or build our own local copy of the user’s Gmail that stays in sync (more work upfront, but fastest and most reliable long-term—like having your own mailbox that updates automatically).
换句话说，它也建议我：固定Gmail的同步到我们当前的系统上（快但是混乱-就像用强力胶封住第二个邮箱到你现存的这个），每次用户打开Cora都从Gmail取邮件（干净但是缓慢-就像给邮局打电话检查你的邮箱而不是有一个邮箱），或者复制用户的Gmail到本地并保持同步（前期投入更多工作，但是长期来说更快更可靠-就像有自己的邮箱自动更新）。
Once I saw that comparison laid out, I was able to make an informed choice in 30 seconds. The agent did the research; I contributed the judgment.
一旦我看到那个对比，我能在30秒内做出有知情的选择。代理做研究，我贡献判断。
Why this compounds:Your choice reveals preferences. When I picked Option C and noted, “I prefer widely supported over cutting-edge,” that preference gets codified. Next time there’s a similar decision, the system knows to weight compatibility highly.
为什么这个复合：你的选择揭示了偏好。当我选择C选项并且做出笔记，“与尖端的相比我选择被广泛支持的，”那个偏向被记住。下一次有个相同的决定，系统知道高度权衡兼容性。
Strategy 8: Review with style agents
策略8:用风格代理检查
What it does:Runs the completed plan through specialized reviewers that check for your preferences
它做什么：通过特别的检查运行完全的计划，来检查你的偏向
When to use it:Final planning step, before implementation
什么时间用：最后的计划阶段，在实施之前
The agent’s job:Catch misalignments with your coding style and architecture preferences
代理的工作：用你的代码风格和建筑风格理解不重合
I have three review agents that run automatically:
我有三个自动运行的检查代理：
Simplification agent:Flags over-engineering. “Do we really need three database tables for this? Could one table with a type field work?”
简化代理：标记过度编程。“我们真的需要三个数据表格吗？一种类型田野工作的表格可以吗？”
Security agent:Checks for common vulnerabilities. “This plan allows user input directly into a database query—add input sanitization.”
安全代理：检查一般的易感性。“这个计划允许用户直接输入进一个数据库问询-加入输入清理。”
Kieran-style agent:Enforces my personal preferences. “This uses complex joins (combining data from multiple database tables in a single query). Kieran prefers simple queries. Consider denormalizing (storing redundant data for simpler queries).”
Kieran风格的代理：强化我的个人偏好。“这个使用复杂的加入（在一个问询中从多样的数据库表格中结合数据）。Kieran偏向简单的问询。考虑去正常化（为更简单的问询储存冗余数据）。”
Plans get better before any code is written.
在写任何代码之前计划得更好。
Why this compounds:These agents accumulate your taste over time. Every time I indicate, “I don’t like this” or “Good catch,” the system gets smarter.
为什么这个复合：随着时间的推移这些代理积累你的品味。每次我暗示，“我不喜欢这个”或者“理解得很好，”系统就变得更聪明。
Getting started: Try this today
开始：今天试一下这个
You don’t need to build everything from scratch. I’ve open-sourced my planning system onEvery’s Github marketplace. Install it in Claude Code, and you’ll have working /plan slash command and research agents immediately. You can alsouse my pluginin Claude Code or Droid.
But you can also start more simply by applying the thinking to your next feature:
你不需要从零开始构建一切。我已经在Every GitHub市场区开源了我的计划系统。把这个装到Claude Code里面，你就会即刻拥有工作/计划命令和研究代理。你也可以使用我在Claude Code或者Droid中的插件。但你也可以通过将你的思考应用到你的下一个特征中开始：
Pick one Fidelity Two feature you’re building this week.It should span multiple files and have clear scope, like adding a new view, implementing a feedback system, or refactoring a component (a reusable piece of your application).
选忠诚度2中的你这周正在构建的一个特征。它应该覆盖多个文件有明确的范围，像是加入一个新视角，实施一个反馈系统，或者重构一个组成部分（对你的应用一个可重使用的部分）。
Before prompting Claude Code or Cursor to build it, spend 15-20 minutes researching:
在提示Claude Code或者Cursor去构建它之前，花15到20分钟去研究：
- Best practices:How have others solved similar problems? Search the web for blog posts, Stack Overflow discussions, and documentation.
- 最好的实践：别人是怎么处理相似的问题的？上网搜索博客文章，栈过载讨论和文档。
- Your patterns:How haveyousolved similar problems? Search your existing codebase for comparable features.
- 你的模式：你之前怎么处理相似的问题的？搜索你现有的代码库来获取可比较的特点。
- Library capabilities:What do your tools actually support? If you’re using a specific code library, have AI read its documentation or source code
- 库能力：你的工具实际上支持什么？如果你使用一个特定的代码库，AI读取了它的文档或者源代码
Have AI synthesize this research into a plan showing:
AI是否综合了这个研究进一个计划展示：
- The problem being solved (one clear sentence)
- 问题被解决（一个清晰的句子）
- Two or three solution approaches (with honest pros and cons of each)
- 两到三个解决路径（每个都有实在的优劣）
- Which existing code patterns this should match
- 这个应该匹配哪个现存的代码模式
- Any edge cases or security considerations
- 任何极端情况或者安全考量
Review the plan and notice your reactions. When you think “this is too complex” or “we already have a better way to do this,” don’t just fix this plan—capture why you think that. Write it down.
检查计划并注意你的反应。当你考虑“这个太复杂”或者“我们早就有更好的做这个的方法，”不要仅仅是修复这个计划-理解你为什么那样想。写下来。
Ship the feature based on the plan,then compare the final implementation to the original plan. Where did you diverge? Why? What would have made the plan better?
基于计划交付这个特征，然后对最初的计划完成比较最后的实施。你叉开去哪儿了？为什么？什么能让这个计划更好？
Take 10 minutes to codify one learning.The simplest way: Add it to your CLAUDE.md file. Write one rule: “When doing X type of work, remember to check Y,” or “I prefer approach A over approach B because of reason C.”
花十分钟来编纂一个学习。最简单的方式：把这个加入到你的文档中。写下一个规则：“当做X类的工作时，记住去检查Y，”或者“我倾向于方法A而不是方法B是因为理由C。”
As you accumulate more learnings, create specialized research agents or commands you can call, such as an “Event Tracking Expert” that knows your patterns, or a “Security Checker” that flags common mistakes. Each agent is just codified knowledge that runs automatically.
当你积累更多的学习时，创造你能召唤的特别的代理或者命令，比如“事件追踪专家”知道你的模式，或者一个“安全检查者”能发现常见的错误。每个代理都是编纂能自动化运行的知识。
That was just one feature, one planning session, one captured learning. Next week, do it again. Reference your notes. See if the second plan is better than the first. In a few months, you’ll have a system that knows how you think.
那只是一个特点，一个计划期，一个理解的学习。下一周，再做一次。提到你的笔记。看看第二个计划是否比第一个更好。在几个月的时间内，你会有一个知道你如何思考的系统。
