Batch and Revise Flow（批次修訂工作流程）
Batch and Revise Flow 是 Superpowers 中專門處理大量類似任務的工作流程，適合重複性工作、批次處理或需要一致性的多項任務。它強調效率、一致性和品質標準化。
何時使用 Batch and Revise Flow
✅ 最適合的情境：
- 需要處理大量類似的檔案或任務
- 需要統一多個項目的標準
- 重複性的程式碼重構工作
- 批次的文件更新或修正
- 多個類似功能的同時開發
- 需要確保一致性的維護工作
❌ 不適合的情境：
- 每個任務都有很大差異
- 任務之間有強烈的相依性
- 需要深入思考的創意性工作
- 時間緊迫的單一任務
Batch and Revise Flow 的四個步驟
第 1 步：批次識別（20-30 分鐘）
識別和分類需要處理的任務。
目標：
- 列出所有需要處理的項目
- 識別任務的共性和差異
- 制定處理優先級
- 建立標準化模板
產出：
- 任務清單和分類
- 處理優先級排序
- 標準化模板
- 處理計畫
時間：20-30 分鐘
第 2 步：批次處理（數小時到數天）
高效率地處理所有任務。
目標：
- 使用標準化流程處理
- 保持處理一致性
- 快速完成大量任務
- 追蹤處理進度
產出：
- 處理完成的項目
- 處理過程記錄
- 異常情況記錄
- 進度追蹤報告
時間：數小時到數天
第 3 步：統一修訂（1-2 小時）
對所有處理結果進行統一修訂。
目標：
- 確保所有項目一致性
- 修復處理中的問題
- 統一品質標準
- 處理邊界情況
產出：
- 修訂後的所有項目
- 一致性檢查報告
- 品質驗證結果
- 最終版本
時間：1-2 小時
第 4 步：品質驗證（30-60 分鐘）
最終驗證和交付。
目標：
- 驗證所有項目品質
- 確認處理完整性
- 準備交付文件
- 總結經驗教訓
產出：
- 品質驗證報告
- 交付清單
- 經驗總結文件
- 流程改進建議
時間：30-60 分鐘
實際範例
範例 1：批次重構 API 端點
情境：需要將 20 個 API 端點統一加入錯誤處理和日誌記錄
Batch and Revise Flow 執行：
第 1 步：批次識別（30 分鐘）
任務清單：
需要處理的 API 端點：
核心功能（10 個）：
- POST /api/users/create
- GET /api/users/:id
- PUT /api/users/:id
- DELETE /api/users/:id
- POST /api/products/create
- GET /api/products/:id
- PUT /api/products/:id
- DELETE /api/products/:id
- POST /api/orders/create
- GET /api/orders/:id
支援功能（10 個）：
- POST /api/auth/login
- POST /api/auth/logout
- GET /api/cart/items
- POST /api/cart/add
- DELETE /api/cart/remove
- POST /api/reviews/create
- GET /api/reviews/product/:id
- POST /api/search/query
- GET /api/categories/list
- GET /api/stats/dashboard任務分類：
- 按功能類型分組：使用者、產品、訂單等
- 按複雜度分級：簡單（CRUD）、中等（業務邏輯）、複雜（整合）
- 按優先級排序：核心 > 支援
標準化模板：
// 標準的 API 端點模板
import { logger } from '../utils/logger';
import { errorHandler } from '../utils/error-handler';
export async function handleApiRequest(req: Request, res: Response) {
const startTime = Date.now();
try {
// 1. 參數驗證
const params = await validateRequest(req);
// 2. 業務邏輯
const result = await processRequest(params);
// 3. 回應處理
res.json({
success: true,
data: result
});
// 4. 成功日誌
logger.info({
endpoint: req.path,
method: req.method,
duration: Date.now() - startTime,
status: 'success'
});
} catch (error) {
// 5. 錯誤處理
errorHandler(error, req, res);
// 6. 錯誤日誌
logger.error({
endpoint: req.path,
method: req.method,
duration: Date.now() - startTime,
status: 'error',
error: error.message
});
}
}第 2 步：批次處理（6 小時）
使用標準模板處理所有端點：
處理策略：
# 按功能分組處理
第 1 組：使用者相關（4 個端點） - 1.5 小時
第 2 組：產品相關（4 個端點） - 1.5 小時
第 3 組：訂單相關（2 個端點） - 1 小時
第 4 組：其他功能（10 個端點） - 2 小時處理範例：
// 處理 POST /api/users/create
export async function createUser(req: Request, res: Response) {
const startTime = Date.now();
try {
const userData = await validateUserSchema(req.body);
const user = await userService.create(userData);
res.status(201).json({
success: true,
data: { id: user.id, email: user.email }
});
logger.info({
endpoint: '/api/users/create',
method: 'POST',
duration: Date.now() - startTime,
status: 'success',
userId: user.id
});
} catch (error) {
errorHandler(error, req, res);
logger.error({
endpoint: '/api/users/create',
method: 'POST',
duration: Date.now() - startTime,
status: 'error',
error: error.message
});
}
}
// 處理 GET /api/users/:id
export async function getUserById(req: Request, res: Response) {
const startTime = Date.now();
try {
const userId = req.params.id;
const user = await userService.findById(userId);
if (!user) {
throw new NotFoundError('User not found');
}
res.json({
success: true,
data: user
});
logger.info({
endpoint: '/api/users/:id',
method: 'GET',
duration: Date.now() - startTime,
status: 'success',
userId
});
} catch (error) {
errorHandler(error, req, res);
logger.error({
endpoint: '/api/users/:id',
method: 'GET',
duration: Date.now() - startTime,
status: 'error',
error: error.message,
userId: req.params.id
});
}
}進度追蹤：
處理進度：
[████████░░░░░░░░░░░░] 40% (8/20)
已處理：
✅ POST /api/users/create
✅ GET /api/users/:id
✅ PUT /api/users/:id
✅ DELETE /api/users/:id
✅ POST /api/products/create
✅ GET /api/products/:id
✅ PUT /api/products/:id
✅ DELETE /api/products/:id
待處理：
⏳ POST /api/orders/create
⏳ GET /api/orders/:id
⏳ 其他支援功能（12 個）第 3 步：統一修訂（1.5 小時）
檢查和統一所有處理結果：
一致性檢查：
// 檢查所有端點的一致性
const consistencyChecks = {
// 1. 錯誤處理一致性
errorHandling: endpoints.map(endpoint => ({
endpoint: endpoint.path,
hasTryCatch: endpoint.handler.toString().includes('try {'),
hasErrorHandler: endpoint.handler.toString().includes('errorHandler'),
hasErrorLogging: endpoint.handler.toString().includes('logger.error')
})),
// 2. 日誌記錄一致性
logging: endpoints.map(endpoint => ({
endpoint: endpoint.path,
hasSuccessLogging: endpoint.handler.toString().includes('logger.info'),
hasErrorLogging: endpoint.handler.toString().includes('logger.error'),
hasDurationTracking: endpoint.handler.toString().includes('Date.now() - startTime')
})),
// 3. 回應格式一致性
responseFormat: endpoints.map(endpoint => ({
endpoint: endpoint.path,
hasSuccessField: endpoint.handler.toString().includes('success: true'),
hasDataField: endpoint.handler.toString().includes('data:')
}))
};
// 識別不一致的地方
const inconsistencies = {
missingErrorHandling: consistencyChecks.errorHandling
.filter(check => !check.hasErrorHandler)
.map(check => check.endpoint),
missingLogging: consistencyChecks.logging
.filter(check => !check.hasSuccessLogging)
.map(check => check.endpoint)
};統一修正：
// 修正不一致的地方
inconsistencies.missingErrorHandling.forEach(endpoint => {
// 加入錯誤處理
console.log(`Adding error handling to ${endpoint}`);
});
inconsistencies.missingLogging.forEach(endpoint => {
// 加入日誌記錄
console.log(`Adding logging to ${endpoint}`);
});第 4 步：品質驗證（45 分鐘）
最終驗證所有端點：
測試案例：
// 測試所有端點的錯誤處理
describe('API Error Handling', () => {
endpoints.forEach(endpoint => {
it(`${endpoint} should handle errors gracefully`, async () => {
const response = await request(app)
.post(endpoint.path)
.send({ invalid: 'data' });
expect(response.status).toBe(400);
expect(response.body).toHaveProperty('success', false);
expect(response.body).toHaveProperty('error');
});
});
});
// 測試所有端點的日誌記錄
describe('API Logging', () => {
endpoints.forEach(endpoint => {
it(`${endpoint} should log requests`, async () => {
const spy = jest.spyOn(logger, 'info');
await request(app).get(endpoint.path);
expect(spy).toHaveBeenCalledWith(
expect.objectContaining({
endpoint: expect.any(String),
method: expect.any(String),
duration: expect.any(Number),
status: expect.any(String)
})
);
});
});
});驗證結果：
品質驗證報告：
✅ 功能測試：20/20 通過
✅ 錯誤處理測試：20/20 通過
✅ 日誌記錄測試：20/20 通過
✅ 效能測試：所有端點 < 200ms
✅ 一致性檢查：100% 一致
異常情況處理：
⚠️ 2 個端點需要特殊處理（檔案上傳）
→ 已建立特殊處理流程總耗時：8 小時（原本需要 20+ 小時）
範例 2：批次更新文件
情境：需要更新 50 個 Markdown 文件的格式和內容
Batch and Revise Flow 執行：
第 1 步：批次識別（20 分鐘）
文件清單：
docs/
├── getting-started/
│ ├── installation.md
│ ├── quick-start.md
│ ├── configuration.md
│ └── troubleshooting.md (5 files)
├── api/
│ ├── authentication.md
│ ├── users.md
│ ├── products.md
│ ├── orders.md
│ └── payments.md (15 files)
├── guides/
│ ├── user-management.md
│ ├── product-catalog.md
│ ├── order-processing.md
│ └── payment-integration.md (20 files)
└── reference/
├── cli-commands.md
├── api-reference.md
└── configuration-reference.md (10 files)
總計：50 個文件標準化模板：
<!-- 每個文件的標準模板 -->
---
title: [文件標題]
description: [文件描述]
lastUpdated: [最後更新日期]
tags: [標籤列表]
---
# [文件標題]
## 簡介
[文件簡介內容]
## 前置需求
- 需求 1
- 需求 2
## 使用方法
### 步驟 1
[步驟說明]
### 步驟 2
[步驟說明]
## 範例
[使用範例]
## 注意事項
[重要注意事項]
## 相關資源
- [相關文件 1](../path/to/doc1)
- [相關文件 2](../path/to/doc2)第 2 步：批次處理（4 小時）
使用腳本批次處理：
#!/bin/bash
# batch-update-docs.sh
# 建立標準化腳本
for file in $(find docs -name "*.md"); do
echo "Processing $file..."
# 1. 加入標準 frontmatter
add_frontmatter "$file"
# 2. 更新文件格式
update_format "$file"
# 3. 檢查連結
check_links "$file"
# 4. 更新日期
update_date "$file"
echo "✅ Completed $file"
done處理結果：
批次處理報告：
總文件數：50
成功處理：48
處理失敗：2
失敗文件：
- docs/api/payments.md（格式特殊，需手動處理）
- docs/reference/api-reference.md（內容複雜，需手動處理）
自動化處理時間：4 小時
手動處理時間：1 小時第 3 步：統一修訂（1 小時）
統一修訂處理結果：
修訂項目：
- 統一標題格式
- 修正連結路徑
- 更新過時內容
- 加入缺失的章節
第 4 步：品質驗證（30 分鐘）
驗證文件品質：
驗證項目：
# 執行品質檢查
npm run docs:check
檢查結果：
✅ Markdown 語法：50/50 通過
✅ 內部連結：48/50 有效（2 個需修正）
✅ 外部連結：45/50 有效（5 個需更新）
✅ 代碼範例：50/50 可執行
✅ 拼寫檢查：50/50 通過總耗時：6.5 小時（原本需要 15+ 小時）
Batch and Revise Flow 的特色
1. 效率優化
時間節省對比：
順序處理方式：
50 個任務 × 30 分鐘 = 25 小時
批次處理方式：
準備 30 分鐘 + 處理 6 小時 + 修訂 1.5 小時 + 驗證 1 小時 = 9 小時
時間節省：64%2. 一致性保證
標準化處理確保一致性：
// 所有處理結果遵循相同標準
const standard = {
format: '統一格式',
quality: '統一品質',
style: '統一風格',
documentation: '統一文件'
};3. 品質控制
多層次品質檢查：
- 處理過程中的即時檢查
- 統一修討階段的一致性檢查
- 最終驗證階段的全面檢查
4. 可追蹤性
完整的處理記錄：
處理記錄：
- 處理時間和負責人
- 處理方法和工具
- 異常情況記錄
- 修訂內容追蹤Batch and Revise Flow 的工具支援
1. 自動化腳本
# 批次處理腳本範例
#!/bin/bash
# batch-process.sh
# 配置
INPUT_DIR="src"
OUTPUT_DIR="processed"
TEMPLATE="template.txt"
# 批次處理
for file in $INPUT_DIR/*; do
echo "Processing $file..."
# 應用模板
apply_template "$file" "$TEMPLATE"
# 驗證結果
validate_output "$file"
# 移動到輸出目錄
mv "$file" "$OUTPUT_DIR/"
echo "✅ Completed $file"
done2. 程式碼生成器
// 批次生成程式碼的工具
class CodeGenerator {
generate(endpoint: Endpoint): string {
return `
export async function ${endpoint.functionName}(req: Request, res: Response) {
const startTime = Date.now();
try {
const result = await this.processRequest(req);
res.json({ success: true, data: result });
logger.info({
endpoint: '${endpoint.path}',
duration: Date.now() - startTime,
status: 'success'
});
} catch (error) {
errorHandler(error, req, res);
logger.error({
endpoint: '${endpoint.path}',
duration: Date.now() - startTime,
status: 'error',
error: error.message
});
}
}
`;
}
batchGenerate(endpoints: Endpoint[]): void {
endpoints.forEach(endpoint => {
const code = this.generate(endpoint);
this.writeToFile(endpoint.functionName, code);
});
}
}3. 品質檢查工具
// 批次品質檢查工具
class QualityChecker {
async checkAll(items: Item[]): Promise<QualityReport> {
const results = await Promise.all(
items.map(item => this.checkItem(item))
);
return {
total: items.length,
passed: results.filter(r => r.status === 'passed').length,
failed: results.filter(r => r.status === 'failed').length,
warnings: results.filter(r => r.status === 'warning').length,
details: results
};
}
async checkItem(item: Item): Promise<CheckResult> {
const checks = [
this.checkFormat(item),
this.checkConsistency(item),
this.checkQuality(item),
this.checkCompleteness(item)
];
const results = await Promise.all(checks);
return {
item: item.id,
status: this.determineStatus(results),
checks: results
};
}
}Batch and Revise Flow 的最佳實踐
1. 清晰的分類標準
有效的分類策略：
分類維度：
1. 按功能類型：CRUD、業務邏輯、整合
2. 按複雜度：簡單、中等、複雜
3. 按優先級：核心、重要、次要
4. 按風險等級：高、中、低
分類好處：
- 可以使用不同的處理策略
- 可以合理安排處理順序
- 可以更好地追蹤進度2. 標準化的處理模板
建立可重複的模板：
// 標準化模板的結構
interface ProcessTemplate {
// 輸入格式
input: InputFormat;
// 處理步驟
steps: ProcessStep[];
// 輸出格式
output: OutputFormat;
// 品質標準
qualityStandards: QualityCheck[];
// 異常處理
errorHandling: ErrorHandling;
}3. 有效的進度追蹤
實時進度監控：
// 進度追蹤系統
class ProgressTracker {
private totalItems: number;
private processedItems: number = 0;
private failedItems: string[] = [];
updateProgress(item: string, status: 'success' | 'failed') {
this.processedItems++;
if (status === 'failed') {
this.failedItems.push(item);
}
this.displayProgress();
}
displayProgress() {
const percentage = (this.processedItems / this.totalItems) * 100;
const progressBar = '█'.repeat(Math.floor(percentage / 5)) +
'░'.repeat(20 - Math.floor(percentage / 5));
console.log(`[${progressBar}] ${percentage.toFixed(1)}% (${this.processedItems}/${this.totalItems})`);
if (this.failedItems.length > 0) {
console.log(`Failed: ${this.failedItems.length} items`);
}
}
}4. 系統化的驗證流程
多層次驗證：
第 1 層：自動化檢查
- 格式驗證
- 語法檢查
- 基本規則檢查
第 2 層：一致性檢查
- 跨項目一致性
- 標準符合性
- 風格統一性
第 3 層：品質驗證
- 功能測試
- 效能測試
- 使用者體驗測試與其他 Skills 的組合
推薦組合
Dispatching Parallel Agents + Batch and Revise Flow
dispatching-parallel-agents → batch-and-revise-flow使用多個代理並行處理批次任務，然後統一修訂
Subagent-Driven Development + Batch and Revise Flow
subagent-driven-development → batch-and-revise-flow使用子代理處理不同批次的任務
常見問題
Q1：如何處理批次中的異常項目？
A：
異常處理策略：
1. 識別異常項目並記錄
2. 評估異常原因和影響
3. 決定處理方式（跳過、手動處理、調整模板）
4. 在統一修訂階段特別處理Q2：如何確保批次處理的品質？
A：
品質保證策略：
1. 建立明確的品質標準
2. 使用自動化檢查工具
3. 實施抽樣檢查機制
4. 在統一修訂階段全面檢查Q3：批次處理失敗怎麼辦？
A：
失敗恢復策略：
1. 記錄失敗項目和原因
2. 實施恢復機制（checkpoint）
3. 從失敗點重新開始
4. 在驗證階段特別關注Batch and Revise Flow 是處理大量重複性工作的最佳實踐，能顯著提升效率並確保一致性，是任何開發者都應該掌握的重要技能！