multi-team-coding

完整的 AI 驱动编程工作流。包含：(1) 多团队并行开发（OpenClaw + Claude Code/Codex/OpenCode），(2) 一人公司模式（单日 90+ 提交），(3) Playwright 自动化测试（E2E/API/视觉/性能），(4) 自动 PR 管理和合并。适用于独立开发者、初创团队、开源项目维护。

Safety Notice

This listing is from the official public ClawHub registry. Review SKILL.md and referenced scripts before running.

Copy this and send it to your AI assistant to learn

Install skill "multi-team-coding" with this command: npx skills add LongFer/multi-team-coding

AI 驱动编程工作流

完整的自动化编程解决方案，从任务分配到测试、部署全流程自动化。

📚 目录

  1. 多团队并行开发
  2. 一人公司模式
  3. Playwright 自动化测试
  4. 快速开始
  5. 完整示例

多团队并行开发

基于 OpenClaw + OpenCode 的自主工程团队模式，通过主 agent 编排多个 coding agent 并行工作，实现代码自动化。

核心理念

编排器模式（Orchestrator Pattern）：

  • 主 agent（你）作为编排器，负责任务分解、分配和协调
  • 多个 coding agent（Claude Code/Codex/OpenCode）作为工作团队
  • 每个团队在独立的 git worktree 中工作，互不干扰
  • 自动追踪进度、处理依赖、合并结果

关键优势：

  • 并行执行，速度提升 2-5 倍
  • 智能任务分解，自动识别依赖关系
  • 实时进度监控，异常自动告警
  • 自动冲突检测和解决建议

架构设计

主 Agent（编排器）
    ├── 任务分析器：分解需求为独立子任务
    ├── 任务调度器：分配任务给可用团队
    ├── 进度监控器：实时追踪各团队状态
    ├── 冲突检测器：识别潜在代码冲突
    └── 结果集成器：合并各团队成果

工作团队（Coding Agents）
    ├── Team A: 独立 worktree + coding agent
    ├── Team B: 独立 worktree + coding agent
    ├── Team C: 独立 worktree + coding agent
    └── Team N: 独立 worktree + coding agent

工作流程

1. 智能任务分解

主 agent 分析用户需求，自动识别：

  • 独立模块（可并行）
  • 依赖关系（需串行）
  • 共享资源（需协调）
  • 优先级排序
# 示例：构建电商系统
任务树：
├── [P0] 数据库设计（基础，其他依赖）
├── [P1] 并行组
│   ├── Team A: 用户认证模块
│   ├── Team B: 商品管理 API
│   └── Team C: 订单系统
└── [P2] 前端集成（依赖 P1 完成）

2. 动态工作空间创建

为每个团队自动创建隔离的工作环境：

# 主项目目录
PROJECT_ROOT=$(pwd)
WORKSPACE_BASE=/tmp/multi-team-$(date +%s)

# 创建任务状态追踪文件
cat > $WORKSPACE_BASE/status.json << 'EOF'
{
  "project": "电商系统",
  "started": "2026-03-09T07:00:00Z",
  "teams": {},
  "dependencies": {}
}
EOF

# 为每个团队创建 worktree
create_team_workspace() {
  local team_name=$1
  local task_desc=$2
  local branch_name="team-${team_name}"
  local work_dir="${WORKSPACE_BASE}/${team_name}"
  
  git worktree add -b $branch_name $work_dir main
  
  # 记录团队信息
  echo "{\"status\": \"created\", \"task\": \"$task_desc\", \"dir\": \"$work_dir\"}" \
    > $WORKSPACE_BASE/teams/${team_name}.json
}

3. 启动工作团队

使用统一的启动模板，支持多种 coding agent：

# 启动函数（支持 Claude Code/Codex/OpenCode）
start_team() {
  local team_name=$1
  local agent_type=$2  # claude, codex, opencode
  local task_prompt=$3
  local work_dir="${WORKSPACE_BASE}/${team_name}"
  
  # 构建完整提示词
  local full_prompt="
【团队】: $team_name
【任务】: $task_prompt

【要求】:
1. 遵循项目代码规范（参考 .editorconfig）
2. 编写单元测试（覆盖率 > 80%）
3. 更新相关文档
4. 提交前运行 lint 和 format
5. 提交信息格式：feat($team_name): 简短描述

【完成标准】:
- 所有测试通过
- 代码审查通过
- 文档完整

【完成后执行】:
git add . && git commit -m 'feat($team_name): 完成任务'
openclaw system event --text '✅ $team_name 完成：$task_prompt' --mode now
"

  # 根据 agent 类型选择命令
  case $agent_type in
    claude)
      bash pty:true workdir:$work_dir background:true \
        command:"claude '$full_prompt'"
      ;;
    codex)
      bash pty:true workdir:$work_dir background:true \
        command:"codex exec --full-auto '$full_prompt'"
      ;;
    opencode)
      bash pty:true workdir:$work_dir background:true \
        command:"opencode run '$full_prompt'"
      ;;
  esac
  
  # 记录 session ID
  echo $! > $WORKSPACE_BASE/teams/${team_name}.pid
}

# 示例：启动多个团队
start_team "auth" "claude" "实现用户认证模块：注册、登录、JWT、密码加密"
start_team "products" "codex" "实现商品管理 API：CRUD、分类、搜索、库存"
start_team "orders" "opencode" "实现订单系统：创建、支付、状态管理、历史"

4. 实时进度监控

主 agent 持续监控各团队状态：

# 监控脚本
monitor_teams() {
  local workspace=$1
  
  while true; do
    echo "=== 团队状态 $(date +%H:%M:%S) ==="
    
    for team_file in $workspace/teams/*.json; do
      team_name=$(basename $team_file .json)
      pid_file="$workspace/teams/${team_name}.pid"
      
      if [ -f "$pid_file" ]; then
        pid=$(cat $pid_file)
        
        # 检查进程状态
        if ps -p $pid > /dev/null; then
          # 获取最新输出
          process action:log sessionId:$pid limit:5
          echo "  [$team_name] 🟢 运行中"
        else
          echo "  [$team_name] ✅ 已完成"
        fi
      fi
    done
    
    echo ""
    sleep 30
  done
}

# 后台启动监控
monitor_teams $WORKSPACE_BASE &
MONITOR_PID=$!

5. 智能冲突检测

在合并前自动检测潜在冲突：

# 冲突检测函数
detect_conflicts() {
  local workspace=$1
  local conflicts=()
  
  echo "🔍 检测潜在冲突..."
  
  # 收集所有团队修改的文件
  declare -A file_teams
  
  for team_dir in $workspace/*/; do
    team_name=$(basename $team_dir)
    
    # 获取该团队修改的文件
    cd $team_dir
    modified_files=$(git diff --name-only main)
    
    for file in $modified_files; do
      if [ -n "${file_teams[$file]}" ]; then
        conflicts+=("⚠️  冲突：$file 被 ${file_teams[$file]} 和 $team_name 同时修改")
      else
        file_teams[$file]=$team_name
      fi
    done
  done
  
  # 报告冲突
  if [ ${#conflicts[@]} -gt 0 ]; then
    echo "❌ 发现 ${#conflicts[@]} 个潜在冲突："
    printf '%s\n' "${conflicts[@]}"
    return 1
  else
    echo "✅ 无冲突，可以安全合并"
    return 0
  fi
}

6. 自动结果集成

智能合并各团队成果：

# 集成函数
integrate_results() {
  local workspace=$1
  local project_root=$2
  
  cd $project_root
  
  echo "🔄 开始集成各团队成果..."
  
  # 按依赖顺序合并
  local merge_order=("auth" "products" "orders" "frontend")
  
  for team_name in "${merge_order[@]}"; do
    echo "  合并 $team_name..."
    
    # 合并分支
    if git merge --no-ff team-${team_name} -m "feat: 集成 $team_name 模块"; then
      echo "  ✅ $team_name 合并成功"
    else
      echo "  ❌ $team_name 合并失败，需要手动解决"
      git merge --abort
      
      # 调用 AI 辅助解决冲突
      bash pty:true command:"claude '解决以下合并冲突：
$(git diff --name-only --diff-filter=U)

要求：
1. 分析冲突原因
2. 保留正确的代码
3. 确保功能完整
4. 提交解决方案
'"
      return 1
    fi
  done
  
  echo "✅ 所有模块集成完成"
}

7. 自动化测试验证

集成后自动运行测试套件：

# 验证函数
validate_integration() {
  local project_root=$1
  
  cd $project_root
  
  echo "🧪 运行集成测试..."
  
  # 安装依赖
  if [ -f "package.json" ]; then
    npm install
  elif [ -f "requirements.txt" ]; then
    pip install -r requirements.txt
  fi
  
  # 运行测试
  if npm test; then
    echo "✅ 所有测试通过"
    return 0
  else
    echo "❌ 测试失败，回滚集成"
    git reset --hard HEAD~1
    return 1
  fi
}

一人公司模式

基于 Elvis Sun 的实战经验：单日 94 次提交，30 分钟合并 7 个 PR，完全不打开编辑器。

核心理念

本地优先 + 自动化 + 批量处理

  • AI 跑在本地，不依赖云端网页
  • 不需要一直盯着屏幕
  • 不需要频繁点击权限弹窗
  • 让 AI 团队自主工作，你只需要审查结果

快速启动

cd your-project
bash ~/.openclaw/workspace/skills/multi-team-coding/examples/one-person-company.sh

详细文档：ONE-PERSON-COMPANY.md

Playwright 自动化测试

基于 Claude Code + Playwright CLI 实现端到端测试自动化。

核心优势

  • 高效：26K tokens vs 114K tokens (MCP)
  • 可靠：基于可访问性树，不依赖截图
  • 并行：多浏览器、多测试同时运行
  • 持久化：保存认证状态，避免重复登录

快速启动

cd your-project
bash ~/.openclaw/workspace/skills/multi-team-coding/examples/playwright-test-workflow.sh

详细文档：PLAYWRIGHT-AUTOMATION.md

快速开始

场景 1：批量修复 Bug

# 自动从 GitHub Issues 获取所有 bug
# 并行启动多个 Claude Code 团队修复
cd your-project
bash ~/.openclaw/workspace/skills/multi-team-coding/examples/claude-code-teams.sh 5

场景 2：开发新功能 + 自动测试

# 1. 开发功能
bash ~/.openclaw/workspace/skills/multi-team-coding/examples/claude-code-teams.sh

# 2. 生成并运行测试
bash ~/.openclaw/workspace/skills/multi-team-coding/examples/playwright-test-workflow.sh

场景 3：一人公司全自动模式

# 早上启动，下午收获
bash ~/.openclaw/workspace/skills/multi-team-coding/examples/one-person-company.sh

完整示例

电商系统开发（端到端）

#!/bin/bash
# 完整的电商系统开发流程

PROJECT_ROOT=~/Projects/ecommerce
cd $PROJECT_ROOT

echo "🚀 启动电商系统开发"

# 1. 并行开发核心功能
echo "📝 Step 1: 并行开发功能模块..."
bash ~/.openclaw/workspace/skills/multi-team-coding/examples/claude-code-teams.sh 5

# 等待开发完成
echo "⏳ 等待开发完成..."
wait

# 2. 生成自动化测试
echo "🧪 Step 2: 生成自动化测试..."
bash ~/.openclaw/workspace/skills/multi-team-coding/examples/playwright-test-workflow.sh << EOF
1
EOF

# 等待测试生成
wait

# 3. 运行测试
echo "🚀 Step 3: 运行测试..."
bash ~/.openclaw/workspace/skills/multi-team-coding/examples/playwright-test-workflow.sh << EOF
2
EOF

# 4. 自动合并 PR
echo "🔄 Step 4: 合并通过的 PR..."
gh pr list --state open --json number,statusCheckRollup | \
  jq -r '.[] | select(.statusCheckRollup[0].state == "SUCCESS") | .number' | \
  while read pr; do
    gh pr merge $pr --squash --delete-branch
  done

echo "🎉 完成！"
echo "📊 查看报告："
echo "  - 开发报告: /tmp/claude-teams-*/report-*.md"
echo "  - 测试报告: playwright-report/index.html"

工作流对比

传统方式

开发者手动编码
  ↓ (8 小时)
手动编写测试
  ↓ (2 小时)
手动运行测试
  ↓ (30 分钟)
手动创建 PR
  ↓ (10 分钟)
手动审查和合并
  ↓ (30 分钟)
总计: 11 小时 10 分钟

AI 驱动工作流

启动脚本
  ↓ (1 分钟)
AI 团队并行开发
  ↓ (30 分钟，自动)
AI 生成测试
  ↓ (15 分钟，自动)
自动运行测试
  ↓ (5 分钟，自动)
自动创建和合并 PR
  ↓ (2 分钟，自动)
总计: 53 分钟（人工参与 < 5 分钟）

效率提升：12 倍

配置和定制

自定义 Agent 选择

编辑 examples/claude-code-teams.sh：

select_agent_for_task() {
  local task_type=$1
  
  case $task_type in
    bug)
      echo "codex"      # 快速修复
      ;;
    feature)
      echo "claude"     # 复杂功能
      ;;
    refactor)
      echo "opencode"   # 代码优化
      ;;
  esac
}

自定义并发数

# 根据机器性能调整
# 8 核 CPU → 3-5 个并发
# 16 核 CPU → 8-10 个并发
bash claude-code-teams.sh 5

自定义测试类型

编辑 examples/playwright-test-workflow.sh：

# 只生成 E2E 测试
start_test_generation_team "$feature" "$description" "e2e"

# 生成所有类型测试
for type in e2e api visual performance; do
  start_test_generation_team "$feature" "$description" "$type"
done

最佳实践

1. 任务拆分

  • 独立性：每个任务应该独立，减少依赖
  • 明确性：清晰的目标和验收标准
  • 平衡性：工作量相当
  • 可测试：可以独立测试

2. 代码质量

  • 遵循项目规范（.editorconfig, .eslintrc）
  • 编写清晰的提交信息（Conventional Commits）
  • 保持测试覆盖率 > 80%
  • 及时处理 CI 失败

3. 资源管理

  • 控制并发数量（避免资源耗尽）
  • 定期清理 worktree
  • 监控系统资源使用
  • 使用 SSD 提升性能

4. 团队协作

  • 使用通知系统（Feishu/Slack）
  • 生成详细的日报
  • 定期审查 AI 生成的代码
  • 建立代码审查流程

故障排查

问题 1：Agent 卡住

# 查看日志
tail -f /tmp/*/logs/issue-*.log

# 发送继续信号
process action:write sessionId:XXX data:"继续\n"

# 重启
process action:kill sessionId:XXX

问题 2：测试失败

# 查看详细报告
npx playwright show-report

# 只运行失败的测试
npx playwright test --last-failed

# 调试模式
npx playwright test --debug

问题 3：PR 合并冲突

# 使用 AI 解决冲突
bash pty:true command:"claude '
解决以下合并冲突：
$(git diff --name-only --diff-filter=U)

要求：
1. 分析冲突原因
2. 保留正确的代码
3. 确保功能完整
4. 提交解决方案
'"

性能优化

1. 使用本地模型

# 对于简单任务，使用本地模型更快
export CODEX_MODEL="local/qwen-2.5-coder"
export CLAUDE_MODEL="local/deepseek-coder"

2. 缓存依赖

# 共享 node_modules
for team_dir in /tmp/teams/*/; do
  ln -s $PROJECT_ROOT/node_modules $team_dir/node_modules
done

3. 增量构建

# 只重建变更的模块
changed_modules=$(git diff --name-only main | cut -d'/' -f1 | sort -u)
for module in $changed_modules; do
  cd $module && npm run build
done

成本分析

API 成本

假设每个任务：
- Claude Code: $0.50
- Codex: $0.30
- OpenCode: $0.20
- Playwright 测试: $0.10

10 个任务 × 平均 $0.35 = $3.50

vs 人工成本：
10 个任务 × 8 小时 × $50/小时 = $4,000

节省：99.9%

时间成本

传统方式：10 个任务 × 8 小时 = 80 小时
AI 工作流：10 个任务 × 0.5 小时 = 5 小时

节省：75 小时（93.75%）

总结

这套 AI 驱动编程工作流提供：

✅ 多团队并行开发：2-5 倍速度提升 ✅ 一人公司模式：单日 90+ 提交 ✅ 自动化测试：E2E/API/视觉/性能全覆盖 ✅ 自动 PR 管理：从创建到合并全自动 ✅ 本地优先：不依赖云端，数据安全 ✅ 成本优化：节省 99.9% 人工成本

适用场景：

  • 独立开发者
  • 初创公司
  • 开源项目维护
  • 副业项目

开始你的 AI 驱动编程之旅！ 🚀

相关文档

社区和支持

场景

构建一个完整的电商系统，包含用户、商品、订单、支付四个核心模块。

执行流程

#!/bin/bash
# 电商系统多团队开发脚本

PROJECT_ROOT=$(pwd)
WORKSPACE_BASE=/tmp/ecommerce-$(date +%s)
mkdir -p $WORKSPACE_BASE/teams

echo "🚀 启动电商系统多团队开发"

# 1. 任务分解
declare -A TASKS=(
  ["auth"]="用户认证：注册、登录、JWT、权限管理"
  ["products"]="商品管理：CRUD、分类、搜索、库存"
  ["orders"]="订单系统：创建、支付、状态、历史"
  ["payment"]="支付集成：Stripe、支付宝、微信支付"
)

# 2. 创建工作空间并启动团队
for team in "${!TASKS[@]}"; do
  echo "  创建团队: $team"
  
  # 创建 worktree
  git worktree add -b team-$team $WORKSPACE_BASE/$team main
  
  # 启动 coding agent
  bash pty:true workdir:$WORKSPACE_BASE/$team background:true \
    command:"claude '
【团队】: $team
【任务】: ${TASKS[$team]}

【技术栈】:
- 后端: Node.js + Express + TypeScript
- 数据库: PostgreSQL + Prisma
- 测试: Jest + Supertest

【要求】:
1. 遵循 RESTful API 设计
2. 编写单元测试和集成测试
3. 添加 API 文档（JSDoc）
4. 错误处理和日志记录
5. 提交前运行 lint

【完成后】:
git add . && git commit -m \"feat($team): ${TASKS[$team]}\"
openclaw system event --text \"✅ $team 完成\" --mode now
'" &
  
  echo $! > $WORKSPACE_BASE/teams/$team.pid
done

# 3. 监控进度
echo ""
echo "📊 监控团队进度（每30秒更新）"
while true; do
  clear
  echo "=== 电商系统开发进度 $(date +%H:%M:%S) ==="
  echo ""
  
  all_done=true
  for team in "${!TASKS[@]}"; do
    pid=$(cat $WORKSPACE_BASE/teams/$team.pid 2>/dev/null)
    
    if [ -n "$pid" ] && ps -p $pid > /dev/null 2>&1; then
      echo "  [$team] 🟢 进行中"
      all_done=false
    else
      echo "  [$team] ✅ 已完成"
    fi
  done
  
  if $all_done; then
    echo ""
    echo "🎉 所有团队完成！开始集成..."
    break
  fi
  
  sleep 30
done

# 4. 冲突检测
echo ""
echo "🔍 检测代码冲突..."
cd $PROJECT_ROOT

conflicts_found=false
for team in "${!TASKS[@]}"; do
  if ! git merge --no-commit --no-ff team-$team 2>/dev/null; then
    echo "  ⚠️  $team 存在冲突"
    conflicts_found=true
    git merge --abort
  else
    git merge --abort
  fi
done

if $conflicts_found; then
  echo "❌ 发现冲突，需要手动解决"
  exit 1
fi

# 5. 按顺序合并
echo ""
echo "🔄 合并各团队成果..."
merge_order=("auth" "products" "orders" "payment")

for team in "${merge_order[@]}"; do
  echo "  合并 $team..."
  git merge --no-ff team-$team -m "feat: 集成 $team 模块"
done

# 6. 运行测试
echo ""
echo "🧪 运行集成测试..."
npm install
npm test

if [ $? -eq 0 ]; then
  echo "✅ 所有测试通过"
else
  echo "❌ 测试失败，回滚"
  git reset --hard HEAD~4
  exit 1
fi

# 7. 清理
echo ""
echo "🧹 清理工作空间..."
for team in "${!TASKS[@]}"; do
  git worktree remove $WORKSPACE_BASE/$team
done

echo ""
echo "🎊 电商系统开发完成！"

高级特性

1. 依赖管理

处理模块间的依赖关系：

# 定义依赖图
declare -A DEPENDENCIES=(
  ["auth"]=""                    # 无依赖，优先执行
  ["products"]="auth"            # 依赖 auth
  ["orders"]="auth,products"     # 依赖 auth 和 products
  ["payment"]="orders"           # 依赖 orders
)

# 拓扑排序执行
execute_with_dependencies() {
  local executed=()
  local pending=("${!DEPENDENCIES[@]}")
  
  while [ ${#pending[@]} -gt 0 ]; do
    for task in "${pending[@]}"; do
      deps="${DEPENDENCIES[$task]}"
      
      # 检查依赖是否都已完成
      can_execute=true
      if [ -n "$deps" ]; then
        IFS=',' read -ra dep_array <<< "$deps"
        for dep in "${dep_array[@]}"; do
          if [[ ! " ${executed[@]} " =~ " ${dep} " ]]; then
            can_execute=false
            break
          fi
        done
      fi
      
      # 执行任务
      if $can_execute; then
        start_team "$task" "claude" "${TASKS[$task]}"
        executed+=("$task")
        pending=("${pending[@]/$task}")
      fi
    done
    
    sleep 5
  done
}

2. 动态负载均衡

根据任务复杂度分配不同的 agent：

# 任务复杂度评估
estimate_complexity() {
  local task=$1
  local lines_of_code=0
  local num_files=0
  
  # 分析任务描述，估算复杂度
  # 简单任务: < 500 行代码
  # 中等任务: 500-2000 行
  # 复杂任务: > 2000 行
  
  if [ $lines_of_code -lt 500 ]; then
    echo "simple"
  elif [ $lines_of_code -lt 2000 ]; then
    echo "medium"
  else
    echo "complex"
  fi
}

# 选择合适的 agent
select_agent() {
  local complexity=$1
  
  case $complexity in
    simple)
      echo "opencode"  # 快速，适合简单任务
      ;;
    medium)
      echo "codex"     # 平衡，适合中等任务
      ;;
    complex)
      echo "claude"    # 强大，适合复杂任务
      ;;
  esac
}

3. 自动重试机制

团队失败时自动重试：

# 重试函数
retry_team() {
  local team=$1
  local max_retries=3
  local retry_count=0
  
  while [ $retry_count -lt $max_retries ]; do
    echo "  尝试 $team (第 $((retry_count+1)) 次)..."
    
    start_team "$team" "claude" "${TASKS[$team]}"
    
    # 等待完成
    wait_for_team "$team"
    
    # 检查结果
    if validate_team_output "$team"; then
      echo "  ✅ $team 成功"
      return 0
    else
      echo "  ❌ $team 失败，准备重试..."
      retry_count=$((retry_count+1))
      
      # 清理失败的工作
      cd $WORKSPACE_BASE/$team
      git reset --hard HEAD
      git clean -fd
    fi
  done
  
  echo "  ❌ $team 达到最大重试次数"
  return 1
}

4. 实时协作通知

通过 Feishu/Slack 发送进度通知：

# 发送通知
notify_progress() {
  local team=$1
  local status=$2
  local message=$3
  
  # 使用 OpenClaw 的 message 工具
  message action:send channel:feishu target:group_chat_id \
    message:"
【多团队开发进度】
团队: $team
状态: $status
详情: $message
时间: $(date '+%Y-%m-%d %H:%M:%S')
"
}

# 在关键节点发送通知
notify_progress "auth" "🟢 进行中" "用户认证模块开发中..."
notify_progress "auth" "✅ 完成" "用户认证模块已完成并通过测试"

最佳实践

1. 任务拆分原则

SMART 原则：

  • Specific（具体）：任务描述清晰明确
  • Measurable（可衡量）：有明确的完成标准
  • Achievable（可实现）：单个团队能在合理时间内完成
  • Relevant（相关）：与项目目标直接相关
  • Time-bound（有时限）：设定合理的完成时间

示例：

❌ 不好：实现用户功能
✅ 好：实现用户注册、登录、JWT认证，包含单元测试，预计2小时

2. 代码规范统一

在项目根目录创建配置文件：

# .editorconfig
root = true

[*]
charset = utf-8
indent_style = space
indent_size = 2
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true

# .eslintrc.json
{
  "extends": ["airbnb-base"],
  "rules": {
    "no-console": "warn"
  }
}

# .prettierrc
{
  "semi": true,
  "singleQuote": true,
  "tabWidth": 2
}

3. 提交信息规范

使用 Conventional Commits：

# 格式
<type>(<scope>): <subject>

# 类型
feat: 新功能
fix: 修复
docs: 文档
style: 格式
refactor: 重构
test: 测试
chore: 构建

# 示例
feat(auth): 实现JWT认证
fix(orders): 修复订单状态更新bug
docs(api): 更新API文档

4. 测试策略

每个团队必须包含测试：

// 单元测试示例
describe('Auth Module', () => {
  test('should register new user', async () => {
    const user = await register({
      email: 'test@example.com',
      password: 'password123'
    });
    expect(user).toHaveProperty('id');
  });
  
  test('should login with valid credentials', async () => {
    const token = await login({
      email: 'test@example.com',
      password: 'password123'
    });
    expect(token).toBeTruthy();
  });
});

5. 文档要求

每个模块包含 README：

# 用户认证模块

## 功能
- 用户注册
- 用户登录
- JWT Token 管理
- 密码加密

## API 端点
- POST /api/auth/register
- POST /api/auth/login
- POST /api/auth/logout

## 使用示例
\`\`\`javascript
const { register } = require('./auth');
const user = await register({ email, password });
\`\`\`

## 测试
\`\`\`bash
npm test auth
\`\`\`

故障排查

问题 1：团队卡住不动

症状：进程运行但无输出

解决：

# 查看详细日志
process action:log sessionId:XXX limit:100

# 发送输入（可能在等待确认）
process action:submit sessionId:XXX data:"y"

# 如果真的卡住，重启
process action:kill sessionId:XXX
retry_team "team_name"

问题 2：合并冲突

症状：多个团队修改了同一文件

解决：

# 查看冲突文件
git diff --name-only --diff-filter=U

# 使用 AI 辅助解决
bash pty:true command:"claude '
分析并解决以下合并冲突：

冲突文件：
$(git diff --name-only --diff-filter=U)

冲突内容：
$(git diff)

要求：
1. 理解两个版本的意图
2. 合并功能，保留所有特性
3. 确保代码可运行
4. 解决后提交
'"

问题 3：测试失败

症状：集成后测试不通过

解决：

# 查看失败的测试
npm test -- --verbose

# 逐个模块测试
for team in auth products orders; do
  echo "测试 $team..."
  npm test -- $team
done

# 回滚到最后一个可工作的版本
git log --oneline -10
git reset --hard <commit_hash>

问题 4：性能问题

症状：同时运行太多团队导致系统卡顿

解决：

# 限制并发数
MAX_CONCURRENT=3
active_count=0

for team in "${!TASKS[@]}"; do
  # 等待有空位
  while [ $active_count -ge $MAX_CONCURRENT ]; do
    sleep 5
    # 更新活跃计数
    active_count=$(ps aux | grep "claude\|codex\|opencode" | wc -l)
  done
  
  start_team "$team"
  active_count=$((active_count+1))
done

性能优化

1. 增量构建

只重新构建修改的模块：

# 检测变更
changed_modules=$(git diff --name-only main | cut -d'/' -f1 | sort -u)

# 只重建变更的模块
for module in $changed_modules; do
  cd $module && npm run build
done

2. 缓存依赖

共享 node_modules：

# 在主项目安装依赖
npm install

# 各团队链接到主项目
for team_dir in $WORKSPACE_BASE/*/; do
  ln -s $PROJECT_ROOT/node_modules $team_dir/node_modules
done

3. 并行测试

使用 Jest 的并行功能：

# 并行运行所有测试
npm test -- --maxWorkers=4

# 只运行变更相关的测试
npm test -- --onlyChanged

总结

多团队编程工作流通过智能编排和并行执行，将开发效率提升 2-5 倍。

关键要素：

  • 主 agent 作为编排器，负责任务分解和协调
  • 多个 coding agent 并行工作，互不干扰
  • 实时监控进度，自动处理异常
  • 智能冲突检测和解决
  • 自动化测试和集成

适用场景：

  • 大型功能的模块化开发
  • 批量 issue 并行修复
  • 多仓库同步更新
  • 复杂重构任务

注意事项：

  • 合理拆分任务，确保独立性
  • 控制并发数量，避免资源耗尽
  • 定期检查进度，及时处理异常
  • 重视测试，确保集成质量

Source Transparency

This detail page is rendered from real SKILL.md content. Trust labels are metadata-based hints, not a safety guarantee.

Open Registry RecordOpen in ClawHub

Related Skills

Related by shared tags or category signals.

Coding

Wip Ai Devops Toolbox Private

Complete DevOps toolkit for AI-assisted software development. Release pipeline, license compliance, copyright enforcement, repo visibility guard, identity fi...

Registry SourceRecently Updated
2860parkertoddbrooks
Coding

Wip Release

One-command release pipeline. Bumps version, updates changelog + SKILL.md, publishes to npm + GitHub.

Registry SourceRecently Updated
2700parkertoddbrooks
Coding

Wip File Guard

Hook that blocks destructive edits to protected identity files. For Claude Code CLI and OpenClaw.

Registry SourceRecently Updated
5690parkertoddbrooks
Coding

Agent Memory Manager

Gives the agent persistent, structured long-term memory across sessions. Organizes memory by project, client, trade, and domain. The agent never forgets what...

Registry SourceRecently Updated
270georges91560