<!-- title: Claude Code自动化：从-p模式到Agent调度 -->

## 概述

本教程面向已熟悉 Claude Code 基础交互、希望将其集成到自动化流水线中的开发者。你将掌握三种核心自动化机制：`--print` / `-p` 非交互模式、Hooks 生命周期钩子、以及基于 Task 工具的子 Agent 并行调度。学完即可将 Claude Code 嵌入 CI/CD、定时任务、批量脚本，构建"AI 即基础设施"的开发工作流。

**适用人群**：有 3 个月以上 Claude Code 使用经验的开发者、DevOps 工程师、技术团队负责人。

**前置条件**：
- Claude Code CLI 已安装并完成 API Key 配置
- 熟悉 Bash 脚本与 JSON 处理（jq）
- 了解 Git hooks 概念
- 一个可运行的代码仓库用于练习

---

## 第一章：非交互模式——让 Claude Code 成为命令行工具

### 1.1 --print 模式基础

交互模式下，Claude Code 是对话式的。但自动化场景需要"输入→执行→输出→退出"的单次运行模式。`--print`（缩写 `-p`）就是为此而生。

```bash
# 最简单的非交互调用
claude -p "解释 src/index.ts 的入口函数"

# 等价写法
claude --print "解释 src/index.ts 的入口函数"
```

**预期结果**：Claude Code 读取文件、分析代码、输出解释文本，然后退出。不会进入交互循环。

### 1.2 管道输入：Unix 哲学的威力

`--print` 模式天然支持 Unix 管道，这是构建自动化链的基础：

```bash
# 将 git diff 管道给 Claude Code 做 code review
git diff HEAD~3..HEAD | claude -p "审查这些变更，列出潜在问题"

# 将错误日志管道给 Claude Code 分析根因
npm test 2>&1 | claude -p "分析测试失败原因并给出修复建议"

# 将 API 响应管道给 Claude Code 生成类型定义
curl -s https://api.example.com/openapi.json | \
  claude -p "根据这个 OpenAPI 规范生成 TypeScript 类型定义"
```

### 1.3 结构化输出：从文本到可解析数据

自动化流水线需要机器可读的输出，而非人类可读的散文。`--output-format` 和 `--json-schema` 两个 flag 组合使用，可以将 Claude Code 变成一个结构化数据生成器：

```bash
# JSON 格式输出
claude -p --output-format json \
  "列出 src/ 目录下所有 API 端点，包含路径、方法、描述"

# 流式 JSON——适合长时间任务
claude -p --output-format stream-json \
  "重构 src/auth.ts 模块"

# 强制 JSON Schema 校验——这是自动化的关键
claude -p \
  --output-format json \
  --json-schema '{
    "type": "object",
    "properties": {
      "title": {"type": "string"},
      "risk": {"type": "string", "enum": ["low", "medium", "high"]},
      "summary": {"type": "string"}
    },
    "required": ["title", "risk", "summary"]
  }' \
  "审查当前 git diff，返回标题、风险等级和摘要"
```

**预期输出**：
```json
{
  "title": "Auth middleware bypass vulnerability",
  "risk": "high",
  "summary": "jwt.verify 缺少算法白名单限制，攻击者可通过 alg:none 绕过认证"
}
```

### 1.4 工具边界控制：安全自动化的基石

在自动化场景中，Claude Code 的行为必须可预测。`--allowedTools` 和 `--disallowedTools` 提供了精确的工具级控制：

```bash
# 只允许读取，禁止写入——适合 code review 场景
claude -p \
  --allowedTools "Read,Glob,Grep" \
  "审计 src/ 目录的安全问题"

# 允许编辑和 git 操作，禁止网络请求
claude -p \
  --allowedTools "Read,Edit,Bash(git:*)" \
  --disallowedTools "Bash(curl:*)" \
  "修复所有 TypeScript 编译错误并提交"

# 精确控制 Bash 子命令
claude -p \
  --allowedTools "Read,Edit,Bash(npm test:*),Bash(npm run lint:*)" \
  "运行测试并修复所有失败的用例"
```

### 1.5 权限模式：自动化场景的最佳选择

`--permission-mode` 决定了 Claude Code 在遇到需要确认的操作时的行为：

```bash
# plan 模式：只规划不执行，适合架构评审
claude -p --permission-mode plan "分析这个微服务架构的瓶颈"

# auto 模式：自动处理大部分权限请求，适合受信任的脚本
claude -p --permission-mode auto "清理所有未使用的 import"

# dontAsk 模式：不询问直接执行，仅在沙箱环境中使用
claude -p --permission-mode dontAsk "重构 src/utils/ 目录"
```

### 1.6 会话管理：恢复与分支

```bash
# 恢复最近的会话
claude --continue

# 恢复指定 ID 的会话
claude --resume abc12345-6789-def0-1234-567890abcdef

# 从已有会话分支出新会话——类似 git branch
claude --continue --fork-session
```

`--fork-session` 特别有用：你在探索一个方案时发现需要走另一条路，可以分叉出新的会话，保留原始上下文但不污染原会话历史。

---

## 第二章：Hooks——Claude Code 的生命周期钩子系统

### 2.1 Hooks 是什么

Hooks 是在 Claude Code 生命周期的特定时刻自动执行的 shell 命令、HTTP 请求或 LLM 提示。它们是**确定性的**——不像 CLAUDE.md 中的指令那样"可能被遵守"，而是**必定执行**。


![图表1](images/claude-code-tutorial-r4-0355-mermaid-0.png)

> *图表 1*


**核心价值对比**：

| 机制 | 执行保证 | 适用场景 |
|------|---------|---------|
| CLAUDE.md 指令 | 不保证（AI 可能忽略） | 编码风格偏好、项目约定 |
| Hooks | 100% 保证 | 安全策略、代码格式化、审计日志 |
| MCP 服务器 | 按需调用 | 外部工具集成 |

### 2.2 Hook 配置位置

```bash
# 项目级（推荐，随代码仓库共享）
.claude/settings.json

# 用户级（对所有项目生效）
~/.claude/settings.json
```

### 2.3 Hook 类型与事件

Claude Code 提供了三种 Hook 类型和超过 20 个生命周期事件：

**三种 Hook 类型**：

| 类型 | 机制 | 适用场景 |
|------|------|---------|
| `command` | 执行 shell 命令 | 格式化、lint、安全检查 |
| `http` | 发送 HTTP 请求 | 外部系统集成、通知 |
| `prompt` | 调用 LLM 做决策 | 复杂判断（shell 无法处理的） |

**核心事件时间线**：

| 事件 | 触发时机 | 能否阻止操作 |
|------|---------|------------|
| `SessionStart` | 会话启动/恢复 | 否 |
| `UserPromptSubmit` | 用户提交提示后 | 是 |
| `PreToolUse` | 工具执行前 | 是 |
| `PostToolUse` | 工具执行后 | 否（已执行） |
| `SubagentStart` | 子 Agent 启动时 | 否 |
| `SubagentStop` | 子 Agent 完成时 | 是 |
| `Stop` | Agent 完成响应时 | 是 |
| `Notification` | 发送通知时 | 否 |
| `FileChanged` | 磁盘文件变更时 | 否 |

### 2.4 实战：第一个 Hook——自动格式化

```json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write 2>/dev/null; exit 0"
          }
        ]
      }
    ]
  }
}
```

**工作原理**：
1. Claude Code 写入或编辑文件（触发 `PostToolUse`，匹配 `Write` 或 `Edit`）
2. Hook 通过 stdin 接收 JSON，包含文件路径
3. `jq` 提取路径，Prettier 格式化该文件
4. `exit 0` 确保即使 Prettier 失败也不阻塞 Claude Code

### 2.5 实战：安全防护 Hook

阻止危险命令执行，这是生产环境必备：

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'CMD=$(jq -r \".tool_input.command\" <<< \"$(cat)\"); for p in \"rm -rf /\" \"rm -rf ~\" \"drop table\" \"--force\" \"push.*--force\"; do if echo \"$CMD\" | grep -qiE \"$p\"; then echo \"Blocked: $p\" >&2; exit 2; fi; done; exit 0'"
          }
        ]
      }
    ]
  }
}
```

**关键机制**：`exit 2` 表示"阻止操作"。Claude Code 会看到 stderr 中的阻止原因，并调整后续行为。

保护敏感文件不被写入：

```bash
#!/bin/bash
# .claude/hooks/protect-files.sh
INPUT=$(cat)
FILE=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')

PROTECTED=(".env" ".env.local" "secrets/" ".git/" "package-lock.json")

for pattern in "${PROTECTED[@]}"; do
  if [[ "$FILE" == *"$pattern"* ]]; then
    jq -n --arg f "$FILE" --arg p "$pattern" '{
      hookSpecificOutput: {
        hookEventName: "PreToolUse",
        permissionDecision: "deny",
        permissionDecisionReason: "受保护文件被拦截: \($p)"
      }
    }'
    exit 0
  fi
done
exit 0
```

对应配置：

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/protect-files.sh"
          }
        ]
      }
    ]
  }
}
```

### 2.6 实战：审计日志 Hook

记录 Claude Code 执行的所有 Bash 命令：

```json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'jq -r \".tool_input.command\" <<< \"$(cat)\" | while read cmd; do echo \"$(date +%Y-%m-%dT%H:%M:%S) $cmd\" >> \"$CLAUDE_PROJECT_DIR/.claude/command-audit.log\"; done; exit 0'"
          }
        ]
      }
    ]
  }
}
```

### 2.7 实战：Stop Hook——响应完成前的质量门禁

`Stop` 事件在 Claude Code 完成响应时触发。你可以在此时运行验证：

```bash
#!/bin/bash
# .claude/hooks/verify-tests.sh
INPUT=$(cat)

# 防止无限循环：如果 hook 已经激活过，直接退出
if [ "$(echo "$INPUT" | jq -r '.stop_hook_active')" = "true" ]; then
  exit 0
fi

# 检查是否有 TypeScript 文件被修改
CHANGED=$(git diff --name-only | grep -c '\.tsx\?$' || true)

if [ "$CHANGED" -gt 0 ]; then
  # 运行类型检查
  if ! npx tsc --noEmit 2>/dev/null; then
    echo "TypeScript 类型检查失败，请修复后再完成"
    exit 2
  fi
fi
exit 0
```

**防循环机制至关重要**：Stop Hook 触发后 Claude Code 可能再次响应，再次触发 Stop。`stop_hook_active` 字段用于检测这种循环。

### 2.8 Hook 的高级用法：MCP 工具匹配

Hook 的 `matcher` 字段支持匹配 MCP 工具调用：

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "mcp__github__*",
        "hooks": [
          {
            "type": "command",
            "command": "echo 'MCP GitHub tool called' >> /tmp/mcp-audit.log"
          }
        ]
      }
    ]
  }
}
```

### 2.9 HTTP Hook：集成外部系统

```json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "http",
            "url": "https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK",
            "method": "POST",
            "headers": {
              "Content-Type": "application/json"
            }
            }
          }
        ]
      }
    ]
  }
}
```

---

## 第三章：子 Agent 与并行调度

### 3.1 子 Agent 的本质

子 Agent（Subagent）是 Claude Code 通过 Task 工具创建的独立 AI 会话。每个子 Agent 拥有自己的上下文窗口、系统提示和工具权限。关键特性：

1. **上下文隔离**：子 Agent 的探索不会污染父 Agent 的上下文
2. **并行执行**：多个子 Agent 可以同时运行
3. **单一返回值**：父 Agent 只看到子 Agent 的最终摘要，而非中间过程


![图表2](images/claude-code-tutorial-r4-0355-mermaid-1.png)

> *图表 2*


### 3.2 内置子 Agent

Claude Code 自带几个预定义的子 Agent：

| 子 Agent | 模型 | 工具权限 | 用途 |
|----------|------|---------|------|
| Explore | Haiku（快速低成本） | 只读 | 代码搜索、文件发现 |
| Plan | 继承父会话 | 只读 | 架构研究、方案设计 |
| General-purpose | 继承父会话 | 全部工具 | 复杂多步骤任务 |
| statusline-setup | Sonnet | 有限 | 状态栏配置 |
| claude-code-guide | Haiku | 只读 | Claude Code 使用帮助 |

**Explore 的深度级别**：
- `quick`：快速搜索，适合精确查找
- `medium`：平衡搜索，适合一般探索
- `very thorough`：全面搜索，适合深度分析

### 3.3 自定义子 Agent

子 Agent 用 Markdown + YAML frontmatter 定义：

```markdown
---
name: security-auditor
description: 安全审计专家，扫描代码中的 OWASP Top 10 漏洞
model: claude-haiku-4-5
tools:
  - Read
  - Glob
  - Grep
---

你是一位专业的安全审计员。你的任务是：

1. 扫描指定文件或目录中的安全漏洞
2. 按 OWASP Top 10 分类标记问题
3. 给出每个问题的严重等级（Critical/High/Medium/Low）
4. 提供具体的修复建议和代码示例

输出格式：
- 每个问题包含：文件路径、行号、漏洞类型、严重等级、修复建议
- 最后给出整体安全评分（A-F）
```

保存位置：
```bash
# 项目级
.claude/agents/security-auditor.md

# 用户级（所有项目可用）
~/.claude/agents/security-auditor.md
```

### 3.4 子 Agent 的工具限制

精确控制子 Agent 能做什么，是实现安全自动化的关键：

```markdown
---
name: test-writer
description: 自动编写单元测试
model: claude-sonnet-4-6
allowed-tools:
  - Read
  - Write
  - Glob
  - Grep
  - Bash(npm test:*)
disallowed-tools:
  - Edit
---
```

### 3.5 Worktree 隔离：并行修改不冲突

当多个子 Agent 需要修改代码时，使用 Git Worktree 提供文件系统级隔离：

```bash
# 在 worktree 中运行子 Agent
claude --worktree

# 或在配置中指定
```


![图表3](images/claude-code-tutorial-r4-0355-mermaid-2.png)

> *图表 3*


### 3.6 并行模式的三种范式

**范式 1：并行探索（Parallel Exploration）**

适合开始新功能前快速了解代码库：

```
请用 Task 工具并行启动 4 个子 Agent：
1. 读取 auth/ 目录，总结认证模式
2. 读取 api/ 目录，总结路由模式
3. 读取 db/ 目录，总结数据层模式
4. 读取 tests/ 目录，总结测试模式

每个返回 200 字摘要。
```

**范式 2：并行应用（Parallel Application）**

同一模板应用到多个目标：

```
为以下 6 个模块各启动一个子 Agent 编写单元测试：
- src/auth/
- src/api/
- src/db/
- src/utils/
- src/middleware/
- src/services/

每个子 Agent 读取对应模块和现有测试模式，然后编写测试文件。
```

**范式 3：专业角色（Specialized Personas）**

```
启动 3 个子 Agent 审查这段代码：
1. 安全审计员：检查注入、XSS、CSRF 等安全漏洞
2. 性能分析师：检查 N+1 查询、内存泄漏、不必要的重渲染
3. 可维护性评审：检查命名、复杂度、测试覆盖

每个返回独立评审报告。
```

### 3.7 成本控制策略

子 Agent 会增加 token 消耗，需要合理控制：

| 策略 | 做法 | 效果 |
|------|------|------|
| 模型路由 | 探索类任务用 Haiku，复杂任务用 Sonnet | 成本降低 60-80% |
| 限制工具 | 只读子 Agent 禁止 Write/Edit | 避免意外修改 |
| 控制并发 | API Tier 1 最多 5 个并发 | 避免排队浪费 |
| 精简提示 | 子 Agent 提示控制在 100-300 字 | 减少 input token |
| 汇总而非堆叠 | 父 Agent 综合子 Agent 结果，而非直接拼接 | 控制上下文大小 |

---

## 第四章：自动化实战案例

### 4.1 CI/CD 集成：自动代码审查

```yaml
# .github/workflows/ai-review.yml
name: AI Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  ai-review:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

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

      - name: AI Code Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # 获取 PR 变更范围
          DIFF=$(git diff origin/main...HEAD)
          
          # 结构化审查
          claude -p \
            --output-format json \
            --json-schema '{
              "type": "object",
              "properties": {
                "issues": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "properties": {
                      "file": {"type": "string"},
                      "line": {"type": "number"},
                      "severity": {"type": "string"},
                      "message": {"type": "string"}
                    }
                  }
                },
                "summary": {"type": "string"},
                "approved": {"type": "boolean"}
              }
            }' \
            --allowedTools "Read,Glob,Grep" \
            "审查以下变更。以下是 git diff 输出：
            $DIFF
            
            检查安全漏洞、性能问题、代码风格。
            如果没有严重问题，设置 approved 为 true。" \
            > review_result.json

          # 发布审查结果到 PR
          SUMMARY=$(jq -r '.summary' review_result.json)
          APPROVED=$(jq -r '.approved' review_result.json)
          
          gh pr comment ${{ github.event.pull_request.number }} \
            --body "## AI Code Review
            $SUMMARY
            **状态**: $([ "$APPROVED" = "true" ] && echo '✅ 通过' || echo '⚠️ 需要关注')"
```

### 4.2 定时任务：夜间代码清理

```bash
#!/bin/bash
# scripts/nightly-cleanup.sh

set -euo pipefail

LOG_FILE=".claude/logs/cleanup-$(date +%Y%m%d).log"

claude -p \
  --permission-mode auto \
  --allowedTools "Read,Edit,Bash(npm run lint:*),Bash(git:*)" \
  "执行以下任务：
1. 扫描 src/ 目录中所有未使用的 import 并移除
2. 运行 ESLint --fix 修复所有可自动修复的问题
3. 更新 TypeScript 类型定义中的过期引用
4. 如果有修改，用 'chore: nightly cleanup [skip ci]' 提交
5. 列出所有修改过的文件" \
  2>&1 | tee "$LOG_FILE"

echo "清理完成于 $(date)" >> "$LOG_FILE"
```

配合 crontab 定时执行：

```bash
# 每天凌晨 2 点执行
0 2 * * * /path/to/project/scripts/nightly-cleanup.sh
```

### 4.3 批量处理：多文件文档生成

```bash
#!/bin/bash
# scripts/generate-docs.sh

# 为每个组件生成 JSDoc 文档
for file in src/components/*.tsx; do
  component_name=$(basename "$file" .tsx)
  
  echo "处理组件: $component_name"
  
  claude -p \
    --output-format json \
    --allowedTools "Read,Edit" \
    "为 $file 中的所有导出函数和组件添加 JSDoc 注释。
    遵循以下规则：
    - 每个导出函数必须有 @param、@returns、@example
    - React 组件必须有 Props 类型说明
    - 使用中文注释
    不要修改函数逻辑，只添加注释。" \
    > "docs/component-${component_name}.json"
done

echo "所有组件文档生成完成"
```

### 4.4 测试失败自动修复

```bash
#!/bin/bash
# scripts/auto-fix-tests.sh

# 运行测试
npm test 2>&1 | tee /tmp/test-output.txt
EXIT_CODE=$?

if [ $EXIT_CODE -ne 0 ]; then
  echo "测试失败，启动自动修复..."
  
  claude -p \
    --permission-mode auto \
    --allowedTools "Read,Edit,Write,Bash(npm test:*)" \
    "以下是测试失败的输出：

$(cat /tmp/test-output.txt)

请：
1. 分析每个失败测试的原因
2. 修复源代码中的 bug（不是修改测试来适应 bug）
3. 重新运行测试验证修复
4. 报告修复了哪些文件以及每个问题的根因"
else
  echo "所有测试通过"
fi
```

### 4.5 完整的 Agent 调度流水线

以下是一个综合案例，展示如何组合 `-p` 模式、Hooks 和子 Agent 来处理 Bug 修复流程：

```bash
#!/bin/bash
# scripts/triage-bugs.sh
# 自动拉取高优先级 bug，分析并批量修复

set -euo pipefail

# 步骤 1：拉取 bug 列表
ISSUES=$(claude -p \
  --output-format json \
  --allowedTools "Bash(gh:*)" \
  "使用 gh CLI 列出所有 open 的、标记为 bug 和 high-priority 的 issue。
   返回 JSON 数组，每个元素包含：number, title, labels, body 前 200 字符")

echo "发现 $(echo "$ISSUES" | jq 'length') 个高优先级 bug"

# 步骤 2：对每个 bug 启动独立的 worktree 修复
for i in $(seq 0 $(($(echo "$ISSUES" | jq 'length') - 1))); do
  NUMBER=$(echo "$ISSUES" | jq -r ".[$i].number")
  TITLE=$(echo "$ISSUES" | jq -r ".[$i].title")
  BODY=$(echo "$ISSUES" | jq -r ".[$i].body")
  
  echo "=== 处理 Bug #$NUMBER: $TITLE ==="
  
  # 在独立 worktree 中修复
  claude -p \
    --permission-mode auto \
    --worktree \
    --allowedTools "Read,Edit,Write,Bash(npm test:*),Bash(git:*)" \
    "你正在修复 GitHub Issue #$NUMBER。

标题：$TITLE
描述：$BODY

步骤：
1. 阅读相关代码，理解 bug 根因
2. 实现修复
3. 运行测试验证
4. 提交到新分支 fix/issue-$NUMBER
5. 返回修复摘要"
done

echo "所有 bug 处理完成"
```

---

## 第五章：高级技巧与最佳实践

### 5.1 --append-system-prompt：轻量级行为注入

不需要修改 CLAUDE.md，就能为特定任务添加规则：

```bash
claude -p \
  --append-system-prompt "在修改生产代码前，必须先编写回归测试" \
  "修复 src/api/auth.ts 中的 JWT 验证 bug"
```

### 5.2 MCP 配置隔离

使用 `--mcp-config` 和 `--strict-mcp-config` 确保自动化环境的可复现性：

```bash
# 只使用指定的 MCP 服务器，忽略全局配置
claude -p \
  --mcp-config ./mcp.review.json \
  --strict-mcp-config \
  "使用 GitHub MCP 工具审查最近的 PR"
```

### 5.3 多目录访问

```bash
# 同时访问主仓库和共享库
claude -p \
  --add-dir ../shared-lib \
  --add-dir ../design-system \
  "检查主仓库中是否有可以直接使用 shared-lib 中已有实现的重复代码"
```

### 5.4 调试自动化问题

```bash
# 将调试日志写入文件
claude -p \
  --debug-file ./claude-debug.log \
  "这个自动化任务出了问题"

# 会话结束后检查日志
cat ./claude-debug.log | grep -i error
```

### 5.5 错误处理与重试

```bash
#!/bin/bash
MAX_RETRIES=3
RETRY=0

while [ $RETRY -lt $MAX_RETRIES ]; do
  if claude -p \
    --permission-mode auto \
    "完成指定任务"; then
    echo "任务成功完成"
    exit 0
  fi
  
  RETRY=$((RETRY + 1))
  echo "第 $RETRY 次尝试失败，重试中..."
  sleep 10
done

echo "任务在 $MAX_RETRIES 次尝试后仍然失败"
exit 1
```

### 5.6 Hooks + -p 模式的协同

在 `.claude/settings.json` 中配置的 Hooks 对 `-p` 模式同样生效。这意味着你的安全策略和代码质量控制在自动化场景下依然有效：


![图表4](images/claude-code-tutorial-r4-0355-mermaid-3.png)

> *图表 4*


---

## 第六章：架构全景图


![图表5](images/claude-code-tutorial-r4-0355-mermaid-4.png)

> *图表 5*


---

## 延伸阅读

- [Claude Code Hooks 官方文档](https://code.claude.com/docs/en/hooks) — 完整的 Hook 事件参考和 JSON Schema
- [Claude Code 子 Agent 官方文档](https://code.claude.com/docs/en/sub-agents) — 自定义 Agent 的创建和配置
- [Claude Code CLI 完整参考](https://skillsplayground.com/guides/claude-code-cli/) — 所有 CLI flag 和环境变量
- [10 个你可能没用过的 CLI Flag](https://www.mager.co/blog/2026-04-20-claude-code-cli-flags/) — 进阶 flag 使用技巧
- [awesome-claude-code-hooks](https://github.com/ithiria894/awesome-claude-code-hooks) — 社区维护的 Hook 配置合集
- [Claude Code Headless 模式详解](https://restato.github.io/blog/claude-code-headless-mode/) — 非交互模式的深度指南

---

## 训练营适用性评估

| 维度 | 评估 |
|------|------|
| **适合训练营类型** | 进阶训练营（学员需有 Claude Code 基础使用经验）、DevOps 自动化训练营、团队效能提升工作坊 |
| **前置知识要求** | Bash 脚本、JSON/jq、Git 基础、CI/CD 概念、Claude Code 基础操作 |
| **预计教学时长** | 4-6 小时（含动手实验） |
| **实验环境要求** | 每人一个代码仓库、Anthropic API Key、GitHub 仓库 |
| **推荐教学顺序** | 第 1 章（30分钟）→ 第 2 章（60分钟）→ 第 3 章（45分钟）→ 第 4 章实战（90分钟）→ 第 5 章讨论（30分钟） |
| **课后作业建议** | 为自己的项目配置完整的 Hook 体系 + 一个 CI/CD 自动审查 Pipeline |

> [!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)