Skip to content

第8章 Agent 与“我们” ​

AI 带来的冲击绝不仅限于程序员的终端命令行,它正在以雷霆之势重塑电影、短剧、内容创作、艺术设计以及所有将“人类智力与形象数字化”的传统行业。面对这种海啸般的变革,掩耳盗铃、自欺欺人或者盲目抗拒没有任何意义。技术浪漫主义的精髓,不在于怀念过去的技术,而在于用当下的技术重新点亮人的价值。技术的本质是人的延伸,而非人的替代。所以,我们需采取行动,我们必须接受这一切的改变。最终做回我们自己。

8.1 Agent 的挑战和机遇并存 ​

本章导语给了一个基本的判断:技术的本质是人的延伸,不是人的替代。这个判断如果想要成立,它必须有一个前提:你得先接得上。接不上的部分,不会被延伸,只会被重新定价。

我们身边通常有两种人。一种把 Agent 接进现有流程,我们见过几天的活压到半个小时;另一种试了两天,结论是“不过如此”。

这些差别不在工具版本,也不在提示词(Prompt)写得多漂亮,而在手里有没有可以被工具接住的东西。

所以这一节不写安慰话。我们把挑战和机遇拆成一张价格表:哪些能力在贬值,哪些在升值,升值的那部分需要什么前提。这里的“价格”是稀缺度的比喻,不是报价单;下文只给方向,不给数字。

8.1.1 冲击与挑战:哪些能力在贬值 ​

Agent 普及之前,个人护城河大致由两样东西构成:记得多、推得快。这两样在硅基系统面前都在贬值,但贬值的幅度不同,得分开看。

个人能力之外,还有两类结构性冲击:比特(单纯以信息为工作介质的行业)行业的环节重构,组织中间层的信息中转被压缩。两样个人能力加两类结构性冲击,共四条线。这一节只算贬值账,升值账在 8.1.2。

显性知识:从“记住”变成“能查到” ​

过去,行业门槛常常表现为一套只有内部人熟悉的细节。某个框架的参数顺序、某类报错的排查路径、某份合同的常规条款,记住了就有优势。

Agent 改变的,是检索与归纳这两项成本,知识本身没变。

以代码为例。按非空代码行、用常见分词器(tokenizer)粗估,英文标识符为主、不含大段中文注释时,每行 8 到 15 个 Token,一个十万行的仓库,全文在 80 万到 150 万 Token 之间。

这个量级对上下文窗口(Context Window)是个考验:128K 到 200K 窗口的模型根本装不下。1M 级的窗口,80 万这端勉强能装,150 万那端仍需分段读。

Agent 不会硬装,它先用 rg 搜关键字,再用语法树或语言服务器协议(LSP)建符号索引,沿引用关系定位调用链,只把相关片段读进来。

人做同样的事,要逐文件打开、跳转、记录。差距不在智商,而在检索、定位与归纳的成本。

注意:Agent 给出的调用链只是候选,没跑过测试就当成事实,会导致错误传播到后续修改里。

这里有一个常被忽略的边界。Agent 擅长公开知识的检索,不擅长你私有上下文的获取。公司的报销规则、没写进文档的接口约定、三年前一次故障的口头结论,模型不会自动知道。

它要么靠你喂进去,要么靠工具现场读。检索成本降了,私有上下文的成本没降。这一步省不了,也没有捷径可走。

也因此,“死记硬背”的边际价值正在归零,“知道去哪找、找得对不对”的价值反而更清楚了。前者是记忆,后者是判断。

推理:过程变便宜,担责没变便宜 ​

第二道护城河是推导能力。复杂逻辑、架构设计、法条解构,曾经是少数人的特权;把问题描述清楚,模型就能给出结构完整的推导过程。

但“能推”和“能交付”是两件事,中间隔着验证与担责。

先算一笔账。一个十步的任务,假设每一步有 95% 的正确率,串起来只剩约 59.9%。二十步,只剩约 35.8%。这不是模型不行,而是多步串联之后的概率数学。这是上限估计;真实值取决于各步错误是否相关。这里的 95% 指每一步一次做对的概率,链上只计生成步;不设检查点、一次跑完。

python
# Python 3.10+,无需第三方库
for steps in (5, 10, 20):
    print(steps, round(0.95 ** steps, 3))

跑出来是 77.4%、59.9%、35.8%。步数越多,对单步准确率的要求越苛刻。想把二十步的整体成功率做到 80%,单步得达到约 98.9%。这个数字靠“模型再强一点”解决不了,得靠拆步骤、加校验、设检查点。

拿一个支付 bug 举例。定位、复现、改代码、跑单测、回归、发布,六个动作;跑单测、回归是校验步,价值是把错误挡在下一步之前,不按乘法叠加。若六步都按 95% 连乘,整体只剩约 73.5%。实际链路通常不止六步。

这就是为什么 Agent 越能干,架构和验收反而越重要。推理过程可以外包,结果的责任没法外包。最后签字、承担后果的人还是你。

前两类讲的是个人手里有什么,后两类讲的是个人站在哪里。

比特行业:被重构的是环节,不是行业 ​

第一类结构性冲击落在生产资料全是比特的行业。软件、短剧的字幕与后期、文案、平面设计、翻译,生产要素都在数字世界里,Agent 的边际成本极低(仍按 Token 计费)。

“行业被整体取代”这个说法太粗。真正被重构的是行业里的具体环节。

拿一条三分钟的短剧出海字幕举例。拆开通常是四步:听写、翻译、时间轴、校对。前三步都是比特加工,Agent 可以批量做。第四步要看文化语境,一个双关语翻错了,观众会笑场,Agent 不一定看得出来。

字幕团队没有消失,只是从几个人变成一个人加一套 Agent 流水线。以我们见过的一个五人字幕小组为例,一集原来要两天,现在一个人半天出初版。被挤掉的是纯搬运环节,留下来的是判断环节。

注意:批量生成的字幕如果不做抽检,会导致错译以集为单位扩散,返工成本高于逐集校对。

平面设计也一样。生成二十版海报只要几分钟,但选哪一版、改哪句文案、有没有踩到版权,仍然要人拍板。机器不承担这个责任,也不签这个字。

组织中间层:信息中转的价值被压缩 ​

第二类结构性冲击,是把尺度再放大一层,落到组织。传统组织里,有大量岗位的核心工作是信息中转。

需求从业务传到开发,要有人翻译;进度从各组汇总到管理层,要有人整理;一份材料从 A 系统搬到 B 系统,要有人改格式。

这类工作不直接做决策,也不直接接触客户。它的价值,是把信息从一个人手里安全地交到另一个人手里。

Agent 最擅长的正是这件事。会议纪要、周报汇总、需求拆解、格式转换,过去要占掉几个人的时间,现在一个人加 Agent 就能跑完。

岗位没有立刻消失,先被压缩的是编制。原本要一个小团队做的汇总,现在一个人加 Agent 就能跑,多出来的人要么上移做判断,要么转岗。对组织来说,这是效率;对个人来说,这是位置变化。

所以中间层真正的风险,不是被 Agent 替代,是被会用 Agent 的同事替代。

注意:把中转工作全部交给 Agent 而不设复核,会导致错误在部门之间静默传递,等到下游发现时已经改不动。

两类能力贬值,加上两类结构性冲击,结论是一致的:Agent 拿走的是可复述、可穷举、可批量的部分。

8.1.2 机遇:升值的那部分与它的前提 ​

如果只看到这里,容易得出一个悲观结论:门槛没了,人也不值钱了。这个结论只对了一半。

挑战和机遇不是两回事,是同一件事在不同位置的人身上的两种结果。

原来靠信息差吃饭的人,优势在缩小;原来被信息差挡住的人,机会在变大。起点不同、手里有什么不同、规模不同、能力边界不同,接住机遇的方式也不同。

后发者:起点被抬高,但终点没被规定 ​

对新入行的人,最大的障碍通常是时间,不是笨。老从业者用五年踩过的坑,新人得再踩一遍。

Agent 把这段重复路压缩了。在我们自己的项目里,新成员接手一个模块,通常先让 Agent 把入口、依赖和测试跑一遍,再人工确认。这一步很耗时间,现在能省下来,花在判断上。

起点抬高不等于终点前移。Agent 能带你读懂并发模型,不能替你判断这里该不该加锁。能生成十个方案,不能替你承担选错方案的后果。

后发者真正的机会,是跳过“抄一遍”的阶段,把时间花在“判断哪一版对”上。这个阶段原本要几年才开始,Agent 能把它提前。

先发者:隐性知识第一次可以被放大 ​

对干了多年的人,Agent 的价值不在“替你写”,在“替你跑”。

一个架构师最值钱的东西,往往不在代码里。是看到需求就知道哪里会出问题,是评审时一眼看出状态机少了一个分支,是故障现场敢拍板先回滚。这些判断来自实战,写不进教科书。

比如数据库慢查询。资深工程师看一眼执行计划,就知道是索引选择性问题。Agent 能列出候选索引,但不能替你对业务的读写比例做取舍。这个取舍只能由人来定,模型替不了。

这些判断只能通过带人传递,带宽有限。一个资深工程师同时跟三个项目就到顶了。这是我们的经验值,不是行业统计。

如果他能把判断写成规则、检查清单、验收用例,Agent 就能替他执行。带宽从“跟三个项目”变成“同时审多条流水线”。前提是你能把它写出来。写不出来的隐性知识,再好的 Agent 也放大不了。

把判断写出来,也是边界解构的前提。

小团队:试错成本第一次变得可承受 ​

先发者放大的是判断,小团队放大的是试错。

按我们的经验,一个人两周能做出一个能点开、能跑通的小工具,比如内部报表或单页应用;这指的是原型,不含测试、合规与上线运维。他本人没有突然变强,只是每个角色的第一版由 Agent 生成。

这让创业的顺序变了。过去是“先融资、再招人、再做产品”,现在是“先做产品、再决定要不要融资”。

试错次数从一年一次变成一月一次。失败成本也从量级上降下来:“几十万”是养一个小团队一个月的综合人力成本,“几千块”是一轮原型的 Token 账单。两个数字口径不同,只做量级对比:几千块只是工具现金支出,不计人力。

原型成本和交付成本是两件事。Agent 能把原型成本压到很低,交付成本仍然包括测试、合规、运维、客服。别把“能演示”当成“能上线”。

注意:原型直接拿去接真实流量,会导致未处理的边界条件在生产环境集中暴露。

边界解构:从“我会做什么”到“我能调度什么” ​

最后一类机遇,是个人能力边界开始出现可操作的松动。

但要泼一点冷水。一个人能调度一条流水线,不等于一个人能做好所有角色。调度本身是新的专业能力:拆任务、定接口、设验收、控预算。这四件事任何一件缺位,Agent 越多,返工越多;最常见的缺位是接口。

一个常见的反例是,任务拆得粗,Agent 各自按自己的理解写,最后合并时接口对不上,返工时间超过从头写。工具放大了执行力,也同样放大了架构与设计上的缺陷。

正向的版本是:一个人把写作、审校、发布三条线拆开,各自定接口和验收,自己只做统稿和最后拍板。这时的“调度”已经是设计与验收,不再是打杂。

也因此,“超级个体”不是“什么都会的人”,是“能把判断变成编排的人”。这个区别,8.4 会展开。

把这张价格表摊开,大致是两类。

  • 在贬值:公开知识的检索、初稿的生成、格式转换、常规推理、批量素材加工。
  • 在升值:问题的定义、结果的验收、担责、私有上下文的组织。

价格变了,位置就得跟着变。越早看清越主动,越晚越被动。下一步不是问“Agent 会不会取代你”,而是问“你手里哪些能力还在按旧价格出售”。接得住的人按新价成交,接不住的人被重新定价。

8.2 讨论具体怎么改:知识怎么映射,思维怎么换,沟通怎么结构化,协作怎么组织。

8.2 我们必须进行改变 ​

8.1 说的是外部世界的变化,护城河在贬值,这一点已经能在日常工作里看见。但门槛同时也在降低。所以要改的不是意志力,是做法。真正难改的是人这一侧,工具换了,脑子没换,效率差距照样拉不开。

Agent 刚进入工作流时,很多人的第一反应不是恐慌,而是兴奋。我们见过有人把 Agent 半小时干完的活拖成三天交,装作自己还很忙,用加班时长证明自己仍然有价值。

这种做法短期能保住面子,长期会输掉时间窗口。交付节奏对不上需求节奏,你越装忙,积压的活越多;等到老板和客户知道真实的生产力数量级,你手里已经没有议价权了。

所以我们没有别的选择,只能改。这一节讲四个改变:知识与技能的 Agent 映射(简称 Agent 映射),思维模式的重构(简称思维重构),沟通模式的转变(简称沟通转变),协作模式的改变(简称协作习惯)。前三件改的是做事方式,最后一件改的是默认反应,四件事其实互相咬着,指向同一件事:把人从“自己干”挪到“把活定义清楚”。

本节出现的次数与时长,均为我们的经验值,不是统计结论。

8.2.1 知识与技能的 Agent 映射:把经验拆成可调用的接口 ​

先看一个常见场景。一位做了十年数据清洗的工程师,手里攒了几十个脚本,每个脚本带半行注释,路径写死在本机,参数靠改代码。

他一直相信这就是自己的护城河,直到有人把同类需求交给 Agent,二十分钟就跑通了,输出还比他稳定。问题不在脚本不值钱,而在于这些脚本从来没有被组织成 Agent 能用的形态。

躺在硬盘里的知识是死知识,放着不动只会逐年过期。知识的价值不在于藏,而在于被调用;对组织来说,调用次数越多越值钱。对个人来说,定价权来自把经验定义成别人能用的接口。

把死知识变成可调用的能力,我们叫它“知识与技能的 Agent 映射”,简称 Agent 映射。它不是把文件上传给模型,而是把经验重新组织成接口,分三步完成。

先说清要搬的是什么。知识有三类:写在文档里的流程,跑在机器上的脚本,以及只在老员工脑子里的判断规则。前两类好搬,第三类最难,因为它平时靠场景触发,不写下来就会消失。

而 Agent 映射本身分三步,是递进的:先有形状,再有说明,最后接上真实任务、拿到反馈。跳过任何一步,映射都会退化成把文件丢给模型。

第一步:结构化封装 ​

封装不是重写代码,而是划清边界。

一份能交给 Agent 的知识,至少要说清四件事:输入是什么,输出是什么,在什么条件下有效,失败时返回什么。原来的脚本往往只回答了前两个,输入靠口头约定,失败靠人翻日志。

Agent 看不懂这种默契。它需要一个显式的接口,把类型、范围、必填项和错误码都写在明面上,缺一项就会在真实任务里出问题。

封装也有成本。只用一次的临时脚本不值得封装,改过三次以上的流程才值得。判断标准很朴素:这套东西你今年还会不会再讲一遍给新人听。会,就封装。

下面这段代码把一个折扣规则封装成工具,可以在 Python 3.6 及以上版本直接运行(本书在 3.10.12 上实测),不依赖第三方库。

python
# discount_tool.py
RATES = {"A": 0.90, "B": 0.95, "C": 1.00}

TOOL_SCHEMA = {
    "name": "calc_discount",
    "description": "按客户等级计算订单折后金额,单位为元",
    "parameters": {
        "type": "object",
        "properties": {
            "amount": {"type": "number", "description": "订单原价,必须大于 0"},
            "level": {"type": "string", "enum": ["A", "B", "C"],
                      "description": "客户等级,A 最优"},
        },
        "required": ["amount", "level"],
    },
}

def calc_discount(amount: float, level: str) -> float:
    if amount <= 0:
        raise ValueError("amount 必须大于 0")
    if level not in RATES:
        raise ValueError(f"未知等级: {level}")
    return round(amount * RATES[level], 2)

if __name__ == "__main__":
    print(calc_discount(1000, "A"))
    print(calc_discount(1000, "C"))

函数本身用异常表达错误,但工具层不能把异常直接抛给模型。挂上去之前要加一层很薄的 wrapper,把异常转成返回体:

python
# 工具层入口:把异常转成 Agent 能读的返回体
def calc_discount_tool(args: dict) -> dict:
    try:
        return {"isError": False,
                "content": calc_discount(args["amount"], args["level"])}
    except KeyError as e:
        return {"isError": True, "message": f"缺少参数: {e.args[0]}"}
    except (TypeError, ValueError) as e:
        return {"isError": True, "message": str(e)}

上面的 TOOL_SCHEMA 只是给模型看的声明,真正被调用的是这个入口。返回 isError 而不是抛异常,Agent 才能读到错在哪、要不要转人工。

保存后直接运行,输出是 900.0 和 1000.0。

bash
python3 discount_tool.py

这段代码的价值不在算法,而在边界。金额为负、等级不认识,异常都会被转成一条明确的错误信息,Agent 读到它,才知道下一步该问人还是该重试。

如果只给一句“计算折扣”,模型会自己补规则,补错了,账也就错了,而且错得很难发现。

第三类知识,也就是老员工脑中的判断规则,不能靠上面的接口封装直接搬。可行的做法是倒推,分三步。先挑最近三次真实判断,问清楚当时看了哪些信号、在什么条件下改判,把规则写成一句可执行的条件。再把那三次判断做成输入输出样例。最后把前置条件写进工具描述,让 Agent 在调用前先自查。规则说不清,往往不是它不存在,而是从没被要求说清楚。

第二步:语义化设定 ​

封装解决“能不能调”,语义解决“该不该调”。

工具描述是模型选择工具的重要依据,工具名与参数定义同样参与选择。描述写得含糊,模型就会在错误的场景调用它,调用成功反而更危险。比较两种写法:

  • 差:"计算折扣"。
  • 好:"按客户等级计算订单折后金额,仅适用于已确认的销售订单,不处理退款与税费"。

后者多了三样东西:业务场景、前置条件、排除范围,这三样显著影响模型会不会误用。参数也要写清楚,amount 要标单位,level 要列枚举,不要指望模型猜“元”还是“分”。

我们的观察是,工具描述里每多一句边界说明,通常能少一轮返工。这句话听起来像常识,真正做的时候,大多数人只写第一句功能描述。

工具描述还有第二重作用:它是团队文档。新同事读一遍工具描述,就知道这个能力能做什么、不能做什么,不必再翻源码。

第三步:动态映射与激活 ​

封装和语义做完,知识还只是文件。要让它活起来,必须挂到 Agent 上,用真实任务反复喂它。

第一版不必公开,先挂到私有 Agent(自己搭的、只给自己用的那个),跑自己最熟的业务流程。跑的过程会暴露纸面上看不见的问题:参数不够、边界漏了、返回格式对不上下游。

每修一次,留一条回归用例,输入、期望输出两项就够,实际输出由断言给出。用例不用多,但要覆盖边界:金额下界、空等级、未知枚举。正常路径模型本来就会走,出问题的永远是边界。

python
# test_discount.py
from discount_tool import calc_discount

CASES = [
    ((1000, "A"), 900.0),
    ((1000, "B"), 950.0),
    ((0, "A"), "ValueError"),
    ((1000, ""), "ValueError"),
    ((1000, "D"), "ValueError"),
]

for args, expect in CASES:
    try:
        got = calc_discount(*args)
    except ValueError:
        got = "ValueError"
    assert got == expect, f"{args}: 期望 {expect},实际 {got}"
print("全部通过")

只有五条用例,但能挡住最常见的手滑。有 CI 就挂上去,没有就每次改规则前手动跑一遍,改坏了当场就能发现。

注意:工具描述与实现不一致,会导致 Agent 选对工具却传错参数,任务静默产出错误结果。

映射不是一次性动作。业务在变,规则在变,映射也要跟着版本走。今天能跑通的工具,半年后可能因为上游字段改名而失效,没有回归用例就发现不了。

映射的落点也要选。涉及客户数据的工具,想进公司内部共享库之前,权限与计费都要先想清楚。

读者如果手里正好有一套旧脚本,可以先挑最常用的那个试一遍。不用等整套体系设计完,先让一个工具跑通。

讲到这里,知识算是搬出去了。但搬出去不等于会用,工具再新,如果人还在用旧做法,也发挥不出来。下一个要改的,是思维模式。

8.2.2 思维模式的重构:三大跃迁 ​

改思维比改工具难。工具可以重装,思维只能自己拆,尤其干了多年的老手,路径依赖最深。

过去遇到问题,第一反应是下场动手,这个习惯曾经是优点,现在成了瓶颈。我们不喊口号,只谈三个可操作的跃迁。

这三个跃迁对应三种旧习惯:抢着做、懒得说、不敢定。

跃迁一:从求解者到提问者 ​

旧标准里,价值等于解题速度。同样一个页面,你改半天,Agent 改两分钟,速度这条赛道已经没了。

新的赛道是定义问题。定义问题不是喊口号,而是把一个模糊的抱怨,拆成一组可以验收的约束。

  • 模糊:这个报表太慢了,优化一下。
  • 可执行:这张报表在 10 万行数据下耗时 8 秒,目标是 3 秒内,内存不超过 500 MB。

第二句里,每个数字都是验收条件,Agent 知道自己有没有做到,你也知道该不该收货。我们把这个动作叫“把抱怨翻译成指标”,翻不出来的需求,先别派给 Agent。

提问还有一层:问对问题。“怎么让报表更快”是太宽的问题,“慢在哪一段”才是真问题。前者把判断权交出去,后者把判断权留在自己手里。

跃迁二:从埋头苦干到完整描述 ​

有一类专家很吃香:活干得漂亮,但讲不清楚。在人情协作里,这不算大问题,同事看你做过,就信你。

在 Agent 面前,这是硬伤。模型读不到你的脑子,只能读你的话,你少写一句,它就少做一件。

描述能力,本质是把隐性意图写成显性契约。契约具体长什么样,8.2.3 会展开成五段结构、样例和边界三类,这里只留一个判断。写不全,就别急着开工;写全了,任务已经成了一半,剩下的才是执行。

举个反例。让 Agent 改一版落地页,只说“做得高级一点”,它会给你渐变、阴影和大圆角。改成“参考这份竞品,保留现有文案结构,只调字号与留白,主色不超过两种”,返工立刻少一半。

跃迁三:从繁琐求证到果断裁决 ​

过去求证很贵,所以要谨慎,一个方案验证一周,谁都不敢拍板。现在 Agent 几分钟能给你十个方案,瓶颈从“能不能做”变成“选哪一个”。

这时候还按老办法逐个求证,等于把新工具用成旧流程。我们的做法是分层:Agent 负责铺开选项,人负责收敛。

  • 先让 Agent 列出候选,每个方案给一句适用条件。
  • 人只看适用条件,做第一轮淘汰,至少能砍掉一半。
  • 剩下的两三个,再让 Agent 补代价与风险。
  • 人拍板,写一句决策理由。

决策理由要落纸,但不用长,三行就够:选了什么,为什么,什么条件下换。复盘时按当时写下的三个关键假设逐条核对,哪条错了,一眼就能看出来。判断力不会因为 Agent 变强而贬值,恰恰相反,选项越多,判断越贵。

三个跃迁说完,会发现它们都指向同一件事:人从执行位退到定义位。但定义位不是喊出来的,它要落到每一次具体的对话里。这就带出下一个改变:沟通模式。

8.2.3 沟通模式的转变:结构化、例证化与边界显式化 ​

和同事沟通,你可以靠默契,说半句,对方能补全。和 Agent 沟通,没有默契可依靠。你不写“周五之前交”,它就不知道周五是个截止时间。

所以沟通要换写法。我们的做法是三条:结构化、例证化、边界显式化。这三条不是修辞技巧,它们的共同目标是把“我以为”变成“写清楚”。

这里的边界是沟通级,管的是单次委托怎么写,包含权限、内容、停止三类;任务级的那四类边界,放到 8.2.4 再说。

结构化:先给骨架,再填内容 ​

结构化的作用是收敛解空间。散文式描述让模型自由发挥,结构化描述则让它按格填。

最小的结构是五段:背景、目标、输入、输出、验收。

text
背景:现有日报靠人工汇总,每天耗时 2 小时。
目标:把汇总时间压到 10 分钟以内,格式与现有一致。
输入:三个业务系统的 CSV 导出,放在 ./data/ 下,每天 9 点前到位。
输出:一份 Markdown 日报,包含总量、环比、异常 Top 5。
验收:连续三天产出与人工版本误差小于 1%,格式通过模板校验。

这五段没有一句废话,模型拿到它,不需要猜你想干什么。反过来,如果只写“帮我做个日报自动化”,模型会自己定义什么叫日报,定义错了,返工三轮。

一份委托要回答五件事:为什么做、做成什么样、输入是什么、不能做什么、什么时候停。五件事分别落进五段:为什么做与做成什么样,进背景与目标;输入是什么,进输入;不能做什么与什么时候停,进边界三类,具体见本小节末。

结构还有一个好处:可复用。同一份骨架换个背景,就能派给另一个 Agent,甚至能给新人当任务模板。写一次,用很多次。

例证化:给一个样例,胜过十句形容词 ​

形容词最不靠谱。“专业一点”“大气一点”“简洁一点”,每个人理解都不同,模型只能按训练数据里的平均值去猜。

样例不一样,给一组输入输出,标准就落地了。

  • 要模型写周报,先给它一篇你认可的旧周报。
  • 要模型改代码风格,先给它一段符合规范的函数。
  • 要模型做数据清洗,先给它三行脏数据和清洗后的结果。

我们在书稿项目里就是这么干的。给写作 Agent 的不是“写得好一点”,而是一份风格标准和一份范文,两者一摆,输出立刻稳定。这是我们的主观感受,没有做对照实验。

样例不必多,一到两个就够,多了反而稀释重点。选样例的标准只有一条:它能代表你想要的上限。

如果找不到合适样例,就让 Agent 先出三个版本,你挑一个最接近的,再让它按这个方向收敛。这比空口描述快得多。

边界显式化:把不能做的事写死 ​

人类协作里,常识是默认项。Agent 没有默认项,不写禁止,它就会尝试,尝试的代价有时是不可逆的。

边界至少写三类。

  • 权限边界:能读哪些目录,能调哪些接口,能用哪些账号。
  • 内容边界:不许编造数据,不许改口径,不许省略异常。
  • 停止边界:连续失败几次停,单次花多少 Token 停,遇到什么情况必须转人工。

注意:只写“要做什么”而不写“不能做什么”,会导致 Agent 在边界外自行补全,产出看似完整但无法追溯的结果。

写约束时有个取舍:约束越多越安全,但太多会互相打架。我们的做法是先列硬约束,不超过五条(上面三类各挑一两条),其余放进验收标准,不塞进指令。

三条合起来,就是一份可执行的委托,也就是一次交给 Agent 的完整说明书。它不是话术,是接口,写得好不好,直接决定返工次数。

结构化给框架,例证给标准,边界给红线。三样齐了,沟通成本会明显下降,你也会越来越敢把整段任务交出去。

不过,沟通再顺,也只解决了“怎么派活”。还有一个更靠前的问题:遇到难题,你第一个想到谁?

8.2.4 协作模式的改变:让 Agent 跑第一棒 ​

这个问题听起来小,实际决定效率。

过去遇到陌生领域,人的第一反应有两个:找熟人,或者自己硬搜。找熟人要等,硬搜要耗,两种都要一天起步。

Agent 时代多了一个选项:先让它跑第一棒。

第一棒跑什么 ​

第一棒不是让它给最终答案,而是让它把地形摸清。具体是四件事:

  • 术语:这个领域有哪些关键词,各自什么意思。
  • 方案:主流做法有几种,各自的适用条件是什么。
  • 风险:常见的失败模式有哪些。
  • 待确认:哪些点必须找真人核实。

四件事做完,你手里就有了一张地图。带着地图去找专家,问的问题完全不同。

以前你问“这个怎么弄”。现在你问“方案 B 在我们的场景下,状态一致性怎么保证”。

后一个问题,专家愿意答,也答得快,因为他不需要从零给你科普,只需要判断你的方案对不对。

举个具体例子。要给项目选一个开源队列,过去是翻文档、看 star、试装,一天就过去了。现在先让 Agent 跑一遍:列出五个候选,给出吞吐、持久化、运维成本的对比,标出它不确定的版本号。你拿着这张表,十分钟左右就能定方向。

一个可复用的流程 ​

我们的做法分三步,整套控制在半小时以内。

  • 写一段 200 字以内的背景,说明你要解决什么。
  • 让 Agent 输出上面那张四栏地图,并标注不确定项、来源与时间。
  • 人读一遍,划掉错的,圈出要问的,再决定下一步。

最后一步不能省。Agent 的地图会有错,尤其是版本与价格这类时效信息,它可能引用半年前的文档;第二步标不出来源与时间的结论,一律当待核实处理。

注意:把 Agent 的调研结论直接当事实使用,会导致方案建立在过期信息上,返工时成本更高。

哪些事不能让 Agent 跑第一棒 ​

边界同样重要。这是任务级边界,与 8.2.3 的沟通级边界分工不同。那一节管的是单次委托怎么写,这里管的是哪些任务根本不该整段交出去。有四类事要人先上。

  • 不可逆操作:删库、转账、对外发布。第一棒可以是演练,不能是真跑。
  • 涉密数据:客户名单、合同条款、未公开的财务数据。先脱敏,再喂。
  • 责任归属:法律意见、医疗建议、审计结论。Agent 可以整理材料,签字的人必须是人。
  • 与人有关的判断:绩效、裁员、客户关系。Agent 先跑,省下的是时间,输掉的是信任。

这四条不是保守,是划清责任。越界一次,代价可能抵消前面所有的效率收益。

习惯怎么养成 ​

习惯不靠决心,靠次数。

先做一件,做顺了再凑十件。之后挑十件小事,全部让 Agent 跑第一棒。查一个库、读一份文档、比三个方案、写一段脚本,都算。

坚持一个月,你会发现一个变化:遇到问题的第一反应,从“我来”变成“先让它试试”。这个反应一旦形成,效率的差距就拉开了。

这件事不需要等公司批准,也不需要等工具完美。现在就能开始,成本是一顿晚饭的时间。

读者不妨现在就挑一件手边的小事,今晚让它跑一次。

8.1 说护城河在贬值,8.2 讲的是怎么赶在见底之前换地基。Agent 映射、思维重构、沟通转变、协作习惯,四个改变没有一件能靠想明白完成,都得靠做。

读者不必四件一起上。先挑一件做满一个月,效果比同时铺开好。

而做需要投入。时间、钱、精力,一样都省不了。下一节讲这笔账怎么算。

8.3 利用 Agent 重新武装自己:真金白银的破局之路 ​

8.2 讲的是为什么必须改变。道理落到个人身上,第一道坎往往不是认知,而是启动成本,这道坎跨不过去,后面的方法都用不上。

装环境要时间,买 Token 要钱,整理知识要精力,这三样都要先付出去。回报却在几周以后才能看见,所以很多人卡在这里。

很多人认同方向,却总想等一个更便宜的时机,等别人把坑踩完再进场。

我们的判断很直接:这笔钱越早花越值。这里不鼓励乱花,只是想说明换一套干活方式有门票。门票大约几百元,不算贵,但必须真付。

下面按四步走。选一个今天能跑通的平台,把知识切成可检索的资产,做出第一个能验收的助理,再留出稳定预算。

8.3.1 选择一个合适的工具平台:别抠搜,马上干 ​

三条判据 ​

选平台的第一条判据,是能不能被脚本调用。Agent 的强项是执行确定命令、读结构化输出,再按退出码决定下一步。

一个只能靠鼠标点击的平台,很难把活真正交出去。你点一次,它跑一次,中间的人反而成了流程里的瓶颈。

第二条判据,是资产能不能导出。Prompt、知识库、会话记录都要能打包带走,不能被平台锁死在自家数据库里。

第三条判据,是计费是否透明。按调用量计费、账单可下钻到单次请求,才谈得上 8.3.4 的预算管理与成本复盘。

三条都过,再比价格,价格是最后一项。顺序反过来,通常会在后续付出更高的切换成本,省下的订阅费还不够补一次迁移。

云端和本地怎么选,第 2 章讲过,这里只给结论。要在一周内验证一个想法,先用 Coze 或 Dify,注册当天就能跑通。

要长期常驻、要工具权限、要改循环内核(Agent 的想—做—看循环),就在本机装 OpenClaw 或 Codex CLI。两者不是替代关系,而是先后关系,先跑通再谈控制权。

云端买的是“当天跑通”,本地买的是“控制权与权限”,这就是先云后本地的理由。两段都走一遍,选型才算有依据。

下面以 OpenClaw 为例。Coze 与 Dify 的判断标准一样,换成各自的插件与知识库配置即可。

当天跑通最小链路 ​

选定之后,当天就要跑通一条最小链路。下面是 OpenClaw 的验收步骤,环境为 Ubuntu 22.04 与 Node 22.22.3–22.x、24.15–24.x、25.9+,缺一步都不算装好。

先 node -v 核对版本,以 openclaw 的 engines 声明为准:22.22.3–22.x、24.15–24.x、25.9+ 都可以;不满足就先升级 Node,再执行下面的安装。安装命令里的版本号固定为 2026.9.2,以当时最新稳定版为准,本文写于 2026-11。

bash
node -v
npm install -g openclaw@2026.9.2
openclaw onboard
openclaw gateway run --port 18789

另开一个终端,确认网关(Gateway)活着,再发一条只读任务,看看结果能不能回来。

bash
openclaw gateway health
openclaw agent --agent main --message "列出 /path/to/agent-lab 下最近三次 git 提交"

/path/to/agent-lab 换成你的真实目录,没有就新建一个空目录。

注意:Node 版本不在 22.22.3–22.x、24.15–24.x、25.9+ 范围内时,安装会报 engines 不匹配,导致 Gateway 起不来、后面的命令全部失败。先用 nvm 或包管理器升级 Node。

这条链路跑通,说明模型、工具、Gateway 三件事都通了。跑不通时先查环境,不要急着换平台,否则只会把同一个问题再遇一遍。

很多人会在这里省钱。他们去找免费镜像站,或者买几十元的套壳账号,觉得功能看起来一样,价格却便宜很多。

这笔账算错了。部分免费镜像存在限流、模型降级、记录请求内容的问题,你的业务数据和 API Key(密钥)都会经过别人的服务器。

注意:把 API Key 填进来源不明的镜像站,会导致密钥泄漏、账单被别人跑光、数据被留存。充值前先确认服务方的资质与隐私条款。

几百元的启动预算,买到的是时间和确定性。我们见过有人折腾免费方案整整 3 天,丢掉的是同等时长的产出和 3 次试错机会。

平台选完,只说明阵地有了。下一步是把你的知识搬进去,知识不在,工具再多也拼不出结果,助理只能空转。

8.3.2 数字化与格式化你的知识:别把宝贝烂在硬盘里 ​

平台能导出,这一步才有前提。知识资产化不是把文件复制到一个目录,它要经过四道处理,加一道验收:收集、清洗、切块、加元数据,每一步都决定后面的检索质量。

收集的目标是找全。业务脚本、复盘文档、客户问答、排障记录,凡是重复用过的,都算,别只收正式文档。

清洗的目标是去噪。删掉过期版本、重复段落和无关附件,只留可复用的结论,过程可以另存,结论才值得反复调用。

切块的目标是让检索命中。一段讲一件事,长度控制在 300 到 800 字(经验值,按检索效果调),太短会丢上下文(Context),太长会稀释重点。

元数据的目标是可追溯。每块除来源(source)与块号(chunk)外,还要带更新时间(updated_at)与适用范围(scope),出了问题才能顺着字段回到原文。

常见的错误,是把一份两百页的文档直接丢给模型。Context 窗口不够、又没做检索时,它要么读不完,要么读到了也抓不住重点,最后只能给出泛泛的答案。

正确的形态是一个浅目录加一批小文件。目录按业务分,文件按问题分,每层不超过三个分支(同样是经验值)。

每个文件只回答一个问题。文件名就是检索词,也就是问题的短名;正文就是答案,先写结论,再写依据,长度控制在 800 到 1200 字(两屏以内)。

下面是整理脚本,只依赖 Python 标准库。环境要求 Python 3.10 以上,不需要安装任何第三方包。

python
#!/usr/bin/env python3
"""把一个目录下的 md/txt 笔记切成 JSONL,供检索使用。"""
import datetime
import json
import pathlib
import re
import sys

ROOT = pathlib.Path(sys.argv[1] if len(sys.argv) > 1 else "notes")
OUT = pathlib.Path(sys.argv[2] if len(sys.argv) > 2 else "knowledge.jsonl")
MIN_CHARS = 300
MAX_CHARS = 800


def clean(text: str) -> str:
    text = re.sub(r"`{3}.*?`{3}", "", text, flags=re.S)
    text = re.sub(r"\n{3,}", "\n\n", text)
    return text.strip()


def cut_long(para: str, size: int, floor: int) -> list[str]:
    parts = []
    while len(para) > size:
        window = para[:size]
        cut = max(window.rfind("。"), window.rfind("!"), window.rfind("?"), window.rfind("\n"))
        if cut < floor // 2:
            cut = size - 1
        parts.append(para[: cut + 1].strip())
        para = para[cut + 1 :].strip()
    if para:
        parts.append(para)
    return parts


def split(text: str, size: int = MAX_CHARS, floor: int = MIN_CHARS) -> list[str]:
    parts = []
    for para in re.split(r"\n\s*\n", text):
        if para.strip():
            parts.extend(cut_long(para.strip(), size, floor))
    merged = []
    for part in parts:
        short = merged and (len(merged[-1]) < floor or len(part) < floor)
        if short and len(merged[-1]) + len(part) + 2 <= size:
            merged[-1] = f"{merged[-1]}\n\n{part}"
        else:
            merged.append(part)
    return merged


def main() -> None:
    if not ROOT.is_dir():
        sys.exit(f"目录不存在: {ROOT}")
    count = 0
    with OUT.open("w", encoding="utf-8") as f:
        for path in sorted(ROOT.rglob("*")):
            if path.suffix.lower() not in {".md", ".txt"}:
                continue
            text = clean(path.read_text(encoding="utf-8"))
            if not text:
                continue
            rel = path.relative_to(ROOT)
            updated_at = datetime.date.fromtimestamp(path.stat().st_mtime).isoformat()
            scope = rel.parts[0] if len(rel.parts) > 1 else ""
            for i, chunk in enumerate(split(text)):
                rec = {
                    "source": str(rel),
                    "chunk": i,
                    "text": chunk,
                    "updated_at": updated_at,
                    "scope": scope,
                }
                f.write(json.dumps(rec, ensure_ascii=False) + "\n")
                count += 1
    print(f"写入 {count} 条 -> {OUT}")


if __name__ == "__main__":
    main()

用法只有一行,第一个参数是知识目录,第二个参数是输出文件。脚本会跳过空文件、保留相对路径;长段按句号切,找不到句号时硬切到 800 字以内;相邻短段尽量合并,但受 800 字上限约束,末段可能不足 300 字。

bash
python3 format_knowledge.py knowledge knowledge.jsonl

一条记录包含五个字段:来源 source、块号 chunk、正文 text、更新时间 updated_at、适用范围 scope。updated_at 取文件修改日期,scope 默认取一级目录名,需要更细的适用范围时手工补。检索命中后,你能顺着来源回到原文,而不是只拿到一段无出处的文字。

整理完要验收,这是第五道。随机抽 10 个你真实问过的问题,用你选定的检索层(Dify 知识库、向量库,或 rg 关键词检索都行)逐个查,看能否命中正确文件,这是最便宜的一次质检。这里验的是知识库的检索层,不是助理的输出层。

命中 7 个以下,先改切块和元数据,不要怪模型。我们的经验是,检索失败多半出在切块与元数据,排序只是其中一环。

文件太大、标题太泛、来源缺失,都会让正确的段落排到后面。先把这三处修好,再考虑换检索方案。

注意:把客户隐私、数据库密码、内部地址一起格式化进知识库,会导致它们被检索到并进入 Context,造成泄漏。入库前先脱敏,或加白名单。

知识就位以后,才轮到助理。没有知识,助理只是一个会说话的搜索框,答得很快,但答不到点上。

8.3.3 创建你的能力助理:打造专属的数字分身 ​

本节说的助理,也叫能力助理或数字分身。助理不是一个新聊天框,而是一个可交付的工作单元,由四件东西组成:Prompt、知识、工具与验收用例(先手写,存为 tests/cases.jsonl)。

四件少一件,它就只能演示,不能上岗。Prompt 决定它怎么想,知识决定它知道什么,两者都影响判断质量。

工具决定它能做什么,验收用例决定它做得对不对。这四件事里,最容易被跳过的是验收用例,因为它不产生演示效果。

第一个助理不要做大。挑一件你每天重复做、每次超过 20 分钟的事,范围越窄,验收越容易,价值也越快显现。

比如合同初审、周报汇总、日志排障。这些活有固定输入,也有明确的对错标准,适合做第一个样本。

下面是一个合同审阅助理的最小定义。文件放在 <workspace>/skills/contract-review/SKILL.md,核心只有四步,每一步都要有可检查的完成标准。

markdown
---
name: contract-review
description: 审阅采购合同,标出付款、违约与知识产权条款的风险点。用户上传合同或贴出条款时使用。
---

# 合同审阅

1. 读取合同全文,按付款、交付、违约、知识产权四类条款逐条定位。
2. 每条给出原文位置、风险等级与修改建议。
3. 原文没有约定的条款写「未约定」,不要推测。
4. 输出 Markdown 列表,每条不超过 80 字。

目录里再放一样东西:tests/cases.jsonl 存验收用例。SKILL.md、知识库引用、工具配置、验收用例四件齐了,助理才有可复现的行为。

knowledge/ 不放进助理目录。SKILL.md 用路径直接指向 8.3.2 的同一份知识库,不复制副本,避免双份漂移。

text
<workspace>/skills/contract-review/
├── SKILL.md          # 内文用路径引用 ../../knowledge/
└── tests/
    └── cases.jsonl

description 不是给人看的介绍,是给模型看的触发条件。写清场景和动作,它才知道什么时候该用,什么时候不该用。

工具只给必要的那几个。能读文件就不要给写权限,能读一个目录就不要给整个磁盘;权限在 Agent 配置里按任务开,不写进 SKILL.md。

权限每多一层,影响的半径就大一圈。助理的能力边界应该由任务决定,而不是由默认配置决定。

验收用例至少写 10 条。每条包含输入、期望结果(如命中的条款)、不可出现的错误,三者缺一不可,否则测了等于没测。

这里验的是助理任务的输出层,与 8.3.2 的检索层验收不是同一把尺,不能互相替代。手写阶段先用纸面用例,8.4.3 会把它升级成可执行的验收脚本。

10 条里过 8 条,可以开始日常使用;高危错误按 0 容忍,一般错误不超过 2 条。这两条线是经验值,按你的业务风险调整;过不了,先看是知识缺失,还是指令含糊,两类问题的修法完全不同。

修法上,前者补文件,后者改步骤,不要用更长的 Prompt 掩盖知识缺口,那样只会把错误埋得更深。

Prompt 越长,错误越难定位。先把知识补齐,再谈措辞优化,顺序反了,你会一直在改说法,而问题始终在原地。

注意:给助理开放整个用户目录和 Shell 权限,再让它自动执行,会导致一条误写的删除命令把源码与资料一起带走。权限按任务开,执行前先做快照。

助理跑顺之后,才谈得上复制。8.4 会讲怎么把多个助理组织成数字军团,这里先把第一个做对。

8.3.4 为 Agent 留出你的预算:不要让战马饿肚子 ​

预算不是财务问题,是产能开关。额度设得太低,Agent 只能做小任务,复杂流程永远跑不起来。本地模型只算电费与硬件折旧,下面按 Token 计费口径算。

算一笔账。单任务成本等于输入 Token 乘以单价,加上输出 Token 乘以单价;这个公式适用于按 Token 计费的文本模型。先把账算清,再谈预算。

假设一次任务输入 3 万 Token、输出 5000 Token。输入按每百万 4 元、输出按每百万 16 元(单价为示例假设,按你的实际账单与日期核对),单次成本约 0.2 元。

一天运行 40 次,一个月约 1200 次运行,模型费约 240 元。这个数字不高,但它只是模型部分,真正的账单还要加上基础设施。

服务器、存储、搜索接口要另算,按我们的估算,通常还要再加 100 到 300 元。失败重试是常见的隐性大头:重试率按 20% 到 50% 估,模型费还要再加 20% 到 50%。

下面这段脚本可以直接改参数,单价以你的实际账单为准。改完跑一遍,预算就有底了,需要改的是四类参数:输入单价、输出单价、任务量、单次用量。

python
#!/usr/bin/env python3
"""按任务量估算每月模型账单,单价以你的账单为准。"""
INPUT_PRICE = 4.0
OUTPUT_PRICE = 16.0
TASKS_PER_DAY = 40
IN_TOKENS = 30_000
OUT_TOKENS = 5_000

cost_per_task = (
    IN_TOKENS / 1_000_000 * INPUT_PRICE
    + OUT_TOKENS / 1_000_000 * OUTPUT_PRICE
)
monthly = cost_per_task * TASKS_PER_DAY * 30
print(f"单任务 {cost_per_task:.3f} 元,每月 {monthly:.2f} 元")

下面三档说的都是模型费,不含基础设施,对应试跑、稳定、多助理并行三个任务量区间。

我们建议读者分三档。试跑期每月模型费 200 到 300 元,只求跑通一条链路,不追求任务量;上面的算例 240 元正好落在这一档,加基础设施合计约 340 到 540 元。这个阶段的目标是验证,不是省钱。

稳定期每月模型费 500 到 1500 元,覆盖日常任务和失败重试。多助理并行时,模型费 3000 元起步。档位不是标准,是起点。

钱要花在能计价的地方。若平台支持,就给每个助理单独发一个 API Key,账单才能归因到助理;不支持就用日志或标签按任务打标。归因清楚,才谈得上优化。

再设两道闸。月度硬上限挡住异常;若平台支持,就在月度上限的 70% 和 90% 各提醒一次,不支持就用两个固定金额档。提醒要发到人能看到的地方,没有闸,异常会变成常态。

每周看一次单次交付成本(下称单次成本)。它涨得比交付量快,说明 Context 或重试出了问题,该查日志了。成本曲线比总额更早报警。

预算要按产出复盘。要区分运行次数与交付任务数:同样 240 元,如果每月只交付 4 个任务,单次成本 60 元,还不如自己干。

如果交付 40 个任务,单次 6 元,这笔钱就值。判断标准不是花了多少,是每个任务摊到多少。

预算留足,助理才敢接长任务。这也是超级个体的底气:省下的那点钱,通常不够补一次返工。

真金白银的意思,是把钱花在能放大的地方。不是买最贵的工具,也不是死守最便宜的方案,而是让投入产出可算。

注意:循环没有退出条件,又不设预算上限,会导致一次失控的重试在夜里烧掉一个月额度,后续任务全部停摆。给循环加最大步数,并设月度硬上限。

回到开头。重新武装自己,不是买一个更贵的工具,而是把平台、知识、助理、预算四件事做实,缺一不可。它们不必一次做到完美:先跑通,再迭代,每一步都留下可验证的产物。这四步都不需要宏大叙事,你今天先做第一件能验收的事就行,付钱只是其中一条可选路径。

下一步,8.4 把这套方法推到极致。一个人如何组织一支数字军团,前提是今天这四步已经落地。

8.4 成为领域内的超级个体:从一人公司到数字军团的崛起 ​

8.3 讲的是怎么把自己武装起来。充钱、整理知识、建助理、留预算,四件事做完,你手上会有几个能干的助理。

接下来的问题是规模。助理从 3 个长到 30 个,靠人记就不行了。真正的问题不是数量,是你对每个助理当前状态的记忆。

一个细分领域的成熟从业者,配上三到五个助理,大致能顶上一个五人小团队的产出。这个换算有前提,而且前提不轻。活必须能拆开,也必须能验收。一旦需要跨部门博弈或者现场谈判,人数还是省不掉。

规模问题不是 Agent 时代才有的,十多年前的全栈梦就撞过同一堵墙。

回看十多年前,很多技术爱好者都梦想过成为无所不能的全栈极客。从 Java 撸到 C++,从前端干到后端,一个人包揽所有技术栈。

这个梦想当年大多停在玩具阶段,原因不是技术不够好,而是交付一个复杂系统还得有人判断需求、有人验收结果、有人为失败兜底。这三件事过去只能靠人来做。

Agent 压缩的是执行、检索、初稿这三件事的成本。它把这些环节压到了接近一台机器的边际成本水平,但没有把专业判断本身也一起压掉。

这一节回答四个问题:选哪个领域,怎么画架构,怎么把助理从 1 做到 10,以及助理多起来以后怎么组建数字军团。

8.4.1 冷静的清醒:超级个体的领域局限性 ​

先说不成立的部分。超级个体不是一个什么都会的人,而是一个在自己选定的领域里,借助少量助理,能独立走完从判断到交付全流程的人。

跨领域通吃这件事,在 Agent 时代仍然不成立,原因有两条。第一条是你得能验货,第二条是你得问对问题。

先看验货这一关。Agent 给出的东西是对是错、能不能直接用,只有内行看得出来。

拿一份 SaaS 采购合同来说。合同正文里写着无限责任条款,数据处理附件里还有跨境传输的约定。Agent 能在十几秒里把这两段摘出来,措辞整理得挺规整。

但它不知道这一条在你们的行业里意味着什么。一个做过三年 SaaS 采购的律师,三十秒就能指出风险落在哪一方的资产负债表上。一个外行把这份摘要读三遍,只会觉得条款写得挺规范。

医疗的场景更直接,出错成本也更高。内科医生让 Agent 读一张 CT,Agent 能读片、给出随访建议供医生参考;是否随访、三个月还是六个月复查,由医生签字判断。外行看到的只是“有个阴影”,然后在两种选择之间各猜一半。

这个差别不是能力上的差距,而是责任归属上的差别。Agent 摘得出条款,但它不为这条款造成的损失负责。所以最终那一票,得由既懂行又能担责的人来投。

再看提问。指令的精度取决于你对这个领域的理解深度,这一点 Agent 帮不上忙,它只会沿着你给出的框架往下走。

外行只能提出“帮我看看这份合同有没有问题”。这个问题太大,Agent 只能回一段泛泛的清单,看起来全面,实际上没有一条能落到决策上。

内行会问“附件里约定的数据类型,和正文的跨境传输条款对得上吗”。问题一收窄,答案就具体了,能直接进谈判纪要。

两条门槛合起来,指向同一个结论。Agent 放大的是判断力,不是替代判断力。

你原本的判断力接近零,乘上十倍还是零。这句话不好听,但它决定了超级个体这条路对谁有效。

那么,到底哪些领域适合一个人做成超级个体?我们看三条标准,缺一条都不成立。

第一条,交付物是明确的。代码、合同、报表、设计稿,都能拿出来被验收。写诗不行,因为好坏没有共同标准;做战略咨询也不行,因为结论要等两年才知道对错。

第二条,有可复用的知识资产。模板、判例、SOP、检查清单,这些东西能沉淀,能被助理反复调用,下一次遇到同类问题只需要复用一次。每接一单都从零开始的领域,助理帮不上第二次。

第三条,反馈周期短。一周之内能知道对错,你就能快速修正自己的判断。

新药研发、长期投资这类领域,Agent 能加速中间环节,但整个链条一个人扛不下来。等你知道判断错的时候,钱和时间都已经沉在里面了。

三条都满足的领域不多,但每一个都不小。法律科技、财务合规、独立开发、技术写作,我们接触过的项目里,都有人靠一个人加几个助理在跑。

还有一条选法,是从你已经在做的事里挑,不要从“哪个行业热”里挑。

判断力只能从实际交付里长出来。挑一个你过去三年反复做过、被客户骂过、也被夸过的领域,比挑一个风口可靠得多。通常三年能入场,八年才成熟;风口两年换一个,判断力却要这么久才长得出来。

说到这里,“一人公司”才落得下来。它不是注册意义上的公司,也不是一个人什么都干。它是一人配三到五个助理,把一条完整业务线从头跑到尾:接单、判断、执行、验收、交付,中间不用再招人补位。

三到五个这个数量,正好盖住检索、初稿、格式转换这些可拆可验收的环节,又不至于多到自己记不住谁在干什么。

一人公司是起点,不是终点。业务线跑顺之后,复制第二、第三条线,复制的是同一套架构和同一批验收脚本,同一领域内的业务线不算三个方向。助理往上长,人从执行里退出来,去定标准、做判断、担责任。

走到这一步,一个人的产能接近一支小团队,这就是“从一人公司到数字军团”的意思。

8.4.2 设计你的工作架构:超级个体的顶层规划 ​

选定领域之后,第二件事不是马上开干,而是先给自己画一张图。

这张图叫个人工作架构。名字听着挺大,其实内容一页 A4 纸就写得完,只分四块。

第一块是能力边界。先把边界写清楚:写你会什么,也要写清楚你不会什么。我们自己的边界是能写代码、能做架构、能写技术书,不做硬件、不做芯片、不做重资产运营。

“不会什么”比“会什么”更重要。它会替你挡掉大部分不该接的活,也让你在别人递来机会的时候有个判断依据。

还有一层,是横向和纵向的搭配。以我们自己的情况来说,横向是二十年的软件开发经验,能驾驭多种语言与框架。纵向是五年的大模型落地经验,能从底层分布式调度一路做到上层架构设计。

横向决定你能接多宽,纵向决定你能扎多深。两者都不缺,你才有资格在一个细分领域里说“这个我能独立交付”。

第二块是输入,也是助理最帮不上忙的一块。一手信息从哪来,客户访谈、生产日志、代码仓库、你自己的项目现场,这些都得靠人去跑。它们是你区别于通用模型的地方。

第三块是加工。哪些环节你亲自做,哪些交给助理,这条线要划清楚。判断类的活自己做,检索、整理、初稿、格式转换交出去。

第四块是验收。交付之前用什么标准卡一遍。这一块最容易被跳过,也最不该跳过。

四个块里,最值钱的是最后一块。架构最大的用处不是提高效率,是让你能体面地拒绝那些看上去诱人、实际上会把你拖散的机会。

没有架构的人,什么活都敢接。接了三个方向,每个方向都停在半成品,离可交付还差最后一公里,一年下来没有一个能拿得出手。这是超级个体最常见的死法,原因不是能力不够,是方向太多。

这张图不是画一次就完事,它得跟着你的活一起迭代。每半年复盘一遍,边界会移动,输入源会换,验收标准也要跟着改。

我们自己的架构在过去两年改过三次。最近一次是把审校从纯人工改成脚本加人工复核,原因是脚本当前能跑完 15 项格式检查,人只需要看剩下的部分。

把这四块写下来,架构才算有了骨架。下面是本书写作的实际架构,可以直接对照。

  • 能力边界:能写代码、能做架构、能写技术书;不做硬件、不做芯片
  • 输入:项目里真实跑过的问题、代码、执行日志
  • 加工:拆章、写初稿、审校、合并,四步分工,产出可发布的章节文件与合并稿
  • 验收:standards/style_check.py,它检查段长、句长、破折号、营销腔词等 15 项,逐项给 PASS 或 FAIL

最后一条最关键。验收标准必须是可执行的验收脚本,不能是“读起来还行”这种没法判的话。

注意:验收标准只写在文档里、没有可执行脚本时,每一轮修订都只能靠感觉判断,修订永远收不了尾。

8.4.3 助理从一到十:验收从用例升级为脚本 ​

8.3.3 给过助理的最小定义:Prompt、知识、工具、验收用例,四件不变。这里要解决的不是定义,是数量。

助理从 3 个长到 30 个,第一个撑不住的是验收。

手写用例在第一个助理上够用。十条用例,每条含输入、合格判据、禁止项,你能逐条看完。到第十个助理,用例还是手写,你往往就会跳过检查,或者只挑顺眼的看。

规模上来之后要补的核心只有一件事:验收从手写用例变成验收脚本。定义不动,判据不动,动的是谁来执行。

验收脚本有两个前提。一是判据可判定,二是边界可检查。任一条不满足的,先回去改定义,不要急着写脚本。

能被执行的判据长这样:术语表里的标准译法不一致就算错,段首出现“不难看出”就算空话。这类规则既能写成脚本,也能被人复核。

写不出来的是“语言要专业”“逻辑要清晰”。这种话写了等于没写,因为没有人知道边界在哪,助理也只能靠猜。

边界里最该写清楚的是“不许做什么”。比如不许改写用户提供的原文,不许在事实不确定时自行补全,不许跨项目引用数据。

这三条边界写进去,助理的输出范围就收窄了,验收脚本也才有东西可查。边界写不清楚,后面所有的质量问题都会回到你一个人身上,助理越多,回得越快。

上面的判据都是文字类。下面这个例子换成结构类,看的是同一件事:判据能不能被脚本判定。它是一份助理的验收脚本,也是 8.3.3 那套验收用例做法的升级版,示例换成周报。环境是 Python 3.10 及以上,只用标准库,从标准输入读产物。

python
"""accept.py:校验一份周报的结构。Python 3.10+,仅标准库。"""
import json
import sys

REQUIRED = {"title", "items"}


def main() -> int:
    try:
        data = json.load(sys.stdin)
    except json.JSONDecodeError as exc:
        print(f"不是合法 JSON: {exc}")
        return 1

    if not isinstance(data, dict):
        print("顶层必须是 JSON 对象")
        return 1

    missing = REQUIRED - data.keys()
    if missing:
        print(f"缺字段: {sorted(missing)}")
        return 1

    if not isinstance(data["items"], list) or not data["items"]:
        print("items 必须是非空列表")
        return 1

    print(f"通过: {len(data['items'])} 条")
    return 0


if __name__ == "__main__":
    sys.exit(main())

跑法是两行命令,看退出码就是结论,不需要人去读输出。

bash
python3 accept.py < report.json
echo $?

写成脚本的好处是可以批量跑。三十个助理的产物,一个循环全跑完,谁不合格一目了然,比人盯着看三十遍可靠得多。

bash
for f in out/*.json; do python3 accept.py < "$f" || echo "FAIL $f"; done

关于效率提升,市面上常说助理能替你做掉九成的活。这个数字不要照抄。

按我们的项目粗估,助理能替你做掉六成到八成,还剩下两到四成是判断和担责,交不出去。这个比例只按项目任务量粗算,样本不多。比例高低还取决于岗位,越是流程化的活,越接近八成。

到第十个前后,助理本身已经不难建,难的是别把十个助理建重复。命名按“领域-动作”固定格式,同名不建第二个。登记进一张总表,写清入口、负责的活和验收脚本在哪。复制时连目录一起复制,只改输入输出,不改验收骨架。

8.4.4 把你的数字助理组织起来:构建你的个人数字军团 ​

助理超过十个,问题就变了。不再是“怎么建”,而是“怎么排”。

把助理排成队,绕不过去的是三件事:派单、超时、重派。这三件事都得在代码里看得见,缺一件,第十个助理一出现就会散架。

派单的前提是任务要有一张表。谁在做、做到哪一步、什么时候该回来,都得能查。靠脑子记十个任务,第三天往往就漏。

会话要隔离。一个助理把 Context 搞乱了,不能让它污染另一个助理。这也是本书反复强调的一条,任务要有边界,边界就是一次执行。

人不盯着的时候,卡住的任务得有人捞。这件事交给看门狗:超时先重新派一次,连续超时再标出来等人看。重派不是另一套机制,它就是超时之后的下一步。

还有一条最容易被忽略的纪律:回执。任务发出去不等于完成,得有人确认收到,并且读过结论。

回执没签收,就等于没读。发起方只能一直等,或者重复派单,两种结果都是浪费。

派单、超时、重派,加上一条回执纪律,合起来才叫编排。多开几个聊天窗口、靠人工来回复制粘贴,那叫手工,助理一多就会乱。

建数字军团的顺序也有讲究。先把一条线跑通,从派单到验收全过一遍,再复制第二条。

一上来就铺十条线,每条都卡在不同环节,你根本分不清是助理的问题还是流程的问题。先跑通一条,你至少有一个可对照的样本。

下面这段调度器把派单、超时、重派串了一遍。超时用固定值模拟,本例只演示重派和失败标记。Python 3.10 及以上,只用标准库,离线可跑。

python
"""legion.py:最小数字军团调度器。Python 3.10+,仅标准库。"""
import json
from dataclasses import dataclass

TIMEOUT, MAX_TRIES = 2, 2


@dataclass
class Assistant:
    name: str
    skills: set[str]


@dataclass
class Task:
    tid: str
    skill: str
    state: str = "pending"
    tries: int = 0
    owner: str = ""


SQUAD = [Assistant("reviewer", {"review"}), Assistant("writer", {"write", "review"})]
TASKS = [Task("t1", "review"), Task("t2", "write"), Task("t3", "review")]


def dispatch(task: Task, busy: set[str]) -> str:
    for mate in SQUAD:
        if task.skill in mate.skills and mate.name not in busy:
            busy.add(mate.name)
            return mate.name
    return ""


def run(tasks: list[Task]) -> list[dict]:
    busy: set[str] = set()
    queue, log = list(tasks), []
    while queue:
        task = queue.pop(0)
        owner = dispatch(task, busy)
        if not owner:
            task.state = "queued"
            log.append({"task": task.tid, "state": task.state})
            continue

        task.owner, task.tries = owner, task.tries + 1
        spent = TIMEOUT + 1 if task.tid == "t2" else 1   # 模拟 t2 超时
        busy.discard(owner)

        if spent > TIMEOUT:
            task.state = "timeout" if task.tries < MAX_TRIES else "failed"
            if task.state == "timeout":
                queue.append(task)
        else:
            task.state = "done"

        log.append({"task": task.tid, "owner": owner,
                    "tries": task.tries, "state": task.state})
    return log


if __name__ == "__main__":
    print(json.dumps(run(TASKS), ensure_ascii=False, indent=1))

运行结果是四条记录。t1 和 t3 分给审校助理,一次通过。t2 分给写作助理,第一次超时收回,第二次还是超时,标记失败。

整个过程中没有人插手,也没有人需要盯着屏幕。如果不加超时机制,t2 会一直挂在写作助理那里,你第二天才发现任务根本没动,而中间那十几个小时的成本已经付出去了。

代码只有几十行,真正的成本不在代码。成本在定义每个任务的“完成”长什么样,以及失败之后谁来接。

同一个小循环,放大到七十多个助理,就是下面这个规模。

我们目前的体系里跑着 19 个活跃项目、82 个已部署的节点,其中 75 个在跑(统计时点:2026 年 11 月初)。节点就是一个助理的运行实例,有的负责资料检索与竞品分析,有的做调度引擎的代码重构与测试,有的协助本书的章节写作,还有的处理日常推广和知识咨询。

这些助理不是同时开着的聊天窗口。核心业务线上的节点都有明确的任务边界、可执行的验收和超时兜底,跑砸了会被重新派单,连续失败会被标出来等人看。

一支数字军团和一堆工具的区别就在这里。工具需要你一件一件拿起来用,数字军团在你不看的时候还在跑。这才是超级个体真正的产能来源,也是 8.4 节的落点。

回到本章的题目,Agent 与“我们”。

Agent 没有让人变得不重要。它把人的位置往上挪了一层,从做事的人,变成定标准、做判断、担责任的人。门槛不在会不会用工具(工具每年都在换),而在有没有值得被放大的专业能力。这件事没有捷径,只能在一个领域里一年一年攒出来。

文字 CC BY-NC-SA 4.0 | 代码 Apache-2.0