阅读视图

发现新文章,点击刷新页面。

Everything Claude Code:让我把 AI 编程效率再翻一倍的东西

Hi~大家好呀,我是清汤饺子。

先说个让我差点砸键盘的场景。

我打开一个新的 Claude Code session,准备继续前天没写完的功能。

Claude 热情地跟我打招呼:嗨!很高兴再次见到你,有什么我可以帮你?

我说:继续前天的任务。

Claude:好的!请问你想做什么?

我:就是那个功能模块啊,前天做到一半的那个。

Claude:好的!请问你想做什么功能?

我:……你刚才不是说了"再次见到我吗"?

Claude:哦,那只是客气话,我的记忆撑不过一个 session。

我:……行吧。

这个对话你是不是也似曾相识?

是不是也想问 AI:你礼貌吗?

一、我的痛点:AI 每次都是"新人"

Claude Code 的 memory 功能我深度用过——CLAUDE.md 配了、项目规范配了、技术栈配了。

但它只能记住"静态上下文",记不住"动态进度" :上次做到哪了、上次做了什么决定、上次遇到了什么问题。

更崩溃的是——有时候 Claude 会"选择性失忆"。明明配置了 memory,它偏偏没触发。有一次我让它帮我重构一个模块,它完全忽略了我们的代码规范,输出了一套我完全不认识的风格。

我开始认真想:有没有一套系统,能让 AI 的"记忆"真正 work?

然后我发现了 Everything Claude Code。

二、ECC 是什么

GitHub 110K+ stars,Anthropic Hackathon 冠军作品。

作者是 affaan-m,做了 10 个月每天高强度在真实项目里打磨出来的。定位不是"配置文件合集",而是:一套完整的 AI Agent 性能优化系统

ECC 官方有一张对比表,说清了它的核心价值:

Without ECC With ECC
AI 不了解团队的代码模式 AI 通过 rules 和 skills 学习团队规范
测试靠手动写,覆盖率不稳定 TDD 流程内置,测试先行,覆盖率透明
安全漏洞靠人工 review AgentShield 实时扫描,102 条规则自动拦截
团队没有统一的代码标准 skills 和 agents 全团队共享
每个 session 从零开始 Continuous Learning 跨 session 积累

这张表说清楚了 ECC 解决的问题。但光看表感受不深,我用了两个月,说说具体是什么体验。

三、GitHub App:把 commit 历史变成团队规范

这是 ecc.tools 最让我惊喜的功能。

ECC 提供一个 GitHub App(免费安装),它的工作方式是这样的:

  1. 在你的仓库安装 ECC Tools GitHub App
  2. 在任意 issue 下评论 /ecc-tools analyze
  3. ECC 自动分析你的 commit 历史、代码模式、团队规范
  4. 自动生成一个 Pull Request,把这些历史转成 skills 和 defaults

翻译成人话:你的 git 提交记录里藏着团队多年的工程经验,ECC 自动把这些经验提取出来,变成 AI 可以复用的规范。

这个 PR 不是直接合并的——你审核、修改、确认之后才生效。完全可控。

我试了一下,第一次跑完它生成了大约 30 条 rules,覆盖了我们的 commit message 规范、分支命名规则、还有 API 错误处理的一些惯用模式。

最厉害的是:这个 PR 里的内容是专门针对你这个仓库的,不是通用模板。ECC 读的是你真实的 git 历史,提取的是你团队真实在用的规范。

四、Token 优化:让 AI 跑得更快

Context window 是有限的,AI 跑着跑着就开始"失忆"前面的内容。ECC 有几个实用的省 tokens 方法,都是踩坑踩出来的经验。

  • 模型选择:大多数日常任务用 Sonnet 4.5 就够了,复杂任务(跨 5+ 文件、架构决策、安全关键代码)升 Opus,重复性劳动降级到 Haiku 当 worker。类比一下:能用摩托车拉的不用卡车,卡车油耗高,还不好停。

  • 工具替换:Claude 默认用 grep 或 ripgrep 搜索代码,tokens 消耗大。换 mgrep,平均节省 50%——就像从手动档换成自动挡,不改变目的地,但脚不酸了。

  • 后台进程:不需要 AI 实时处理输出的任务,用 tmux 丢后台,不占用 context。这就像让 AI 同时处理多项任务——实际上它是把不重要的任务先寄存起来。

  • 模块化代码库:文件越小(几百行 vs 几千行),AI 消耗的 tokens 越少,出错率也越低。

五、Memory 持久化:AI 不再是"金鱼"

这是 ECC 最打动我的功能,也是它和"普通配置文件"的本质区别所在。

原生 Claude Code memory 只能存"静态模板"——项目规范、技术栈、代码风格。但它存不住"动态进度" :上次做到哪了、遇到了什么问题、做了什么决策。

ECC 的解法是把三个 Hook 串联起来,形成完整的记忆链条。

第一棒:SessionComplete Hook,session 结束时自动存档

Session 结束时,Claude 自动把当前状态写入 .tmp 文件——完成的任务、遇到的阻塞、关键决策、下次继续需要的信息,全都存下来。

第二棒:SessionStart Hook,新 session 开始时自动恢复

新 session 开始时,Claude 自动读取上次的 .tmp 文件。它会主动问:"检测到上次有未完成的任务,要继续吗?"

第三棒:PreCompact Hook,提前预警该整理了

在你积累了很多上下文的时候,提前提示你"该整理一下了",避免等到 AI 开始"失忆"才后悔。

三个 hook 串联起来,实现的是:跨 session 真正零手动干预的连续记忆。我第一次用这套组合的感觉是——Claude 终于不是"金鱼"了,甚至有点像一个记性比我还好的 senior。

六、Continuous Learning:让 AI 从错误中进化

核心问题:同一个错误,AI 犯一次两次三次,永远记不住。

解法:告诉 Claude "记住它",它把这个模式自动写入 skills,下次遇到类似场景自动调用。

触发方式有两种:

自动:session 结束时运行 /learn,自动提取这次 session 里发现的有效模式。

手动:中途解决了什么非平凡的问题,马上 /learn 即时提取。

我连续三次让 Claude 帮我写 API 接口,它第三次就自己学会了"我们项目里 API 文件放哪里、命名规范是什么、错误处理用什么模式"。

这感觉就像养成了一个会自动学习的好习惯——不用催,它自己就记住了

七、验证与安全

AI 执行命令是有风险的。Prompt injection、未经授权的文件修改、"AI 误删整个 node_modules"这种事,社区里见过太多了。

解法:ECC 提供了 AgentShield——一个独立的安全扫描工具,102 条规则、1282 个测试用例、98% 覆盖率,采用 Red Team / Blue Team / Auditor 三层 Pipeline。

这阵容,比很多公司的安全团队都专业。

效果:扫描输出分级展示,critical 问题直接标红。

运行效果是这样的:

$ npx ecc-agentshield scan ./CLAUDE.md

 CRITICAL  Unrestricted file system access via Bash tool
 WARNING    No rate limiting on external API calls
 WARNING    Missing secret detection guardrail
 PASS       Tool permissions properly scoped
 PASS       Destructive action confirmation required
 PASS       No prompt injection vectors detected

Security Score: 72/1001 critical, 2 warnings, 3 passed
Full report saved to ./agentshield-report.json

我之前差点让 Claude 把整个 node_modules 删了——它问都没问我直接动手。幸好当时没执行,不然一天白干。有 AgentShield,那种"先斩后奏"的命令直接被拦截,连求情的机会都不给

八、技术原理

看完 GitHub 仓库,我发现 ECC 比"配置文件合集"要系统得多。它的核心不是某一个功能,而是一套层次化的 Agent 优化架构

1. 五类组件:底层基础设施

ECC 的仓库由五类组件构成,每一类解决不同层次的问题:

  • Agents(智能体):30+ 专业子代理,负责特定领域的任务执行。比如 code-reviewer 专门做 code review,build-error-resolver 专门修编译错误,chief-of-staff 专门做任务规划和进度管理。每一个 agent 只做一件事,做得很专注。

  • Skills(技能):可复用的任务模式库,分两类——

    • 语言生态:TypeScript、Python、Go、Rust、Java、PHP、Perl、Kotlin、C++ 等,每个语言有对应的 patterns 和 conventions
    • 垂直领域:django、laravel、springboot、pytorch 等框架完整技能栈,覆盖从开发到部署的全流程
  • Commands(命令):斜杠命令是快速触发技能的入口,比如 /plan 触发任务规划、/tdd 启动 TDD 流程、/learn 即时提取好模式。命令和技能联动,构成了 ECC 的交互层。

  • Rules(规则):始终遵循的约束,放置在 .claude/rules/ 目录下。AI 每个 session 都会读取,是最低层次的"铁律"。Rules 不同于 Skills——Skills 是告诉 AI"怎么做",Rules 是告诉 AI"绝对不能怎么做"。

  • Hooks(钩子):挂在 Session 生命周期上的自动化脚本,这是 ECC 最具特色的设计。每个 Hook 有明确的触发时机:

    • PreToolUse:工具执行前触发,比如拦截危险命令
    • PostToolUse:工具执行后触发,比如自动格式化、自动运行 lint
    • SessionComplete:session 结束时触发,自动存档
    • SessionStart:session 开始时触发,自动恢复上下文
    • PreCompact:上下文即将溢出前触发,提前预警

2. SKILL.md:技能自动发现的秘密

ECC 的 Skills 不是靠手动调用的,而是靠 description 字段自动触发

每个 Skill 文件(Markdown 格式)顶部有一段 YAML metadata:

---
name: tdd-workflow
description: Use when the user wants to do test-driven development - sets up TDD flow with RED first
---

当 AI 判断当前任务符合 description 的条件时,自动激活对应 Skill,整个过程不需要你做任何事情。

这意味着 ECC 的 Skills 系统本质上是上下文感知的——AI 根据当前任务状态自动匹配最佳实践,而不是等你一步步指示。

3. SQLite 状态存储:持久化的秘密

ECC 用 SQLite 作为状态存储数据库,记录:

  • 已安装的 Skills 列表和版本
  • Session 历史摘要
  • Continuous Learning 的演化记录
  • 各平台(Claude Code / Codex / Cursor / OpenCode)的配置状态

这让 ECC 具备"状态记忆"——不是每次从零开始,而是知道"上次装了什么、上次做了什么、哪里出了问题"。支持增量更新,不用每次全量重装。

4. Continuous Learning 的技术实现

ECC 的 Continuous Learning 不是靠"更长的 context window",而是靠自动提取 + 写入 Skills 目录

  1. AI 在 session 中发现一个有效的模式(比如"这个项目的 API 错误处理用 Result type")
  2. 自动把这个模式写入 ~/.everything-claude-code/skills/
  3. 下次遇到类似场景,Skills 触发,模式复用

本质是把隐性知识显性化,把单次经验变成可复用资产。这解决了 AI "同类错误重复犯" 的根本问题。

5. AgentShield 的技术实现

AgentShield 不是简单的"危险命令黑名单",而是一套多层次安全扫描机制

  • Hook 层:在命令执行前拦截,扫描 rm -rfcurl | bashgit push --force 等危险模式
  • CVE 数据库:集成了常见漏洞数据库,扫描依赖包是否有已知漏洞
  • Sandbox 隔离:危险操作在隔离环境执行,不直接影响主项目

6. 安装架构:Manifest 驱动

ECC 的安装不是"一键全装",而是Manifest 驱动的选择性安装

./install.sh --profile full        # 全量安装
./install.sh typescript            # 只装 TypeScript 相关
./install.sh --target cursor python  # 只给 Cursor 装 Python 生态

install-plan.jsinstall-apply.js 负责解析 Manifest,按需安装。SQLite 状态存储记录"装了什么",支持增量更新。ECC_HOOK_PROFILE 环境变量还可以控制 Hook 的严格程度(minimal / standard / strict)。

GitHub 仓库:github.com/affaan-m/ev…

九、和 Superpowers + OpenSpec 的关系

这三个工具解决的问题正好互补:

工具 解决的问题
OpenSpec 需求对齐——先签字再动手
Superpowers 工程纪律——TDD、task 分解、子 Agent 编排
ECC 性能和记忆——Token 优化、Memory 持久化、安全扫描

OpenSpec 在最上游——它管的是做什么

Superpowers 在中游——它管的是怎么做

ECC 在底层——它管的是怎么跑得更好

三个一起用,才是完整的 AI 编程工作流。


写在最后

ECC 解决了一个根本问题:AI 不是"真的智能",它是"真的没有记忆"

110K+ stars 说明这套方法论经过了大量开发者的验证。我用了两个月,最大的感受是——AI 编程终于有点像"和一个靠谱的同事合作",而不是"和一个热情的实习生搏斗"——热情是热情,但每次都要我来收拾残局。

当然它不是银弹。配置成本不低,学习曲线陡峭,踩坑也需要时间。如果你每天用 AI 写代码,这点投入值得;如果只是偶尔用用,原生体验可能就够了——省下的配置时间够你手动写好几屏代码了

你被 AI coding 的"失忆症"困扰过吗?有没有什么土办法?

欢迎评论区聊聊,看看大家都有什么奇葩经历,互相种草避坑。

如果觉得有帮助,点个赞收藏一下,我会更有动力更新下一期。

也欢迎关注我的公众号「清汤饺子」,获取更多技术干货!

Superpowers:给 AI 编程 Agent 装上"工程化超能力"

Hi~大家好呀,我是清汤饺子。 前几天让 Claude Code 帮我写个小功能,它噼里啪啦一顿输出,代码倒是挺像那么回事。一跑,报错 40 个。

我盯着屏幕愣了三秒,然后开始一个个手动修。

事后复盘,问题不在 AI 写的代码烂,而在于——它太有热情了。拿到需求就开干,根本不问我"你想解决什么问题"、"这个场景下最优解是什么"。

这感觉就像招了一个「执行力超强但完全没有工程纪律」的 junior。

然后我发现了 Superpowers。

01 解决什么问题

AI Coding Agent 最大的通病,懂的都懂:

  • 拿到需求就开干:不等你确认,先肝为敬
  • 不写测试:代码写完自己都不知道写了啥
  • 代码像开盲盒:这次好使,下次不知道哪个版本就崩了

人类工程师有 TDD、有 code review、有设计评审,有一整套工程纪律来约束自己。但 AI Agent 呢?它只管输出,不管后果。

Superpowers 就是干这个的——给 AI Agent 装上一组技能卡,让它学会工程化的工作流

不是让它更聪明,是让它更有章法。

02 Superpowers 是什么

这是 Jesse Vincent(GitHub @obra)做的一个开源项目,全称是 Superpowers — An agentic skills framework & software development methodology

翻译成人话:一套给 AI 编程 Agent 用的技能框架

它不是让你用更厉害的模型,而是让你的 AI Agent 具备一套工程化思维:

  • 写代码前先做设计评审
  • 先写测试再写实现
  • 任务拆解到 2-5 分钟一个
  • 子 Agent 并行执行 + 两阶段 review

支持 Claude Code、Cursor、Codex、OpenCode 和 Gemini,主流 AI 编程工具都能用。

03 这工作流是怎么跑起来的

第一步:brainstorming —— 先别写代码,灵魂拷问一下

Superpowers 的第一条技能叫 brainstorming,触发时机是「写代码之前」。

当 AI 看到你要做新功能,它不会直接开干,而是反过来问你:

"你到底想解决什么问题?" "这个场景下有哪些边界情况?" "你觉得最优解是什么?"

我第一次用它做设计,它连着问了我 6 个问题才肯动笔。那感觉……像找了个 senior 在给我做 design review。

Socratic 追问,让 AI 先理解需求再动手。这治好了 AI "拿到需求就肝" 的毛病。

第二步:writing-plans —— 任务拆解到 2-5 分钟

需求确认之后,进入 writing-plans 技能。

AI 会把整个功能拆成若干小任务,每个任务:

  • 精确到文件路径
  • 有完整的代码内容
  • 有验收标准

更关键的是:每个任务 2-5 分钟就能跑完

以前我让 AI 写整个功能,它容易迷失在中途。现在它把活儿拆成「傻瓜式操作手册」,就像给一个「执行力强但没耐心」的 junior 写了一份 2 分钟就能完成的小任务清单。

第三步:subagent-driven-development —— 子 Agent 并行跑

计划就绪,主 Agent 调度 subagent-driven-development 技能。

它的核心是:

  1. 子 Agent 并行执行:每个任务交给独立的子 Agent 处理
  2. 两阶段 review:先检查规格是否合规,再检查代码质量
  3. 连续运行能力:实测 Claude 可以连续跑 2 小时不用管

简单说就是:你当老板,AI 们当工人。主 Agent 包工头负责分配任务、监督进度、质量把关。

第四步:TDD 红绿重构 —— 先写测试这道坎

这是我觉得最有价值的部分:test-driven-development

核心流程就三步:

  1. RED:写一个注定失败的测试
  2. GREEN:写最少的代码让测试通过
  3. REFACTOR:重构优化

重点是:必须先写测试,再写实现,测试前的代码直接删掉

这治好了 AI "写完代码懒得测" 的毛病。以前我让 AI 写功能,它输出完就完事,根本不管测试。现在它被强制绑上了 TDD 的战车。

第五步:收尾工作 —— finishing-a-development-branch

任务全部完成后,finishing-a-development-branch 技能接管:

  • 验证所有测试通过
  • 给出四个选项:merge / PR / 保留 / 丢弃
  • 自动清理 worktree

不需要你手动去处理分支清理,AI 会把收尾工作做完。

04 技能全景图

技能 触发时机 作用
brainstorming 写代码前 需求澄清,Socratic 追问
writing-plans 设计批准后 任务拆分,2-5min/任务
using-git-worktrees 设计批准后 创建独立分支,验证干净测试基线
verification-before-completion 调试完成后 验证问题真的修好了
subagent-driven-development 计划就绪 子 Agent 并行执行 + 两阶段 review
test-driven-development 实现中 强制红绿重构
systematic-debugging 调试时 4 阶段根因分析
requesting-code-review 任务间 按严重性报告问题
finishing-a-development-branch 任务完成 收尾 + 分支清理

这套技能的精妙之处在于:触发完全自动。你不需要手动调用,AI 会根据当前任务状态自动匹配技能。

就像给 AI 装了一堆「工程化本能」,遇到对应场景自动触发。

05 怎么装上

各平台安装方法:

Claude Code

# 方式一:官方 Claude 插件市场(推荐)
/plugin install superpowers@claude-plugins-official

# 方式二:社区 marketplace(需要先注册)
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Cursor

# 在 Agent chat 中
/add-plugin superpowers

Codex

Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md

安装大约 5 分钟,配上之后的感觉像是——给 AI 做了一个完整的入职培训。

06 真实感受

惊喜时刻

  • 项目节奏完全变了。以前我追着 AI 跑,现在是 AI 追着任务跑
  • Claude 真的能连续跑 2 小时不出岔子
  • TDD 闭环治好了我懒得写测试的毛病

崩溃时刻

  • 第一次用的时候它问太多问题(brainstorming 阶段),差点想卸载
  • 配置比想象中复杂,需要花时间理解每个技能的触发逻辑

适合的人

  • 有一定经验的开发者,懂 TDD、懂工程化的人用起来如虎添翼
  • 团队协作场景,AI 能承接更多的工程纪律

不适合的人

  • 纯新手可能觉得被束缚,不知道为什么要这么做
  • 小项目不值得折腾,简单功能直接让 AI 写反而更快

07 本质是什么

用了一圈下来,我觉得 Superpowers 的本质是:

不是让 AI 替代你,是让它成为更有章法的搭档。

它不是在提升 AI 的智商,而是在约束 AI 的行为——让它像人类工程师一样思考、像人类工程师一样工作。

以前我把活儿交给 AI,总是提心吊胆,不知道它会整出什么幺蛾子。现在有了 Superpowers 的工程化约束,我更愿意把任务交给 AI 了。

因为它不会再半夜给我埋雷。

08 技术原理

看完了 GitHub 仓库之后,我发现 Superpowers 的实现比"配置文件合集"要精妙得多。

SKILL.md:技能即文档

每个技能都是一个 .md 文件(Markdown),放在 skills/ 目录下。文件格式包含两部分:

Frontmatter(YAML 元信息)

---
name: brainstorming
description: Use when [condition] - [what it does]
---

正文内容:技能的详细指令,告诉 AI 在什么场景下怎么做。

关键是 description 字段——这是 AI 自动发现和触发技能的依据。Codex/Claude Code 在每次任务执行前,会扫描 ~/.agents/skills/ 目录,根据 description 匹配当前上下文,自动激活对应技能。整个过程不需要你手动调用。

7 步接力:上游输出驱动下游输入

每一步的输出成为下一步的输入:

  • brainstorming 产出设计文档(human-approved)
  • using-git-worktrees 创建隔离分支环境
  • writing-plans 把设计拆成任务清单
  • subagent-driven-development 按任务执行 + 两阶段 review
  • test-driven-development 强制 TDD
  • requesting-code-review 任务间按严重性报告问题
  • finishing-a-development-branch 收尾

两阶段 Review:规格合规 → 代码质量

每个子 Agent 完成任务后,经历两关:

  1. 规格合规性审查:任务有没有按 plan 执行?有没有超出范围?
  2. 代码质量审查:代码本身写得怎么样?有没有明显 bug 或坏味道?

两关都过,才进入下一个任务。这治好了 AI "做多了或做歪了" 的问题。

TDD 强制闭环

test-driven-development 的核心规则:

  • RED:AI 必须先写一个注定失败的测试
  • GREEN:然后写最少的代码让测试通过
  • REFACTOR:最后重构优化

最狠的一条:测试写出来之前的代码直接删掉。AI 没有"先写实现后补测试"的选项。

哲学层:Process over guessing

README 里 Jesse Vincent 写了四条原则:

  • Test-Driven Development — 先写测试,永远
  • Systematic over ad-hoc — 系统化流程 > 猜测
  • Complexity reduction — 简单性是首要目标
  • Evidence over claims — 用验证说话,不要只靠感觉

本质就是:不要相信 AI 的直觉,要相信工程纪律

GitHub 仓库:github.com/obra/superp…


写在最后

Superpowers 这套技能框架,解决的不是 AI 能力不足的问题,而是 AI 行为不可控的问题。

如果你也在用 AI Coding Agent,感觉它"太热情但不靠谱",建议试试这套方法论。

当然,它不是银弹。工程纪律是给有工程经验的人用的,如果你本身对 TDD、代码审查这些概念不熟悉,Superpowers 可能会让你更困惑。

核心问题是:你愿不愿意花时间教会 AI 按你的方式工作?

这个问题没有标准答案,取决于你的项目规模和团队情况。


你在用 AI 编程工具吗?有什么"AI 疯狂输出但最后还是我来收拾烂摊子"的经历吗?欢迎在评论区聊聊,看看大家都有什么奇葩故事。

如果觉得有帮助,点个赞收藏一下,我会更有动力更新下一期。

也欢迎关注我的公众号「清汤饺子」,获取更多技术干货!

搞懂 Cursor 后,我一行代码都不敲了《进阶篇》

Hi~大家好呀,我是清汤饺子。

上篇我们讲了 Cursor 的基础用法——怎么安装、怎么用 Agent、怎么写功能修 Bug。学会了这些,你已经能用 Cursor 正常干活了。

但你可能会有这种感觉:有时候 AI 好像"不太懂你"——它不知道你的编码习惯,不记得你的项目规范,每次都要重复解释很多东西。

好!那这篇文章就是来解决这个问题的。我们来聊聊怎么把 Cursor 调教成最懂你的搭档。

跟着这个系列学完,你会发现 Cursor 不只是个代码补全工具——它是你的 AI 开发团队。

你可以同时叫多个 Agent 帮你干活:一个读代码理解业务,一个写新功能,一个修 Bug,一个跑测试,一个写文档。你只需要告诉它们想做什么,然后等着验收结果就行。

这个系列一共三篇:

第一篇从零上手 Cursor

讲讲怎么安装、Agent 怎么用、怎么写功能、怎么修 Bug

第二篇(就是这篇):让 Cursor 更懂你

上下文引用、Rules、Skills、MCP 这些

第三篇团队协作与场景实战

怎么在团队里用好 Cursor


我踩过的坑

刚开始用 Cursor 我经常有这种感觉:

让 AI 帮你改个功能,它改完了你一看——完全不是你想的那样

后来我明白了,不是 AI 笨,是我没告诉它"看哪里"。

AI 输出的质量好坏,很大程度上取决于它"看到"了什么。你给它塞越多无关的信息,它的注意力就越分散,出来的结果就越水。

这篇文章,就是来讲讲怎么让 AI 更懂你。


一、上下文管理:让 AI 看到正确的代码

1.1 核心引用符号

Cursor 给了一套 @ 符号引用体系,让你精准控制送入模型的上下文。

说人话:就是告诉 AI "看这个文件"、"看这个文件夹"。

符号 作用
@文件名 把指定文件内容注入上下文
@文件夹名 注入整个目录的结构信息
@codebase 触发语义搜索,让 Agent 自己去找相关代码
@doc 引入已索引的第三方文档
@web 触发实时网络搜索
@git 引用 Git 历史、diff

1.2 两种搜索模式

用 @codebase 时,Cursor 会综合用两种搜索:

  • 精确搜索:知道函数名、变量名就直接搜,速度极快
  • 语义搜索:不知道具体叫什么,但能描述功能

1.3 使用建议

✅ 先精确,后宽泛:知道文件名就直接 @文件名

✅ 先探索,再改动:让 AI 先展示现有的相关实现

✅ 只引入必要的:塞太多无关文件会稀释 AI 的注意力

💡 心得:这是我踩过最大的坑!之前都是直接让 AI 干活,也不告诉它看哪里,结果它搜一堆不相关的代码,写出来的东西牛头不对马嘴。加上精准的 @ 引用后,效率直接翻倍。


二、Rules:给 AI 写项目规则

2.1 大模型没有记忆

不知道你们烦不烦,反正我是烦透了——每次开新会话都要跟 AI 解释一遍项目规范

"我们用 Tailwind 别用 styled-components" "API 统一放 src/api/ 目录" "组件名要用 PascalCase"

累不累啊。

Rules 解决的问题就是:把你的编码规范、架构决策,固化成 AI 的"持久记忆"

2.2 四种规则类型

类型 存储位置 适用范围
Project Rules .cursor/rules/ 当前项目,可提交到 Git
User Rules Cursor Settings 所有项目,个人偏好
Team Rules 团队 Dashboard 全团队,付费版
AGENTS.md 项目根目录 当前项目,纯 Markdown

2.3 怎么创建 Rules

两种方式:

  1. 在 Chat 中输入 /create-rule,描述你想要规则
  2. 通过 Settings:Cursor Settings > Rules > + Add Rule

2.4 最佳实践

✅ 每条规则保持在 500 行以内,超出就拆

✅ 规则要具体可执行,像清晰的内部文档

✅ 用 @文件 引用范例,而不是把代码贴进去

✅ 发现 Agent 反复犯同一个错时,就写一条规则

💡 心得:Rules 是我用了就回不去的功能。之前每次都要重复说的话,现在配置一次就行。而且配置完,AI 写出来的代码风格完全一致,代码审查都省心了。


三、Skills:封装可复用的 AI 技能

3.1 什么是 Skills

如果说 Rules 是给 AI 定"工作原则",那 Skills 就是给 AI 打包"专项能力"。

举个例子:你们团队每次发版都要走一套固定流程——跑测试、构建镜像、部署到测试环境、跑集成测试、部署到生产。

这些步骤每次都要手把手教 AI,累不累?

Skills 就是来解决这个问题的。 它把领域特定的知识和工作流打包成 Agent 可以调用的技能包。

3.2 特点

  • 可移植:兼容所有支持 Agent Skills 标准的 AI 工具
  • 渐进式加载:Agent 按需加载资源
  • 可版本控制:作为文件存在,可以 Git 管理

3.3 目录结构

.agents/skills/
└── deploy-app/
    ├── SKILL.md
    ├── scripts/
    └── references/

3.4 怎么调用 Skills

  • 自动触发:Agent 根据对话上下文判断
  • 手动调用:在 Chat 中输入 /技能名

3.5 Rules vs Skills 怎么选?

场景 用什么
每次对话都需要遵守的编码规范 Rules
需要执行脚本的复杂任务流程 Skills
可复用的跨项目专项能力 Skills

💡 心得:我是先从 Rules 开始的,后来发现某些流程反复出现,就封装成了 Skills。比如我们团队的"发版流程",现在喊一声 /deploy 就搞定,省老鼻子事儿了。


四、.cursorignore:控制 AI 的视野范围

4.1 为什么要用 .cursorignore

Cursor 打开项目时会自动索引代码库。

但有些文件你不希望 AI 触碰——凭据、密钥、超大生成文件。

.cursorignore 就是这道防火墙。

相当于告诉 AI:"这些文件你别看,别问,别碰。"

4.2 语法规则

和 .gitignore 语法完全一样:

# 屏蔽特定文件
config/secrets.json

# 屏蔽整个目录
private/vendor/

# 按扩展名屏蔽
*.key
*.pem

4.3 全局忽略规则

在 Cursor Settings 中可以设置全局忽略规则,对所有项目生效。

💡 心得:之前没注意,有次让 AI 帮我重构代码,它把 node_modules 也搜进去了——整个项目直接卡死。加上 .cursorignore 后,世界清静了。


五、MCP:扩展 Agent 的能力边界

5.1 我以前的困扰

默认情况下,Cursor Agent 可以读写代码,执行终端命令、搜索网页。

但我想让它帮我——

  • 看看 Figma 设计稿长什么样
  • 查一下数据库现在什么结构
  • 更新 Jira 的 Issue 状态

臣妾做不到啊!

5.2 MCP 是什么

MCP 打破了这个边界——让 Agent 连接到任意外部系统:数据库、设计工具、项目管理平台。

说人话:以前 AI 是个"聋子瞎子",只能看代码;现在它长了"耳朵眼睛",能自己去看设计稿、去查数据库、去更新 Jira。

MCP(Model Context Protocol)就是一个"连接协议"——相当于 AI 和外部工具之间的翻译官。

5.3 怎么安装 MCP Server

方式一:一键安装(推荐)

访问 Cursor Marketplace,点击 Server 的「Add to Cursor」按钮。

方式二:手动配置 mcp.json

在项目根目录创建 .cursor/mcp.json

⚠️ 密钥永远不要硬编码,使用环境变量传入!

5.4 常用 MCP 示例

  • Figma MCP:让 Agent 直接读取 Figma 设计文件
  • Linear MCP:Agent 可以直接读 Issue、更新状态
  • 数据库 MCP:让 Agent 查询数据库 schema

💡 心得:接上 Figma MCP 之后,我前端页面开发效率翻倍。之前要反复对比设计稿和代码,现在直接让 AI 看图,帮我调样式——简直不要太爽。


六、Agent 工具详解:终端、浏览器、搜索

6.1 Terminal 工具

Agent 不仅仅是个"写代码的工具",它有一套完整的行动能力。

你可以理解为:AI 不仅能帮你写代码,还能帮你跑代码。

Agent 可以直接在你的终端里执行 Shell 命令——运行测试、安装依赖、执行构建。

沙箱保护机制

默认情况下,终端命令运行在受限沙箱中,相当于有个安全带:

访问类型 默认策略
文件读取 允许整个文件系统
文件写入 只允许工作区目录
网络访问 默认阻止,可配置

可以在 Settings > Agents > Auto-Run 中配置:

  • Run in Sandbox:自动在沙箱运行(推荐)
  • Ask Every Time:每条命令都手动确认

6.2 Browser 工具

Agent 可以控制一个完整浏览器:截图、点击、填表单、读 console 日志。

说白了就是:AI 可以自己开浏览器操作网页。

核心能力:

  • Navigate:访问 URL
  • Click / Type:与按钮、表单交互
  • Screenshot:截图
  • Console Output:读 JS 错误

还内置了设计侧边栏,直接可视化调整元素。

💡 心得:Browser 工具是我用过最香的功能之一。之前调样式要在浏览器和编辑器之间来回切换,现在直接让 AI 帮我调,它自己打开浏览器看效果,不满意就改——我只需要最后验收就行。

6.3 Web Search 工具

当使用 @web 时,Agent 会触发网络搜索。

它不只是返回链接,而是读取页面内容后提取关键信息。

相当于 AI 帮你看网页、总结内容,而不是丢一堆链接让你自己去看。


七、Subagents:多代理协作完成复杂任务

7.1 什么时候用 Subagents

当任务足够复杂——需要大量代码探索、并行处理多个模块——单个 Agent 会遇到上下文窗口限制。

就像一个人同时做很多事会手忙脚乱,AI 也一样。

Subagents 是 Cursor 对这个问题的解答。

7.2 Subagent 机制

Subagent 本质上是父 Agent 可以委托任务的专属 AI 助手。

你可以理解为:派几个小助手出去干活,各有各的分工,最后给你汇总。

每个 Subagent:

  • 拥有独立上下文窗口
  • 接收父 Agent 传入的任务描述
  • 可以配置独立模型

7.3 两种运行模式

模式 行为 适用场景
Foreground 阻塞等待 需要依赖输出的顺序任务
Background 立即返回 长耗时任务、并行工作流

7.4 三个内置 Subagent

  • Explore:搜索和分析代码库
  • Bash:执行 Shell 命令
  • Browser:控制浏览器

7.5 最佳实践

✅ 每个 Subagent 职责单一

✅ description 字段决定自动委托效果

✅ 提交到 Git:让整个团队受益

✅ 从少量开始:先建 2-3 个针对性强的

💡 心得:大型重构的时候,Subagents 简直救命。之前要一个个文件手动处理,现在分工明确——一个读代码理解业务,一个写新功能,一个跑测试——几分钟就干完以前要一下午的活。


八、Cursor CLI:在命令行中使用 AI

8.1 CLI 是什么

以前你用 Cursor,是不是都得打开编辑器?

但有时候我就是想在终端里直接让 AI 干活,不想开图形界面——太慢了。

Cursor CLI 就是让你在终端里用 AI。

不用打开 VS Code,直接在命令行就能让 AI 帮你干活。

8.2 安装

curl https://cursor.com/install -fsS | bash

8.3 交互模式

# 启动交互会话
agent

# 带初始 Prompt
agent "把认证模块重构为 JWT 方式"

8.4 Headless 模式

在脚本或 CI 中用 -p / --print 参数:

# 只提建议
agent -p "这个代码库是做什么的?"

# 允许修改文件
agent -p --force "将这个文件重构为 ES6+ 语法"

⚠️ 注意:-p 模式下默认只读,加上 --force 才会真正写入文件。

💡 心得:CLI 我主要用在 CI 里。每次 PR 提交后自动跑一遍代码审查,省了一个同事的工作量——开玩笑的,至少省了他 30% 的时间。


小结

这篇文章覆盖了让 Cursor "更懂你"的完整体系:

模块 解决的问题
上下文管理 让 AI 看到正确的代码,不多不少
Rules 把团队规范固化为 AI 的持久记忆
Skills 将重复流程打包为可复用能力
.cursorignore 保护敏感文件
MCP 连接外部系统
Agent 工具 用终端、浏览器、搜索形成行动闭环
Subagents 拆解复杂任务,并行执行
CLI 把 AI 能力延伸到脚本和 CI/CD

这些功能不是孤立的——一个成熟的 工作流 可能是:

.cursorignore 保护敏感文件 → Rules 定义项目规范 → Skills 封装部署流程 → MCP 连接 Linear 和数据库 → Subagents 并行处理大型重构 → 最后 CLI 把 AI Review 集成进 PR 流水线。

从最需要的地方开始,逐步搭建属于你的 AI 协作工作流。


下一步

前两篇讲的都是个人使用。第三篇我们聊聊怎么在团队里用好 Cursor。

第三篇预告:团队协作与场景实战

  • GitHub / GitLab 集成
  • Cloud Agent:让 AI 在云端跑任务
  • 团队管理
  • 前端工作流实战
  • Python / 数据分析实战
  • 用 AI 写文档和测试

好了,这篇就先到这里。

觉得有帮助的话,点个赞收藏一下,后续更新也能第一时间看到~

有问题欢迎在评论区问我,咱们下篇见!

也欢迎关注我的公众号「清汤饺子」,获取更多技术干货!

搞懂 Cursor 后,我一行代码都不敲了《实战篇》

Hi~大家好呀,我是清汤饺子。

前两篇我们分别讲了 Cursor 的基础用法和进阶功能——怎么安装、怎么用 Agent、怎么让 AI 更懂你的项目。

好!那这篇文章是第三篇,也是这个系列的最后一篇。

我们来聊聊怎么让整个团队高效地用好 Cursor。

如果你是团队的负责人,或者你想推动团队一起用 Cursor——这篇文章就是给你看的~

这个系列一共三篇:

第一篇从零上手 Cursor

讲讲怎么安装、Agent 怎么用、怎么写功能、怎么修 Bug

第二篇:让 Cursor 更懂你

上下文引用、Rules、Skills、MCP 这些

第三篇(就是这篇):团队协作与场景实战

怎么在团队里用好 Cursor


我踩过的坑

说出来你们可能不信,我们团队刚开始用 Cursor 的时候,那叫一个乱。

每个人都自己用自己的,也没有什么规范。

有人说用 Composer 1.5,有人说用 Opus;有人让 AI 随便改代码,有人全程盯着。

结果呢?代码风格不一致,AI 生成的代码质量参差不齐,有时候还闹出安全问题。

累不累啊。

后来我们痛定思痛,开始系统性地在团队里推广 Cursor。

这篇文章,就是把我们团队踩过的坑、总结的经验都分享出来。希望能帮你们少走弯路。


一、GitHub / GitLab 集成:让 AI 进入代码审查流程

1.1 我们遇到了什么问题

以前每次 PR 提交后,都要排队等同事 Code Review。有时候同事忙,等个大半天甚至一天都正常。

而且 Review 质量也看心情——有时候认真看,有时候赶时间就随便扫一眼。低级错误反复出现。

1.2 BugBot 是什么

Cursor 的 GitHub 集成可以让你每次 PR 都有 AI 先审一遍。

我叫它BugBot——它会在每次 PR 更新时自动分析 diff,找出 Bug,安全问题和代码质量问题,直接标注在有问题的代码行上,并给出修复建议。

相当于有个人帮你先过一遍,把明显的问题都标出来。

1.3 怎么开启

  1. 打开 cursor.com/dashboard?tab=integrations
  2. 点击 GitHub 旁边的 Connect
  3. 选择授权范围
  4. 进入 Bugbot 标签页,选择要开启的仓库

1.4 触发方式

  • 自动触发:每次 PR 更新时自动运行
  • 手动触发:在 PR 评论中写 cursor review

💡 心得:BugBot 帮我挡掉了至少一半的低级错误。之前每次 Code Review 都要说"这里变量名不一致"、"这里没判空",现在 AI 替我说了。

1.5 @cursor 触发 Agent

接入 GitHub 之后,任何人都可以在 PR 或 Issue 的评论中输入 @cursor + 描述,直接触发一个 Cloud Agent:

# 在 Issue 评论中
@cursor 实现用户头像上传功能

# 在 PR 评论中
@cursor 修复这个 Bug

二、Cloud Agent:让 AI 在云端跑任务

2.1 本地运行的痛

以前我让 AI 干活,有个最大的限制——必须开着电脑。

有时候下班了或者出差了,想让 AI 跑个大任务,根本不可能。

而且有些任务耗时特别长,比如跑完整的测试套件、构建生产环境——电脑一直开着不现实,电费也肉疼。

2.2 Cloud Agent 是什么

Cloud Agent 把这些工作搬到云端的虚拟机上,让 AI 在你睡觉的时候继续干活。

说人话:就是找了个远程电脑帮你跑 AI 任务,关机也不耽误。

每个 Cloud Agent 实例:

  • 可以启动开发服务器、打开浏览器
  • 从 GitHub 克隆仓库,在独立分支上工作
  • 可以运行构建、测试,自动修复 CI 失败
  • 支持 MCP 工具,可连接数据库

2.3 怎么启动

入口 方式
Cursor 编辑器 Agent 输入框下拉菜单选择 Cloud
Cursor Web cursor.com/agents
GitHub PR 或 Issue 评论中 @cursor
CLI agent -c "任务描述"

2.4 Automations:定时和事件驱动

Automations 让 Cloud Agent 在没有人工触发的情况下自动运行。

说人话:就像设了个定时闹钟,到点了 AI 自己就跑去干活。

实用场景示例:

# 场景一:每晚自动清理 Feature Flags
触发器:每天凌晨 2 点
Prompt:扫描代码库,找出已全量放量超过 30 天的 Feature Flag

# 场景二:PR 合并后自动更新文档
触发器:PR merged
Prompt:分析本次合并的改动,更新 docs/ 目录

💡 心得:我现在每天下班前设一个 Automation,第二天来公司 AI 已经把测试跑完了、报告打好了——的感觉不要太爽。


三、团队管理:成员、权限与用量

3.1 创建团队

访问 cursor.com/team/new-team,填写团队名称,邀请成员。

按量计费,不按席位。 这点很划算——人多人少都是一个价。

3.2 角色体系

角色 使用 Cursor 管理成员 是否计费
Member 可邀请
Admin 完整权限
Unpaid Admin 完整权限

Unpaid Admin 是专为 IT、财务等管理人员设计的角色——不用付费,但是可以管理成员。

3.3 用量分析(Analytics)

Analytics 仪表盘能看到:

  • AI Share of Committed Code:AI 生成代码占提交代码的比例
  • Agent Edits:Agent 建议的代码行数及用户接受率
  • Usage Leaderboard:团队内各成员的使用量排行
  • Repository Insights:按仓库维度统计的 AI 代码贡献

💡 心得:我们团队每个月会看一次 Analytics。之前大家都不好意思说用多了,现在数据透明,反而更愿意分享技巧了。

3.4 SSO 配置

Cursor 支持 SAML 2.0 SSO,Team 计划免费包含。

配置步骤:

  1. Dashboard → Settings → Single Sign-On (SSO)
  2. 在身份提供商中创建 SAML 应用
  3. 完成域名验证

四、前端工作流实战

4.1 我们遇到的前端痛点

前端开发有几个典型的高频痛点:

  • 设计稿还原效率低
  • 组件复用不规范
  • 调试 UI 要反复截图对比

4.2 从设计到代码的完整闭环

配合 Figma MCP,可以让 Cursor 直接读取设计文件:

@figma 读取设计文件中的 UserCard 组件规范,
用 Tailwind CSS 实现这个组件
用浏览器工具验证还原效果

实现后,让 Agent 用浏览器工具直接对比:

@browser 打开 localhost:3000/components/user-card,
截图后与设计稿对比

💡 心得:之前调样式要在 Figma 和代码之间来回切换几十次——现在 AI 帮我对比,效率直接翻倍。

4.3 用 Cursor 做原型设计

快速原型是前端开发中 Cursor 价值最高的场景之一:

我需要一个任务管理应用原型:
- 任务列表支持拖拽排序
- 支持按优先级筛选
- 样式参考 Linear 简洁风格

小提示

  • 指定具体的 UI 库(shadcn/ui、Radix)
  • 完成后立即用浏览器工具验证响应式表现

五、Python / 数据分析实战

5.1 Python 项目的挑战

Python 项目的挑战在于:

  • 环境依赖复杂
  • 数据分析代码散乱难维护
  • 调试 pandas 问题要反复 print

5.2 配置 Python 专属 Rules

.cursor/rules/ 下创建规则文件。

---
description: "Python 项目规范"
globs: "**/*.py"
---

## 代码规范
- 所有函数必须有类型注解
- 使用 pydantic BaseModel 定义数据结构

5.3 数据分析场景技巧

让 AI 理解数据结构:

这是销售数据,帮我:
1. 检查数据质量
2. 按地区做销售额汇总
3. 画出趋势图

💡 心得:之前数据分析都要先写一堆 print 看数据——现在直接让 AI 帮我分析,它还能给出优化建议。


六、用 AI 写文档和测试

6.1 文档和测试是最大的拖延源

你们有没有这种感觉——每次写文档,加测试,都是能拖就拖?

我懂。写代码已经够累了,还要写文档,加测试,太烦了。

但文档和测试又特别重要,怎么办?

让 AI 帮你写啊!

6.2 自动生成代码注释

注释生成策略:

不要让 AI 给每一行加注释——那样只会产生噪音。更好的方式是聚焦在真正需要解释的地方:

为这个文件中的所有公共函数生成 JSDoc 注释

小提示

  • 明确指定注释风格(JSDoc / Google style)
  • 在 Rules 中固定注释规范

6.3 单元测试生成

从 Bug 反向生成测试:

这个 PR 修复了优惠券叠加计算错误的 Bug,
根据修复的逻辑,生成回归测试

💡 心得:修完 Bug 立即让 AI 生成测试,已经成了我的习惯。现在代码质量放心多了。


小结

这篇文章覆盖了团队级 AI 协作的完整体系:

模块 解决的团队问题 核心工具
GitHub/GitLab 集成 代码审查效率低 BugBot、@cursor
Cloud Agent 任务依赖本地机器 Cloud Agent、Automations
团队管理 成员权限混乱 角色体系、Analytics、SSO
前端实战 设计还原慢 Figma MCP、Browser 工具
Python 实战 数据分析代码质量低 数据库 MCP
文档与测试 文档滞后 CLI 批处理、Automations

团队落地的推进路径

第一步(第 1-2 周):建立基础

  • 创建团队,邀请成员,配置 SSO
  • 接入 GitHub,开启 BugBot
  • 在一个活跃仓库配置 Project Rules

第二步(第 3-4 周):引入自动化

  • 配置 Cloud Agent 环境
  • 创建第一个 Automation
  • 用 Analytics 建立基准数据

第三步(第 2-3 个月):深化场景

  • 添加对应的 MCP(Figma、数据库)
  • 为高频重复任务创建 Automations
  • 封装团队专属 Skills

第四步(持续优化):数据驱动改进

  • 每月查看 Analytics
  • 收集大家踩过的坑,及时更新规则

三篇系列回顾

至此,整个「Cursor 从零到精通」系列完整收官。

篇目 核心主题
第一篇 从零上手
第二篇 让 Cursor 更懂你
第三篇 团队协作与场景实战

三篇叠加在一起,描述的是同一件事的三个层次:会用 → 用好 → 团队用好。

从只会问 AI "帮我写代码",到真正把 AI 融入团队的开发基础设施——不只是提升个人效率,而是让整个团队的协作方式升级。

这才是 Cursor 作为 AI 编辑器真正的价值所在。


好了,这个系列到这里就完结啦!

觉得有帮助的话,点个赞收藏一下,后续更新也能第一时间看到~

感谢你陪我一起走完这三篇文章,有问题欢迎在评论区问我~

我们下个系列见!👋

也欢迎关注我的公众号「清汤饺子」,获取更多技术干货!

❌