[!note] Agent不是银弹，没必要也不应该全用Agent——当任务可以用确定性的类/函数解决时，不应该用 Agent。

核心洞察#

1
  传统软件开发:
2
  ┌─────────────────────────────────────┐
3
  │  class ResumeParser {               │
4
  │      fun parse(file) -> Resume      │
5
  │  }                                 │
6
  │                                      │
7
  │  class MatchEngine {                 │
8
  │      fun match(jd, resumes) -> []   │
9
  │  }                                 │
10
  │                                      │
11
  │  // 开发者写死的逻辑                 │
12
  │  // 控制流完全确定                    │
13
  └─────────────────────────────────────┘

1
  Agent 开发:
2
  ┌─────────────────────────────────────┐
3
  │  JD Worker:                         │
4
  │    "解析 JD，返回结构化 Schema"      │
5
  │                                      │
6
  │  Resume Worker:                      │
7
  │    "解析简历，返回结构化数据"        │
8
  │                                      │
9
  │  Match Worker:                       │
10
  │    "计算匹配度，返回评分+理由"       │
11
  │                                      │
12
  │  // 控制流由 Prompt + LLM 决定        │
13
  │  // 存在不确定性                     │
14
  └─────────────────────────────────────┘

本质相同

1
  ┌──────────┬────────────────┬──────────────────────┐
2
  │   维度   │    OOP 范式    │      Agent 范式      │
3
  ├──────────┼────────────────┼──────────────────────┤
4
  │ 核心抽象 │ Class / Object │ Agent / Tool         │
5
  ├──────────┼────────────────┼──────────────────────┤
6
  │ 接口定义 │ Interface      │ Tool Definition      │
7
  ├──────────┼────────────────┼──────────────────────┤
8
  │ 依赖注入 │ DI Container   │ Context / Memory     │
9
  ├──────────┼────────────────┼──────────────────────┤
10
  │ 组合模式 │ Composite      │ Orchestrator         │
11
  ├──────────┼────────────────┼──────────────────────┤
12
  │ 职责分离 │ SOLID 原则     │ Single-purpose Agent │
13
  ├──────────┼────────────────┼──────────────────────┤
14
  │ 可测试性 │ Mock / Stub    │ 单元测试 Prompt      │
15
  ├──────────┼────────────────┼──────────────────────┤
16
  │ 组装流程 │ 依赖图         │ Pipeline / DAG       │
17
  └──────────┴────────────────┴──────────────────────┘

关键区别

1
  ┌──────────┬──────────────────┬─────────────────────────┐
2
  │   区别   │       OOP        │          Agent          │
3
  ├──────────┼──────────────────┼─────────────────────────┤
4
  │ 控制流   │ 确定性 (if/else) │ LLM 参与决策 (不确定性) │
5
  ├──────────┼──────────────────┼─────────────────────────┤
6
  │ 逻辑表达 │ 代码             │ Prompt + 示例           │
7
  ├──────────┼──────────────────┼─────────────────────────┤
8
  │ 运行时   │ 编译时确定       │ 每次调用可能有差异      │
9
  ├──────────┼──────────────────┼─────────────────────────┤
10
  │ 调试方式 │ 断点 / 日志      │ 检查 Prompt / 输出      │
11
  └──────────┴──────────────────┴─────────────────────────┘

但思维模式要转变

1
  OOP 思维:
2
  ─────────────────────────────
3
  "我要写一个 MatchEngine 类，
4
    实现 match(jd, resumes) 方法，
5
    算法是用加权评分"
6

7
  Agent 思维:
8
  ─────────────────────────────
9
  "我需要一个 Match Worker Agent，
10
    它能理解 JD 和简历的语义，
11
    评分要可解释，
12
     Prompt 应该怎么写？输出格式是什么？"

AI 开发 = 70% 软件工程 + 20% Prompt 工程 + 10% 新范式适配

1
  ├── 软件工程 (不变)
2
  │   ├── 系统设计
3
  │   ├── 数据存储
4
  │   ├── 网络通信
5
  │   ├── 故障恢复
6
  │   └── 监控告警
7
  │
8
  ├── Prompt 工程 (新技能)
9
  │   ├── 如何清晰表达任务
10
  │   ├── 如何约束输出格式
11
  │   ├── 如何写 Few-shot 示例
12
  │   └── 如何处理边界情况
13
  │
14
  └── 新范式适配 (新思维)
15
      ├── 接受不确定性
16
      ├── 设计可容错的 Pipeline
17
      └── 权衡：Agent vs 直接调用

Agent 不是银弹——当任务可以用确定性的类/函数解决时，不应该用 Agent。

就像招聘筛选场景：

简历解析 → 可以用 Agent（格式多样，需要理解）
向量索引 → 不需要 Agent（确定性的数学运算）
批量匹配 → 可以用 Agent（需要推理和解释）
结果排序 → 不需要 Agent（确定的比较运算）

总结：Agent 是工具，不是架构。用对了是杠杆，用错了是负担。