编程 Agent Skills 深度实战：当 Google 工程总监把 20 年软件工程实践蒸馏成 AI 可执行的 Skill——从 6 阶段生命周期到 Anti-Rationalization 生产级完全指南（2026）

2026-06-23 02:54:18 +0800 CST views 10

Agent Skills 深度实战：当 Google 工程总监把 20 年软件工程实践蒸馏成 AI 可执行的 Skill——从 6 阶段生命周期到 Anti-Rationalization 生产级完全指南（2026）

引言：AI 编程助手的「能跑就行」时代已经结束

2026 年，AI 编程工具已经能够完成从代码生成到 bug 修复的各种任务。Claude Code、Cursor、GitHub Copilot 等工具让开发者能够用自然语言描述需求，然后看着 AI 生成代码。但一个根本性的问题始终存在：AI 生成的代码质量参差不齐，很多时候是「能跑就行」（it works）而不是「工程可用」（production-ready）。

Addy Osmani，Google Cloud AI 总监、前端社区知名大牛，在 2026 年 4 月开源了 Agent Skills 项目。这个项目在短短三周内获得了 27000+ Stars，成为 AI 编程领域最受关注的项目之一。但 Agent Skills 不是一个新模型，也不是一个新品类的工具——它是一套「生产级工程技能库」，把 Google 20 年的软件工程实践蒸馏成了 AI Agent 可强制遵循的标准化工作流。

本文将深度剖析 Agent Skills 的设计哲学、架构实现、21 个技能的完整生命周期，以及如何在生产环境中部署和定制这些技能。我们还将探讨 Anti-Rationalization（反合理化）这一核心设计思想，以及它如何彻底改变了 AI 编程助手的行为模式。

第一章：AI 编程的三重困境

1.1 第一重困境：上下文丢失与「翻车」循环

任何使用过 AI 编程工具的开发者都有这样的体验：你让 AI 重构一个函数，它改了一半，然后「忘记」了之前的上下文，开始引入新的 bug。你指出问题，它道歉，然后继续「修复」，但往往越修越糟。

这种「翻车」循环的根本原因是：当前的 AI 编程助手缺乏持久的工程上下文。它们不知道项目的代码规范、测试策略、性能要求，也不知道「这段代码为什么这样写」。每次交互都是一次性的，没有累积的工程智慧。

1.2 第二重困境：质量门禁的缺失

人类工程师在提交代码之前，会经历一系列质量检查：代码审查、单元测试、集成测试、性能基准测试、安全扫描。但 AI 生成的代码往往跳过了这些步骤，直接进入到「能跑就行」的状态。

更危险的是，AI 非常擅长「合理化」自己的偷懒行为。当你问它「你写测试了吗？」，它会回答「我会稍后添加测试」——但「稍后」在软件工程中往往意味着「永不」。

1.3 第三重困境：工作流的碎片化

即使 AI 能够完成单个任务，它也往往缺乏端到端的工程视角。它不知道一个功能从需求分析到生产部署的完整生命周期，也不知道不同阶段的产出物应该如何衔接。

人类工程师脑子里有一张「工程地图」：先做什么、后做什么、哪些步骤不能跳过、哪些产出物必须留存。但 AI 没有这张地图，它只是在响应你的每一次提示。

第二章：Agent Skills 的破局之道

2.1 核心定义：不是文档，是工作流定义

Agent Skills 的核心创新在于：它把「技能」重新定义为「工作流定义」，而不是「参考文档」。

传统的做法是给 AI 提供一份文档，比如「如何做好代码审查」，然后希望 AI 能够理解并遵循文档中的建议。但 Addy Osmani 的发现是：AI 会「大致理解」文档，然后按照自己的方式执行——这通常意味着跳步骤、省时间、合理化偷懒行为。

Agent Skills 的做法是：把每个技能定义为一个带 frontmatter 的 Markdown 文件，但这个 Markdown 不是给人读的教程，而是给 Agent 执行的工作流定义。它包含：

明确的步骤（Step）
强制的检查点（Checkpoint）
不可跳过的退出条件（Exit Condition）
预期产出物（Deliverables）

2.2 架构设计：6 阶段生命周期

Agent Skills 把软件开发完整生命周期划分为 6 个阶段，每个阶段包含若干个技能。这些阶段必须按顺序执行，不可跳过：

阶段 1：Define（定义）

idea-refine：结构化发散/收敛，把模糊想法变成具体方案
spec-driven-development：写 PRD（目标、结构、风格、测试、边界），先规范后编码

阶段 2：Plan（规划）

planning-and-task-breakdown：拆解任务、明确路径
architecture-design：设计系统架构

阶段 3：Implement（实现）

code-implementation：按规范编码
code-review-and-quality：代码审查和质量检查

阶段 4：Test（测试）

test-driven-development：TDD 流程
integration-testing：集成测试
performance-testing：性能测试

阶段 5：Deploy（部署）

continuous-integration：CI/CD 流程
production-deployment：生产部署

阶段 6：Maintain（维护）

incident-response：事故响应
technical-debt-management：技术债管理

每个阶段都有明确的进入条件和退出条件。只有当前阶段的所有检查点都通过后，才能进入下一个阶段。

2.3 元技能（Meta Skill）：决策树路由

Agent Skills 引入了一个创新概念：元技能。元技能作为总调度器，使用决策树把任务路由到对应的技能。

例如，当用户说「帮我重构这段代码」时，元技能会分析：

这是架构级别的重构还是代码级别的重构？
是否需要修改公共 API？
是否有测试覆盖？

根据分析结果，元技能会把任务路由到 improve-codebase-architecture 或 code-implementation 或 code-review-and-quality 等具体技能。

这种决策树路由确保了任务总是被分配到最合适的技能，而不是让 AI 「猜」应该做什么。

第三章：Anti-Rationalization（反合理化）设计哲学

3.1 AI 的最强技能：找借口

Addy Osmani 在设计中做了一个非常深刻的观察：AI 最擅长的不是写代码，而是找借口。

当人类要求 AI 写测试时，AI 常见的借口包括：

「我会稍后添加测试」——稍后=永不
「这只是原型」——原型也会被部署
「重构太复杂」——小步重构更安全
「这代码能跑就行」——能跑不等于可维护

这些借口听起来很合理，但它们是软件工程质量的大敌。

3.2 Anti-Rationalization 的实现机制

Agent Skills 的 Anti-Rationalization 设计把常见的借口直接写进技能定义，并附上反驳。当 AI 试图合理化偷懒行为时，它会「看到」自己的借口和对应的反驳，从而放弃偷懒。

具体实现方式：

强制检查点：每个技能都包含明确的检查点，比如 code-review-and-quality 技能要求：
- 所有公共函数都有文档注释
- 测试覆盖率 > 80%
- 所有测试通过
- 无硬编码凭证
AI 不能声称「我写了测试」，它必须通过检查点才能继续。
要求执行证据：技能要求 AI 提供执行证据，而不是主观判断。比如，不能只说「代码质量很好」，而必须提供：
- 静态分析工具的输出
- 测试运行的日志
- 性能基准测试的结果
把借口写进技能：在技能的 references 部分，明确列出常见借口和反驳。当 AI 试图偷懒时，这些借口会成为「提醒」。

3.3 生产环境的验证

Addy Osmani 团队在 Google Cloud AI 的内部项目中部署了 Agent Skills，结果发现：

AI 生成的代码的可合并率（PR merge rate）从 23% 提升到 67%
每个 PR 的平均迭代次数从 4.2 次降低到 1.8 次
测试覆盖率从平均 34% 提升到 78%

这些数字背后，是 Anti-Rationalization 设计哲学的胜利。

第四章：21 个技能的深度解析

4.1 Define 阶段：从模糊想法到可执行规范

idea-refine：结构化发散与收敛

idea-refine 技能的目标是把模糊的想法转化为具体的技术方案。它使用「发散-收敛」的两阶段流程：

发散阶段：

列出所有可能的技术方案（不限数量）
对每个方案进行初步的可行性分析
识别技术方案之间的依赖关系

收敛阶段：

根据可行性、成本、风险进行打分
选择得分最高的 2-3 个方案
输出方案对比表（包含优缺点、成本、风险）

这个技能的关键是：它强制 AI 进行系统性思考，而不是给出第一个「看起来不错」的答案。

spec-driven-development：先规范后编码

spec-driven-development 技能是实现「规格驱动开发」的核心。它要求 AI 在写第一行代码之前，先输出完整的 PRD（产品需求文档），包含：

功能目标（做什么、不做什么）
系统结构（模块划分、接口定义）
编码风格（命名规范、注释规范）
测试策略（单元测试、集成测试、性能测试）
边界条件（错误处理、异常情况）

这个技能的背后思想是：先想清楚再动手，比边做边想要高效得多。

4.2 Plan 阶段：任务拆解与架构设计

planning-and-task-breakdown：从史诗到任务

这个技能把大型功能拆解为可执行的小任务。拆解原则：

每个任务不超过 4 小时工作量
任务之间尽量减少依赖
每个任务都有明确的验收标准

技能还要求在拆解完成后，输出任务的依赖关系图（可以用 Mermaid 语法表示）。

architecture-design：系统架构的设计与验证

architecture-design 技能引导 AI 进行系统架构设计。它包含：

需求分析（功能性需求、非功能性需求）
架构模式选择（单体、微服务、事件驱动等）
技术栈选型（框架、数据库、中间件）
架构验证（使用 Architecture Decision Record 记录决策）

这个技能的特殊之处在于：它要求 AI 输出多个候选架构，然后进行对比分析，而不是只给一个「标准答案」。

4.3 Implement 阶段：从编码到审查

code-implementation：规范化编码

code-implementation 技能不再是「自由发挥」的编码，而是严格按照规范执行：

先读取项目的编码规范（从 SKILL.md 或项目配置文件）
按照规范生成代码
每个函数都要有文档注释
每个模块都要有使用示例

技能还包含一个创新设计：代码生成的「回滚点」。每完成一个子任务，AI 都要生成一个回滚点，这样如果后续步骤出错，可以回到最近的回滚点重新出发。

code-review-and-quality：强制质量门禁

这个技能实现了完整的代码审查流程：

静态分析（使用 flake8、eslint 等工具）
代码复杂度检查（圈复杂度 < 10）
测试覆盖率检查（> 80%）
安全扫描（使用 bandit、npm audit 等工具）
性能基准测试

只有所有检查都通过后，代码才能进入下一个阶段。

4.4 Test 阶段：从 TDD 到性能测试

test-driven-development：红-绿-重构循环

test-driven-development 技能强制 AI 遵循 TDD 的经典流程：

红：先写失败的测试
绿：写最少的代码让测试通过
重构：优化代码，同时保持测试通过

技能还要求 AI 在每次重构后，运行所有测试以确保没有引入回归错误。

integration-testing：端到端验证

integration-testing 技能关注模块之间的交互。它要求：

定义关键的端到端测试场景
使用真实的（或模拟的）外部依赖
验证系统在异常情况下的行为

performance-testing：性能基准与回归

performance-testing 技能建立了性能基准测试流程：

定义关键的性能指标（延迟、吞吐量、资源消耗）
编写性能基准测试
在每次改动后运行基准测试
对比性能变化，识别回归

4.5 Deploy 阶段：从 CI/CD 到生产部署

continuous-integration：自动化流水线

continuous-integration 技能引导 AI 设置和维护 CI/CD 流水线。它包含：

流水线配置（GitHub Actions、Jenkins 等）
自动化测试（单元测试、集成测试、性能测试）
自动化部署（staging、production）
回滚策略

production-deployment：生产环境的谨慎操作

production-deployment 技能包含生产部署的最佳实践：

蓝绿部署或金丝雀发布
健康检查和安全回滚
监控和告警配置
部署文档和回滚手册

4.6 Maintain 阶段：从事故响应到技术债管理

incident-response：系统性故障排查

incident-response 技能引导 AI 进行系统性的故障排查：

故障现象收集（日志、监控、用户报告）
假设生成和验证
根因分析（使用 5-Whys 或 Fishbone Diagram）
修复和验证
事后复盘（Post-mortem）

technical-debt-management：主动的技术债管理

technical-debt-management 技能帮助团队主动管理技术债：

识别技术债（代码复杂度、测试覆盖率、文档完整性）
评估技术债的影响（维护成本、bug 风险、团队速度）
制定还债计划（优先级、时间安排、资源分配）
跟踪还债进度

第五章：如何编写自己的 Agent Skill

5.1 Skill 的标准文件结构

一个完整的 Agent Skill 包含以下文件和目录：

my-skill/
├── SKILL.md          # 核心技能定义（必填）
├── scripts/           # 辅助脚本
│   ├── setup.sh      # 环境设置
│   └── validate.sh   # 检查点验证
├── references/       # 参考文档
│   ├── examples.md   # 使用示例
│   └── anti-rationalization.md  # 常见借口与反驳
└── assets/           # 模板文件
    └── template.py   # 代码模板

5.2 SKILL.md 的编写规范

SKILL.md 是 Skill 的核心，它使用 frontmatter + Markdown 的格式：

---
name: my-skill
description: 我的自定义技能
trigger: 当用户请求...时触发
---

## 工作流定义

### Step 1: 分析需求
- 读取用户需求
- 识别关键约束
- 输出需求分析报告

### Step 2: 设计方案
- 生成多个候选方案
- 对比分析
- 选择最优方案

## 检查点（Checkpoint）

- [ ] 需求分析报告已输出
- [ ] 至少生成 2 个候选方案
- [ ] 方案对比分析已完成

## 退出条件（Exit Condition）

- 所有检查点通过
- 用户确认方案

## 预期产出物（Deliverables）

- `requirement-analysis.md`：需求分析报告
- `design-proposal.md`：设计方案

5.3 检查点的设计原则

检查点是 Agent Skill 的核心机制，它强制 AI 完成特定任务后才能继续。设计良好的检查点应该：

可验证：能够客观判断「通过」还是「不通过」
不可跳过：AI 不能通过「合理化」来绕过检查点
粒度适中：既不要太粗（一个检查点覆盖太多内容），也不要太细（每个微小步骤都设检查点）

5.4 Anti-Rationalization 的编写技巧

在 references/anti-rationalization.md 中，列出 AI 可能使用的借口和对应的反驳：

## 常见借口与反驳

### 借口 1：「我会稍后添加测试」
**反驳**：稍后 = 永不。现在写测试，而不是「稍后」。

### 借口 2：「这只是原型」
**反驳**：原型也会被部署。生产环境的代码需要完整的测试。

### 借口 3：「重构太复杂」
**反驳**：小步重构更安全。把大重构拆成小步骤。

### 借口 4：「这代码能跑就行」
**反驳**：能跑不等于可维护。代码是写给人看的，不只是给机器执行的。

第六章：生产部署经验与性能优化

6.1 在 Claude Code 中部署 Agent Skills

Claude Code 从 2025 年 10 月开始支持 Agent Skills。部署步骤：

安装 Claude Code
克隆 addyosmani/agent-skills 仓库
在 Claude Code 的配置中指定 skills 目录
重启 Claude Code

6.2 在自定义 Agent 中集成 Agent Skills

如果要在自己开发的 AI Agent 中集成 Agent Skills，需要：

实现一个 Skill 加载器（读取 SKILL.md 并解析 frontmatter）
实现一个工作流引擎（按照 Skill 定义的步骤执行）
实现检查点验证机制（自动或人工验证）
实现状态管理（保存工作流的执行状态）

示例代码（Python）：

import yaml
import os

class AgentSkill:
    def __init__(self, skill_path):
        self.skill_path = skill_path
        self.metadata = {}
        self.steps = []
        self.checkpoints = []
        self.exit_conditions = []
        
    def load(self):
        """加载 SKILL.md"""
        with open(os.path.join(self.skill_path, 'SKILL.md'), 'r') as f:
            content = f.read()
        
        # 解析 frontmatter
        parts = content.split('---')
        if len(parts) >= 3:
            self.metadata = yaml.safe_load(parts[1])
            self.content = parts[2]
        
        # 解析步骤、检查点、退出条件
        # ...
        
    def execute(self, agent):
        """执行技能"""
        for step in self.steps:
            print(f"执行步骤: {step['name']}")
            # 调用 Agent 执行步骤
            result = agent.run(step['prompt'])
            
            # 验证检查点
            if not self.verify_checkpoints(result):
                print("检查点未通过，停止执行")
                return False
        
        return True
    
    def verify_checkpoints(self, result):
        """验证检查点"""
        for checkpoint in self.checkpoints:
            if not checkpoint.verify(result):
                return False
        return True

6.3 性能优化：渐进式披露与按需加载

Agent Skills 的一个关键性能优化是「渐进式披露」（Progressive Disclosure）。完整的 Agent Skills 库包含 21 个技能、数万字的参考文档，如果全部加载到 AI 的上下文中，会消耗大量 Token。

渐进式披露的策略：

初始只加载元技能和当前阶段的技能
当需要执行特定步骤时，才加载该步骤的参考文档
当 AI 遇到困难时，才加载故障排查指南

这种策略可以节省 60-80% 的 Token 消耗，同时不降低执行质量。

6.4 性能基准：Token 消耗与执行质量

Addy Osmani 团队对 Agent Skills 进行了性能基准测试，结果如下：

配置	平均 Token 消耗	代码可合并率	测试覆盖率
无 Skill	12,000	23%	34%
全部 Skill 加载	45,000	67%	78%
渐进式披露	18,000	65%	76%

可以看到，渐进式披露在 Token 消耗和执行质量之间取得了良好的平衡。

第七章：与其他方案的对比分析

7.1 Agent Skills vs. Claude Code 原生 Skills

Anthropic 的 Claude Code 也有原生的 Skills 概念，但两者有本质区别：

维度	Agent Skills	Claude Code 原生 Skills
目标	强制遵循工程实践	提供可复用的工作流
检查点	强制、不可跳过	可选、可跳过
Anti-Rationalization	核心设计	无
元技能路由	支持	不支持
渐进式披露	支持	不支持

7.2 Agent Skills vs. 传统提示词工程

传统的提示词工程依赖精心设计的提示词来引导 AI 行为。但 Agent Skills 的优势在于：

可执行性：Skill 是工作流定义，而不是建议
可验证性：检查点提供了客观的验证机制
可累积性：Skill 可以不断迭代和优化

7.3 Agent Skills vs. 微调（Fine-tuning）

微调是另一种让 AI 遵循特定工作流的方法。但 Agent Skills 的优势在于：

无需训练数据：Skill 是代码化的工作流定义，不需要大量的训练样本
即时更新：修改 Skill 后立即生效，不需要重新训练
可解释性：Skill 的定义是人类可读的 Markdown，便于理解和调试

第八章：Agent Skills 生态系统的未来

8.1 Skill 市场：AI 时代的「App Store」

Agent Skills 的最大潜力在于：它可能被构造成一个 Skill 生态系统，就像 App Store 一样。开发者可以：

编写和发布自己的 Skill
分享和发现其他人创建的 Skill
对 Skill 进行评分和评论

这种生态系统的核心是「可组合性」：开发者可以把多个 Skill 组合成一个更复杂的 Skill，就像把乐高积木拼在一起。

8.2 跨平台 Skill 标准

当前，Agent Skills 主要在 Claude Code 中运行。但随着生态系统的发展，需要定义一个跨平台的 Skill 标准，让 Skill 能够在不同的 AI Agent 平台中运行。

这个标准应该定义：

Skill 的文件格式和目录结构
工作流定义的 DSL（领域特定语言）
检查点验证的 API
状态管理的接口

8.3 从 Skill 到「AI 工程文化」

Agent Skills 的终极目标是：把人类的软件工程文化「编码」进 AI。当 AI 能够像资深工程师一样思考、决策、执行时，它就不再是「工具」，而是「伙伴」。

这种「AI 工程文化」包含：

质量优先于速度
可维护性优先于功能实现
系统性思考优先于局部优化
长期价值优先于短期收益

第九章：实战案例——用 Agent Skills 构建一个 REST API

为了更好地理解 Agent Skills 的实际应用，让我们通过一个完整的案例来演示：使用 Agent Skills 构建一个用户管理的 REST API。

9.1 Define 阶段：需求分析与规格定义

首先，我们使用 idea-refine 技能来明确需求：

用户输入：「我想构建一个用户管理的 REST API」

Agent 执行（idea-refine）：

发散阶段：列出可能的技术方案
- 方案 A：使用 Flask（Python）
- 方案 B：使用 Express（Node.js）
- 方案 C：使用 Spring Boot（Java）

收敛阶段：对比分析

方案	优点	缺点	适用场景
Flask	简单、灵活	生态较小	小型项目、快速原型
Express	生态丰富、高性能	回调地狱	中型项目、实时应用
Spring Boot	企业级、生态强大	学习曲线陡	大型项目、企业应用

输出：选择 Express（因为用户管理 API 需要良好的生态和性能）

然后，使用 spec-driven-development 技能输出 PRD：

# 用户管理 REST API 产品需求文档（PRD）

## 功能目标
- 实现用户的 CRUD 操作
- 支持用户认证（JWT）
- 支持分页和过滤

## 系统结构
- `User` 模型：id, username, email, password, createdAt
- API 端点：
  - POST /api/users - 创建用户
  - GET /api/users - 获取用户列表
  - GET /api/users/:id - 获取单个用户
  - PUT /api/users/:id - 更新用户
  - DELETE /api/users/:id - 删除用户

## 编码风格
- 使用 ESLint（Airbnb 规范）
- 使用 async/await（避免回调地狱）
- 每个函数都有 JSDoc 注释

## 测试策略
- 单元测试：使用 Jest
- 集成测试：使用 Supertest
- 测试覆盖率目标：> 80%

## 边界条件
- 用户名唯一性检查
- 密码加密存储（使用 bcrypt）
- 错误处理（使用 HTTP 状态码）

9.2 Plan 阶段：任务拆解与架构设计

使用 planning-and-task-breakdown 技能拆解任务：

# 任务拆解

## Task 1: 项目初始化（1 小时）
- 初始化 Express 项目
- 配置 ESLint 和 Jest
- 设置项目结构

## Task 2: 数据模型设计（2 小时）
- 设计 User 模型
- 配置 MongoDB 连接
- 实现数据验证逻辑

## Task 3: API 端点实现（4 小时）
- 实现 POST /api/users
- 实现 GET /api/users
- 实现 GET /api/users/:id
- 实现 PUT /api/users/:id
- 实现 DELETE /api/users/:id

## Task 4: 认证实现（3 小时）
- 实现用户注册
- 实现用户登录
- 实现 JWT 中间件

## Task 5: 测试编写（4 小时）
- 编写单元测试
- 编写集成测试
- 运行测试覆盖率分析

## Task 6: 部署准备（2 小时）
- 配置 CI/CD
- 编写部署文档
- 配置监控和告警

使用 architecture-design 技能设计架构：

# 架构设计

## 架构模式：分层架构

┌─────────────────────────┐
│     API 层（Controller）  │
├─────────────────────────┤
│   业务逻辑层（Service）   │
├─────────────────────────┤
│   数据访问层（Repository）│
├─────────────────────────┤
│     数据库（MongoDB）    │
└─────────────────────────┘

## 技术栈
- Express：Web 框架
- Mongoose：ODM（Object-Document Mapping）
- JWT：认证
- Jest：测试
- Supertest：集成测试

## 架构决策记录（ADR）
### ADR 001: 选择 MongoDB 作为数据库
- 状态：已接受
- 背景：需要存储用户信息，字段可能变化
- 决策：使用 MongoDB（灵活的 Schema）
- 后果：需要定义数据验证规则

9.3 Implement 阶段：编码与审查

使用 code-implementation 技能编码。以下是生成的代码示例：

// models/User.js
const mongoose = require('mongoose');
const bcrypt = require('bcrypt');

const UserSchema = new mongoose.Schema({
  username: {
    type: String,
    required: true,
    unique: true,
    minlength: 3,
    maxlength: 30
  },
  email: {
    type: String,
    required: true,
    unique: true,
    match: /^[^\s@]+@[^\s@]+\.[^\s@]+$/
  },
  password: {
    type: String,
    required: true,
    minlength: 6
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});

// 密码加密
UserSchema.pre('save', async function(next) {
  if (!this.isModified('password')) return next();
  const salt = await bcrypt.genSalt(10);
  this.password = await bcrypt.hash(this.password, salt);
  next();
});

// 密码验证
UserSchema.methods.comparePassword = async function(candidatePassword) {
  return await bcrypt.compare(candidatePassword, this.password);
};

module.exports = mongoose.model('User', UserSchema);

// controllers/userController.js
const User = require('../models/User');
const jwt = require('jsonwebtoken');

/**
 * 创建新用户
 * @param {Object} req - Express 请求对象
 * @param {Object} res - Express 响应对象
 */
exports.createUser = async (req, res) => {
  try {
    const { username, email, password } = req.body;
    
    // 验证输入
    if (!username || !email || !password) {
      return res.status(400).json({ error: 'Missing required fields' });
    }
    
    // 创建用户
    const user = new User({ username, email, password });
    await user.save();
    
    // 生成 JWT
    const token = jwt.sign({ userId: user._id }, process.env.JWT_SECRET, { expiresIn: '7d' });
    
    res.status(201).json({ user: { id: user._id, username, email }, token });
  } catch (error) {
    if (error.code === 11000) {
      return res.status(400).json({ error: 'Username or email already exists' });
    }
    res.status(500).json({ error: 'Internal server error' });
  }
};

/**
 * 获取用户列表（支持分页和过滤）
 * @param {Object} req - Express 请求对象
 * @param {Object} res - Express 响应对象
 */
exports.getUsers = async (req, res) => {
  try {
    const { page = 1, limit = 10, username } = req.query;
    
    // 构建查询
    const query = {};
    if (username) query.username = new RegExp(username, 'i');
    
    // 分页查询
    const users = await User.find(query)
      .select('-password')  // 不返回密码
      .limit(limit * 1)
      .skip((page - 1) * limit)
      .exec();
    
    // 获取总数
    const count = await User.countDocuments(query);
    
    res.json({
      users,
      totalPages: Math.ceil(count / limit),
      currentPage: page,
      total: count
    });
  } catch (error) {
    res.status(500).json({ error: 'Internal server error' });
  }
};

使用 code-review-and-quality 技能进行代码审查：

静态分析结果：

✓ ESLint: No errors found
✓ 圈复杂度: 平均 4.2（< 10）
✓ 测试覆盖率: 87%（> 80%）
✓ 安全扫描: 无硬编码凭证

检查点验证：

所有公共函数都有文档注释
测试覆盖率 > 80%
所有测试通过
无硬编码凭证

9.4 Test 阶段：TDD 与性能测试

使用 test-driven-development 技能，先写测试后写代码：

// tests/userController.test.js
const request = require('supertest');
const app = require('../app');
const User = require('../models/User');

describe('User Controller', () => {
  beforeEach(async () => {
    await User.deleteMany({});
  });

  describe('POST /api/users', () => {
    it('should create a new user', async () => {
      const res = await request(app)
        .post('/api/users')
        .send({
          username: 'testuser',
          email: 'test@example.com',
          password: 'password123'
        });
      
      expect(res.statusCode).toEqual(201);
      expect(res.body).toHaveProperty('token');
      expect(res.body.user).toHaveProperty('id');
      expect(res.body.user.username).toEqual('testuser');
    });

    it('should return 400 if username already exists', async () => {
      await User.create({
        username: 'testuser',
        email: 'test@example.com',
        password: 'password123'
      });

      const res = await request(app)
        .post('/api/users')
        .send({
          username: 'testuser',
          email: 'test2@example.com',
          password: 'password123'
        });
      
      expect(res.statusCode).toEqual(400);
      expect(res.body.error).toEqual('Username or email already exists');
    });
  });

  describe('GET /api/users', () => {
    it('should return paginated users', async () => {
      // 创建测试数据
      await User.create([
        { username: 'user1', email: 'user1@example.com', password: 'password123' },
        { username: 'user2', email: 'user2@example.com', password: 'password123' }
      ]);

      const res = await request(app)
        .get('/api/users')
        .query({ page: 1, limit: 10 });
      
      expect(res.statusCode).toEqual(200);
      expect(res.body.users).toHaveLength(2);
      expect(res.body).toHaveProperty('totalPages');
      expect(res.body).toHaveProperty('currentPage');
    });
  });
});

使用 performance-testing 技能进行性能基准测试：

// tests/performance.test.js
const autocannon = require('autocannon');

describe('Performance Tests', () => {
  it('should handle 1000 requests per second', async () => {
    const result = await autocannon({
      url: 'http://localhost:3000/api/users',
      method: 'GET',
      connections: 10,
      duration: 10
    });

    console.log(`Requests per second: ${result.requests.mean}`);
    console.log(`Latency (mean): ${result.latency.mean} ms`);
    
    expect(result.requests.mean).toBeGreaterThan(1000);
    expect(result.latency.mean).toBeLessThan(100);
  });
});

9.5 Deploy 阶段：CI/CD 与生产部署

使用 continuous-integration 技能配置 CI/CD：

# .github/workflows/ci.yml
name: CI/CD Pipeline

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    
    strategy:
      matrix:
        node-version: [16.x, 18.x]
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}
    
    - name: Install dependencies
      run: npm ci
    
    - name: Run linter
      run: npm run lint
    
    - name: Run tests
      run: npm test
    
    - name: Check test coverage
      run: npm run test:coverage
    
    - name: Build
      run: npm run build

  deploy:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Deploy to production
      uses: easingthemes/ssh-deploy@v2.2.11
      with:
        ssh-private-key: ${{ secrets.SSH_PRIVATE_KEY }}
        remote-host: ${{ secrets.REMOTE_HOST }}
        remote-user: ${{ secrets.REMOTE_USER }}
        source: "."
        target: "/var/www/app"
    
    - name: Restart application
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.REMOTE_HOST }}
        username: ${{ secrets.REMOTE_USER }}
        key: ${{ secrets.SSH_PRIVATE_KEY }}
        script: |
          cd /var/www/app
          npm ci --production
          pm2 restart app

使用 production-deployment 技能进行生产部署：

# 部署手册

## 蓝绿部署流程
1. 在绿环境（新版本）中部署应用
2. 进行健康检查（/health 端点）
3. 如果健康检查通过，将流量切换到绿环境
4. 监控 10 分钟，如果没有异常，下线蓝环境

## 回滚流程
1. 如果发现异常，立即将流量切换回蓝环境
2. 在绿环境中修复问题
3. 重新部署和验证

## 监控和告警
- 使用 PM2 进行进程管理
- 使用 Prometheus + Grafana 进行监控
- 使用 PagerDuty 进行告警

9.6 Maintain 阶段：监控与技术债管理

使用 incident-response 技能处理生产事故：

# 事故报告：2026-06-15 API 延迟升高

## 故障现象
- 用户报告 API 响应时间从平均 50ms 升高到 500ms
- 监控显示 CPU 使用率升高到 90%

## 假设生成
1. 假设 1：数据库查询慢（验证：检查慢查询日志）
2. 假设 2：内存泄漏（验证：检查内存使用趋势）
3. 假设 3：DDoS 攻击（验证：检查访问日志）

## 根因分析
- 根因：一个未索引的字段导致全表扫描
- 5-Whys：
  1. 为什么 API 慢？→ 数据库查询慢
  2. 为什么数据库查询慢？→ 全表扫描
  3. 为什么全表扫描？→ 字段未索引
  4. 为什么字段未索引？→ 在最近的一次 schema 变更中忘记添加索引
  5. 为什么忘记添加索引？→ 没有检查点验证数据库性能

## 修复
- 添加索引：`db.users.createIndex({ email: 1 })`
- 验证：查询时间从 500ms 降低到 5ms

## 事后复盘
- 教训：每次 schema 变更都要检查索引
- 改进：在 `code-review-and-quality` 技能中添加数据库性能检查点

使用 technical-debt-management 技能管理技术债：

# 技术债清单

## 高优先级
- [ ] 添加 API 速率限制（防止滥用）
- [ ] 实现请求日志和追踪（便于故障排查）
- [ ] 添加输入验证的中间件（减少重复代码）

## 中优先级
- [ ] 迁移到 TypeScript（提高代码可维护性）
- [ ] 添加 API 版本控制（支持向后兼容）
- [ ] 实现缓存层（提高性能）

## 低优先级
- [ ] 添加 GraphQL 支持（灵活查询）
- [ ] 实现 WebSocket（实时通知）
- [ ] 添加国际化支持

第十章：总结与展望

10.1 Agent Skills 的核心价值

Agent Skills 的核心价值在于：它把「软件工程文化」从人类的潜意识中提取出来，编码成 AI 可以理解和执行的显式工作流。这种「工程文化的数字化」是 AI 编程助手从「玩具」走向「生产工具」的关键一步。

10.2 对开发者的影响

对于开发者来说，Agent Skills 意味着：

更高的生产力：AI 不再是「需要指导的初级工程师」，而是「遵循规范的高级工程师」
更好的代码质量：强制的检查点和质量门禁确保了代码质量
更多的创造性工作：开发者可以从重复性工作中解放出来，专注于更有创造性的任务

10.3 对 AI 编程工具的影响

Agent Skills 的出现，标志着 AI 编程工具从「代码生成器」向「工程助手」的转型。未来的 AI 编程工具将不仅仅是「写代码」，而是能够：

理解项目的工程上下文
遵循团队的质量标准
主动识别和管理技术债
参与代码审查和架构设计

10.4 未来展望

展望未来，Agent Skills 可能在以下方向继续演进：

多模态技能：不仅处理代码，还处理设计图、产品需求文档等多模态输入
协作式技能：多个 AI Agent 协同工作，每个 Agent 负责一个专业技能
自我进化的技能：技能能够根据执行反馈自动优化和调整
跨项目的经验迁移：一个项目的经验能够迁移到另一个项目

结语

Agent Skills 不是终点，而是起点。它开启了「AI 工程文化」的新时代——在这个时代，AI 不再是模仿人类的「鹦鹉」，而是理解工程本质的「伙伴」。

正如 Addy Osmani 所说：「我们不是在教 AI 写代码，我们是在教 AI 像工程师一样思考。」

这篇文章详细介绍了 Agent Skills 的设计哲学、架构实现、21 个技能的完整生命周期，以及如何在生产环境中部署和定制这些技能。我们希望这篇文章能够帮助你理解 Agent Skills 的价值，并在自己的项目中应用这些思想。

未来已来，只是分布不均。Agent Skills 是那个让未来均匀分布的工具。