+
+信任该文件夹后，你就可以使用 GitHub 账号登录。
+
+```
+> /login
+```
+
+**接下来会发生什么：**
+
+1. Copilot CLI 会显示一个一次性验证码（例如 `ABCD-1234`）
+2. 浏览器会打开 GitHub 的设备授权页面。如果你还没有登录 GitHub，请先登录。
+3. 在提示时输入该验证码
+4. 选择 “Authorize”，授予 GitHub Copilot CLI 访问权限
+5. 回到终端——现在你已经登录成功！
+
+
+
+*设备授权流程：终端生成验证码，你在浏览器中完成验证，随后 Copilot CLI 完成身份验证。*
+
+**提示**：登录状态会在不同会话之间保留。除非 token 过期或你主动退出登录，否则通常只需操作一次。
+
+---
+
+## 验证是否可用
+
+### 第 1 步：测试 Copilot CLI
+
+现在你已经登录，让我们确认 Copilot CLI 可以正常工作。如果 CLI 还没有启动，请先在终端中启动它：
+
+```bash
+> 打个招呼，并告诉我你能帮我做什么
+```
+
+收到回复后，你可以退出 CLI：
+
+```bash
+> /exit
+```
+
+---
+
+
+
+现在就开始，亲眼看看 Copilot CLI 能做什么。
+
+---
+
+## 先熟悉一下：你的第一批提示词
+
+在进入那些令人惊艳的演示之前，我们先从一些你现在就能试的简单提示开始。**不需要代码仓库**！只要打开终端并启动 Copilot CLI：
+
+```bash
+copilot
+```
+
+可以先试试这些适合初学者的提示词：
+
+```
+> 用简单的话解释一下 Python 中的 dataclass 是什么
+
+> 写一个函数，按指定键对字典列表进行排序
+
+> Python 中 list 和 tuple 有什么区别？
+
+> 给我 5 条编写整洁 Python 代码的最佳实践
+```
+
+不用 Python？也没关系！直接问你所用语言的问题即可。
+
+留意一下这种体验有多自然。你只需要像和同事交流一样提问。探索完成后，输入 `/exit` 即可离开当前会话。
+
+**核心认识**：GitHub Copilot CLI 是对话式的。你一开始并不需要掌握什么特殊语法，直接用自然语言提问就可以。
+
+## 实际看看效果
+
+现在，我们来看看为什么开发者会把它称作“随叫随到的资深工程师”。
+
+> 📖 **如何阅读这些示例**：以 `>` 开头的行，是你在交互式 Copilot CLI 会话中输入的提示。没有 `>` 前缀的行，则是你在终端中运行的 shell 命令。
+
+> 💡 **关于示例输出**：本课程中的示例输出仅用于说明。由于 Copilot CLI 每次的回复都可能不同，你看到的结果在措辞、格式和细节上都会有所差异。请关注返回信息的*类型*，而不是逐字逐句是否一致。
+
+### 演示 1：几秒钟完成代码审查
+
+课程中包含一些带有刻意设置代码质量问题的示例文件。我们先来审查其中一个：
+
+```bash
+# 如果你是在本地操作且还没有克隆课程仓库，请先执行
+git clone https://github.com/github/copilot-cli-for-beginners
+cd copilot-cli-for-beginners
+
+# 启动 Copilot
+copilot
+```
+
+进入交互式会话后：
+
+```
+> 审查 @samples/book-app-project/book_app.py 中的代码质量问题，并提出改进建议
+```
+
+> 💡 **`@` 是什么？** `@` 符号告诉 Copilot CLI 去读取某个文件。你会在第 02 章系统学习这个功能。现在先按示例原样复制命令即可。
+
+---
+
+
+
+你刚刚已经看到了 Copilot CLI 能做什么。接下来，我们来理解*怎样*高效地使用这些能力。关键在于：知道面对不同场景时，应该使用三种交互模式中的哪一种。
+
+> 💡 **注意**：Copilot CLI 还有一种 **Autopilot** 模式，它会在不等待你输入的情况下持续推进任务。这个模式很强大，但需要授予完整权限，而且会自主消耗 premium requests。本课程先聚焦下面三种模式。等你熟悉基础之后，我们再带你了解 Autopilot。
+
+---
+
+## 🧩 现实类比：外出就餐
+
+你可以把使用 GitHub Copilot CLI 想象成外出吃饭。从规划路线到下单，不同场景适合不同方式：
+
+| 模式 | 就餐类比 | 适用场景 |
+|------|----------|----------|
+| **Plan** | 去餐厅前先看导航路线 | 复杂任务 —— 先规划路线、查看中途步骤、确认方案，再开始执行 |
+| **Interactive** | 和服务员交流 | 需要探索和迭代 —— 提问、定制、实时获得反馈 |
+| **Programmatic** | 走得来速点餐 | 快速、明确的任务 —— 留在当前环境中，快速得到结果 |
+
+就像外出吃饭一样，你会自然地逐步体会出每种方式适合什么场景。
+
+
+
+*根据任务来选择模式：Plan 适合先规划，Interactive 适合来回协作，Programmatic 适合快速一次性得到结果。*
+
+### 我应该先从哪种模式开始？
+
+**先从 Interactive 模式开始。**
+- 你可以边试边问后续问题
+- 上下文会随着对话自然累积
+- 出错了也很容易通过 `/clear` 纠正
+
+熟悉之后，可以继续尝试：
+- **Programmatic 模式**（`copilot -p "
+
+**最适合**：探索、迭代、多轮对话。就像和一位服务员交流，他可以回答问题、接收反馈，并根据情况随时调整。
+
+启动一个交互式会话：
+
+```bash
+copilot
+```
+
+正如你前面已经看到的，启动后会出现一个提示符，你可以自然地输入内容。要查看可用命令的帮助，只需输入：
+
+```
+> /help
+```
+
+**核心认识**：Interactive 模式会保持上下文。每一条消息都会建立在之前内容之上，就像真实对话一样。
+
+#### Interactive 模式示例
+
+```bash
+copilot
+
+> 审查 @samples/book-app-project/utils.py 并提出改进建议
+
+> 给所有函数添加类型提示
+
+> 让错误处理更健壮一些
+
+> /exit
+```
+
+注意，每一个提示都会建立在上一个回答之上。你是在进行对话，而不是每次都从头开始。
+
+---
+
+### 模式 2：Plan 模式
+
+
+
+**最适合**：你想在执行之前先审查方案的复杂任务。可以把它理解为出行前先用导航规划路线。
+
+Plan 模式会帮助你在编写任何代码之前，先创建一个分步实施计划。你可以使用 `/plan` 命令，或者按 **Shift+Tab** 切换到 Plan 模式：
+
+> 💡 **提示**：**Shift+Tab** 可以在不同模式之间循环切换：Interactive → Plan → Autopilot。你可以在交互式会话中随时按下它，无需输入命令就能切换模式。
+
+```bash
+copilot
+
+> /plan 为图书应用添加一个“mark as read”命令
+```
+
+**Plan 模式输出示例：**（你的输出可能不同）
+
+```
+📋 实施计划
+
+步骤 1：更新 book_app.py 中的命令处理逻辑
+ - 为 "mark" 命令新增 elif 分支
+ - 创建 handle_mark_as_read() 函数
+
+步骤 2：实现处理函数
+ - 提示用户输入图书标题
+ - 调用 collection.mark_as_read(title)
+ - 显示成功/失败消息
+
+步骤 3：更新帮助文本
+ - 在可用命令列表中加入 "mark"
+ - 记录该命令的用法
+
+步骤 4：测试整个流程
+ - 添加一本书
+ - 将它标记为已读
+ - 在列表输出中确认状态已经变化
+
+是否继续实现？[Y/n]
+```
+
+**核心认识**：Plan 模式允许你在真正写代码前先审查并修改方案。计划完成后，你甚至可以让 Copilot CLI 把计划保存到文件中，供后续参考。例如，你可以说“把这个计划保存到 `mark_as_read_plan.md`”，它就会创建一个包含计划细节的 markdown 文件。
+
+> 💡 **想试更复杂一些的内容？** 可以输入：`/plan 为图书应用添加搜索和筛选功能`。Plan 模式既适合简单功能，也能扩展到完整应用级别的任务。
+
+> 📚 **Autopilot 模式**：你可能已经注意到，Shift+Tab 会切换到第三种模式 **Autopilot**。在 autopilot 模式下，Copilot 会沿着完整计划一路执行，不会在每一步都等待你的输入——就像把任务交给同事，然后说“做完告诉我一声”。典型流程通常是 plan → accept → autopilot，所以前提是你要先学会写好计划。先熟悉 Interactive 和 Plan 模式，等准备好了，再查看[官方文档](https://docs.github.com/copilot/concepts/agents/copilot-cli/autopilot)。
+
+---
+
+### 模式 3：Programmatic 模式
+
+
+
+**最适合**：自动化、脚本、CI/CD、一次性命令。就像走得来速点餐，不需要和服务员来回交流，也能快速拿到结果。
+
+对于不需要交互的一次性命令，可以使用 `-p` 参数：
+
+```bash
+# 生成代码
+copilot -p "写一个函数，用来判断一个数字是偶数还是奇数"
+
+# 获取快速帮助
+copilot -p "如何在 Python 中读取 JSON 文件？"
+```
+
+**核心认识**：Programmatic 模式会快速给出答案然后退出。没有持续对话，只有输入 → 输出。
+
+
+
+
+---
+
+## 常用斜杠命令
+
+这些命令在交互模式下可用。**一开始先掌握下面这几条就够了**——它们已经覆盖了日常 90% 的使用场景：
+
+| 命令 | 作用 | 何时使用 |
+|------|------|----------|
+| `/help` | 显示所有可用命令 | 忘记命令时 |
+| `/clear` | 清空对话并重新开始 | 切换话题时 |
+| `/plan` | 编码前先规划工作 | 处理更复杂功能时 |
+| `/research` | 使用 GitHub 和 Web 来源做深入研究 | 在编码前需要调研某个主题时 |
+| `/model` | 显示或切换 AI 模型 | 想更换 AI 模型时 |
+| `/exit` | 结束当前会话 | 完成后退出时 |
+
+作为入门，这些就足够了！等你逐渐熟练后，再去探索更多命令也不迟。
+
+> 📚 **官方文档**：[CLI 命令参考](https://docs.github.com/copilot/reference/cli-command-reference) 提供了完整的命令和参数列表。
+
+📚 进一步学习：在脚本中使用 Programmatic 模式（点击展开）
+ +熟悉之后，你可以在 shell 脚本中使用 `-p`： + +```bash +#!/bin/bash + +# 自动生成提交信息 +COMMIT_MSG=$(copilot -p "为以下变更生成一条提交信息： $(git diff --staged)") +git commit -m "$COMMIT_MSG" + +# 审查文件 +copilot --allow-all -p "审查 @myfile.py 中的问题" +``` +> ⚠️ **关于 `--allow-all`**：这个参数会跳过所有权限提示，让 Copilot CLI 无需再次确认就能读取文件、运行命令和访问 URL。由于程序化模式（`-p`）没有交互式会话来逐项批准操作，因此通常需要它。请只在你自己编写的提示词、且位于你信任的目录中使用 `--allow-all`。不要在不可信输入或敏感目录中使用它。 + +
+` | 将某个目录加入允许列表 |
+| `/list-dirs` | 显示所有允许的目录 |
+| `/cwd`, `/cd [directory]` | 查看或更改当前工作目录 |
+
+> ⚠️ **请谨慎使用**：`/allow-all` 会跳过确认提示。对于可信项目很方便，但面对不可信代码时一定要小心。
+
+### 会话
+
+| 命令 | 作用 |
+|------|------|
+| `/resume` | 切换到其他会话（可选指定会话 ID） |
+| `/rename` | 重命名当前会话 |
+| `/context` | 显示上下文窗口 token 使用情况和可视化信息 |
+| `/usage` | 显示会话使用指标和统计信息 |
+| `/session` | 显示会话信息和工作区摘要 |
+| `/compact` | 汇总当前对话以减少上下文使用 |
+| `/share` | 将会话导出为 markdown 文件或 GitHub gist |
+
+### 帮助与反馈
+
+| 命令 | 作用 |
+|------|------|
+| `/help` | 显示所有可用命令 |
+| `/changelog` | 显示 CLI 版本的更新日志 |
+| `/feedback` | 向 GitHub 提交反馈 |
+| `/theme` | 查看或设置终端主题 |
+
+### 快速 shell 命令
+
+在命令前加 `!`，即可直接运行 shell 命令，而不经过 AI：
+
+```bash
+copilot
+
+> !git status
+# 直接运行 git status，绕过 AI
+
+> !python -m pytest tests/
+# 直接运行 pytest
+```
+
+### 切换模型
+
+Copilot CLI 支持来自 OpenAI、Anthropic、Google 等提供方的多种 AI 模型。你能使用哪些模型，取决于你的订阅级别和所在地区。使用 `/model` 查看可用选项并进行切换：
+
+```bash
+copilot
+> /model
+
+# 显示可用模型，并让你进行选择。请选择 Sonnet 4.5。
+```
+
+> 💡 **提示**：有些模型会消耗更多 “premium requests”。标记为 **1x** 的模型（例如 Claude Sonnet 4.5）通常是很好的默认选择：能力强，同时也更高效。倍率更高的模型会更快消耗你的 premium request 配额，因此请留到真正需要时再使用。
+
+
+
+---
+
+# 练习
+
+📚 更多命令（点击展开）
+ +> 💡 上面的几条命令已经能覆盖你日常的大部分使用场景。这里提供这份参考，是为了等你准备好后继续深入探索。 + +### 智能体环境 + +| 命令 | 作用 | +|------|------| +| `/init` | 为你的仓库初始化 Copilot 指令 | +| `/agent` | 浏览并选择可用智能体 | +| `/skills` | 管理技能以增强能力 | +| `/mcp` | 管理 MCP 服务器配置 | + +> 💡 技能会在[第 05 章](../05-skills/README.zh.md)详细介绍。MCP 服务器会在[第 06 章](../06-mcp-servers/README.zh.md)详细介绍。 + +### 模型与子智能体 + +| 命令 | 作用 | +|------|------| +| `/model` | 显示或切换 AI 模型 | +| `/delegate` | 将任务交给 GitHub 上的 Copilot 编码智能体（云端智能体） | +| `/fleet` | 将复杂任务拆分为并行子任务，以更快完成 | +| `/tasks` | 查看后台子智能体和分离的 shell 会话 | + +### 代码 + +| 命令 | 作用 | +|------|------| +| `/diff` | 查看当前目录中的改动 | +| `/review` | 运行代码审查智能体来分析改动 | +| `/research` | 使用 GitHub 和 Web 来源执行深度调研 | +| `/terminal-setup` | 启用多行输入支持（shift+enter 和 ctrl+enter） | + +### 权限 + +| 命令 | 作用 | +|------|------| +| `/allow-all` | 为当前会话自动批准所有权限提示 | +| `/add-dir
+
+现在，轮到你把学到的内容用起来了。
+
+---
+
+## ▶️ 亲自试试
+
+### 交互式探索
+
+启动 Copilot，并通过连续提示词迭代式地改进图书应用：
+
+```bash
+copilot
+
+> 审查 @samples/book-app-project/book_app.py —— 哪些地方可以改进？
+
+> 把 if/elif 链重构成更易维护的结构
+
+> 给所有处理函数添加类型提示
+
+> /exit
+```
+
+### 规划一个功能
+
+使用 `/plan`，让 Copilot CLI 在真正编写代码前先给出实现方案：
+
+```bash
+copilot
+
+> /plan 为图书应用添加一个搜索功能，可以按标题或作者查找图书
+
+# 审查计划
+# 批准或修改
+# 观察它一步步实现
+```
+
+### 用 Programmatic 模式做自动化
+
+`-p` 参数允许你直接在终端中运行 Copilot CLI，而不进入交互模式。请在仓库根目录、终端中（不是在 Copilot 内部）复制并粘贴下面的脚本，用来审查图书应用中的所有 Python 文件。
+
+```bash
+# 审查图书应用中的所有 Python 文件
+for file in samples/book-app-project/*.py; do
+ echo "正在审查 $file..."
+ copilot --allow-all -p "对 @$file 做一次快速代码质量审查——只关注关键问题"
+done
+```
+
+**PowerShell（Windows）：**
+
+```powershell
+# 审查图书应用中的所有 Python 文件
+Get-ChildItem samples/book-app-project/*.py | ForEach-Object {
+ $relativePath = "samples/book-app-project/$($_.Name)";
+ Write-Host "正在审查 $relativePath...";
+ copilot --allow-all -p "对 @$relativePath 做一次快速代码质量审查——只关注关键问题"
+}
+```
+
+---
+
+完成这些演示后，再试试下面这些变化版练习：
+
+1. **Interactive 挑战**：启动 `copilot`，探索图书应用。询问 `@samples/book-app-project/books.py` 的作用，并连续 3 次要求它提出改进建议。
+
+2. **Plan 模式挑战**：运行 `/plan 为图书应用添加评分和书评功能`。仔细阅读计划。它是否合理？
+
+3. **Programmatic 挑战**：运行 `copilot --allow-all -p "列出 @samples/book-app-project/book_app.py 中的所有函数，并说明每个函数的作用"`。它第一次就成功了吗？
+
+---
+
+## 📝 作业
+
+### 主挑战：改进图书应用中的工具函数
+
+前面的动手示例主要聚焦于审查和重构 `book_app.py`。现在，请把同样的技能应用到另一个文件 `utils.py` 上：
+
+1. 启动一个交互式会话：`copilot`
+2. 让 Copilot CLI 总结这个文件：`@samples/book-app-project/utils.py 这个文件中的每个函数分别是做什么的？`
+3. 要求它添加输入校验：“为 `get_user_choice()` 添加校验，使其能够处理空输入和非数字输入”
+4. 要求它改进错误处理：“如果 `get_book_details()` 收到空字符串标题会怎样？请为这种情况添加保护逻辑。”
+5. 要求它添加文档字符串：“为 `get_book_details()` 添加完整的文档字符串，包含参数说明和返回值说明”
+6. 观察上下文如何在多轮提示之间传递。每一步改进都会建立在前一步之上
+7. 使用 `/exit` 退出
+
+**成功标准**：你应该得到一个改进后的 `utils.py`，其中包含输入校验、错误处理和文档字符串，而且这些改进都是通过一次多轮对话逐步完成的。
+
+
+
+
+### 额外挑战：比较三种模式
+
+前面的示例中，搜索功能使用了 `/plan`，批量审查使用了 `-p`。现在请针对一个新任务，把三种模式都试一遍：为 `BookCollection` 类添加一个 `list_by_year()` 方法：
+
+1. **Interactive**：`copilot` → 让它一步步设计并实现这个方法
+2. **Plan**：`/plan 为 BookCollection 添加一个 list_by_year(start, end) 方法，用于按出版年份范围筛选图书`
+3. **Programmatic**：`copilot --allow-all -p "@samples/book-app-project/books.py 为其添加一个 list_by_year(start, end) 方法，返回出版年份在 start 和 end（含）之间的图书"`
+
+**思考**：哪一种模式对你来说最自然？你会在什么场景下使用它们？
+
+---
+
+💡 提示（点击展开）
+ +**可尝试的示例提示词：** +```bash +> @samples/book-app-project/utils.py 这个文件中的每个函数分别是做什么的？ +> 为 get_user_choice() 添加校验，使其能够处理空输入和非数字输入 +> 如果 get_book_details() 收到空字符串标题会怎样？请为这种情况添加保护逻辑。 +> 为 get_book_details() 添加完整的文档字符串，包含参数说明和返回值说明 +``` + +**常见问题：** +- 如果 Copilot CLI 提出澄清性问题，直接自然地回答即可 +- 上下文会持续保留，所以每条提示都会建立在前一条之上 +- 如果你想重新开始，可以使用 `/clear` + +
+
+
+---
+
+# 总结
+
+## 🔑 关键要点
+
+1. **Interactive 模式** 适合探索和迭代 —— 上下文会持续累积。它就像和一个会记住你前面说过什么的人持续对话。
+2. **Plan 模式** 通常适合更复杂、更完整的任务。先审查方案，再开始实现。
+3. **Programmatic 模式** 适合自动化场景。不需要交互。
+4. **四个核心命令**（`/help`、`/clear`、`/plan`、`/exit`）已经覆盖了大多数日常使用场景。
+
+> 📋 **快速参考**：查看 [GitHub Copilot CLI 命令参考](https://docs.github.com/en/copilot/reference/cli-command-reference)，获取完整的命令和快捷方式列表。
+
+---
+
+## ➡️ 下一步
+
+现在你已经理解了三种模式，接下来我们来学习如何为 Copilot CLI 提供与你代码相关的上下文。
+
+在 **[第 02 章：上下文与对话](../02-context-conversations/README.zh.md)** 中，你将学习：
+
+- 使用 `@` 语法引用文件和目录
+- 使用 `--resume` 和 `--continue` 管理会话
+- 理解上下文管理为何让 Copilot CLI 真正强大
+
+---
+
+**[← 返回课程首页](../README.md)** | **[继续阅读第 02 章 →](../02-context-conversations/README.zh.md)**
diff --git a/02-context-conversations/README.zh.md b/02-context-conversations/README.zh.md
new file mode 100644
index 00000000..ae1a0061
--- /dev/null
+++ b/02-context-conversations/README.zh.md
@@ -0,0 +1,872 @@
+
+
+> **如果 AI 不只看到单个文件，而是能看到你整个代码库，会怎样？**
+
+在本章中，你将解锁 GitHub Copilot CLI 的真正威力：上下文。你会学会使用 `@` 语法引用文件和目录，让 Copilot CLI 深入理解你的代码库。你会发现如何在多个会话之间保持对话、几天后精确地从上次停下的位置继续，以及跨文件分析如何发现单文件审查完全看不到的 Bug。
+
+## 🎯 学习目标
+
+在本章结束时，你将能够：
+
+- 使用 `@` 语法引用文件、目录和图片
+- 使用 `--resume` 和 `--continue` 恢复之前的会话
+- 理解 [上下文窗口](../GLOSSARY.md#context-window) 是如何工作的
+- 编写高质量的多轮对话
+- 在多项目场景下管理目录访问权限
+
+> ⏱️ **预计用时**：约 50 分钟（20 分钟阅读 + 30 分钟动手）
+
+---
+
+## 🧩 真实世界类比：和同事协作
+
+🔧 常见错误与故障排查（点击展开）
+ +### 常见错误 + +| 错误 | 会发生什么 | 如何修复 | +|------|------------|----------| +| 输入 `exit` 而不是 `/exit` | Copilot CLI 会把 “exit” 当成提示词，而不是命令 | 斜杠命令始终以 `/` 开头 | +| 用 `-p` 进行多轮对话 | 每次 `-p` 调用都是隔离的，不会记住之前的内容 | 需要持续上下文的对话请使用交互模式（`copilot`） | +| 提示词中包含 `$` 或 `!` 却忘了加引号 | Shell 会在 Copilot CLI 看到内容前，先解释这些特殊字符 | 用引号包裹提示词：`copilot -p "$HOME 表示什么？"` | + +### 故障排查 + +**“Model not available”** —— 你的订阅可能不包含所有模型。使用 `/model` 查看当前可用模型。 + +**“Context too long”** —— 你的对话已经用满了上下文窗口。可以使用 `/clear` 重置，或者开启新会话。 + +**“Rate limit exceeded”** —— 等几分钟后再试。对于批量操作，可以考虑在程序化模式下加入延迟。 + +
+
+*就像你的同事一样，Copilot CLI 也不是读心术大师。提供更多信息，能帮助人类和 Copilot 都给出更有针对性的帮助！*
+
+想象一下你向同事解释一个 Bug：
+
+> **没有上下文时**："这本图书应用不能正常工作。"
+
+> **有上下文时**："看看 `books.py`，尤其是 `find_book_by_title` 函数。它没有做不区分大小写的匹配。"
+
+要给 Copilot CLI 提供上下文，请使用 *`@` 语法* 把 Copilot CLI 指向特定文件。
+
+---
+
+# 必备：基础上下文
+
+
+
+本节涵盖的是你高效使用上下文所需的一切。先把这些基础打牢。
+
+---
+
+## @ 语法
+
+`@` 符号用于在提示中引用文件和目录。你可以借此告诉 Copilot CLI：“请看这个文件”。
+
+> 💡 **提示**：本课程中的所有示例都使用此仓库自带的 `samples/` 文件夹，你可以直接在本地运行每一条命令。
+
+### 现在就试试（无需额外准备）
+
+你可以对电脑上的任意文件这么做：
+
+```bash
+copilot
+
+# 指向任意已有文件
+> 解释 @package.json 是做什么的
+> 总结一下 @README.md 的内容
+> @.gitignore 里面有什么？为什么要这样配置？
+```
+
+> 💡 **手头没有项目？** 先创建一个简单的测试文件：
+> ```bash
+> echo "def greet(name): return 'Hello ' + name" > test.py
+> copilot
+> > @test.py 是做什么的？
+> ```
+
+### 基本 @ 用法模式
+
+| 模式 | 功能 | 示例用法 |
+|---------|------|----------|
+| `@file.py` | 引用单个文件 | `审查 @samples/book-app-project/books.py` |
+| `@folder/` | 引用目录下的所有文件 | `审查 @samples/book-app-project/` |
+| `@file1.py @file2.py` | 同时引用多个文件 | `比较 @samples/book-app-project/book_app.py @samples/book-app-project/books.py` |
+
+### 引用单个文件
+
+```bash
+copilot
+
+> 解释一下 @samples/book-app-project/utils.py 是做什么的
+```
+
+---
+
+
+
+
+---
+
+### 引用多个文件
+
+```bash
+copilot
+
+> 比较 @samples/book-app-project/book_app.py 和 @samples/book-app-project/books.py 是否保持一致
+```
+
+### 引用整个目录
+
+```bash
+copilot
+
+> 审查 @samples/book-app-project/ 中所有文件的错误处理情况
+```
+
+---
+
+## 跨文件智能
+
+这里是上下文变成“超能力”的地方。单文件分析有用，跨文件分析则可以带来质变。
+
+🎬 实机演示
+ + + +*演示输出会有差异。你的模型、工具和回复内容可能与这里不同。* + +
+
+### 演示：找出跨文件的 Bug
+
+```bash
+copilot
+
+> @samples/book-app-project/book_app.py @samples/book-app-project/books.py
+>
+> 这些文件是如何协同工作的？数据流是怎样的？
+```
+
+> 💡 **进阶选项**：如果你想做安全向的跨文件分析，可以试试 Python 安全示例：
+> ```bash
+> > @samples/buggy-code/python/user_service.py @samples/buggy-code/python/payment_processor.py
+> > 查找这两个文件之间相互关联的安全漏洞
+> ```
+
+---
+
+
+
+
+---
+
+**Copilot CLI 可能给出的发现示例**：
+
+```
+跨模块分析
+=====================
+
+1. 数据流模式
+ book_app.py 创建 BookCollection 实例并调用方法
+ books.py 定义 BookCollection 类并管理数据持久化
+
+ 流程：book_app.py（命令行界面）→ books.py（业务逻辑）→ data.json（存储）
+
+2. 重复的展示函数
+ book_app.py:9-21 show_books() 函数
+ utils.py:28-36 print_books() 函数
+
+ 影响：两个几乎相同的函数在做同一件事。如果你修改了其中一个
+ （例如更改输出格式），就必须记得同步修改另一个。
+
+3. 不一致的错误处理
+ book_app.py 会处理年份转换时的 ValueError
+ books.py 出错时只是悄悄返回 None/False
+
+ 模式：跨模块没有统一的错误处理方式
+```
+
+**为什么这很重要**：单独审查一个文件看不到整体情况。只有跨文件分析才能发现：
+- **重复代码**，应该合并成一个实现
+- **数据流模式**，展示各个组件如何协作
+- **架构问题**，影响可维护性
+
+---
+
+### 演示：60 秒读懂一个代码库
+
+🎬 实机演示
+ + + +*演示输出会有差异。你的模型、工具和回复内容可能与这里不同。* + +
+
+刚接手一个项目？可以用 Copilot CLI 快速熟悉它。
+
+```bash
+copilot
+
+> @samples/book-app-project/
+>
+> 用一段话说明这个应用是做什么的，以及它最大的问题有哪些？
+```
+
+**你可能会得到类似的回答**：
+```text
+这是一个 CLI 图书收藏管理器，允许用户添加、列出、删除和搜索存储在 JSON 文件中的图书。主要的质量问题包括：
+
+1. 重复的展示逻辑——show_books() 和 print_books() 做的是同一件事
+2. 错误处理不一致——有的错误抛出异常，有的只是返回 False
+3. 缺少输入校验——年份可以为 0，标题/作者可以是空字符串
+4. 缺少测试——像 find_book_by_title 这样的重要函数没有测试覆盖
+
+优先修复项：合并重复的展示函数，并添加输入校验。
+```
+
+**效果**：原本需要一小时读代码，现在压缩到十秒。你立刻就知道应该把精力放在哪些问题上。
+
+---
+
+## 实用示例
+
+### 示例 1：带上下文的代码评审
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py 请帮我检查这个文件是否有潜在 Bug
+
+# Copilot CLI 现在拥有完整文件内容，可以给出具体反馈：
+# "第 49 行：大小写敏感的比较可能会漏掉一些图书……"
+# "第 29 行：虽然捕获了 JSON 解码错误，但数据损坏没有被记录……"
+
+> 那 @samples/book-app-project/book_app.py 呢？
+
+# 现在在审查 book_app.py，但仍然记得 books.py 的上下文
+```
+
+### 示例 2：理解一个代码库
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py 这个模块是做什么的？
+
+# Copilot CLI 阅读 books.py，并理解 BookCollection 类
+
+> @samples/book-app-project/ 给我一个代码结构的整体概览
+
+# Copilot CLI 扫描整个目录并总结结构
+
+> 这个应用是如何保存和加载图书的？
+
+# Copilot CLI 可以沿着它已经看过的代码进行跟踪
+```
+
+
+
+
+### 示例 3：跨文件重构
+
+```bash
+copilot
+
+> @samples/book-app-project/book_app.py @samples/book-app-project/utils.py
+> 我看到有重复的展示函数：show_books() 和 print_books()。请帮我把它们合并一下。
+
+# Copilot CLI 同时看到两个文件，可以建议如何合并重复代码
+```
+
+---
+
+## 会话管理
+
+会话会在你工作时自动保存。你可以恢复之前的会话，从上次停下的位置继续。
+
+### 会话自动保存
+
+每一段对话都会自动保存。只要正常退出即可：
+
+```bash
+copilot
+
+> @samples/book-app-project/ 让我们改进一下所有模块中的错误处理
+
+[... 做一些工作 ...]
+
+> /exit
+```
+
+### 恢复最近的会话
+
+```bash
+# 从上次停下的位置继续
+copilot --continue
+```
+
+### 恢复指定会话
+
+```bash
+# 以交互方式从会话列表中挑选
+copilot --resume
+
+# 或者通过 ID 恢复某个特定会话
+copilot --resume abc123
+```
+
+> 💡 **如何找到会话 ID？** 你不需要记住它们。运行不带 ID 的 `copilot --resume` 会显示一个交互式列表，其中包含你之前的会话、名称、ID 和最近活动时间。选中你想要的即可。
+>
+> **多个终端怎么办？** 每个终端窗口都是一个独立的会话，拥有自己的上下文。如果你在三个终端里都打开了 Copilot CLI，那就是三个独立会话。从任意终端运行 `--resume` 都可以浏览它们。`--continue` 标志会继续最近关闭的那个会话，而不管它之前在哪个终端运行。
+>
+> **可以不重启就切换会话吗？** 可以。在活动会话内部使用 `/resume` 斜杠命令：
+> ```
+> > /resume
+> # 会显示一个可切换的会话列表
+> ```
+
+### 组织你的会话
+
+给会话起一个有意义的名字，方便之后查找：
+
+```bash
+copilot
+
+> /rename book-app-review
+# 会话已重命名，之后更容易识别
+```
+
+### 检查和管理上下文
+
+随着你不断添加文件和对话内容，Copilot CLI 的[上下文窗口](../GLOSSARY.md#context-window)会逐渐被填满。下面两个命令可以帮你保持掌控：
+
+```bash
+copilot
+
+> /context
+上下文使用情况：45,000 / 128,000 tokens (35%)
+
+> /clear
+# 清空上下文，从头开始。切换话题时使用
+```
+
+> 💡 **何时使用 `/clear`**：如果你刚刚一直在审查 `books.py`，现在想切换到 `utils.py`，先运行 `/clear`。否则旧话题的上下文可能会干扰新问题的回答。
+
+---
+
+### 接着上次继续
+
+🎬 多轮对话演示
+ + + +*演示输出会有差异。你的模型、工具和回复内容可能与这里不同。* + +
+
+*会话在退出时会自动保存。几天后恢复时，上下文依然完整：包含文件、问题和进度。*
+
+想象这样一个跨多天的工作流：
+
+```bash
+# 周一：开始评审图书应用
+copilot
+
+> /rename book-app-review
+> @samples/book-app-project/books.py
+> 请列出并编号所有代码质量问题
+
+发现的质量问题：
+1. 重复的展示函数（book_app.py 和 utils.py）- MEDIUM
+2. 没有对空字符串做输入校验 - MEDIUM
+3. 年份可以为 0 或负数 - LOW
+4. 所有函数都缺少类型标注 - LOW
+5. 没有错误日志记录 - LOW
+
+> 修复第 1 个问题（重复函数）
+# 着手修复...
+
+> /exit
+```
+
+```bash
+# 周三：精确地从上次停下的位置继续
+copilot --continue
+
+> 我们之前对图书应用的评审里，还有哪些问题没有修复？
+
+来自 book-app-review 会话的剩余问题：
+2. 没有对空字符串做输入校验 - MEDIUM
+3. 年份可以为 0 或负数 - LOW
+4. 所有函数都缺少类型标注 - LOW
+5. 没有错误日志记录 - LOW
+
+第 1 个问题（重复函数）已经在周一修复了。
+
+> 接下来我们先解决第 2 个问题
+```
+
+**强大之处在于**：几天之后，Copilot CLI 仍然记得：
+- 你当时正在处理哪个文件
+- 你列出的编号问题清单
+- 哪些问题已经修复了
+- 整个对话的上下文
+
+无需重新讲述，也不用重新读文件，直接继续工作即可。
+
+---
+
+**🎉 你已经掌握了核心要点！** `@` 语法、会话管理（`--continue` / `--resume` / `/rename`），以及上下文相关命令（`/context` / `/clear`），已经足够让你高效使用 Copilot CLI。下面的内容都是可选进阶，等你准备好再回来学习。
+
+---
+
+# 可选进阶：更深入的用法
+
+
+
+这些主题建立在前面的核心内容之上。**可以按兴趣选择性阅读，也可以直接跳到[练习](#练习)。**
+
+| 我想了解... | 跳转到 |
+|---|---|
+| 通配符模式和更多会话命令 | [更多 @ 模式与会话命令](#additional-patterns) |
+| 如何在多轮提示中不断累积上下文 | [上下文感知对话](#context-aware-conversations) |
+| token 限制和 `/compact` | [理解上下文窗口](#understanding-context-windows) |
+| 如何选择要引用哪些文件 | [选择要引用的内容](#choosing-what-to-reference) |
+| 分析截图和设计稿 | [使用图片工作](#working-with-images) |
+
+
+
+
+更多 @ 模式与会话命令
+ + +### 更多 @ 模式 + +对于高阶用户，Copilot CLI 支持通配符模式和图片引用： + +| 模式 | 功能 | +|---------|------| +| `@folder/*.py` | 引用目录中所有 .py 文件 | +| `@**/test_*.py` | 递归通配：在任意子目录中查找所有测试文件 | +| `@image.png` | 用于 UI 评审的图片文件 | + +```bash +copilot + +> 查找 @samples/book-app-project/**/*.py 中所有 TODO 注释 +``` + +### 查看会话信息 + +```bash +copilot + +> /session +# 显示当前会话的详细信息和工作区概览 + +> /usage +# 显示会话的统计信息和使用情况 +``` + +### 分享你的会话 + +```bash +copilot + +> /share file ./my-session.md +# 将会话导出为一个 markdown 文件 + +> /share gist +# 将会话创建为一个 GitHub gist +``` + +
+
+
+上下文感知对话
+ + +### 上下文感知对话 + +真正的魔力体现在多轮对话中——每一轮都在前一轮的基础上继续构建。 + +#### 示例：渐进式改进 + +```bash +copilot + +> @samples/book-app-project/books.py 请审查一下 BookCollection 类 + +Copilot CLI："这个类功能上没问题，但我注意到： +1. 部分方法缺少类型标注 +2. 没有对空标题/作者做校验 +3. 错误处理还有改进空间" + +> 给所有方法都加上类型标注 + +Copilot CLI："这是添加了完整类型标注之后的类……" +[展示加上类型后的版本] + +> 现在改进一下错误处理 + +Copilot CLI："在带类型的版本基础上，这是改进过的错误处理……" +[添加了校验和合理的异常处理] + +> 为这个最终版本生成测试 + +Copilot CLI："基于带类型和错误处理的最终版本，生成的测试如下……" +[生成了较为全面的测试] +``` + +注意每一条提示都是在前面工作成果的基础上继续。这就是上下文的力量。 + +
+
+
+*上下文窗口就像一张桌子：一次只能放得下有限的东西。文件、对话历史和系统提示都会占用空间。*
+
+#### 接近上限时会发生什么
+
+```bash
+copilot
+
+> /context
+
+上下文使用情况：45,000 / 128,000 tokens (35%)
+
+# 随着你不断添加文件和对话，这个数字会持续增大
+
+> @large-codebase/
+
+上下文使用情况：120,000 / 128,000 tokens (94%)
+
+# 警告：接近上下文限制
+
+> @another-large-file.py
+
+已达到上下文限制。较早的内容会被自动总结。
+```
+
+#### `/compact` 命令
+
+当上下文接近上限，又不想丢失历史对话时，可以使用 `/compact` 将历史对话总结为更精简的内容，从而释放 token：
+
+```bash
+copilot
+
+> /compact
+# 总结对话历史，释放上下文空间
+# 你的关键发现和决策会被保留下来
+```
+
+#### 提高上下文利用率的小技巧
+
+| 场景 | 操作 | 原因 |
+|-----------|------|------|
+| 开始新话题 | `/clear` | 移除无关上下文 |
+| 对话很长 | `/compact` | 总结历史，节省 token |
+| 只需特定文件 | 用 `@file.py` 而不是 `@folder/` | 只加载需要的内容 |
+| 快到上限 | 新开一个会话 | 获得全新的 128K 上下文 |
+| 同时做多个主题 | 针对每个主题使用 `/rename` | 方便恢复对应会话 |
+
+#### 大型代码库的最佳实践
+
+1. **尽量具体**：优先使用 `@samples/book-app-project/books.py` 而不是 `@samples/book-app-project/`
+2. **切换话题时清空**：换焦点时使用 `/clear`
+3. **使用 `/compact`**：总结对话历史以释放上下文
+4. **多会话并行**：每个功能或主题用一个独立会话
+
+
+
+理解上下文窗口
+ + +### 理解上下文窗口 + +你已经在核心部分了解了 `/context` 和 `/clear`。这里是关于上下文窗口如何工作的更深入解释。 + +每个 AI 都有一个“上下文窗口”，即它一次能同时考虑的文本总量。 + +
+
+*上下文窗口就像一张桌子：一次只能放得下有限的东西。文件、对话历史和系统提示都会占用空间。*
+
+#### 接近上限时会发生什么
+
+```bash
+copilot
+
+> /context
+
+上下文使用情况：45,000 / 128,000 tokens (35%)
+
+# 随着你不断添加文件和对话，这个数字会持续增大
+
+> @large-codebase/
+
+上下文使用情况：120,000 / 128,000 tokens (94%)
+
+# 警告：接近上下文限制
+
+> @another-large-file.py
+
+已达到上下文限制。较早的内容会被自动总结。
+```
+
+#### `/compact` 命令
+
+当上下文接近上限，又不想丢失历史对话时，可以使用 `/compact` 将历史对话总结为更精简的内容，从而释放 token：
+
+```bash
+copilot
+
+> /compact
+# 总结对话历史，释放上下文空间
+# 你的关键发现和决策会被保留下来
+```
+
+#### 提高上下文利用率的小技巧
+
+| 场景 | 操作 | 原因 |
+|-----------|------|------|
+| 开始新话题 | `/clear` | 移除无关上下文 |
+| 对话很长 | `/compact` | 总结历史，节省 token |
+| 只需特定文件 | 用 `@file.py` 而不是 `@folder/` | 只加载需要的内容 |
+| 快到上限 | 新开一个会话 | 获得全新的 128K 上下文 |
+| 同时做多个主题 | 针对每个主题使用 `/rename` | 方便恢复对应会话 |
+
+#### 大型代码库的最佳实践
+
+1. **尽量具体**：优先使用 `@samples/book-app-project/books.py` 而不是 `@samples/book-app-project/`
+2. **切换话题时清空**：换焦点时使用 `/clear`
+3. **使用 `/compact`**：总结对话历史以释放上下文
+4. **多会话并行**：每个功能或主题用一个独立会话
+
+
+
+
+选择要引用的内容
+ + +### 选择要引用的内容 + +在上下文里，并不是所有文件都同等重要。下面是如何有策略地选择： + +#### 文件大小考量 + +| 文件大小 | 约 [token](../GLOSSARY.md#token) 数 | 策略 | +|-----------|-------------------|----------| +| 小型 (<100 行) | ~500-1,500 tokens | 可以放心引用 | +| 中型 (100-500 行) | ~1,500-7,500 tokens | 有选择地引用具体文件 | +| 大型 (500+ 行) | 7,500+ tokens | 更加谨慎，只引用真正需要的文件 | +| 超大型 (1000+ 行) | 15,000+ tokens | 考虑拆分或只针对关键部分 | + +**具体示例：** +- 书籍应用的 4 个 Python 文件合起来 ≈ 2,000-3,000 tokens +- 一个典型的 Python 模块（200 行）≈ 3,000 tokens +- 一个 Flask API 文件（400 行）≈ 6,000 tokens +- 你的 package.json ≈ 200-500 tokens +- 一段简短的提示 + 回复 ≈ 500-1,500 tokens + +> 💡 **代码的快速估算方法：** 用代码行数 × 约 15 来估算 token 数。这只是一个粗略估计。 + +#### 应该包含什么，排除什么 + +**高价值**（优先包含）： +- 入口文件（`book_app.py`、`main.py`、`app.py`） +- 你问题直接相关的文件 +- 被目标文件直接导入的文件 +- 配置文件（`requirements.txt`、`pyproject.toml`） +- 数据模型或 dataclass + +**价值较低**（可以考虑排除）： +- 生成文件（编译输出、打包产物） +- node_modules 或 vendor 目录 +- 体积巨大的数据文件或测试数据 +- 和你当前问题无关的文件 + +#### 特定性光谱 + +``` +不够具体 ────────────────────────► 更具体 +@samples/book-app-project/ @samples/book-app-project/books.py:47-52 + │ │ + └─ 扫描所有内容 └─ 只包含你真正需要的部分 + （占用更多上下文） （更好地节省上下文） +``` + +**何时用广泛引用**（`@samples/book-app-project/`）： +- 初次探索一个代码库 +- 想在多文件中寻找模式 +- 做架构层面的审查 + +**何时用精确引用**（`@samples/book-app-project/books.py`）： +- 调试某个特定问题 +- 审查某个特定文件 +- 只想询问单个函数 + +#### 实战示例：分阶段加载上下文 + +```bash +copilot + +# 第 1 步：先从整体结构入手 +> @package.json 这个项目使用了哪些框架？ + +# 第 2 步：根据回答再深入 +> @samples/book-app-project/ 给我看看项目结构 + +# 第 3 步：聚焦关键部分 +> @samples/book-app-project/books.py 请审查 BookCollection 类 + +# 第 4 步：只在需要时再添加相关文件 +> @samples/book-app-project/book_app.py @samples/book-app-project/books.py CLI 是如何使用 BookCollection 的？ +``` + +这种分阶段的方式可以让上下文保持聚焦且高效利用。 + +
+
+
+---
+
+# 练习
+
+使用图片工作
+ + +### 使用图片工作 + +你可以使用 `@` 语法在对话中包含图片，也可以直接**从剪贴板粘贴**（Cmd+V / Ctrl+V）。Copilot CLI 可以分析截图、设计稿和示意图，帮你进行 UI 调试、实现设计以及分析报错界面。 + +```bash +copilot + +> @images/screenshot.png 这张图片里发生了什么？ + +> @images/mockup.png 按这个设计写出对应的 HTML 和 CSS。把 HTML 放到一个名为 index.html 的新文件中，CSS 放到 styles.css 中。 +``` + +> 📖 **延伸阅读**：参见 [更多上下文功能](../appendices/additional-context.md#working-with-images)，了解支持的图片格式、实用用例，以及如何把图片和代码结合使用的技巧。 + +
+
+现在是时候运用你的上下文和会话管理技能了。
+
+---
+
+## ▶️ 自己动手试试
+
+### 完整项目评审
+
+本课程附带了一套可以直接评审的示例文件。启动 copilot，然后输入下面的提示：
+
+```bash
+copilot
+
+> @samples/book-app-project/ 请对这个项目做一次代码质量评审
+
+# Copilot CLI 会识别出类似下面的问题：
+# - 重复的展示函数
+# - 缺少输入校验
+# - 错误处理不一致
+```
+
+> 💡 **想用你自己的文件练习？** 可以创建一个小型 Python 项目（`mkdir -p my-project/src`），添加几个 .py 文件，然后用 `@my-project/src/` 来评审。你也可以先让 copilot 帮你生成一些示例代码！
+
+### 会话工作流
+
+```bash
+copilot
+
+> /rename book-app-review
+> @samples/book-app-project/books.py 我们来给空标题添加输入校验
+
+[Copilot CLI 给出了一种校验方案]
+
+> 实现这个修复
+> 现在合并 @samples/book-app-project/ 中重复的展示函数
+> /exit
+
+# 之后 - 从上次停下的位置继续
+copilot --continue
+
+> 为我们做的这些修改生成测试
+```
+
+---
+
+完成这些演示后，可以再尝试下面的变体：
+
+1. **跨文件挑战**：分析 book_app.py 和 books.py 是如何协作的：
+ ```bash
+ copilot
+ > @samples/book-app-project/book_app.py @samples/book-app-project/books.py
+ > 这些文件之间是什么关系？有没有明显的代码坏味道？
+ ```
+
+2. **会话挑战**：启动一个会话，用 `/rename my-first-session` 命名，做一些修改后用 `/exit` 退出，然后运行 `copilot --continue`。它是否记得你在做什么？
+
+3. **上下文挑战**：在会话中途运行 `/context`。你用了多少 token？试试 `/compact` 再看一次。（关于 `/compact` 的更多说明见进阶部分的 [理解上下文窗口](#understanding-context-windows)。）
+
+**自检**：当你能解释为什么 `@folder/` 比逐个打开文件更强大时，你就真正理解了上下文。
+
+---
+
+## 📝 课后作业
+
+### 主要挑战：追踪数据流
+
+我们在动手示例中侧重于代码质量评审和输入验证。现在用同样的上下文技巧做一件不同的事：追踪数据在应用中的流动：
+
+1. 启动交互式会话：`copilot`
+2. 同时引用 `books.py` 和 `book_app.py`：
+ `@samples/book-app-project/books.py @samples/book-app-project/book_app.py 追踪一本书如何从用户输入一路被保存到 data.json。每一步都涉及哪些函数？`
+3. 加上数据文件作为额外上下文：
+ `@samples/book-app-project/data.json 如果这个 JSON 文件丢失或损坏会怎样？哪些函数会失败？`
+4. 请求一次跨文件改进：
+ `@samples/book-app-project/books.py @samples/book-app-project/utils.py 给出一种在两个文件中都适用的一致错误处理策略。`
+5. 重命名会话：`/rename data-flow-analysis`
+6. 使用 `/exit` 退出，然后用 `copilot --continue` 恢复，并就数据流提出一个后续问题
+
+**成功标准**：你可以跨多个文件追踪数据流、恢复已命名的会话，并获得跨文件的改进建议。
+
+
+` - 给会话命名，方便下次恢复
+
+
+
+### 进阶挑战：上下文限制
+
+1. 使用 `@samples/book-app-project/` 一次性引用书籍应用的所有文件
+2. 针对不同文件（`books.py`、`utils.py`、`book_app.py`、`data.json`）提出多个详细问题
+3. 运行 `/context` 查看使用情况。上下文填满得有多快？
+4. 练习使用 `/compact` 释放空间，然后继续对话
+5. 尝试更精确的文件引用方式（例如用 `@samples/book-app-project/books.py` 代替整个文件夹），观察对上下文使用的影响
+
+---
+
+💡 提示（点击展开）
+ +**开始步骤示例：** +```bash +cd /path/to/copilot-cli-for-beginners +copilot +> @samples/book-app-project/books.py @samples/book-app-project/book_app.py 追踪一本书如何从用户输入一路被保存到 data.json。 +> @samples/book-app-project/data.json 如果这个文件丢失或损坏会怎样？ +> /rename data-flow-analysis +> /exit +``` + +然后使用：`copilot --continue` 恢复 + +**常用命令：** +- `@file.py` - 引用单个文件 +- `@folder/` - 引用文件夹内所有文件（注意末尾的 `/`） +- `/context` - 查看当前上下文使用情况 +- `/rename
+
+
+---
+
+# 总结
+
+## 🔑 关键要点
+
+1. **`@` 语法** 让 Copilot CLI 获得关于文件、目录和图片的上下文
+2. **多轮对话** 会随着上下文累积而变得越来越有针对性
+3. **会话自动保存**：使用 `--continue` 或 `--resume` 从上次停下的位置继续
+4. **上下文窗口** 有容量限制：使用 `/context`、`/clear` 和 `/compact` 来管理
+5. **权限相关标志位**（`--add-dir`、`--allow-all`）控制多目录访问，要谨慎使用！
+6. **图片引用**（`@screenshot.png`）能帮助你从视觉上调试 UI 问题
+
+> 📚 **官方文档**：[使用 Copilot CLI](https://docs.github.com/copilot/how-tos/copilot-cli/use-copilot-cli)，其中包含关于上下文、会话和文件操作的完整参考。
+
+> 📋 **快捷参考**：参见 [GitHub Copilot CLI 命令参考](https://docs.github.com/en/copilot/reference/cli-command-reference) 获取完整的命令和快捷方式列表。
+
+---
+
+## ➡️ 下一步
+
+现在你已经学会如何为 Copilot CLI 提供上下文，接下来就可以把它应用到真实的开发任务中。本章学到的上下文技巧（文件引用、跨文件分析和会话管理）是下一章中更强大工作流的基石。
+
+在 **[第 03 章：开发工作流](../03-development-workflows/README.zh.md)** 中，你将学习：
+
+- 代码评审工作流
+- 重构模式
+- 调试辅助
+- 测试生成
+- Git 集成
+
+---
+
+**[← 返回第 01 章](../01-setup-and-first-steps/README.zh.md)** | **[继续阅读第 03 章 →](../03-development-workflows/README.zh.md)**
diff --git a/03-development-workflows/README.zh.md b/03-development-workflows/README.zh.md
new file mode 100644
index 00000000..d1f2ab3f
--- /dev/null
+++ b/03-development-workflows/README.zh.md
@@ -0,0 +1,950 @@
+
+
+> **如果 AI 还能找出那些你甚至不知道该问的 bug，会怎样？**
+
+在本章中，GitHub Copilot CLI 会成为你日常开发的主力工具。你会把它融入自己每天已经在使用的工作流：测试、重构、调试以及 Git。
+
+## 🎯 学习目标
+
+完成本章后，你将能够：
+
+- 使用 Copilot CLI 进行全面的代码审查
+- 安全地重构遗留代码
+- 在 AI 辅助下调试问题
+- 自动生成测试
+- 将 Copilot CLI 融入你的 Git 工作流
+
+> ⏱️ **预计耗时**：约 60 分钟（15 分钟阅读 + 45 分钟动手）
+
+---
+
+## 🧩 现实类比：木匠的工作流
+
+木匠不只是会用工具，他们还会为不同工作准备不同的工作流：
+
+🔧 常见错误与排查（点击展开）
+ +### 常见错误 + +| 常见错误 | 表现 | 修复方式 | +|---------|--------------|-----| +| 忘记在文件名之前加 `@` | Copilot CLI 会把 "books.py" 当成普通文本 | 使用 `@samples/book-app-project/books.py` 来引用文件 | +| 以为会话会自动持续存在 | 重新启动 `copilot` 会丢失之前的上下文 | 使用 `--continue`（最近的会话）或 `--resume`（从列表选择会话） | +| 引用当前目录之外的文件 | 出现 "Permission denied" 或 "File not found" 错误 | 使用 `/add-dir /path/to/directory` 授权访问目录 | +| 切换话题时不使用 `/clear` | 旧上下文会干扰新问题的回答 | 在开始不同任务前运行 `/clear` | + +### 故障排查 + +**“File not found” 错误**——先确认当前所在目录： + +```bash +pwd # 查看当前目录 +ls # 列出文件 + +# 然后启动 copilot，并使用相对路径 +copilot + +> 请审查 @samples/book-app-project/books.py +``` + +**“Permission denied”**——把目录加入允许列表： + +```bash +copilot --add-dir /path/to/directory + +# 或者在会话中： +> /add-dir /path/to/directory +``` + +**上下文填满得太快：** +- 更精确地引用文件 +- 在不同主题间使用 `/clear` +- 把工作拆分到多个会话中 + +
+
+类似地，开发者在面对不同任务时，也有不同工作流。GitHub Copilot CLI 可以增强这些工作流，让你在日常编码中更高效，也更有把握。
+
+---
+
+# 五种工作流
+
+
+
+下面每个工作流都可以单独阅读。挑选与你当前需求匹配的部分即可，或者全部按顺序学一遍。
+
+---
+
+## 按需选择你的路径
+
+本章涵盖了开发者常用的五种工作流。**不过，你完全不需要一次把它们全读完！** 下面每个可折叠部分都是自包含的。请选择最符合你当前项目需求的部分即可。之后你随时可以回来继续探索其他工作流。
+
+
+
+| 我想…… | 跳转到 |
+|---|---|
+| 在合并前审查代码 | [工作流 1：代码审查](#workflow-1-code-review) |
+| 清理凌乱或遗留代码 | [工作流 2：重构](#workflow-2-refactoring) |
+| 定位并修复 bug | [工作流 3：调试](#workflow-3-debugging) |
+| 为我的代码生成测试 | [工作流 4：测试生成](#workflow-4-test-generation) |
+| 写出更好的提交信息和 PR | [工作流 5：Git 集成](#workflow-5-git-integration) |
+| 编码前先做研究 | [快速提示：先研究，再规划或编码](#quick-tip-research-before-you-plan-or-code) |
+| 从头到尾看完整的 bug 修复流程 | [综合实战](#putting-it-all-together-bug-fix-workflow) |
+
+**展开下面任一工作流**，看看 GitHub Copilot CLI 如何在该领域增强你的开发过程。
+
+---
+
+
+
+
+
+### 基础审查
+
+这个示例使用 `@` 符号引用文件，让 Copilot CLI 可以直接访问文件内容并进行审查。
+
+```bash
+copilot
+
+> 审查 @samples/book-app-project/book_app.py 的代码质量
+```
+
+---
+
+
+
+---
+
+
+工作流 1：代码审查 - 审查文件、使用 /review 智能体、创建严重级别检查清单
+ +
+
+### 基础审查
+
+这个示例使用 `@` 符号引用文件，让 Copilot CLI 可以直接访问文件内容并进行审查。
+
+```bash
+copilot
+
+> 审查 @samples/book-app-project/book_app.py 的代码质量
+```
+
+---
+
+
+
+
+---
+
+### 输入校验审查
+
+在提示词中列出你关心的类别，让 Copilot CLI 把审查重点放在某个特定问题上（这里是输入校验）。
+
+```text
+copilot
+
+> 审查 @samples/book-app-project/utils.py 的输入校验问题。检查：缺失的校验、错误处理漏洞，以及边界情况
+```
+
+
+### 跨文件项目审查
+
+用 `@` 引用整个目录，让 Copilot CLI 一次性扫描项目中的每个文件。
+
+```bash
+copilot
+
+> @samples/book-app-project/ 审查整个项目。创建一个按严重级别分类的问题 markdown 检查清单
+```
+
+### 交互式代码审查
+
+使用多轮对话继续深挖。先做一次宽泛审查，然后直接追问，而不用重新开始。
+
+```bash
+copilot
+
+> @samples/book-app-project/book_app.py 审查这个文件，重点关注：
+> - 输入校验
+> - 错误处理
+> - 代码风格和最佳实践
+
+# Copilot CLI 会给出详细的审查结果
+
+> 关于用户输入处理——我是否遗漏了任何边界情况？
+
+# Copilot CLI 会指出空字符串、特殊字符等潜在问题
+
+> 把发现的所有问题整理成按严重级别排序的检查清单
+
+# Copilot CLI 会生成按优先级排列的行动项
+```
+
+### 审查检查清单模板
+
+让 Copilot CLI 按特定格式组织输出（这里是一个按严重级别分类的 markdown 检查清单，你可以直接粘贴到 issue 中）。
+
+```bash
+copilot
+
+> 审查 @samples/book-app-project/，并创建一个按以下级别分类的 markdown 问题检查清单：
+> - Critical（数据丢失风险、崩溃）
+> - High（bug、行为不正确）
+> - Medium（性能、可维护性）
+> - Low（风格、轻微改进）
+```
+
+### 理解 Git 改动（/review 很重要）
+
+在使用 `/review` 命令之前，你需要理解 Git 中两类改动：
+
+| 改动类型 | 含义 | 如何查看 |
+|-------------|---------------|------------|
+| **已暂存改动** | 你已用 `git add` 标记为下次提交内容的文件 | `git diff --staged` |
+| **未暂存改动** | 你已经修改、但还没加入暂存区的文件 | `git diff` |
+
+```bash
+# 快速参考
+git status # 同时显示已暂存和未暂存的改动
+git add file.py # 将文件加入暂存区，准备提交
+git diff # 显示未暂存改动
+git diff --staged # 显示已暂存改动
+```
+
+### 使用 /review 命令
+
+`/review` 命令会调用内置的 **code-review 智能体**，它专门针对已暂存和未暂存的改动进行分析，并输出高信噪比的结果。与其写自由形式提示词，不如直接用斜杠命令来触发这个专用内置智能体。
+
+```bash
+copilot
+
+> /review
+# 调用 code-review 智能体来分析已暂存/未暂存改动
+# 提供聚焦、可执行的反馈
+
+> /review 检查认证流程中的安全问题
+# 在指定重点方向下运行审查
+```
+
+> 💡 **提示**：code-review 智能体在你有待提交改动时效果最好。先用 `git add` 暂存文件，可以让审查结果更聚焦。
+
+🎬 查看实际演示！
+ + + +*演示输出会有所不同。你的模型、工具和响应不会与这里展示的内容完全一致。* + +
+
+
+### 简单重构
+
+> **先试试这个：** `@samples/book-app-project/book_app.py 命令处理目前使用 if/elif 链。请将其重构为字典分发模式。`
+
+先从直接、清晰的改进开始。可以在图书应用上尝试下面这些提示词。每个提示词都把 `@` 文件引用与明确的重构指令配对，让 Copilot CLI 清楚知道要改什么。
+
+```bash
+copilot
+
+> @samples/book-app-project/book_app.py 命令处理目前使用 if/elif 链。请将其重构为字典分发模式。
+
+> @samples/book-app-project/utils.py 为所有函数添加类型提示
+
+> @samples/book-app-project/book_app.py 将图书显示逻辑提取到 utils.py 中，以更好地分离关注点
+```
+
+> 💡 **刚开始学重构？** 先从添加类型提示、改进变量命名这类简单请求开始，再逐步挑战更复杂的转换。
+
+---
+
+
+
+---
+
+
+工作流 2：重构 - 重组代码、分离关注点、改进错误处理
+ +
+
+### 简单重构
+
+> **先试试这个：** `@samples/book-app-project/book_app.py 命令处理目前使用 if/elif 链。请将其重构为字典分发模式。`
+
+先从直接、清晰的改进开始。可以在图书应用上尝试下面这些提示词。每个提示词都把 `@` 文件引用与明确的重构指令配对，让 Copilot CLI 清楚知道要改什么。
+
+```bash
+copilot
+
+> @samples/book-app-project/book_app.py 命令处理目前使用 if/elif 链。请将其重构为字典分发模式。
+
+> @samples/book-app-project/utils.py 为所有函数添加类型提示
+
+> @samples/book-app-project/book_app.py 将图书显示逻辑提取到 utils.py 中，以更好地分离关注点
+```
+
+> 💡 **刚开始学重构？** 先从添加类型提示、改进变量命名这类简单请求开始，再逐步挑战更复杂的转换。
+
+---
+
+
+
+
+---
+
+### 分离关注点
+
+在一个提示词中用 `@` 引用多个文件，这样 Copilot CLI 就能在重构过程中把代码在不同文件之间移动。
+
+```bash
+copilot
+
+> @samples/book-app-project/utils.py @samples/book-app-project/book_app.py
+> utils.py 文件里把 print 语句和逻辑混在了一起。请重构，把显示函数与数据处理分离。
+```
+
+### 改进错误处理
+
+提供两个相关文件，并说明你想统一处理的横切问题，这样 Copilot CLI 就能在两个文件中一起给出一致的修复建议。
+
+```bash
+copilot
+
+> @samples/book-app-project/utils.py @samples/book-app-project/books.py
+> 这些文件的错误处理方式不一致。请建议一种基于自定义异常的统一方案。
+```
+
+### 添加文档
+
+用详细的项目符号列表明确说明每个 docstring 应该包含哪些内容。
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py 为所有方法添加完整的 docstring：
+> - 包含参数类型和说明
+> - 记录返回值
+> - 标明可能抛出的异常
+> - 添加使用示例
+```
+
+### 用测试安全地重构
+
+在多轮对话中串联两个相关请求。先生成测试，再借助这些测试作为安全网进行重构。
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py 在重构之前，先为当前行为生成测试
+
+# 先拿到测试
+
+> 现在把 BookCollection 类重构为使用上下文管理器处理文件操作
+
+# 可以放心重构——测试会验证行为是否保持不变
+```
+
+🎬 查看实际演示！
+ + + +*演示输出会有所不同。你的模型、工具和响应不会与这里展示的内容完全一致。* + +
+
+
+### 简单调试
+
+> **先试试这个：** `@samples/book-app-buggy/books_buggy.py 用户反馈搜索 "The Hobbit" 时没有结果，但它明明在数据里。请调试原因。`
+
+先描述哪里出了问题。下面这些是你可以在有 bug 的图书应用上尝试的常见调试模式。每个提示词都把 `@` 文件引用与明确的症状描述配对，让 Copilot CLI 去定位并诊断 bug。
+
+```bash
+copilot
+
+# 模式：“应该得到 X，却得到了 Y”
+> @samples/book-app-buggy/books_buggy.py 用户反馈搜索 "The Hobbit" 时没有结果，但它明明在数据里。请调试原因。
+
+# 模式：“行为出乎意料”
+> @samples/book-app-buggy/book_app_buggy.py 当我删除一本不存在的书时，应用却提示删除成功。帮我找出原因。
+
+# 模式：“结果不对”
+> @samples/book-app-buggy/books_buggy.py 当我把一本书标记为已读时，所有书都会被标记。bug 在哪里？
+```
+
+> 💡 **调试提示**：描述清楚*症状*（你看到了什么）和*期望*（本该发生什么）。其余部分交给 Copilot CLI 来推断。
+
+---
+
+
+
+---
+
+
+工作流 3：调试 - 追踪 bug、做安全审计、跨文件定位问题
+ +
+
+### 简单调试
+
+> **先试试这个：** `@samples/book-app-buggy/books_buggy.py 用户反馈搜索 "The Hobbit" 时没有结果，但它明明在数据里。请调试原因。`
+
+先描述哪里出了问题。下面这些是你可以在有 bug 的图书应用上尝试的常见调试模式。每个提示词都把 `@` 文件引用与明确的症状描述配对，让 Copilot CLI 去定位并诊断 bug。
+
+```bash
+copilot
+
+# 模式：“应该得到 X，却得到了 Y”
+> @samples/book-app-buggy/books_buggy.py 用户反馈搜索 "The Hobbit" 时没有结果，但它明明在数据里。请调试原因。
+
+# 模式：“行为出乎意料”
+> @samples/book-app-buggy/book_app_buggy.py 当我删除一本不存在的书时，应用却提示删除成功。帮我找出原因。
+
+# 模式：“结果不对”
+> @samples/book-app-buggy/books_buggy.py 当我把一本书标记为已读时，所有书都会被标记。bug 在哪里？
+```
+
+> 💡 **调试提示**：描述清楚*症状*（你看到了什么）和*期望*（本该发生什么）。其余部分交给 Copilot CLI 来推断。
+
+---
+
+
+
+
+---
+
+### “Bug Detective”——AI 会发现相关缺陷
+
+这正是上下文感知调试真正发光的地方。你可以在有 bug 的图书应用上试试这个场景：用 `@` 提供整个文件，只描述用户报告的症状。Copilot CLI 会顺着线索追到根因，甚至可能顺手发现附近的其他 bug。
+
+```bash
+copilot
+
+> @samples/book-app-buggy/books_buggy.py
+>
+> 用户反馈：“按作者名查书时，部分姓名匹配不起作用”
+> 请调试原因
+```
+
+**Copilot CLI 会这样做：**
+```
+根因：第 80 行使用的是精确匹配 (`==`)，而不是部分匹配 (`in`)。
+
+第 80 行：return [b for b in self.books if b.author == author]
+
+`find_by_author` 函数要求完全匹配。搜索 "Tolkien"
+时，就找不到作者为 "J.R.R. Tolkien" 的图书。
+
+修复：改为不区分大小写的部分匹配：
+return [b for b in self.books if author.lower() in b.author.lower()]
+```
+
+**这为什么重要**：Copilot CLI 会阅读整个文件，理解你的 bug 报告上下文，并给出一个具体修复方案和清晰解释。
+
+> 💡 **额外收获**：由于 Copilot CLI 会分析整个文件，它经常还能发现*你没有主动问到*的其他问题。例如，在修复作者搜索时，它可能还会顺手发现 `find_book_by_title` 中大小写敏感的 bug！
+
+### 现实世界安全侧栏
+
+调试你自己的代码固然重要，但理解生产应用中的安全漏洞同样关键。试试这个示例：把一个你不熟悉的文件交给 Copilot CLI，让它审计安全问题。
+
+```bash
+copilot
+
+> @samples/buggy-code/python/user_service.py 找出这个 Python 用户服务中的所有安全漏洞
+```
+
+这个文件展示了你在生产应用中会遇到的真实安全模式。
+
+> 💡 **你会遇到的常见安全术语：**
+> - **SQL 注入（SQL Injection）**：当用户输入被直接放进数据库查询中时，攻击者就可能执行恶意命令
+> - **参数化查询（Parameterized queries）**：更安全的替代方案——使用占位符（`?`）把用户数据与 SQL 命令分离
+> - **竞争条件（Race condition）**：两个操作同时发生并互相干扰时出现的问题
+> - **跨站脚本（XSS, Cross-Site Scripting）**：攻击者将恶意脚本注入网页的漏洞
+
+---
+
+### 理解错误
+
+把堆栈跟踪直接粘贴到提示词中，并配上 `@` 文件引用，这样 Copilot CLI 就能把错误映射到源代码。
+
+```bash
+copilot
+
+> 我遇到了这个错误：
+> AttributeError: 'NoneType' object has no attribute 'title'
+> at show_books (book_app.py:19)
+>
+> @samples/book-app-project/book_app.py 解释原因并告诉我如何修复
+```
+
+### 用测试用例调试
+
+描述准确的输入和观察到的输出，为 Copilot CLI 提供一个具体且可复现的测试用例，便于它推理。
+
+```bash
+copilot
+
+> @samples/book-app-buggy/books_buggy.py remove_book 函数有个 bug。当我尝试删除 "Dune" 时，
+> 它连 "Dune Messiah" 也一起删掉了。请调试这个问题：解释根因并给出修复方案。
+```
+
+### 沿着代码追踪问题
+
+引用多个文件，让 Copilot CLI 跨文件跟踪数据流，定位问题最初出现的位置。
+
+```bash
+copilot
+
+> 用户反馈图书列表编号从 0 开始，而不是 1。
+> @samples/book-app-buggy/book_app_buggy.py @samples/book-app-buggy/books_buggy.py
+> 沿着列表显示流程追踪，找出问题发生的位置
+```
+
+### 理解数据问题
+
+把数据文件和读取它的代码一起提供给 Copilot CLI，这样它在建议错误处理改进方案时才能看到完整上下文。
+
+```bash
+copilot
+
+> @samples/book-app-project/data.json @samples/book-app-project/books.py
+> JSON 文件有时会损坏，导致应用崩溃。我们应该如何优雅地处理这种情况？
+```
+
+🎬 查看实际演示！
+ + + +*演示输出会有所不同。你的模型、工具和响应不会与这里展示的内容完全一致。* + +
+
+
+> **先试试这个：** `@samples/book-app-project/books.py 为所有函数生成 pytest 测试，并覆盖边界情况`
+
+### “测试爆炸”——2 个测试 vs 15+ 个测试
+
+手动编写测试时，开发者通常只会写 2-3 个基础测试：
+- 测试有效输入
+- 测试无效输入
+- 测试一个边界情况
+
+看看当你要求 Copilot CLI 生成全面测试时会发生什么！这个提示词使用了结构化项目符号列表，并搭配 `@` 文件引用，帮助 Copilot CLI 生成充分的测试覆盖：
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py 生成全面的 pytest 测试。请覆盖：
+> - 添加图书
+> - 删除图书
+> - 按标题查找
+> - 按作者查找
+> - 标记为已读
+> - 空数据的边界情况
+```
+
+---
+
+
+
+---
+
+
+工作流 4：测试生成 - 自动生成全面测试和边界情况
+ +
+
+> **先试试这个：** `@samples/book-app-project/books.py 为所有函数生成 pytest 测试，并覆盖边界情况`
+
+### “测试爆炸”——2 个测试 vs 15+ 个测试
+
+手动编写测试时，开发者通常只会写 2-3 个基础测试：
+- 测试有效输入
+- 测试无效输入
+- 测试一个边界情况
+
+看看当你要求 Copilot CLI 生成全面测试时会发生什么！这个提示词使用了结构化项目符号列表，并搭配 `@` 文件引用，帮助 Copilot CLI 生成充分的测试覆盖：
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py 生成全面的 pytest 测试。请覆盖：
+> - 添加图书
+> - 删除图书
+> - 按标题查找
+> - 按作者查找
+> - 标记为已读
+> - 空数据的边界情况
+```
+
+---
+
+
+
+
+---
+
+**你会得到什么**：15+ 个全面测试，包括：
+
+```python
+class TestBookCollection:
+ # 主流程
+ def test_add_book_creates_new_book(self):
+ ...
+ def test_list_books_returns_all_books(self):
+ ...
+
+ # 查找操作
+ def test_find_book_by_title_case_insensitive(self):
+ ...
+ def test_find_book_by_title_returns_none_when_not_found(self):
+ ...
+ def test_find_by_author_partial_match(self):
+ ...
+ def test_find_by_author_case_insensitive(self):
+ ...
+
+ # 边界情况
+ def test_add_book_with_empty_title(self):
+ ...
+ def test_remove_nonexistent_book(self):
+ ...
+ def test_mark_as_read_nonexistent_book(self):
+ ...
+
+ # 数据持久化
+ def test_save_books_persists_to_json(self):
+ ...
+ def test_load_books_handles_missing_file(self):
+ ...
+ def test_load_books_handles_corrupted_json(self):
+ ...
+
+ # 特殊字符
+ def test_add_book_with_unicode_characters(self):
+ ...
+ def test_find_by_author_with_special_characters(self):
+ ...
+```
+
+**结果**：30 秒内，你就能拿到那些原本可能要花一小时才想清并写出来的边界情况测试。
+
+---
+
+### 单元测试
+
+把目标收窄到单个函数，并列出你想覆盖的输入类别，这样 Copilot CLI 就会生成聚焦而全面的单元测试。
+
+```bash
+copilot
+
+> @samples/book-app-project/utils.py 为 get_book_details 生成全面的 pytest 测试，覆盖：
+> - 有效输入
+> - 空字符串
+> - 非法年份格式
+> - 非常长的标题
+> - 作者名中的特殊字符
+```
+
+### 运行测试
+
+用自然语言向 Copilot CLI 询问你的工具链。它可以为你生成正确的 shell 命令。
+
+```bash
+copilot
+
+> 我该如何运行测试？请给我 pytest 命令。
+
+# Copilot CLI 会回答：
+# cd samples/book-app-project && python -m pytest tests/
+# 或者查看详细输出：python -m pytest tests/ -v
+# 如果想看到 print 语句：python -m pytest tests/ -s
+```
+
+### 针对特定场景测试
+
+列出你希望覆盖的高级或棘手场景，这样 Copilot CLI 就不会只停留在主流程。
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py 为这些场景生成测试：
+> - 添加重复图书（标题和作者都相同）
+> - 通过标题部分匹配删除图书
+> - 图书集合为空时查找图书
+> - 保存时出现文件权限错误
+> - 对图书集合的并发访问
+```
+
+### 向现有文件补充测试
+
+请求为单个函数生成*额外*测试，这样 Copilot CLI 会在你已有测试基础上补充新的用例。
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py
+> 为 find_by_author 函数生成额外测试，覆盖这些边界情况：
+> - 带连字符的作者名（例如 "Jean-Paul Sartre"）
+> - 具有多个名字的作者
+> - 作者名为空字符串
+> - 带重音字符的作者名
+```
+
+🎬 查看实际演示！
+ + + +*演示输出会有所不同。你的模型、工具和响应不会与这里展示的内容完全一致。* + +
+
+
+> 💡 **这个工作流默认你已经熟悉基本的 git 操作**（暂存、提交、分支）。如果 git 对你来说还是新内容，建议先学习前四个工作流。
+
+### 生成提交信息
+
+> **先试试这个：** `copilot -p "为以下改动生成一条 Conventional Commit 格式的提交信息：$(git diff --staged)"` —— 先暂存一些改动，再运行它，看看 Copilot CLI 如何帮你写提交信息。
+
+这个示例使用 `-p` 内联提示参数，再配合 shell 命令替换，把 `git diff` 输出直接传给 Copilot CLI，一次性生成提交信息。`$(...)` 语法会运行括号中的命令，并把结果插入外层命令中。
+
+```bash
+
+# 看看改了什么
+git diff --staged
+
+# 使用 [Conventional Commit](../GLOSSARY.md#conventional-commit) 格式生成提交信息
+# （结构化消息示例："feat(books): add search" 或 "fix(data): handle empty input"）
+copilot -p "为以下改动生成一条 Conventional Commit 格式的提交信息：$(git diff --staged)"
+
+# 输出："feat(books): 支持按作者名部分匹配搜索
+#
+# - 更新 find_by_author，使其支持部分匹配
+# - 添加不区分大小写的比较
+# - 改进按作者搜索时的用户体验"
+```
+
+---
+
+
+
+---
+
+
+## 快速提示：先研究，再规划或编码
+
+当你需要调研某个库、理解最佳实践，或探索一个陌生主题时，可以先用 `/research` 做一次深度研究，再开始写代码：
+
+```bash
+copilot
+
+> /research 在 CLI 应用中校验用户输入，Python 最好的库有哪些？
+```
+
+Copilot CLI 会搜索 GitHub 仓库和 Web 来源，然后返回带参考资料的摘要。当你准备开始一个新功能、想先做出更有依据的决策时，这非常有用。你还可以使用 `/share` 分享这些结果。
+
+> 💡 **提示**：`/research` 很适合用在 `/plan` *之前*。先研究方案，再规划实现。
+
+---
+
+
+## 综合实战：缺陷修复工作流
+
+下面是一套针对已报告缺陷的完整修复工作流：
+
+```bash
+
+# 1. 理解 bug 报告
+copilot
+
+> 用户反馈：'按作者名查找图书时，部分姓名匹配不起作用'
+> @samples/book-app-project/books.py 分析并找出最可能的原因
+
+# 2. 调试问题（继续在同一个会话中）
+> 基于上面的分析，给我看看 find_by_author 函数，并解释问题所在
+
+> 修复 find_by_author 函数，使其支持部分姓名匹配
+
+# 3. 为修复生成测试
+> @samples/book-app-project/books.py 专门为以下场景生成 pytest 测试：
+> - 作者全名匹配
+> - 作者名部分匹配
+> - 不区分大小写匹配
+> - 找不到作者名
+
+# 4. 生成提交信息
+copilot -p "为以下改动生成提交信息：$(git diff --staged)"
+
+# 输出："fix(books): 支持按作者名部分匹配搜索"
+```
+
+### 缺陷修复工作流摘要
+
+| 步骤 | 操作 | Copilot 命令 |
+|------|--------|-----------------|
+| 1 | 理解缺陷 | `> [描述 bug] @relevant-file.py 分析最可能的原因` |
+| 2 | 获取详细分析 | `> 给我看看这个函数，并解释问题所在` |
+| 3 | 实施修复 | `> 修复这个[具体问题]` |
+| 4 | 生成测试 | `> 为[具体场景]生成测试` |
+| 5 | 提交 | `copilot -p "为以下改动生成提交信息：$(git diff --staged)"` |
+
+---
+
+# 练习
+
+工作流 5：Git 集成 - 提交信息、PR 描述、/delegate 和 /diff
+ +
+
+> 💡 **这个工作流默认你已经熟悉基本的 git 操作**（暂存、提交、分支）。如果 git 对你来说还是新内容，建议先学习前四个工作流。
+
+### 生成提交信息
+
+> **先试试这个：** `copilot -p "为以下改动生成一条 Conventional Commit 格式的提交信息：$(git diff --staged)"` —— 先暂存一些改动，再运行它，看看 Copilot CLI 如何帮你写提交信息。
+
+这个示例使用 `-p` 内联提示参数，再配合 shell 命令替换，把 `git diff` 输出直接传给 Copilot CLI，一次性生成提交信息。`$(...)` 语法会运行括号中的命令，并把结果插入外层命令中。
+
+```bash
+
+# 看看改了什么
+git diff --staged
+
+# 使用 [Conventional Commit](../GLOSSARY.md#conventional-commit) 格式生成提交信息
+# （结构化消息示例："feat(books): add search" 或 "fix(data): handle empty input"）
+copilot -p "为以下改动生成一条 Conventional Commit 格式的提交信息：$(git diff --staged)"
+
+# 输出："feat(books): 支持按作者名部分匹配搜索
+#
+# - 更新 find_by_author，使其支持部分匹配
+# - 添加不区分大小写的比较
+# - 改进按作者搜索时的用户体验"
+```
+
+---
+
+
+
+
+---
+
+### 解释改动
+
+把 `git show` 的输出传给 `-p` 提示词，就能得到上一条提交的自然语言摘要。
+
+```bash
+# 这个提交改了什么？
+copilot -p "解释这个提交做了什么：$(git show HEAD --stat)"
+```
+
+### PR 描述
+
+将 `git log` 输出与结构化提示模板结合，就可以自动生成一份完整的 pull request 描述。
+
+```bash
+# 根据分支改动生成 PR 描述
+copilot -p "为这些改动生成 pull request 描述：
+$(git log main..HEAD --oneline)
+
+包含：
+- 改动摘要
+- 进行这些改动的原因
+- 已完成的测试
+- 是否有 breaking changes？（yes/no）"
+```
+
+### Push 前审查
+
+在 `-p` 提示词中使用 `git diff main..HEAD`，就可以在 push 之前快速对整条分支的改动做一次健全性检查。
+
+```bash
+# push 之前做最后检查
+copilot -p "在我 push 之前，帮我审查这些改动是否有问题：
+$(git diff main..HEAD)"
+```
+
+### 使用 /delegate 处理后台任务
+
+`/delegate` 命令会把工作交给 GitHub 上的 Copilot 编码智能体。使用 `/delegate` 斜杠命令（或 `&` 快捷前缀），可以把定义清晰的任务交给后台智能体。
+
+```bash
+copilot
+
+> /delegate 为登录表单添加输入校验
+
+# 或者使用 & 前缀快捷方式：
+> & 修复 README 标题中的拼写错误
+
+# Copilot CLI：
+# 1. 把你的改动提交到一个新分支
+# 2. 打开一个 draft pull request
+# 3. 在 GitHub 后台继续处理
+# 4. 完成后请求你审查
+```
+
+这非常适合那些边界清晰、你希望在自己处理其他工作时让它后台完成的任务。
+
+### 使用 /diff 审查本次会话改动
+
+`/diff` 命令会显示你当前会话中产生的所有改动。用这个斜杠命令，可以在提交前先查看 Copilot CLI 修改过的全部内容的可视化 diff。
+
+```bash
+copilot
+
+# 做了一些修改之后……
+> /diff
+
+# 显示本次会话中所有被修改文件的可视化 diff
+# 很适合在提交前做审查
+```
+
+🎬 查看实际演示！
+ + + +*演示输出会有所不同。你的模型、工具和响应不会与这里展示的内容完全一致。* + +
+
+现在轮到你来应用这些工作流了。
+
+---
+
+## ▶️ 自己试一试
+
+完成演示后，再尝试下面这些变化版练习：
+
+1. **Bug Detective 挑战**：让 Copilot CLI 调试 `samples/book-app-buggy/books_buggy.py` 中的 `mark_as_read` 函数。它是否解释了为什么这个函数会把**所有**图书都标记为已读，而不是只标记一本？
+
+2. **测试挑战**：为图书应用中的 `add_book` 函数生成测试。数一数 Copilot CLI 覆盖了多少你自己未必会想到的边界情况。
+
+3. **提交信息挑战**：对图书应用中的任意文件做一个小改动，暂存它（`git add .`），然后运行：
+ ```bash
+ copilot -p "为以下改动生成一条 Conventional Commit 格式的提交信息：$(git diff --staged)"
+ ```
+ 它生成的信息，是否比你匆忙写出来的更好？
+
+**自我检查**：如果你能解释为什么“调试这个 bug”比“找 bug”更强大（上下文很重要！），那就说明你已经理解了开发工作流的核心。
+
+---
+
+## 📝 作业
+
+### 主挑战：重构、测试并交付
+
+前面的动手示例主要聚焦于 `find_book_by_title` 和代码审查。现在，请把同样的工作流技能应用到 `book-app-project` 中的其他函数上：
+
+1. **审查**：让 Copilot CLI 审查 `books.py` 中的 `remove_book()` 是否存在边界情况和潜在问题：
+ `@samples/book-app-project/books.py 审查 remove_book() 函数。如果标题只部分匹配另一本书（例如 "Dune" vs "Dune Messiah"），会发生什么？有没有未处理的边界情况？`
+2. **重构**：让 Copilot CLI 改进 `remove_book()`，使其能处理不区分大小写匹配，以及在找不到图书时返回有用反馈
+3. **测试**：专门为改进后的 `remove_book()` 生成 pytest 测试，覆盖：
+ - 删除存在的图书
+ - 不区分大小写的标题匹配
+ - 找不到图书时返回合适反馈
+ - 从空集合中删除
+4. **审查**：暂存你的改动，并运行 `/review` 检查是否还有遗漏问题
+5. **提交**：生成一条 Conventional Commit 格式的提交信息：
+ `copilot -p "为以下改动生成一条 Conventional Commit 格式的提交信息：$(git diff --staged)"`
+
+
+
+
+### 额外挑战：使用 Copilot CLI 创建一个应用
+
+> 💡 **注意**：这个 GitHub Skills 练习使用的是 **Node.js**，而不是 Python。不过，你在这里练习的 GitHub Copilot CLI 技巧——创建 issue、生成代码、在终端中协作——适用于任何语言。
+
+这个练习会向开发者展示如何在构建一个 Node.js 计算器应用时，使用 GitHub Copilot CLI 从终端创建 issue、生成代码并开展协作。你会安装 CLI、使用模板和 AI 智能体，并练习迭代式、命令行驱动的开发方式。
+
+##### 💡 提示（点击展开）
+ +**每一步都可以使用的示例提示词：** + +```bash +copilot + +# 第 1 步：审查 +> @samples/book-app-project/books.py 审查 remove_book() 函数。有哪些边界情况还没有处理？ + +# 第 2 步：重构 +> 改进 remove_book()，使用不区分大小写的匹配，并在找不到图书时返回清晰消息。请向我展示修改前后的代码。 + +# 第 3 步：测试 +> 为改进后的 remove_book() 函数生成 pytest 测试，覆盖： +> - 删除存在的图书 +> - 不区分大小写匹配（"dune" 应该删除 "Dune"） +> - 找不到图书时返回合适响应 +> - 从空集合中删除 + +# 第 4 步：审查 +> /review + +# 第 5 步：提交 +> 为这次重构生成一条 Conventional Commit 格式的提交信息 +``` + +**提示：** 在改进 `remove_book()` 之后，不妨再问 Copilot CLI：“这个文件里还有哪些函数也可以从同样的改进中受益？” 它可能会建议你对 `find_book_by_title()` 或 `find_by_author()` 做类似改动。 + +
[开始“使用 Copilot CLI 创建应用程序”技能练习](https://github.com/skills/create-applications-with-the-copilot-cli)
+
+---
+
+
+
+
+---
+
+# 总结
+
+## 🔑 关键要点
+
+🔧 常见错误与故障排查（点击展开）
+ +### 常见错误 + +| 错误 | 会发生什么 | 修复方法 | +|---------|--------------|-----| +| 使用模糊提示词，比如 “审查这段代码” | 得到很泛的反馈，错过具体问题 | 更具体一些：例如 “审查 SQL 注入、XSS 和认证问题” | +| 做代码审查时不用 `/review` | 错过专门优化过的代码审查智能体 | 使用 `/review`，它专为高信噪比输出而调优 | +| 没有上下文就要求“找 bug” | Copilot CLI 不知道你遇到的到底是什么 bug | 先描述症状：例如 “用户反馈在 Y 场景下会出现 X” | +| 生成测试时不指定框架 | 生成的测试可能使用错误语法或断言库 | 明确说明：例如 “使用 Jest 生成测试” 或 “使用 pytest” | + +### 故障排查 + +**审查结果看起来不完整** —— 更具体地说明它应该检查什么： + +```bash +copilot + +# 不要这样： +> 审查 @samples/book-app-project/book_app.py + +# 试试这样： +> 审查 @samples/book-app-project/book_app.py 的输入校验、错误处理和边界情况 +``` + +**测试与我的框架不匹配** —— 明确指定框架： + +```bash +copilot + +> @samples/book-app-project/books.py 使用 pytest 生成测试（不要用 unittest） +``` + +**重构改变了行为** —— 提醒 Copilot CLI 必须保持行为不变： + +```bash +copilot + +> @samples/book-app-project/book_app.py 将命令处理重构为字典分发。重要：保持对外行为完全一致——不要引入破坏性变更 +``` + +
+
+1. 使用具体提示词时，**代码审查**会更加全面
+2. 先生成测试，再做**重构**会更安全
+3. **调试**时，把错误和代码一起展示给 Copilot CLI 会更有效
+4. **测试生成**应该覆盖边界情况和错误场景
+5. **Git 集成**可以自动化提交信息和 PR 描述
+
+> 📋 **快速参考**：查看 [GitHub Copilot CLI 命令参考](https://docs.github.com/en/copilot/reference/cli-command-reference)，获取完整的命令和快捷键列表。
+
+---
+
+## ✅ 检查点：你已经掌握核心基础
+
+**恭喜！** 现在你已经具备了高效使用 GitHub Copilot CLI 所需的核心技能：
+
+| 技能 | 章节 | 你现在可以…… |
+|-------|---------|----------------|
+| 基础命令 | 第 01 章 | 使用交互模式、计划模式、程序化模式（`-p`）和斜杠命令 |
+| 上下文 | 第 02 章 | 用 `@` 引用文件、管理会话、理解上下文窗口 |
+| 工作流 | 第 03 章 | 审查代码、重构、调试、生成测试，并与 git 集成 |
+
+第 04-06 章会介绍更多功能，它们会让 Copilot CLI 更加强大，也很值得继续学习。
+
+---
+
+## 🛠️ 构建你的个人工作流
+
+使用 GitHub Copilot CLI 并不存在唯一“正确”的方式。下面是一些帮助你逐渐形成自己模式的小建议：
+
+> 📚 **官方文档**：[Copilot CLI 最佳实践](https://docs.github.com/copilot/how-tos/copilot-cli/cli-best-practices) 提供了 GitHub 推荐的工作流和技巧。
+
+- **对稍复杂的任务，先从 `/plan` 开始。** 在执行前先打磨计划——好的计划往往能带来更好的结果。
+- **把效果好的提示词保存下来。** 当 Copilot CLI 出错时，记下问题出在哪里。时间久了，这会成为你自己的实践手册。
+- **大胆尝试。** 有些开发者偏好又长又细的提示词，也有人更喜欢简短提示配合追问。多试几种方法，留意哪种最适合你。
+
+> 💡 **接下来会学到**：在第 04 章和第 05 章中，你会学习如何把自己的最佳实践固化为自动加载的自定义指令和技能。
+
+---
+
+## ➡️ 接下来是什么
+
+剩余章节会介绍更多可以扩展 Copilot CLI 能力的功能：
+
+| 章节 | 涵盖内容 | 你会在什么时候需要它 |
+|---------|----------------|---------------------|
+| 第 04 章：智能体 | 创建专门的 AI 智能体 | 当你需要领域专家（前端、安全）时 |
+| 第 05 章：技能 | 为任务自动加载指令 | 当你经常重复相同提示词时 |
+| 第 06 章：MCP 服务器 | 连接外部服务 | 当你需要来自 GitHub、数据库等的实时数据时 |
+
+**建议**：先用一周时间练习这些核心工作流，等你出现具体需求时，再回来学习第 04-06 章。
+
+---
+
+## 继续学习更多主题
+
+在 **[第 04 章：智能体与自定义指令](../04-agents-custom-instructions/README.zh.md)** 中，你将学习：
+
+- 使用内置智能体（`/plan`、`/review`）
+- 通过 `.agent.md` 文件创建专门的智能体（前端专家、安全审计员）
+- 多智能体协作模式
+- 用于项目规范的自定义指令文件
+
+---
+
+**[← 返回第 02 章](../02-context-conversations/README.zh.md)** | **[继续阅读第 04 章 →](../04-agents-custom-instructions/README.zh.md)**
diff --git a/04-agents-custom-instructions/README.zh.md b/04-agents-custom-instructions/README.zh.md
new file mode 100644
index 00000000..0513ee24
--- /dev/null
+++ b/04-agents-custom-instructions/README.zh.md
@@ -0,0 +1,785 @@
+
+
+> **如果你能在一个工具里同时“雇用”一位 Python 代码审查员、测试专家和安全审查员，会怎样？**
+
+在第 03 章中，你已经掌握了核心工作流：代码审查、重构、调试、生成测试，以及 git 集成。这些能力会让你在使用 GitHub Copilot CLI 时效率大幅提升。现在，我们继续进阶。
+
+到目前为止，你一直把 Copilot CLI 当作通用助手来使用。而智能体可以让它拥有特定“角色”，并自带一套标准。例如，一个代码审查智能体会默认关注类型提示和 PEP 8；一个测试助手智能体会默认按 pytest 的方式来编写测试。你将看到：同样的提示，交给带有针对性指令的智能体处理，结果会明显更好。
+
+## 🎯 学习目标
+
+学完本章后，你将能够：
+
+- 使用内置智能体：Plan（`/plan`）、Code-review（`/review`），并理解自动智能体（Explore、Task）
+- 使用智能体文件（`.agent.md`）创建专门化智能体
+- 将智能体用于特定领域任务
+- 使用 `/agent` 和 `--agent` 在不同智能体之间切换
+- 编写自定义指令文件来承载项目专属规范
+
+> ⏱️ **预计用时**：约 55 分钟（20 分钟阅读 + 35 分钟动手实践）
+
+---
+
+## 🧩 现实类比：雇用专业人士
+
+当你需要修缮房屋时，不会只找一个“全能帮手”，而是会找不同的专业人员：
+
+| 问题 | 专业人士 | 原因 |
+|---------|------------|-----|
+| 水管漏水 | 水管工 | 熟悉管道规范，也有专用工具 |
+| 线路改造 | 电工 | 理解安全要求，施工符合规范 |
+| 更换屋顶 | 屋顶工 | 了解材料，也考虑本地气候条件 |
+
+智能体也是同样的道理。与其使用一个泛泛的 AI，不如使用专注于特定任务、并知道该遵循什么流程的智能体。你只需把指令配置一次，之后每次需要这类专长时都可以复用：代码审查、测试、安全、文档编写都可以。
+
+
+
+---
+
+# 使用智能体
+
+马上开始使用内置智能体和自定义智能体。
+
+---
+
+## *刚接触智能体？* 从这里开始！
+从没用过、也没创建过智能体？下面这些内容足够你开始完成本课程。
+
+1. **先马上试试一个*内置*智能体：**
+ ```bash
+ copilot
+ > /plan Add input validation for book year in the book app
+ ```
+ 这会调用 Plan 智能体，生成一个分步骤的实现计划。
+
+2. **看看我们的一个自定义智能体示例：** 定义智能体指令其实很简单，可以先看看我们提供的 [python-reviewer.agent.md](../.github/agents/python-reviewer.agent.md) 文件，了解基本模式。
+
+3. **理解核心概念：** 智能体就像是在咨询某个专家，而不是求助于通才。比如一个“前端智能体”会自动关注可访问性和组件模式，你不需要反复提醒，因为这些要求已经写在它的指令里了。
+
+
+## 内置智能体
+
+**其实你在第 03 章“开发工作流”里已经用过一些内置智能体了！**
+`/plan` 和 `/review` 本质上就是内置智能体。现在你知道它们背后是怎么工作的了。完整列表如下： + +| 智能体 | 调用方式 | 作用 | +|-------|---------------|--------------| +| **Plan** | `/plan` 或 `Shift+Tab`（循环切换模式） | 在编码前创建分步骤的实现计划 | +| **Code-review** | `/review` | 对已暂存/未暂存的更改进行聚焦且可执行的审查 | +| **Init** | `/init` | 生成项目配置文件（指令、智能体） | +| **Explore** | *自动* | 当你要求 Copilot 探索或分析代码库时，由内部自动使用 | +| **Task** | *自动* | 执行测试、构建、lint、依赖安装等命令 | + +
+ +**内置智能体实战**——调用 Plan、Code-review、Explore 和 Task 的示例 + +```bash +copilot + +# Invoke the Plan agent to create an implementation plan +> /plan Add input validation for book year in the book app + +# Invoke the Code-review agent on your changes +> /review + +# Explore and Task agents are invoked automatically when relevant: +> Run the test suite # Uses Task agent + +> Explore how book data is loaded # Uses Explore agent +``` + +那 Task 智能体呢？它会在幕后负责管理和跟踪当前发生的事情，并以清晰、简洁的格式返回结果： + +| 结果 | 你会看到什么 | +|---------|--------------| +| ✅ **成功** | 简短摘要（例如 “All 247 tests passed”“Build succeeded”） | +| ❌ **失败** | 完整输出，包括堆栈跟踪、编译错误和详细日志 | + + +> 📚 **官方文档**：[GitHub Copilot CLI Agents](https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli#use-custom-agents) + +--- + +# 将智能体加入 Copilot CLI + +你完全可以定义自己的智能体，把它们纳入工作流！定义一次，后续直接调用。 + +
+
+
+## 🗂️ 添加你的智能体
+
+智能体文件是扩展名为 `.agent.md` 的 Markdown 文件。它由两部分组成：YAML frontmatter（元数据）和 Markdown 指令。
+
+> 💡 **还不熟悉 YAML frontmatter？** 它就是文件顶部一小段由 `---` 包围的设置块。YAML 本质上就是 `key: value` 键值对。文件剩下的部分仍然是普通 Markdown。
+
+下面是一个最小示例智能体：
+
+```markdown
+---
+name: my-reviewer
+description: Code reviewer focused on bugs and security issues
+---
+
+# Code Reviewer
+
+You are a code reviewer focused on finding bugs and security issues.
+
+When reviewing code, always check for:
+- SQL injection vulnerabilities
+- Missing error handling
+- Hardcoded secrets
+```
+
+> 💡 **必填项与可选项**：`description` 字段是必填的。`name`、`tools`、`model` 等其他字段则是可选的。
+
+
+## 智能体文件放在哪里
+
+| 位置 | 作用范围 | 最适合 |
+|----------|-------|----------|
+| `.github/agents/` | 项目级 | 团队共享、带有项目约定的智能体 |
+| `~/.copilot/agents/` | 全局（所有项目） | 你在各处都会用到的个人智能体 |
+
+**这个项目在 [.github/agents/](../.github/agents/) 文件夹中已经包含了一些示例智能体文件**。你可以自己写，也可以基于我们已提供的内容做定制。
+
+
+
+
+
+## 🚀 使用自定义智能体的两种方式
+
+### 交互模式
+在交互模式中，使用 `/agent` 列出智能体，然后选择你要开始协作的智能体。
+选中后，接下来的对话就会由该智能体继续处理。
+
+```bash
+copilot
+> /agent
+```
+
+如果要切换到别的智能体，或者返回默认模式，再次使用 `/agent` 即可。
+
+### 编程式模式
+
+直接用某个智能体启动一个新会话。
+
+```bash
+copilot --agent python-reviewer
+> Review @samples/book-app-project/books.py
+```
+
+> 💡 **切换智能体**：你随时都可以再次使用 `/agent` 或 `--agent` 切换到其他智能体。若要回到标准的 Copilot CLI 体验，使用 `/agent` 并选择 **no agent**。
+
+---
+
+# 深入理解智能体
+
+📂 查看本课程中的示例智能体
+ +| 文件 | 说明 | +|------|-------------| +| `hello-world.agent.md` | 最小示例——建议从这里开始 | +| `python-reviewer.agent.md` | Python 代码质量审查员 | +| `pytest-helper.agent.md` | Pytest 测试专家 | + +```bash +# Or copy one to your personal agents folder (available in every project) +cp .github/agents/python-reviewer.agent.md ~/.copilot/agents/ +``` + +想找更多社区智能体，可以查看 [github/awesome-copilot](https://github.com/github/awesome-copilot)。 + +
+
+> 💡 **这一节是可选的。** 内置智能体（`/plan`、`/review`）已经足够覆盖大多数工作流。只有当你需要在工作中持续应用某种专门化能力时，才有必要创建自定义智能体。
+
+下面每个主题都是相对独立的。**挑你感兴趣的读即可，不必一次全部看完。**
+
+| 我想…… | 跳转到 |
+|---|---|
+| 看看为什么智能体比通用提示更强 | [专家 vs 通用型](#specialist-vs-generic-see-the-difference) |
+| 在一个功能上组合多个智能体 | [与多个智能体协作](#working-with-multiple-agents) |
+| 组织、命名并共享智能体 | [组织与共享智能体](#organizing--sharing-agents) |
+| 设置始终生效的项目上下文 | [为 Copilot 配置项目](#configuring-your-project-for-copilot) |
+| 查询 YAML 属性和工具 | [智能体文件参考](#agent-file-reference) |
+
+选择下方任一场景展开阅读。
+
+---
+
+
+
+
+
+---
+
+
+专家 vs 通用型：看看区别——为什么智能体产出的结果比通用提示更好
+ +## 专家 vs 通用型：看看区别 + +这正是智能体价值体现出来的地方。看看区别： + +### 不使用智能体（通用 Copilot） + +```bash +copilot + +> Add a function to search books by year range in the book app +``` + +**通用输出**： +```python +def search_by_year_range(books, start_year, end_year): + results = [] + for book in books: + if book['year'] >= start_year and book['year'] <= end_year: + results.append(book) + return results +``` + +很基础，能用，但缺了很多东西。 + +--- + +### 使用 Python Reviewer 智能体 + +```bash +copilot + +> /agent +# Select "python-reviewer" + +> Add a function to search books by year range in the book app +``` + +**专家输出**： +```python +from typing import List, Dict, Any + +def search_by_year_range( + books: List[Dict[str, Any]], + start_year: int, + end_year: int +) -> List[Dict[str, Any]]: + """ + Search for books within a specified year range. + + Args: + books: List of book dictionaries + start_year: Starting year (inclusive) + end_year: Ending year (inclusive) + + Returns: + List of books published within the year range + + Raises: + ValueError: If start_year is greater than end_year + TypeError: If year values are not integers + """ + if not isinstance(start_year, int) or not isinstance(end_year, int): + raise TypeError("Year values must be integers") + + if start_year > end_year: + raise ValueError(f"Start year ({start_year}) cannot be greater than end year ({end_year})") + + return [ + book for book in books + if isinstance(book.get('year'), int) + and start_year <= book['year'] <= end_year + ] +``` + +**python-reviewer 智能体会自动包含的内容**： +- ✅ 所有参数和返回值都带有类型提示 +- ✅ 完整的 docstring，包含 Args/Returns/Raises +- ✅ 带有恰当错误处理的输入校验 +- ✅ 使用列表推导提升性能 +- ✅ 处理边界情况（缺失/无效年份值） +- ✅ 符合 PEP 8 的格式 +- ✅ 防御式编程实践 + +**差别在哪里**：同样的提示，输出质量却明显更高。智能体带来了那些你平时容易忘记要求的专业能力。 + +
+
+
+---
+
+
+与多个智能体协作——组合专家、中途切换、把智能体当作工具
+ +## 与多个智能体协作 + +真正的威力体现在：多个专家一起协作完成一个功能。 + +### 示例：构建一个简单功能 + +```bash +copilot + +> I want to add a "search by year range" feature to the book app + +# Use python-reviewer for design +> /agent +# Select "python-reviewer" + +> @samples/book-app-project/books.py Design a find_by_year_range method. What's the best approach? + +# Switch to pytest-helper for test design +> /agent +# Select "pytest-helper" + +> @samples/book-app-project/tests/test_books.py Design test cases for a find_by_year_range method. +> What edge cases should we cover? + +# Synthesize both designs +> Create an implementation plan that includes the method implementation and comprehensive tests. +``` + +**关键洞察**：你是那个统筹全局的架构师，负责指挥专家。专家处理细节，你把握方向。 + +
+
+
+### 把智能体当作工具
+
+当智能体配置好后，Copilot 在处理复杂任务时也可以把它们作为工具来调用。如果你让它完成一个全栈功能，Copilot 可能会自动把其中不同部分委派给合适的专门化智能体。
+
+🎬 看看实际效果！
+ + + +*演示输出会有所不同——你所使用的模型、工具和实际响应都可能与这里展示的不一致。* + +
+
+
+**先从简单开始：** 先在项目文件夹里创建一个 `*.agent.md` 文件。等你确认满意后，再把它移动到长期存放的位置。
+
+除了智能体文件，Copilot 还会自动读取**项目级指令文件**，不需要 `/agent`。关于 `AGENTS.md`、`.instructions.md` 和 `/init`，请参见下文的 [为 Copilot 配置项目](#configuring-your-project-for-copilot)。
+
+
+
+---
+
+
+组织与共享智能体——命名、文件放置、指令文件与团队共享
+ +## 组织与共享智能体 + +### 给智能体命名 + +创建智能体文件时，名称很重要。它决定了你在 `/agent` 或 `--agent` 后面要输入什么，也决定了你的队友会在智能体列表里看到什么。 + +| ✅ 好名字 | ❌ 避免使用 | +|--------------|----------| +| `frontend` | `my-agent` | +| `backend-api` | `agent1` | +| `security-reviewer` | `helper` | +| `react-specialist` | `code` | +| `python-backend` | `assistant` | + +**命名约定：** +- 使用小写加连字符：`my-agent-name.agent.md` +- 名称中体现领域：`frontend`、`backend`、`devops`、`security` +- 需要时尽量具体：例如 `react-typescript`，而不是笼统的 `frontend` + +--- + +### 与团队共享 + +把智能体文件放进 `.github/agents/` 后，它们就会被版本控制。推送到仓库后，团队中的每个人都会自动获得这些智能体。不过，智能体只是 Copilot 会读取的一类文件。它还支持**指令文件**，这些文件会在每次会话中自动生效，不需要任何人手动运行 `/agent`。 + +可以这样理解：智能体是你按需“叫来的专家”，而指令文件则是始终生效的团队规则。 + +### 文件应该放在哪里 + +你已经知道两个主要位置了（见上文的 [智能体文件放在哪里](#where-to-put-agent-files)）。可以参考下面这个决策思路来选择： + +
+
+**先从简单开始：** 先在项目文件夹里创建一个 `*.agent.md` 文件。等你确认满意后，再把它移动到长期存放的位置。
+
+除了智能体文件，Copilot 还会自动读取**项目级指令文件**，不需要 `/agent`。关于 `AGENTS.md`、`.instructions.md` 和 `/init`，请参见下文的 [为 Copilot 配置项目](#configuring-your-project-for-copilot)。
+
+
+
+
+---
+
+
+为 Copilot 配置项目——AGENTS.md、指令文件与 /init 初始化
+ +## 为 Copilot 配置项目 + +智能体是你按需调用的专家。**项目配置文件**则不同：Copilot 会在每次会话中自动读取它们，用来理解你项目的约定、技术栈和规则。没有人需要运行 `/agent`；这些上下文会始终对仓库中的所有协作者生效。 + +### 用 /init 快速开始 + +最省事的入门方式，是让 Copilot 直接为你生成配置文件： + +```bash +copilot +> /init +``` + +Copilot 会扫描你的项目，并创建有针对性的指令文件。之后你也可以自行修改。 + +### 指令文件格式 + +| 文件 | 作用范围 | 说明 | +|------|-------|-------| +| `AGENTS.md` | 项目根目录或嵌套目录 | **跨平台标准**——适用于 Copilot 和其他 AI 助手 | +| `.github/copilot-instructions.md` | 项目级 | GitHub Copilot 专用 | +| `.github/instructions/*.instructions.md` | 项目级 | 颗粒度更细、按主题拆分的指令 | +| `CLAUDE.md`, `GEMINI.md` | 项目根目录 | 为兼容性而支持 | + +> 🎯 **刚开始接触？** 先用 `AGENTS.md` 来承载项目指令即可。其他格式可以之后再按需了解。 + +### AGENTS.md + +`AGENTS.md` 是推荐格式。它是一个[开放标准](https://agents.md/)，可同时适用于 Copilot 和其他 AI 编码工具。把它放在仓库根目录后，Copilot 就会自动读取。本项目自己的 [AGENTS.md](../AGENTS.md) 就是一个可直接参考的示例。 + +一个典型的 `AGENTS.md` 会描述项目背景、代码风格、安全要求和测试标准。你可以用 `/init` 自动生成，也可以参考我们的示例文件手写一个。 + +### 自定义指令文件（`.instructions.md`） + +如果团队希望有更细粒度的控制方式，可以把指令拆分成按主题组织的多个文件。每个文件负责一个关注点，并会自动生效： + +``` +.github/ +└── instructions/ + ├── python-standards.instructions.md + ├── security-checklist.instructions.md + └── api-design.instructions.md +``` + +> 💡 **说明**：指令文件适用于任何语言。这里用 Python 只是为了配合我们的课程项目；如果你的团队使用 TypeScript、Go、Rust 或其他技术，也完全可以采用同样的做法。 + +**寻找社区指令文件**：你可以浏览 [github/awesome-copilot](https://github.com/github/awesome-copilot)，其中提供了适用于 .NET、Angular、Azure、Python、Docker 等多种技术的现成指令文件。 + +### 禁用自定义指令 + +如果你需要让 Copilot 忽略所有项目特定配置（这在调试或对比行为时很有用）： + +```bash +copilot --no-custom-instructions +``` + +
+
+
+---
+
+# 练习
+
+智能体文件参考——YAML 属性、工具别名与完整示例
+ +## 智能体文件参考 + +### 一个更完整的示例 + +你在前面已经看过了[最小智能体格式](#add-your-agents)。下面再看一个更完整的示例，它使用了 `tools` 属性。请创建 `~/.copilot/agents/python-reviewer.agent.md`： + +```markdown +--- +name: python-reviewer +description: Python code quality specialist for reviewing Python projects +tools: ["read", "edit", "search", "execute"] +--- + +# Python Code Reviewer + +You are a Python specialist focused on code quality and best practices. + +**Your focus areas:** +- Code quality (PEP 8, type hints, docstrings) +- Performance optimization (list comprehensions, generators) +- Error handling (proper exception handling) +- Maintainability (DRY principles, clear naming) + +**Code style requirements:** +- Use Python 3.10+ features (dataclasses, type hints, pattern matching) +- Follow PEP 8 naming conventions +- Use context managers for file I/O +- All functions must have type hints and docstrings + +**When reviewing code, always check:** +- Missing type hints on function signatures +- Mutable default arguments +- Proper error handling (no bare except) +- Input validation completeness +``` + +### YAML 属性 + +| 属性 | 必填 | 说明 | +|----------|----------|-------------| +| `name` | 否 | 显示名称（默认使用文件名） | +| `description` | **是** | 说明智能体做什么——帮助 Copilot 理解何时建议使用它 | +| `tools` | 否 | 允许使用的工具列表（省略则表示可用所有工具）。见下方工具别名。 | +| `target` | 否 | 限定仅用于 `vscode` 或 `github-copilot` | + +### 工具别名 + +在 `tools` 列表中使用以下名称： +- `read` - 读取文件内容 +- `edit` - 编辑文件 +- `search` - 搜索文件（grep/glob） +- `execute` - 运行 shell 命令（也可以写作：`shell`、`Bash`） +- `agent` - 调用其他自定义智能体 + +> 📖 **官方文档**：[Custom agents configuration](https://docs.github.com/copilot/reference/custom-agents-configuration) +> +> ⚠️ **仅限 VS Code**：`model` 属性（用于选择 AI 模型）在 VS Code 中可用，但 GitHub Copilot CLI 不支持。为了跨平台共用智能体文件，你依然可以安全地包含这个属性，GitHub Copilot CLI 会忽略它。 + +### 更多智能体模板 + +> 💡 **给初学者的说明**：下面这些示例是模板。**请把其中的具体技术替换成你项目真正使用的技术。** 重点在于智能体的*结构*，而不是示例里提到的具体技术栈。 + +本项目在 [.github/agents/](../.github/agents/) 文件夹中提供了可运行示例： +- [hello-world.agent.md](../.github/agents/hello-world.agent.md) - 最小示例，建议从这里开始 +- [python-reviewer.agent.md](../.github/agents/python-reviewer.agent.md) - Python 代码质量审查员 +- [pytest-helper.agent.md](../.github/agents/pytest-helper.agent.md) - Pytest 测试专家 + +社区智能体可参考 [github/awesome-copilot](https://github.com/github/awesome-copilot)。 + +
+
+创建你自己的智能体，并亲自体验它们的效果。
+
+---
+
+## ▶️ 动手试试看
+
+```bash
+
+# Create the agents directory (if it doesn't exist)
+mkdir -p .github/agents
+
+# Create a code reviewer agent
+cat > .github/agents/reviewer.agent.md << 'EOF'
+---
+name: reviewer
+description: Senior code reviewer focused on security and best practices
+---
+
+# Code Reviewer Agent
+
+You are a senior code reviewer focused on code quality.
+
+**Review priorities:**
+1. Security vulnerabilities
+2. Performance issues
+3. Maintainability concerns
+4. Best practice violations
+
+**Output format:**
+Provide issues as a numbered list with severity tags:
+[CRITICAL], [HIGH], [MEDIUM], [LOW]
+EOF
+
+# Create a documentation agent
+cat > .github/agents/documentor.agent.md << 'EOF'
+---
+name: documentor
+description: Technical writer for clear and complete documentation
+---
+
+# Documentation Agent
+
+You are a technical writer who creates clear documentation.
+
+**Documentation standards:**
+- Start with a one-sentence summary
+- Include usage examples
+- Document parameters and return values
+- Note any gotchas or limitations
+EOF
+
+# Now use them
+copilot --agent reviewer
+> Review @samples/book-app-project/books.py
+
+# Or switch agents
+copilot
+> /agent
+# Select "documentor"
+> Document @samples/book-app-project/books.py
+```
+
+---
+
+## 📝 作业
+
+### 主要挑战：打造一支专门化智能体小队
+
+前面的动手示例创建了 `reviewer` 和 `documentor` 两个智能体。现在，请练习为另一类任务创建并使用智能体——改进 book app 中的数据校验：
+
+1. 创建 3 个为 book app 量身定制的智能体文件（`.agent.md`），每个智能体一个文件，放在 `.github/agents/` 中
+2. 你的智能体应包括：
+ - **data-validator**：检查 `data.json` 中是否有缺失或格式错误的数据（作者为空、`year=0`、字段缺失）
+ - **error-handler**：审查 Python 代码中的错误处理是否一致，并提出统一方案
+ - **doc-writer**：生成或更新 docstring 和 README 内容
+3. 在 book app 上分别使用这些智能体：
+ - `data-validator` → 审计 `@samples/book-app-project/data.json`
+ - `error-handler` → 审查 `@samples/book-app-project/books.py` 和 `@samples/book-app-project/utils.py`
+ - `doc-writer` → 为 `@samples/book-app-project/books.py` 添加 docstring
+4. 协作使用：先让 `error-handler` 找出错误处理缺口，再让 `doc-writer` 记录改进后的方案
+
+**成功标准**：你拥有 3 个可用的智能体，它们能够稳定产出高质量结果，而且你可以通过 `/agent` 在它们之间切换。
+
+
+
+
+### 进阶挑战：指令库
+
+你已经构建了按需调用的智能体。现在试试另一个方向：**指令文件**。它们会在每次会话中被 Copilot 自动读取，不需要 `/agent`。
+
+创建一个 `.github/instructions/` 文件夹，并至少添加 3 个指令文件：
+- `python-style.instructions.md`，用于强制执行 PEP 8 和类型提示约定
+- `test-standards.instructions.md`，用于在测试文件中强制执行 pytest 约定
+- `data-quality.instructions.md`，用于校验 JSON 数据条目
+
+在 book app 代码上测试每个指令文件。
+
+---
+
+💡 提示（点击展开）
+ +**起步模板**：在 `.github/agents/` 中为每个智能体创建一个文件： + +`data-validator.agent.md`: +```markdown +--- +description: Analyzes JSON data files for missing or malformed entries +--- + +You analyze JSON data files for missing or malformed entries. + +**Focus areas:** +- Empty or missing author fields +- Invalid years (year=0, future years, negative years) +- Missing required fields (title, author, year, read) +- Duplicate entries +``` + +`error-handler.agent.md`: +```markdown +--- +description: Reviews Python code for error handling consistency +--- + +You review Python code for error handling consistency. + +**Standards:** +- No bare except clauses +- Use custom exceptions where appropriate +- All file operations use context managers +- Consistent return types for success/failure +``` + +`doc-writer.agent.md`: +```markdown +--- +description: Technical writer for clear Python documentation +--- + +You are a technical writer who creates clear Python documentation. + +**Standards:** +- Google-style docstrings +- Include parameter types and return values +- Add usage examples for public methods +- Note any exceptions raised +``` + +**测试你的智能体：** + +> 💡 **注意：** 你本地这份仓库副本里应该已经有 `samples/book-app-project/data.json`。如果缺失，请从源仓库下载原始版本： +> [data.json](https://github.com/github/copilot-cli-for-beginners/blob/main/samples/book-app-project/data.json) + +```bash +copilot +> /agent +# Select "data-validator" from the list +> @samples/book-app-project/data.json Check for books with empty author fields or invalid years +``` + +**提示：** YAML frontmatter 中的 `description` 字段是智能体生效所必需的。 + +
+
+
+---
+
+# 总结
+
+## 🔑 关键要点
+
+1. **内置智能体**：`/plan` 和 `/review` 可直接调用；Explore 与 Task 会自动工作
+2. **自定义智能体**是定义在 `.agent.md` 文件中的专门化角色
+3. **好的智能体**具备清晰的专长、标准和输出格式
+4. **多智能体协作**可以通过组合不同专长来解决复杂问题
+5. **指令文件**（`.instructions.md`）用于编码团队标准，并自动应用
+6. **一致的输出**来自定义良好的智能体指令
+
+> 📋 **快速参考**：完整命令与快捷方式列表，请参见 [GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference)。
+
+---
+
+## ➡️ 下一步
+
+智能体改变的是 *Copilot 在你的代码中如何思考、如何采取有针对性的行动*。接下来，你将学习**技能**——它们改变的是 Copilot *会遵循哪些步骤*。如果你正好想弄清楚智能体和技能有什么区别，第 05 章会正面回答这个问题。
+
+在 **[第 05 章：技能系统](../05-skills/README.zh.md)** 中，你将学习：
+
+- 技能如何根据你的提示自动触发（不需要 slash command）
+- 如何安装社区技能
+- 如何使用 SKILL.md 文件创建自定义技能
+- 智能体、技能和 MCP 的区别
+- 什么时候该使用哪一种
+
+---
+
+**[← 返回第 03 章](../03-development-workflows/README.zh.md)** | **[继续阅读第 05 章 →](../05-skills/README.zh.md)**
diff --git a/05-skills/README.zh.md b/05-skills/README.zh.md
new file mode 100644
index 00000000..a3971b6c
--- /dev/null
+++ b/05-skills/README.zh.md
@@ -0,0 +1,864 @@
+
+
+> **如果 Copilot 能自动套用你们团队的最佳实践，而你不必每次都重新解释，会怎样？**
+
+在本章中，你将学习什么是 Agent Skills：这是一种指令文件夹，当它与当前任务相关时，Copilot 会自动加载。智能体改变的是 Copilot *如何思考*，而技能教会 Copilot *用哪些特定方式完成任务*。你会创建一个安全审计技能，让 Copilot 在你询问安全问题时自动应用它；构建符合团队标准的审查准则，确保代码质量保持一致；并理解技能如何在 Copilot CLI、VS Code 和 Copilot coding agent 中协同工作。
+
+
+## 🎯 学习目标
+
+学完本章后，你将能够：
+
+- 理解技能如何工作，以及什么时候该用技能
+- 使用 SKILL.md 文件创建自定义技能
+- 使用来自共享仓库的社区技能
+- 知道什么时候该用技能、智能体或 MCP
+
+> ⏱️ **预计用时**：约 55 分钟（20 分钟阅读 + 35 分钟动手实践）
+
+---
+
+## 🧩 现实类比：电动工具的附件
+
+一把通用电钻已经很有用，但装上专用附件后，它会更强大。
+🔧 常见错误与排查（点击展开）
+ +### 常见错误 + +| 错误 | 会发生什么 | 修复方式 | +|---------|--------------|-----| +| 智能体 frontmatter 中缺少 `description` | 智能体无法加载，或无法被发现 | 一定要在 YAML frontmatter 中包含 `description:` | +| 智能体文件位置不对 | 使用时找不到智能体 | 放到 `~/.copilot/agents/`（个人）或 `.github/agents/`（项目）中 | +| 使用 `.md` 而不是 `.agent.md` | 文件可能不会被识别为智能体 | 文件名应类似 `python-reviewer.agent.md` | +| 智能体提示过长 | 可能触及 30,000 字符限制 | 保持智能体定义聚焦；详细指令更适合放进技能 | + +### 排查方法 + +**找不到智能体**——检查智能体文件是否存在于以下任一位置： +- `~/.copilot/agents/` +- `.github/agents/` + +列出可用智能体： + +```bash +copilot +> /agent +# Shows all available agents +``` + +**智能体没有按预期执行指令**——在提示中表达得更明确，并在智能体定义中补充更多细节： +- 带版本号的具体框架/库 +- 团队约定 +- 示例代码模式 + +**自定义指令未加载**——在项目中运行 `/init`，建立项目专属指令： + +```bash +copilot +> /init +``` + +或者检查它们是否被禁用了： +```bash +# Don't use --no-custom-instructions if you want them loaded +copilot # This loads custom instructions by default +``` + +
+
+
+技能也是一样。就像为了不同工作更换不同钻头一样，你也可以为 Copilot 添加不同技能来处理不同任务：
+
+| 技能附件 | 用途 |
+|------------|---------|
+| `commit` | 生成风格一致的提交信息 |
+| `security-audit` | 检查 OWASP 漏洞 |
+| `generate-tests` | 创建全面的 pytest 测试 |
+| `code-checklist` | 套用团队的代码质量标准 |
+
+
+
+*技能就像专用附件，用来扩展 Copilot 的能力*
+
+---
+
+# 技能如何工作
+
+
+
+了解什么是技能、它们为什么重要，以及它们与智能体和 MCP 有什么不同。
+
+---
+
+## *刚接触技能？* 从这里开始！
+
+1. **先看看已经有哪些技能可用：**
+ ```bash
+ copilot
+ > /skills list
+ ```
+ 这会显示 Copilot 能在你的项目和个人文件夹中找到的所有技能。
+
+2. **看一个真实的技能文件：** 看看我们提供的 [code-checklist SKILL.md](../.github/skills/code-checklist/SKILL.md)，了解它的基本模式。它本质上就是 YAML frontmatter 加上一段 Markdown 指令。
+
+3. **理解核心概念：** 技能是面向特定任务的指令。当你的提示与技能描述匹配时，Copilot 会*自动*加载该技能。你不需要手动启用它，只要自然地提出问题即可。
+
+
+## 理解技能
+
+Agent Skills 是一些文件夹，里面包含指令、脚本和资源；当与你的任务**相关**时，Copilot 会**自动加载**它们。Copilot 会先读取你的提示，检查是否有匹配的技能，然后自动应用相应指令。
+
+```bash
+copilot
+
+> Check books.py against our quality checklist
+# Copilot detects this matches your "code-checklist" skill
+# and automatically applies its Python quality checklist
+
+> Generate tests for the BookCollection class
+# Copilot loads your "pytest-gen" skill
+# and applies your preferred test structure
+
+> What are the code quality issues in this file?
+# Copilot loads your "code-checklist" skill
+# and checks against your team's standards
+```
+
+> 💡 **关键洞察**：技能会根据你的提示与技能描述的匹配结果，**自动触发**。你只要自然提问，Copilot 就会在后台应用相关技能。你也可以直接调用技能，下面就会讲到。
+
+> 🧰 **开箱即用的模板**：可以看看 [.github/skills](../.github/skills/) 文件夹，里面有一些可直接复制粘贴尝试的简单技能。
+
+### 直接用 Slash Command 调用
+
+虽然自动触发是技能最主要的工作方式，但你也可以把技能名当作 slash command，**直接调用技能**：
+
+```bash
+> /generate-tests Create tests for the user authentication module
+
+> /code-checklist Check books.py for code quality issues
+
+> /security-audit Check the API endpoints for vulnerabilities
+```
+
+当你想明确保证某个技能被使用时，这种方式就很有用。
+
+> 📝 **技能调用 vs 智能体调用**：不要把技能调用和智能体调用混淆：
+> - **技能**：`/skill-name 
+
+| 特性 | 它的作用 | 适用场景 |
+|---------|--------------|-------------|
+| **智能体** | 改变 AI 的思考方式 | 需要跨多种任务的专门化能力 |
+| **技能** | 提供面向任务的具体指令 | 某些具体、可重复且步骤明确的任务 |
+| **MCP** | 连接外部服务 | 需要从 API 获取实时数据 |
+
+对于广泛的专长，用智能体；对于特定任务指令，用技能；对于外部数据，用 MCP。一个智能体在一次对话中也可以使用一个或多个技能。比如你让某个智能体帮你检查代码时，它可能会自动同时应用 `security-audit` 技能和 `code-checklist` 技能。
+
+> 📚 **了解更多**：完整的技能格式和最佳实践，请参见官方文档 [About Agent Skills](https://docs.github.com/copilot/concepts/agents/about-agent-skills)。
+
+---
+
+## 从手写长提示到自动化专长
+
+在深入学习如何创建技能之前，我们先看看*为什么*值得学它。先理解它能带来的一致性收益，再去看“怎么做”，会更容易明白。
+
+### 没有技能时：审查不一致
+
+每次做代码审查时，你都可能漏掉点什么：
+
+```bash
+copilot
+
+> Review this code for issues
+# Generic review - might miss your team's specific concerns
+```
+
+或者你每次都要写一长串提示：
+
+```bash
+> Review this code checking for bare except clauses, missing type hints,
+> mutable default arguments, missing context managers for file I/O,
+> functions over 50 lines, print statements in production code...
+```
+
+耗时：**30+ 秒**输入。稳定性：**取决于你记得多少**。
+
+### 有技能后：最佳实践自动生效
+
+安装好 `code-checklist` 技能后，你只需要自然地提出请求：
+
+```bash
+copilot
+
+> Check the book collection code for quality issues
+```
+
+**后台发生的事情**：
+1. Copilot 从你的提示中识别到 “code quality” 和 “issues”
+2. 检查技能描述，发现你的 `code-checklist` 技能匹配
+3. 自动加载你们团队的质量检查清单
+4. 无需你逐项列出，直接完成全部检查
+
+
+
+*你只需要自然提问。Copilot 会将你的提示匹配到正确技能，并自动应用。*
+
+**输出示例**：
+```
+## Code Checklist: books.py
+
+### Code Quality
+- [PASS] All functions have type hints
+- [PASS] No bare except clauses
+- [PASS] No mutable default arguments
+- [PASS] Context managers used for file I/O
+- [PASS] Functions are under 50 lines
+- [PASS] Variable and function names follow PEP 8
+
+### Input Validation
+- [FAIL] User input is not validated - add_book() accepts any year value
+- [FAIL] Edge cases not fully handled - empty strings accepted for title/author
+- [PASS] Error messages are clear and helpful
+
+### Testing
+- [FAIL] No corresponding pytest tests found
+
+### Summary
+3 items need attention before merge
+```
+
+**区别就在这里**：你们团队的标准会自动、稳定地应用到每一次审查中，而不需要你每次再手动打一遍。
+
+---
+
+
+
+
+---
+
+## 大规模保持一致：团队 PR 审查技能
+
+设想你的团队有一个 10 点 PR 检查清单。没有技能时，每位开发者都得记住这 10 点，而总会有人漏掉其中某一项。有了 `pr-review` 技能后，整个团队都能得到一致的审查结果：
+
+```bash
+copilot
+
+> Can you review this PR?
+```
+
+Copilot 会自动加载你们团队的 `pr-review` 技能，并检查全部 10 个点：
+
+```
+PR Review: feature/user-auth
+
+## Security ✅
+- No hardcoded secrets
+- Input validation present
+- No bare except clauses
+
+## Code Quality ⚠️
+- [WARN] print statement on line 45 - remove before merge
+- [WARN] TODO on line 78 missing issue reference
+- [WARN] Missing type hints on public functions
+
+## Testing ✅
+- New tests added
+- Edge cases covered
+
+## Documentation ❌
+- [FAIL] Breaking change not documented in CHANGELOG
+- [FAIL] API changes need OpenAPI spec update
+```
+
+**这就是它的价值**：团队中的每个人都会自动套用相同的标准。新成员也不需要死记这份清单，因为技能已经替他们处理好了。
+
+---
+
+# 创建自定义技能
+
+🎬 看看实际效果！
+ + + +*演示输出会有所不同。你所使用的模型、工具和实际响应都可能与这里展示的不一致。* + +
+
+通过 SKILL.md 文件构建你自己的技能。
+
+---
+
+## 技能存放位置
+
+技能存放在 `.github/skills/`（项目级）或 `~/.copilot/skills/`（用户级）中。
+
+### Copilot 如何找到技能
+
+Copilot 会自动扫描以下位置来发现技能：
+
+| 位置 | 作用范围 |
+|----------|-------|
+| `.github/skills/` | 项目级（通过 git 与团队共享） |
+| `~/.copilot/skills/` | 用户级（你的个人技能） |
+
+### 技能结构
+
+每个技能都位于自己的文件夹中，并包含一个 `SKILL.md` 文件。你也可以根据需要加入脚本、示例或其他资源：
+
+```
+.github/skills/
+└── my-skill/
+ ├── SKILL.md # Required: Skill definition and instructions
+ ├── examples/ # Optional: Example files Copilot can reference
+ │ └── sample.py
+ └── scripts/ # Optional: Scripts the skill can use
+ └── validate.sh
+```
+
+> 💡 **提示**：目录名最好与 SKILL.md frontmatter 中的 `name` 保持一致（小写，用连字符分隔）。
+
+### SKILL.md 格式
+
+技能使用一种很简单的 Markdown 格式：YAML frontmatter + 正文说明。
+
+```markdown
+---
+name: code-checklist
+description: Comprehensive code quality checklist with security, performance, and maintainability checks
+license: MIT
+---
+
+# Code Checklist
+
+When checking code, look for:
+
+## Security
+- SQL injection vulnerabilities
+- XSS vulnerabilities
+- Authentication/authorization issues
+- Sensitive data exposure
+
+## Performance
+- N+1 query problems (running one query per item instead of one query for all items)
+- Unnecessary loops or computations
+- Memory leaks
+- Blocking operations
+
+## Maintainability
+- Function length (flag functions > 50 lines)
+- Code duplication
+- Missing error handling
+- Unclear naming
+
+## Output Format
+Provide issues as a numbered list with severity:
+- [CRITICAL] - Must fix before merge
+- [HIGH] - Should fix before merge
+- [MEDIUM] - Should address soon
+- [LOW] - Nice to have
+```
+
+**YAML 属性：**
+
+| 属性 | 必填 | 说明 |
+|----------|----------|-------------|
+| `name` | **是** | 唯一标识符（小写，空格用连字符） |
+| `description` | **是** | 描述技能做什么，以及 Copilot 何时应该使用它 |
+| `license` | 否 | 适用于该技能的许可证 |
+
+> 📖 **官方文档**：[About Agent Skills](https://docs.github.com/copilot/concepts/agents/about-agent-skills)
+
+### 创建你的第一个技能
+
+我们来构建一个安全审计技能，用于检查 OWASP Top 10 漏洞：
+
+```bash
+# Create skill directory
+mkdir -p .github/skills/security-audit
+
+# Create the SKILL.md file
+cat > .github/skills/security-audit/SKILL.md << 'EOF'
+---
+name: security-audit
+description: Security-focused code review checking OWASP (Open Web Application Security Project) Top 10 vulnerabilities
+---
+
+# Security Audit
+
+Perform a security audit checking for:
+
+## Injection Vulnerabilities
+- SQL injection (string concatenation in queries)
+- Command injection (unsanitized shell commands)
+- LDAP injection
+- XPath injection
+
+## Authentication Issues
+- Hardcoded credentials
+- Weak password requirements
+- Missing rate limiting
+- Session management flaws
+
+## Sensitive Data
+- Plaintext passwords
+- API keys in code
+- Logging sensitive information
+- Missing encryption
+
+## Access Control
+- Missing authorization checks
+- Insecure direct object references
+- Path traversal vulnerabilities
+
+## Output
+For each issue found, provide:
+1. File and line number
+2. Vulnerability type
+3. Severity (CRITICAL/HIGH/MEDIUM/LOW)
+4. Recommended fix
+EOF
+
+# Test your skill (skills load automatically based on your prompt)
+copilot
+
+> @samples/book-app-project/ Check this code for security vulnerabilities
+# Copilot detects "security vulnerabilities" matches your skill
+# and automatically applies its OWASP checklist
+```
+
+**预期输出**（你的结果可能不同）：
+
+```
+Security Audit: book-app-project
+
+[HIGH] Hardcoded file path (book_app.py, line 12)
+ File path is hardcoded rather than configurable
+ Fix: Use environment variable or config file
+
+[MEDIUM] No input validation (book_app.py, line 34)
+ User input passed directly to function without sanitization
+ Fix: Add input validation before processing
+
+✅ No SQL injection found
+✅ No hardcoded credentials found
+```
+
+---
+
+## 编写好的技能描述
+
+SKILL.md 中的 `description` 字段非常关键！Copilot 就是靠它来决定是否加载你的技能：
+
+```markdown
+---
+name: security-audit
+description: Use for security reviews, vulnerability scanning,
+ checking for SQL injection, XSS, authentication issues,
+ OWASP Top 10 vulnerabilities, and security best practices
+---
+```
+
+> 💡 **提示**：把你平时自然会说的关键词写进去。如果你常说 “security review”，那就在描述里明确包含 “security review”。
+
+### 技能与智能体结合使用
+
+技能与智能体可以协同工作。智能体提供专长，技能提供具体指令：
+
+```bash
+# Start with a code-reviewer agent
+copilot --agent code-reviewer
+
+> Check the book app for quality issues
+# code-reviewer agent's expertise combines
+# with your code-checklist skill's checklist
+```
+
+---
+
+# 管理与共享技能
+
+发现已安装技能、查找社区技能，并共享你自己的技能。
+
+
+
+---
+
+## 使用 `/skills` 命令管理技能
+
+使用 `/skills` 命令来管理已安装的技能：
+
+| 命令 | 作用 |
+|---------|--------------|
+| `/skills list` | 显示所有已安装技能 |
+| `/skills info
+
+
+---
+
+### 什么时候使用 `/skills reload`
+
+在创建或编辑某个技能的 SKILL.md 文件后，运行 `/skills reload`，即可在不重启 Copilot 的情况下让改动生效：
+
+```bash
+# Edit your skill file
+# Then in Copilot:
+> /skills reload
+Skills reloaded successfully.
+```
+
+> 💡 **顺带一提**：即使你使用 `/compact` 压缩了对话历史，技能仍然会继续生效，不需要在 compact 之后重新加载。
+
+---
+
+## 查找并使用社区技能
+
+### 使用插件安装技能
+
+> 💡 **什么是插件？** 插件是可安装的软件包，可以把技能、智能体和 MCP 服务器配置一起打包。你可以把它理解成 Copilot CLI 的“应用商店扩展”。
+
+`/plugin` 命令可以让你浏览并安装这些包：
+
+```bash
+copilot
+
+> /plugin list
+# Shows installed plugins
+
+> /plugin marketplace
+# Browse available plugins
+
+> /plugin install 看看实际效果！
+ + + +*演示输出会有所不同。你所使用的模型、工具和实际响应都可能与这里展示的不一致。* + +
+
+通过构建并测试你自己的技能，把刚学到的内容用起来。
+
+---
+
+## ▶️ 动手试试看
+
+### 构建更多技能
+
+下面再给你两个技能示例，展示不同的模式。你可以沿用上文“创建你的第一个技能”中的 `mkdir` + `cat` 流程，也可以直接复制粘贴到正确的位置。更多示例见 [.github/skills](../.github/skills)。
+
+### pytest 测试生成技能
+
+这个技能用于确保整个代码库中的 pytest 结构保持一致：
+
+```bash
+mkdir -p .github/skills/pytest-gen
+
+cat > .github/skills/pytest-gen/SKILL.md << 'EOF'
+---
+name: pytest-gen
+description: Generate comprehensive pytest tests with fixtures and edge cases
+---
+
+# pytest Test Generation
+
+Generate pytest tests that include:
+
+## Test Structure
+- Use pytest conventions (test_ prefix)
+- One assertion per test when possible
+- Clear test names describing expected behavior
+- Use fixtures for setup/teardown
+
+## Coverage
+- Happy path scenarios
+- Edge cases: None, empty strings, empty lists
+- Boundary values
+- Error scenarios with pytest.raises()
+
+## Fixtures
+- Use @pytest.fixture for reusable test data
+- Use tmpdir/tmp_path for file operations
+- Mock external dependencies with pytest-mock
+
+## Output
+Provide complete, runnable test file with proper imports.
+EOF
+```
+
+### 团队 PR 审查技能
+
+这个技能用于在整个团队范围内强制执行一致的 PR 审查标准：
+
+```bash
+mkdir -p .github/skills/pr-review
+
+cat > .github/skills/pr-review/SKILL.md << 'EOF'
+---
+name: pr-review
+description: Team-standard PR review checklist
+---
+
+# PR Review
+
+Review code changes against team standards:
+
+## Security Checklist
+- [ ] No hardcoded secrets or API keys
+- [ ] Input validation on all user data
+- [ ] No bare except clauses
+- [ ] No sensitive data in logs
+
+## Code Quality
+- [ ] Functions under 50 lines
+- [ ] No print statements in production code
+- [ ] Type hints on public functions
+- [ ] Context managers for file I/O
+- [ ] No TODOs without issue references
+
+## Testing
+- [ ] New code has tests
+- [ ] Edge cases covered
+- [ ] No skipped tests without explanation
+
+## Documentation
+- [ ] API changes documented
+- [ ] Breaking changes noted
+- [ ] README updated if needed
+
+## Output Format
+Provide results as:
+- ✅ PASS: Items that look good
+- ⚠️ WARN: Items that could be improved
+- ❌ FAIL: Items that must be fixed before merge
+EOF
+```
+
+### 继续深入
+
+1. **技能创建挑战**：创建一个 `quick-review` 技能，做一个 3 点检查清单：
+ - bare except 子句
+ - 缺失的类型提示
+ - 不清晰的变量名
+
+ 测试方式：提问 “Do a quick review of books.py”
+
+2. **技能对比实验**：给自己计时，手动写一段详细的安全审查提示。然后只问一句 “Check for security issues in this file”，让 `security-audit` 技能自动加载。看看这个技能帮你节省了多少时间？
+
+3. **团队技能挑战**：想一想你们团队的代码审查清单。能不能把它编码成一个技能？先写下 3 个这个技能应该始终检查的内容。
+
+**自测**：如果你能解释清楚为什么 `description` 字段很重要（因为 Copilot 就靠它来决定是否加载技能），就说明你已经理解技能了。
+
+---
+
+## 📝 作业
+
+### 主要挑战：构建一个书籍摘要技能
+
+上面的示例创建了 `pytest-gen` 和 `pr-review` 技能。现在请练习创建一种完全不同类型的技能：它不再是做代码检查，而是根据数据生成格式化输出。
+
+1. 列出你当前已有的技能：启动 Copilot 后运行 `/skills list`。你也可以使用 `ls .github/skills/` 查看项目技能，或使用 `ls ~/.copilot/skills/` 查看个人技能。
+2. 在 `.github/skills/book-summary/SKILL.md` 创建一个 `book-summary` 技能，用来生成书籍集合的格式化 Markdown 摘要
+3. 你的技能应包含：
+ - 清晰的名称和描述（描述对于匹配至关重要！）
+ - 明确的格式规则（例如：输出一个包含标题、作者、年份、阅读状态的 Markdown 表格）
+ - 输出约定（例如：用 ✅/❌ 表示阅读状态，并按年份排序）
+4. 测试该技能：`@samples/book-app-project/data.json Summarize the books in this collection`
+5. 通过检查 `/skills list`，确认该技能会自动触发
+6. 也试试直接调用：`/book-summary Summarize the books in this collection`
+
+**成功标准**：你已经拥有一个可用的 `book-summary` 技能，当你询问书籍集合相关内容时，Copilot 会自动应用它。
+
+
+
+
+### 进阶挑战：提交信息技能
+
+1. 创建一个 `commit-message` 技能，用统一格式生成 Conventional Commit 提交信息
+2. 通过暂存一些更改后提问来测试它：“Generate a commit message for my staged changes”
+3. 为你的技能编写说明，并以 `copilot-skill` topic 发布到 GitHub
+
+---
+
+💡 提示（点击展开）
+ +**起步模板**：创建 `.github/skills/book-summary/SKILL.md`： + +```markdown +--- +name: book-summary +description: Generate a formatted markdown summary of a book collection +--- + +# Book Summary Generator + +Generate a summary of the book collection following these rules: + +1. Output a markdown table with columns: Title, Author, Year, Status +2. Use ✅ for read books and ❌ for unread books +3. Sort by year (oldest first) +4. Include a total count at the bottom +5. Flag any data issues (missing authors, invalid years) + +Example: +| Title | Author | Year | Status | +|-------|--------|------|--------| +| 1984 | George Orwell | 1949 | ✅ | +| Dune | Frank Herbert | 1965 | ❌ | + +**Total: 2 books (1 read, 1 unread)** +``` + +**测试一下：** +```bash +copilot +> @samples/book-app-project/data.json Summarize the books in this collection +# The skill should auto-trigger based on the description match +``` + +**如果没有触发：** 试试先运行 `/skills reload`，再重新提问。 + +
+
+
+---
+
+# 总结
+
+## 🔑 关键要点
+
+1. **技能是自动的**：当你的提示与技能描述匹配时，Copilot 会加载它们
+2. **也支持直接调用**：你也可以用 `/skill-name` 这个 slash command 直接调用技能
+3. **SKILL.md 格式**：YAML frontmatter（name、description、可选的 license）加 Markdown 指令
+4. **位置很重要**：`.github/skills/` 用于项目/团队共享，`~/.copilot/skills/` 用于个人使用
+5. **description 是关键**：描述要贴近你平时自然提问的方式
+
+> 📋 **快速参考**：完整命令与快捷方式列表，请参见 [GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference)。
+
+---
+
+## ➡️ 下一步
+
+技能通过自动加载的指令扩展了 Copilot 的能力。但如果要连接外部服务怎么办？这就是 MCP 发挥作用的地方。
+
+在 **[第 06 章：MCP 服务器](../06-mcp-servers/README.zh.md)** 中，你将学习：
+
+- 什么是 MCP（Model Context Protocol）
+- 如何连接 GitHub、文件系统和文档服务
+- 如何配置 MCP 服务器
+- 多服务器工作流
+
+---
+
+**[← 返回第 04 章](../04-agents-custom-instructions/README.zh.md)** | **[继续阅读第 06 章 →](../06-mcp-servers/README.zh.md)**
diff --git a/06-mcp-servers/README.zh.md b/06-mcp-servers/README.zh.md
new file mode 100644
index 00000000..067f7d09
--- /dev/null
+++ b/06-mcp-servers/README.zh.md
@@ -0,0 +1,938 @@
+
+
+> **如果 Copilot 能直接在终端里读取你的 GitHub issue、检查数据库、创建 PR，会怎么样？**
+
+到目前为止，Copilot 只能基于你直接提供给它的内容工作：你用 `@` 引用的文件、对话历史，以及它自身的训练数据。但如果它还能主动去查看 GitHub 仓库、浏览项目文件，或者检索某个库的最新文档呢？
+
+这正是 MCP（模型上下文协议）的作用。它是一种将 Copilot 连接到外部服务的方式，让它能够访问实时的真实世界数据。Copilot 连接的每个服务都称为一个 “MCP 服务器”。在本章中，你会配置几种这样的连接，并看到它们如何让 Copilot 变得强大得多。
+
+> 💡 **已经熟悉 MCP？** 可以直接[跳到快速开始](#-use-the-built-in-github-mcp)，确认它是否正常工作，然后开始配置服务器。
+
+## 🎯 学习目标
+
+学完本章后，你将能够：
+
+- 理解 MCP 是什么，以及它为什么重要
+- 使用 `/mcp` 命令管理 MCP 服务器
+- 为 GitHub、filesystem 和文档服务配置 MCP 服务器
+- 在图书应用项目中使用基于 MCP 的工作流
+- 了解何时以及如何构建自定义 MCP 服务器（可选）
+
+> ⏱️ **预计用时**：约 50 分钟（15 分钟阅读 + 35 分钟动手实践）
+
+---
+
+## 🧩 现实类比：浏览器扩展
+
+🔧 常见错误与排查（点击展开）
+ +### 常见错误 + +| 错误 | 会发生什么 | 修复方式 | +|---------|--------------|-----| +| 文件名不是 `SKILL.md` | 技能不会被识别 | 文件名必须严格为 `SKILL.md` | +| `description` 字段写得含糊 | 技能永远不会自动加载 | `description` 是**主要**发现机制。要用具体的触发词 | +| frontmatter 中缺少 `name` 或 `description` | 技能加载失败 | 在 YAML frontmatter 中补上这两个字段 | +| 文件夹位置错误 | 找不到技能 | 使用 `.github/skills/skill-name/`（项目）或 `~/.copilot/skills/skill-name/`（个人） | + +### 排查方法 + +**技能没有被使用**——如果 Copilot 没有在你预期的时候使用技能： + +1. **检查 description**：它是否和你的提问方式相匹配？ + ```markdown + # Bad: Too vague + description: Reviews code + + # Good: Includes trigger words + description: Use for code reviews, checking code quality, + finding bugs, security issues, and best practice violations + ``` + +2. **确认文件位置**： + ```bash + # Project skills + ls .github/skills/ + + # User skills + ls ~/.copilot/skills/ + ``` + +3. **检查 SKILL.md 格式**：必须包含 frontmatter： + ```markdown + --- + name: skill-name + description: What the skill does and when to use it + --- + + # Instructions here + ``` + +**技能没有出现在列表中**——确认文件夹结构正确： +``` +.github/skills/ +└── my-skill/ # Folder name + └── SKILL.md # Must be exactly SKILL.md (case-sensitive) +``` + +创建或编辑技能后，请运行 `/skills reload`，确保改动被正确加载。 + +**测试技能是否已加载**——直接问 Copilot： +```bash +> What skills do you have available for checking code quality? +# Copilot will describe relevant skills it found +``` + +**我怎么知道自己的技能真的在工作？** + +1. **看输出格式**：如果你的技能规定了某种输出格式（例如 `[CRITICAL]` 标签），就在响应里看看这些格式是否真的出现 +2. **直接询问**：拿到响应后，继续问一句 “Did you use any skills for that?” +3. **对比有/无技能的差异**：用 `--no-custom-instructions` 运行同样的提示，观察区别： + ```bash + # With skills + copilot --allow-all -p "Review @file.py for security issues" + + # Without skills (baseline comparison) + copilot --allow-all -p "Review @file.py for security issues" --no-custom-instructions + ``` +4. **检查是否包含特定检查项**：如果你的技能里要求检查某些具体内容（比如 “functions over 50 lines”），看看它们是否真的出现在输出里 + +
+
+把 MCP 服务器理解成浏览器扩展会很直观。浏览器本身可以显示网页，但扩展可以把它连接到更多服务：
+
+| 浏览器扩展 | 连接到什么 | MCP 对应物 |
+|-------------------|---------------------|----------------|
+| 密码管理器 | 你的密码保管库 | **GitHub MCP** → 你的仓库、issue、PR |
+| Grammarly | 写作分析服务 | **Context7 MCP** → 库文档 |
+| 文件管理器 | 云存储 | **Filesystem MCP** → 本地项目文件 |
+
+没有扩展时，浏览器依然有用；但加上扩展后，它会变得功能强大。MCP 服务器对 Copilot 也是如此。它们把 Copilot 连接到实时的数据源，让它能够读取 GitHub issue、探索文件系统、获取最新文档等等。
+
+***MCP 服务器会把 Copilot 连接到外部世界：GitHub、仓库、文档，以及更多内容***
+
+> 💡 **关键洞察**：没有 MCP 时，Copilot 只能看到你通过 `@` 显式共享的文件。有了 MCP，它就能自动主动地探索项目、检查 GitHub 仓库并查阅文档。
+
+---
+
+
+
+# 30 秒快速开始：MCP
+
+
+
+## 使用内置的 GitHub MCP 服务器快速上手
+先别急着配置，马上实际看看 MCP 是如何工作的。
+GitHub MCP 服务器默认已内置。试试下面这段：
+
+```bash
+copilot
+> List the recent commits in this repository
+```
+
+如果 Copilot 返回了真实的 commit 数据，你就已经亲眼看到了 MCP 的效果。这就是 GitHub MCP 服务器在代表你访问 GitHub。但 GitHub 只是 *其中一个* 服务器。本章还会教你如何添加更多服务器（文件系统访问、最新文档等），让 Copilot 做到更多事情。
+
+---
+
+## `/mcp show` 命令
+
+使用 `/mcp show` 可以查看当前配置了哪些 MCP 服务器，以及它们是否已启用：
+
+```bash
+copilot
+
+> /mcp show
+
+MCP Servers:
+✓ github (enabled) - GitHub integration
+✓ filesystem (enabled) - File system access
+```
+
+> 💡 **只看到了 GitHub 服务器？** 这是正常的！如果你还没有添加其他 MCP 服务器，那么列表里通常只有 GitHub。下一节你会继续添加更多服务器。
+
+> 📚 **想查看所有 `/mcp` 命令？** 还有用于添加、编辑、启用和删除服务器的命令。可跳到本章末尾的[完整命令参考](#-additional-mcp-commands)。
+
+
+
+
+---
+
+## MCP 带来了什么变化？
+
+下面是 MCP 在实际使用中的区别：
+
+**没有 MCP：**
+```bash
+> What's in GitHub issue #42?
+
+"I don't have access to GitHub. You'll need to copy and paste the issue content."
+```
+
+**有了 MCP：**
+```bash
+> What's in GitHub issue #42 of this repository?
+
+Issue #42: Login fails with special characters
+Status: Open
+Labels: bug, priority-high
+Description: Users report that passwords containing...
+```
+
+MCP 让 Copilot 真正感知到你的实际开发环境。
+
+> 📚 **官方文档**：[About MCP](https://docs.github.com/copilot/concepts/context/mcp)，更深入地了解 MCP 如何与 GitHub Copilot 配合工作。
+
+---
+
+# 配置 MCP 服务器
+
+🎬 看看实际效果！
+ + + +*演示输出会有所不同。你的模型、工具和响应不一定与这里显示的一样。* + +
+
+既然你已经看到了 MCP 的实际效果，接下来就来配置更多服务器。本节会介绍配置文件格式，以及如何添加新的服务器。
+
+---
+
+## MCP 配置文件
+
+MCP 服务器配置在 `~/.copilot/mcp-config.json`（用户级，对所有项目生效）或 `.vscode/mcp.json`（项目级，只对当前工作区生效）中。
+
+```json
+{
+ "mcpServers": {
+ "server-name": {
+ "type": "local",
+ "command": "npx",
+ "args": ["@package/server-name"],
+ "tools": ["*"]
+ }
+ }
+}
+```
+
+*大多数 MCP 服务器都以 npm 包的形式分发，并通过 `npx` 命令运行。*
+
+
+
+
+---
+
+## 添加 MCP 服务器
+
+GitHub MCP 服务器是内置的，无需额外设置。下面列出的是你可以继续添加的其他服务器。**你可以挑自己感兴趣的看，也可以按顺序一步步完成。**
+
+| 我想要…… | 跳转到 |
+|---|---|
+| 让 Copilot 浏览我的项目文件 | [Filesystem 服务器](#filesystem-server) |
+| 获取最新的库文档 | [Context7 服务器](#context7-server-documentation) |
+| 了解可选扩展（自定义服务器、web_fetch） | [进阶内容](#beyond-the-basics) |
+
+💡 不熟悉 JSON？ 点这里了解每个字段的含义
+ +| 字段 | 含义 | +|-------|---------------| +| `"mcpServers"` | 所有 MCP 服务器配置的容器 | +| `"server-name"` | 你自定义的服务器名称（例如 “github”“filesystem”） | +| `"type": "local"` | 表示服务器运行在你的本机上 | +| `"command": "npx"` | 要执行的程序（`npx` 用来运行 npm 包） | +| `"args": [...]` | 传给命令的参数 | +| `"tools": ["*"]` | 允许使用该服务器提供的所有工具 | + +**重要的 JSON 规则：** +- 字符串必须使用双引号 `"`（不能用单引号） +- 最后一项后面不能有多余逗号 +- 文件必须是合法 JSON（如果不确定，可使用 [JSON validator](https://jsonlint.com/)） + +
+
+
+Filesystem 服务器 - 让 Copilot 探索你的项目文件
+ + +### Filesystem 服务器 + +```json +{ + "mcpServers": { + "filesystem": { + "type": "local", + "command": "npx", + "args": ["-y", "@modelcontextprotocol/server-filesystem", "."], + "tools": ["*"] + } + } +} +``` + +> 💡 **路径 `.` 的含义**：这里的 `.` 表示“当前目录”。Copilot 能访问的是你启动它时所在位置的相对文件。在 Codespace 中，这通常是工作区根目录。如果你更喜欢，也可以使用类似 `/workspaces/copilot-cli-for-beginners` 这样的绝对路径。 + +把这段内容加入你的 `~/.copilot/mcp-config.json`，然后重启 Copilot。 + +
+
+
+Context7 服务器 - 获取最新库文档
+ + +### Context7 服务器（文档） + +Context7 可以让 Copilot 访问热门框架和库的最新文档。这样 Copilot 就不必依赖可能已经过时的训练数据，而是直接获取当前的官方文档内容。 + +```json +{ + "mcpServers": { + "context7": { + "type": "local", + "command": "npx", + "args": ["-y", "@upstash/context7-mcp"], + "tools": ["*"] + } + } +} +``` + +- ✅ **不需要 API key** +- ✅ **不需要账号** +- ✅ **你的代码保留在本地** + +把这段内容加入你的 `~/.copilot/mcp-config.json`，然后重启 Copilot。 + +
+
+
+
+
+### 完整配置文件
+
+下面是一份包含 filesystem 和 Context7 服务器的完整 `mcp-config.json`：
+
+> 💡 **注意：** GitHub MCP 是内置的，你不需要把它加进配置文件。
+
+```json
+{
+ "mcpServers": {
+ "filesystem": {
+ "type": "local",
+ "command": "npx",
+ "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
+ "tools": ["*"]
+ },
+ "context7": {
+ "type": "local",
+ "command": "npx",
+ "args": ["-y", "@upstash/context7-mcp"],
+ "tools": ["*"]
+ }
+ }
+}
+```
+
+将它保存为 `~/.copilot/mcp-config.json` 可用于全局访问；保存为 `.vscode/mcp.json` 则只对当前项目生效。
+
+---
+
+# 使用 MCP 服务器
+
+现在你已经配置好了 MCP 服务器，接下来看看它们究竟能做什么。
+
+进阶内容 - 自定义服务器与 Web 访问（可选）
+ + +这些都属于可选扩展，适合在你熟悉上面核心服务器之后再尝试。 + + + +### Microsoft Learn MCP 服务器 + +到目前为止你看到的每个 MCP 服务器（filesystem、Context7）都运行在本机上。但 MCP 服务器也可以远程运行，这意味着你只需要把 Copilot CLI 指向一个 URL，其余工作都会自动完成。不需要 `npx` 或 `python`，也不需要本地进程，更不用安装依赖。 + +[Microsoft Learn MCP Server](https://github.com/microsoftdocs/mcp) 就是一个很好的例子。它让 Copilot CLI 可以直接访问微软官方文档（Azure、Microsoft Foundry 和其他 AI 主题、.NET、Microsoft 365 等等），因此它能搜索文档、获取完整页面、查找官方代码示例，而不是只依赖模型已有的训练数据。 + +- ✅ **不需要 API key** +- ✅ **不需要账号** +- ✅ **不需要本地安装** + +**使用 `/plugin install` 快速安装：** + +与其手动编辑 JSON 配置文件，不如直接用一条命令安装： + +```bash +copilot + +> /plugin install microsoftdocs/mcp +``` + +这会自动添加服务器及其相关的 agent skills。安装的技能包括： + +- **microsoft-docs**：概念、教程和事实查询 +- **microsoft-code-reference**：API 查询、代码示例和故障排查 +- **microsoft-skill-creator**：一个用于生成 Microsoft 技术相关自定义技能的元技能 + +**用法：** +```bash +copilot + +> What's the recommended way to deploy a Python app to Azure App Service? Search Microsoft Learn. +``` + +📚 进一步了解：[Microsoft Learn MCP Server overview](https://learn.microsoft.com/training/support/mcp-get-started) + +### 使用 `web_fetch` 进行 Web 访问 + +Copilot CLI 内置了 `web_fetch` 工具，可以从任意 URL 抓取内容。它很适合在不离开终端的情况下拉取 README、API 文档或发布说明。不需要额外配置 MCP 服务器。 + +你可以通过 `~/.copilot/config.json`（Copilot 的通用设置）来控制允许访问哪些 URL；这个文件和 `~/.copilot/mcp-config.json`（MCP 服务器定义）是分开的。 + +```json +{ + "permissions": { + "allowedUrls": [ + "https://api.github.com/**", + "https://docs.github.com/**", + "https://*.npmjs.org/**" + ], + "blockedUrls": [ + "http://**" + ] + } +} +``` + +**用法：** +```bash +copilot + +> Fetch and summarize the README from https://github.com/facebook/react +``` + +### 构建自定义 MCP 服务器 + +想把 Copilot 连接到你自己的 API、数据库或内部工具吗？你可以用 Python 构建一个自定义 MCP 服务器。这完全是可选的，因为预构建的服务器（GitHub、filesystem、Context7）已经能覆盖大多数使用场景。 + +📖 参见[自定义 MCP 服务器指南](mcp-custom-server.zh.md)，它会以图书应用为例，提供一份完整的实践演练。 + +📚 如需更多背景信息，可参考 [MCP for Beginners course](https://github.com/microsoft/mcp-for-beginners)。 + +
+
+---
+
+## 服务器使用示例
+
+**你可以挑一个服务器先试，也可以按顺序全部走一遍。**
+
+| 我想试试…… | 跳转到 |
+|---|---|
+| GitHub 仓库、issue 和 PR | [GitHub 服务器](#github-server-built-in) |
+| 浏览项目文件 | [Filesystem 服务器用法](#filesystem-server-usage) |
+| 查询库文档 | [Context7 服务器用法](#context7-server-usage) |
+| 自定义服务器、Microsoft Learn MCP 与 `web_fetch` 的使用 | [进阶用法](#beyond-the-basics-usage) |
+
+
+
+
+GitHub 服务器（内置） - 访问仓库、issue、PR 等
+ + +### GitHub 服务器（内置） + +GitHub MCP 服务器是**内置的**。只要你已经登录 Copilot（你在初始设置时就做过了），它就已经可以工作。无需任何额外配置！ + +> 💡 **不工作？** 运行 `/login` 重新完成 GitHub 认证。 + +
+
+
+| 功能 | 示例 |
+|---------|----------|
+| **仓库信息** | 查看 commit、分支、贡献者 |
+| **Issues** | 列出、创建、搜索并评论 issue |
+| **Pull requests** | 查看 PR、diff、创建 PR、检查状态 |
+| **代码搜索** | 跨仓库搜索代码 |
+| **Actions** | 查询工作流运行情况和状态 |
+
+```bash
+copilot
+
+# See recent activity in this repo
+> List the last 5 commits in this repository
+
+Recent commits:
+1. abc1234 - Update chapter 05 skills examples (2 days ago)
+2. def5678 - Add book app test fixtures (3 days ago)
+3. ghi9012 - Fix typo in chapter 03 README (4 days ago)
+...
+
+# Explore the repo structure
+> What branches exist in this repository?
+
+Branches:
+- main (default)
+- chapter6 (current)
+
+# Search for code patterns across the repo
+> Search this repository for files that import pytest
+
+Found 1 file:
+- samples/book-app-project/tests/test_books.py
+```
+
+> 💡 **在用你自己的 fork 吗？** 如果你 fork 了这份课程仓库，也可以尝试创建 issue 和 pull request 这样的写操作。下面的练习会带你实践。
+
+> ⚠️ **看不到结果？** GitHub MCP 操作的是仓库的远端（github.com 上的仓库），而不仅仅是本地文件。先运行 `git remote -v` 确认仓库配置了 remote。
+
+在 Dev Container 中进行认证
+ +- **GitHub Codespaces**（推荐）：认证会自动完成。`gh` CLI 会继承你的 Codespace token，无需额外操作。 +- **本地 dev container（Docker）**：容器启动后运行 `gh auth login`，然后重启 Copilot。 + +**认证故障排查：** +```bash +# Check if you're authenticated +gh auth status + +# If not, log in +gh auth login + +# Verify GitHub MCP is connected +copilot +> /mcp show +``` + +
+
+
+Filesystem 服务器 - 浏览并分析项目文件
+ + +### Filesystem 服务器 + +完成配置后，filesystem MCP 会提供一组 Copilot 可自动使用的工具： + +```bash +copilot + +> How many Python files are in the book-app-project directory? + +Found 3 Python files in samples/book-app-project/: +- book_app.py +- books.py +- utils.py + +> What's the total size of the data.json file? + +samples/book-app-project/data.json: 2.4 KB + +> Find all functions that don't have type hints in the book app + +Found 2 functions without type hints: +- samples/book-app-project/utils.py:10 - get_user_choice() +- samples/book-app-project/utils.py:14 - get_book_details() +``` + +
+
+
+Context7 服务器 - 查询库文档
+ + +### Context7 服务器 + +```bash +copilot + +> What are the best practices for using pytest fixtures? + +From pytest Documentation: + +Fixtures - Use fixtures to provide a fixed baseline for tests: + + import pytest + + @pytest.fixture + def sample_books(): + return [ + {"title": "1984", "author": "George Orwell", "year": 1949}, + {"title": "Dune", "author": "Frank Herbert", "year": 1965}, + ] + + def test_find_by_author(sample_books): + # fixture is automatically passed as argument + results = [b for b in sample_books if "Orwell" in b["author"]] + assert len(results) == 1 + +Best practices: +- Use fixtures instead of setup/teardown methods +- Use tmp_path fixture for temporary files +- Use monkeypatch for modifying environment +- Scope fixtures appropriately (function, class, module, session) + +> How can I apply this to the book app's test file? + +# Copilot now knows the official pytest patterns +# and can apply them to samples/book-app-project/tests/test_books.py +``` + +
+
+
+---
+
+## 多服务器工作流
+
+这些工作流能说明，为什么很多开发者会说：“用了之后就再也不想离开它了。” 每个示例都会在同一个会话里组合使用多个 MCP 服务器。
+
+进阶用法 - 自定义服务器与 `web_fetch` 的使用
+ + +### 进阶内容 + +**自定义 MCP 服务器**：如果你已经按照[自定义 MCP 服务器指南](mcp-custom-server.zh.md)构建了 book-lookup 服务器，就可以直接查询自己的图书集合： + +```bash +copilot + +> Look up information about "1984" using the book lookup server. Search for books by George Orwell +``` + +**Microsoft Learn MCP**：如果你安装了 [Microsoft Learn MCP server](#microsoft-learn-mcp-server)，就可以直接查询微软官方文档： + +```bash +copilot + +> How do I configure managed identity for an Azure Function? Search Microsoft Learn. +``` + +**Web Fetch**：使用内置的 `web_fetch` 工具，可以从任意 URL 拉取内容： + +```bash +copilot + +> Fetch and summarize the README from https://github.com/facebook/react +``` + +
+
+*完整的 MCP 工作流：GitHub MCP 获取仓库数据，Filesystem MCP 查找代码，Context7 MCP 提供最佳实践，而 Copilot 负责分析与整合*
+
+下面每个示例都是完整自洽的。**你可以挑一个最感兴趣的，也可以全部读完。**
+
+| 我想看…… | 跳转到 |
+|---|---|
+| 多个服务器如何协同工作 | [多服务器探索](#multi-server-exploration) |
+| 如何在一个会话中从 issue 走到 PR | [Issue 到 PR 工作流](#issue-to-pr-workflow) |
+| 如何快速做项目健康检查 | [健康看板](#health-dashboard) |
+
+
+
+
+多服务器探索 - 在一个会话中组合 filesystem、GitHub 和 Context7
+ + +#### 使用多个 MCP 服务器探索图书应用 + +```bash +copilot + +# Step 1: Use filesystem MCP to explore the book app +> List all Python files in samples/book-app-project/ and summarize +> what each file does + +Found 3 Python files: +- book_app.py: CLI entry point with command routing (list, add, remove, find) +- books.py: BookCollection class with data persistence via JSON +- utils.py: Helper functions for user input and display + +# Step 2: Use GitHub MCP to check recent changes +> What were the last 3 commits that touched files in samples/book-app-project/? + +Recent commits affecting book app: +1. abc1234 - Add test fixtures for BookCollection (2 days ago) +2. def5678 - Add find_by_author method (5 days ago) +3. ghi9012 - Initial book app setup (1 week ago) + +# Step 3: Use Context7 MCP for best practices +> What are Python best practices for JSON data persistence? + +From Python Documentation: +- Use context managers (with statements) for file I/O +- Handle JSONDecodeError for corrupted files +- Use dataclasses for structured data +- Consider atomic writes to prevent data corruption + +# Step 4: Synthesize a recommendation +> Based on the book app code and these best practices, +> what improvements would you suggest? + +Suggestions: +1. Add input validation in add_book() for empty strings and invalid years +2. Consider atomic writes in save_books() to prevent data corruption +3. Add type hints to utils.py functions (get_user_choice, get_book_details) +``` + +
+
+
+**结果是**：代码探索 → 历史回顾 → 最佳实践查询 → 改进建议。**全部都在同一个终端会话中完成，并且同时用到了三个 MCP 服务器。**
+
+🎬 看看 MCP 工作流的实际效果！
+ + + +*演示输出会有所不同。你的模型、工具和响应不一定与这里显示的一样。* + +
+
+
+Issue 到 PR 工作流 - 不离开终端，从 GitHub issue 直接走到 pull request
+ + +#### Issue 到 PR 工作流（在你自己的仓库中） + +如果你对自己的 fork 或仓库有写权限，这个流程会特别适合： + +> 💡 **如果你现在还无法亲手尝试，也不用担心。** 如果你当前使用的是只读 clone，可以在作业部分再实践。现在先把流程读懂即可。 + +```bash +copilot + +> Get the details of GitHub issue #1 + +Issue #1: Add input validation for book year +Status: Open +Description: The add_book function accepts any year value... + +> @samples/book-app-project/books.py Fix the issue described in issue #1 + +[Copilot implements year validation in add_book()] + +> Run the tests to make sure the fix works + +All 8 tests passed ✓ + +> Create a pull request titled "Add year validation to book app" + +✓ Created PR #2: Add year validation to book app +``` + +**零复制粘贴。零上下文切换。一个终端会话全部完成。** + +
+
+
+---
+
+# 练习
+
+健康看板 - 使用多个服务器快速检查项目健康状况
+ + +#### 图书应用健康看板 + +```bash +copilot + +> Give me a health report for the book app project: +> 1. List all functions across the Python files in samples/book-app-project/ +> 2. Check which functions have type hints and which don't +> 3. Show what tests exist in samples/book-app-project/tests/ +> 4. Check the recent commit history for this directory + +Book App Health Report +====================== + +📊 Functions Found: +- books.py: 8 methods in BookCollection (all have type hints ✓) +- book_app.py: 6 functions (4 have type hints, 2 missing) +- utils.py: 3 functions (1 has type hints, 2 missing) + +🧪 Test Coverage: +- test_books.py: 8 test functions covering BookCollection +- Missing: no tests for book_app.py CLI functions +- Missing: no tests for utils.py helper functions + +📝 Recent Activity: +- 3 commits in the last week +- Most recent: added test fixtures + +Recommendations: +- Add type hints to utils.py functions +- Add tests for book_app.py CLI handlers +- All files well-sized (<100 lines) - good structure! +``` + +**结果是**：几秒钟内聚合多个数据源。手动完成的话，你可能要运行 grep、统计行数、查看 git log，还要逐个浏览测试文件。轻轻松松就是 15 分钟以上的工作量。 + +
+
+**🎉 现在你已经掌握核心内容了！** 你已经理解了 MCP，也看过如何配置服务器，还看到了它在真实工作流中的表现。现在轮到你自己动手了。
+
+---
+
+## ▶️ 自己试试看
+
+现在轮到你了！完成下面这些练习，动手实践如何在图书应用项目中使用 MCP 服务器。
+
+### 练习 1：检查你的 MCP 状态
+
+先看看当前有哪些 MCP 服务器可用：
+
+```bash
+copilot
+
+> /mcp show
+```
+
+你应该会看到 GitHub 服务器显示为已启用。如果没有，运行 `/login` 完成认证。
+
+---
+
+### 练习 2：使用 Filesystem MCP 探索图书应用
+
+如果你已经配置了 filesystem 服务器，可以用它来探索图书应用：
+
+```bash
+copilot
+
+> How many Python files are in samples/book-app-project/?
+> What functions are defined in each file?
+```
+
+**预期结果**：Copilot 会列出 `book_app.py`、`books.py` 和 `utils.py`，并说明每个文件中的函数。
+
+> 💡 **还没配置 filesystem MCP？** 按照上面[完整配置](#complete-configuration-file)一节创建配置文件，然后重启 Copilot。
+
+---
+
+### 练习 3：使用 GitHub MCP 查询仓库历史
+
+使用内置的 GitHub MCP 来探索本课程仓库：
+
+```bash
+copilot
+
+> List the last 5 commits in this repository
+
+> What branches exist in this repository?
+```
+
+**预期结果**：Copilot 会从 GitHub 远端显示最近的 commit 信息和分支名称。
+
+> ⚠️ **在 Codespace 中？** 这个功能会自动可用，因为认证会被继承。如果你是在本地 clone 上操作，请确认 `gh auth status` 显示你已登录。
+
+---
+
+### 练习 4：组合使用多个 MCP 服务器
+
+现在在同一个会话中同时使用 filesystem 和 GitHub MCP：
+
+```bash
+copilot
+
+> Read samples/book-app-project/data.json and tell me what books are
+> in the collection. Then check the recent commits to see when this
+> file was last modified.
+```
+
+**预期结果**：Copilot 会读取 JSON 文件（filesystem MCP），列出其中的 5 本书，包括 “The Hobbit”“1984”“Dune”“To Kill a Mockingbird” 和 “Mysterious Book”，然后再使用 GitHub 查询该文件的提交历史。
+
+**自我检查**：如果你能解释为什么“检查我仓库的 commit 历史”比手动运行 `git log` 再把输出粘贴进提示词更高效，就说明你真正理解了 MCP。
+
+---
+
+## 📝 作业
+
+### 主挑战：用 MCP 探索图书应用
+
+请在图书应用项目上练习组合使用 MCP 服务器。在一次 Copilot 会话中完成以下步骤：
+
+1. **确认 MCP 正常工作**：运行 `/mcp show`，并确认至少 GitHub 服务器已启用
+2. **设置 filesystem MCP**（如果还没做）：创建 `~/.copilot/mcp-config.json`，写入 filesystem 服务器配置
+3. **探索代码**：让 Copilot 使用 filesystem 服务器来：
+ - 列出 `samples/book-app-project/books.py` 中的所有函数
+ - 检查 `samples/book-app-project/utils.py` 中哪些函数缺少类型注解
+ - 读取 `samples/book-app-project/data.json`，找出其中是否有数据质量问题（提示：看最后一条）
+4. **检查仓库活动**：让 Copilot 使用 GitHub MCP 来：
+ - 列出最近修改过 `samples/book-app-project/` 中文件的 commit
+ - 查看当前是否有未关闭的 issue 或 pull request
+5. **组合服务器**：在一个提示词中让 Copilot：
+ - 读取 `samples/book-app-project/tests/test_books.py`
+ - 将已测试的函数与 `books.py` 中的所有函数进行对比
+ - 总结缺失了哪些测试覆盖
+
+**成功标准**：你能够在同一个 Copilot 会话中流畅地结合 filesystem 和 GitHub MCP 数据，并清楚说明每个 MCP 服务器分别为结果贡献了什么。
+
+
+
+
+### 加分挑战：构建自定义 MCP 服务器
+
+想更深入一些？按照[自定义 MCP 服务器指南](mcp-custom-server.zh.md)来做，亲手用 Python 构建一个可以连接任意 API 的 MCP 服务器。
+
+---
+
+💡 提示（点击展开）
+ +**步骤 1：确认 MCP** +```bash +copilot +> /mcp show +# Should show "github" as enabled +# If not, run: /login +``` + +**步骤 2：创建配置文件** + +使用上文[完整配置](#complete-configuration-file)中的 JSON，并将其保存为 `~/.copilot/mcp-config.json`。 + +**步骤 3：需要观察的数据质量问题** + +`data.json` 中最后一本书是： +```json +{ + "title": "Mysterious Book", + "author": "", + "year": 0, + "read": false +} +``` +作者为空、年份为 0。这就是数据质量问题！ + +**步骤 5：测试覆盖对比** + +`test_books.py` 中的测试覆盖了：`add_book`、`mark_as_read`、`remove_book`、`get_unread_books` 和 `find_book_by_title`。而 `load_books`、`save_books`、`list_books` 等函数没有直接测试。`book_app.py` 里的 CLI 函数和 `utils.py` 里的辅助函数也都没有测试。 + +**如果 MCP 不工作：** 编辑完配置文件后，重启 Copilot。 + +
+
+
+---
+
+🔧 常见错误与故障排查（点击展开）
+ +### 常见错误 + +| 错误 | 会发生什么 | 修复方式 | +|---------|--------------|-----| +| 不知道 GitHub MCP 是内置的 | 试图手动安装或配置它 | GitHub MCP 默认已包含。直接试试：“List the recent commits in this repo” | +| 在错误的位置找配置 | 找不到或无法编辑 MCP 设置 | 用户级配置在 `~/.copilot/mcp-config.json`，项目级配置在 `.vscode/mcp.json` | +| 配置文件中的 JSON 无效 | MCP 服务器加载失败 | 用 `/mcp show` 检查配置；验证 JSON 语法 | +| 忘记为 MCP 服务器做认证 | 出现 “Authentication failed” 错误 | 某些 MCP 需要单独认证。查看各服务器的要求 | + +### 故障排查 + +**“MCP server not found”** - 请检查： +1. npm 包是否存在：`npm view @modelcontextprotocol/server-github` +2. 配置是否为合法 JSON +3. 服务器名称是否与配置一致 + +使用 `/mcp show` 查看当前配置。 + +**“GitHub authentication failed”** - 内置 GitHub MCP 使用的是你的 `/login` 凭据。试试： + +```bash +copilot +> /login +``` + +这样会重新与你的 GitHub 账户完成认证。如果问题仍然存在，请检查你的 GitHub 账户是否拥有访问目标仓库所需的权限。 + +**“MCP server failed to start”** - 检查服务器日志： +```bash +# Run the server command manually to see errors +npx -y @modelcontextprotocol/server-github +``` + +**MCP 工具不可用** - 确认服务器已启用： +```bash +copilot + +> /mcp show +# Check if server is listed and enabled +``` + +如果服务器已被禁用，可参考下面的[更多 `/mcp` 命令](#-additional-mcp-commands)了解如何重新启用。 + +
+📚 更多
+
+
+除了 `/mcp show` 之外，还有一些其他命令可以用来管理 MCP 服务器：
+
+| 命令 | 作用 |
+|---------|--------------|
+| `/mcp show` | 显示所有已配置的 MCP 服务器及其状态 |
+| `/mcp add` | 通过交互式流程添加新服务器 |
+| `/mcp edit ` | 编辑已有服务器配置 |
+| `/mcp enable ` | 启用已禁用的服务器 |
+| `/mcp disable ` | 临时禁用服务器 |
+| `/mcp delete ` | 永久删除服务器 |
+
+在本课程的大多数场景里，`/mcp show` 就已经足够了。随着你管理的服务器越来越多，其他命令会变得更有用。
+
+
+
+---
+
+# 总结
+
+## 🔑 核心要点
+
+1. **MCP** 会把 Copilot 连接到外部服务（GitHub、文件系统、文档）
+2. **GitHub MCP 是内置的** - 无需配置，只需要 `/login`
+3. **Filesystem 和 Context7** 通过 `~/.copilot/mcp-config.json` 进行配置
+4. **多服务器工作流** 可以在一次会话中组合多个来源的数据
+5. 使用 `/mcp show` **检查服务器状态**（还有更多命令可用于管理服务器）
+6. **自定义服务器** 可以让你连接任意 API（可选内容，附录指南中有介绍）
+
+> 📋 **快速参考**：完整命令和快捷方式列表请参见 [GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference)。
+
+---
+
+## ➡️ 接下来学什么
+
+现在你已经掌握了所有构件：模式、上下文、工作流、智能体、技能以及 MCP。接下来，该把它们真正组合起来了。
+
+在 **[第 07 章：融会贯通](../07-putting-it-together/README.zh.md)** 中，你将学习：
+
+- 将智能体、技能和 MCP 组合成统一工作流
+- 从功能想法到合并 PR 的完整开发流程
+- 使用 hook 实现自动化
+- 适用于团队环境的最佳实践
+
+---
+
+**[← 返回第 05 章](../05-skills/README.zh.md)** | **[继续前往第 07 章 →](../07-putting-it-together/README.zh.md)**
diff --git a/06-mcp-servers/mcp-custom-server.zh.md b/06-mcp-servers/mcp-custom-server.zh.md
new file mode 100644
index 00000000..5c466447
--- /dev/null
+++ b/06-mcp-servers/mcp-custom-server.zh.md
@@ -0,0 +1,176 @@
+# 构建自定义 MCP 服务器
+
+> ⚠️ **这部分内容完全是可选的。** 仅使用预构建的 MCP 服务器（GitHub、filesystem、Context7），你也能非常高效地使用 Copilot CLI。本指南面向想把 Copilot 连接到自定义内部 API 的开发者。更多细节可参考 [MCP for Beginners course](https://github.com/microsoft/mcp-for-beginners)。
+>
+> **前置要求：**
+> - 熟悉 Python
+> - 理解 `async`/`await` 编程模式
+> - 系统中可使用 `pip`（本开发容器已包含）
+>
+> **[← 返回第 06 章：MCP 服务器](README.zh.md)**
+
+---
+
+想把 Copilot 连接到你自己的 API 吗？下面会演示如何用 Python 构建一个简单的 MCP 服务器，用来查询图书信息，并与本课程中一直在使用的图书应用项目相呼应。
+
+## 项目设置
+
+```bash
+mkdir book-lookup-mcp-server
+cd book-lookup-mcp-server
+pip install mcp
+```
+
+> 💡 **`mcp` 包是什么？** 它是用于构建 MCP 服务器的官方 Python SDK。协议细节由它处理，你可以把注意力放在工具本身的实现上。
+
+## 服务器实现
+
+创建一个名为 `server.py` 的文件：
+
+```python
+# server.py
+import json
+from mcp.server.fastmcp import FastMCP
+
+# Create the MCP server
+mcp = FastMCP("book-lookup")
+
+# Sample book database (in a real server, this could query an API or database)
+BOOKS_DB = {
+ "978-0-547-92822-7": {
+ "title": "The Hobbit",
+ "author": "J.R.R. Tolkien",
+ "year": 1937,
+ "genre": "Fantasy",
+ },
+ "978-0-451-52493-5": {
+ "title": "1984",
+ "author": "George Orwell",
+ "year": 1949,
+ "genre": "Dystopian Fiction",
+ },
+ "978-0-441-17271-9": {
+ "title": "Dune",
+ "author": "Frank Herbert",
+ "year": 1965,
+ "genre": "Science Fiction",
+ },
+}
+
+
+@mcp.tool()
+def lookup_book(isbn: str) -> str:
+ """Look up a book by its ISBN and return title, author, year, and genre."""
+ book = BOOKS_DB.get(isbn)
+ if book:
+ return json.dumps(book, indent=2)
+ return f"No book found with ISBN: {isbn}"
+
+
+@mcp.tool()
+def search_books(query: str) -> str:
+ """Search for books by title or author. Returns all matching results."""
+ query_lower = query.lower()
+ results = [
+ {**book, "isbn": isbn}
+ for isbn, book in BOOKS_DB.items()
+ if query_lower in book["title"].lower()
+ or query_lower in book["author"].lower()
+ ]
+ if results:
+ return json.dumps(results, indent=2)
+ return f"No books found matching: {query}"
+
+
+@mcp.tool()
+def list_all_books() -> str:
+ """List all books in the database with their ISBNs."""
+ books_list = [
+ {"isbn": isbn, "title": book["title"], "author": book["author"]}
+ for isbn, book in BOOKS_DB.items()
+ ]
+ return json.dumps(books_list, indent=2)
+
+
+if __name__ == "__main__":
+ mcp.run()
+```
+
+**这里发生了什么：**
+
+| 部分 | 作用 |
+|------|------|
+| `FastMCP("book-lookup")` | 创建一个名为 “book-lookup” 的服务器 |
+| `@mcp.tool()` | 将函数注册为 Copilot 可调用的工具 |
+| 类型注解 + 文档字符串 | 告诉 Copilot 每个工具的作用以及需要哪些参数 |
+| `mcp.run()` | 启动服务器并监听请求 |
+
+> 💡 **为什么用装饰器？** 你只需要 `@mcp.tool()` 装饰器即可。MCP SDK 会自动读取函数名、类型注解和文档字符串来生成工具 schema，无需手动编写 JSON schema！
+
+## 配置
+
+将以下内容添加到你的 `~/.copilot/mcp-config.json`：
+
+```json
+{
+ "mcpServers": {
+ "book-lookup": {
+ "type": "local",
+ "command": "python3",
+ "args": ["./book-lookup-mcp-server/server.py"],
+ "tools": ["*"]
+ }
+ }
+}
+```
+
+## 用法
+
+```bash
+copilot
+
+> Look up the book with ISBN 978-0-547-92822-7
+
+{
+ "title": "The Hobbit",
+ "author": "J.R.R. Tolkien",
+ "year": 1937,
+ "genre": "Fantasy"
+}
+
+> Search for books by Orwell
+
+[
+ {
+ "title": "1984",
+ "author": "George Orwell",
+ "year": 1949,
+ "genre": "Dystopian Fiction",
+ "isbn": "978-0-451-52493-5"
+ }
+]
+
+> List all available books
+
+[Shows all books in the database with ISBNs]
+```
+
+## 下一步
+
+构建出基础服务器后，你还可以：
+
+1. **添加更多工具** - 每个 `@mcp.tool()` 函数都会成为 Copilot 可调用的一个工具
+2. **连接真实 API** - 用真实的 API 调用或数据库查询替换示例中的 `BOOKS_DB`
+3. **添加认证机制** - 安全地处理 API key 和 token
+4. **共享你的服务器** - 发布到 PyPI，让其他人也能通过 `pip` 安装
+
+## 资源
+
+- [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk)
+- [MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk)
+- [Example MCP Servers](https://github.com/modelcontextprotocol/servers)
+- [MCP for Beginners Course](https://github.com/microsoft/mcp-for-beginners)
+
+---
+
+**[← 返回第 06 章：MCP 服务器](README.zh.md)**
diff --git a/07-putting-it-together/README.zh.md b/07-putting-it-together/README.zh.md
new file mode 100644
index 00000000..c8028fbf
--- /dev/null
+++ b/07-putting-it-together/README.zh.md
@@ -0,0 +1,515 @@
+
+
+> **你学到的一切都会在这里汇合。用一次会话，就能从想法走到合并后的 PR。**
+
+在本章中，你会把前面学到的所有内容组合成完整工作流。你将借助多智能体协作来构建功能，设置能在提交前拦截安全问题的 pre-commit hook，把 Copilot 集成进 CI/CD 流水线，并在一次终端会话中完成从功能想法到合并 PR 的全过程。也正是在这里，GitHub Copilot CLI 会真正成为生产力放大器。
+
+> 💡 **说明**：本章演示的是如何把你前面学到的内容组合起来。**即使不使用智能体、技能或 MCP，你仍然可以高效工作（虽然它们确实很有帮助）。** 核心工作流——描述、规划、实现、测试、审查、交付——仅依靠第 00-03 章介绍的内置功能也完全可以成立。
+
+## 🎯 学习目标
+
+学完本章后，你将能够：
+
+- 在统一工作流中组合使用智能体、技能和 MCP（模型上下文协议）
+- 通过多工具协作方式构建完整功能
+- 使用 hook 搭建基础自动化
+- 应用专业开发中的最佳实践
+
+> ⏱️ **预计用时**：约 75 分钟（15 分钟阅读 + 60 分钟动手实践）
+
+---
+
+## 🧩 现实类比：交响乐团
+
+📚 更多 /mcp 命令（点击展开）
+
+
+除了 `/mcp show` 之外，还有一些其他命令可以用来管理 MCP 服务器：
+
+| 命令 | 作用 |
+|---------|--------------|
+| `/mcp show` | 显示所有已配置的 MCP 服务器及其状态 |
+| `/mcp add` | 通过交互式流程添加新服务器 |
+| `/mcp edit 
+
+一支交响乐团由很多声部组成：
+- **弦乐**负责打基础（就像你的核心工作流）
+- **铜管**带来力量（就像拥有专门能力的智能体）
+- **木管**增添色彩（就像扩展能力的技能）
+- **打击乐**维持节奏（就像把外部系统接入进来的 MCP）
+
+单看每个声部，能做的事都有限；但在良好的指挥下，它们一起就能创造出宏大的作品。
+
+**这正是本章要教你的内容！**+*就像指挥家统筹乐团一样，你将把智能体、技能和 MCP 编排成统一工作流* + +先从一个完整场景开始：在一次会话中修改代码、生成测试、完成审查并创建 PR。稍后我们会在下方的[集成模式](#the-integration-pattern-for-power-users)部分拆解这种方法。 + +--- + + + +## 从想法到合并 PR，全程一个会话完成 + +与其在编辑器、终端、测试运行器和 GitHub UI 之间来回切换、不断丢失上下文，不如把所有工具集中到同一个终端会话里。稍后我们会在下面的[集成模式](#the-integration-pattern-for-power-users)部分详细拆解这种工作方式。 + +```bash +# Start Copilot in interactive mode +copilot + +> I need to add a "list unread" command to the book app that shows only +> books where read is False. What files need to change? + +# Copilot creates high-level plan... + +# SWITCH TO PYTHON-REVIEWER AGENT +> /agent +# Select "python-reviewer" + +> @samples/book-app-project/books.py Design a get_unread_books method. +> What is the best approach? + +# Python-reviewer agent produces: +# - Method signature and return type +# - Filter implementation using list comprehension +# - Edge case handling for empty collections + +# SWITCH TO PYTEST-HELPER AGENT +> /agent +# Select "pytest-helper" + +> @samples/book-app-project/tests/test_books.py Design test cases for +> filtering unread books. + +# Pytest-helper agent produces: +# - Test cases for empty collections +# - Test cases with mixed read/unread books +# - Test cases with all books read + +# IMPLEMENT +> Add a get_unread_books method to BookCollection in books.py +> Add a "list unread" command option in book_app.py +> Update the help text in the show_help function + +# TEST +> Generate comprehensive tests for the new feature + +# Multiple tests are generated similar to the following: +# - Happy path (3 tests) — filters correctly, excludes read, includes unread +# - Edge cases (4 tests) — empty collection, all read, none read, single book +# - Parametrized (5 cases) — varying read/unread ratios via @pytest.mark.parametrize +# - Integration (4 tests) — interplay with mark_as_read, remove_book, add_book, and data integrity + +# Review the changes +> /review + +# If review passes, generate a PR (uses GitHub MCP covered earlier in the course) +> Create a pull request titled "Feature: Add list unread books command" +``` + +**传统做法**：在编辑器、终端、测试运行器、文档和 GitHub UI 之间来回切换。每一次切换都会带来上下文丢失和额外摩擦。 + +**核心洞察**：你像架构师一样在指挥这些专家。细节由他们处理，而你负责愿景与方向。 + +> 💡 **更进一步**：对于这种大型、多步骤的计划，可以尝试使用 `/fleet`，让 Copilot 并行执行彼此独立的子任务。更多细节请参考[官方文档](https://docs.github.com/copilot/concepts/agents/copilot-cli/fleet)。 + +--- + +# 更多工作流 + +
+
+对于已经完成第 04-06 章的进阶用户来说，下面这些工作流展示了智能体、技能和 MCP 如何成倍放大你的效率。
+
+
+
+## 集成模式
+
+下面是把这些能力组合起来时的心智模型：
+
+
+
+---
+
+## 工作流 1：问题定位与修复
+
+这是一个结合完整工具链的真实缺陷修复流程：
+
+```bash
+copilot
+
+# PHASE 1: Understand the bug from GitHub (MCP provides this)
+> Get the details of issue #1
+
+# Learn: "find_by_author doesn't work with partial names"
+
+# PHASE 2: Research best practice (deep research with web + GitHub sources)
+> /research Best practices for Python case-insensitive string matching
+
+# PHASE 3: Find related code
+> @samples/book-app-project/books.py Show me the find_by_author method
+
+# PHASE 4: Get expert analysis
+> /agent
+# Select "python-reviewer"
+
+> Analyze this method for issues with partial name matching
+
+# Agent identifies: Method uses exact equality instead of substring matching
+
+# PHASE 5: Fix with agent guidance
+> Implement the fix using lowercase comparison and 'in' operator
+
+# PHASE 6: Generate tests
+> /agent
+# Select "pytest-helper"
+
+> Generate pytest tests for find_by_author with partial matches
+> Include test cases: partial name, case variations, no matches
+
+# PHASE 7: Commit and PR
+> Generate a commit message for this fix
+
+> Create a pull request linking to issue #1
+```
+
+---
+
+
+
+## 工作流 2：代码审查自动化（可选）
+
+> 💡 **本节是可选内容。** Pre-commit hook 对团队很有价值，但并不是高效工作的前提。如果你刚开始学习，可以先跳过。
+>
+> ⚠️ **性能说明**：这个 hook 会对每个 staged 文件调用一次 `copilot -p`，每个文件都可能耗费数秒。对于较大的提交，建议只限制在关键文件上使用，或者改为手动执行 `/review`。
+
+**git hook** 是 Git 在某些特定时机会自动执行的脚本，例如在 commit 之前。你可以利用它对代码运行自动化检查。下面演示如何在提交时自动运行 Copilot 审查：
+
+```bash
+# Create a pre-commit hook
+cat > .git/hooks/pre-commit << 'EOF'
+#!/bin/bash
+
+# Get staged files (Python files only)
+STAGED=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.py$')
+
+if [ -n "$STAGED" ]; then
+ echo "Running Copilot review on staged files..."
+
+ for file in $STAGED; do
+ echo "Reviewing $file..."
+
+ # Use timeout to prevent hanging (60 seconds per file)
+ # --allow-all auto-approves file reads/writes so the hook can run unattended.
+ # Only use this in automated scripts. In interactive sessions, let Copilot ask for permission.
+ REVIEW=$(timeout 60 copilot --allow-all -p "Quick security review of @$file - critical issues only" 2>/dev/null)
+
+ # Check if timeout occurred
+ if [ $? -eq 124 ]; then
+ echo "Warning: Review timed out for $file (skipping)"
+ continue
+ fi
+
+ if echo "$REVIEW" | grep -qi "CRITICAL"; then
+ echo "Critical issues found in $file:"
+ echo "$REVIEW"
+ exit 1
+ fi
+ done
+
+ echo "Review passed"
+fi
+EOF
+
+chmod +x .git/hooks/pre-commit
+```
+
+> ⚠️ **macOS 用户注意**：macOS 默认不包含 `timeout` 命令。你可以通过 `brew install coreutils` 安装，或者把 `timeout 60` 替换为不带超时保护的简单调用。
+
+> 📚 **官方文档**：完整 hooks API 请参见 [Use hooks](https://docs.github.com/copilot/how-tos/copilot-cli/use-hooks) 和 [Hooks configuration reference](https://docs.github.com/copilot/reference/hooks-configuration)。
+>
+> 💡 **内置替代方案**：Copilot CLI 自带 hooks 系统（`copilot hooks`），可以在 pre-commit 等事件上自动运行。上面的手写 git hook 让你拥有完全控制权，而内置系统则更容易配置。可结合上面的文档，选择最适合你工作流的方式。
+
+现在，每次提交都会自动进行一次快速安全审查：
+
+```bash
+git add samples/book-app-project/books.py
+git commit -m "Update book collection methods"
+
+# Output:
+# Running Copilot review on staged files...
+# Reviewing samples/book-app-project/books.py...
+# Critical issues found in samples/book-app-project/books.py:
+# - Line 15: File path injection vulnerability in load_from_file
+#
+# Fix the issue and try again.
+```
+
+---
+
+## 工作流 3：加入一个新的代码库
+
+当你刚加入一个新项目时，可以把上下文、智能体和 MCP 结合起来，加速熟悉过程：
+
+```bash
+# Start Copilot in interactive mode
+copilot
+
+# PHASE 1: Get the big picture with context
+> @samples/book-app-project/ Explain the high-level architecture of this codebase
+
+# PHASE 2: Understand a specific flow
+> @samples/book-app-project/book_app.py Walk me through what happens
+> when a user runs "python book_app.py add"
+
+# PHASE 3: Get expert analysis with an agent
+> /agent
+# Select "python-reviewer"
+
+> @samples/book-app-project/books.py Are there any design issues,
+> missing error handling, or improvements you would recommend?
+
+# PHASE 4: Find something to work on (MCP provides GitHub access)
+> List open issues labeled "good first issue"
+
+# PHASE 5: Start contributing
+> Pick the simplest open issue and outline a plan to fix it
+```
+
+这个工作流把 `@` 上下文、智能体和 MCP 组合进了一次完整的 onboarding 会话，正好就是本章前面介绍过的集成模式。
+
+---
+
+# 最佳实践与自动化
+
+这些模式和习惯会让你的工作流更高效。
+
+---
+
+## 最佳实践
+
+### 1. 先收集上下文，再做分析
+
+在请 Copilot 分析之前，先把上下文准备好：
+
+```bash
+# Good
+> Get the details of issue #42
+> /agent
+# Select python-reviewer
+> Analyze this issue
+
+# Less effective
+> /agent
+# Select python-reviewer
+> Fix login bug
+# Agent doesn't have issue context
+```
+
+### 2. 搞清楚区别：智能体、技能和自定义指令
+
+每种工具都有自己最擅长的场景：
+
+```bash
+# Agents: Specialized personas you explicitly activate
+> /agent
+# Select python-reviewer
+> Review this authentication code for security issues
+
+# Skills: Modular capabilities that auto-activate when your prompt
+# matches the skill's description (you must create them first — see Ch 05)
+> Generate comprehensive tests for this code
+# If you have a testing skill configured, it activates automatically
+
+# Custom instructions (.github/copilot-instructions.md): Always-on
+# guidance that applies to every session without switching or triggering
+```
+
+> 💡 **关键点**：智能体和技能都可以分析代码，也都可以生成代码。真正的区别在于**如何被激活**——智能体是显式激活（`/agent`），技能是自动激活（根据提示词匹配），而自定义指令则始终生效。
+
+### 3. 让每个会话保持聚焦
+
+使用 `/rename` 给会话命名（便于在历史记录中查找），并用 `/exit` 干净地结束会话：
+
+```bash
+# Good: One feature per session
+> /rename list-unread-feature
+# Work on list unread
+> /exit
+
+copilot
+> /rename export-csv-feature
+# Work on CSV export
+> /exit
+
+# Less effective: Everything in one long session
+```
+
+### 4. 用 Copilot 让工作流可复用
+
+与其只把工作流写在 wiki 里，不如直接把它们编码到仓库中，让 Copilot 可以实际使用：
+
+- **自定义指令**（`.github/copilot-instructions.md`）：始终生效的指导，适合记录编码规范、架构规则以及 build/test/deploy 步骤。每次会话都会自动遵循。
+- **提示词文件**（`.github/prompts/`）：团队可共享的可复用参数化提示词模板，例如代码审查、组件生成或 PR 描述模板。
+- **自定义智能体**（`.github/agents/`）：把某种专门角色编码下来（例如安全审查员、文档作者），团队任何人都可以通过 `/agent` 激活。
+- **自定义技能**（`.github/skills/`）：将分步工作流指令打包，在相关场景下自动激活。
+
+> 💡 **这样做的收益**：新成员可以直接继承你的工作流——它们已经内置在仓库里，而不是只存在于某个人脑中。
+
+---
+
+## Bonus：生产环境模式
+
+这些模式是可选的，但在专业团队环境中非常有价值。
+
+### PR 描述生成器
+
+```bash
+# Generate comprehensive PR descriptions
+BRANCH=$(git branch --show-current)
+COMMITS=$(git log main..$BRANCH --oneline)
+
+copilot -p "Generate a PR description for:
+Branch: $BRANCH
+Commits:
+$COMMITS
+
+Include: Summary, Changes Made, Testing Done, Screenshots Needed"
+```
+
+### CI/CD 集成
+
+对于已经有 CI/CD 流水线的团队，你可以使用 GitHub Actions 在每个 pull request 上自动运行 Copilot 审查。这包括自动发布审查评论，并筛选关键问题。
+
+> 📖 **继续阅读**：完整的 GitHub Actions 工作流、配置选项和故障排查技巧，请参见 [CI/CD Integration](../appendices/ci-cd-integration.md)。
+
+---
+
+# 练习
+
+
+
+把完整工作流真正跑一遍。
+
+---
+
+## ▶️ 自己试试看
+
+在完成前面的演示后，再试试下面这些变体：
+
+1. **端到端挑战**：选一个小功能（例如 “列出未读图书” 或 “导出为 CSV”），然后完整走一遍工作流：
+ - 用 `/plan` 做规划
+ - 用智能体做设计（python-reviewer、pytest-helper）
+ - 实现
+ - 生成测试
+ - 创建 PR
+
+2. **自动化挑战**：按照“代码审查自动化”工作流设置 pre-commit hook。然后故意提交一个带有文件路径漏洞的修改。它会被拦下来吗？
+
+3. **你的生产工作流**：为你经常做的一类任务设计自己的工作流，并把它写成一份清单。哪些环节可以通过技能、智能体或 hook 自动化？
+
+**自我检查**：当你能够向同事解释智能体、技能和 MCP 是如何协同工作的，以及各自适合在什么场景下使用，就说明你已经完成了这门课程。
+
+---
+
+## 📝 作业
+
+### 主挑战：端到端功能开发
+
+前面的动手示例带你实现了一个 “列出未读图书” 功能。现在请把完整工作流应用到另一个功能上：**按年份范围搜索图书**：
+
+1. 启动 Copilot 并收集上下文：`@samples/book-app-project/books.py`
+2. 用 `/plan Add a "search by year" command that lets users find books published between two years` 进行规划
+3. 在 `BookCollection` 中实现 `find_by_year_range(start_year, end_year)` 方法
+4. 在 `book_app.py` 中添加 `handle_search_year()` 函数，提示用户输入起始年份和结束年份
+5. 生成测试：`@samples/book-app-project/books.py @samples/book-app-project/tests/test_books.py Generate tests for find_by_year_range() including edge cases like invalid years, reversed range, and no results.`
+6. 用 `/review` 做审查
+7. 更新 README：`@samples/book-app-project/README.md Add documentation for the new "search by year" command.`
+8. 生成 commit message
+
+请在实践过程中记录你的工作流。
+
+**成功标准**：你已经借助 Copilot CLI，从想法一路走到 commit，完整经历了规划、实现、测试、文档更新和审查。
+
+> 💡 **加分项**：如果你已经完成第 04 章并配置好了智能体，可以尝试创建和使用自定义智能体。例如，用一个 error-handler 智能体来审查实现，用一个 doc-writer 智能体来更新 README。
+
+
+
+
+---
+
+💡 提示（点击展开）
+ +**请参考本章开头的[“从想法到合并 PR”](#idea-to-merged-pr-in-one-session)示例模式。** 关键步骤如下： + +1. 用 `@samples/book-app-project/books.py` 收集上下文 +2. 用 `/plan Add a "search by year" command` 做规划 +3. 实现方法和命令处理函数 +4. 生成覆盖边界情况的测试（无效输入、空结果、反向区间） +5. 用 `/review` 做审查 +6. 用 `@samples/book-app-project/README.md` 更新 README +7. 用 `-p` 生成 commit message + +**需要考虑的边界情况：** +- 如果用户输入的是 “2000” 和 “1990”（区间反了）怎么办？ +- 如果没有任何图书落在这个区间内怎么办？ +- 如果用户输入了非数字内容怎么办？ + +**重点在于练习完整工作流**：从想法 → 上下文 → 规划 → 实现 → 测试 → 文档 → 提交。 + +
+
+
+---
+
+# 总结
+
+## 🔑 核心要点
+
+1. **集成胜于孤立**：把工具组合起来，影响最大
+2. **上下文优先**：分析前先准备好必要上下文
+3. **智能体做分析，技能做执行**：把合适的工具用在合适的环节
+4. **自动化重复工作**：Hook 和脚本会成倍放大你的效率
+5. **把工作流文档化**：可共享的模式会让整个团队都受益
+
+> 📋 **快速参考**：完整命令和快捷方式列表请参见 [GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference)。
+
+---
+
+## 🎓 课程完成！
+
+恭喜你！你已经学会了：
+
+| 章节 | 你学到的内容 |
+|---------|-------------------|
+| 00 | Copilot CLI 安装与快速开始 |
+| 01 | 三种交互模式 |
+| 02 | 使用 `@` 语法管理上下文 |
+| 03 | 开发工作流 |
+| 04 | 专门化智能体 |
+| 05 | 可扩展技能 |
+| 06 | 通过 MCP 连接外部系统 |
+| 07 | 统一的生产工作流 |
+
+现在，你已经具备用 GitHub Copilot CLI 真正放大开发效率的能力了。
+
+## ➡️ 接下来呢
+
+你的学习不会停在这里：
+
+1. **每天练习**：把 Copilot CLI 用在真实工作中
+2. **构建自定义工具**：为自己的具体需求创建智能体和技能
+3. **分享经验**：帮助团队采纳这些工作流
+4. **持续关注更新**：跟进 GitHub Copilot 的新功能发布
+
+### 资源
+
+- [GitHub Copilot CLI Documentation](https://docs.github.com/copilot/concepts/agents/about-copilot-cli)
+- [MCP Server Registry](https://github.com/modelcontextprotocol/servers)
+- [Community Skills](https://github.com/topics/copilot-skill)
+
+---
+
+**做得很棒！现在就去构建一些真正厉害的东西吧。**
+
+**[← 返回第 06 章](../06-mcp-servers/README.zh.md)** | **[返回课程首页 →](../README.md)**