feat(docs):重构 Stage-3 Claude 核心技能章节

- 新增 3.1-claude-mcp: Claude 与 MCP 基础 - 新增 3.2-skills: Skills 开发指南 - 新增 3.3-long-running-tasks: 长任务处理 - 新增 3.4-agent-teams: Agent 团队协作 - 新增 3.5-superpowers: Claude 超能力实战 - 删除旧版 3.1-mcp-claude-code-skills 和 3.2-long-running-tasks
2026-02-28 19:04:24 +08:00
parent 09cbd870e5
commit e84b8d8ae0
7 changed files with 6590 additions and 6 deletions
@@ -1,3 +0,0 @@
 # 高级一：MCP 与 Claude Code Skills
 > 本章节正在编写中，敬请期待...
@@ -1,3 +0,0 @@
 # 高级二：如何让 Coding Tools 长时间工作
 > 本章节正在编写中，敬请期待...
@@ -0,0 +1,984 @@
 # Claude Code Skills 完全指南
 ## Skills 简介
 **Claude Code Skills** 是一种将专业知识、工作流程和最佳实践打包成"可复用技能包"的功能。
 想象一下，Skills 就像是给 Claude 配备的"技能书"——当你需要它完成特定任务时，它不再需要你一遍遍地解释要求，而是直接按照预先定义好的技能标准来执行工作。
 ### 为什么需要 Skills？
 在没有 Skills 之前，使用 Claude Code 存在一些问题：
 - **重复指令**：每次都要解释"代码要符合什么风格"、"提交信息要怎么写"
 - **知识无法沉淀**：团队成员各自的使用经验无法共享
 - **标准不统一**：不同的人用 Claude，结果可能完全不同
 - **效率低下**：常见的任务每次都要从头解释
 Skills 解决了这些问题，让 Claude 变成一个"有经验的团队成员"——它知道你的项目规范、工作流程和最佳实践。
 ---
 ## 快速开始
 ### 第一步：安装 find-skills（强烈推荐必装）
 在开始使用 Skills 之前，强烈推荐先安装 `find-skills` —— 这是 AI Agent 领域的"技能搜索神器"，目前已有 60K+ 订阅量。
 **find-skills 是什么？**
 简单来说，find-skills 就像是 AI Agent 的"应用商店搜索器"。当你需要完成某个任务但本地没有对应的 Skill 时，它会自动帮你搜索并推荐最合适的 Skill。
 **安装 find-skills**：
 ```bash
 npx skills add vercel-labs/agent-skills@find-skills -g -y
 ```
 安装完成后，你就可以直接告诉 Claude 你的需求，它会通过 find-skills 自动搜索相关技能。
 **使用示例**：
 ```
 我需要做一个 React 组件的性能优化，帮我找找有什么技能可以用
 ```
 Claude 会通过 find-skills 搜索，然后告诉你找到了哪些相关技能，你可以选择安装。
 **为什么推荐先装 find-skills？**
 没有 find-skills 之前：
 - 手动在 GitHub 搜索相关技能
 - 逐个复制、安装、配置
 - 反复调试适配
 有了 find-skills 之后：
 - 一句话描述需求
 - AI 自动搜索最匹配的技能
 - 一键安装，立即可用
 **Windows 用户注意**：官方版本对 Windows 支持有限，社区制作了 Windows 适配版本，支持 CMD 和 PowerShell，并增加了中文搜索功能。
 下载 Windows 版本：[github.com/tongbei821/customize-skills](https://github.com/tongbei821/customize-skills/blob/main/findskills/SKILL.md)
 安装步骤：
 1. 下载 Windows 版本的 SKILL.md
 2. 替换 `C:/Users/你的用户名/.agents/skills/find-skills` 目录下的文件
 3. 重启 Claude Code 即可生效
 **相关链接**：
 - [Skills 官网](https://skills.sh/) - 浏览所有可用技能
 - [find-skills 仓库](https://github.com/vercel-labs/agent-skills) - 官方源码
 ---
 ### 5 分钟上手 Skills（使用官方有趣 Skills 测试）
 让我们通过官方提供的 Skills 来快速体验 Skills 的强大功能。
 #### 测试 1：skill-creator（创建技能的技能）
 **安装官方 Skills 仓库**：
 ```bash
 /plugin marketplace add anthropics/skills
 ```
 或者直接克隆：
 ```bash
 git clone https://github.com/anthropics/skills.git ~/.claude/skills/official
 ```
 **体验 skill-creator**：
 在 Claude Code 中输入：
 ```
 /skill-creator
 我想创建一个技能，功能是自动格式化 JavaScript 代码。
 ```
 Claude 会引导你：
 1. 明确技能用途和场景
 2. 生成 SKILL.md 草稿
 3. 创建测试用例
 4. 运行评估并优化
 **预期效果**：你不需要手动写任何文件，Claude 会帮你完成整个创建流程。
 #### 测试 2：slack-gif-creator（创建 Slack GIF）
 **体验创作技能**：
 ```
 /slack-gif-creator
 帮我创建一个 128x128 的 GIF：
 - 蓝色背景渐变
 - 一个白色星星从左飞到右边
 - 同时带一点旋转效果
 ```
 Claude 会：
 1. 分析需求
 2. 生成 Python 代码（使用 PIL）
 3. 创建动画
 4. 优化文件大小
 **预期效果**：一个可用的 GIF 文件，符合 Slack 规范。
 #### 测试 3：mcp-builder（构建 MCP 服务器）
 **体验 MCP 开发技能**：
 ```
 /mcp-builder
 我想创建一个 MCP 服务器来连接我的 Notion workspace。
 ```
 Claude 会：
 1. 引导你完成需求分析
 2. 生成 MCP 服务器代码（Python 或 TypeScript）
 3. 配置工具和资源
 4. 提供测试方法
 **预期效果**：一个可运行的 MCP 服务器代码。
 #### 查看所有可用 Skills
 ```
 /skills
 ```
 或
 ```
 你有哪些技能？
 ```
 ### 理解 Skills 的价值
 通过这三个测试，你可以看到 Skills 的核心价值：
 1. **技能组合**：不同技能解决不同问题，可以灵活组合
 2. **AI 协作**：让 Claude 引导你完成复杂任务
 3. **可复用性**：创建一次，反复使用
 4. **可共享**：团队成员都可以使用相同的 Skills
 接下来，我们会深入探讨 Skills 的各个方面。
 ---
 ### 实战：用 find-skills 安装并体验第一个 Skill
 安装 find-skills 后，让我们用它来搜索并安装第一个好玩 的 Skill —— Remotion 视频制作工具。
 #### 第一步：用 find-skills 搜索 Remotion
 在 Claude Code 中输入：
 ```
 帮我找找 Remotion 相关的技能，我想做视频
 ```
 Claude 会通过 find-skills 搜索，推荐 `remotion-dev/skills`。
 #### 第二步：安装 Remotion Skills
 ```bash
 npx skills add remotion-dev/skills -g
 ```
 #### 第三步：用它做个好玩的！
 Remotion 是一个用 React 代码制作视频的框架，安装这个 Skill 后，你可以用自然语言让 Claude 帮你写视频代码。
 **任务 1：做个炫酷的文字动画视频**
 ```
 用 Remotion 做一个视频：
 - 1920x1080，5 秒
 - 一行文字 "Hello World" 从左边飞进来
 - 同时带旋转和缩放效果
 - 背景是渐变色
 ```
 Claude 会生成完整的 Remotion 代码，你可以运行它看到动画效果。
 **任务 2：做一个数据可视化视频**
 ```
 做一个 10 秒的视频，展示数据增长：
 - 开始是一个柱状图
 - 柱子逐个长高（带动画）
 - 数字滚动增加
 - 最后显示 "增长 300%" 的大字
 ```
 **任务 3：做一个多场景切换的演示视频**
 ```
 做一个产品演示视频，三个场景：
 场景 1：Logo 淡入显示，2 秒
 场景 2：产品特性列表逐个出现，3 秒
 场景 3：CTA 按钮弹出，2 秒
 每个场景之间有平滑过渡
 ```
 **运行代码**：
 Claude 生成的代码是完整的 Remotion 项目，你可以：
 1. 创建新项目：`npx create-video my-video`
 2. 把 Claude 生成的代码复制进去
 3. 运行预览：`npm start`
 4. 渲染视频：`npm run build`
 ---
 ### 第二个 Skill：用 find-skills 解决"前端又丑又卡"
 #### 第一步：用自然语言描述你的问题
 直接告诉 Claude 你的抽象需求：
 ```
 我的网页看起来很土，而且加载很慢，帮我找找有什么技能可以用
 ```
 或者更具体一点：
 ```
 我想让前端变好看，然后别那么卡
 ```
 #### 第二步：Claude 会用 find-skills 搜索
 Claude 会通过 find-skills 搜索 skills.sh 数据库，推荐相关的技能。对于"变好看+不卡"的需求，它会推荐：
 **anthropics/skills/frontend-design**（官方技能）
 这个技能专门解决 AI 生成的界面"看起来很土"的问题，让 Claude 设计出：
 - 独特的视觉风格（避开千篇一律的"AI 模板感"）
 - 专业的配色和字体
 - 流畅的动画效果
 - 生产级别的代码质量（代码干净，性能自然好）
 #### 第三步：安装并使用
 **安装**：
 ```bash
 npx skills add anthropics/skills/frontend-design -g
 ```
 **可以用它完成的任务**：
 ```
 帮我重新设计这个页面，要看起来很专业，别像 AI 生成的
 ```
 ```
 这个 UI 太丑了，用更现代的设计风格重写
 ```
 ```
 做一个暗色主题的 Dashboard，要有科技感
 ```
 Claude 会根据这个技能的规范，帮你设计出：
 - 独特的视觉方向（极简主义、复古未来主义、野兽派等）
 - 精心挑选的配色和字体
 - 合理的间距和布局
 - 流畅的交互动画
 ---
 ### 两个 Skills 的对比
 | Skills | 解决什么问题 | 好玩程度 |
 |--------|-------------|---------|
 | **remotion-dev/skills** | 用代码做视频 | ⭐⭐⭐⭐⭐ |
 | **anthropics/skills/frontend-design** | 让前端变好看 | ⭐⭐⭐⭐ |
 ---
 ### 安装后如何使用
 安装完成后，你不需要做任何额外配置。当你向 Claude 提出相关任务时，它会自动调用对应的 Skill。
 查看已安装的 Skills：
 ```bash
 npx skills list
 ```
 ---
 ## Skills 是什么？
 ### 核心概念
 **Skills 是存储在文件系统中的"技能包"**，包含：
 - **SKILL.md**：技能的定义文件（必需）
 - **scripts/**：辅助脚本（可选）
 - **templates/**：输出模板（可选）
 - **references/**：参考文档（可选）
 ### Skills vs 提示词
 你可能会有疑问：Skills 和直接给 Claude 发提示词有什么区别？
 | 提示词 | Skills |
 |--------|--------|
 | 临时性的，每次都要重复说 | 持久化的，写一次反复用 |
 | 存在对话历史中，占用 Token | 按需加载，节省 Token |
 | 无法在会话间共享 | 可以在团队中共享 |
 | 难以版本控制 | 可以用 Git 管理 |
 ### Skills 的两种类型
 **全局 Skills（个人）**：
 - 存放位置：`~/.claude/skills/`
 - 作用范围：所有项目
 - 适用场景：个人通用技能
 **项目 Skills（团队）**：
 - 存放位置：`项目目录/.claude/skills/`
 - 作用范围：当前项目
 - 适用场景：团队共享、项目特定规范
 ### Skills 如何工作
 当 Claude Code 启动时，它会：
 1. 扫描 Skills 目录
 2. 解析每个 SKILL.md 文件
 3. 提取 YAML frontmatter 元数据
 4. 将技能内容加入"知识库"
 5. 根据 description 自动匹配触发
 ---
 ## SKILL.md 文件结构
 ### 基本结构
 一个完整的 Skill 目录是这样的：
 ```
 my-skill/
 ├── SKILL.md          # 必需：技能定义文件
 ├── scripts/          # 可选：辅助脚本
 ├── templates/        # 可选：输出模板
 ├── references/       # 可选：参考文档
 └── examples/         # 可选：示例文件
 ```
 ### SKILL.md 模板
 SKILL.md 文件分为两个部分：
 **第一部分：YAML Frontmatter（元数据）**
 ```yaml
 ---
 name: skill-name              # 技能名称，会变成 /skill-name 命令
 description: 简短描述         # 用于 Claude 自动匹配触发
 category: development         # 分类
 tags:                           # 标签
  - code
  - automation
 ---
 ```
 **第二部分：Markdown 内容（指令）**
 ```markdown
 # 技能标题
 ## 使用场景
 什么时候用这个技能
 ## 执行步骤
 1. 第一步
 2. 第二步
 ## 注意事项
 - 注意点 1
 - 注意点 2
 ```
 ### 关键字段说明
 | 字段 | 必填 | 说明 |
 |------|------|------|
 | `name` | 是 | 技能名称，只能用小写字母、数字、连字符 |
 | `description` | 是 | 技能描述，越具体越容易被 Claude 自动匹配 |
 | `category` | 否 | 分类标签 |
 | `tags` | 否 | 更多分类标签 |
 | `allowed-tools` | 否 | 允许使用的工具，无需权限即可用 |
 ---
 ## Skills vs MCP：有什么区别？
 很多初学者会混淆 Skills 和 MCP，它们是完全不同的两个东西。
 ### 核心区别
 | 维度 | Skills | MCP |
 |------|--------|-----|
 | **本质** | 知识和流程 | 工具和接口 |
 | **提供什么** | 告诉 AI "怎么做" | 给 AI "能用什么" |
 | **存储位置** | `skills/` 目录 | MCP 服务器 |
 | **配置方式** | Markdown 文件 | JSON 配置文件 |
 | **触发方式** | `/skill-name` 或自动识别 | 通过配置自动加载 |
 ### 形象比喻
 如果把 Claude 比作一个"工作人员"：
 - **MCP** 是给这个工作人员配备的"工具"（扳手、电脑、访问权限）
 - **Skills** 是给这个工作人员的"操作手册"（怎么做代码审查、怎么提交代码）
 ### 它们的关系
 Skills 和 MCP 不是竞争关系，而是互补关系：
 ```
 用户任务 → Claude 识别需求
               ↓
        加载相关 Skills（知道怎么做）
               ↓
        通过 MCP 调用工具（有工具可用）
               ↓
        完成任务
 ```
 ### 举例说明
 **场景：代码审查**
 - **Skills** 定义：审查步骤、检查清单、输出格式
 - **MCP** 提供：访问 GitHub PR、获取代码 diff 的能力
 两者配合：Skills 告诉 Claude "怎么审查"，MCP 给 Claude "访问代码的能力"。
 ### 选择建议
 | 你的需求 | 推荐方案 |
 |----------|----------|
 | 需要定义工作流程 | 用 Skills |
 | 需要访问外部数据 | 用 MCP |
 | 需要两者都有 | 配合使用 |
 ---
 ## 常用 Skills 获取资源
 ### 官方资源
 - [Anthropic 官方 Skills 仓库](https://github.com/anthropics/skills) - 官方维护的技能集合
 - [Claude Code 官方文档 - Skills](https://docs.anthropic.com/en/docs/claude-code/configuration/skills) - 官方文档
 ### GitHub 社区资源
 | 仓库 | 说明 |
 |------|------|
 | [shanraisshan/claude-code-best-practice](https://github.com/shanraisshan/claude-code-best-practice) | Boris Cherny（Claude Code 负责人）维护，包含 Skills、Agents、Hooks 等 |
 | [affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code) | 综合工具包，包含预配置 Skills |
 | [JackyST0/awesome-agent-skills](https://github.com/JackyST0/awesome-agent-skills) | 精选 Skills 资源列表 |
 | [jeffallan/claude-skills](https://github.com/jeffallan/claude-skills) | 66 个专业技能，300+ 参考文档 |
 | [GitCode/awesome-claude-skills](https://gitcode.com/GitHub_Trending/aw/awesome-claude-skills) | 开源精选 |
 ### 如何安装社区 Skills
 使用 find-skills，只需要告诉 Claude 你需要什么，它会自动搜索并推荐：
 ```
 帮我找找有什么 React 性能优化相关的技能
 ```
 Claude 会通过 find-skills 搜索 skills.sh 数据库，然后列出最相关的技能，你选择安装即可。
 **搜索技巧**：
 - 使用具体关键词："react testing" 优于 "testing"
 - 组合「领域 + 动作」："nextjs deploy"、"typescript lint"
 - 优先选择高安装量的技能（10K+ 说明经过实战检验）
 - 关注 Trending 榜单发现新兴技能
 ---
 ## 如何创建自己的 Skills
 创建 Skills 有两种方法：一种是直接让 Claude 帮你创建，另一种使用专门的 skill-creator 工具。
 ### 方法一：直接让 Claude 帮你创建
 这是最简单的方式，直接用自然语言告诉 Claude 你的需求。
 **示例**：
 ```
 请帮我创建一个名为 "format-code" 的 skill，功能是自动格式化代码。
 要求：
 1. 自动检测编程语言类型
 2. 应用对应的格式化规则
 3. 返回格式化前后的 diff
 ```
 Claude 会自动：
 1. 创建目录结构
 2. 生成 SKILL.md 文件
 3. 填写 YAML frontmatter
 4. 编写技能内容
 **适用场景**：
 - 快速创建简单技能
 - 你知道要什么，但不熟悉 SKILL.md 格式
 - 想要快速迭代和修改
 ### 方法二：使用 skill-creator
 skill-creator 是一个专门用来创建 Skills 的工具，会引导你一步步完成。
 **安装**：
 ```bash
 npx skills add anthropics/skills@skill-creator -g
 ```
 或者安装整个官方 skills 仓库：
 ```bash
 npx skills add anthropics/skills -g
 ```
 **使用**：
 ```
 /skill-creator
 ```
 然后按提示填写：
 - 技能名称
 - 功能描述
 - 使用场景
 - 执行步骤
 skill-creator 会：
 1. 引导你明确技能用途
 2. 生成 SKILL.md 草稿
 3. 创建测试用例
 4. 运行评估并优化
 **适用场景**：
 - 创建复杂的技能
 - 需要规范的创建流程
 - 想要测试和验证技能
 ### 两种方法对比
 | 方法一：直接创建 | 方法二：skill-creator |
 |-----------------|---------------------|
 | 快速简单 | 步骤引导 |
 | 适合简单技能 | 适合复杂技能 |
 | 直接对话完成 | 规范流程 |
 | 灵活修改 | 有测试验证 |
 ### 技巧：如何写好需求
 **好的需求描述**：
 ```
 创建一个 "git-commit" skill，功能是自动提交代码。
 执行步骤：
 1. 检查有哪些文件被修改
 2. 生成符合 Conventional Commits 规范的提交信息
 3. 执行 git commit
 4. 询问是否需要 push
 注意事项：
 - 提交前先检查是否有敏感信息
 - 不要提交 dist/node_modules/ 等目录
 ```
 **不好的需求描述**：
 ```
 帮我写一个提交代码的 skill
 ```
 太模糊了，Claude 不知道具体要做什么。
 ---
 ## 常用 Skills 实例
 ### 实例 1：代码审查 Skill
 创建目录和文件：
 ```bash
 mkdir -p ~/.claude/skills/review-pr
 ```
 ```bash
 cat > ~/.claude/skills/review-pr/SKILL.md << 'EOF'
 ---
 name: review-pr
 description: 审查 Pull Request 的代码质量、安全性和测试覆盖率
 ---
 你是一位资深的代码审查者。
 ## 审查流程
 1. **代码风格检查**
   - 代码是否符合团队规范
   - 命名是否清晰
   - 注释是否充分
 2. **安全性检查**
   - 是否有安全漏洞
   - 敏感信息是否暴露
   - 输入验证是否完善
 3. **测试检查**
   - 是否有足够的测试
   - 测试用例是否覆盖边界情况
   - 测试是否可运行
 4. **总体评价**
   - 优点是什么
   - 需要改进的地方
   - 建议是否批准合并
 ## 输出格式
 请以清晰的结构输出审查结果，使用列表形式。
 EOF
 ```
 使用方式：
 ```
 /review-pr
 请审查当前分支的 PR
 ```
 ### 实例 2：Git 自动提交 Skill
 ```bash
 mkdir -p ~/.claude/skills/git-commit
 ```
 ```bash
 cat > ~/.claude/skills/git-commit/SKILL.md << 'EOF'
 ---
 name: git-commit
 description: 自动检测修改、生成提交信息并提交代码
 ---
 你是一位熟练的 Git 用户。
 ## 执行流程
 1. **检查修改**
   运行 `git status` 查看修改的文件
   运行 `git diff` 查看具体改动
 2. **生成提交信息**
   分析改动的性质
   生成符合 Conventional Commits 格式的提交信息
   格式：`type(scope): description`
 3. **安全检查**
   检查是否有敏感信息（密钥、密码、token）
   检查是否包含了不该提交的目录
 4. **确认后执行**
   显示提交信息供确认
   执行 `git add` 和 `git commit`
   询问是否需要 push
 ## 注意事项
 - 不要提交 node_modules/、dist/、.next/ 等目录
 - 提交前先运行测试确保代码可用
 - 提交信息要清晰说明改动内容
 EOF
 ```
 使用方式：
 ```
 /git-commit
 ```
 ### 实例 3：测试生成 Skill
 ```bash
 mkdir -p ~/.claude/skills/gen-test
 ```
 ```bash
 cat > ~/.claude/skills/gen-test/SKILL.md << 'EOF'
 ---
 name: gen-test
 description: 为代码自动生成单元测试，确保功能正确性
 ---
 你是一位测试开发工程师。
 ## 工作流程
 1. **分析代码**
   - 理解函数/类的功能
   - 识别输入和输出
   - 找出边界情况
 2. **生成测试**
   - 使用合适的测试框架
   - 覆盖正常情况
   - 覆盖边界情况
   - 覆盖异常情况
 3. **验证测试**
   - 确保测试可以运行
   - 确保测试能检测到问题
   - 不要过度模拟实现
 ## 测试框架
 - JavaScript/TypeScript：Jest 或 Vitest
 - Python：pytest
 - Go：testing 包
 ## 输出格式
 先输出测试代码，然后说明如何运行测试。
 EOF
 ```
 使用方式：
 ```
 /gen-test
 为 src/utils.ts 生成单元测试
 ```
 ### 实例 4：文档生成 Skill
 ```bash
 mkdir -p ~/.claude/skills/gen-readme
 ```
 ```bash
 cat > ~/.claude/skills/gen-readme/SKILL.md << 'EOF'
 ---
 name: gen-readme
 description: 为项目自动生成 README 文档
 ---
 你是一位技术文档专家。
 ## 工作流程
 1. **分析项目**
   - 扫描项目目录结构
   - 查看 package.json 或其他配置文件
   - 阅读现有代码
 2. **生成内容**
   - 项目简介
   - 安装方法
   - 使用说明
   - API 文档
   - 开发指南
 3. **格式化**
   - 使用清晰的章节结构
   - 添加代码示例
   - 添加适当的徽章
   - 添加许可证信息
 ## 标准 README 结构
 - 项目标题和简介
 - 功能特点
 - 安装方法
 - 快速开始
 - 使用说明
 - API 文档
 - 开发指南
 - 贡献指南
 - 许可证
 EOF
 ```
 使用方式：
 ```
 /gen-readme
 为当前项目生成 README 文档
 ```
 ---
 ## 进阶技巧
 ### Skills 与 Hooks 配合
 Hooks 可以在特定事件时自动执行操作，结合 Skills 可以实现更强大的自动化。
 例如：代码保存后自动格式化
 ```json
 // .claude/hooks.json
 {
  "hooks": {
    "PostToolUse": [{
      "matcher": {
        "tool_name": "Edit"
      },
      "hook": {
        "type": "command",
        "command": "/format-code"  // 调用 format-code skill
      }
    }]
  }
 }
 ```
 ### Skills 与 Commands 配合
 Commands 是简单的快捷命令，Skills 是复杂的工作流。两者可以配合使用。
 ### 团队协作
 **共享项目 Skills**：
 1. 将 Skills 放在 `.claude/skills/` 目录
 2. 提交到 Git 仓库
 3. 团队成员克隆项目后即可使用
 **版本控制**：
 - Skills 可以像代码一样进行版本控制
 - 每个 commit 都可以记录 Skills 的变更
 - 可以回滚到旧版本
 ---
 ## 常见问题
 ### Q1：Skill 没有被触发？
 可能的原因：
 - YAML frontmatter 格式错误
 - description 不够具体
 - Claude Code 没有重启
 解决方法：
 - 检查 YAML 格式是否正确
 - 改进 description，包含具体的使用场景
 - 重启 Claude Code
 ### Q2：description 怎么写才准确？
 好的 description 包含：
 - 技能的具体功能
 - 使用场景（"当用户提到..."）
 - 触发关键词
 **不好的例子**：
 ```
 description: 审查代码
 ```
 **好的例子**：
 ```
 description: 审查 Pull Request 的代码。当用户提到 PR、review、代码审查时触发。
 ```
 ### Q3：Skills 和 Commands 的区别？
 | Commands | Skills |
 |----------|--------|
 | 简单快捷命令 | 完整工作流 |
 | 单个 `.md` 文件 | 目录结构（SKILL.md + 可选文件） |
 | 手动触发 | 可自动触发 |
 | 适合简单操作 | 适合复杂流程 |
 ### Q4：如何调试 Skill？
 1. 使用 `/skills` 查看技能是否被识别
 2. 直接输入技能名称手动触发
 3. 检查 SKILL.md 文件内容是否正确
 4. 查看 Claude Code 日志
 ---
 ## 参考资料
 ### 官方资源
 - [Claude Code 官方文档 - Skills](https://docs.anthropic.com/en/docs/claude-code/configuration/skills)
 - [Agent Skills 标准](https://agentskills.io/)
 - [Anthropic 官方工程文章（Agent Skills 实战理念）](https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills)
 - [Anthropic 官方 Skills GitHub 仓库](https://github.com/anthropics/skills)
 - [VS Code Copilot Agent Skills 文档](https://code.visualstudio.com/docs/copilot/customization/agent-skills)
 ### 资源入口
 - [skills.sh](https://skills.sh/) - Vercel 出品的 Agent Skills 应用商店，48000+ 技能库
 - [find-skills](https://github.com/vercel-labs/agent-skills) - 智能技能搜索工具，60K+ 订阅
 - [Skills 市场（中文界面）](https://skillsmp.com/zh) - 发现和安装社区 Skills
 ### GitHub 社区项目
 - [vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills) - Vercel Labs 官方 Agent Skills 集合（含 find-skills）
 - [claude-code-best-practice](https://github.com/shanraisshan/claude-code-best-practice) - Boris Cherny 维护的官方最佳实践
 - [everything-claude-code](https://github.com/affaan-m/everything-claude-code) - 综合工具包，包含预配置 Skills
 - [awesome-claude-skills](https://github.com/ComposioHQ/awesome-claude-skills) - 精选 Skills 资源列表
 - [superpowers](https://github.com/obra/superpowers) - 软件开发自动化工作流 Skills 集合
 - [jeffallan/claude-skills](https://github.com/jeffallan/claude-skills) - 66 个专业技能，300+ 参考文档
 - [awesome-agent-skills](https://github.com/JackyST0/awesome-agent-skills) - 精选资源列表
 ### 官方 Skills 示例
 - [skill-creator](https://github.com/anthropics/skills/tree/main/skills/skill-creator) - 创建新技能的技能
 - [mcp-builder](https://github.com/anthropics/skills/tree/main/skills/mcp-builder) - 构建 MCP 服务器的技能
 - [slack-gif-creator](https://github.com/anthropics/skills/tree/main/skills/slack-gif-creator) - 创建 Slack GIF 的技能
 ### 中文教程
 - [Claude Code 高级配置与使用技巧完全指南](https://blog.csdn.net/2601_95335870/article/details/158460599)
 - [Vibe Coding - CLAUDE.md、Skills、Subagents 全链路实战](https://blog.csdn.net/yangshangwei/article/details/158319117)
 - [手把手教你自定义 Claude Code Skills](https://m.blog.csdn.net/u010028049/article/details/157979705)
 ---
 ## 总结
 Skills 是让 Claude Code 从"通用助手"变成"团队专家"的关键。
 通过 Skills，你可以：
 - 标准化工作流程
 - 复用团队知识
 - 提高协作效率
 - 减少重复解释
 记住：**如果你发现自己重复两次同样的指令，就应该考虑创建一个 Skill**。
 现在就开始创建你的第一个 Skill 吧！
@@ -0,0 +1,577 @@
 # 高级二：如何让 Claude Code 长时间工作
 ## 引言
 传统的 AI 编程助手是"对话式"的——你说一句，它回一句，然后停下了。但对于真正的开发任务来说，这种模式远远不够。
 想象一下这些场景：你想让 Claude 帮你重构整个项目，但它写完几个文件就说"我完成了"；你想让 Claude 持续修复 bug 直到测试全部通过，但它跑一次就停下来；你想让 Claude "过夜干活"，但第二天发现它早就停了。
 本章要解决的核心问题是：如何让 Claude Code 像真正的开发者一样，持续工作直到任务真正完成。
 ---
 ## 核心原理：为什么 AI 会"过早停止"？
 在介绍各种方法之前，先理解问题的根源。
 ### AI 的"完成判断"不可靠
 LLM（大语言模型）有一个根本缺陷：它无法准确判断自己的工作是否真正完成。
 人类的完成标准是客观的——所有测试通过、功能完整可用、代码质量达标。但 AI 只能基于"感觉"来判断。它可能会觉得"看起来差不多了"就停止，或者觉得"输出够多了"就停下，又或者不知道接下来该干什么而停下。
 这就是为什么我们需要一个外部系统来判断任务是否真正完成，而不是依赖 AI 自己的感觉。
 ### 解决方案的核心思想
 解决方案的核心是：让 AI 在一个"循环"中工作。
 每次它想退出时，外部系统会检查三个问题——真的完成了吗？符合客观标准了吗？还有没有遗漏？如果没有，就重新注入任务，继续下一轮。
 这个思想的实现形式多种多样，从简单的 bash 脚本到复杂的编排系统，本质都是一样的。
 ---
 ## 方法一：While True Bash Loop（最原始的方法）
 这是最简单、最直接的实现方式。本质上就是写一个无限循环，每次循环都重新启动 Claude Code 并喂给它同样的任务描述。
 最简单的实现只需要 5 行代码：
 ```bash
 #!/bin/bash
 while true; do
    cat PROMPT.md | claude
 done
 ```
 ### 工作原理
 这个脚本的工作流程很直接。第一步是读取 PROMPT.md 文件中的任务描述。第二步是启动 Claude Code 并将任务描述传递给它。第三步是 Claude 开始工作并输出结果。第四步是 Claude 完成后退出。第五步是循环自动重新启动，整个过程回到第一步，形成无限循环——除非你手动按 Ctrl+C 中断。
 ### 优缺点
 这种方法的优点是极其简单，任何人都能看懂，不需要任何配置，立即可用，适合快速实验。
 但缺点也很明显：它无法判断任务是否真的完成，可能无限空转，没有安全保护机制，会浪费 API 调用。
 ### 实际使用示例
 首先创建一个 PROMPT.md 文件来描述任务。比如重构用户认证模块的任务可以这样写：
 ```markdown
 # 任务：重构用户认证模块
 要求：
 1. 将所有认证逻辑抽取到独立的 AuthService 类
 2. 添加单元测试，覆盖率 > 80%
 3. 更新相关文档
 当所有测试通过且文档更新完成后，输出：任务完成
 ```
 然后创建循环脚本并运行：
 ```bash
 chmod +x loop.sh
 ./loop.sh
 ```
 ### 安全改进版
 为了避免无限循环，可以添加迭代次数限制：
 ```bash
 #!/bin/bash
 MAX_ITERATIONS=50
 iteration=0
 while true; do
    iteration=$((iteration + 1))
    echo "=== 迭代 $iteration/$MAX_ITERATIONS ==="
    cat PROMPT.md | claude
    if [ $iteration -ge $MAX_ITERATIONS ]; then
        echo "达到最大迭代次数，停止"
        break
    fi
    sleep 5  # 稍作等待，避免 API 限流
 done
 ```
 这个改进版本添加了最大迭代次数限制，每次循环显示当前进度，达到限制后自动停止。同时在每次循环之间添加 5 秒延迟，避免触发 API 限流。
 ---
 ## 方法二：Ralph Wiggum Plugin（官方推荐）
 Ralph Wiggum 是 Anthropic 官方推出的插件，专门解决长时间任务问题。它以《辛普森一家》中的角色命名，象征着"尽管失败，仍坚持尝试"的精神。
 ### 核心机制：Stop Hook
 Ralph 的核心机制是 Stop Hook。当 Claude 想要退出时，Stop Hook 会拦截这个退出信号。然后系统会检查：输出了特定的完成标记吗？如果没有找到完成标记，就重新注入原始 prompt，开始下一轮迭代。如果找到了完成标记，才允许 Claude 退出。
 这个机制保证了 Claude 不会因为"感觉差不多了"就停下来，而是必须真正完成明确标记的任务。
 ### 安装
 安装很简单，只需要在 Claude Code 中运行：
 ```bash
 claude /plugins:add ralph-wiggum
 ```
 ### 基本使用
 基本使用方式是通过 `/ralph-loop` 命令：
 ```bash
 /ralph-loop "构建一个待办事项 API，包含 CRUD 操作、输入验证、测试。
             全部完成后输出 <promise>COMPLETE</promise>" \
  --max-iterations 50 \
  --completion-promise "COMPLETE"
 ```
 ### 参数说明
 最重要的两个参数是 `--max-iterations` 和 `--completion-promise`。
 `--max-iterations` 设置最大迭代次数，这是安全机制，推荐值在 20-100 之间。即使任务没有完成，达到这个次数后也会停止，防止无限循环消耗 API 额度。
 `--completion-promise` 指定完成标记文本，需要是一个明确唯一的标识。当 Claude 的输出中包含这个标记时，Ralph 才会认为任务完成并允许退出。推荐使用像 `COMPLETE`、`TASK_DONE` 这样清晰的标记，避免使用模糊的词汇。
 ### Prompt 编写最佳实践
 编写好的 Prompt 是 Ralph 成功的关键。
 不好的 Prompt 往往没有明确的完成标准。比如简单地说"写一个 todo API"，这样 AI 可能写个基础框架就说完成了，没有测试、没有验证、没有文档。
 好的 Prompt 应该包含详细的阶段性要求和明确的验收标准。比如可以这样写：
 首先分阶段描述任务。阶段 1 是基础功能，列出所有 CRUD 端点：POST /todos 创建任务、GET /todos 获取列表、GET /todos/:id 获取单个、PUT /todos/:id 更新、DELETE /todos/:id 删除。阶段 2 是输入验证，标题不能为空，完成状态必须是布尔值。阶段 3 是测试，为每个端点编写测试，覆盖率要大于 80%。
 然后列出验收标准：所有测试通过、代码通过 linter 检查、README 包含 API 文档。
 最后指定一个唯一的完成标记：`<promise>TODO_API_COMPLETE</promise>`。
 这样 Claude 就知道确切要做什么，什么时候才算真正完成。
 ### 实战案例
 有一个著名的案例是在 Y Combinator 黑客松上，一个团队使用 Ralph Loop。晚上 11 点他们设置任务：根据 specs 目录下的 6 个产品需求，依次实现每个项目的 MVP，每完成一个输出特定的完成标记。设置最大迭代次数 200 次，然后就去睡觉了。
 第二天早上醒来，他们发现有 6 个可演示的项目，而 API 调用成本只有 297 美元。这就是 Ralph 的威力——你睡觉的时候，AI 在工作。
 另一个案例来自 Boris Cherny（Claude Code 负责人）。他使用 Ralph 加上 Opus 4.5 模型，在 30 天内提交了 259 个 PR，包含 497 次提交，新增 40,000 行代码、删除 38,000 行代码。最惊人的是，这 100% 都是由 Claude Code 完成的，没有人工编写一行代码。
 ### Ralph 的哲学
 Ralph 体现了三个核心哲学思想。
 第一是迭代大于完美。不要指望一次就完美，让循环来改进。第一次可能只写个框架，第二次修复 bug，第三次优化代码，第四次添加测试，每次都比上一次更好。
 第二是失败是数据。每次测试失败都是改进的机会，不要害怕失败，要从失败中学习。
 第三是持续尝试。Keep trying until it works——这就是 Ralph 的精神。
 ---
 ## 方法三：增强版 Ralph
 这是社区对官方 Ralph 的增强实现，在 GitHub 上可以找到 [frankbria/ralph-claude-code](https://github.com/frankbria/ralph-claude-code) 项目，增加了更多安全机制。
 ### 额外特性
 增强版提供了几个额外的安全特性。
 第一个是双重退出条件。官方 Ralph 只需要检查完成标记，但增强版需要同时满足完成标记和显式 EXIT_SIGNAL 才会真正停止。这意味着即使 Claude 输出了完成标记，如果它没有明确表示要退出，循环还会继续，可以进一步验证和改进。
 第二个是速率限制功能。默认设置为 100 次/小时，防止因为某种 bug 导致无限循环时，API 账单爆炸。你可以根据需要调整这个限制。
 第三个是智能熔断器。如果系统连续 5 次检测到完成标记，会强制退出。这是为了防止某种边缘情况导致循环无法正常结束。
 第四个是实时仪表盘。增强版提供了一个命令行界面，可以显示当前迭代次数、任务进度、预估成本等信息，让你随时掌握状态。
 ### 安装
 安装增强版 Ralph 需要先从 GitHub 克隆仓库：
 ```bash
 git clone https://github.com/frankbria/ralph-claude-code.git
 cd ralph-claude-code
 ./install.sh
 ```
 安装脚本会自动设置好所需的文件和配置。
 ### 使用
 使用增强版 Ralph 分两步。首先用 `ralph-setup` 命令初始化项目：
 ```bash
 ralph-setup my-project
 ```
 这会在项目中创建所需的配置文件。然后用 `ralph loop` 命令启动循环：
 ```bash
 ralph loop
 ```
 ### 配置文件
 增强版 Ralph 使用配置文件 `.claude/ralph-config.json` 来设置参数：
 ```json
 {
  "maxIterations": 50,
  "rateLimitPerHour": 100,
  "completionPromise": "TASK_COMPLETE",
  "exitSignal": "EXIT_NOW",
  "costAlertThresholds": [10, 50, 100]
 }
 ```
 `maxIterations` 是最大迭代次数。`rateLimitPerHour` 是每小时速率限制。`completionPromise` 是完成标记文本。`exitSignal` 是显式退出信号。`costAlertThresholds` 是成本预警阈值，当花费达到这些金额时会发出警告。
 ---
 ## 方法四：Agent Teams（多代理并行）
 当任务足够大时，单个 Claude 不够用，需要"团队协作"。
 Agent Teams 是一个高级功能，允许多个 Claude 实例并行工作，通过共享任务列表协调依赖关系。这适合超大型项目，比如 Nicholas Carlini 的实验中，16 个并行 Agent 在 2 周内编写了 100,000+ 行代码，构建出一个能编译 Linux 内核的 C 编译器。
 Agent Teams 的内容比较复杂，我们将在下一节《3.3 Agent Teams 多代理协作》中详细讲解。
 ---
 ## 方法五：后台任务（Ctrl+B）
 这是一个简单但实用的非阻塞执行方法。
 ### 基本操作
 使用方式很直观。当 Claude 开始运行一个任务时，你可以按 `Ctrl+B` 把它推送到后台。
 比如你说："运行完整测试套件"。Claude 开始运行。你可以按 `Ctrl+B`，Claude 会返回："任务已推送到后台（ID: task_abc123）"。然后你可以继续说："同时，帮我分析这个日志文件"。Claude 会在后台运行测试的同时，帮你分析日志。
 ### 查看后台任务
 有几种方式查看后台任务。使用 `/tasks` 命令可以列出所有后台任务，包括任务 ID、状态、启动时间等信息。按 `Ctrl+T` 可以快速查看任务状态的摘要。你也可以从任务列表中选择某个任务，把它恢复到前台（Bring to foreground），查看它的实时输出。
 ### 适用场景
 后台任务适合几个典型场景。
 第一个是长时间运行的测试。完整测试套件可能需要几十分钟，用后台任务可以在测试运行的同时继续开发。
 第二个是大型项目构建。构建过程可能需要很长时间，后台运行不会阻塞其他工作。
 第三个是批量文件处理。比如批量重命名、批量格式化等，可以在后台进行。
 第四个是任何你不想等待的事情。
 ---
 ## 安全机制：防止无限循环
 任何自动循环系统都必须有安全保护，否则可能出现失控的情况。
 ### 硬性限制
 最基本的保护是设置 `--max-iterations`（最大迭代次数），这是必须的。无论任务是否完成，达到这个次数后都会停止，防止无限循环消耗 API 额度。
 你还可以设置时间限制，比如最长运行 4 小时后自动停止。或者设置 API 预算警告，当花费达到一定金额（比如 10 美元、50 美元、100 美元）时暂停并通知你。
 ### 智能检测
 可以添加智能检测来发现死循环。比如检查最近几次提交有没有实质变化：
 ```bash
 if [ $(git diff HEAD~5 | wc -l) -eq 0 ]; then
    echo "最近 5 次提交没有实质变化，可能陷入循环"
    exit 1
 fi
 ```
 如果最近 5 次提交的代码差异很小，说明可能陷入了死循环，应该停止并报警。
 ### 成本预警
 配置文件中可以设置成本预警阈值：
 ```json
 {
  "costAlertThresholds": [10, 50, 100],
  "alertAction": "pause_and_notify"
 }
 ```
 当花费达到 10、50、100 美元时，系统会暂停任务并发送通知，让你决定是否继续。
 ### 人工检查点
 对于特别重要的任务，可以设置人工检查点：
 ```bash
 if [ $((iteration % 10)) -eq 0 ]; then
    read -p "已完成 $iteration 次迭代，继续吗？(y/n)" answer
    if [ "$answer" != "y" ]; then
        break
    fi
 fi
 ```
 这样每 10 次迭代暂停一次，等待你确认是否继续。这样可以在出现问题时及时干预。
 ---
 ## 实战：用 Ralph Loop 构建完整的 BBS 论坛系统
 让我们通过一个完整的例子来展示 Ralph Loop 的威力。我们将从零开始构建一个仿造 BBS 论坛系统，包含用户鉴权、发帖、用户中心和管理后台。
 ### 项目目标
 构建一个功能完整的 BBS 论坛系统，包含：
 **用户端功能**：
 - 用户注册、登录、退出
 - 浏览帖子列表（分页）
 - 查看帖子详情
 - 发布新帖
 - 评论功能
 - 个人中心（查看自己的帖子、修改个人信息）
 **管理后台功能**：
 - 管理员登录
 - 用户管理（封禁、解封）
 - 帖子管理（删除、置顶）
 - 评论管理
 - 系统统计
 **技术栈**：
 - 后端：Node.js + Express + SQLite 数据库
 - 前端：React + React Router + Axios
 - 认证：JWT Token
 - 样式：Tailwind CSS
 ### 准备工作
 首先安装 Ralph Wiggum 插件：
 ```bash
 claude /plugins:add ralph-wiggum
 ```
 ### 启动 Ralph Loop
 现在启动 Ralph Loop，让它完成整个项目：
 ```bash
 /ralph-loop "
 请从零开始构建一个完整的 BBS 论坛系统，使用 TDD 方式开发。
 项目结构要求：
 - backend/ 目录：Express API 服务器
 - frontend/ 目录：React 前端应用
 - 两个目录都有各自的测试
 后端功能要求：
 - 使用 Express 框架
 - SQLite 数据存储（better-sqlite3）
 - JWT 用户认证（jsonwebtoken + bcrypt）
 - 用户表：id、username、password、email、role、createdAt
 - 帖子表：id、title、content、authorId、category、pinned、createdAt
 - 评论表：id、content、postId、authorId、createdAt
 后端 API 端点：
 - POST /api/auth/register - 用户注册
 - POST /api/auth/login - 用户登录
 - GET /api/posts - 获取帖子列表（分页、分类筛选）
 - GET /api/posts/:id - 获取帖子详情
 - POST /api/posts - 发布帖子（需登录）
 - PUT /api/posts/:id - 编辑帖子（作者或管理员）
 - DELETE /api/posts/:id - 删除帖子（作者或管理员）
 - POST /api/posts/:id/comments - 发表评论（需登录）
 - GET /api/user/profile - 获取个人信息（需登录）
 - PUT /api/user/profile - 更新个人信息（需登录）
 - GET /api/admin/stats - 管理员统计（需管理员）
 - GET /api/admin/users - 用户列表（需管理员）
 - PUT /api/admin/users/:id/ban - 封禁用户（需管理员）
 前端页面要求：
 - /login - 登录页
 - /register - 注册页
 - / - 首页（帖子列表）
 - /post/:id - 帖子详情
 - /new - 发布帖子
 - /profile - 个人中心
 - /admin - 管理后台（需管理员权限）
 管理后台功能：
 - 用户管理（查看、封禁、解封）
 - 帖子管理（查看、删除、置顶）
 - 评论管理（查看、删除）
 - 系统统计（用户数、帖子数、评论数）
 TDD 要求：
 - 先写测试，后写代码
 - 每个功能都要有对应的测试
 - 后端使用 Jest，API 测试要覆盖所有端点
 - 前端使用 Vitest，组件测试要覆盖主要功能
 - 认证中间件要有测试
 验收标准：
 - 运行 npm test（后端）全部通过
 - 运行 npm test（前端）全部通过
 - 前端可以正常启动并使用
 - 后端 API 可以正常响应
 - 普通用户和管理员权限正确隔离
 - 代码通过 ESLint 检查
 完成后输出：<promise>BBS_SYSTEM_COMPLETE</promise>
 " --max-iterations 150 --completion-promise "BBS_SYSTEM_COMPLETE"
 ```
 ### 预计时间
 根据项目复杂度：
 **如果人工编写**：大约 40-60 小时（包括数据库设计、认证系统、前后端联调、测试）
 **使用 Ralph Loop**：
 - 基础版本（核心功能）：约 3-5 小时
 - 完整版本（包含管理后台、测试）：约 6-10 小时
 ### 监控进度
 Ralph Loop 运行时，你可以通过几个方式监控进度：
 **查看迭代次数**：Ralph 会显示当前迭代次数和最大次数，你可以估算剩余时间。
 **查看日志**：你可以看到 Claude 正在做什么——设计数据库、写 API、实现前端组件、修复 bug。
 **测试状态**：每次测试运行的结果会显示，通过的测试会增加，失败的测试会减少。当失败的测试开始变少，说明项目接近完成。
 ### 完成后验证
 当 Ralph Loop 输出完成标记后，你需要手动验证：
 ```bash
 # 后端测试
 cd backend
 npm test
 # 前端测试
 cd frontend
 npm test
 # 启动后端
 cd backend
 npm start
 # 启动前端（另一个终端）
 cd frontend
 npm run dev
 ```
 打开浏览器，测试以下流程：
 1. 注册新用户
 2. 登录
 3. 浏览帖子
 4. 发布新帖
 5. 发表评论
 6. 访问个人中心
 7. 退出后用管理员登录（默认账号：admin/admin123）
 8. 测试管理后台功能
 ### 注意事项
 Ralph Loop 虽然强大，但有几个注意事项：
 **第一，Prompt 越详细，结果越好**。模糊的 Prompt 导致需要更多迭代来修正。
 **第二，设置合理的迭代次数**。BBS 系统比较复杂，建议至少 100 次迭代。
 **第三，TDD 是推荐方式**。先写测试可以大幅减少调试时间。
 **第四，最终需要人工验证**。AI 可能遗漏边界情况或特殊场景，特别是安全相关的功能。
 **第五，数据库设计要仔细**。Ralph 可能需要几次迭代才能设计出合理的数据库结构。
 ---
 ## 方法对比与选择
 各种方法各有特点，适合不同场景。
 While True Loop 最简单，只需要 5 行代码就能工作，适合快速实验和原型验证。但功能有限，没有完成检测，只能靠迭代次数限制。
 Ralph Wiggum 是通用推荐，适合大部分场景。它有完整的 Stop Hook 机制，支持完成标记检测，有官方支持，文档完善。
 增强版 Ralph 更适合生产环境，有双重退出条件、速率限制、智能熔断器等额外的安全机制。
 后台任务适合简单的非阻塞执行，只需要按 `Ctrl+B` 就能用。但它只是简单的后台运行，没有循环机制。
 ---
 ## 总结
 让 Claude Code 长时间工作的核心思想很简单：不要让它"一次完成"，而是让它"持续尝试直到真正完成"。
 所有方法本质上都是在做同一件事：给 Claude 一个任务，让它工作，检查是否真的完成，如果没有，继续下一轮。
 选择哪种方法取决于你的具体需求。
 如果想要简单快速，用 While True Loop。5 行代码就能工作，但功能有限。
 如果想要通用推荐，用 Ralph Wiggum。官方支持，功能完整，适合大部分场景。
 如果是生产环境，用增强版 Ralph。有额外的安全机制，更可靠。
 （Agent Teams 多代理协作的内容请参考下一节《3.3 Agent Teams 多代理协作》）
 希望这一章的内容能帮助你更好地利用 Claude Code，让 AI 真正成为你的生产力工具，而不仅仅是聊天机器人。
 ---
 ## 参考资料
 ### 官方资源
 - [Claude Code 官方文档](https://docs.anthropic.com/en/docs/claude-code) - Claude Code 的完整官方文档
 - [Ralph Wiggum Plugin README](https://github.com/anthropics/claude-plugins-official/tree/main/plugins/ralph-wiggum) - Ralph Wiggum 插件的官方文档
 - [Claude Code Hooks 系统](https://docs.anthropic.com/en/docs/claude-code/configuration/hooks) - Hooks 系统的官方文档
 ### 社区项目
 - [frankbria/ralph-claude-code](https://github.com/frankbria/ralph-claude-code) - 增强版 Ralph 实现，包含额外的安全机制
 - [win4r/claude-code-hooks](https://github.com/win4r/claude-code-hooks) - Hook 示例和工具集合
 - [snarktank/ralph](https://github.com/snarktank/ralph) - 原始 Ralph 实现
 - [affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code) - 生产级配置模板
 - [claude-flow](https://github.com/ruvnet/claude-flow) - 企业级编排平台
 ### 文章与教程
 - [Geoffrey Huntley - Ralph Technique](https://ghuntley.com/ralph/) - Ralph 技术的原创者
 - [O'Reilly - Conductors to Orchestrators](https://www.oreilly.com/radar/conductors-to-orchestrators-the-future-of-agentic-coding/) - AI 编程从指挥到编排的演进
 - [构建可靠长时运行AI代理的有效框架实践](https://m.blog.csdn.net/weixin_48708052/article/details/158044721) - Anthropic 工程博客精读
 - [Claude Code 最佳实践（作者亲授）](https://juejin.cn/post/7366666666666666666) - 官方最佳实践分享
 - [Claude Code 全攻略](https://developer.aliyun.com/article/1705912) - 完整的使用指南
 - [Reverse Engineering Analysis](https://m.blog.csdn.net/qq_33778762/article/details/149490953) - Claude Code 的逆向工程分析
 ### 实战案例
 - [16 Agents Build C Compiler](https://arxiv.org/abs/2408.01342) - Nicholas Carlini 的实验论文
 - [Boris Cherny's 30 Days](https://twitter.com/boriskirov/status/1756002385683786616) - 259 PRs 案例分享
 - [Y Combinator Hackathon](https://github.com/geoffreyhuntley/ralph) - 6 个项目过夜生成的案例
 ### 工具文档
 - [Tmux 官方文档](https://github.com/tmux/tmux/wiki) - Tmux 的完整文档
 - [GitHub Actions 文档](https://docs.github.com/en/actions) - GitHub Actions 的官方文档
 - [Agent SDK](https://docs.anthropic.com/en/docs/agents) - 构建自定义代理的 SDK
@@ -0,0 +1,623 @@
 # 高级五：Claude Code Superpowers 工程级开发
 ## Superpowers 简介
 **Superpowers** 是由 Jesse Vincent（网名 obra）开发的开源代理技能框架，专门解决 AI 编程中的一个核心问题：如何让 AI 写出"工程级"的代码，而不是"玩具级"的代码。
 想象一下，普通 AI 编程助手就像一个"聪明的实习生"——它能写出能跑的代码，但可能没有测试、没有文档、没有遵循最佳实践。而 Superpowers 则像是给这个实习生配备了一位"资深工程师导师"，强制它遵循完整的软件开发流程。
 ### 为什么需要 Superpowers？
 在没有 Superpowers 之前，使用 Claude Code 存在一些问题：
 - **Vibe Coding 的混乱**：AI 直接开始写代码，没有规划，导致频繁返工
 - **缺少 TDD 纪律**：AI 习惯先写代码再补测试，甚至干脆不写测试
 - **需求模糊直接动手**：用户说"做一个登录功能"，AI 就开始写，结果做出来不是想要的
 - **代码质量不稳定**：没有代码审查机制，质量依赖 AI 的"心情"
 Superpowers 解决了这些问题，让 Claude 变成一个"有纪律的开发团队"——它先帮你澄清需求，然后制定计划，再用 TDD 方式开发，最后通过代码审查确保质量。
 ---
 ## 快速开始
 ### 第一步：安装 Superpowers
 在 Claude Code 中运行：
 ```bash
 # 添加 marketplace
 /plugin marketplace add obra/superpowers-marketplace
 # 安装 superpowers
 /plugin install superpowers@superpowers-marketplace
 ```
 或者手动克隆：
 ```bash
 git clone https://github.com/obra/superpowers.git ~/.claude/skills/superpowers
 ```
 ### 第二步：体验第一个 Skill
 让我们用 Superpowers 的 **brainstorming**（头脑风暴）技能来体验它的价值。
 在 Claude Code 中输入：
 ```
 我做一个用户登录功能
 ```
 **没有 Superpowers 之前**：Claude 直接开始写代码，可能做出来不是你想要的。
 **有 Superpowers 之后**：Claude 会通过苏格拉底式提问帮你澄清需求：
 > 这个登录功能是为 Web 应用还是移动应用设计的？
 >
 > 需要支持哪些登录方式？邮箱密码？第三方登录（Google、GitHub）？
 >
 > 是否需要"记住我"功能？
 >
 > 密码重置流程是邮件还是短信？
 >
 > ...
 这些问题迫使你在编码前想清楚真正需要什么，避免写出一堆用不上的代码。
 ### 第三步：了解技能触发机制
 Superpowers 不是"魔法开关"，它是一组**技能集合**。了解技能如何触发很重要。
 **技能触发的三种方式**：
 1. **关键词触发**
   - 当你提到 "TDD"、"测试驱动开发"、"先写测试" 时
   - `test-driven-development` 技能会被激活
 2. **场景触发**
   - 当需求模糊时，`brainstorming` 技能会主动提问
   - 当出现 bug 时，`systematic-debugging` 技能会被激活
 3. **手动调用**
   - 直接使用技能名称：`/test-driven-development`
 #### 💡 重要理解：不指定 TDD 会怎样？
 这是一个常见误解，让我们澄清：
 ```
 # 情况 A：不提 TDD
 "实现一个计算器"
 → Claude 可能写测试，也可能不写
 → 取决于模型本身的训练习惯
 # 情况 B：提到 TDD
 "用 TDD 方式实现一个计算器"
 → test-driven-development 技能被激活
 → 强制遵循 RED-GREEN-REFACTOR 流程
 ```
 **Superpowers 的真正价值**：不是"无中生有"，而是"强化纪律"。
 - 没有 TDD 技能时：Claude 写测试是"看心情"
 - 有 TDD 技能时：Claude 被强制遵循 TDD 流程
 ### 理解 Superpowers 的价值
 通过上面的解释，你可以看到 Superpowers 的核心价值：
 1. **需求优先**：`brainstorming` 技能在需求模糊时主动提问
 2. **流程纪律**：`test-driven-development` 强制 TDD 红绿重构循环
 3. **任务分解**：`writing-plans` 将大项目拆解为小任务
 4. **质量控制**：`code-review` 技能确保代码质量
 ---
 ## Superpowers 核心技能详解
 Superpowers 包含 **20+ 个可组合技能**，覆盖整个软件开发生命周期。让我们按类别了解它们。
 ### 🧪 测试类技能
 #### test-driven-development（测试驱动开发）
 **如何触发**：提到 "TDD"、"测试驱动开发"、"先写测试" 等关键词。
 **这个技能做什么**：强制 Claude 遵循 TDD 红绿重构循环，而不是"想起来再写测试"。
 **传统开发方式**（常见问题）：
 1. 直接写代码
 2. 手动测试一下
 3. 发现 bug，修改代码
 4. 重复...（测试？下次再说吧）
 **TDD 方式**（技能激活后）：
 1. 🔴 **RED**：先写一个失败的测试
 2. 🟢 **GREEN**：写最少的代码让测试通过
 3. 🔵 **REFACTOR**：重构代码，保持测试通过
 4. 重复
 **使用示例**：
 ```
 用 TDD 方式实现一个用户认证模块
 ```
 Claude 会：
 1. 先编写测试（测试用户名密码验证、测试 token 生成...）
 2. 运行测试，确认全部失败（RED）
 3. 编写最小实现代码
 4. 运行测试，确认通过（GREEN）
 5. 重构代码，提取公共逻辑
 6. 再次运行测试，确认仍然通过（REFACTOR）
 > **注意**：如果你不提 "TDD"，Claude 可能也可能不写测试。这个技能的作用是**强化流程纪律**，确保测试不会"被遗忘"。
 ### 🐛 调试类技能
 #### systematic-debugging（系统化调试）
 当出现 bug 时，人类开发者往往会随机尝试各种修复方案。Superpowers 强制使用四阶段根因分析：
 **阶段 1：复现问题**
 - 确认 bug 可以稳定复现
 - 记录复现步骤
 **阶段 2：隔离根因**
 - 通过二分法缩小范围
 - 添加日志定位问题代码
 **阶段 3：验证假设**
 - 提出根因假设
 - 设计验证实验
 **阶段 4：修复并验证**
 - 实施修复
 - 确认 bug 解决
 - 添加回归测试
 #### verification-before-completion（完成前验证）
 这个技能防止 Claude "感觉差不多"就停止工作。它要求 Claude 在声称任务完成前：
 1. 运行所有测试
 2. 手动测试关键功能
 3. 检查代码质量（lint）
 4. 确认文档已更新
 ### 🤝 协作类技能
 #### brainstorming（头脑风暴）
 这是 Superpowers 最有趣的技能之一。它使用苏格拉底式提问法帮你澄清需求。
 **工作方式**：当你提出一个模糊需求时，Claude 不会直接动手，而是会问你问题：
 ```
 你：做一个博客系统
 Claude：
 - 这个博客主要是给谁看的？技术读者还是大众？
 - 需要支持 Markdown 编辑吗？
 - 需要评论功能吗？
 - 需要搜索功能吗？
 - 是单用户还是多作者？
 - ...
 ```
 这些问题迫使你思考真正需要什么功能，避免开发出一堆用不上的东西。
 #### writing-plans（编写计划）
 这个技能将大任务分解为 2-5 分钟可完成的小任务。
 **示例**：
 ```
 用 writing-plans 规划一个待办事项 API 的开发
 ```
 Claude 会生成详细计划：
 ```markdown
 # 实现计划
 ## 任务 1：设计数据库 schema（预计 5 分钟）
 - 创建 todos 表
 - 定义字段：id, title, completed, createdAt
 ## 任务 2：创建 Express 路由（预计 10 分钟）
 - POST /todos - 创建任务
 - GET /todos - 获取列表
 - GET /todos/:id - 获取单个
 - PUT /todos/:id - 更新
 - DELETE /todos/:id - 删除
 ## 任务 3：添加输入验证（预计 10 分钟）
 - 标题不能为空
 - completed 必须是布尔值
 ## 任务 4：编写测试（预计 15 分钟）
 - 为每个端点编写测试
 - 覆盖边界情况
 ## 任务 5：启动服务器并验证（预计 5 分钟）
 - 运行测试
 - 手动测试 API
 验收标准：
 - 所有测试通过
 - curl 测试每个端点正常
 ```
 #### executing-plans（执行计划）
 这个技能批量执行计划，并在每个检查点暂停确认。
 **使用示例**：
 ```
 执行上面的计划，每完成一个任务暂停一下
 ```
 Claude 会：
 1. 完成任务 1，然后暂停：`✅ 数据库 schema 完成，继续吗？`
 2. 你确认后完成任务 2，再次暂停
 3. 以此类推
 这让你可以在每个阶段检查方向是否正确，避免跑远了才发现错了。
 #### dispatching-parallel-agents（并行代理调度）
 这个技能可以同时启动多个子代理并行工作。
 **使用场景**：当你需要同时处理多个独立任务时。
 ```
 用并行代理同时完成：
 - 代理 A：编写后端 API
 - 代理 B：编写前端组件
 - 代理 C：编写测试
 ```
 每个代理在自己的隔离环境中工作，互不干扰。
 #### subagent-driven-development（子代理驱动开发）
 这个技能为每个小任务启动一个独立的子代理。
 **优势**：
 - 每个子代理有独立的上下文
 - 任务失败不会影响其他任务
 - 可以并行执行多个任务
 #### using-git-worktrees（使用 Git Worktrees）
 这个技能使用 Git 的 worktree 功能创建隔离的开发环境。
 **好处**：
 - 多个功能可以并行开发
 - 每个 worktree 是独立的
 - 不会互相冲突
 ### 👀 代码审查类技能
 #### requesting-code-review（请求代码审查）
 当你完成代码后，这个技能会自动请求代码审查。
 ```
 完成功能后自动触发代码审查
 ```
 #### receiving-code-review（接收代码审查）
 这个技能定义了如何接收和处理审查反馈。
 **审查流程**：
 1. 提交代码
 2. 自动触发审查
 3. 审查者检查代码质量、安全性、测试覆盖率
 4. 提出改进建议
 5. 修复问题
 6. 重新审查直到批准
 ---
 ## Superpowers 完整工作流程
 Superpowers 的真正威力在于将多个技能组合成完整的开发流程。
 ### 标准开发流程
 ```
 1. Brainstorming（头脑风暴）
   ↓ 通过问答澄清真实需求
 2. Design Document（设计文档）
   ↓ 分块展示设计，等待确认
 3. Writing Plans（编写计划）
   ↓ 分解为 2-5 分钟的小任务
 4. Subagent Development（子代理开发）
   ↓ 每个任务启动独立子代理
   ↓ 两阶段审查：规格符合性 + 代码质量
 5. TDD（测试驱动开发）
   ↓ 强制 RED-GREEN-REFACTOR
 6. Code Review（代码审查）
   ↓ 质量把关
 7. 完成
 ```
 ### 实战案例：用 Superpowers 构建用户认证系统
 让我们通过一个完整的例子来体验 Superpowers 的工作流程。
 #### 第一步：Brainstorming 澄清需求
 ```
 我需要一个用户认证系统
 ```
 Claude 会问你：
 - Web 应用还是移动应用？
 - 支持哪些登录方式？
 - 需要密码重置吗？
 - 需要"记住我"功能吗？
 - ...
 #### 第二步：生成设计文档
 确认需求后，Claude 会生成设计文档：
 ```markdown
 # 用户认证系统设计
 ## 功能需求
 1. 用户注册（邮箱 + 密码）
 2. 用户登录
 3. 密码重置（邮件）
 4. 记住我（JWT + Refresh Token）
 ## 技术选型
 - 后端：Node.js + Express
 - 数据库：SQLite
 - 认证：JWT
 - 加密：bcrypt
 ## API 设计
 - POST /api/auth/register
 - POST /api/auth/login
 - POST /api/auth/refresh
 - POST /api/auth/reset-password
 ```
 #### 第三步：编写实现计划
 ```
 用 writing-plans 制定实现计划
 ```
 Claude 会生成详细的任务列表，每个任务 2-5 分钟可完成。
 #### 第四步：执行开发
 ```
 用 TDD 方式执行上面的计划
 ```
 Claude 会：
 1. 先写测试
 2. 确认测试失败（RED）
 3. 写实现代码
 4. 确认测试通过（GREEN）
 5. 重构代码（REFACTOR）
 #### 第五步：代码审查
 完成后自动触发代码审查，检查：
 - 代码质量
 - 安全性（SQL 注入、XSS 等）
 - 测试覆盖率
 - 文档完整性
 ---
 ## Superpowers vs 直接使用 Claude Code
 | 维度 | 直接使用 Claude Code | 使用 Superpowers |
 |------|---------------------|-----------------|
 | **需求澄清** | AI 直接开始写代码 | 苏格拉底式提问澄清需求 |
 | **开发流程** | 随 AI 自由发挥 | 强制 TDD 红绿重构 |
 | **任务管理** | 一次性完成 | 分解为小任务，带检查点 |
 | **代码质量** | 依赖 AI 判断 | 强制代码审查 |
 | **可预测性** | 结果不稳定 | 流程可重复 |
 | **适用场景** | 简单任务、原型验证 | 复杂项目、生产代码 |
 ### 形象比喻
 如果把 Claude Code 比作一个"聪明的实习生"：
 - **直接使用**：告诉实习生"做一个登录功能"，他直接开始写，可能做出你觉得不对的东西
 - **使用 Superpowers**：给实习生配备一位资深导师，导师会问清楚需求、制定计划、检查代码质量
 ---
 ## 安装与配置详解
 ### 方法一：通过 Marketplace（推荐）
 ```bash
 # 添加 marketplace
 /plugin marketplace add obra/superpowers-marketplace
 # 安装
 /plugin install superpowers@superpowers-marketplace
 # 验证安装
 /skills
 ```
 ### 方法二：手动克隆
 ```bash
 # 创建目录
 mkdir -p ~/.claude/skills
 # 克隆仓库
 git clone https://github.com/obra/superpowers.git ~/.claude/skills/superpowers
 ```
 ### 方法三：项目级别安装
 如果你想在特定项目中使用 Superpowers：
 ```bash
 # 在项目根目录
 mkdir -p .claude/skills
 # 克隆或复制 superpowers
 cp -r ~/.claude/skills/superpowers .claude/skills/
 ```
 这样团队成员可以共享相同的 Superpowers 配置。
 ---
 ## 常用技能速查表
 | 技能名称 | 功能 | 使用场景 |
 |---------|------|---------|
 | `brainstorming` | 苏格拉底式提问澄清需求 | 需求不明确时 |
 | `writing-plans` | 分解任务为小步骤 | 大项目开始前 |
 | `executing-plans` | 执行计划并检查点 | 按计划开发时 |
 | `test-driven-development` | TDD 红绿重构循环 | 所有功能开发 |
 | `systematic-debugging` | 四阶段根因分析 | 出现 bug 时 |
 | `verification-before-completion` | 完成前验证 | 任务结束时 |
 | `requesting-code-review` | 请求代码审查 | 提交代码前 |
 | `subagent-driven-development` | 子代理驱动开发 | 并行任务 |
 | `using-git-worktrees` | Git worktree 隔离 | 并行开发功能 |
 ---
 ## 最佳实践
 ### 1. 明确触发关键词
 Superpowers 的技能是通过关键词触发的，了解常用触发词：
 | 技能 | 触发关键词 |
 |------|-----------|
 | `test-driven-development` | "TDD"、"测试驱动"、"先写测试" |
 | `brainstorming` | 需求模糊时自动触发 |
 | `systematic-debugging` | "调试"、"bug"、"不工作" |
 | `writing-plans` | "制定计划"、"规划" |
 ### 2. 需要流程纪律时用 Superpowers
 - 生产级代码开发 → 提到 "TDD"
 - 需求不明确时 → 让 `brainstorming` 帮你澄清
 - 复杂项目 → 用 `writing-plans` 分解任务
 ### 3. 简单任务不必强求
 如果是快速原型或一次性脚本，不需要强制走完整流程。Superpowers 适合需要长期维护的代码。
 ### 4. 技能可以组合使用
 ```
 用 TDD 方式实现用户认证，完成后帮我做代码审查
 ```
 这会同时触发 `test-driven-development` 和 `code-review` 技能。
 ---
 ## 常见问题
 ### Q1：Superpowers 会让开发变慢吗？
 初期可能会感觉慢，因为：
 - 需要时间澄清需求
 - 要先写测试再写代码
 - 要经过代码审查
 但长期来看，由于减少了返工和 bug，整体效率更高。
 ### Q2：小项目也需要 Superpowers 吗？
 对于原型验证或非常简单的任务，可以直接使用 Claude Code。Superpowers 更适合：
 - 生产级项目
 - 多人协作项目
 - 需要长期维护的项目
 ### Q3：Superpowers 和 Skills 有什么区别？
 | 维度 | Superpowers | Skills |
 |------|-------------|--------|
 | **本质** | 完整的开发方法论框架 | 可复用的技能包 |
 | **范围** | 覆盖整个开发流程 | 聚焦特定功能 |
 | **关系** | Superpowers 内部使用 Skills | Superpowers 是 Skills 的集合 |
 ### Q4：可以自定义 Superpowers 技能吗？
 可以！Superpowers 是开源的，你可以：
 1. Fork 仓库
 2. 修改现有技能
 3. 添加新的技能
 4. 贡献回社区
 ---
 ## 参考资料
 ### 官方资源
 - [obra/superpowers GitHub](https://github.com/obra/superpowers) - 官方仓库（50,000+ ⭐）
 - [Superpowers 详细用法教程](https://www.cnblogs.com/gyc567/p/19510203) - 中文详细教程
 - [Superpowers 环境配置指南](https://m.blog.csdn.net/gitblog_00683/article/details/144768992) - 配置指南
 ### 社区资源
 | 仓库 | 说明 |
 |------|------|
 | [affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code) | 综合工具包，包含 TDD 工作流 |
 | [shanraisshan/claude-code-best-practice](https://github.com/shanraisshan/claude-code-best-practice) | 官方最佳实践 |
 ### 相关文章
 - [告别 Vibe Coding！用 Superpowers 让 Claude Code 写出工程级代码](https://juejin.cn/post/7593573617648123956)
 - [我如何用 Superpowers MCP 强制 Claude Code 在编码前进行规划](https://juejin.cn/post/7570341520551673871)
 - [Claude Code + Superpowers 保姆级入门教程](https://juejin.cn/post/7594832320030638123)
 ---
 ## 总结
 Superpowers 是一组**工程级开发技能集合**，让 Claude Code 从"聪明的实习生"变成"有纪律的开发团队"。
 ### 核心要点
 1. **Superpowers 是技能集合，不是魔法**
   - 安装后，技能在后台可用
   - 通过关键词或场景触发
   - 可以手动调用特定技能
 2. **记住关键触发词**
   - 想要 TDD → 说 "用 TDD 方式"
   - 需求模糊 → `brainstorming` 会主动提问
   - 出现 bug → 提到 "调试" 触发 `systematic-debugging`
 3. **适用场景**
   - ✅ 生产级代码开发
   - ✅ 需要长期维护的项目
   - ✅ 团队协作项目
   - ❌ 快速原型（可选）
   - ❌ 一次性脚本（可选）
 记住：**Superpowers 不让 AI 更聪明，而是让 AI 更有纪律。**
		`@@ -1,3 +0,0 @@`
			`# 高级一：MCP 与 Claude Code Skills`

			`> 本章节正在编写中，敬请期待...`
		`@@ -1,3 +0,0 @@`
			`# 高级二：如何让 Coding Tools 长时间工作`

			`> 本章节正在编写中，敬请期待...`