Part 3 · 第 13 章 · 建立 AI 系统

搭建你的第一条自动化工作流
用 Claude Code 把 Skill 串成流水线——触发一次，自动跑完

第12章建好了 Skill 库，每次用 AI 不再从零想提示词。但每个步骤还是你手动触发、手动推进。这一章要做一件事：让这些步骤自己流转起来——你只负责给输入，剩下的交给工作流。

核心方法论：流程节点拆解 — 把任何重复性工作分解成三段：触发（什么条件启动）→ 处理（每一步做什么，放入 Skill 提示词）→ 输出（结果去哪里）。用 Claude Code 写 Python 脚本把这三段串起来，一次运行，全程自动。主工具是 Claude Code，它比任何可视化平台都更灵活、更强大，而且你已经在第9章和第11章用过它了。

小节一

你其实已经在做工作流了——只是还没串起来

承上启下 · 认知升级

回想第11章的 HR 招聘案例：设计了一条7步流程，每一步标注了自动化级别。回想第12章：建好了"简历解析 Skill"和"候选人评分 Skill"，有标准输入字段、有提示词主体、有预期输出格式。

现在的状态是：每次来新一批简历，你要手动打开 AI 工具，粘贴第一份简历调用解析 Skill，把结果复制出来，再粘贴去调用评分 Skill，把评分结果记录到表格……重复1023次。Skill 解决了"每次不用重新想提示词"，但没有解决"每次还是需要你手动推进"的问题。

工作流的核心价值：把"每次都要你推进"变成"触发一次自动完成"

工作流要解决的就是这个问题。它不是一个新概念，本质上就是一段代码——把你手动操作的步骤顺序，写成程序让计算机自动执行。好消息是：你不需要自己会编程，Claude Code 会帮你写。你只需要描述清楚每一步做什么，它生成代码、你运行，工作流就跑起来了。

小节二

Skill、工作流、Agent——三层能力的真实边界

认知框架 · 三层区别

第6章介绍过这三个概念，当时还比较抽象。现在经历了 Ch9 到 Ch12，可以用更准确的方式讲清楚它们的边界——核心区别不是复杂度，而是谁来决定下一步。

🔧

Skill

你来推进

一次调用、一个任务。你填输入，你触发，你看结果。每一次都需要你主动操作。

⚙️

工作流

触发器来推进

多步骤串联，固定顺序执行。触发一次后不需要你介入，步骤自动流转到结束。

🤖

Agent

AI 来推进

AI 自主判断下一步做什么，根据中途结果动态选择路径，不是固定流程。

工作流和 Agent 的根本区别在于：工作流的路径是你提前设计好的，每一步做什么是固定的；Agent 的路径是 AI 临时决定的，它会根据上一步的结果判断下一步该用哪个工具、该走哪条分支。

📌 什么时候该升级到 Agent

工作流应付得了大多数重复性工作。当你发现工作流需要根据中间结果做出"无法提前写成规则"的判断时——比如"这份简历信息残缺，需要去候选人领英主页补全资料"——这时候工作流力不从心，该考虑 Agent 了。第14章专门讲这个。

小节三

面对任何新工具都不焦虑——学习新工具五步法

元能力 · 通用方法

从第9章开始，这本书用的主要工具已经是 Claude Code。这一章的工作流也用它来实现。有人会问：Claude Code 不是写代码用的吗？我不是程序员，能用吗？

面对这类问题，先用一套通用框架来想清楚——这套方法适用于任何你以后遇到的 AI 新工具：

搞清楚它是哪一层能力

Claude Code 是"AI 辅助执行环境"——它能帮你写代码、直接在本地运行、读写文件、调用 API。它不是聊天工具，而是可以帮你做事的执行工具。对应本书框架：它是工作流层的执行引擎，可以运行任何你能描述清楚的工作流。

找它的最小可用场景，先跑通一个

不要从最复杂的功能开始。Claude Code 的最小可用场景：打开终端，输入一个任务描述，看它生成并运行代码。第9章处理 Excel 表格时就是这个模式——你描述需求，它写 Python，你看结果。工作流只是更长的任务描述。

理解它的输入和输出格式

Claude Code 的输入是自然语言描述（你告诉它做什么）+ 本地文件（它可以直接读取）。输出是代码执行结果，可以是终端打印、文件写入、HTML 报告等任何你指定的格式。和对话 AI 的区别是：它能直接操作你电脑上的文件，不需要复制粘贴。

用自己的真实任务套进去

本章用 HR 招聘案例——1023份简历、三个岗位、已经建好了解析 Skill 和评分 Skill。把这个真实场景用 Claude Code 跑一遍，比任何教程都学得快。

判断它值不值得进入你的常用工具栈

跑完本章案例之后，你自然会有判断。Claude Code 的核心优势：灵活（任何 Python 能做的它都能做）、直连本地文件、不依赖第三方平台、免费（在 Claude 订阅内）。核心局限：需要安装 Claude Code 客户端、工作流触发要手动运行（不能定时自动触发，除非配合系统定时任务）。

🔑 关键认知：你不需要懂代码，你需要懂业务

Claude Code 帮你写代码，你负责告诉它业务逻辑——每一步做什么、用什么规则判断、结果存在哪里。第11章你已经把业务逻辑想清楚了（7步流程图），第12章把操作单元建好了（Skill卡片）。这一章的工作就是把这两样东西交给 Claude Code，让它翻译成可运行的代码。

小节四

工作流三段式框架——触发 → 处理 → 输出

核心框架 · 通用骨架

所有工作流，不管多复杂，都由三段组成。在动手之前先把这三段想清楚，是避免后期反复修改的最有效方式。

触发层 TRIGGER

什么条件下启动这条工作流

手动运行（你执行脚本）/ 定时触发（系统计划任务）/ 文件变化（新文件到来）/ 外部事件（邮件到达、API 调用）。本章案例用手动触发：你把简历文件夹路径传给脚本，它开始工作。

python recruit_workflow.py --folder ./resumes/ --positions JD_config.yaml

↓

处理层 PROCESS

每一步做什么——这里放你的 Skill

处理层由一个或多个步骤组成，每个步骤有明确的输入和输出。AI 处理步骤 = 把 Skill 提示词放进代码调用 API；规则处理步骤 = 用 if/else 做分类判断；数据处理步骤 = 读取、清洗、格式转换。

Step1: 解析简历文本 → Step2: AI评分 → Step3: 按分数分级

↓

输出层 OUTPUT

结果去哪里、以什么格式呈现

终端打印 / 写入 Excel 或 CSV / 生成 HTML 报告（第10章的技能直接用上）/ 发送邮件 / 推送到飞书。本章案例：生成一份 HTML 推荐报告，每个候选人有评分和推荐理由，按岗位分组展示。

output: recruitment_report_2026.html（可直接在浏览器打开/打印）

在用 Claude Code 实现工作流之前，建议先在纸上或文档里把这三段写清楚。越具体越好——"处理层"需要精确到每一步的输入和输出是什么，而不是"处理简历"这种模糊描述。写清楚之后，交给 Claude Code 的任务描述质量会高很多，生成的代码通常一两次就能跑通。

小节五

主案例：用 Claude Code 把 HR 招聘工作流跑起来

完整案例 · 从设计到运行

回到第11章的场景：收到1023份简历，三个岗位（产品经理/数据分析师/运营专员），需要完成初筛、评分、分级、生成推荐报告。第11章设计了流程，第12章建好了 Skill。现在把它真正跑起来。

第一步：在纸上把三段式写清楚。

触发

手动运行，传入简历文件夹 + 岗位配置

输入：resumes/ 文件夹（PDF/Word）+ positions.yaml（三个岗位的评分标准）

↓

处理 Step 1 · AI节点

简历结构化解析（Skill → 代码）

对每份简历调用 Claude API，传入"简历解析 Skill"提示词，输出结构化 JSON（姓名/学历/工作经历/技能）

输入：简历文本 → 输出：parsed_resume.json

↓

处理 Step 2 · 规则节点

硬性条件过滤（不用 AI，用规则）

学历不符 / 工作年限不符 → 直接归入"不符合"池，不再调用 AI 评分（省 token 成本）

输入：parsed_resume.json → 输出：pass_list / reject_list

↓

处理 Step 3 · AI节点

综合评分（Skill → 代码）

对通过初筛的简历，调用"候选人评分 Skill"提示词，按岗位评分标准输出打分 JSON（各维度分数+亮点+风险）

输入：pass_list + 岗位评分标准 → 输出：scored_candidates.json

↓

输出

生成 HTML 推荐报告（第10章技能上场）

把评分结果渲染成可交互 HTML 报告，按岗位分组，候选人按分数排序，有评分详情和推荐理由

输出：recruitment_report.html（浏览器打开即用，可打印为PDF）

第二步：把设计交给 Claude Code，让它写代码。给 Claude Code 的任务描述示例：

给 Claude Code 的任务描述
PROMPT
帮我写一个 Python 工作流脚本 recruit_workflow.py，实现以下功能：

【输入】
- 命令行参数：--folder（简历文件夹路径）--config（YAML配置文件路径）
- 支持 PDF 和 Word 格式的简历文件

【处理步骤】
Step1：读取文件夹里的所有简历，提取纯文本内容

Step2：对每份简历调用 Claude API（claude-opus-4-5），
使用以下提示词解析结构化信息：
"""
请从以下简历文本中提取信息，以JSON格式返回：
{"name","education":{"level","school","major"},
 "work_years","experiences":[...],"skills":[...]}
"""

Step3：按 YAML 配置文件里的硬性条件过滤
（学历、工作年限不符合的直接归入reject_list）

Step4：对通过初筛的简历，再次调用 Claude API，
使用以下评分提示词：
"""
你是资深招聘官。请对候选人进行综合评分（0-100分）。
岗位要求：{position_requirements}
候选人信息：{parsed_resume}
请输出JSON：{"total_score","dimensions":{...},"highlight","risk"}
"""

Step5：把所有评分结果整合，生成 HTML 报告
- 按岗位分组展示
- 每个岗位内按 total_score 倒序排列
- 展示每人的分数条、亮点和风险标注
- 报告风格参考现代商务感，深色头部，白色卡片

【输出】
- recruitment_report.html（主报告）
- results.json（原始数据，备份用）
- run.log（每步耗时和处理数量）

【依赖】
使用 anthropic Python SDK，需要读取环境变量 ANTHROPIC_API_KEY
用 PyPDF2 读 PDF，用 python-docx 读 Word 文件

Claude Code 收到这段描述，会生成完整的 Python 脚本。下面是它生成的核心代码结构，让你理解整体逻辑（完整文件由 Claude Code 生成，你不需要自己写）：

recruit_workflow.py
PYTHON
import anthropic, json, yaml, argparse
from pathlib import Path

# ── 初始化 Claude 客户端 ──────────────────────────
client = anthropic.Anthropic()   # 自动读取 ANTHROPIC_API_KEY

# ── Skill 提示词（直接从第12章 Skill 卡片迁移）──────
PARSE_SKILL = """
请从以下简历文本中提取结构化信息，以JSON格式返回：
{
  "name": "姓名",
  "education": {"level": "学历", "school": "学校", "major": "专业"},
  "work_years": 工作年限数字,
  "experiences": [{"company","title","duration_months"}],
  "skills": ["技能列表"]
}
只返回JSON，不要其他文字。
"""

SCORE_SKILL = """
你是资深招聘官，请对以下候选人进行综合评分（0-100分）。

岗位要求：{requirements}
候选人信息：{resume_json}

评分维度（各占权重）：
- 学历匹配度（20%）
- 工作经验相关性（35%）
- 技能符合度（25%）
- 成长潜力（20%）

请以JSON格式返回，只返回JSON：
{"total_score": 85, "dimensions": {"edu":18,"exp":30,"skill":22,"growth":15},
 "highlight": "核心优势一句话", "risk": "主要风险一句话"}
"""

# ── Step 1：解析简历 ────────────────────────────
def parse_resume(text):
    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=1024,
        messages=[{"role": "user",
                     "content": PARSE_SKILL + "\n\n简历内容：\n" + text}]
    )
    return json.loads(response.content[0].text)

# ── Step 2：硬性条件过滤（规则，不用 AI）────────────
def hard_filter(parsed, requirements):
    if parsed["work_years"] < requirements["min_years"]:
        return False, "工作年限不足"
    if parsed["education"]["level"] not in requirements["edu_levels"]:
        return False, "学历不符"
    return True, "通过初筛"

# ── Step 3：AI 综合评分 ─────────────────────────
def score_candidate(parsed, position_requirements):
    prompt = SCORE_SKILL.format(
        requirements=json.dumps(position_requirements, ensure_ascii=False),
        resume_json=json.dumps(parsed, ensure_ascii=False)
    )
    response = client.messages.create(
        model="claude-opus-4-5", max_tokens=512,
        messages=[{"role": "user", "content": prompt}]
    )
    return json.loads(response.content[0].text)

# ── 主工作流：串联所有步骤 ─────────────────────────
def run_workflow(folder, config):
    results = []
    files = list(Path(folder).glob("*.pdf")) + list(Path(folder).glob("*.docx"))
    print(f"找到 {len(files)} 份简历，开始处理...")

    for i, f in enumerate(files):
        text = extract_text(f)           # 提取文本
        parsed = parse_resume(text)      # Step1: 解析
        ok, reason = hard_filter(parsed, config["requirements"])  # Step2: 过滤
        if not ok:
            results.append({..., "status": "rejected", "reason": reason})
            continue
        score = score_candidate(parsed, config["scoring"])  # Step3: 评分
        results.append({..., "status": "scored", "score": score})
        print(f"[{i+1}/{len(files)}] {parsed['name']} → {score['total_score']}分")

    generate_html_report(results)   # Step4: 生成报告
    print("✅ 完成！报告已生成：recruitment_report.html")

💡 注意代码里的两处关键

PARSE_SKILL 和 SCORE_SKILL 这两个变量直接对应第12章 Skill 卡片的"提示词主体"字段，原封不动粘贴进来。Skill 卡片的"输入字段"变成了代码里的 format() 替换的变量。这就是"Skill 变节点"的全部操作——复制提示词、填进代码框架。

另一处是 hard_filter 函数——规则类步骤不需要调用 AI，用 Python 直接判断，速度快、成本低。只有真正需要语言理解能力的步骤才调用 Claude API。

小节六

Skill 变节点——从卡片到代码只有一步

核心操作 · 迁移逻辑

上一节的代码里有一个关键操作，值得单独拆出来讲清楚：第12章的 Skill 卡片是怎么变成工作流里的 AI 处理节点的？

第12章 · Skill 卡片

📥 输入字段

{简历文本原文} {岗位名称} {评分标准配置}

📝 提示词主体

你是资深招聘官。请对以下候选人评分... 岗位要求：{requirements} 候选人：{resume_json} 输出JSON：{total_score...}

📤 预期输出格式

JSON，含 total_score、 dimensions、highlight、risk

→

第13章 · 代码节点

📥 函数参数

parsed_resume # 结构化简历 position_reqs # 岗位配置yaml

📝 提示词变量（原封不动）

SCORE_SKILL = """ 你是资深招聘官... 岗位要求：{requirements} 候选人：{resume_json} 输出JSON：{total_score...} """

📤 返回值处理

json.loads(response) # 解析成字典直接用

迁移只需要三个动作：① 把"提示词主体"原文复制，赋值给一个 Python 变量；② 把"输入字段"的占位符改成 .format(key=value) 的格式；③ 把"预期输出格式"改成 json.loads() 解析。其他都是固定模板，Claude Code 会帮你填。

这个迁移逻辑说明了 Skill 库为什么是工作流的基础：建 Skill 库时逼着你把"输入字段"和"输出格式"想清楚，这两个字段恰好就是代码里节点函数的"参数"和"返回值"——格式对了，迁移是机械操作，不需要任何额外思考。

小节七

批量处理1023份简历——循环让工作流规模化

批量执行 · 循环节点

单份简历的处理逻辑验证通了之后，扩展到1023份只需要加一个循环。这是工作流相比手动操作最大的价值所在：手动操作的成本随数量线性增长，代码循环的成本几乎不变。

批量处理 + 进度显示 + 错误容忍
PYTHON
import time, logging

def run_batch(files, config):
    results, errors = [], []
    passed, rejected, scored = 0, 0, 0

    for i, file in enumerate(files, 1):
        try:
            # 每份简历走完整的处理流程
            text   = extract_text(file)
            parsed = parse_resume(text)
            ok, reason = hard_filter(parsed, config)

            if not ok:
                rejected += 1
                results.append({"file": file.name, "status": "rejected",
                                  "reason": reason})
            else:
                score = score_candidate(parsed, config)
                scored += 1
                results.append({"file": file.name, "status": "scored",
                                  "name": parsed["name"], **score})

            # 实时进度
            print(f"\r处理中 {i}/{len(files)} | 通过:{scored} 淘汰:{rejected}",
                  end="", flush=True)
            time.sleep(0.3)   # 避免 API 限速

        except Exception as e:
            errors.append({"file": file.name, "error": str(e)})
            # 单份出错不影响其他简历继续处理

    print(f"\n✅ 完成：{scored}份评分 | {rejected}份淘汰 | {len(errors)}份出错")
    return results, errors

上面代码里有两个设计值得注意。第一是错误容忍：把每份简历的处理放在 try/except 里，单份出错不会让整个工作流崩溃，出错的文件记录在 errors 列表里，事后单独处理。处理1023份文件时，总会有几份格式损坏或内容异常的，错误容忍让工作流的鲁棒性大大提升。

第二是 time.sleep(0.3)——每处理一份简历后等待0.3秒。Claude API 有并发限制，不加延迟的话批量请求很容易触发限速错误。这类"工程细节"是 Claude Code 知道的，你不需要自己想，在任务描述里提一句"注意 API 限速"它就会处理好。

⚠️ 批量处理的成本意识

1023份简历，每份调用两次 Claude API（解析+评分），大约是2000次 API 调用。按当前 Claude API 定价，这个量级的成本大约在几十元人民币。在正式运行前，可以先用10-20份简历测试，确认逻辑正确、成本符合预期，再跑全量。Claude Code 可以帮你提前估算成本——告诉它"帮我估算处理1000份简历大概需要多少token，费用是多少"即可。

小节八

条件分支——让工作流根据结果走不同路径

条件节点 · 分级路由

基础工作流是线性的：每份简历都走同样的路径。加入条件分支之后，工作流可以根据评分结果自动分级处理，不同分数段的候选人走不同后续流程。

条件分支：评分结果自动路由到三条后续处理路径

在代码里实现这个分支只需要几行 if/elif/else：

条件分支路由
PYTHON
def route_candidate(candidate):
    score = candidate["total_score"]

    if score >= 85:
        candidate["tier"] = "A"
        candidate["action"] = "直推终面"
        candidate["recommend_letter"] = generate_recommend_letter(candidate)

    elif score >= 70:
        candidate["tier"] = "B"
        candidate["action"] = "人工复核"
        # 加入待定池，HR 手动确认后推进

    else:
        candidate["tier"] = "C"
        candidate["action"] = "归档备案"

    return candidate

# A层推荐信也用 Skill——用 Claude Code 写一个 generate_recommend_letter Skill
def generate_recommend_letter(candidate):
    prompt = f"""
    请为以下 A 级候选人写一份简短推荐意见（150字以内），供面试官参考。
    候选人亮点：{candidate['highlight']}
    评分：{candidate['total_score']}分
    请直接输出推荐意见文字，不要有其他内容。
    """
    # 调用 Claude API，返回推荐意见文字
    ...

条件分支的强大之处是：它让工作流变成一个主动分拣系统，不同质量的输入自动走不同路径，后续处理量大幅减少。1023份简历经过条件分支之后，HR 只需要人工确认 B 层的待定池（通常50-100人），A 层已经自动准备好了推荐信，C 层自动归档不需要看。

小节九

五种通用工作流模式——你的场景是哪种

模式识别 · 通用结构

HR 招聘工作流是"多步串联 + 条件分支 + 批量循环"的组合。但实际上大多数工作流只需要五种基础模式中的一种或两种。看完这五种，你就能判断自己想搭的工作流属于哪种结构。

模式一

单路径

输入 → AI处理 → 输出

最简单的形式。适合：格式转换、文档摘要、周报生成、邮件润色。一个输入、一步 AI 处理、一个输出。

模式二

多步串联

输入 → Skill1 → Skill2 → Skill3 → 输出

前一步的输出是后一步的输入。适合：简历解析→评分→生成推荐语；资讯获取→摘要→分析影响。

模式三

条件分支

处理 → 判断条件 → A路径 / B路径

根据中间结果走不同后续。适合：评分分级路由、数据异常检测处理、不同类型内容的差异化处理。

模式四

批量循环

列表 → for each → 处理单条 → 汇总

对一组数据重复执行同样处理。适合：批量简历、批量合同审核、批量商品描述生成、多城市数据汇总。

模式五

并行合并

输入 → 并行处理A + B → 合并结果

同时处理多路输入，最后合并。适合：多竞品同时分析后对比、多数据源聚合报告、多语言内容同时生成。

HR 招聘案例是模式二 + 模式三 + 模式四的组合：每份简历走模式二（串联处理），有条件分支（模式三）路由，外层是批量循环（模式四）。大多数复杂工作流都是这几种基础模式的组合，掌握了五种模式，你就能分析任意工作流的结构。

举一反三：其他场景套哪种模式

竞品快报工作流：输入竞品URL列表 → 批量循环（模式四）→ 每个URL走：提取正文 → AI摘要 → 分析影响（模式二）→ 合并生成一份内参（模式五合并步骤）

月度数据复盘：输入数据文件 → 数据清洗 → AI分析 → 条件判断：达标/未达标走不同结论路径（模式三）→ 生成HTML报告（模式一输出）

合同批量审核：合同文件夹 → 批量循环（模式四）→ 每份：提取关键条款 → AI识别风险点 → 风险评级（模式三分支）→ 汇总风险报告

小节十

不想写代码？Coze 拖拉拽也能实现同样的事

可视化替代 · Coze 方案

Claude Code 是本书推荐的主工具，原因很直接：它更灵活（任何 Python 能做的都能做）、可以直接操作本地文件、不需要额外注册账号、已经在前几章用过。但如果你确实不想接触任何代码界面，有一个可视化的替代方案：Coze（字节跳动出品，网页端，完全免费，无需安装）。

Coze 的工作流是把上面讲的所有步骤变成可拖拉拽的节点，逻辑完全一样，只是操作界面不同。HR 招聘工作流在 Coze 里的节点排列：

🟣 Coze 工作流节点对照（与代码版本一一对应）

📥 开始节点
输入简历文本

→

🤖 LLM节点
简历解析Skill

→

🔀 条件节点
硬性过滤规则

→

🤖 LLM节点
评分Skill

→

🔀 条件节点
A/B/C分级

→

📤 结束节点
输出结果

每个 LLM 节点里填入的内容，就是 Skill 卡片的提示词主体——和代码版本里的 PARSE_SKILL、SCORE_SKILL 变量完全相同。Coze 的优势是可以直接接入飞书机器人、企业微信、定时触发等，适合需要把工作流"部署"为团队服务的场景。具体操作步骤见附录A：Coze 操作手册。

维度	Claude Code（推荐）	Coze（可视化替代）
操作方式	描述需求，AI 生成代码，你运行	拖拉拽节点，配置参数，点击运行
处理本地文件	✅ 直接读取电脑上的文件	❌ 需要先上传到 Coze 平台
灵活性	✅ 任何逻辑都能实现	受限于 Coze 提供的节点类型
定时自动触发	需配合系统计划任务（cron）	✅ 内置定时触发功能
外部集成	需要自己写 API 调用代码	✅ 内置飞书/邮件/企微连接器
团队共享	共享 .py 文件	✅ 一键发布为团队可用服务
成本	Claude 订阅内含，仅 API 调用费	免费，但 LLM 节点调用有额度限制

选择建议：如果你的工作流处理的是本地文件（简历PDF/Excel数据），或者需要很灵活的数据处理逻辑——用 Claude Code。如果你的工作流需要定时自动跑、或者需要连接飞书/企微推送通知——Coze 是更合适的选择，或者 Claude Code + 系统定时任务的组合。

小节十一

工作流能做什么，不能做什么——边界决定选型

边界认知 · 引出 Agent

工作流是目前为止最强大的 AI 能力层——它把所有前几章的技能（Python数据处理、HTML报告、Skill 提示词）整合成了一个自动运行的系统。但它有一个根本性的局限，值得在这里说清楚。

工作流的本质是固定剧本：你提前设计好所有步骤和分支条件，运行时按剧本执行。这意味着，所有可能出现的情况你都需要提前考虑到并写进条件分支。工作流不能自己发现问题、不能自己改变处理策略、不能自己决定去哪里找额外信息。

工作流遇到边界的真实场景

处理第473份简历时，这份简历是扫描版图片，文字提取失败，parse_resume 收到的是空字符串，AI 返回了一个空 JSON，评分输出 0 分，进入 C 层归档。——但实际上这可能是一个很强的候选人，只是简历格式特殊。

工作流里的 try/except 记录了这个错误，但不会主动说"我要去用 OCR 重新识别这份简历"或者"我要通知 HR 这份简历需要人工处理"。它只会跳过，记录错误，继续处理下一份。

这就是工作流的边界：它按规则执行，不会自主判断"这条规则现在不合适，我要换一种方式"。

当你遇到以下两种情况时，工作流就力不从心了，需要考虑升级到 Agent：

第一种：处理路径无法提前枚举。比如一个工作流需要"根据简历内容的具体情况，决定去哪个网站查额外信息"——可能去领英、可能去 GitHub、可能去某行业数据库。这些路径太多，写不完条件分支。

第二种：需要多轮迭代直到达标。比如"不断修改报告，直到所有数据引用都有来源"——这需要 AI 反复检查自己的输出、决定下一步改什么。这是循环判断的逻辑，不是固定步骤。

✅ 本章核心结论

工作流 = 把你手动推进的 Skill 调用链，变成触发一次自动完成的代码流水线。用 Claude Code 实现的方法：三段式框架（触发→处理→输出）+ Skill 提示词迁移进代码 + 循环处理批量数据 + 条件分支自动路由。工作流能解决"重复性强、步骤固定"的自动化需求；当任务需要"临时判断、动态路径"时，它就到了边界，需要 Agent 接手。

✓

一张三段式设计图：你自己的工作场景用触发→处理→输出三段写清楚，每步有输入和输出说明

✓

一条跑通的工作流脚本：用 Claude Code 生成并实际运行了至少一条工作流，处理了真实数据

✓

Skill 迁移完成：第12章至少一个 Skill 卡片的提示词，已经变成工作流代码里的 AI 节点

✓

识别了工作流的边界：能说出自己这条工作流"在什么情况下会失效、什么情况下需要升级到 Agent"

工作流解决的是"固定流程的自动化"。下一章要解决的是工作流搞不定的那类问题：任务目标明确，但执行路径需要 AI 自主判断，中途会遇到各种意外情况，需要 AI 像一个真正的执行者一样灵活应对。

→ 下一章：搭建你的第一个 Agent 助手——当任务需要 AI 自主判断路径时，工作流升级成 Agent

搭建你的第一条自动化工作流用 Claude Code 把 Skill 串成流水线——触发一次，自动跑完