Copilot 高阶使用技巧：自定义智能体与后端开发工作流实战

作为一名长期关注 AI 辅助开发的工程师，我在使用 Copilot 的过程中逐渐发现：默认的 Copilot 虽然强大，但想要真正贴合后端开发场景、提升团队协作效率，就必须深入挖掘其自定义能力。很多开发者仅停留在 Tab 补全和基础聊天的层面，未能发挥 Copilot 作为"开发智能体编排平台"的潜力。

今天这篇博客，将完全贴合后端开发场景，详细讲解如何创建自定义智能体（Agent）、设计后端开发工作流，以及如何配置一套完整的后端开发智能体套件。无论你是个人开发者还是团队协作，都能跟着配置出最适合自己的 Copilot 开发环境。

一、先理清：Copilot 默认能力 vs 后端开发真实需求

1.1 Copilot 默认提供了什么？

功能 说明 局限性
Tab 补全 基于上下文的代码补全 缺乏领域知识，无法理解业务规则
Chat 对话 自然语言交互问答 无状态，每次需重复上下文
Plan Agent 任务分解与执行计划 通用性强，但缺乏后端专项能力
内置 Skills 终端、搜索、文件操作等 无数据库优化、API设计等后端专项技能

1.2 后端开发的特殊需求

后端开发不同于前端或通用编程，它有独特的技术栈和关注点：

关注点 具体需求 默认 Copilot 能否满足？
架构设计 微服务、事件驱动、分层架构 ❌ 缺乏架构设计专项
数据库优化 索引优化、慢查询分析、性能调优 ❌ 无数据库专项能力
API 设计 RESTful 规范、版本管理、文档生成 ⚠️ 基础支持，无深度
安全审查 漏洞扫描、权限控制、数据加密 ❌ 无安全专项
测试策略 单元测试、集成测试、性能测试 ⚠️ 基础支持
DevOps CI/CD、容器化、监控告警 ❌ 无专项支持

结论：默认的 Agent + Plan + Skills 对于简单 CRUD 开发够用，但要做专业后端开发（涉及架构设计、数据库优化、API 设计、安全审查等），必须自定义智能体来填补能力缺口。

二、核心方案：自定义智能体（Agent）开发指南

2.1 什么是自定义智能体？

自定义智能体是针对特定任务或领域封装的 AI 专家。与通用 Copilot 不同，自定义智能体：

  • 专注特定领域：如数据库优化、架构设计、安全审查
  • 封装最佳实践：内置该领域的知识、规范、工具
  • 可复用可分享：一次创建，团队共享

2.2 自定义智能体的存放位置

VS Code Copilot 支持以下路径存放自定义智能体：

路径类型 存放位置 作用范围 适用场景
项目级 .github/prompts/ 或 .copilot/prompts/ 当前工作区 项目专属智能体
用户级 ~/.config/Code/User/prompts/ (Linux/Mac) 或 %APPDATA%/Code/User/prompts/ (Windows) 所有工作区 个人常用智能体
团队共享 通过 Git 子模块或共享文件夹 多个项目 团队协作智能体

后端开发推荐方案：

  • 个人开发：将常用智能体放在 ~/.config/Code/User/prompts/，随时可用
  • 团队协作：创建 awesome-copilot 仓库，存放团队共享智能体，通过 Git 子模块引入各项目

2.3 创建自定义智能体的完整步骤

以创建一个后端架构师智能体为例，演示完整流程：

步骤 1：确定智能体的职责和边界

智能体名称：backend-architect

核心职责：

  • 设计系统架构（微服务、单体、事件驱动等）
  • 输出架构图（使用 Mermaid 语法）
  • 提供技术选型建议
  • 分析非功能性需求（性能、安全、扩展性）

不涉及的职责：

  • 具体代码实现（交给开发智能体）
  • 数据库详细设计（交给 DBA 智能体）
  • 前端设计
步骤 2：编写智能体定义文件

在用户级 prompts 目录创建 backend-architect.agent.md：

mkdir -p ~/.config/Code/User/prompts
cat > ~/.config/Code/User/prompts/backend-architect.agent.md << 'EOF'
---
name: backend-architect
description: 资深后端架构师，专注于系统架构设计、技术选型、架构图输出。使用 Mermaid 语法绘制架构图，提供专业的架构建议和最佳实践。
tools: ["read", "edit", "search", "github"]
---

# 后端架构师智能体

你是一位拥有 15 年经验的资深后端架构师，曾主导过多个大型互联网系统的架构设计。你的职责是帮助开发团队设计高质量、可扩展、易维护的系统架构。

## 核心能力

1. **架构设计**
   - 微服务架构
   - 单体应用架构
   - 事件驱动架构
   - 分层架构
   - CQRS / 事件溯源

2. **技术选型**
   - 编程语言选择
   - 框架对比分析
   - 数据库选型
   - 消息队列选型
   - 缓存策略

3. **架构图绘制**
   - 使用 Mermaid 语法
   - 系统架构图
   - 数据流图
   - 部署架构图
   - 时序图

## 工作流程

当用户提出架构设计需求时，按以下步骤执行：

### 步骤 1：需求分析
- 理解业务场景和目标
- 识别核心功能和非功能需求
- 确定约束条件（预算、时间、团队技能）
- 预估系统规模（用户量、数据量、并发量）

### 步骤 2：架构方案设计
- 提出 2-3 种可行的架构方案
- 每种方案包括：架构风格、技术栈、核心组件
- 分析各方案的优缺点

### 步骤 3：详细设计
- 确定最终架构方案
- 绘制架构图（Mermaid 语法）
- 定义核心模块和接口
- 设计数据模型

### 步骤 4：输出交付物
- 架构设计文档（Markdown 格式）
- 架构图（Mermaid 语法，可渲染）
- 技术选型报告
- 风险评估和应对策略

## 输出规范

### 架构文档结构

```markdown
# {系统名称} 架构设计文档

## 1. 概述
- 项目背景
- 设计目标
- 范围界定

## 2. 架构设计
### 2.1 架构风格
### 2.2 系统架构图
\`\`\`mermaid
[架构图代码]
\`\`\`

## 3. 技术选型
### 3.1 后端技术栈
### 3.2 数据存储
### 3.3 中间件

## 4. 模块设计
### 4.1 核心模块
### 4.2 接口定义

## 5. 非功能性需求
### 5.1 性能要求
### 5.2 安全设计
### 5.3 可扩展性

## 6. 风险评估

## 7. 演进路线

架构图规范

  • 使用 Mermaid 语法
  • 图表类型：graph TD（流程图）、graph LR（横向流程图）、sequenceDiagram（时序图）
  • 颜色标识：核心业务（蓝色 #3b82f6）、数据存储（绿色 #10b981）、外部服务（橙色 #f59e0b）
  • 包含图例说明

注意事项

  1. 避免过度设计：根据实际需求选择合适的架构复杂度
  2. 考虑团队能力：技术选型需匹配团队技术栈和经验
  3. 预留扩展空间：设计时考虑未来 1-2 年的业务增长
  4. 重视非功能需求：性能、安全、可维护性与功能同等重要
  5. 文档化：所有设计决策需记录 rationale（ rationale ）

交互示例

用户：我需要设计一个电商系统的订单模块架构，日活 100 万用户，高峰期每秒 1000 订单。

架构师：

  1. 首先分析需求：

    • 日活 100 万，峰值并发高
    • 核心业务：订单创建、支付、状态流转
    • 数据一致性要求高

  2. 推荐架构方案：

    • 采用微服务架构，订单服务独立部署
    • 使用事件驱动（Event Sourcing）处理订单状态流转
    • 数据库采用读写分离 + 分库分表

  3. 绘制架构图…
    [输出 Mermaid 架构图]

  4. 技术选型建议…
    [输出详细技术选型报告]
    EOF


#### 步骤 3：验证智能体配置

1. **重启 VS Code** 或 **Reload Window**
2. 打开 Copilot Chat，输入 `@`，查看是否出现 `backend-architect` 选项
3. 测试智能体：输入 `@backend-architect 帮我设计一个用户认证系统的架构`

#### 步骤 4：迭代优化

根据实际使用情况，不断优化智能体：
- 调整提示词（Prompt），让输出更符合预期
- 补充示例，提升场景覆盖度
- 添加工具（Tools），扩展能力边界

### 2.4 推荐的智能体清单（后端开发专用）

以下是我为后端开发整理的**核心智能体套件**，按优先级分类：

#### P0 - 核心必备（必装）

| 智能体 | 文件名 | 功能 | 使用场景 |
|-------|--------|------|---------|
| **架构师** | `backend-architect.agent.md` | 系统架构设计、技术选型 | 新项目启动、架构评审 |
| **调试专家** | `debug.agent.md` | 系统化调试、根因分析 | Bug 排查、性能问题 |
| **规划师** | `planner.agent.md` | 任务拆解、计划制定 | 需求分析、迭代规划 |
| **规格书编写** | `specification.agent.md` | 技术规格文档生成 | 设计文档、接口文档 |
| **QA 专家** | `qa-subagent.agent.md` | 测试计划、边界分析 | 测试设计、质量保障 |

#### P1 - 技术专项（按需安装）

| 技术领域 | 智能体 | 功能 | 适用场景 |
|---------|-------|------|---------|
| **数据库** | `mongodb-performance-advisor.agent.md` | MongoDB 性能分析与索引优化 | MongoDB 项目 |
| | `postgresql-dba.agent.md` | PostgreSQL 调优与查询优化 | PostgreSQL 项目 |
| **API 设计** | `api-architect.agent.md` | REST/GraphQL API 设计 | 接口设计阶段 |
| **代码审查** | `gilfoyle.agent.md` | 毒舌代码审查（趣味+实用） | 代码 Review |
| | `se-security-reviewer.agent.md` | 安全漏洞审查 | 安全审计 |
| **测试** | `polyglot-test-planner.agent.md` | 多语言测试策略 | 测试规划 |
| | `playwright-tester.agent.md` | E2E 测试 | UI 自动化测试 |
| **DevOps** | `github-actions-expert.agent.md` | CI/CD 流程 | 流水线配置 |
| **文档** | `gem-documentation-writer.agent.md` | 技术文档编写 | 文档生成 |

#### P2 - 特定语言专家（选装）

| 语言/框架 | 智能体 | 功能 |
|----------|-------|------|
| **.NET** | `expert-dotnet-software-engineer.agent.md` | .NET 专家模式，设计模式、最佳实践 |
| **Java** | `java-mcp-expert.agent.md` | Java 专家，Spring 生态 |
| **Python** | `python-mcp-expert.agent.md` | Python 专家，FastAPI/Django |
| **Go** | `go-mcp-expert.agent.md` | Go 专家，微服务/云原生 |
| **Node.js** | `typescript-mcp-expert.agent.md` | TypeScript/Node 专家 |

---

## 三、实战：后端开发完整工作流设计

光有智能体还不够，关键是**设计一套完整的工作流**，让不同智能体协同工作。以下是我为后端开发设计的**四阶段工作流**。

### 3.1 工作流总览

```mermaid
flowchart TD
    A[需求输入] --> B{Phase 1: 设计阶段}
    B --> C[调用 @backend-architect<br/>设计系统架构]
    C --> D[输出 Architecture.md<br/>架构图 + 技术选型]
    D --> E{Phase 2: 规划阶段}
    E --> F[调用 @planner<br/>制定实现计划]
    F --> G[输出 plan.yaml<br/>任务拆分 + 依赖关系]
    G --> H[调用 @specification<br/>编写技术规格]
    H --> I[输出 spec-xxx.md<br/>接口定义 + 数据模型]
    I --> J{Phase 3: 开发阶段}
    J --> K{具体任务类型?}
    K -->|API 设计| L[调用 @api-architect]
    K -->|数据库设计| M[调用 @mongodb-performance-advisor<br/>或 @postgresql-dba]
    K -->|业务逻辑| N[编码实现]
    K -->|.NET 项目| O[调用 @expert-dotnet-software-engineer]
    L --> P[代码审查]
    M --> P
    N --> P
    O --> P
    P --> Q{Phase 4: 验证阶段}
    Q --> R[单元测试]
    R --> S[调用 @qa-subagent<br/>全面测试计划]
    S --> T[调用 @se-security-reviewer<br/>安全审查]
    T --> U{Bug?}
    U -->|是| V[调用 @debug<br/>根因分析]
    V --> N
    U -->|否| W[调用 @gem-documentation-writer<br/>生成文档]
    W --> X[CI/CD 部署]

3.2 Phase 1：设计阶段（启动时）

触发时机：新项目启动、新模块开发、架构评审

执行流程：

# 1. 用户输入需求
"我需要设计一个电商系统的订单模块，日活 100 万用户，峰值每秒 1000 订单"

# 2. 调用架构师智能体
@backend-architect 帮我设计一个电商订单系统的架构

# 3. 架构师输出
- 《OrderService_Architecture.md》 系统架构文档
  - 系统上下文图（Mermaid）
  - 组件架构图（Mermaid）
  - 部署架构图（Mermaid）
  - 技术选型报告
  - 非功能性需求分析（性能、安全、扩展性）

输出示例（Architecture.md 结构）：

# OrderService 架构设计文档

## 1. 概述
### 1.1 项目背景
电商系统核心模块，支撑日均 100 万活跃用户

### 1.2 设计目标
- 支撑峰值 1000 TPS 订单创建
- 订单数据最终一致性
- 99.99% 可用性

## 2. 架构设计

### 2.1 架构风格
采用微服务架构 + 事件驱动模式

### 2.2 系统架构图
```mermaid
graph TB
    GW[API Gateway<br/>Kong] --> OS[Order Service<br/>Node.js]
    OS --> DB[(Order DB<br/>PostgreSQL)]
    OS --> ES[Event Store<br/>Kafka]
    ES --> PS[Payment Service]
    ES --> IS[Inventory Service]
    PS --> NS[Notification Service]
    style OS fill:#3b82f6,color:#fff
    style DB fill:#10b981,color:#fff
    style ES fill:#f59e0b,color:#fff

2.3 技术选型

组件 选型 理由
服务框架 NestJS 内置依赖注入、支持微服务
数据库 PostgreSQL 强一致性、支持 JSON
消息队列 Kafka 高吞吐、持久化
缓存 Redis 分布式锁、限流

3. 非功能性需求

3.1 性能

  • 订单创建 P99 < 200ms
  • 数据库连接池：50-100

3.2 安全

  • 敏感字段加密存储
  • 接口防刷限流

4. 风险评估

…

5. 演进路线

  • Phase 1: MVP 单体架构
  • Phase 2: 服务拆分
  • Phase 3: 多活架构

### 3.3 Phase 2：规划阶段（设计完成后）

**触发时机**：架构文档完成后，进入编码前

**执行流程**：

```bash
# 1. 调用规划师智能体
@planner 基于 OrderService_Architecture.md 制定开发计划

# 2. 规划师输出
- 《plan.yaml》 执行计划
  - 任务列表（ID、描述、优先级、预估工时）
  - 依赖关系
  - 里程碑节点

# 3. 调用规格书编写智能体
@specification 编写订单模块的技术规格

# 4. 规格书输出
- 《spec-order-module.md》 技术规格
  - 接口定义（OpenAPI 规范）
  - 数据模型（ER 图）
  - 业务规则
  - 错误码定义

plan.yaml 示例：

plan_id: order-service-2024
project: OrderService
version: 1.0.0
created_at: 2026-02-26

objective: 完成订单服务核心功能开发

phases:
  - name: 基础架构
    tasks:
      - id: T001
        title: 项目脚手架搭建
        description: NestJS 项目初始化，配置 ESLint、Prettier
        estimated_hours: 2
        assignee: backend-dev-1
        status: pending

      - id: T002
        title: 数据库设计
        description: 创建 Order、OrderItem 实体，配置 TypeORM
        estimated_hours: 4
        assignee: backend-dev-1
        status: pending
        dependencies: [T001]

  - name: 核心功能
    tasks:
      - id: T003
        title: 订单创建接口
        description: POST /api/orders 实现，含参数校验
        estimated_hours: 6
        assignee: backend-dev-2
        status: pending
        dependencies: [T002]

      - id: T004
        title: 订单状态流转
        description: 状态机实现，支持取消、支付、发货
        estimated_hours: 8
        assignee: backend-dev-2
        status: pending
        dependencies: [T003]

  - name: 测试与优化
    tasks:
      - id: T005
        title: 单元测试
        description: 核心服务单元测试，覆盖率 >80%
        estimated_hours: 6
        assignee: qa-engineer
        status: pending
        dependencies: [T004]

      - id: T006
        title: 性能测试
        description: 压测脚本，验证 1000 TPS 目标
        estimated_hours: 4
        assignee: qa-engineer
        status: pending
        dependencies: [T005]

milestones:
  - name: 基础完成
    target_date: 2026-03-05
    tasks: [T001, T002]

  - name: 功能完成
    target_date: 2026-03-15
    tasks: [T003, T004]

  - name: 发布就绪
    target_date: 2026-03-20
    tasks: [T005, T006]

3.4 Phase 3：开发阶段（编码中）

触发时机：按计划执行具体开发任务

执行流程：

# 场景 1：API 设计
@api-architect 设计订单创建接口，包含请求参数、响应格式、错误码

# 场景 2：数据库优化（MongoDB 项目）
@mongodb-performance-advisor 分析订单查询慢的问题，给出索引优化建议

# 场景 3：数据库优化（PostgreSQL 项目）
@postgresql-dba 分析订单表的查询性能，优化慢 SQL

# 场景 4：.NET 项目开发
@expert-dotnet-software-engineer 使用 DDD 模式实现订单领域模型

# 场景 5：代码审查
@gilfoyle 审查这段订单服务的代码，给出改进建议

3.5 Phase 4：验证阶段（完成后）

触发时机：开发完成后，发布前

执行流程：

# 1. 自测
npm test  # 或 pytest、dotnet test 等

# 2. QA 全面测试
@qa-subagent 为订单模块制定全面的测试计划，包括边界测试、异常测试

# 3. 安全审查
@se-security-reviewer 审查订单模块的安全漏洞，包括 SQL 注入、越权访问

# 4. Bug 修复（如有）
@debug 分析订单创建偶尔失败的问题

# 5. 文档生成
@gem-documentation-writer 为订单模块生成 API 文档和开发手册

# 6. CI/CD 部署
# 使用 github-actions-expert 配置流水线

四、完整配置：后端开发智能体套件

4.1 推荐的智能体清单（后端开发专用）

以下是我为你整理的完整后端开发智能体套件，按优先级分类：

P0 - 核心必备（必装）
智能体 文件名 功能 使用场景
架构师 backend-architect.agent.md 系统架构设计、技术选型 新项目启动、架构评审
调试专家 debug.agent.md 系统化调试、根因分析 Bug 排查、性能问题
规划师 planner.agent.md 任务拆解、计划制定 需求分析、迭代规划
规格书编写 specification.agent.md 技术规格文档生成 设计文档、接口文档
QA 专家 qa-subagent.agent.md 测试计划、边界分析 测试设计、质量保障
P1 - 技术专项（按需安装）
技术领域 智能体 功能 适用场景
数据库 mongodb-performance-advisor.agent.md MongoDB 性能分析与索引优化 MongoDB 项目
postgresql-dba.agent.md PostgreSQL 调优与查询优化 PostgreSQL 项目
API 设计 api-architect.agent.md REST/GraphQL API 设计 接口设计阶段
代码审查 gilfoyle.agent.md 毒舌代码审查（趣味+实用） 代码 Review
se-security-reviewer.agent.md 安全漏洞审查 安全审计
测试 polyglot-test-planner.agent.md 多语言测试策略 测试规划
playwright-tester.agent.md E2E 测试 UI 自动化测试
DevOps github-actions-expert.agent.md CI/CD 流程 流水线配置
文档 gem-documentation-writer.agent.md 技术文档编写 文档生成
P2 - 特定语言专家（选装）
语言/框架 智能体 功能
.NET expert-dotnet-software-engineer.agent.md .NET 专家模式，设计模式、最佳实践
Java java-mcp-expert.agent.md Java 专家，Spring 生态
Python python-mcp-expert.agent.md Python 专家，FastAPI/Django
Go go-mcp-expert.agent.md Go 专家，微服务/云原生
Node.js typescript-mcp-expert.agent.md TypeScript/Node 专家

4.2 快速安装脚本

为了帮助你快速部署这套智能体套件，我提供了一个安装脚本：

#!/bin/bash
# install-backend-agents.sh
# 后端开发智能体套件一键安装脚本

set -e

# 配置
AGENT_REPO="https://github.com/your-org/awesome-copilot.git"
INSTALL_DIR="${HOME}/.config/Code/User/prompts"
BACKUP_DIR="${HOME}/.config/Code/User/prompts-backup-$(date +%Y%m%d%H%M%S)"

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

echo "========================================"
echo "  后端开发智能体套件安装程序"
echo "========================================"
echo ""

# 检查 VS Code 是否安装
if ! command -v code &> /dev/null; then
    echo -e "${RED}错误：未检测到 VS Code，请先安装 VS Code${NC}"
    exit 1
fi

# 备份现有配置
if [ -d "$INSTALL_DIR" ]; then
    echo -e "${YELLOW}备份现有智能体配置到: $BACKUP_DIR${NC}"
    mkdir -p "$BACKUP_DIR"
    cp -r "$INSTALL_DIR"/* "$BACKUP_DIR"/ 2>/dev/null || true
fi

# 创建安装目录
echo -e "${GREEN}创建安装目录: $INSTALL_DIR${NC}"
mkdir -p "$INSTALL_DIR"

# 克隆或下载智能体仓库
echo -e "${GREEN}下载后端开发智能体套件...${NC}"
if command -v git &> /dev/null; then
    git clone --depth 1 "$AGENT_REPO" /tmp/awesome-copilot
    cp /tmp/awesome-copilot/agents/*.agent.md "$INSTALL_DIR"/ 2>/dev/null || true
    rm -rf /tmp/awesome-copilot
else
    echo -e "${YELLOW}未安装 Git，尝试使用 curl/wget 下载...${NC}"
    # 这里可以添加 curl/wget 下载逻辑
fi

# 创建 P0 核心智能体（如果下载失败，创建基础版本）
echo -e "${GREEN}确保 P0 核心智能体已安装...${NC}"

# 创建 backend-architect 基础版（如果不存在）
if [ ! -f "$INSTALL_DIR/backend-architect.agent.md" ]; then
    cat > "$INSTALL_DIR/backend-architect.agent.md" << 'EOF'
---
name: backend-architect
description: 资深后端架构师，专注于系统架构设计、技术选型、架构图输出。
tools: ["read", "edit", "search"]
---

# 后端架构师智能体

你是一位拥有 15 年经验的资深后端架构师...

[此处省略完整内容，参考前文]
EOF
fi

# 创建其他 P0 智能体的占位符或基础版本
for agent in planner debug specification qa-subagent; do
    if [ ! -f "$INSTALL_DIR/${agent}.agent.md" ]; then
        echo -e "${YELLOW}注意: ${agent}.agent.md 未找到，请从仓库手动安装${NC}"
    fi
done

# 验证安装
echo ""
echo -e "${GREEN}========================================${NC}"
echo -e "${GREEN}  安装完成！已安装的智能体:${NC}"
echo -e "${GREEN}========================================${NC}"
echo ""

ls -1 "$INSTALL_DIR"/*.agent.md 2>/dev/null | while read file; do
    name=$(basename "$file" .agent.md)
    echo -e "  ✅ ${GREEN}@$name${NC}"
done

echo ""
echo -e "${YELLOW}使用方法:${NC}"
echo "  1. 重启 VS Code 或按 Ctrl+Shift+P → 'Developer: Reload Window'"
echo "  2. 打开 Copilot Chat (Ctrl+Alt+I)"
echo "  3. 输入 @ 查看可用智能体"
echo "  4. 例如: @backend-architect 帮我设计一个电商系统架构"
echo ""
echo -e "${YELLOW}提示:${NC}"
echo "  - 备份文件位于: $BACKUP_DIR"
echo "  - 如需卸载，删除目录: $INSTALL_DIR"
echo "  - 更多智能体请访问: https://github.com/your-org/awesome-copilot"
echo ""

4.3 配置验证清单

安装完成后，使用以下清单验证配置是否正确：

## 后端开发智能体套件验证清单

### 基础配置
- [ ] VS Code 已安装 Copilot 扩展
- [ ] Copilot Chat 可以正常使用
- [ ] 智能体目录 `~/.config/Code/User/prompts/` 已创建

### 智能体安装
- [ ] @backend-architect 可以调用
- [ ] @planner 可以调用
- [ ] @debug 可以调用
- [ ] @specification 可以调用
- [ ] @qa-subagent 可以调用

### 功能验证
- [ ] @backend-architect 能输出 Mermaid 架构图
- [ ] @planner 能生成带依赖关系的计划
- [ ] @debug 能分析错误日志并定位问题
- [ ] @specification 能生成 OpenAPI 接口文档
- [ ] @qa-subagent 能识别边界条件和测试场景

### 工作流验证
- [ ] 能完成 Phase 1: 架构设计 → 输出 Architecture.md
- [ ] 能完成 Phase 2: 规划 → 输出 plan.yaml + spec.md
- [ ] 能完成 Phase 3: 开发 → 调用专项智能体编码
- [ ] 能完成 Phase 4: 验证 → 测试 + 安全审查

五、高级技巧：自定义智能体的进阶玩法

5.1 让智能体协同工作

单个智能体能力有限，但多个智能体协同可以完成复杂任务。以下是一个多智能体协作示例：

用户：帮我完成一个完整的订单服务开发，从架构设计到测试

Step 1: @backend-architect 设计订单服务整体架构
   ↓ 输出 Architecture.md

Step 2: @planner 基于架构文档制定开发计划
   ↓ 输出 plan.yaml

Step 3: @specification 编写订单模块接口规格
   ↓ 输出 spec-order-module.md

Step 4: @expert-dotnet-software-engineer 实现订单领域模型（假设是 .NET 项目）
   ↓ 输出 OrderService 代码

Step 5: @mongodb-performance-advisor 优化订单查询性能（假设用 MongoDB）
   ↓ 输出索引优化建议

Step 6: @qa-subagent 制定全面测试计划
   ↓ 输出测试用例

Step 7: @se-security-reviewer 审查安全漏洞
   ↓ 输出安全报告

Step 8: @gem-documentation-writer 生成项目文档
   ↓ 输出 README.md + API 文档

5.2 智能体的条件触发

你可以设置条件触发器，让智能体在特定场景自动介入：

# 智能体触发规则配置示例
triggers:
  # 当检测到错误日志时，自动调用 debug 智能体
  - condition: "file_pattern: '*.log' AND content_match: 'ERROR|Exception'"
    action: "@debug 分析这个错误日志"

  # 当创建新的 Controller 文件时，自动调用 API 设计智能体
  - condition: "file_pattern: '*Controller.cs' AND event: 'create'"
    action: "@api-architect 审查这个 Controller 的 API 设计"

  # 当检测到慢查询时，自动调用 DBA 智能体
  - condition: "file_pattern: '*.sql' AND content_match: 'duration > 1000ms'"
    action: "@postgresql-dba 优化这个慢查询"

5.3 创建智能体技能（Skills）

除了创建智能体，你还可以创建技能（Skills），将可复用的能力封装起来：

# 文件位置：.github/skills/database-optimization/SKILL.md

---
name: database-optimization
description: 数据库性能优化专家技能，包含索引优化、查询优化、慢查询分析等能力。
---

# 数据库优化技能

## 适用场景

- 数据库查询变慢
- 需要设计索引
- 慢查询日志分析
- 数据库性能调优

## 工作流程

### 步骤 1：收集信息
- 数据库类型和版本
- 当前表结构和数据量
- 慢查询日志（如有）
- 业务查询场景

### 步骤 2：分析诊断
- 使用 EXPLAIN 分析查询计划
- 识别全表扫描
- 找出缺失的索引
- 分析锁竞争

### 步骤 3：优化实施
- 创建合适的索引
- 重写低效的 SQL
- 调整数据库参数
- 优化表结构

### 步骤 4：验证效果
- 对比优化前后的性能指标
- 监控数据库负载
- 确认业务正常

## 最佳实践

1. **索引设计原则**
   - 选择性高的字段优先
   - 联合索引遵循最左前缀
   - 避免过多索引（影响写入）

2. **查询优化原则**
   - 避免 SELECT *
   - 使用 LIMIT 限制返回条数
   - 大表分页优化

3. **监控指标**
   - QPS（每秒查询数）
   - 慢查询比例
   - 连接数使用率
   - 缓存命中率

5.4 团队共享配置

为了让团队成员使用统一的智能体配置，可以创建团队共享仓库：

# 团队共享智能体仓库结构
awesome-copilot/
├── README.md                    # 使用说明
├── agents/                      # 智能体定义
│   ├── backend-architect.agent.md
│   ├── debug.agent.md
│   ├── planner.agent.md
│   └── ...
├── skills/                      # 共享技能
│   ├── database-optimization/
│   │   └── SKILL.md
│   ├── api-design/
│   │   └── SKILL.md
│   └── ...
├── prompts/                     # 提示词模板
│   ├── code-review.template.md
│   ├── pr-description.template.md
│   └── ...
└── workflows/                   # 工作流定义
    ├── backend-development.yaml
    ├── bug-fix.yaml
    └── code-review.yaml

团队成员使用方法：

# 方式 1：Git 子模块（推荐）
cd your-project
git submodule add https://github.com/your-org/awesome-copilot.git .copilot
cd .copilot && ./install.sh

# 方式 2：符号链接
ln -s /path/to/awesome-copilot/agents/* ~/.config/Code/User/prompts/

# 方式 3：VS Code 扩展（如果开发了配套扩展）
# 在 VS Code 扩展市场搜索 "Awesome Copilot" 并安装

六、常见问题与解决方案

6.1 智能体不生效

问题：创建了 .agent.md 文件，但在 Copilot Chat 中输入 @ 看不到该智能体。

解决方案：

  1. 检查文件路径：确保文件放在正确的 prompts 目录下

    # 用户级
ls ~/.config/Code/User/prompts/*.agent.md

# 项目级
ls .github/prompts/*.agent.md

  2. 检查文件命名：必须以 .agent.md 结尾

    # 正确的
backend-architect.agent.md

# 错误的
backend-architect.md
backend-architect-agent.md

  3. 检查 YAML 前置元数据：必须包含 name 和 description

    ---
name: backend-architect
description: 后端架构师智能体
---

  4. 重启 VS Code：修改后需要 Reload Window

    Ctrl+Shift+P → Developer: Reload Window

6.2 智能体输出不符合预期

问题：智能体的输出质量不高，或者不符合项目需求。

解决方案：

  1. 优化提示词（Prompt）：

    • 添加更多示例（Few-shot）
    • 明确输出格式要求
    • 添加约束条件（如"必须使用 Mermaid 语法"）

  2. 添加项目上下文：

    • 创建 .github/copilot-instructions.md 包含项目规范
    • 在智能体提示词中引用项目特定规则

  3. 迭代优化：

    • 记录不满意的输出案例
    • 针对性调整提示词
    • 测试多种输入场景

6.3 多个智能体如何协作

问题：复杂任务需要多个智能体协作，如何编排？

解决方案：

  1. 手动编排（适合一次性任务）：

    Step 1: @backend-architect 设计架构
Step 2: @planner 制定计划
Step 3: @expert-dotnet-software-engineer 实现代码
Step 4: @qa-subagent 设计测试

  2. 工作流定义（适合重复性任务）：
    创建 .github/workflows/development.yaml：

    workflow:
  name: Backend Development Pipeline
  steps:
    - agent: backend-architect
      output: architecture.md

    - agent: planner
      input: architecture.md
      output: plan.yaml

    - parallel:
      - agent: expert-dotnet-software-engineer
        input: plan.yaml
        scope: implementation

      - agent: api-architect
        input: architecture.md
        scope: api-design

    - agent: qa-subagent
      input: [implementation, api-design]
      output: test-plan.md

    - agent: se-security-reviewer
      input: implementation
      output: security-report.md

  3. 使用父智能体编排（适合复杂协作）：
    创建一个编排智能体 orchestrator.agent.md：

    # 编排器智能体

你是一位项目协调专家，擅长将复杂任务拆解并分派给专业智能体。

当用户提出复杂需求时，你应该：
1. 分析需求，确定需要哪些专业智能体
2. 按顺序调用各个智能体
3. 传递上下文，确保信息不丢失
4. 整合各智能体的输出，形成完整方案

可用的专业智能体：
- @backend-architect - 架构设计
- @planner - 任务规划
- @expert-dotnet-software-engineer - .NET 开发
- @mongodb-performance-advisor - MongoDB 优化
- @qa-subagent - 测试设计
- @se-security-reviewer - 安全审查

七、总结：从"工具使用者"到"智能体设计师"

通过本文的详细介绍，相信你已经掌握了 Copilot 自定义智能体的完整方法。让我们回顾一下核心要点：

7.1 核心收获

  1. 默认 Copilot 不够用：对于专业后端开发，必须自定义智能体填补能力缺口

  2. 智能体三要素：

    • 明确的职责边界
    • 详细的提示词（Prompt）
    • 规范的输出格式

  3. 四阶段工作流：

    • Phase 1: 设计（架构师）
    • Phase 2: 规划（规划师 + 规格书编写）
    • Phase 3: 开发（专项智能体）
    • Phase 4: 验证（QA + 安全审查）

  4. 团队协作关键：建立共享智能体仓库，统一团队配置

7.2 行动清单

为了帮助你快速落地，以下是立即行动清单：

## Week 1: 基础搭建
- [ ] 创建 `~/.config/Code/User/prompts/` 目录
- [ ] 安装 P0 核心智能体（backend-architect、planner、debug、specification、qa-subagent）
- [ ] 验证智能体可正常调用
- [ ] 在一个小项目中试用完整工作流

## Week 2: 专项增强
- [ ] 根据技术栈安装数据库智能体（MongoDB/PostgreSQL DBA）
- [ ] 安装 API 设计智能体
- [ ] 安装语言专家智能体（如 .NET/Java/Python）
- [ ] 在真实业务需求中验证专项智能体效果

## Week 3: 团队协作
- [ ] 创建团队共享智能体仓库
- [ ] 编写团队专属智能体（符合项目规范）
- [ ] 制定团队使用规范（何时调用哪个智能体）
- [ ] 培训团队成员使用

## Week 4: 优化迭代
- [ ] 收集团队反馈
- [ ] 优化智能体提示词
- [ ] 创建工作流模板（标准化四阶段工作流）
- [ ] 建立最佳实践文档

7.3 未来展望

自定义智能体的能力还在快速演进，以下是一些值得关注的趋势：

  1. MCP（Model Context Protocol）集成：智能体将能够调用更多外部工具和 API
  2. 多模态智能体：不仅处理文本，还能理解代码结构、生成架构图
  3. 自进化智能体：根据用户反馈自动优化提示词和行为
  4. 团队智能体市场：像 VS Code 扩展市场一样，共享和复用智能体

7.4 最后的建议

  1. 从小处开始：不要试图一次性配置所有智能体，从 P0 核心开始，逐步扩展
  2. 持续迭代：根据实际使用效果，不断优化智能体的提示词
  3. 文档化：记录每个智能体的职责和使用场景，方便团队成员查阅
  4. 保持开放：关注 Copilot 的新特性，及时更新智能体以利用新能力

希望这篇博客能帮助你充分发挥 Copilot 的潜力，打造属于自己的后端开发智能体团队。如果你有任何问题或想分享你的智能体配置经验，欢迎在评论区留言交流～

参考资源

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/Lvyizhuo/article/details/[文章ID]

# copilot
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

cover

AI人工智能——详解人工智能算力高质量发展评估体系报告【附全文阅读】

avatar 2048 AI社区

我与AI: 盘一盘我是怎么在项目开发中应用Agent Skills的

本文总结了AI Agent Skills在2025年开发实践中的应用价值与设计理念。Skills通过标准化封装专业知识，实现专家级稳定输出、组织知识资产化、跨平台复用和复杂任务处理。其核心创新是渐进式披露机制：元数据层(100token/技能)始终加载，主体指令层(1000-5000token)触发加载，附加资源层按需调用。这种设计显著优化了上下文管理效率，相比传统MCP方式可减少95%初始tok

avatar 2048 AI社区
cover

应对OpenClaw安全困局，eSign EATI为AI智能体“上户口

avatar 2048 AI社区