<!-- title: Claude Code /simplify与/batch：批量代码操作实战 -->

# Claude Code /simplify与/batch：批量代码操作实战

## 概述

Claude Code v2.1.63 引入了两个革命性的内置命令：`/simplify` 和 `/batch`。前者通过三个并行审查Agent自动优化已更改代码，后者以"计划-执行"模式批量处理大规模代码迁移。本教程面向已掌握 Claude Code 基础操作的开发者，深入拆解这两个命令的内部机制、实战模式和组合技巧，帮助你将AI驱动的代码质量提升与批量重构纳入日常工作流。

**适用人群**：已使用 Claude Code 1个月以上的中高级开发者，团队技术负责人，以及需要大规模代码迁移的架构师。

**学习目标**：
- 掌握 `/simplify` 三Agent并行审查的内部机制与调优方法
- 理解 `/batch` 的计划-执行两阶段模式与文件分组策略
- 学会在 CI/CD 和 headless 模式中集成这两个命令
- 构建一个完整的批量迁移实战流水线

---

## 前置条件

| 条件 | 说明 |
|------|------|
| Claude Code 版本 | ≥ v2.1.63（2026年3月发布） |
| API 访问 | Anthropic API Key，推荐 Pro/Max 计划 |
| Git 基础 | 理解 diff、stash、branch 操作 |
| 项目状态 | 建议在一个有 Git 历史的现有项目上练习 |
| Token 预算 | /batch 大规模操作可能消耗较多 Token，建议预留额度 |

版本检查命令：

```bash
claude --version
# 确保输出 ≥ 2.1.63
```

---

## 第一章：/simplify 深度解析

### 1.1 /simplify 是什么

`/simplify` 是一个**后实现清理命令**。在你完成功能开发或代码修改之后，它自动分析你的 Git diff，识别最近更改的文件，然后启动三个并行的审查Agent，每个Agent专注不同维度的代码质量，最终汇总发现并直接修复问题。

它解决的核心痛点是：**AI生成的代码能用但臃肿**。无论是你手写还是Claude Code生成的代码，在快速迭代中总会积累重复逻辑、过度工程、命名不当等问题。`/simplify` 就是你的自动化代码质量守门人。

### 1.2 三Agent并行审查架构

`/simplify` 的核心创新在于它的三Agent并行审查机制：

```
                    ┌──────────────────────┐
                    │   /simplify 启动     │
                    │  读取 git diff       │
                    └──────────┬───────────┘
                               │
              ┌────────────────┼────────────────┐
              ▼                ▼                 ▼
    ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
    │  Agent 1:       │ │  Agent 2:       │ │  Agent 3:       │
    │  代码复用审查   │ │  代码质量审查   │ │  执行效率审查   │
    │                 │ │                 │ │                 │
    │  - 重复代码检测 │ │  - 命名规范     │ │  - 不必要计算   │
    │  - 抽象机会    │ │  - 函数复杂度   │ │  - 冗余I/O     │
    │  - 模式统一    │ │  - 类型安全     │ │  - 内存泄漏     │
    └────────┬────────┘ └────────┬────────┘ └────────┬────────┘
             │                   │                   │
             └───────────────────┼───────────────────┘
                                 ▼
                    ┌──────────────────────┐
                    │   汇总报告 + 自动修复 │
                    └──────────────────────┘
```

**Agent 1 — 代码复用审查**：
- 扫描更改文件中的重复代码块
- 识别可以提取为公共函数或工具类的片段
- 检查是否已有项目内的相似实现可以复用
- 建议统一编码模式（如错误处理、日志格式）

**Agent 2 — 代码质量审查**：
- 检查变量和函数命名的语义清晰度
- 评估函数的圈复杂度和认知复杂度
- 验证类型标注的完整性（TypeScript/Python）
- 检查文档注释是否存在且有实际价值

**Agent 3 — 执行效率审查**：
- 检测不必要的重复计算或循环
- 识别可以延迟加载的资源
- 发现冗余的I/O操作（多余的文件读写、网络请求）
- 标记潜在的内存泄漏或不合理的对象生命周期

### 1.3 基础用法

最简单的使用方式——在完成一段代码修改后直接运行：

```bash
# 在 Claude Code 交互模式中输入
/simplify
```

Claude Code 会自动：
1. 执行 `git diff` 获取当前未暂存的更改
2. 分析涉及的文件列表和变更内容
3. 启动三个并行Subagent进行审查
4. 汇总结果并展示发现的问题
5. 询问是否自动修复

**预期输出示例**：

```
Running /simplify on your recent changes...

3 review agents completed:
┌─────────────┬──────────┬──────────┐
│ Agent        │ Issues   │ Severity │
├─────────────┼──────────┼──────────┤
│ Reuse        │ 4 found  │ 2 medium │
│ Quality      │ 3 found  │ 1 high   │
│ Efficiency   │ 2 found  │ 1 medium │
└─────────────┴──────────┴──────────┘

Key findings:
1. [Quality-HIGH] `processOrder()` has cyclomatic complexity of 15
   → Suggestion: Extract validation logic into separate function
2. [Reuse-MED] Duplicate error handling pattern in 3 files
   → Suggestion: Create shared `handleApiError()` utility
3. [Efficiency-MED] `getUserData()` called twice in same flow
   → Suggestion: Cache result from first call

Apply fixes? (Y/n)
```

### 1.4 高级用法：指定审查范围

```bash
# 只审查特定文件
/simplify src/api/orders.ts src/api/payments.ts

# 审查最近3次提交的变更
/simplify --since HEAD~3

# 结合 git stash 审查已暂存的变更
git stash
/simplify --staged
```

### 1.5 /simplify 与 /review 的区别

| 维度 | /simplify | /review |
|------|-----------|---------|
| 目的 | 代码精简和质量提升 | 纯审查，发现问题 |
| Agent数 | 3个并行 | 可配置，通常5+个 |
| 输出 | 诊断 + **自动修复** | 仅报告，不修改代码 |
| 适用时机 | 功能完成后、提交前 | PR审查、代码审计 |
| 修改代码 | **会修改** | **不会修改**（只读） |
| Token消耗 | 中等（修复需要额外Token） | 较低（只读分析） |

**选择原则**：
- 你想**直接修复问题** → `/simplify`
- 你只想**看报告**再自己决定 → `/review`
- 在CI中做**质量门禁** → `/review`（因为不应在CI中自动修改代码）
- 提交前的**最后一道检查** → `/simplify`

### 1.6 实战案例：优化一个React组件

假设你刚用 Claude Code 生成了一个复杂的订单管理组件：

```typescript
// OrderDashboard.tsx — 生成后的初始版本（约280行）
import React, { useState, useEffect } from 'react';
import { fetchOrders, fetchUsers, fetchProducts } from './api';
import { format } from 'date-fns';

export function OrderDashboard() {
  const [orders, setOrders] = useState([]);
  const [users, setUsers] = useState([]);
  const [products, setProducts] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  const [filter, setFilter] = useState('all');

  useEffect(() => {
    const loadData = async () => {
      try {
        setLoading(true);
        const [o, u, p] = await Promise.all([
          fetchOrders(),
          fetchUsers(),
          fetchProducts()
        ]);
        setOrders(o);
        setUsers(u);
        setProducts(p);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    };
    loadData();
  }, []);

  // 以下有大量重复的过滤、排序、格式化逻辑...
  // 嵌套的三元运算符...
  // 重复的 loading/error 处理...
}
```

运行 `/simplify` 后的典型优化：

```typescript
// OrderDashboard.tsx — /simplify 优化后（约120行）
import React, { useState, useEffect, useMemo } from 'react';
import { useApi } from '../hooks/useApi';      // 复用现有hook
import { formatDate, formatCurrency } from '../utils/formatters'; // 统一格式化
import { FilterBar } from './FilterBar';       // 提取的子组件
import { OrderTable } from './OrderTable';     // 提取的子组件

export function OrderDashboard() {
  const { data: orders, loading, error } = useApi(fetchOrders);
  const { data: users } = useApi(fetchUsers);
  const { data: products } = useApi(fetchProducts);
  const [filter, setFilter] = useState('all');

  const enrichedOrders = useMemo(() =>
    orders?.map(order => ({
      ...order,
      userName: users?.find(u => u.id === order.userId)?.name,
      productName: products?.find(p => p.id === order.productId)?.name,
    })) ?? [],
    [orders, users, products]
  );

  if (loading) return <LoadingSpinner />;
  if (error) return <ErrorBanner message={error} />;

  return (
    <div className="order-dashboard">
      <FilterBar value={filter} onChange={setFilter} />
      <OrderTable orders={enrichedOrders} filter={filter} />
    </div>
  );
}
```

**优化摘要**：
- 代码行数从280行降至120行（-57%）
- 提取了3个可复用组件
- 复用了项目内已有的 `useApi` hook
- 消除了重复的 loading/error 处理
- 用 `useMemo` 优化了数据计算性能

---

## 第二章：/batch 深度解析

### 2.1 /batch 是什么

`/batch` 是一个**大规模代码迁移命令**。它采用"计划-执行"两阶段模式：先分析整个变更范围并生成执行计划，确认后再以并行Subagent的方式批量修改文件。适用于跨数十甚至数百个文件的一致性修改场景。

与手动一个个文件修改不同，`/batch` 会：
1. 扫描所有需要修改的文件
2. 按逻辑关联分组（如按模块、按类型）
3. 生成详细的执行计划供你审查
4. 确认后启动并行Subagent批量执行
5. 验证修改结果，汇总变更报告

### 2.2 计划-执行两阶段架构

```
┌───────────────────────────────────────────────────────────┐
│                    /batch 执行流程                         │
├───────────────────────────────────────────────────────────┤
│                                                           │
│  Phase 1: 计划阶段 (Plan)                                 │
│  ┌─────────────────────────────────────────────────┐     │
│  │ 1. 接收用户指令（如"将所有class组件改为函数组件"）  │     │
│  │ 2. 扫描目标文件范围                               │     │
│  │ 3. 分析每个文件需要的具体修改                     │     │
│  │ 4. 按依赖关系分组                                │     │
│  │ 5. 生成执行计划并展示给用户                       │     │
│  └──────────────────────┬──────────────────────────┘     │
│                         │ 用户确认                         │
│                         ▼                                 │
│  Phase 2: 执行阶段 (Execute)                              │
│  ┌─────────────────────────────────────────────────┐     │
│  │                                                  │     │
│  │  ┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐        │     │
│  │  │Sub   │  │Sub   │  │Sub   │  │Sub   │        │     │
│  │  │Agent │  │Agent │  │Agent │  │Agent │        │     │
│  │  │ #1   │  │ #2   │  │ #3   │  │ #4   │        │     │
│  │  │      │  │      │  │      │  │      │        │     │
│  │  │File  │  │File  │  │File  │  │File  │        │     │
│  │  │Group │  │Group │  │Group │  │Group │        │     │
│  │  │ A    │  │ B    │  │ C    │  │ D    │        │     │
│  │  └──┬───┘  └──┬───┘  └──┬───┘  └──┬───┘        │     │
│  │     │         │         │         │             │     │
│  │     └─────────┴─────────┴─────────┘             │     │
│  │                    │                             │     │
│  │                    ▼                             │     │
│  │           变更验证 + 汇总报告                      │     │
│  └─────────────────────────────────────────────────┘     │
│                                                           │
└───────────────────────────────────────────────────────────┘
```

### 2.3 基础用法

```bash
# 在 Claude Code 交互模式中
/batch 将所有 callback 风格的异步函数改为 async/await
```

Claude Code 会先输出计划：

```
/batch Plan: Convert callbacks to async/await

Scope: 23 files across 4 directories
┌─────────────────┬───────────┬──────────────┐
│ Group            │ Files     │ Dependencies │
├─────────────────┼───────────┼──────────────┤
│ A: Core API      │ 8 files   │ None         │
│ B: Services      │ 6 files   │ A            │
│ C: Utilities     │ 5 files   │ None         │
│ D: Tests         │ 4 files   │ A, B, C      │
└─────────────────┴───────────┴──────────────┘

Estimated changes: ~150 line modifications
Groups A & C can run in parallel, then B, then D.

Proceed? (Y/n/e-edit plan)
```

输入 `Y` 后，Agent开始并行执行。输入 `e` 可以编辑计划，调整分组或排除特定文件。

### 2.4 常用 /batch 场景与指令模板

#### 场景一：框架版本迁移

```bash
# React 类组件 → 函数组件
/batch 将所有 React class 组件迁移为函数组件，使用 hooks 替代生命周期方法。先列出所有需要修改的文件，按目录分组执行。

# Vue 2 → Vue 3 Composition API
/batch 将所有 Vue 2 Options API 组件迁移为 Vue 3 Composition API 的 <script setup> 语法。注意保持 props 和 emit 定义不变。
```

#### 场景二：API 统一替换

```bash
# 旧API → 新API
/batch 将代码中所有使用 deprecatedApiClient 的地方替换为 newApiService。注意参数映射关系：旧API的 page/size 对应新API的 offset/limit。先更新类型定义文件，再更新所有调用方。

# 日志框架切换
/batch 将所有 console.log/console.error 调用替换为结构化日志 logger.info/logger.error，保留原始日志信息并添加上下文字段。
```

#### 场景三：代码规范统一

```bash
# CSS Module 迁移
/batch 将所有内联 style 对象转换为 CSS Module 引用。为每个组件创建对应的 .module.css 文件，将内联样式提取到 CSS 类中，更新组件引用。

# 测试框架迁移
/batch 将所有 Jest 测试文件迁移到 Vitest。更新 import 语句、mock 语法、断言方法。先处理配置文件，再批量更新测试文件。
```

### 2.5 分组策略详解

`/batch` 的分组策略直接影响执行效率和成功率。理解以下策略帮助你写出更精准的指令：

**按依赖关系分组（默认）**：

```
Group A (无依赖): 类型定义、常量、工具函数
Group B (依赖A): 服务层、数据访问层
Group C (依赖A): API控制器
Group D (依赖B,C): 测试文件
```

执行顺序：A → B和C并行 → D

**按目录/模块分组**：

```bash
/batch 按 src/ 下的模块目录分组，每个模块作为独立的执行组。
```

**按修改类型分组**：

```bash
/batch 将同名修改分为一组：所有 import 语句修改为一组，所有函数签名修改为一组，所有测试更新为一组。
```

### 2.6 /batch 的安全机制

`/batch` 内置了多层安全保护：

| 机制 | 说明 |
|------|------|
| 计划审查 | 必须用户确认后才开始执行 |
| 文件锁定 | 同一文件不会被两个Agent同时修改 |
| 验证步骤 | 每组完成后验证编译/测试通过 |
| 回滚支持 | 如果某组失败，自动回滚该组变更 |
| Token预算 | 达到上限时暂停并提示，不会无限制消耗 |

手动触发回滚：

```bash
# 如果 /batch 执行中途发现问题
# 直接在 Claude Code 中输入
撤销上一组 /batch 的修改

# 或用 git 回滚
git checkout -- .
```

---

## 第三章：组合技与工作流

### 3.1 /simplify + /batch 联合工作流

最强大的模式是**先 /batch 后 /simplify**：

```
大规模重构/迁移 → /batch 执行批量修改 → /simplify 清理代码质量
```

**实战示例：Express → Fastify 迁移**

```bash
# Step 1: 用 /batch 做框架迁移
/batch 将所有 Express 路由迁移到 Fastify。将 router.get/post/put/delete 语法迁移为 Fastify 的 route 方法定义。将 Express 中间件转换为 Fastify 插件。更新类型定义。按 routes/ 目录分组执行。

# Step 2: /batch 完成后，运行 /simplify 清理
/simplify
# /simplify 会发现迁移过程中产生的冗余代码：
# - 重复的类型转换
# - 不必要的中间层封装
# - 遗留的 Express 风格错误处理
```

### 3.2 Headless 模式集成

将 `/batch` 和 `/simplify` 集成到自动化流水线中：

```bash
#!/bin/bash
# auto-simplify.sh — 自动化代码质量检查脚本

# 1. 获取变更文件列表
CHANGED_FILES=$(git diff --name-only origin/main...HEAD)

if [ -z "$CHANGED_FILES" ]; then
  echo "No changes detected."
  exit 0
fi

echo "Running /simplify on changed files..."

# 2. 以 headless 模式运行 /simplify
claude -p "/simplify $CHANGED_FILES" \
  --output-format json \
  --allowedTools "Edit,Read,Bash" \
  --max-turns 10

# 3. 检查结果
if [ $? -eq 0 ]; then
  echo "Simplify completed successfully."
  # 运行测试验证
  npm test
else
  echo "Simplify encountered issues."
  exit 1
fi
```

### 3.3 stream-json 集成：实时监控 /batch 执行

使用 `stream-json` 输出格式可以实时监控 `/batch` 的执行进度：

```bash
claude -p "/batch 将所有 Python 文件的 f-string 中用到的 .format() 调用改为 f-string 语法" \
  --output-format stream-json \
  --verbose \
  --include-partial-messages
```

输出事件流示例：

```json
{"type":"assistant","subtype":"text","text":"Analyzing 47 files..."}
{"type":"assistant","subtype":"text","text":"Group A: 12 files (core/)"}
{"type":"assistant","subtype":"text","text":"Group B: 15 files (services/)"}
{"type":"tool_use","tool":"Task","input":{"description":"Batch Group A","prompt":"..."}}
{"type":"tool_result","tool":"Task","output":"Modified 12 files successfully"}
{"type":"tool_use","tool":"Task","input":{"description":"Batch Group B","prompt":"..."}}
{"type":"tool_result","tool":"Task","output":"Modified 15 files successfully"}
{"type":"assistant","subtype":"text","text":"Batch complete: 47 files modified, 0 errors"}
```

结合 `jq` 做实时过滤：

```bash
claude -p "/batch 将所有 .py 文件的 print() 调用替换为 logger.info()" \
  --output-format stream-json \
  --verbose 2>/dev/null | \
  jq -r 'select(.type=="assistant") | .text' | \
  grep -E "(Group|Modified|Error|Complete)"
```

### 3.4 GitHub Actions 集成

```yaml
# .github/workflows/ai-code-quality.yml
name: AI Code Quality Gate

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  simplify-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Run /simplify review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # 获取PR变更的文件
          CHANGED=$(git diff --name-only origin/${{ github.base_ref }}...HEAD | tr '\n' ' ')

          # 以只读模式运行质量检查（不自动修复）
          claude -p "分析以下文件的代码质量：$CHANGED。检查代码复用、命名规范、执行效率三个方面。输出JSON格式的报告。" \
            --output-format json \
            --allowedTools "Read,Glob,Grep,Bash" \
            --max-turns 15 > simplify-report.json

      - name: Upload Report
        uses: actions/upload-artifact@v4
        with:
          name: simplify-report
          path: simplify-report.json

      - name: Comment on PR
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const report = JSON.parse(fs.readFileSync('simplify-report.json', 'utf8'));
            // 解析报告并添加PR评论
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: formatReport(report)
            });
```

---

## 第四章：实战项目 — TypeScript 项目全面类型化迁移

以下是一个完整的实战项目，展示如何使用 `/batch` 和 `/simplify` 将一个中型 TypeScript 项目从"部分类型标注"升级为"严格类型全覆盖"。

### 4.1 项目背景

假设一个 Express + TypeScript 项目，约50个源文件，大量使用 `any` 类型和缺失类型标注。

### 4.2 步骤一：评估现状

```bash
# 先让 Claude Code 扫描项目现状
claude -p "统计这个项目中所有 TypeScript 文件的使用情况：
1. 有多少个 any 类型标注
2. 有多少个文件启用了 strict 模式
3. 有多少个函数缺少返回类型
4. 有多少个参数缺少类型标注
输出JSON格式的统计报告。" \
  --output-format json \
  --allowedTools "Read,Glob,Grep,Bash"
```

### 4.3 步骤二：分阶段 /batch 执行

```bash
# 在 Claude Code 交互模式中执行

# Phase 1: 类型定义基础
/batch 创建完整的类型定义体系。
- 在 src/types/ 下创建所有业务实体的接口定义
- 每个接口包含完整的字段类型和 JSDoc 注释
- 按领域分组：用户、订单、商品、支付
- 先分析现有的接口和数据结构，确保类型定义覆盖所有使用场景

# Phase 2: API层类型化
/batch 为所有 API 路由添加完整的请求/响应类型。
- 创建统一的 Request<T> 和 Response<T> 泛型类型
- 为每个路由的 req.body、req.params、req.query 添加类型标注
- 添加返回类型标注
- 按 routes/ 目录分组执行

# Phase 3: 服务层类型化
/batch 为所有 service 文件添加完整的函数签名类型。
- 替换所有 any 为具体类型
- 添加函数参数和返回值类型
- 确保与 Phase 1 定义的类型一致
- 按 services/ 目录分组执行

# Phase 4: 数据访问层
/batch 为所有数据库操作添加类型标注。
- 为查询结果添加类型映射
- 替换 raw query 中的 any 为具体类型
- 确保与业务实体类型一致

# Phase 5: 清理
/simplify
# 清理类型化过程中产生的冗余代码
```

### 4.4 步骤三：验证与修复

```bash
# 运行类型检查
npx tsc --noEmit

# 如果有错误，让 Claude Code 修复
claude -p "运行 npx tsc --noEmit 并修复所有类型错误" \
  --max-turns 15

# 运行测试确保没有破坏功能
npm test
```

### 4.5 步骤四：持续保障

在项目根目录的 `CLAUDE.md` 中添加规则：

```markdown
## Type Safety Rules
- 禁止使用 any 类型，特殊情况用 unknown 并添加类型守卫
- 所有公共函数必须有参数类型和返回类型
- 新文件必须启用 strict 模式
- API 路由必须使用 Request<T> 和 Response<T> 泛型
```

这样后续的 Claude Code 会话会自动遵循这些规则。

---

## 第五章：性能优化与最佳实践

### 5.1 Token 消耗优化

`/batch` 和 `/simplify` 都是 Token 密集型操作。以下是降低消耗的实用技巧：

| 技巧 | 预期节省 | 实现方式 |
|------|---------|---------|
| 缩小 diff 范围 | 30-50% | 用 `/simplify src/specific/` 指定目录 |
| 使用 Haiku 模型 | 60-80% | /batch 前切换模型：`/model haiku` |
| 分批执行 | 20-40% | 每次 /batch 只处理一个模块 |
| 先 /compact 再 /batch | 15-25% | 清理上下文后再启动大操作 |
| 限制 max-turns | 防止无限循环 | `claude -p "/batch ..." --max-turns 20` |

### 5.2 常见问题与解决方案

**问题1：/batch 计划阶段超时**

```bash
# 原因：项目文件太多，扫描时间过长
# 解决：缩小范围
/batch 只处理 src/api/ 目录下的文件，将 callback 改为 async/await
```

**问题2：/simplify 修改了不应该改的代码**

```bash
# 原因：审查范围包含了稳定代码
# 解决：先 git stash 不相关变更，只保留目标变更
git stash push -m "temp" -- src/stable/
/simplify
git stash pop
```

**问题3：/batch 执行中 Agent 冲突**

```bash
# 原因：两个Agent修改了同一文件
# 解决：使用更精细的分组策略
/batch 将所有测试文件的 import 路径从 '@/utils' 改为 '@/lib/utils'。每个文件作为独立任务，不要并行修改同一个文件。
```

**问题4：Token 不足中途停止**

```bash
# 解决：分阶段执行，每阶段完成后 commit
# Phase 1
/batch 处理 src/types/ 目录的类型迁移
git add -A && git commit -m "chore: batch phase 1 - types"

# Phase 2
/batch 处理 src/api/ 目录的类型迁移
git add -A && git commit -m "chore: batch phase 2 - api"
```

### 5.3 与 /loop 组合：定时代码质量巡检

```bash
# 在 Claude Code 交互模式中设置定时巡检
/loop 每天早上9点运行以下任务：
1. 拉取最新代码
2. 检查最近24小时的提交
3. 对新增/修改的文件运行 /simplify 审查
4. 生成代码质量报告并保存到 docs/reports/
```

### 5.4 完整工作流 Mermaid 图

```mermaid
graph TD
    A[开发功能] --> B[git add 暂存变更]
    B --> C{变更规模?}
    C -->|小规模<br><10个文件| D[运行 /simplify]
    C -->|大规模<br>≥10个文件| E[运行 /batch]
    E --> F[审查执行计划]
    F --> G[确认并执行]
    G --> H[批量修改完成]
    H --> D
    D --> I[审查优化建议]
    I --> J{自动修复?}
    J -->|是| K[应用修复]
    J -->|否| L[仅保留报告]
    K --> M[运行测试验证]
    L --> M
    M --> N{测试通过?}
    N -->|是| O[git commit 提交]
    N -->|否| P[修复测试失败]
    P --> M
    O --> Q[CI/CD 代码质量检查]
    Q --> R{质量门禁通过?}
    R -->|是| S[合并到主分支]
    R -->|否| T[运行 /simplify 修复]
    T --> M

    style D fill:#4CAF50,color:#fff
    style E fill:#2196F3,color:#fff
    style K fill:#FF9800,color:#fff
    style S fill:#8BC34A,color:#fff
```

---

## 第六章：进阶模式

### 6.1 自定义 /simplify 审查维度

通过 CLAUDE.md 可以引导 `/simplify` 关注特定维度：

```markdown
## Code Quality Standards
- 所有函数不超过30行
- 嵌套不超过3层
- 所有 API 调用必须有超时设置
- 所有异步操作必须有错误处理
- 禁止使用 var 关键字
- 所有 React 组件必须有 displayName
```

### 6.2 自定义 /batch 模板

创建可复用的 /batch 指令作为自定义命令：

```markdown
<!-- .claude/commands/batch-add-logging.md -->
# 批量添加结构化日志

对以下文件添加结构化日志：

1. 分析 $ARGUMENTS 中的所有文件
2. 为每个函数的入口和出口添加 logger.debug 日志
3. 为每个错误处理分支添加 logger.error 日志
4. 日志格式：`[模块名.函数名] 操作描述 {关键参数}`
5. 使用项目统一的 logger 实例
6. 按文件分组并行执行
```

使用方式：

```bash
/project:batch-add-logging src/api/*.ts
```

### 6.3 多项目 /batch 协调

对于 monorepo 或多包项目：

```bash
/batch 分析整个 monorepo 的包依赖图。然后按照以下顺序批量升级所有包的依赖版本：
1. 先升级 packages/shared/ 中的共享包
2. 再升级依赖共享包的中间层包
3. 最后升级应用层包
每个包升级后运行该包的测试，确保兼容性。
```

---

## 延伸阅读

- [Claude Code /simplify and /batch 官方命令文档](https://code.claude.com/docs/en/commands) — 官方命令参考
- [Claude Code Batch Processing 完整指南](https://smartscope.blog/en/generative-ai/claude/claude-code-batch-processing/) — /batch 深度解析
- [Claude Code /simplify: 三Agent代码审查](https://www.howdoiuseai.com/blog/2026-04-16-what-does-simplify-do-in-claude-code-code-review) — 三Agent架构详解
- [Run Claude Code Programmatically](https://code.claude.com/docs/en/headless) — Headless模式官方文档
- [Claude Code Sub-Agents Guide](https://www.aibuilderclub.com/blog/claude-code-sub-agents-guide) — Subagent并行执行模式

## 训练营适用性评估

| 维度 | 评估 |
|------|------|
| 适合训练营类型 | 企业级AI编程训练营（中高级班）、代码质量提升工作坊、大规模迁移训练营 |
| 学员基础要求 | 已掌握 Claude Code 基础操作，有1个月以上使用经验 |
| 预计教学时长 | 4-6小时（含实操练习） |
| 实操占比 | 70%（需要真实的代码项目进行练习） |
| 推荐练习项目 | 提供一个100+文件的 TypeScript 半成品项目，让学员完成从迁移到优化的全流程 |
| 考核方式 | 学员提交 /batch + /simplify 的执行报告，代码质量指标提升幅度作为评分依据 |

## 参考来源

1. [Claude Code Commands — Anthropic 官方文档](https://code.claude.com/docs/en/commands) — /simplify 和 /batch 官方命令说明
2. [Claude Code Batch Processing Complete Guide — SmartScope](https://smartscope.blog/en/generative-ai/claude/claude-code-batch-processing/) — /batch 命令系统化指南
3. [What Does /simplify Do in Claude Code? — HowDoIUseAI](https://www.howdoiuseai.com/blog/2026-04-16-what-does-simplify-do-in-claude-code-code-review) — 三Agent并行审查架构详解
4. [Claude Code /simplify and /batch Commands Guide — claudefa.st](https://claudefa.st/blog/guide/mechanics/simplify-batch-commands) — 两个命令的对比与使用场景
5. [Run Claude Code Programmatically — Anthropic 官方文档](https://code.claude.com/docs/en/headless) — Headless 模式与 stream-json 集成参考

> [!tip] 51学通信知识星球
> **星主：爱卫生**（微信：gprshome201101）——公众号「51学通信」创办者，19 年通信行业运维与讲师经验，著有《GPRS网络信令实例详解》《EPC原理与实践》《5G核心网原理与实践》三本纸质书（各大电商平台有售）。
> **星球定位**：深耕 5G 核心网、IMS、NFV/AI、云原生等 ICT 领域，主打运维岗位与信令分析。
> **当前规模**：5200 篇主题 / 990 个回答，198 元/年。
> **加入福利**：加入星球后请加爱卫生微信，拉您进知识星球年度陪伴与答疑群——不限量回复您的各种问题，另有群内分享。
> **AI 加持**：51学通信知识星球已作为 skill 接入 WorkBuddy，使用 deepseek-4-flash 在海量星球帖子中精准找贴、找视频、找 FAQ 和案例，做总结、找文档和 PPT 等场景全覆盖。

![51学通信知识星球海报-扫码加入](https://wiki.500nian.com/images/zhixingqiu_qrcode.png)