译文对照：《我怎么用 Cursor》前半篇（How I Use Cursor）

［图片：我怎么用 Cursor］

［图片：我如何使用 Cursor］

［图片：我如何使用 Cursor］

［图片：我如何使用 Cursor］

［图片：我怎么用 Cursor］

［图片：我是怎么用 Cursor 的］

［图片：我如何使用 Cursor］

有件事我想先说清楚。在去面试 @cursor_ai 之前，我其实从没真正用过 Cursor。

有件事我得坦白。去 @cursor_ai 面试之前，我其实从没用过 Cursor。

有件事我得坦白。在参加 @cursor_ai 的面试之前，我其实从未用过 Cursor。

我得坦白一件事。在 @cursor_ai 面试之前，我其实从没用过 Cursor。

我得先坦白一件事。面试 @cursor_ai 之前，我从来没真正用过 Cursor。

有件事我得坦白。去 @cursor_ai 面试之前，我其实从来没用过 Cursor。

有件事我得先一吐为快。去 @cursor_ai 面试之前，我其实从来没真正用过 Cursor。

在 Meta，Claude Code 当时火得不行。我甚至为自己的 side project 付了每月 200 美元的个人方案。我喜欢它足够简单，上手就能感到高效。卡住我的地方是：我想自己做一套 skills，把 cc 拧成几乎什么都能干的样子。我甚至开始在它上面自己写 agent 编排工具。

在 Meta，Claude Code 火得一塌糊涂。我甚至自掏腰包，为业余项目买了每月 200 美元的个人套餐。我喜欢它简单，也喜欢它让我很快就进入高效状态。真正让我离不开它的，是我自己攒下的一套 skills。靠这些 skills，cc 几乎能变成我想要的任何东西。我甚至开始在它之上开发自己的 agent 编排工具。

在 Meta，Claude Code 正迅速风靡起来。我甚至自掏腰包，为自己的业余项目订了每月 200 美元的套餐。我喜欢它的简单，也喜欢那种很快就能高效做事的感觉。真正吸引我的是开发自己的一套 skills，让 cc 几乎能变成我想要的任何东西。我甚至开始在它之上开发自己的 agent 编排工具。

在 Meta，Claude Code 当时正火爆发展。我甚至为了自己的业余项目买了一个月 200 美元的个人套餐。我喜欢它的简单，也喜欢它能让我迅速感受到生产力。对我来说，难点在于开发自己的一套 skills，把 cc 变成几乎任何我想要的样子。我甚至开始在它之上开发自己的 agent 编排工具。

在 Meta，Claude Code 当时正在爆发式增长。我甚至为了业余项目，买了每月 200 美元的个人套餐。我喜欢它简单，也喜欢自己很快就能做出东西。我的卡点在于自己做一套 skills，把 cc 变成几乎任何我想要的东西。我甚至开始在它上面做自己的 agent 编排工具。

在 Meta 的时候，Claude Code 正火得一塌糊涂。我甚至自掏腰包订了每月 200 美元的个人套餐，用来做自己的业余项目。我喜欢它的简单，喜欢上手就能出活。最让我着迷的是打造自己的一套 skills，把 cc 变成几乎任何我想要的样子。我甚至在它之上开始写自己的 agent 编排工具。

在 Meta 的时候，Claude Code 正在爆发式流行。我甚至为副业项目自费买了每月 200 美元的个人套餐。我喜欢它的简单，也喜欢自己这么快就有产出感。最让我着迷的，是自己写一套 skills，把 cc 变成几乎任何我想要的东西。我甚至开始在它上面做自己的 agent 编排工具。

onsite 面试那两天，我用 Cursor 做面试项目。那是 Cursor 3 发布之前，所以我用的是 Editor Window。我用 vscode 已经很多年，大部分快捷键还在「上下文窗口」里，回到 IDE 并不难。不过说实话，头一两个小时我确实很想念 cli。到处去点东西，感觉近乎野蛮。但有几件事真正让我眼前一亮。

现场面试那两天，我一直用 Cursor 做面试项目。当时 Cursor 3 还没发布，所以我用的是 Editor Window。我用 vscode 已经很多年，大部分快捷键还留在我的上下文窗口里，所以回到 IDE 并不算难。不过说实话，头一两个小时我确实怀念 cli。用鼠标点来点去，感觉简直有点原始。但有几件事让我印象很深。

现场面试期间，我连续两天使用 Cursor 来构建面试项目。当时 Cursor 3 还没发布，所以我用的是 Editor Window。多年来我一直在用 vscode，大多数键盘快捷键还留在我的上下文窗口里，因此重新用回 IDE 并不太难。不过说实话，最初一两个小时里，我确实很想念 CLI。用鼠标点来点去，简直原始得近乎野蛮。但有几件事确实让我眼前一亮。

在现场面试的 2 天里，我用 Cursor 做面试项目。那是在 Cursor 3 发布之前，所以我用的是 Editor Window。那时候我已经用了好多年 vscode，大部分快捷键还在我的上下文里，所以回到 IDE 并不太难。但我不能说谎。在头一两个小时里，我确实很想念 cli。用鼠标点来点去感觉简直像未开化。不过有几点确实让我印象深刻。

现场面试那两天，我用 Cursor 做面试项目。那时 Cursor 3 还没发布，所以我用的是编辑器窗口。我用 vscode 已经很多年，大部分快捷键还留在我的上下文窗口里，所以回到 IDE 并不难。不过说实话。头一两个小时，我确实很怀念命令行。用鼠标点来点去，感觉近乎野蛮。但有几件事真的让我印象很深。

现场面试那两天，我用 Cursor 做面试项目。那时 Cursor 3 还没发布，我用的是 Editor Window。到那会儿我已经用了很多年 vscode，大部分快捷键还在我的上下文窗口里，所以回到 IDE 并不算难。但说实话，头一两个小时我确实很想 cli。到处点来点去，感觉简直像原始人。不过有几件事真的让我眼前一亮。

现场面试那两天，我全程用 Cursor 搭面试项目。那时 Cursor 3 还没发布，所以我用的是 Editor Window。我用 vscode 已经太多年，大部分快捷键还留在我的上下文窗口里，所以回到 IDE 不算太难。但老实说，头一两个小时我确实很想念 cli。什么都要用鼠标点，感觉简直原始。不过有几样东西真的让我眼前一亮。

第一，我当时习惯的模型（Opus 和 Codex）不知怎么感觉更聪明。而且能随时切换模型，在项目不同部分同时用两者（Opus 做前端，Codex 做系统），这一点很惊人。面试之前，我已经在大谈多模型 adversarial review，所以能在 UI 里原生做这件事，感觉非常自然。更好的是能拉起不同模型的 subagent，一次对话里两边的长处都能用上。

第一，我当时用惯的模型（Opus 和 Codex）不知怎么变聪明了。还能随时切换模型，在项目的不同部分同时用上两个（前端用 Opus，系统层用 Codex），这太棒了。面试之前，我就已经在到处夸多模型对抗式审查，所以能在界面里原生做到这件事，感觉非常自然。更好的是，还能派出不同模型的子代理，在一次对话里把两边的长处都拿到。

第一，我当时常用的模型 Opus 和 Codex 不知为何感觉更聪明了。能随时切换模型，还能让两者同时处理项目的不同部分，实在太棒了（Opus 做前端，Codex 做系统）。面试之前，我就一直在大力称赞多模型对抗式审查，因此能直接在 UI 里这么做，感觉非常自然。更棒的是还能创建不同模型的子代理，让我在一次对话中兼得两者之长。

第一，我当时用惯的 Opus 和 Codex 模型，不知怎么的，感觉更聪明了。而且能随时切换模型，甚至在项目的不同部分同时用这俩模型（Opus 做前端，Codex 做系统），这太神奇了。在面试前，我已经非常推崇多模型的 对抗审查，所以能在 UI 里原生做这件事感觉非常自然。更好的是还能派生不同模型的子代理，这样我在一次对话里就能兼得两者的优势。

第一，我当时用惯的模型，Opus 和 Codex，不知怎么就感觉更聪明了。能随时切换模型，还能同时用在项目的不同部分，这点好得惊人。Opus 做前端，Codex 做系统。面试之前，我就已经对多模型的对抗式审查赞不绝口，所以能在界面里原生做这件事，感觉很自然。更好的是，我能拉起不同模型的子代理，在一次对话里把两边的长处都拿到。

第一，我当时用惯的模型，Opus 和 Codex，感觉莫名更聪明了。能随时切换模型，在项目的不同部分同时用上两个（Opus 写前端，Codex 写系统），这感觉太棒了。面试之前我就已经在到处安利多模型的对抗式评审，所以能在 UI 里原生这么做，感觉非常自然。更棒的是可以起不同模型的子代理，一次对话里两头的好处都能占到。

第一，我当时用惯的模型，Opus 和 Codex，在这里不知怎么感觉更聪明了。而且能随时切换模型，在项目的不同部分同时用两个（前端交给 Opus，系统交给 Codex），这一点太棒了。面试之前，我就已经在到处安利多模型对抗式 review，所以能在 UI 里原生做到这一点，感觉非常自然。更好的是还能拉起不同模型的子代理，一次对话里把两边的好处都占上。

第二，compaction 快得离谱。用 cc 时，compact 往往要好几分钟，所以我总在盯着上下文和 plan 用量。Cursor 里快到我彻底震惊，以至于我几乎从不需要看还剩多少上下文。它就是能用。而在 cc 里，compact 之后我经常觉得模型突然变笨了很多。

第二，压缩上下文快得离谱。作为 cc 用户，我习惯了压缩一次要好几分钟，所以一直时刻盯着上下文和套餐用量。Cursor 里压缩这么快，我完全震惊了。快到我基本再也不用去看上下文用了多少。它就是好用。而在 cc 里，我常常觉得压缩之后模型一下子变得特别笨。

第二，上下文压缩快得惊人。作为 cc 用户，我早已习惯压缩要等上好几分钟，所以总得时刻盯着上下文和套餐用量。Cursor 的速度快得让我无比震惊，快到我基本不用再查看用了多少上下文。它就是能正常工作；而用 cc 时，我常觉得模型压缩后一下子变得特别笨。

第二，compaction 快得离谱。作为一个 cc 用户，我习惯了 compaction 动辄好几分钟，所以我总是时刻警惕我的上下文和套餐用量。所以 Cursor 里的速度彻底震惊了我。以至于我基本上不用去看用了多少上下文。它就是能用，而在 cc 里我经常觉得模型在 compaction 后就变傻了。

第二，压缩快得离谱。用 cc 的时候，我习惯了压缩要花好几分钟，于是一刻不停地盯着上下文和套餐用量。所以 Cursor 里的速度让我彻底震住了。快到我基本上不用再看上下文用了多少。它就是能用。在 cc 里，我却常常觉得模型一压缩完就变得特别笨。

第二，压缩快得离谱。作为 cc 用户，我习惯了压缩一次要好几分钟，所以总是时刻盯着自己的上下文和套餐用量。Cursor 快得让我震惊，快到我基本不用再看自己用了多少上下文。它就是能用。而在 cc 里，我常常觉得模型一压缩完就变蠢了一大截。

第二，压缩快得离谱。作为 cc 用户，我习惯了压缩要花好几分钟，所以一直对自己的上下文和 plan 用量保持警惕。Cursor 里的速度让我彻底震惊，快到我基本不用看自己用了多少上下文。它就是能用，而在 cc 里，压缩之后我常觉得模型直接变傻了。

第三，我注意到 GUI 相对 TUI 能多给多少东西。能直接在 Cursor 的浏览器里打开你的应用，用 Design Mode 改设计，感觉很直觉，也让我开始想：专用 UI 能让 agentic coding 有效多少。

我注意到的第三件事，是 GUI 能比 TUI 多给出很多东西。直接在 Cursor 的浏览器里打开自己的应用，用 Design Mode 改设计，感觉很直观。这也让我开始想：专门设计的界面，能让 agent 编程有效多少。

我注意到的第三件事，是 GUI 相比 TUI 能多做多少事情。可以直接在 Cursor 的浏览器里打开应用，再用 Design Mode 修改设计，感觉很直观。这也让我开始思考，为特定用途打造的 UI 能在多大程度上提升 agent 编程的效率。

第三点我注意到的是，GUI 能比 TUI 提供多得多的东西。能直接在 Cursor 的浏览器里打开应用，用 Design Mode 修改设计，感觉很直观，也让我开始思考专用的 UI 能在多大程度上让 agent 编程更高效。

我注意到的第三件事，是图形界面能比文本界面多提供多少。可以直接在 Cursor 的浏览器里打开应用，再用 Design Mode 改设计，感觉很直观。这也让我开始想，专门做的界面能让用 agent 写代码有效到什么程度。

我注意到的第三点，是 GUI 比 TUI 能多给多少东西。直接在 Cursor 的浏览器里打开你的应用，用 Design Mode 改设计，用起来很直觉，也让我开始琢磨：专门打造的 UI 能让 agentic coding 高效多少。

第三，我注意到 GUI 比 TUI 能多给多少东西。能直接在 Cursor 内置浏览器里打开应用、用 Design Mode 改设计，这很直觉，也让我开始琢磨：专门打造的 UI，到底能把 agent 编程变得多有效。

用 Cursor 做 Cursor

用 Cursor 开发 Cursor

用 Cursor 构建 Cursor

用 Cursor 构建 Cursor

用 Cursor 做 Cursor

用 Cursor 开发 Cursor

用 Cursor 造 Cursor

三月底入职以来，我主要做 Cursor 3 的 Agent Window，也把它当日常主力。我仍然觉得 cc 是个很酷的产品，团队也很棒，但我注意到它的简单往往会推着人去包一层自己的抽象。上一份工作里，感觉每周都会冒出一个基于 cc 的内部编排工具。

三月底入职以来，我主要在做 Cursor 3 的 Agent Window，也把它当作日常主力工具。我仍然觉得 cc 是个很酷的产品，团队也很棒。但我注意到，它太简单了，往往让人想在外面再包一层自己的抽象。在上一份工作里，感觉每周都有人宣布一个基于 cc 的新内部编排工具。

自从三月底加入以来，我主要负责 Cursor 3 的 Agent Window，也一直把它作为日常主力工具。虽然我仍然认为 cc 是一款很酷的产品，背后也有一支出色的团队，但我发现，它的简单往往会让人想在外面再包一层，构建自己的抽象。在我上一份工作里，感觉每周都会有人发布一个基于 cc 构建的新内部编排工具。

自 3 月底加入以来，我主要在做 Cursor 3 的 Agent Window，并把它作为日常主力。虽然我仍然觉得 cc 是个很酷的产品，团队也很棒，但我注意到它的简单往往会驱使人们想在它外面包装自己的一套抽象。在上一份工作里，感觉每周都会宣布一个构建在 cc 之上的新内部编排工具。

三月底加入以来，我主要在做 Cursor 3 的 Agent 窗口，并且把它当成我每天的主力工具。我仍然觉得 cc 是个很酷的产品，团队也很强。但它的简单，往往会让人想自己做一层抽象，把它包起来。上一份工作里，感觉几乎每周都会宣布一个新的内部编排工具，就建在 cc 上面。

三月底入职以来，我主要在做 Cursor 3 的 Agent Window，日常也拿它当主力工具。我依然觉得 cc 是个很酷的产品，团队也很棒，但我注意到，它的简单反而会推着人想自己在它外面包一层抽象。在上一份工作时，感觉每周都有一个建在 cc 之上的内部编排工具发布。

三月底入职以来，我的工作主要在 Cursor 3 的 Agent Window 上，它也是我每天的主力。我仍然觉得 cc 是个很酷的产品，团队也很棒，但我注意到，它的简单反而会推着大家想在它外面包一层自己的抽象。在上一份工作里，感觉每周都有人宣布一个新的、基于 cc 的内部编排工具。

@bcherny 经常谈「latent demand」这个概念：

@bcherny 经常讲「潜在需求」这个概念：

@bcherny 经常谈到「潜在需求」这个概念：

@bcherny 经常谈到「潜在需求」这个概念：

@bcherny 经常讲「潜在需求」这个想法：

@bcherny 经常讲「潜在需求」这个说法：

@bcherny 经常谈「潜在需求」这个想法：

"There's this really old idea in product called latent demand... you build a product in a way that is hackable, that is kind of open-ended enough that people can abuse it for other use cases. Then you see how people abuse it and then you build for that."

「产品领域有个很老的想法，叫潜在需求……你把产品做得可以随便折腾，足够开放，让人能把它滥用到别的用途上。然后你看人们怎么滥用它，再照着这个去做产品。」

「产品领域有个非常古老的概念，叫作潜在需求……你用一种可改造的方式构建产品，让它足够开放，使人们能拿去做其他用途。然后观察大家怎么使用它，再针对这些用法来构建产品。」

「产品里有个很老的想法叫潜在需求……你把产品做得很 hackable，足够开放，以至于人们可以为了别的用例来滥用它。然后你看看人们是怎么滥用的，接着你就为那个需求去构建产品。」

「产品这行有个很老的概念，叫潜在需求……你把产品做得可以魔改，也算开放到足以让人把它滥用到别的用途上。然后你看人们怎么滥用，再照着那个做。」

「产品领域有个很老的说法叫潜在需求……你把产品做得容易改造、足够开放，人们就会拿它折腾出别的用法。然后你观察大家怎么折腾，再照着那个方向做。」

「产品圈有个很老的想法，叫潜在需求……你把产品做得可以折腾，开放到人们能拿它去干别的用场。然后你看大家怎么折腾它，再照着那些用法去造产品。」

说的就是这个！大家纷纷做出编排工具，暴露出的 latent demand 是：用 cli 时，你这个人自己就是编排者。

正是这样！大家不约而同地去做编排工具，暴露出的潜在需求是：用 cli，就等于让你这个人自己当编排器。

说的正是这个！大家不约而同地做起编排工具，恰恰暴露了其中的潜在需求：使用 CLI 时，作为人类的你其实就是编排者。

就是这样！大家纷纷做编排工具，暴露出的潜在需求是：用 cli 只会让你这个人类成为编排者。

说的就是这个。大家纷纷去做编排工具，暴露出的潜在需求就是：用命令行，就会让你这个人自己当编排者。

说的就是这个！大家不约而同地去做编排工具，恰恰暴露了潜在需求：只用 cli，你这个人自己就成了编排者。

说的就是这个！大家纷纷做编排工具，暴露出的潜在需求是：用 cli 干活的时候，当编排者的就是你这个人。

但我用过的每种 agent 工作流，都把重点放错了。在 GUI 里跑多个 CLI，完全没抓住点。我真正关心的做法是：建立对 agents 的信任。

但我用过的每一种 agent 工作流，重点都放错了。在 GUI 里跑多个 CLI，完全没抓住要点。我感兴趣的做法，是建立对 agent 的信任。

但我用过的每一种 agent 工作流都把重点放错了。在 GUI 里运行多个 CLI，完全没有抓住要点。我真正感兴趣的方向，是建立对 agent 的信任。

但我用过的每一个 agent 工作流都关注错了重点。在 GUI 里跑多个 cli 完全没抓住要领。我感兴趣的方法是建立对 agent 的信任。

但我用过的每一种 agent 工作流，关注点都不对。在图形界面里跑好几个命令行，完全没抓到真正的重点。我感兴趣的做法，是建立对 agent 的信任。

但我用过的每个 agent 工作流都搞错了重点。在 GUI 里跑多个 CLI 完全没抓住要害。我感兴趣的方向是建立对 agent 的信任。

但我用过的每一种 agent 工作流都把重心放错了。在 GUI 里跑多个 CLI，完全没抓住重点。我感兴趣的路子，是建立对 agent 的信任。

做过工程经理之后，我很快意识到，管 agents 很像搭一支人类工程团队。新人需要 onboarding，才能理解代码库，也理解工作怎么推进。他们入职时已经带着从过去经验里练出来的 skills：怎么 debug、怎么写出高质量代码和测试、怎么沟通，等等。

我以前做过工程经理，很快就意识到，管理 agent 跟组建一支由人组成的工程团队很像。新人入职需要引导，让他们了解代码库，也了解活是怎么干的。他们入职时已经「预训练」过，带着从过去经历里学来的 skills：比如怎么调试，怎么写高质量的代码和测试，怎么沟通。

我以前做过工程经理，很快就意识到，管理 agent 与组建人类工程团队颇为相似。新员工需要接受入职引导，既要理解代码库，也要了解团队如何开展工作。他们加入时已经带着从过往经验中学到的 skills：比如如何调试、如何编写高质量代码和测试，以及如何沟通。

作为一名前研发经理，我很快意识到管理 agent 感觉很像建设一支人类研发团队。新员工需要入职培训，不仅要让他们了解代码库，还要了解工作是怎么推进的。他们加入时已经带着从过去经验里学到的技能做过预训练了：比如怎么调试，怎么写高质量的代码和测试，怎么沟通等等。

我以前做过工程经理，很快就发现，管 agent 的感觉很像在带一支由人组成的工程团队。新人得先入职适应，才会理解代码库，也才会理解事情是怎么做成的。他们进组时就已经预训练好了，skills 来自过去的经验：怎么调试，怎么写高质量的代码和测试，怎么沟通，这只是其中几样。

我以前当过工程经理，很快意识到管 agent 和带一支人类工程团队很像。新员工入职要有人带，既要懂代码库，也要懂工作是怎么开展的。他们入职时已经带着过去经验训练出的技能：怎么调试、怎么写出高质量的代码和测试、怎么沟通，等等。

我以前做过工程经理，很快就意识到，管理 agent 的感觉跟带一支人类工程团队很像。新人需要入职引导，才能看懂代码库，也要弄明白这里的活是怎么干的。他们入职时已经带着过往经历里攒下的 skills：怎么调试、怎么写出高质量的代码和测试、怎么沟通，等等。

Agents 像永远处于失忆和愚钝状态的新人。你跟他们说的话他们记不住，也学不会真正新的东西。但我们可以给他们配上 rules、skills、tools 和长期记忆，去近似那种能力。他们能干又蠢，而且很可教。我把他们的失败模式当成机会，把我对深度、严谨工程的一切都教给他们。

agent 就像一直失忆、一直犯傻的新人。你跟它们说的话，它们记不住，也从来没真正学会什么新东西。但我们可以给它们配上 rules、skills、工具和长期记忆，近似地补上这一点。它们有能力，却很笨，而且很好教。我把它们的失败模式看作机会，借此把我做深入、严谨的工程的经验全都教给它们。

Agent 就像总在失忆、总在犯傻的新员工。它们记不住你说过的话，也从未真正学会任何新东西。但我们可以给它们配备 rules、skills、工具和长期记忆，近似实现这些能力。它们有能力，却也愚笨，而且非常容易教。我把它们的各种失败模式视为机会，可以借此教会它们我所知道的一切，做深入、严谨的工程工作。

Agent 就像处于持续健忘和犯傻状态的新员工。它们不记得你告诉过它们什么，也永远学不到什么新东西。但我们可以给它们配备 rules、skills、工具和长期记忆，这能起到近似的效果。它们有能力但又很笨，而且非常容易教。我把它们失败的模式看作机会，教给它们我所知道的关于深度、严谨工程的一切。

agent 就像一直失忆、一直很蠢的新人。你告诉它们的事，它们记不住。新东西，它们也从来不会真正学会。但我们可以给它们配上 rules、skills、工具和长期记忆，用来大致补上这两点。它们有能力，但很蠢，而且很好教。我把它们的失败模式看成机会，把我会的那套深而严谨的工程做法教给它们。

agent 像是永远处在失忆加犯傻状态里的新员工。你跟他说的话他记不住，也永远学不会新东西。但我们可以给他配上 rules、skills、工具和长期记忆，近似地补上这些。他能干，但笨，而且特别好教。我把他的失败模式看成机会，把我在深入、严谨的工程实践里知道的一切都教给他。

Agent 就像永远处于失忆和犯蠢状态的新员工。它们不记得你告诉过它们什么，也从来不会真的学会新东西。但我们可以给它们配上 rules、skills、工具和长期记忆，把这些近似补齐。它们有本事，却又蠢，还特别好教。我把它们的失败模式看成机会，把我懂的所有深入、严谨的工程方法教给它们。

因为一旦没有严谨，agents 就会阿谀奉承，为了写出你要的代码什么都干得出来。而且它确实能、也确实会写出一大堆。天真的并行化，只是让他们更快地写出 slop。

因为一旦没有严谨，agent 就会一味讨好，不惜一切去写出你要的代码。而且天哪，它能写，也一定会写出一大堆。天真的并行化只会让它们更快地产出 slop。

因为一旦缺少严谨，agent 就会一味迎合你，想尽办法写出你要求的代码。而且它真能、也真会写出海量代码。天真地并行处理，只会让它们更快地写出 slop。

因为如果没有严谨性，agent 会谄媚地不惜一切代价写出你要求的代码。天哪，它能写而且会写出一大堆代码。朴素的并行化只会让它们写 slop 的速度更快。

因为一旦缺了严谨，agent 就会一味迎合，不惜一切写出你要的那段代码。而且它还真能写很多，也一定会写很多。天真地并行，只会让它们把 slop 写得更快。

因为一旦不讲严谨，agent 就会一味迎合，不择手段也要把你要的那段代码写出来。而且它不但能写，还真的会写，一写就是一大堆。简单粗暴的并行化只会让它们更快地生产 slop。

因为一旦没了严谨，agent 会一味讨好，想尽一切办法把你点名要的那段代码写出来。而且说真的，它们能写很多，也一定会写很多。天真的并行化只会让它们更快地写 slop。

我越来越确信，并行编排很多 agent 的价值来自往深处走，而不是铺得很广。你要在一个或少数几个问题上走得更深，才能把得到好结果的机会拉到最大：

• best of N 式赛跑，找出最好的解法
• 对抗式评审
• 多个 agent 一起尝试复现一个被报告的问题
• 不同工作负载用不同模型

引用 @mattpocockuk 的话，「code is not cheap」。

这比在 10 个不同问题上切换上下文要强。瓶颈仍然是我自己，我得记住、并在自己的上下文窗口里装着这些 agent 在做什么。我想更好的界面以后能解这个。

还有信任。信任越多，你站的视角就越高。信任很少时，你必须盯着每一个 agent。能放手时，你才能委派更多。这和管人一模一样。

— @poteto

我越来越相信，并行编排许多 agent 的价值在于做深，而不是铺广。你要在一个或少数几个问题上钻得更深，这样才能尽量提高拿到好结果的机会：

• best of N 式的竞速，找出最好的解法
• 对抗式审查
• 让多个 agent 尝试复现同一个报告上来的问题
• 不同类型的工作交给不同的模型

借 @mattpocockuk 的话说：「代码并不便宜」。

这比在许多 agent 之间来回切换上下文要好，那些 agent 各自在做 10 个不同的问题。瓶颈仍然是我：我得记住我的 agent 在做什么，还得把这些装进我自己的上下文窗口。我觉得会有办法用更好的界面解决这个问题。

还有信任的因素。信任越多，你在视角的阶梯上就能站得越高。信任很少时，你只能盯紧每一个 agent，事无巨细地管。能放手时，你就能委派更多。这跟管人一模一样！

@poteto

我越来越确信，并行编排大量 agent 的价值来自纵深，而不是广度。你应该在一个或少数几个问题上挖得更深，从而尽量提高获得出色结果的概率：

• 采用 best of N 式竞赛，找出最佳方案
• 对抗式审查
• 让多个 agent 尝试复现报告的问题
• 针对不同类型的工作负载使用不同模型

引用 @mattpocockuk 的话：「代码并不廉价」。

这比让许多 agent 分别处理 10 个不同问题、自己不断切换上下文更好。瓶颈仍然在我：我得记住每个 agent 在做什么，还要把这些信息留在自己的上下文窗口里。我觉得更好的 UI 会有办法解决这个问题。

这里还有信任的因素。信任越多，你就越能从更高层次看问题。信任很少时，你必须对每一个 agent 事事过问。能够放手时，你就可以委派更多工作。这和管理人完全一样！

@poteto

我越来越相信，并行编排许多 agent 的价值在于做深，而不是做广。你想在一个或几个问题上钻得更深，这样才能把获得绝佳结果的机会最大化：

• best of N 风格的竞赛，用来寻找最佳方案
• 对抗审查
• 多个 agent 尝试复现上报的问题
• 对不同类型的工作负载使用不同的模型

引用 @mattpocockuk 的话，「代码不便宜」。

这胜过试图在处理 10 个不同问题的许多 agent 之间切换上下文。瓶颈依然在于我要努力记住，并在我自己的上下文里保持我的 agent 都在做些什么。我认为未来会有通过更好的 UI 来解决这个问题的方法。

这里还有信任的因素。你信任越多，你在视角的阶梯上就能爬得越高。当你没多少信任时，你必须微观管理每一个 agent。当你能放手时，你就能委派更多工作。这完全就像管理人类一样！

• @poteto

我越来越确信，并行编排很多 agent 的价值在于做深。往广里铺开，得不到这份价值。你要把一个问题做得更深，或者把少数几个问题做得更深，才最有机会拿到好结果：

• 多开几路一起赛，挑出最好的方案
• 对抗式审查
• 多个 agent 一起试着复现别人报的问题
• 不同类型的活，用不同的模型

引用 @mattpocockuk 的话，「代码并不便宜」。

这比在做着 10 个不同问题的许多 agent 之间来回切换要好。瓶颈还是我自己。我得记住各个 agent 在做什么，并把这些留在自己的上下文窗口里。我觉得以后能靠更好的界面来解决。

还有信任这一层。信任越多，你能把视角抬得越高。信任很少的时候，你就必须微观管理每一个 agent。能放手的时候，就可以多委派一些。这跟管人一模一样！

@poteto

我越来越确信，并行编排多个 agent 的价值在于做深，而不是做宽。要在一个或少数几个问题上挖得更深，这样才最有可能拿到好结果：

• 用 best of N 式赛跑找出最佳方案
• 对抗式评审
• 多个 agent 一起复现上报的问题
• 不同类型的工作负载用不同的模型

借用 @mattpocockuk 的话：「代码并不便宜」。

这好过让许多 agent 分散在 10 个不同的问题上，自己在中间来回切换上下文。瓶颈始终在我：我得记住每个 agent 在做什么，装进自己的上下文窗口里。我觉得会有办法用更好的 ui 解决这个问题。

还有信任这个因素。信任越多，你在视角阶梯上就能站得越高。信任不够，你就得对每个 agent 都管到最细。你放得开手，才能交出更多。这跟带人一模一样！

— @poteto

我越来越确信，并行编排一大堆 agent 的价值来自「深」，不是「广」。你要在一个或几个问题上挖得更深，把拿到好结果的概率拉到最高：

• best of N 式竞速，找最好的解
• 对抗式 review
• 多个 agent 尝试复现一个上报的问题
• 不同类型的活用不同的模型

用 @mattpocockuk 的话说：「代码并不便宜」。

这比同时开十个问题、在一堆 agent 之间来回切上下文要强。瓶颈还是我自己：我得记住每个 agent 在干什么，把它们装在我自己的上下文窗口里。我觉得更好的 ui 能解决这件事。

还有信任这一层。信任越多，你在视角阶梯上就爬得越高。信任少的时候，每一个 agent 你都得事事盯着管。能撒手的时候，你就能把更多交出去。这跟带人一模一样！

— @poteto

想快，先深

想快，先做深

想提速，先深入

想走得快，先走得深

想快，先做深

想快，先往深里做

想快，先做深

我确实认为 agent 编排可以做得有产出。但我们需要 depth first。

我确实认为 agent 编排可以做得高效。但我们得深度优先。

我确实认为，agent 编排可以富有成效。但我们得先向深处走。

我确实认为 agent 编排可以做得富有成效。但我们需要优先做深。

我确实觉得，agent 编排可以做得很有成效。但我们得先做深。

我确实认为 agent 编排是可以做出成效的。但我们得先往深里走。

我确实认为 agent 编排可以高效地做出来。但得先往深里做。

我把 pstack 开源了。这是我每天用来做 @cursor_ai 的个人 skills 与工程原则集合。这些 skills 的早期版本先在 side project 里长出来，之后一直在打磨。

我要开源 pstack。这是我个人的一套 skills 和工程原则，我每天都用它们开发 @cursor_ai。这些 skills 的早期版本，是我在业余项目里开始做的，之后一直在打磨。

我要把 pstack 开源。它是我个人的一套 skills 和工程原则，我每天都用它们来构建 @cursor_ai。我从自己的业余项目中就开始开发这些 skills 的早期版本，此后一直在不断完善。

我开源了 pstack，这是我每天用来开发 @cursor_ai 的个人 skills 集合和工程原则。我早在业余项目里就开始开发这些 skills 的早期版本，并从那时起就一直不断完善它们。

我开源了 pstack。这是我的一套个人 skills 和工程原则，我每天用它来做 @cursor_ai。这些 skills 的早期版本，是我在业余项目里开始做的，之后我一直在打磨。

我正在开源 pstack：我每天用来开发 @cursor_ai 的一套个人 skills 和工程原则。这些 skills 的早期版本，是我在自己的业余项目里开始写的，之后一直在打磨。

我把 pstack 开源了。这是我个人的一套 skills 和工程原则，我每天都在用它开发 @cursor_ai。最早那几版 skills 是在副业项目里写的，之后一直在打磨。

在这里拿：https://cursor.com/marketplace/cursor/pstack

在这里获取：https://cursor.com/marketplace/cursor/pstack

在这里获取：https://cursor.com/marketplace/cursor/pstack

在这里获取：https://cursor.com/marketplace/cursor/pstack

在这里获取：https://cursor.com/marketplace/cursor/pstack

在这里获取：https://cursor.com/marketplace/cursor/pstack

在这里安装：https://cursor.com/marketplace/cursor/pstack

/add-plugin pstack

/add-plugin pstack

/add-plugin pstack

/add-plugin pstack

/add-plugin pstack

/add-plugin pstack

/add-plugin pstack

这些 skills 已经成了 Cursor 团队用得最多的 skills 之一，所以我很兴奋能分享给大家。

这些 skills 已经成为 Cursor 团队用得最多的 skills 之一，所以我很高兴能分享给大家。

这些 skills 已经成为 Cursor 团队使用最频繁的一批 skills，所以我很高兴能把它们分享给大家。

这些 skills 已经成为 Cursor 团队最常用的一些 skills，所以我很激动能和你们所有人分享。

这些 skills 已经进入 Cursor 团队用得最多的那一档，所以我很高兴把它分享给你们所有人。

这些 skills 已经成了 Cursor 团队用得最多的一批，所以能分享给大家，我很兴奋。

在 Cursor 团队，这些 skills 已经是大家用得最多的一批，所以我很开心能把它分享给所有人。

［图片：Cursor 的公司排行榜。我的 skills 这周被用了 9k 次！］

［图片：Cursor 公司内部排行榜。这周大家用了我的 skills 9000 次！］

［图片：Cursor 公司内部排行榜。我的 skills 本周使用了 9 千次！］

［图片：Cursor 公司排行榜。这周我的 skills 被用了 9 千次！］

［图片：Cursor 的公司排行榜。我的 skills 这周使用了 9k 次！］

［图片：Cursor 公司内部排行榜。我的 skills 这周被用了 9k 次！］

［图片：Cursor 公司内部排行榜。这周我的 skills 被用了 9k 次！］

Cursor 的公司排行榜。我的 skills 这周被用了 9k 次！

Cursor 公司内部排行榜。这周大家用了我的 skills 9000 次！

Cursor 公司内部排行榜。我的 skills 本周使用了 9 千次！

Cursor 公司排行榜。这周我的 skills 被用了 9 千次！

Cursor 的公司排行榜。我的 skills 这周使用了 9k 次！

Cursor 公司内部排行榜。我的 skills 这周被用了 9k 次！

Cursor 公司内部排行榜。这周我的 skills 被用了 9k 次！

pstack 用多模型教 agents 更严谨。我把观察到的失败模式都做成了 skills。插件的核心是 /poteto-mode：一个更高阶的 skill，按任务给 agents 对应的 playbook。目标不是最大化 LOC，而是反过来：用最少的代码换最大的影响。

pstack 借助多个模型，教 agent 变得更严谨。我把观察到的所有失败模式都做成了 skills。插件的核心是 /poteto-mode，它是一个高阶 skill，会按手头的任务给 agent 找到该照着走的 playbook。目标不是让代码行数最多，恰恰相反：用最少的代码，产生最大的效果。

pstack 使用多个模型，教 agent 更严谨地工作。我把观察到的所有失败模式都做成了 skills。这个插件的核心是 /poteto-mode，它是一种高阶 skill，会根据具体任务为 agent 提供合适的 playbook。目标不是让 LOC 最大化，恰恰相反：用最少的代码产生最大的影响。

pstack 教 agent 使用多个模型变得更加严谨。我把观察到的所有失败模式都变成了 skills。这个插件的核心是 /poteto-mode，这是一个高阶 skill，它为 agent 提供在给定任务下要遵循的正确 playbook。目标不是最大化代码行数（LOC），而是相反：用最少的代码产生最大的影响。

pstack 教 agent 用多个模型把事情做得更严谨。我把观察到的所有失败模式都做成了 skills。插件的核心是 /poteto-mode。它是更高一层的 skill。面对一项任务，它会给 agent 一份该遵循的 playbook。目标不是把代码行数做到最大。恰恰相反：用最少的代码，做出最大的影响。

pstack 用多个模型教 agent 更严谨地做事。我把观察到的所有失败模式都变成了 skills。这个插件的核心是 /poteto-mode，一个更高阶的 skill，针对手上的任务给 agent 选出该遵循的 playbook。目标不是堆出最多的代码行数，而是反过来：用最少的代码，产生最大的影响。

pstack 教 agent 借多个模型把事情做得更严谨。我把自己观察到的所有失败模式都做成了 skills。这个插件的核心是 /poteto-mode，一个更高阶的 skill，它会按手头的任务给 agent 配上对的 playbook。目标不是把代码行数堆到最多，而是恰恰相反：用最少的代码，换最大的影响。