<!-- title: 模型智能路由：Advisor到Fast全实战 -->

# 模型智能路由：从三档选型到Advisor策略全实战

## 概述

Claude Code提供Haiku、Sonnet、Opus三档模型，2026年4月Anthropic推出Advisor策略——让Sonnet/Haiku在执行过程中按需调用Opus作为"高级顾问"，以Sonnet的价格获得接近Opus的质量。本教程覆盖模型选型决策树、`/model`切换、Advisor策略配置、Fast模式加速，以及一个完整的混合模型工作流实战项目。适合已安装Claude Code、希望降低API成本同时保持输出质量的开发者。

## 前置条件

- 已安装Claude Code（`npm install -g @anthropic-ai/claude-code`）
- 拥有Anthropic API Key或Claude Pro/Max订阅
- 基本熟悉终端操作
- 一个可实践的代码项目（任意语言）

---

## 第一章：三档模型全景——能力、价格与定位

### 1.1 模型矩阵

2026年5月，Claude Code可用模型形成清晰的三个梯队：

| 维度 | Haiku 4.5 | Sonnet 4.6 | Opus 4.6 |
|------|-----------|------------|----------|
| **定位** | 高速轻量 | 通用主力 | 深度推理 |
| **输入价格** | $1/MTok | $3/MTok | $15/MTok |
| **输出价格** | $5/MTok | $15/MTok | $75/MTok |
| **速度** | 极快（<1s首Token） | 快（1-2s首Token） | 中等（2-4s首Token） |
| **上下文窗口** | 200K | 200K | 200K |
| **代码生成** | 适合样板代码 | 适合功能开发 | 适合复杂架构 |
| **推理深度** | 单步推理 | 多步推理 | 深度链式推理 |

关键认知：**同一个任务，用不同模型的价格差距可达15倍**。一个耗时$0.10的Haiku任务，用Opus需要$6.00。选对模型不是奢侈，而是基本功。

### 1.2 什么任务该用什么模型

```mermaid
flowchart TD
    A[收到新任务] --> B{需要深度推理？}
    B -->|否| C{代码量>100行？}
    B -->|是| D{涉及架构决策？}
    C -->|否| E{格式化/重命名/排序？}
    C -->|是| F{逻辑复杂度高？}
    E --> G[Haiku 4.5]
    F -->|否| H[Sonnet 4.6]
    F -->|是| I[Sonnet + Advisor]
    D -->|是| J[Opus 4.6]
    D -->|否| K{多文件重构？}
    K -->|是| I
    K -->|否| H

    style G fill:#4CAF50,color:#fff
    style H fill:#2196F3,color:#fff
    style I fill:#FF9800,color:#fff
    style J fill:#9C27B0,color:#fff
```

**Haiku的最佳场景（占总任务量30-40%）：**
- 文件重命名、变量批量替换
- 生成样板代码（CRUD接口、测试骨架）
- 代码格式化、import排序
- 简单的文档字符串生成
- Git commit message撰写
- lint错误快速修复

**Sonnet的最佳场景（占总任务量50-60%）：**
- 功能模块开发（单个函数/类）
- Bug修复（中等复杂度）
- 单文件重构
- API端点实现
- 单元测试编写
- 代码审查反馈响应

**Opus的最佳场景（占总任务量5-10%）：**
- 系统架构设计
- 跨多模块的复杂重构
- 性能瓶颈诊断
- 安全漏洞分析
- 技术方案选型（多方案对比）
- 复杂算法实现

---

## 第二章：模型切换三法——从会话到全局

### 2.1 方法一：会话内切换（`/model`命令）

最常用的方式，在对话中随时切换：

```
> 你好，请帮我重构这个模块

> /model
? Select a model:
  ○ sonnet (Claude Sonnet 4.6) ← 默认
  ○ opus (Claude Opus 4.6)
  ○ haiku (Claude Haiku 4.5)

# 或者直接指定
> /model opus
✓ Model switched to claude-opus-4-6

> 请分析这个架构的问题...
```

**适用场景：** 临时需要更强推理能力，如遇到Sonnet无法解决的复杂问题时切到Opus。

### 2.2 方法二：启动时指定（`--model`参数）

```bash
# 用Haiku做快速文件整理
claude --model haiku "整理src目录下的所有import语句"

# 用Opus做深度架构分析
claude --model opus "分析这个项目的架构瓶颈，给出优化方案"

# -p模式（print mode）中指定模型
claude -p --model haiku "列出所有TODO注释" < src/main.ts
```

**适用场景：** 自动化流水线、CI/CD中批量任务、一次性脚本。

### 2.3 方法三：配置文件锁定（settings.json）

在项目级别或用户级别锁定默认模型：

```json
// .claude/settings.json（项目级别）
{
  "model": "claude-sonnet-4-6",
  "smallModel": "claude-haiku-4-5"
}
```

```json
// ~/.claude/settings.json（用户级别）
{
  "model": "claude-sonnet-4-6"
}
```

**配置层级（高→低优先级）：**
1. 命令行 `--model` 参数
2. 环境变量 `CLAUDE_MODEL`
3. 项目 `.claude/settings.json`
4. 用户 `~/.claude/settings.json`
5. 企业策略配置
6. 系统默认（Sonnet 4.6）

### 2.4 实战技巧：模型别名与版本锁定

Claude Code使用模型别名（`sonnet`、`opus`、`haiku`），别名自动解析到最新版本。如果需要锁定特定版本：

```bash
# 使用别名（自动跟随最新）
claude --model sonnet

# 锁定特定版本
claude --model claude-sonnet-4-6-20260515

# 查看当前解析到的具体版本
claude config get model
```

> **注意：** 除非有兼容性需求，建议使用别名以自动获取模型更新。

---

## 第三章：Advisor策略——Sonnet的价格，Opus的智能

### 3.1 Advisor策略原理

2026年4月9日，Anthropic正式发布Advisor Strategy。核心思想：

```
传统模式：  [用户] → [单一模型] → [输出]
Advisor模式：[用户] → [执行者(Sonnet/Haiku)] ⇄ [顾问(Opus)] → [输出]
```

**工作流程：**
1. Sonnet/Haiku作为执行者（Executor），处理主要编码任务
2. 当执行者遇到困难或需要验证时，发出`advisor`工具调用
3. Opus作为顾问（Advisor）在同一上下文中审阅并提供建议
4. 执行者根据建议继续工作

**关键数据：**
- SWE-bench基准提升：+2.7%
- 错误率下降：-11.9%
- 成本增幅：仅+15-20%（相对纯Sonnet），远低于全用Opus的5x成本

### 3.2 启用Advisor

**方式一：会话内命令**

```
> /advisor
✓ Advisor enabled: Sonnet will consult Opus when needed
```

**方式二：settings.json配置**

```json
{
  "model": "claude-sonnet-4-6",
  "advisorModel": "claude-opus-4-6"
}
```

**方式三：API级别（用于编程场景）**

```python
import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=[{
        "type": "advisor",
        "name": "advisor"
    }],
    messages=[{
        "role": "user",
        "content": "实现一个高效的LRU缓存，支持并发访问"
    }]
)
```

### 3.3 Advisor触发时机

Advisor不是每个请求都触发。执行者在以下情况会主动咨询Opus：

| 触发条件 | 示例 |
|----------|------|
| 复杂逻辑不确定 | 多线程同步策略选择 |
| 架构方案需要评估 | 数据库选型（SQL vs NoSQL） |
| 代码质量验证 | 重构后的回归风险判断 |
| 遇到已知的自身局限 | 正则表达式边界情况 |
| 安全敏感决策 | 用户输入验证方案 |

```mermaid
sequenceDiagram
    participant User as 用户
    participant Sonnet as Sonnet执行者
    participant Opus as Opus顾问

    User->>Sonnet: 重构认证模块
    Sonnet->>Sonnet: 分析代码结构
    Sonnet->>Sonnet: 生成重构方案
    Sonnet->>Opus: advisor: 请审查此方案的安全风险
    Opus->>Sonnet: 发现JWT刷新时存在竞态条件
    Sonnet->>Sonnet: 修正方案
    Sonnet->>Opus: advisor: 确认修正后的方案
    Opus->>Sonnet: 方案可行，建议增加rate limiting
    Sonnet->>User: 输出最终重构代码
```

### 3.4 Advisor vs 纯Opus：何时选哪个

| 场景 | Advisor | 纯Opus |
|------|---------|--------|
| 日常功能开发 | **推荐** | 过度 |
| 架构设计讨论 | 不够（需要全程深度推理） | **推荐** |
| 大规模跨文件重构 | **推荐** | 成本过高 |
| 代码审查 | **推荐** | 可选 |
| 简单Bug修复 | 不需要（纯Sonnet即可） | 浪费 |
| 安全审计 | 不够（需要持续深度分析） | **推荐** |

---

## 第四章：Fast模式——Opus的速度档

### 4.1 Fast模式原理

Fast模式是Opus 4.6的专用加速配置，通过优先级服务路径实现2.5倍速度提升：

```bash
# 启用Fast模式
/fast

# 效果：
# - 首Token延迟降低约60%
# - 输出速度提升约2.5x
# - 模型权重不变（同一Opus 4.6）
# - 成本略微增加（优先队列费用）
```

**关键特性：**
- 仅适用于Opus 4.6（Sonnet和Haiku不支持）
- 不切换模型，不降级质量
- 适合需要Opus推理深度又追求速度的场景
- 可随时通过`/fast`开关切换

### 4.2 Fast模式适用场景

```bash
# 场景1：紧急Bug修复，需要Opus的深度推理+速度
/fast
> 生产环境出现并发死锁，请快速分析这个锁的持有顺序问题

# 场景2：限时Code Review
/fast
> 审查这PR的所有变更，重点关注安全隐患

# 场景3：快速原型设计
/fast
> 设计一个事件驱动架构的微服务通信方案，画图说明
```

### 4.3 三种加速策略对比

| 策略 | 速度提升 | 成本变化 | 质量影响 | 适用 |
|------|----------|----------|----------|------|
| 切Haiku | 最快(5-10x) | -80% | 降低 | 简单任务 |
| 切Sonnet | 快(2-3x) | -60% | 轻微降低 | 日常开发 |
| Opus+Fast | 快(2.5x) | +20% | 无 | 深度推理+速度 |

---

## 第五章：实战项目——混合模型工作流

### 5.1 项目场景

我们构建一个完整的"智能模型路由器"，根据任务类型自动选择最优模型组合：

```
项目结构：
smart-router/
├── .claude/
│   └── settings.json
├── CLAUDE.md
├── src/
│   ├── router.py
│   ├── analyzer.py
│   └── executor.py
└── tests/
    └── test_router.py
```

### 5.2 第一步：配置混合模型环境

创建项目配置文件，设定Advisor策略：

```json
// .claude/settings.json
{
  "model": "claude-sonnet-4-6",
  "advisorModel": "claude-opus-4-6",
  "permissions": {
    "allow": [
      "Bash(python3 *)",
      "Bash(pytest *)",
      "Read(*)",
      "Write(src/*)",
      "Write(tests/*)"
    ]
  }
}
```

创建项目级CLAUDE.md指导模型选择：

```markdown
# Smart Router 项目规范

## 模型使用策略
- 简单格式化和样板代码：使用 /model haiku
- 功能开发和Bug修复：使用默认Sonnet
- 架构设计和安全审计：使用 /model opus
- 复杂重构和不确定场景：启用 /advisor

## 代码规范
- Python 3.11+
- Type hints必须
- 测试覆盖率>80%
```

### 5.3 第二步：用Haiku生成样板代码

```bash
# 用Haiku快速生成项目骨架
claude --model haiku -p "
创建一个Python项目的骨架：
1. src/router.py - 任务路由器，包含TaskType枚举和route函数
2. src/analyzer.py - 代码分析器，分析任务复杂度
3. src/executor.py - 执行器，根据路由结果执行任务
4. tests/test_router.py - 路由器单元测试
每个文件只生成基础框架，包含类定义和方法签名。
"
```

**预期输出（部分）：**

```python
# src/router.py
from enum import Enum
from dataclasses import dataclass

class TaskType(Enum):
    SIMPLE = "simple"        # → Haiku
    MODERATE = "moderate"    # → Sonnet
    COMPLEX = "complex"      # → Opus
    UNCERTAIN = "uncertain"  # → Sonnet + Advisor

@dataclass
class Task:
    description: str
    code_context: str
    complexity: float  # 0.0 - 1.0

def route(task: Task) -> tuple[TaskType, str]:
    """根据任务特征路由到最优模型"""
    ...
```

### 5.4 第三步：用Sonnet+Advisor实现核心逻辑

回到交互模式，使用默认Sonnet配合Advisor：

```
> /advisor
✓ Advisor enabled

> 请实现router.py的route函数。
  需要分析任务描述和代码上下文，判断复杂度并路由到合适的模型。
  复杂度评估要考虑：代码行数、嵌套层级、是否有并发/安全需求。

# Sonnet开始实现，在关键决策点咨询Opus：
# - 复杂度评分算法设计
# - 并发任务识别策略
# - 边界条件处理
```

**实现结果：**

```python
# src/router.py（完整实现）
from enum import Enum
from dataclasses import dataclass
import re

class TaskType(Enum):
    SIMPLE = "simple"
    MODERATE = "moderate"
    COMPLEX = "complex"
    UNCERTAIN = "uncertain"

@dataclass
class Task:
    description: str
    code_context: str
    complexity: float = 0.0

# 复杂度评估关键词权重
KEYWORD_WEIGHTS = {
    "concurrent": 0.3, "thread": 0.3, "lock": 0.25,
    "security": 0.35, "auth": 0.3, "encrypt": 0.35,
    "refactor": 0.2, "architect": 0.4, "design": 0.3,
    "rename": -0.2, "format": -0.3, "sort": -0.2,
}

def _analyze_description(description: str) -> float:
    """从任务描述中提取复杂度信号"""
    score = 0.5  # 基础分
    desc_lower = description.lower()
    for keyword, weight in KEYWORD_WEIGHTS.items():
        if keyword in desc_lower:
            score += weight
    return max(0.0, min(1.0, score))

def _analyze_code(code: str) -> float:
    """从代码上下文中提取复杂度信号"""
    if not code.strip():
        return 0.5
    lines = code.split('\n')
    max_indent = 0
    for line in lines:
        indent = len(line) - len(line.lstrip())
        max_indent = max(max_indent, indent // 4)
    line_score = min(len(lines) / 200, 0.3)
    nest_score = min(max_indent / 5, 0.3)
    return min(line_score + nest_score + 0.4, 1.0)

def route(task: Task) -> tuple[TaskType, str]:
    """路由到最优模型，返回(任务类型, 模型建议)"""
    desc_score = _analyze_description(task.description)
    code_score = _analyze_code(task.code_context)
    task.complexity = (desc_score * 0.6 + code_score * 0.4)

    if task.complexity < 0.3:
        return (TaskType.SIMPLE, "claude-haiku-4-5")
    elif task.complexity < 0.6:
        return (TaskType.MODERATE, "claude-sonnet-4-6")
    elif task.complexity < 0.8:
        return (TaskType.UNCERTAIN, "claude-sonnet-4-6+advisor")
    else:
        return (TaskType.COMPLEX, "claude-opus-4-6")
```

### 5.5 第四步：用Opus审查关键模块

```
> /model opus
✓ Model switched to claude-opus-4-6

> 审查router.py的route函数实现。
  重点关注：
  1. 复杂度评分算法是否有盲区
  2. 边界条件处理是否完善
  3. 是否有性能隐患
  4. 给出改进建议

# Opus发现：
# - 关键词匹配没有处理否定语境（"不需要并发"会被误判）
# - 缺少对正则/解析类任务的特殊处理
# - 建议增加task_type字段让用户显式指定
```

### 5.6 第五步：用Haiku写测试

```bash
claude --model haiku -p "
基于src/router.py中的route函数，编写tests/test_router.py。
覆盖以下场景：
1. 简单任务路由到Haiku
2. 中等任务路由到Sonnet
3. 复杂任务路由到Opus
4. 不确定任务路由到Advisor
5. 边界值测试
使用pytest。
"
```

### 5.7 运行验证

```bash
cd smart-router && python3 -m pytest tests/ -v
```

**预期结果：**

```
tests/test_router.py::test_simple_task PASSED
tests/test_router.py::test_moderate_task PASSED
tests/test_router.py::test_complex_task PASSED
tests/test_router.py::test_uncertain_task PASSED
tests/test_router.py::test_boundary_values PASSED
======================== 5 passed in 0.12s ========================
```

---

## 第六章：决策实战——七类典型任务的路由方案

### 6.1 任务路由速查表

```mermaid
flowchart LR
    subgraph 输入
        T1[格式化/重命名]
        T2[功能开发]
        T3[Bug修复]
        T4[代码审查]
        T5[架构设计]
        T6[大规模重构]
        T7[安全审计]
    end

    subgraph 路由
        R1[Haiku]
        R2[Sonnet]
        R3[Sonnet+Advisor]
        R4[Opus]
        R5[Opus+Fast]
    end

    T1 --> R1
    T2 --> R2
    T3 --> R3
    T4 --> R3
    T5 --> R4
    T6 --> R3
    T7 --> R5

    style R1 fill:#4CAF50,color:#fff
    style R2 fill:#2196F3,color:#fff
    style R3 fill:#FF9800,color:#fff
    style R4 fill:#9C27B0,color:#fff
    style R5 fill:#E91E63,color:#fff
```

### 6.2 七类任务详细方案

**类型1：代码整理（Haiku）**

```bash
# 一行搞定，Haiku足够
claude --model haiku -p "格式化所有Python文件：排序import、统一引号风格" \
  --glob "src/**/*.py"
```

**类型2：功能开发（Sonnet）**

```bash
# 交互模式，Sonnet是最佳平衡
claude --model sonnet
> 实现用户注册API，包含邮箱验证和密码强度检查
```

**类型3：Bug修复（Sonnet+Advisor）**

```
> /model sonnet
> /advisor
> 修复issue #42：在高并发下购物车数量计算不准确
# Sonnet负责定位和修复，遇到并发策略选择时咨询Opus
```

**类型4：代码审查（Sonnet+Advisor）**

```
> /advisor
> 审查feat/payment分支的所有变更
# Sonnet做逐行审查，Opus在安全敏感处提供深度分析
```

**类型5：架构设计（Opus）**

```bash
claude --model opus
> 设计一个可扩展的事件溯源架构，支撑百万级TPS
> 要求：画出架构图、列出核心组件、给出技术选型理由
```

**类型6：大规模重构（Sonnet+Advisor）**

```
> /advisor
> 将这个Monolith应用拆分为3个微服务
> 第一阶段：识别模块边界，生成拆分计划
# Sonnet执行具体代码修改，Opus在架构决策点介入
```

**类型7：安全审计（Opus+Fast）**

```
> /model opus
> /fast
> 对认证和授权模块做全面安全审计
> 检查：OWASP Top 10、注入、越权、会话管理
# 需要Opus的深度推理+Fast的速度
```

### 6.3 成本对比：同一项目不同策略

以一个包含100个任务的中型项目为例：

| 策略 | 模型分布 | 预估成本 | 质量评分 |
|------|----------|----------|----------|
| 全用Opus | 100% Opus | $150 | 95/100 |
| 全用Sonnet | 100% Sonnet | $30 | 82/100 |
| 全用Haiku | 100% Haiku | $6 | 65/100 |
| **智能路由** | 35%H+55%S+10%O | $22 | 88/100 |
| **路由+Advisor** | 35%H+55%(S+A)+10%O | $27 | **93/100** |

智能路由+Advisor的成本仅比纯Sonnet低10%，但质量接近全Opus水平。**这是最佳性价比策略。**

---

## 第七章：高级技巧——自动化模型路由

### 7.1 Hooks驱动的自动模型切换

利用Claude Code的Hooks机制，根据任务自动切换模型：

```json
// .claude/settings.json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash(git commit*)",
        "command": "echo '/model haiku' > /tmp/claude-model-hint"
      },
      {
        "matcher": "Bash(pytest*--complex*)",
        "command": "echo '/model opus' > /tmp/claude-model-hint"
      }
    ]
  }
}
```

### 7.2 Subagent的模型选择

在Task工具中为子Agent指定模型，实现并行异构计算：

```
> 请同时执行以下任务：
  1. 用Haiku生成所有CRUD接口的单元测试骨架
  2. 用Sonnet实现用户模块的业务逻辑
  3. 用Opus审查整体架构设计
```

在Claude Code内部，这会转化为三个并行的Subagent：

```
Task 1: subagent_type=general-purpose, model=haiku
Task 2: subagent_type=general-purpose, model=sonnet
Task 3: subagent_type=general-purpose, model=opus
```

### 7.3 CI/CD中的模型路由

在GitHub Actions中根据PR大小选择模型：

```yaml
# .github/workflows/ai-review.yml
name: AI Code Review

on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Determine model
        id: model
        run: |
          CHANGES=$(git diff --stat origin/main...HEAD | tail -1 | awk '{print $4+$6}')
          if [ "$CHANGES" -lt 100 ]; then
            echo "model=haiku" >> $GITHUB_OUTPUT
          elif [ "$CHANGES" -lt 500 ]; then
            echo "model=sonnet" >> $GITHUB_OUTPUT
          else
            echo "model=opus" >> $GITHUB_OUTPUT
          fi

      - name: AI Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude -p --model ${{ steps.model.outputs.model }} \
            "审查这个PR的所有变更，给出改进建议"
```

---

## 第八章：常见问题与排错

### Q1：Advisor没有触发，Sonnet一直在独立工作

**原因：** Sonnet需要明确判断"需要帮助"才会触发Advisor。如果任务看起来简单，Advisor不会介入。

**解决：**
```
> /advisor
> 这个重构涉及分布式事务，请确保在关键决策点咨询Advisor
```
在提示中明确要求使用Advisor可以增加触发概率。

### Q2：切换到Haiku后输出质量明显下降

**原因：** 任务复杂度超出Haiku能力范围。

**解决：** Haiku适合结构化、明确的任务。对于Haiku，给出更具体的指令：
```
# 不好的Haiku提示
> 重构这个模块

# 好的Haiku提示
> 将src/utils.py中所有以get_开头的函数重命名为fetch_开头，
> 更新所有调用处，不要改变函数逻辑
```

### Q3：Fast模式费用暴涨

**原因：** Fast模式本身略贵，但如果配合Opus的高单价，费用增长明显。

**解决：** Fast模式只在需要"深度推理+速度"的组合时启用。如果只是追求速度，切换到Sonnet更经济。

### Q4：`/model`命令切换后忘记切回来

**解决：** 在CLAUDE.md中添加模型使用规范，或使用项目级settings.json锁定默认模型：

```json
{
  "model": "claude-sonnet-4-6",
  "smallModel": "claude-haiku-4-5"
}
```

### Q5：API Key余额不足时的降级策略

```bash
# 检查余额
claude config get model

# 降级到Haiku完成紧急任务
claude --model haiku -p "完成当前的紧急修复"
```

---

## 总结：模型选择黄金法则

```
法则1：默认Sonnet，80%的任务不需要更贵的选择
法则2：简单任务用Haiku，省钱且快
法则3：复杂任务用Advisor，而非直接上Opus
法则4：只有架构设计和安全审计才需要纯Opus
法则5：需要Opus+速度时用Fast，而非切Sonnet
法则6：用CLAUDE.md和settings.json固化策略，避免手动选择
法则7：在CI/CD中用代码行数或文件数自动路由模型
```

---

## 延伸阅读

- [Anthropic官方Advisor策略博文](https://claude.com/blog/the-advisor-strategy) — Advisor Strategy设计理念和基准数据
- [Claude Code模型配置文档](https://code.claude.com/docs/en/model-config) — 模型别名、版本锁定、配置层级
- [Claude Code Fast模式文档](https://code.claude.com/docs/en/fast-mode) — Fast模式技术细节和适用场景
- [Builder.io: Claude Advisor API详解](https://www.builder.io/blog/the-claude-advisor-pattern) — Advisor Pattern编程实践
- [Claude Code最佳实践](https://code.claude.com/docs/en/best-practices) — 官方推荐的开发工作流

## 参考来源

1. [The Advisor Strategy: Give Sonnet an Intelligence Boost with Opus](https://claude.com/blog/the-advisor-strategy) — Anthropic官方Advisor策略发布博文，包含基准测试数据
2. [Model Configuration - Claude Code Docs](https://code.claude.com/docs/en/model-config) — 官方模型配置文档，覆盖别名、版本锁定、配置层级
3. [Fast Mode - Claude Code Docs](https://code.claude.com/docs/en/fast-mode) — Fast模式官方说明，2.5x加速原理
4. [Claude Model Routing 101: Decision Tree for Haiku, Sonnet, and Opus](https://tygartmedia.com/claude-model-routing-haiku-sonnet-opus-decision-tree/) — 实用决策树和成本对比
5. [Best Model for Claude Code 2026: Opus vs Sonnet vs Haiku Compared](https://www.morphllm.com/claude-code-models) — 全面对比评测和场景推荐

## 训练营适用性评估

| 维度 | 评估 |
|------|------|
| **适合训练营类型** | 企业AI开发效率提升营、Claude Code进阶营、DevOps智能化训练营 |
| **教学时长** | 3-4小时（含动手实践） |
| **难度级别** | 中级（需熟悉Claude Code基本操作） |
| **前置课程** | Claude Code入门篇、Skill开发基础 |
| **实验环境要求** | 每人需Anthropic API Key（建议预充值$20），一个中型代码项目 |
| **分组建议** | 2-3人一组，每组分配不同类型项目以体验完整路由场景 |

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