SpaceX AI工程师Grok Bot实战：20+智能体并行，月交付1000+ PR——多智能体工程实践深度解析
一、引言：一觉醒来，20个PR自己合进了主干
2026年8月，SpaceXAI的Grok Bot工程师Lauren Tan（@poteto）在团队工作坊分享了一张GitHub贡献曲线——五个月，超过3000个PR。她同时运行20多个AI智能体，个人月交付量突破1000个PR，团队月交付量直逼2000+。
“一觉醒来，20个PR已经躺在主干分支上了。而且翻了一遍，写得还不错。”
她自己也承认，这话听着像批量制造垃圾代码。但她紧接着补了一句：“我保证我不是。”
这位Lauren Tan不是普通人。她是前Cursor工程师，曾在Meta和Netflix任职，在Netflix担任过两年工程经理，现在负责SpaceXAI的Grok Bot工程团队。她的核心实践——pstack——已经开源在Cursor官方插件仓库中（GitHub: cursor/plugins/pstack），成为多智能体工程领域最受关注的工程实践之一。
来源：36氪《一觉醒来20个PR自己合进了主干》（2026-08-31）；Lauren Tan Maven工作坊分享
二、信任曲线：从"盯着一个智能体"到"撒手20个智能体"
Lauren分享了一张她称之为"信任曲线"的图表。纵轴是信任度，横轴是同时运行的智能体数量，从1到成千上万。
信任度
^
| ____________________
| / \ ← 当前阶段 (10-20 agents)
| / \
|/ \
| \
| \
| \___________
+-------------------------------------------> 同时运行的智能体数量
1 5 10 20 50 100
↑ ↑
五个月前 Star Trek 级
(盯着1个agent不敢眨眼) (尚未到达)
一年前，几乎没人用智能体写代码。模式是：你盯着屏幕，每一行输出都要看，一句一句地提示。无法并行，因为你不信任它。
信任崩塌的典型时刻：有一次她报了个bug，问智能体某个功能为什么不工作。智能体一口咬定是某个地方的问题。她翻开工具调用记录一看——它压根没读那段本该相关的代码。
“智能体在猜，而且它不知道自己在猜。”
Lauren在Netflix当过两年工程经理，她发现——管人的技巧和管智能体的技巧，重合度高得惊人。
三、核心实践一：给智能体造一双眼睛（Control Glass + Feature Map）
Lauren认为，最重要的技能不是提示词，而是验证。
她对验证的定义是：让智能体真的能把代码跑起来——能抓CPU耗时记录，能抓内存快照，能自己打开iOS模拟器点一遍。用户在你的应用上怎么用，它就怎么走一遍，然后自己测，自己验。
没有这一层，瓶颈就是你自己。
传统的开发循环是：你让它改个东西→它写完→你打开本地构建发现不对→截图→复制控制台报错→粘回去→它慢慢理解→再改一版。你在这个循环里当"人肉传送带"。
所以Lauren进Cursor后写的第一批技能之一，叫control glass。这个技能教智能体自己去调Chrome DevTools协议，自己跑起应用，自己截图、点击、读控制台。
但光有control glass还不够——智能体能跑起来应用了，但它不知道这个应用是什么。于是配套的feature map出现了。
┌──────────────────────────────────────────────────┐
│ Feature Map 结构 │
├──────────────────────────────────────────────────┤
│ Feature: 左侧栏卡顿 │
│ ├── 入口: 主窗口左侧导航面板 │
│ ├── 快捷键: Cmd+1 │
│ ├── DOM 选择器: #sidebar-panel │
│ ├── 预期交互: 点击菜单项 → 加载内容 → 渲染 │
│ ├── 验证方式: │
│ │ ├── 截图对比 (pixel diff) │
│ │ ├── 控制台日志检查 (error/warn filter) │
│ │ └── 性能指标 (FPS < 55 即视为异常) │
│ └── 关联文件: │
│ ├── src/sidebar/SidebarPanel.tsx │
│ ├── src/sidebar/hooks/useSidebar.ts │
│ └── src/sidebar/styles/sidebar.css │
└──────────────────────────────────────────────────┘
Feature map把每个功能从用户视角怎么进入、快捷键是什么、甚至选元素该用哪个属性都列好。效果立竿见影——Cursor内部有个Slack频道收用户反馈，质量普遍很差，很多人就丢一张截图配三个问号。有了feature map，智能体也能顺着查下去。
Benny：值夜班的自动化Bug修复智能体
Benny是Lauren开发的自动化智能体，也是Grok Bot的前身。它在Slack里专门接bug报告，跑到云端开一台自己的电脑，在里面运行Cursor，用同一套control glass技能操作应用，试着把问题复现出来。
有一次，它这样回话：在修复前的提交上复现出来了，修复后消失。附上一条云端运行记录的链接，你想翻就能翻。
它给的不是一句"应该已经修好了"，而是一组能对照的证据。
关键设计：Lauren用了一套"盲测"机制来验证技能本身——她派出一堆子智能体跑评测，给它们的目录起一些看不出来的名字，不让它们知道自己正在被评估。再叫一个不同模型家族的智能体当裁判，交叉复核，防止自评偏袒。分数不满意就用/loop接着刷，一直刷到10分。
四、核心实践二：Dune架构——把每句代码评审都变成红灯
Lauren敢撒手，靠的不是模型变强，是让护栏变硬。
Grok Bot的架构有个内部代号叫Dune。她的形容是——可以理解成给Electron应用的Next.js，专门为智能体书写而设计。
4.1 禁用useEffect
写过React的都知道useEffect是最大的坑之一。在Dune里，useEffect被禁用了——用了CI直接报红。
4.2 禁用代码注释
智能体写的注释99%都在描述一些跟代码无关的历史片段。它会写下"Lauren说永远不要这么干"——可她当时的意思只是这个PR很烂，你改一下那部分，根本不是什么全局规则。
所以，凡是智能体干不好的事，一律封杀。
4.3 进程隔离
Electron有渲染线程和主线程。agents window在这块分得不清楚，经常有代码被误拉进渲染线程。要跑60帧，每帧只有16毫秒预算，一旦混进重计算或者大量IO，画面立刻开始卡。
Dune的做法是直接分出electron main和electron renderer两个目录，CI去检查依赖图，跨目录乱引用直接失败。
4.4 分层护城河模型
┌──────────────────────────────────────────────────────────────┐
│ 分层护城河模型 │
├──────────────────────────────────────────────────────────────┤
│ 第1层（最硬）: 代码库架构本身 │
│ ├── 目录结构强制分离 (electron main vs renderer) │
│ ├── 唯一正确的写法 = 唯一可能的写法 │
│ └── 智能体天然爱抄现成模式，把正确写法做成唯一写法 │
├──────────────────────────────────────────────────────────────┤
│ 第2层（硬约束）: CI / Lint / 编译器诊断 │
│ ├── useEffect → CI报红 │
│ ├── 代码注释 → CI报红 │
│ ├── 跨目录引用 → 依赖图检查失败 │
│ └── 构建变红 = 不可合并 │
├──────────────────────────────────────────────────────────────┤
│ 第3层（软约束）: Rules / Skills / 代码审查Bot │
│ ├── 智能体会忘，会漏，不会稳定执行 │
│ ├── 需要配合审计和定期检查 │
│ └── 仅靠这一层，代码库变垃圾只是时间问题 │
└──────────────────────────────────────────────────────────────┘
Lauren的原话：
“如果你只有规则、机器人、技能和一份代码风格指南，你的代码库变成一堆垃圾只是时间问题。”
核心哲学：最短的路，就是最好的路。智能体解决问题时永远挑最省事的方式，那就把最省事的方式做成最正确的方式。
把Grok Bot重构到这套架构，用掉了600多个PR——还债的成分居多。
五、pstack插件系统：多智能体调度的工程化实现
pstack是Lauren开源的多智能体编排系统，发布在Cursor官方插件仓库中。它不仅仅是一个prompt集合，而是一个完整的工程化套件。
5.1 pstack架构概览
┌─────────────────────┐
│ /poteto-mode │ ← 入口路由
│ (主调度器) │
└──────────┬──────────┘
│
┌────────────────┼────────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ 21条工程原则 │ │ 22个任务Playbook│ │ 23个工作流技能│
│ │ │ │ │ │
│• Laziness │ │• Bug fix │ │• /how 系统追踪│
│• Prove It │ │• Feature │ │• /why 历史分析│
│ Works │ │• Refactoring │ │• /architect 设计│
│• Boundary │ │• Perf issue │ │• /arena 竞争设计│
│ Discipline │ │• Orchestrate │ │• /swarm 并行覆盖│
│• Guard Context│ │• Autopilot │ │• /interrogate 审查│
│ Window │ │• Babysit │ │• /recall 上下文恢复│
└──────────────┘ └──────────────┘ └──────────────┘
│
▼
┌─────────────────────┐
│ 多模型分发引擎 │
│ │
│ Sol → 精确代码实现 │
│ Grok → 快速机械工作 │
│ Fable → 判断与文案 │
│ Opus → 审查面板 │
└─────────────────────┘
5.2 核心代码：多智能体调度器
以下是一个基于pstack思想的简化多智能体调度器，用Go语言实现：
package main
import (
"context"
"fmt"
"log"
"sync"
"time"
)
// Agent 代表一个智能体实例
type Agent struct {
ID string
Role string
Model string
Playbook string
Status string // idle, running, blocked, done, failed
Goal string
Result *AgentResult
}
// AgentResult 智能体执行结果
type AgentResult struct {
PRs []string
Decisions []Decision
Evidence []Evidence
Error error
}
// Decision 决策记录
type Decision struct {
Time time.Time
Phase string
Action string
Reason string
Evidence string
Outcome string
}
// Evidence 验证证据
type Evidence struct {
Type string // screenshot, trace, log, snapshot
Content string
Passed bool
}
// Orchestrator 多智能体编排器
type Orchestrator struct {
agents map[string]*Agent
playbooks map[string]*Playbook
mu sync.RWMutex
decisionLog []Decision
}
// Playbook 任务剧本
type Playbook struct {
Name string
Steps []Step
Parallel bool
}
// Step 任务步骤
type Step struct {
Order int
Description string
AgentRole string
VerifyFunc func(*Agent) bool
}
// NewOrchestrator 创建编排器
func NewOrchestrator() *Orchestrator {
return &Orchestrator{
agents: make(map[string]*Agent),
playbooks: make(map[string]*Playbook),
}
}
// RegisterAgent 注册智能体
func (o *Orchestrator) RegisterAgent(a *Agent) {
o.mu.Lock()
defer o.mu.Unlock()
o.agents[a.ID] = a
log.Printf("[Orchestrator] Agent %s registered (role: %s, model: %s)", a.ID, a.Role, a.Model)
}
// RegisterPlaybook 注册任务剧本
func (o *Orchestrator) RegisterPlaybook(p *Playbook) {
o.mu.Lock()
defer o.mu.Unlock()
o.playbooks[p.Name] = p
}
// Dispatch 将任务分配给指定智能体
func (o *Orchestrator) Dispatch(ctx context.Context, agentID string, goal string) error {
o.mu.Lock()
agent, ok := o.agents[agentID]
if !ok {
o.mu.Unlock()
return fmt.Errorf("agent %s not found", agentID)
}
agent.Status = "running"
agent.Goal = goal
o.mu.Unlock()
log.Printf("[Dispatch] Agent %s starting: %s", agentID, goal)
// 模拟执行
time.Sleep(2 * time.Second)
o.mu.Lock()
agent.Status = "done"
agent.Result = &AgentResult{
PRs: []string{fmt.Sprintf("PR-%s-%d", agentID, time.Now().Unix())},
Decisions: []Decision{
{Time: time.Now(), Phase: "implement", Action: "修改", Reason: "实现目标", Evidence: "CI通过", Outcome: "success"},
},
}
o.decisionLog = append(o.decisionLog, agent.Result.Decisions...)
o.mu.Unlock()
return nil
}
// Swarm 并行派发多个智能体
func (o *Orchestrator) Swarm(ctx context.Context, agentIDs []string, goal string) map[string]*AgentResult {
results := make(map[string]*AgentResult)
var mu sync.Mutex
var wg sync.WaitGroup
for _, id := range agentIDs {
wg.Add(1)
go func(aid string) {
defer wg.Done()
err := o.Dispatch(ctx, aid, goal)
mu.Lock()
if err != nil {
log.Printf("[Swarm] Agent %s failed: %v", aid, err)
} else {
o.mu.RLock()
results[aid] = o.agents[aid].Result
o.mu.RUnlock()
}
mu.Unlock()
}(id)
}
wg.Wait()
return results
}
// /loop 实现：循环执行直到完成条件满足
func (o *Orchestrator) LoopUntilDone(ctx context.Context, agentID string, goal string,
checkDone func(*Agent) bool, maxIterations int) error {
for i := 0; i < maxIterations; i++ {
log.Printf("[Loop] Iteration %d/%d for agent %s", i+1, maxIterations, agentID)
err := o.Dispatch(ctx, agentID, goal)
if err != nil {
return err
}
o.mu.RLock()
agent := o.agents[agentID]
o.mu.RUnlock()
if checkDone(agent) {
log.Printf("[Loop] Goal achieved for agent %s after %d iterations", agentID, i+1)
return nil
}
time.Sleep(1 * time.Second)
}
return fmt.Errorf("agent %s: max iterations reached without achieving goal", agentID)
}
func main() {
orc := NewOrchestrator()
// 注册5个专业Bot
bots := []*Agent{
{ID: "Baltata", Role: "iOS/Mobile", Model: "Grok-4.6"},
{ID: "Shaoruru", Role: "Desktop/CI/CD", Model: "Grok-4.6"},
{ID: "Hogan", Role: "Infra/用户问题", Model: "Grok-4.6"},
{ID: "Craig", Role: "Android", Model: "Grok-4.6"},
{ID: "Quill", Role: "Harness/测试框架", Model: "Grok-4.6"},
}
for _, bot := range bots {
orc.RegisterAgent(bot)
}
// 注册Playbook
orc.RegisterPlaybook(&Playbook{
Name: "Bug fix",
Steps: []Step{
{Order: 1, Description: "复现bug", AgentRole: "investigation"},
{Order: 2, Description: "定位根因", AgentRole: "investigation"},
{Order: 3, Description: "实现修复", AgentRole: "implementation"},
{Order: 4, Description: "验证修复", AgentRole: "verification"},
},
})
// 并行派发 swarm
ctx := context.Background()
goal := "Fix all flaky tests and make CI green"
agentIDs := []string{"Baltata", "Shaoruru", "Craig", "Quill"}
results := orc.Swarm(ctx, agentIDs, goal)
log.Printf("Swarm complete. Results: %+v", results)
}
5.3 核心命令解析
pstack的核心入口是/poteto-mode，它是一个路由调度器，不包含所有任务的完整指令，而是选择更小的技能片段并按正确顺序执行。
完整流程：
/poteto-mode读取用户请求- 读取21条工程原则索引
- 匹配到对应的Playbook（Bug fix / Feature / Refactoring / Perf issue等）
- 调用专业子技能（
/how、/why、/architect等） - 按模型角色分派（Sol → 精确代码实现，Grok → 快速机械工作，Fable → 判断与文案）
- 验证结果 → 审查 → 提交
关键命令：
| 命令 | 功能 | 使用场景 |
|---|---|---|
/poteto-mode | 主入口路由 | 开始任何任务 |
/loop | 循环执行直到完成 | 长时间运行的多迭代任务 |
/goal | 设定长期目标 | 跨会话持续追踪 |
/swarm | 并行分片执行 | 多个独立子任务 |
/arena | 竞争设计 | 让多个模型独立设计并择优 |
/how | 追踪系统运行时行为 | 理解代码库工作原理 |
/why | 查找历史证据 | 理解设计决策背景 |
/interrogate | 多模型审查 | 代码Review |
/babysit | 监控PR直到可合并 | 自动化PR管理 |
5.4 PR自动化工作流
┌──────────────────────────────────────────────────────┐
│ PR自动化流水线 │
├──────────────────────────────────────────────────────┤
│ │
│ Notion 30分钟自动检查PR │
│ │ │
│ ▼ │
│ Shell: 自动代码审查 (低风险PR自动合并) │
│ │ │
│ ├── 低风险PR → 自动合并到主干 │
│ │ │
│ └── 高风险PR → 标记需要人工审核 │
│ │
│ Grok Bot 夜间审计流程 │
│ │ │
│ ├── 00:00 审计所有未合并PR │
│ ├── 01:00 检查CI状态和测试覆盖率 │
│ ├── 02:00 分析代码质量趋势 │
│ ├── 03:00 生成审计报告 │
│ └── 07:00 汇总报告到Slack │
│ │
│ P0 紧急流程 │
│ │ │
│ ├── 检测到生产环境问题 │
│ ├── 自动拉起修复Bot │
│ ├── 并行运行修复方案 │
│ ├── 自动部署修复 │
│ └── 通知值班工程师 │
│ │
└──────────────────────────────────────────────────────┘
六、五个专业Bot的设计哲学
Grok Bot团队设了5个专业Bot，每个Bot有独立记忆系统和限定上下文，专注单一领域：
Bot 架构设计
┌──────────────────────────────────────────────────────────────┐
│ Grok Bot 工程团队架构 │
├──────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──┴───────┐
│ │ Baltata │ │ Shaoruru │ │ Hogan │ │ Craig │ │ Quill │
│ │ iOS/Mobile│ │Desktop/ │ │ Infra/ │ │ Android │ │ Harness/ │
│ │ │ │ CI/CD │ │ 用户问题 │ │ │ │ 测试框架 │
│ └─────┬─────┘ └─────┬────┘ └─────┬────┘ └─────┬────┘ └─────┬────┘
│ │ │ │ │ │
│ └──────────────┴────────────┴──────────────┴────────────┘
│ │
│ ┌────────▼────────┐
│ │ Cursor Cloud │
│ │ Agent 底层引擎 │
│ │ (200+并发实例) │
│ └─────────────────┘
│ │
│ ┌──────────────────────────────────────────────────────────┐│
│ │ Grok Bot 外层编排层 (创建/提示/监控/验证) ││
│ │ - 模板共享 ││
│ │ - 多账户切换 ││
│ │ - 网络出口路由 ││
│ └──────────────────────────────────────────────────────────┘│
│ │
│ ┌──────────────────────────────────────────────────────────┐│
│ │ Jenny (运营Bot) ││
│ │ - 每日会议 ││
│ │ - 入职流程 ││
│ │ - 事后分析 ││
│ │ - Playbook更新 ││
│ └──────────────────────────────────────────────────────────┘│
└──────────────────────────────────────────────────────────────┘
设计原则：每个Bot有独立的记忆系统和限定的上下文，只专注单一领域。这避免了多任务智能体常见的"上下文污染"问题——当智能体在多个领域之间切换时，一个领域的残留意念会干扰另一个领域的判断。
Grok Bot作为外层编排层，负责创建、提示、监控和验证这些Bot的输出。Cursor Cloud Agent作为底层执行引擎，实现了从15个并发实例到200+的扩展。
七、验证即信任：从"人肉传送带"到自动化验证流水线
pstack对验证的要求极为严格——它拒绝把"构建通过"当作完整的验证证据。
"""
pstack验证流水线 - Python实现
"""
import subprocess
import json
from dataclasses import dataclass, field
from typing import Optional, List
from enum import Enum
import time
class ChangeType(Enum):
CLI = "cli" # 命令行变更
UI = "ui" # UI变更
MIGRATION = "migration" # 数据迁移
PERF = "perf" # 性能变更
STORAGE = "storage" # 存储变更
class VerificationStatus(Enum):
PENDING = "pending"
PASSED = "passed"
FAILED = "failed"
BLOCKED = "blocked"
@dataclass
class VerificationResult:
status: VerificationStatus
evidence: List[str] = field(default_factory=list)
error: Optional[str] = None
duration_ms: int = 0
class VerificationPipeline:
"""验证流水线 - 根据变更类型选择验证策略"""
def __init__(self, repo_path: str):
self.repo_path = repo_path
self.results: List[VerificationResult] = []
def verify(self, change_type: ChangeType, target: str) -> VerificationResult:
"""根据变更类型执行对应的验证"""
start = time.time()
strategies = {
ChangeType.CLI: self._verify_cli,
ChangeType.UI: self._verify_ui,
ChangeType.MIGRATION: self._verify_migration,
ChangeType.PERF: self._verify_perf,
ChangeType.STORAGE: self._verify_storage,
}
strategy = strategies.get(change_type)
if not strategy:
return VerificationResult(
status=VerificationStatus.BLOCKED,
error=f"Unknown change type: {change_type}"
)
result = strategy(target)
result.duration_ms = int((time.time() - start) * 1000)
self.results.append(result)
return result
def _verify_cli(self, command: str) -> VerificationResult:
"""验证CLI变更：实际运行命令"""
try:
# 运行真实命令，检查输出
proc = subprocess.run(
command.split(),
capture_output=True,
text=True,
timeout=30,
cwd=self.repo_path
)
evidence = [
f"stdout: {proc.stdout[:500]}",
f"stderr: {proc.stderr[:500]}",
f"return_code: {proc.returncode}"
]
return VerificationResult(
status=VerificationStatus.PASSED if proc.returncode == 0
else VerificationStatus.FAILED,
evidence=evidence
)
except subprocess.TimeoutExpired:
return VerificationResult(
status=VerificationStatus.FAILED,
error="Command timed out"
)
def _verify_ui(self, feature: str) -> VerificationResult:
"""验证UI变更：通过feature map驱动UI并截图对比"""
# 实际实现中，会调用control glass技能
# 1. 启动应用
# 2. 导航到指定功能
# 3. 执行交互
# 4. 截图对比
# 5. 检查控制台错误
evidence = [
f"Feature: {feature}",
"Screenshot: [captured at run time]",
"Pixel diff: 0 (within threshold)",
"Console errors: 0",
"FPS: 60 (stable)"
]
return VerificationResult(
status=VerificationStatus.PASSED,
evidence=evidence
)
def _verify_perf(self, baseline_trace: str) -> VerificationResult:
"""验证性能变更：对比基线trace"""
# 1. 采集变更后的trace
# 2. 与基线对比
# 3. 生成差异报告
evidence = [
f"Baseline: {baseline_trace}",
"New trace: [captured]",
"CPU delta: -12.3%",
"Memory delta: -5.7%",
"Frame drop: 0 (was 3)"
]
return VerificationResult(
status=VerificationStatus.PASSED,
evidence=evidence
)
def _verify_migration(self, migration_name: str) -> VerificationResult:
"""验证数据迁移：回放真实输入"""
evidence = [f"Migration: {migration_name} replayed successfully"]
return VerificationResult(
status=VerificationStatus.PASSED,
evidence=evidence
)
def _verify_storage(self, storage_key: str) -> VerificationResult:
"""验证存储变更：读取值并验证"""
evidence = [f"Storage read: {storage_key} = [verified]"]
return VerificationResult(
status=VerificationStatus.PASSED,
evidence=evidence
)
# 使用示例
pipeline = VerificationPipeline("/path/to/repo")
# 验证一个CLI变更
cli_result = pipeline.verify(ChangeType.CLI, "git diff --check origin/main")
print(f"CLI verify: {cli_result.status.value}, evidence: {cli_result.evidence}")
# 验证一个UI变更
ui_result = pipeline.verify(ChangeType.UI, "左侧栏卡顿修复")
print(f"UI verify: {ui_result.status.value}, evidence: {ui_result.evidence}")
八、工程师的新定位：从"写代码的人"到"主厨"
1000个PR之后，工程师还剩下什么？
Lauren用了一个词来形容自己的定位：主厨。
不再自己炒每一道菜，手底下有配菜的，有二厨，有各个灶台。你的活儿变成了设计厨房，安排工位，分派任务。
现在Grok Bot团队里，产品经理和设计师会直接提交代码。经常是有人跑来说，这儿有个bug我修好了，你看一下。她点开，确认没问题，盖章。
一个从没写过前端的人，代码能进主干，靠的不是他突然会写了，是那套严格到烦人的架构约束替他兜住了底。
判断标准：当你在代码评审里靠打字告诉别人"这里不能这么写"的时候，这件事本身就是code smell。正确的动作是问自己——怎么把它变成一条lint规则？变成一次CI失败？或者干脆，让这个问题从根上不可能发生？
你在PR评论里说过三遍的话，就该变成一条会让构建变红的规则。
九、工程实践总结
9.1 核心原则
- 验证优先于提示：智能体最大的问题不是不知道怎么写，而是不知道自己在猜。用验证建立信任，而不是用更长的prompt。
- 硬约束 > 软约束：代码库架构 > CI/Lint > 规则/技能。不要指望智能体记住规则，要把规则嵌入到架构本身。
- 最短的路 = 最好的路：智能体永远挑最省事的方式，所以把最省事的方式做成最正确的方式。
- 单一职责：每个Bot只做一件事，拥有独立记忆和限定上下文，避免上下文污染。
- 可复现的证据：不接收"应该修好了"，只接收"在修复前复现、修复后消失"的可验证证据。
9.2 技术栈
| 组件 | 技术 | 说明 |
|---|---|---|
| 编排层 | Grok Bot | 创建、提示、监控、验证 |
| 执行引擎 | Cursor Cloud Agent | 底层代码生成和执行 |
| 多智能体框架 | pstack | 23个技能、22个Playbook、21条原则 |
| 自动化架构 | Dune | Electron应用专用架构 |
| 系统监控 | Notion 30分钟检查 | PR自动审查和合并 |
| 运营Bot | Jenny | 会议、入职、事后分析 |
| 开源项目 | pstack | Cursor官方插件仓库 |
9.3 未来展望
Lauren Tan的实践揭示了一个清晰的趋势：AI不会取代工程师，但使用AI的工程师会取代不使用AI的工程师。而且，随着Grok Bot的模板共享、多账户切换、网络出口路由等新功能上线，多智能体协作的门槛正在进一步降低。
程序员留在牌桌上的筹码，从"我会写代码"变成了"我能判断怎样写代码才算对了"。
参考资料：
- Lauren Tan Maven工作坊分享：https://maven.com/p/e23d9c/how-cursor-turned-ai-agents-into-better-engineers
- pstack 开源项目：https://github.com/cursor/plugins/tree/main/pstack
- Cursor Cloud Agents Changelog (2026-08-19)：https://cursor.com/changelog/08-19-26
- 36氪报道《一觉醒来20个PR自己合进了主干》（2026-08-31）
- Flavio Copes pstack深度解析：https://flaviocopes.com/pstack/
- SpaceXAI Grok Bot官方公告 (2026-08-11)