如果你翻开这本书，多半是因为一种模糊的不安。

说不清具体在担心什么，但总觉得有什么东西正在变。朋友圈里有人在晒自己用 AI 做的图，同事开会时提到"我让模型跑了一下"，新闻里每隔几天就冒出一个新名词。"Transformer""微调""智能体"，一个比一个陌生。你隐约知道这东西重要，每次想认真了解，却被这些词挡在门外。就像推开一扇门，发现里面还有十扇门，于是关上门，继续过原来的日子。

这种不安不是你的问题。是这个领域被讲得太糟了。

打开任何一篇讲 AI 的文章，最常见的情况是：前三段还在说人话。第四段突然出现一个英文缩写，第五段出现一个公式，第六段你就合上手机了。写文章的人早就忘了自己不懂的时候是什么样子。他们不是在教你，是在向你证明他们懂。

这本书想做一件相反的事。

这本书的承诺

写这本书的出发点很简单：AI 不是魔法，是可以一层一层拆开、一步步学会的手艺。

它确实复杂。但它复杂的每一层，都能用你已有的生活经验去理解。神经网络像什么？像一层一层搭起来的筛子。大模型在做什么？像一个把接龙玩到极致的高手。为什么它会一本正经地胡说？因为它被训练成了一个宁可猜也不肯说"我不知道"的考生。

这些类比不完美，但管用。它们能让你先抓住主干，再慢慢长出枝叶。

所以这本书有三个具体的承诺：

第一，从第一个字到最后一个字，不需要任何前置知识。 不需要你会编程，不需要你懂数学，不需要你念过计算机专业。只要你会用手机，能看懂"因为所以"，就足够了。

第二，每一个术语第一次出现时，都会当场解释清楚。 不假设你查过，不假设你记得，不假设你应该知道。

第三，原理和动手交替推进。 只讲原理，你会觉得空。只讲操作，你会变成工具的操作员，工具一换就抓瞎。这本书的做法是：每讲清楚一个机制，就配一个能上手的动作。你要亲眼看到那个机制在起作用。

这本书怎么读

全书四篇，加上一个结业篇，一共 30 章。

第一篇（第 1 到 8 章）基础知识篇，回答"AI 到底是什么"。这一篇不讲操作，只讲清楚它是什么、怎么运作、能做什么、不能做什么。看起来最"慢"，但它是后面所有内容的地基。地基不牢，后面每一步都会打滑。

第二篇（第 9 到 17 章）入门实操篇，回答"怎么用它"。从第一次对话开始，到写东西、读东西、处理表格、做图做视频、辅助学习、查资料、做小工具。这一篇读完，你会成为一个熟练的使用者。

第三篇（第 18 到 24 章）进阶篇，回答"怎么把它搭起来"。你会接触到 API、成本计算、知识库、微调、智能体。还有一个多数人忽略的能力：怎么判断 AI 答得对不对。这一篇读完，你能自己造东西了。

第四篇（第 25 到 29 章）高阶篇，回答"它的门道在哪"。拆开注意力机制，看一遍大模型的完整训练流程，理解推理和部署，然后谈安全和趋势。这一篇读完，你看到新的模型和新的名词时，会有一种"我知道它在说什么"的踏实感。

第 30 章是结业篇，给你一份 30 天的学习路线图。不是鼓励你学 30 天就毕业，而是给你一个具体到每天做什么的启动方案。人在面对庞大知识体系时最难的不是学习，是决定今天该学什么。

你可以从头读，也可以跳着读。但如果你是零基础，我建议至少把第一篇完整读完再跳到第二篇。跳过第一篇直接学操作，你会用得很熟练。但你也会在第一次遇到"AI 胡说八道"时彻底懵掉，因为你不知道它为什么会这样。

关于时间的说明

这本书动笔于 2026 年 10 月。

这个时间点需要写清楚，因为 AI 领域有个残酷的特点：变化太快。

2026 年曾经出现过一个月之内扎堆发布九款旗舰模型的情况。行业里流行一句话，"最强模型的保质期正在缩短"。一本靠比较模型强弱来体现价值的书，写出来就已经开始过时了。

所以这本书做了一件刻意的事：凡是会过期的内容，都只当作例子。凡是不会过期的内容，才当作结论。

具体来说：

• 具体的模型名称、工具名称、价格数字、版本号，都以 2026 年 10 月为准。它们是例子，用来说明方法，不是让你记住的名字。
• 模型为什么会幻觉、检索增强生成为什么有效、测试集怎么设计，这些都是方法。方法不会因为换了一代模型就失效。
• 涉及价格、政策、法规、产品功能的地方，我都会提醒你"以官方最新信息为准"。这不是免责声明，是这个领域的基本素养。
• 正文里引用的外部研究数字，都在句末标了出处；书末的附录 A 把它们按机构归了档，写清了每个数字对应哪几章，方便你回查和更新。

如果你在两年后读这本书，会发现例子过时了，但方法依然管用。这正是我想要的。

最后一句

这本书里有五个普通人，会反复出现在不同的章节里。

陈默，32 岁，行政主管，不懂技术，最担心的是"用不上新工具，被慢慢边缘化"。

林晓青，28 岁，中学语文老师，每天和几十份作文、教案打交道。

赵砚，45 岁，做外贸，公司二十来号人，什么都要自己扛。

苏芮，24 岁，做新媒体运营，手上永远有五件事在并行。

何宇，35 岁，财务经理，天天和表格、口径、报表较劲。

他们的年纪、行业、卡住的地方都不一样。但处境差不多：知道这东西重要，不知道从哪儿下手。你大概能在其中某个人身上，看到自己。

每讲一个方法，我都会先让他们去撞一次墙。你跟着他们撞完，再回头看那些概念，会容易得多。

那么，从第 1 章开始。

陈默第一次对 AI 产生兴趣，是因为一次很难堪的会议。

那是 2024 年秋天，公司开年度规划会。市场部的小姑娘在投影上放了一张图，说这部分视觉素材是"用 AI 生成的"，前后花了二十分钟。会议室里一片惊叹。陈默坐在角落，心里想的却是另一个问题：她是怎么做到的？

散会之后他回到工位，在搜索框里输入"AI 怎么用"。搜索结果第一页，全是看不懂的标题：《Transformer 架构详解》《大模型微调实战》《从零实现一个注意力机制》。

他关掉页面，决定过两天再说。这一过，就是两年。

陈默的问题不在于他笨。他的问题在于，他打开的第一扇门，门后面是术语墙。而所有人都在往墙上敲钉子，没有一个人告诉他：这堵墙到底是干什么用的。

这一章要做的事，就是先带你绕过那堵墙，从外面看一眼整栋建筑。

三个几乎所有人都有的误解

在讲 AI 是什么之前，我想先讲它不是什么。

因为多数人卡住，不是因为学得不够，而是因为一开始就拿错了比喻。

误解一：AI 是一个"大脑"

我们习惯把 AI 叫作"电脑"，把它的能力叫作"智能"。于是很自然地想象：它的内部应该有一个大脑一样的结构，会思考、会理解、会产生想法。

这个比喻误导性极强。

真实情况是：AI 内部没有理解，只有计算。 它不做"理解"这件事，它做的是"根据看到的规律，算出最可能的下一个结果"。

举个具体到不能再具体的例子。你给 AI 一张猫的照片，让它判断这是不是猫。它的内部不会出现"猫"这个概念。它做的是：把这张图变成一大堆数字。然后拿这些数字去和它见过的无数张图对应的数字做比较，最后输出一个概率。比如"是猫的可能性 97.3%"。

它没有"看到"猫。它算出了一个数。

这个区别听着像抠字眼，但它决定了后面所有事情。因为一旦你接受了"它只是在算"，那么它为什么会犯错、为什么会胡说、为什么有时候强得吓人有时候蠢得离谱，就全都讲得通了。

如果真的有一个会思考的大脑在里面，它犯那些错反而没法解释。

误解二：AI 会"思考"

2026 年，市面上的模型普遍有了"推理模式"，你按下按钮。它会先输出一段"思考过程"，看上去像在草稿纸上演算，然后给出答案。

这个设计给人一种强烈的印象：它在想。

但那段"思考过程"本身，也是被算出来的。它是模型生成的另一段文字，只不过这段文字的内容恰好是关于"我该怎么解题"。它和它生成的答案没有本质区别，都是"预测下一个最可能的词"的产物。

我这么说不是要贬低它。恰恰相反，这种"假装思考"的效果好得惊人，在很多任务上，让模型先写一段推理过程，结果确实更准。原因也很朴素：把中间步骤写出来，相当于给它多留了计算空间，减少了"一步到位"时的猜测成分。

但你要记住这个区别：它看起来在想，和它真的在想，是两件事。 这个区别在你需要判断它是否可靠时，很关键。

误解三：AI 什么都懂，只是偶尔出错

这是最贵的一个误解。

很多人第一次用 AI，会经历一个"哇"的阶段：写邮件能写、写代码能写、问历史能答、算数能算。感觉像雇了一个什么都懂的助手。

然后某一天，它在某个你恰好很熟的问题上，给了你一个完全错误、但说起来头头是道的答案。你愣住了。

多数人的第一反应是：它是不是坏了？或者：我是不是问的方式不对？

都不对。真相是：它从来都是这样，只是你之前问的问题，恰好落在它擅长的区域。

2026 年的研究数据显示，同一个模型在不同类型问题上的出错率相差可达 5 到 15 倍。问"北京是哪个国家的首都"这种高频问题，出错率大约 1% 到 3%。问"某位不太知名的学者在哪一年发表了哪篇论文"这种冷门问题，出错率能到 15% 到 40%。问一件发生在它训练数据截止之后的事，出错率可以超过 30%。 来源：2026 年幻觉率分布研究

它一直有这个毛病。只是你第一次遇到它犯错的位置，正好是你熟悉的领域。

那么，AI 到底是什么

绕完了三个圈，现在可以正面回答了。

AI 本质上是一台极其擅长"找规律"的机器。

这句话看着简单，但它是理解一切的地基。

想象你小时候学认字。老师给你看了三百遍"人"这个字，然后你在街上看到一个新写的"人"，你认出来了。你没有记住那三百个具体的"人"字。你从里面提取出了一个抽象的"人之所以是人的形状规律"。

AI 做的事情，形式上是同一件事，只是规模大到你没法想象。

它看过的不是三百个"人"字，而是互联网上几乎所有能找到的文字、图片和声音。它从这些东西里提取出的不是一条规律，而是上千亿个数字。每个数字记录着某种极细微的规律片段。这些数字放在一起，就构成了一个"模型"。

这个词你需要记住，它是后面所有内容的中心：模型（model），指的是从大量数据里提取出来的那一大堆规律的数字表示。

它不是一个程序，不是一本手册，也不是一个数据库。它是一堆数字。这堆数字经过巧妙的组织，使得你输入一个新东西时，它能算出一个合理的输出。

输入，计算，输出。就这么三步。

三样东西，缺一不可

一个 AI 能不能成，取决于三样东西是否同时具备。这三样东西称为 AI 的三要素，你可以把它们当成三个需要同时拧开的开关。

第一样：数据。

规律藏在数据里，没有数据就没有规律可提取。这就是为什么做 AI 的公司都在疯狂收集数据。数据不够、数据质量差、数据有偏见，最后得到的模型就多半有缺陷。

有个数字很能说明问题的严重性：研究发现，当训练数据中只有万分之一的虚假文本时，模型输出的有害内容就会增加 11.2%。万分之一看起来微不足道，但它会在模型内部被放大。 来源：2026 年数据投毒研究

第二样：算法。

算法是"怎么从数据里提取规律"的方法。同样一堆数据，用不同的算法去处理，得到的效果可能天差地别。

你不用记住任何具体算法的名字。你只需要知道：过去十几年 AI 的每一次飞跃，本质上都是有人找到了一种更好的"提取规律的方法"。

第三样：算力。

算力是硬件提供的计算能力。提取规律需要海量的计算，算力不够，再好的算法也跑不起来。

有一个形象的对比：训练早期的大模型，需要成千上万块专用芯片连续运转几十天。电费、硬件、维护，成本以千万美元计。这也解释了为什么全球能独立训练前沿大模型的公司数量一直很少。

三样东西的关系可以这样理解：数据是原料，算法是工艺，算力是工厂。 缺任何一个，都做不出产品。

对普通学习者来说，这三样你一样都不需要拥有。你只需要知道它们存在，因为当新闻里说"某公司发布了新模型"时，真实含义通常是"有人在三样里的一样上取得了突破"。

一个完整的例子，从输入到输出

抽象的话说完了，我们走一遍完整流程。

假设你问 AI 一个问题："为什么天空是蓝色的？"

第一步，你的问题被拆成小块。 模型不认识"句子"，它只认识"词元"（token），可以粗略理解为被切碎的文字碎片。你这句话会被切成若干个词元。

第二步，每个词元被转换成数字。 因为模型只会算术，所有文字都要先变成数字才能运算。

第三步，这些数字在模型内部经过层层计算。 这就是那一大堆参数发挥作用的地方。每一个参数都在参与运算，共同决定最终结果。这个过程极其复杂，但它不带任何"思考"的成分，纯粹是数学运算。

第四步，模型算出下一个最可能出现的词元。 注意，它一次只算一个。它算出"因为"，然后把"因为"接到你问题的后面，重新算下一个，算出"阳光"，再接上，再算……

第五步，循环几百次，直到它算出"结束"。

最后呈现给你的，是一段完整流畅的解释。但它的产生过程，是几百次"猜下一个字"，一次一个。

这就是大语言模型（LLM，Large Language Model）的全部秘密。你后面会看到，这个"每次只猜下一个"的机制，既能解释它为什么强，也能解释它为什么错。

边界与坑

讲到这里，我要提醒三件事，因为它们决定了你后面会不会走弯路。

第一，不要拿"人"的标准去期待它。

它不需要理解就能给出有用的答案，这一点很像一个见多识广但从不深究的顾问。它能帮你干活，但你不能指望它"懂"。当你需要它承担判断、责任和后果时，这个区别就变得极其重要。

第二，不要因为它犯错就否定它的价值。

见过太多人，第一次被 AI 误导之后就再也不用了。这相当于因为一次导航出错就永远不开车。正确的做法是搞清楚它错在哪里、什么情况下容易错。然后用别的手段补上，这正是第 6 章和第 16 章要讲的。

第三，不要试图先学完理论再动手。

AI 这个领域的理论深度，足够你学十年。而它有价值的部分，你两周就能用起来。第 1 到第 8 章讲的是必要的认知地基，这个地基不厚，但要打。打完就动手，别在原地把理论背熟再出发。

三道自测题

在往下读之前，先做三道题。它们能帮你判断自己是不是带着误解在读这本书。

第一题：你对 AI 说"我下周三下午三点要开个会，帮我记着"。它回复"好的，已为您记录"。第二天你再问"我下周有什么安排"，它说"您没有安排任何会议"。

请问：这算不算它"忘了"？

答案：不算。它从来没有"记"过。它第一次回复"已为您记录"也是生成出来的，那个回答只是最像话的一句。它内部的那排旋钮一动都没动。

这件事的通用教训是：它说"我记住了"不等于它记住了。 只有当你所用的产品明确提供了跨对话的持久化存储功能时，"记住"才成立。第 5 章的"上下文窗口"和第 20 章的 RAG，讲的都是这件事。

第二题：你问它"2024 年诺贝尔文学奖得主是谁"，它答对了。你接着问"这位作家最不为人知的一本早期作品是什么"，它给了一个书名和一段简介。

请问：这两次回答的可信度一样吗？

答案：完全不一样。第一个问题是被无数资料反复提到的高频事实。第二个问题几乎没人提过，那本书名和简介很可能是它编的。

这道题要你记住的是：同一个模型、同一次对话、同一个语气，可信度可以相差十几倍。 判断标准不是"它说得像不像"，而是"这件事有多少人说过"。

第三题：你让它"帮我从这份合同里找出所有对我方不利的条款，一条都别漏"。

请问：这个要求里有什么问题？

答案：问题在"一条都别漏"。这是一个"完整性"要求，而它没有能力保证完整性。它只能根据看到的内容，生成一段"最像完整清单"的文字。

正确的做法是把大目标拆开：先让它列出合同的主要条款结构。你自己看一遍；再逐条让它分析。或者用第 12 章那套"要求标注原文位置"的方法，通过抽查来验证它有没有漏。

这三道题的共同点：都在让"人的期待"和"机器的机制"对上号。你对它期待得越像人，越容易失望；你越清楚它是一台算概率的机器，越能用好它。

一段真实对话的完整剖析

最后做一件事：把一段最普通的对话拆开，看每一层发生了什么。

你说："帮我写一封给客户的道歉信，货发晚了。"

它开始工作。

第一步，它把你的话切成词元。 这句话大概被切成十几个碎片。

第二步，每个词元变成数字。 它不认识"道歉"这两个字，它认识的是代表"道歉"这个意思的一串数字。

第三步，这些数字在几十层网络里层层计算。 每一层都在处理关系：这个词和那个词有多相关、这个句子的语气偏正式还是偏随意、这类场景通常包含哪些要素。

第四步，它开始猜第一个字。 在它见过的大量道歉信里，开头出现频率最高的是什么？可能是"尊敬的"。

第五步，接上，再猜。 "尊敬的"后面最可能接什么？"客户""某某先生"……它选一个。

第六步，几百次循环之后，一封道歉信出现了。

你在读这封信时，大脑会自动做几件事：判断语气合不合适、检查有没有漏掉关键信息（没说明延迟原因）。感受它有没有过度道歉。

而它做这些事的时候，全部依据只有一条：我见过的大量"道歉信"通常长什么样。

所以如果你想让它写得更好，唯一的办法就是给它更多、更具体的线索：这个客户合作几年了、延迟的原因是什么、我们打算怎么补偿、语气要诚恳到什么程度。

"给它线索"这件事，就是你后面 20 多章要学的主要技能。 它有一个专门的名字，叫提示词，我们到第 9 章正式展开。

本章收束

三句话记住这一章：

AI 不是会思考的大脑，是一台极其擅长找规律的机器。 它做的事只有三步：输入、计算、输出。每次只猜下一个字。 它不需要理解就能帮到你，也因此多半会在你没设防的地方出错。

陈默在两年前关掉了那扇门。这一章帮他重新打开了一条缝，他终于知道，那堵术语墙后面不是更深的迷宫。而是一套可以用生活经验理解的机制。

下一章要回答一个更根本的问题：机器究竟是怎么"学会"的？它凭什么能从一堆数据里，长出规律来？

陈默教过他女儿骑自行车。

过程是这样的：他扶着后座跑，孩子在前面摇摇晃晃，车把一晃。他喊一句"看前面别看脚"。摔了三四次，到第五次，孩子突然就骑出去了。

事后陈默想起这件事，觉得有点神奇。他没有告诉孩子任何一条"骑车公式"，没有讲解过平衡的力学原理，甚至自己也说不清到底怎么保持平衡。孩子就是摔了、调了、再摔、再调，最后自己摸到了那个感觉。

现在把这件事换到机器身上。

假设你给一台机器看一万张照片，每张都标好"这是猫"或"这不是猫"。看完之后，它自己就学会认猫了。没有人告诉它猫有什么特征，没有告诉它猫有尖耳朵、有胡须、有四条腿。

这很像教孩子骑车。你不讲原理，只给反馈。它自己从反馈里摸出规律。

这个过程，就叫训练（training）。

这一章要讲清楚的就是：训练到底发生了什么。理解了它，你会发现 AI 身上很多"奇怪"的行为，其实一点都不奇怪。

"学习"这个词，在机器里是什么意思

先说清楚一个容易混淆的地方。

人类说"学习"，包含理解、记忆、举一反三、甚至创造性联想。机器说的"学习"，只包含其中一件事：根据反馈调整自己内部的数字。

就这一件事。没有别的。

机器内部的那些数字，前面说过，叫参数。你可以把参数想象成一排排的旋钮。一台刚出厂的机器，这些旋钮都是随机位置，此时它什么都不会，给它一张猫的照片。它给出的答案是随机的。

训练要做的，就是一个一个地拧这些旋钮，直到它给出的答案越来越接近正确。

怎么知道该往哪个方向拧？靠对比。

具体流程是这样：

1. 给它一张照片，让它猜。
2. 它猜"是狗"。但正确答案是"猫"。
3. 系统计算一下"错得有多远"，得到一个数值。这个数值叫损失（loss）。
4. 根据这个数值，系统往回推算：如果要让损失变小，每个旋钮应该往哪边拧、拧多少。
5. 拧一点点。
6. 换下一张照片，重复上面五步。

一万张照片看完，就是拧了一万次。看完十轮，就是十万次。

到最后，这台机器给出的答案已经相当准了。它内部的旋钮已经被调到了一个"能正确识别猫"的位置组合。这组位置，就是模型。

一个能看懂的完整例子

抽象的描述容易飘，我们换一个更简单的任务：判断一封邮件是不是垃圾邮件。

假设我们要教机器做这件事。

第一步，准备好一批已经标注好的邮件。 十万封邮件，每封都被人工标了"是垃圾"或"不是垃圾"。这批带标注的数据叫训练数据。

第二步，决定让机器看什么。 一封邮件里信息很多，正文、标题、发件人、时间、有没有附件。我们挑几个可能和垃圾邮件相关的线索，比如：

• 标题里有没有"限时""免费""中奖"这类词
• 正文里有多少个链接
• 发件人是不是第一次出现
• 邮件有多长

这些被挑出来的线索，叫特征（feature）。这一步是人工做的，它决定了机器能学到什么。特征选得不好，后面再努力也白搭。

第三步，给每个特征配一个初始权重。 比如一开始我们瞎猜："标题有'免费'加 1 分，链接超过 5 个加 2 分。"这就是最初的旋钮位置。

第四步，开始训练。 拿第一封邮件，算出总分。假设总分是 3 分，我们定的规则是"超过 5 分算垃圾"。这封邮件实际是垃圾邮件，但我们算出来只有 3 分，判错了。于是系统调整权重：把"标题有免费"这个特征的分数从 1 调到 1.3。

第五步，换下一封，重复。

十万封邮件过完一轮，权重被调整了十万次。再过几轮，这套权重就能相当准确地判断垃圾邮件了。

注意这个过程里最关键的一点：没有人告诉机器"限时免费中奖这类词是垃圾邮件特征"。 是我们人类选了"标题里有没有这些词"作为特征，但"这些词加多少分"完全是机器自己算出来的。

人类负责提供原料和框架，机器负责找出规律。这就是分工。

训练和"用"是两回事

这里有个概念需要分清楚，因为后面会反复用到。

训练，是调整参数的过程。它慢、贵、需要大量数据和算力。你可能要花几天甚至几个月。

推理（inference），是训练完成之后，拿新的输入去用它。它快、便宜、随时可以做。你每次和 AI 对话，发生的都是推理。

这两个词的区别，可以这样理解：训练像是厨师研发新菜谱的过程，反复试做、反复调味，可能花几个月。推理像是菜谱定稿之后，客人点一份菜，厨房照着做一份。前者是一次性的，后者是每天无数次的。

微调（fine-tuning） 是介于两者之间的第三种事。它是在一个已经训练好的模型上，用少量数据再做一轮小的训练。我们到第 22 章再展开。

对普通用户来说，你永远在做推理。你使用的每一个 AI 产品，它背后的模型早就训练完了。

三件容易被忽视的事

第一件：数据决定了上限

有个说法在 AI 圈里流传很广："垃圾进，垃圾出。"

意思是，如果训练数据有问题，模型多半会有问题。而训练数据的问题有两种，都很常见。

一种是标注错误。人工标注难免出错，如果十万封邮件里有三千封标错了，模型就会学到错误的规律。

另一种是数据偏见。如果历史上某类邮件被大量标记为垃圾，模型可能会把这类邮件本身（而不是它的内容）当作垃圾特征。它会忠实反映数据里的偏见，而不是纠正它。

这就是为什么数据质量在 AI 行业里被看得那么重。有个数字前面提过：训练数据中只有万分之一的虚假文本时，模型输出的有害内容就会增加 11.2%。万分之一，会被放大成百分之十一。 来源：2026 年数据投毒研究

第二件：模型会"背答案"

这是初学者最容易忽略的一个坑：过拟合（overfitting）。

想象一个学生准备考试。他不去理解原理，而是把练习册上每一道题的答案都背下来。如果考试题目和练习册一模一样，他能考满分。但题目稍微变一下，他就完全不会了。

模型也会这样。如果训练数据太少，或者训练得太久，模型会开始"背下"训练数据的细节，而不是"学到"其中的规律。它在训练数据上表现完美，遇到新数据就一塌糊涂。

判断一个模型好坏，看的从来不是它在训练数据上的表现。而是它在没见过的新数据上的表现。这个新数据叫测试数据。

这个原理对你也有直接用处。第 24 章你会学到，怎么给自己设计一个小测试集，用来验证 AI 在你的场景里到底靠不靠谱。那个方法的理论基础，就是这一条。

第三件：模型的"能力上限"是存在的

有一条很实用的认知：任何模型能表达的关系复杂度，都是有上限的。

打个比方。假设你手里只有一把笔直的尺子刀，现在桌上有一条弯曲的分界线，要把两堆点分开。不管你把这把刀怎么摆，总有一块会切错。这不是你不够努力，是工具的形态决定的。

解决的办法是换更强的工具，或者用好几把刀拼出折线。在神经网络的语境里，"更强的工具"就是更深的网络、更多的层。这是第 3 章的内容。

这个比方还能解释另一件事：为什么把模型做得更大通常更有效。更大的模型相当于允许使用更复杂的工具去贴合真实世界的复杂关系。

但请注意"通常"这两个字。更大不等于更好，还要看数据够不够、训练方法对不对。后面你会看到，2026 年有相当多的模型在用极小的参数量接近大模型的效果，靠的是训练方法和数据质量的改进。

边界与坑

第一，不要以为"训练"就是"喂资料"。

很多人以为给 AI 传一堆文件，它就"学会"了这些文件的内容。不是的。你上传文件让它读，只是让它在这一轮对话里能看到这些文字（这叫上下文），对话结束就没了。它内部那排旋钮一点都没变。

要让它真的"记住"，需要微调或者检索增强生成，那是后面第 20 到 22 章的内容。这个区别非常关键，很多人在这里绕了很久。

第二，不要被"模型"这个词骗了。

中文里"模型"听起来像一个实物。实际上它就是一堆数字文件。它可以复制、可以压缩、可以裁剪大小，也可以被量化（把每个数字存得更粗糙一点，换来更快的速度）。第 27 章会讲这些。

第三，别急着理解数学。

这一章完全没有出现公式，后面的章节也尽量不会。原因很简单：理解"旋钮往哪边拧"这件事，不需要知道拧的公式是什么。你要的是判断力，不是计算力。

如果你确实想深挖，第 25 和 26 章会给你一个更扎实的入口。

一个完整的训练过程推演

前面讲得比较抽象，这里用一个更具体、更有画面感的例子把整件事串一遍：让机器学会认手写的数字。

任务：给一张手写数字的图片，判断它是 0 到 9 里的哪一个。

准备阶段。

先收集几万张手写数字的图片，每一张都由人标注好"这是 7""这是 3"。这批带标注的图片就是训练数据。

开始训练。

第一轮，第一张图。

系统拿到的是一张写着"7"的图。对机器来说，这是一堆像素点的亮度数字，假设是 28×28 个小格子。每个格子一个数字，一共 784 个数字。

它把这些数字送进网络。网络经过层层计算，输出 10 个数字，分别代表"这张图是 0 的概率""是 1 的概率"……由于旋钮还是随机位置，它给出的结果可能完全是乱的：它说"这是 3 的概率最高"。

错了。

系统算出误差：它认为这是 3 的概率很高，但正确答案是 7。误差不小。

然后它往回推算：如果想让这个误差变小，每个旋钮应该往哪边拧一点点？

注意，这个"往回推算"是整套方法里最巧的一步。因为网络有几十层、几百万个旋钮，从结果倒推每个旋钮该怎么调，本来是个难到几乎无解的问题。上世纪八十年代有一个方法解决了它，让整个过程变得可以计算。你不必知道这个方法的数学，只需要知道：它是可行的，而且是自动的。

一次微调。

按照算出来的方向，所有旋钮各拧一点点。拧的幅度很小，小到几乎不影响其他图片的判断。这是刻意的，如果一次拧太多，之前学会的东西就会被推翻。

第一轮，第二张图。 重复上面的过程。

第一轮，第三万张图。 重复了三万次。

第二轮。 把这三万张图再过一遍。此时它的判断已经比第一轮准多了，但还没到能用。

第十轮。 三万张图过了十遍，也就是调了三十万次旋钮。

这时候，给它一张它从没见过的手写数字图，它大部分都能认对。

训练完成。

现在回头看，有三件事值得琢磨。

第一，从头到尾，没有任何人告诉它"7 应该有一条横线加一条斜线"。 它自己从三万张图里摸出了"7 长什么样"这个规律。这些规律就藏在那些旋钮的最终位置里。

第二，它没见过的那张图，它也能认出来。 这是这一章所有内容里最关键的一点。它不是背下了这三万张图，而是提取出了"数字形状"这个更本质的东西。能处理没见过的输入，才叫"学会了"。

第三，如果训练数据里全是印刷体的数字，拿一张手写歪斜的给它，它就会懵。 这不是它变笨了，是它学到的是"印刷体数字的规律"，而不是"数字的规律"。

这条推论对你很实用：当你发现 AI 在某类任务上表现很差时，先问一句"这类情况是不是超出了它见过的范围"。答案往往是肯定的。

过拟合的直观演示

第 2 章正文提到过"背答案"的问题，这里用一个更好懂的方式再看一遍。

假设你要训练一个模型，判断"这份简历值不值得面试"。你手上有 20 份简历样本，其中 10 份最终被录用了。

正常的情况：模型从这 20 份里学到一些普遍规律。比如"有相关项目经验的更容易被录用""工作年限太短的可能被淘汰"。然后给它 100 份新简历，它也能给出不错的判断。

过拟合的情况：模型学到的不是规律，而是这 20 份的具体特征。比如"名字以张开头的必然被录用""简历里出现过'第三份实习'这句话的必然被淘汰"。

在训练数据上，它 100% 正确。因为它是"背"下来的。

但给它一份新简历，它给出的判断就接近随机。

怎么发现过拟合？

答案很直接：准备两批数据。

一批用来训练，叫训练数据。另一批从来没让模型见过，只用来检验，叫测试数据。

如果模型在训练数据上准确率 99%，在测试数据上只有 60%，那就说明它在背答案。

这个方法背后的道理很朴素：一个真正的学习成果，应该能应付陌生的题目。只能应付见过的题目，那不叫学会，那叫背会。

这个道理可以直接用在你自己身上。

第 24 章会教你给自己搭一个测试集，用来检验 AI 在你的场景里到底行不行。那个方法的理论依据，就是这一节的内容：不要用做过的题来检验水平。

还有一个更实用的推论：你在和 AI 对话时，不要用"我又试了三个我已经试过的问题，它都答对了"来判断它可靠。 要去试那些你还没试过、而且你不熟悉的问题。那里才藏着真正的答案。

本章收束

三句话：

机器学习的本质，是根据反馈反复微调内部的一排数字。人类提供数据和框架，机器找出规律。 训练是调参数，推理是用参数。你日常用的永远是推理。 模型会背答案（过拟合），也有能力上限。判断它好不好，要看它在没见过的新数据上的表现。

陈默到这里算是迈过了第一道门槛。他不再觉得 AI 神秘了，但也冒出了一个新问题：那些"层层叠起来的结构"到底是什么？

第 3 章，我们拆开它的内部看一看。

小时候玩过一个游戏，叫传话。

一排人站好，第一个人对着第二个人耳朵说一句话，第二个人传给第三个人，一路传到最后。通常最后那个人说出来的，和第一句话已经差了十万八千里。

传话游戏之所以会失真，是因为每一环都只保留了上一环的一部分信息。

有意思的是，神经网络的结构和它有点像，但目的完全相反：它不是靠链条把信息传过去，而是靠一层一层的加工，把信息提炼得越来越清楚。

这一章要看的就是这个结构。

从一个最小的零件开始

神经网络这个名字听着唬人，像是要讲脑科学。其实它的基本零件简单到可以画在一张纸上。

这个零件叫神经元（neuron）。虽然名字借用了生物学的词，但它的行为完全是一道算术题。

一个神经元做的事，分三步：

第一步，收。 它接收若干个输入数字。比如三个输入：0.8、0.3、0.5。

第二步，算。 每个输入乘以一个对应的权重，然后全部加起来。假设权重分别是 2、1、0.5，那么算出来是：

0.8 × 2 + 0.3 × 1 + 0.5 × 0.5 = 1.6 + 0.3 + 0.25 = 2.15

第三步，判。 把这个数和一个门槛比较。如果超过了门槛，就输出一个"激活"的信号（比如 1）；没超过，就输出"不激活"（比如 0）。

就这样。三步，全是加减乘除。

你可以把这个神经元想象成一个很死板的评委。它手里有三个评分项，每项有自己的权重。选手的表现乘上权重加起来，超过它的心理门槛，它就投赞成票。

单个神经元能干的事很少。它能回答的问题，本质上只有"这几个数加起来够不够大"。

但只要有几千亿个这样的评委，并且把它们按层级组织起来，事情就不一样了。

从一层到多层

先把一层讲清楚。

一层（layer），就是很多个神经元并排工作。它们看的是同一个输入，但各自带着不同的权重。

这就像一场评审会。你交上去一份材料，五个评委同时看。一个死死盯住"内容质量"这项，另一个只关心"新颖程度"，第三个对"可读性"敏感。五个评委各自打分，最后你拿到五个数。

这一层的输出，会成为下一层的输入。

于是就有了多层。

多层之所以厉害，是因为它能做到一件单个神经元做不到的事：逐级抽象。

拿识别猫的照片举例。一张照片对机器来说，是一大堆像素点的亮度值，可能是几百万个数字。直接让一层神经元从这几百万个数字里判断"这是不是猫"，几乎不可能。

但分层之后，事情变得可行：

底层看的是相邻像素之间的明暗变化，提取出"边缘"。这时候模型看到的是短线段和明暗交界。

中间层把边缘组合起来，提取出"形状"，圆弧、尖角、条纹。这时候模型看到的是局部图案。

更上层把形状组合起来，提取出"部件"，一只耳朵、一个鼻子、一只眼睛。

最上层把部件组合起来，判断"这构成一只猫吗"。

注意关键点：没有任何一层被明确告知该干什么。 是训练过程自己调出了这种分工。这一点经常让人惊讶，原来"从边缘到形状到部件"这个层次结构，不是人类设计的，是数据自然逼出来的。

为什么"深"有用

现在回到第 2 章留下的那个比喻。

我说过，如果你只有一把笔直的尺子刀，去切一条弯曲的分界线，总有一块会切错。

但如果你允许自己用两把刀呢？你可以把两条刀痕拼起来，形成一条折线。折线能比一条直线更贴近曲线。

三把刀、四把刀、一百把刀呢？每一把负责一小段，拼起来就能非常贴近那条曲线。

加深网络层数，本质上就是在增加"折线可以有多少个折点"。

这解释了"深度"这个词的来历，深度学习（deep learning），"深度"指的就是层数多。早期只能用一两层，现在动辄几十层、上百层。能表达的规律复杂度，差距是巨大的。

训练的时候，到底在调什么

第 2 章说过，训练是拧旋钮。现在可以具体一点了：被拧的旋钮，就是每个神经元里那些权重。

一个模型里有多少旋钮？

以 2026 年的主流大语言模型为例，参数量普遍在几百亿到几千亿这个量级。也就是说，有几百亿到几千亿个数字在同时参与计算。

这个数字很难有实感。换算一下：如果每个参数打印出来占一个字节，一千亿个参数量大约是 100GB 的纯文本。你的手机存不下。

但请注意一个反直觉的事实：这么多参数，并不意味着模型"记住了"那么多内容。

它是把海量的语言规律，高度压缩在了这些数字的相对关系里。就像一张 JPEG 图片能压到原图十分之一大小，还看起来差不多。因为压缩算法抓住了"哪些信息是冗余的"。

模型也是这么干的。它没记住原文，它记住了产生原文的那个规律。

边界与坑

第一，"神经网络"这个词和大脑关系不大。

它的灵感确实来自神经元，但也只是最初的灵感。今天的神经网络和真实的生物大脑相差极远。不要因为名字相似，就以为它像人脑一样工作。

第二，没人能完整解释它为什么有效。

这是个真实存在的问题，不是我在回避。一个训练好的模型里，几十亿个参数各司其职。但没有任何人能说清楚"第 3721 层的第 408 个参数负责什么"。这在专业上叫可解释性（interpretability）问题。

它带来一个实际后果：当模型出错时，你通常无法从内部找到原因。你只能从外部观察，什么输入会导致什么错误。这也正是第 24 章要教你做测试集的原因。

第三，层数不是越多越好。

层数太多会带来两个问题：一是训练变难（信号在层层传递中容易衰减或爆炸），二是过拟合风险上升（回到第 2 章那个背答案的学生）。所以真实的模型架构里，有大量技巧用来解决"怎么让深层网络训练得动"这个问题。

第四，你不需要学会搭神经网络。

这一章的目的不是让你会写代码搭网络。是让你理解：当你看到一个模型有"很多参数""很多层"时，它到底在说什么。以及当你看到"某模型参数量更小但效果接近"时，你能明白那意味着训练方法和数据质量有了突破。

手工算一个神经元

前面那个"评委"的例子太快了，这里放慢速度，完整算一遍。

假设我们要判断"这个人值不值得推荐他去面试"。

第一步，确定看哪几项。

我们挑三个输入：

• 工作年限（归一化后是 0.7）
• 项目经验（归一化后是 0.9）
• 学历背景（归一化后是 0.4）

"归一化"的意思是把它换算成 0 到 1 之间的数，方便计算。你不用管具体怎么换算，只要知道每个输入都是一个 0 到 1 的数字。

第二步，给每项配一个权重。

假设权重是：

• 工作年限：2.0
• 项目经验：3.0
• 学历背景：1.0

权重的意思就是"这件事有多重要"。项目经验权重最高，说明我们最看重它。

第三步，乘起来加总。

0.7 × 2.0 = 1.4 0.9 × 3.0 = 2.7 0.4 × 1.0 = 0.4

加起来：1.4 + 2.7 + 0.4 = 4.5

第四步，和门槛比较。

假设门槛是 3.0。4.5 超过了门槛，所以这个神经元"激活"了，输出一个信号。

这就是一个神经元的全部运算。 三步：乘、加、比。

现在关键问题来了：那三个权重（2.0、3.0、1.0）是怎么来的？

是训练出来的。一开始它们可能是随机的，比如 0.5、0.3、0.8。第一轮判断错误之后，系统会算出"如果项目经验的权重再高一点，结果会更接近正确答案"，于是把它往上调。

调了几百万次之后，权重稳定在一个"能做出准确判断"的位置。

所以权重不是人类设计的，是人类提供了数据和目标，让机器自己找出来的。 这是第 2 章那句话的具体呈现。

再补一句：真实网络里的神经元，输入不是 3 个，可能是几千个；权重不是 3 个，是几千个；神经元数量不是 1 个，是几十万个。

但每一个做的事情，和上面那四步一模一样。 规模很大，原理很朴素。

"加深层数"到底改变了什么

这一节帮你不靠数学就建立"深度有用"的直觉。

回到那个比喻：用直尺刀去切一条弯曲的分界线。

一层的情况：你只有一把直刀。不管怎么摆，你最多只能画出一条直线。曲线弯得厉害的地方，必然切错。

两层的情况：第一层先切一刀，把数据分成两块。第二层在每一块里再各切一刀。合起来，你画的是一条折线，有两个折点。

三层的情况：最多四个折点。

每加一层，可能的折点就翻一倍。

十层就是上千个折点。上千个折点拼出来的折线，已经能非常贴近一条平滑的曲线了。

这就是"深"的价值：它能表达的关系复杂度，随着层数指数级增长。

现在把这个结论翻译成实际意义。

浅的网络能表达的关系很有限，比如"这几个特征加起来够不够大"。

深的网络能表达很复杂的关系，比如"如果是工作日且用户是新用户且最近三天没有访问，那么推荐 A；否则如果……"

世界上真正有用的问题，几乎都是后一种。 识别一张脸、理解一句话、判断一份报告的质量，这些关系复杂到无法用简单规则描述。

所以深度学习之所以叫"深度"，是因为它需要深，才能表达世界的复杂度。

但这里有一个重要的提醒：深不是免费的。

层数越深，两个问题越明显。

第一，训练更难。 信号从最底层传到最顶层，再传回来，中间的加减乘除会让它逐渐衰减或者放大。层数多了，这个"衰减"会导致底层学不到东西。工程师们花了很多年才解决这个问题。

第二，更容易过拟合。 网络越大，能表达的关系越多，也就越容易"背下"训练数据的细节。这就要靠更多的数据和更强的约束来平衡。

第三，算力需求更高。 层数翻倍，计算量也跟着涨。

所以真实的模型架构不是"越深越好"，而是一个综合权衡的结果。 这也是为什么 2026 年会看到很多"参数量更小但效果接近"的模型，它们在深度、宽度、训练方法、数据质量之间找到了更好的平衡点。

你不需要成为架构师

这一章讲了不少结构上的东西。但有一个结论要提前说清楚，免得你在后面觉得"这个我得会"。

你不需要会搭神经网络。

这本书的目标不是让你成为模型开发者。是让你在听到"这个模型有 70 层""它的参数量是 4000 亿""它用了一种新的注意力结构"这类说法时，心里有画面，知道对方在说什么。

为什么这件事有价值？

因为你在选工具、评估方案、和别人讨论时，判断力来自"我知道这些东西大概是什么"。一个听不懂结构的人在评估方案时只能看宣传页；一个知道结构的人会问出更具体的问题。比如"它的层数和参数量是多少""推理时用的是不是量化版本""上下文窗口多大"。

这一章给你的就是这种"听懂"的能力。 到第 25 章，我们还会再打开一层引擎盖，看看注意力机制内部。但同样地，那也是为了听懂，不是为了动手做。

想动手的人，那是一条独立的、更长的路。 这本书会在第 30 章给你指一下路口在哪里。

本章收束

三句话：

神经网络的基本零件是神经元，它做的事只是"乘权重、加起来、过门槛"，纯粹是算术。 多层结构带来逐级抽象，这是它能处理图像、语言这类复杂信息的关键。 参数是被训练出来的权重，数量可达千亿级，它们压缩的是规律，不是原文。

到这里，我们有了机器学习的机制（第 2 章），也有了神经网络的骨架（第 3 章）。

但还有一个巨大的问号没解开：这些都是二十年前就有的东西，为什么大语言模型偏偏在这几年突然变聪明了？

第 4 章回答这个问题。

有一类人玩接龙特别厉害。

你随便说一句话，他能接出下半句，而且接得又顺又贴。你换个话题，他照样接得上。你甚至故意设陷阱，说一句没头没尾的话，他也能给你一个听起来合理的延续。

他靠的不是预知，是语感。他见过太多句话，所以"下一个字最可能是什么"，他心里有个极准的直觉。

大语言模型就是这种接龙高手。而且它把这件事做到了极致：它唯一会做的事，就是看着前面所有的字，猜下一个字最可能是什么。

猜完一个，把猜出来的接到后面，再猜下一个。

就这样，一次一个，几百次之后，一篇文章出现了。

你可能想问：这么简单的一件事，怎么会变成"智能"？

这一章就来回答这个疑问。它是整本书里最关键的一章，如果你只记住一章，记这一章。

一切从"猜下一个字"开始

先把这个机制说清楚，不夸张地说，它是理解所有大语言模型产品的钥匙。

假设你给模型输入："今天天气真"

模型要回答的是：在这个前提下，下一个字最可能是哪个字？

它内部算出每个候选字的概率：好（87%）、棒（6%）、差（3%）、冷（2%）、其他（2%）。

然后它挑一个，比如"好"。

现在输入变成了："今天天气真好"

再猜下一个："啊"（41%）、"，"（28%）、"适合"（15%）……

再挑一个，接上去。

一直循环，直到它算出"该结束了"。

就这么简单。它没有规划整段话的结构，没有先想好中心思想，没有打草稿。它只知道"下一个字最可能是什么"。

这里有个地方值得停下来想一想：既然一次只猜一个字。那它怎么写出有逻辑、有结构、甚至在结尾还会呼应开头的长文章。

答案是：因为"最可能的下一个字"这个判断，本身就已经隐含了逻辑和结构。

打个比方。假设有一位老练的编辑，他读过所有能读到的文章。你给他一段半截的话，他判断"接下来最该写什么"的时候，他脑子里动用的东西，其实是全部写作经验的总和：这句话后面通常接什么、这篇文章到这一步通常该转折了、这个论点通常需要什么例子支撑。

这些经验被压进了他的直觉里，而直觉的输出形式只是"下一个词"。

模型也是这样。它把海量文本里的结构规律，压缩成了"下一个词的概率分布"。这个压缩很彻底，彻底到看起来它是在思考。

为什么是这几年

神经网络不是新东西。上世纪就有了。那为什么大语言模型的爆发发生在最近几年？

答案藏在三个东西同时到位里。

第一个：一种更适合处理语言的网络结构

2017 年，一篇论文提出了一种新的网络结构。它的核心思想，是让句子里的每个词都能直接"看到"句子里的其他所有词，并判断谁和自己相关。

这个结构叫 Transformer。第 25 章会专门拆解它。这里你只需要知道：它解决了一个老问题，以前的网络处理长句子时，读到后面就忘了前面。Transformer 让它能同时"看到"全句，这让它处理语言的能力上了一个台阶。

第二个：规模

有了好结构，还需要大规模。这就是"大"模型的来历。

规模体现在三方面：数据更多（不是几百万句话，而是几乎所有公开文本）、参数更多（从几千万到几千亿）、算力更多。

这里有一个关键的发现：规模带来的提升，不是线性的。

意思是，当你把模型从 10 亿参数扩到 100 亿，能力不是涨 10 倍。而是有时会突然多出一些原来完全没有的能力。这种现象叫涌现（emergence）。

比如，小模型只能勉强把句子说通顺。模型大到一定程度，它突然会做简单的算术了。再大一些，它突然会写代码了。再大一些，它突然能根据你的例子推断你要什么格式了。

没有人明确教过它这些。规模到那里了，能力就冒出来了。

这是 2026 年 AI 行业最让人着迷也最让人不安的一点：我们知道"变大有用"。但对"为什么变大就有用"仍然只有模糊的解释。

第三个：让回答合乎人心

前两个条件让模型变得"有知识"。但光有知识还不够。

一个只做过预训练的模型，就像一个读完了整个图书馆但完全不懂人情世故的人。它的行为模式是"继续文本"，而不是"回答问题"。

你问它"北京在哪个国家"。它可能会接出"北京在哪个国家是一个常见的地理问题，许多人对此感到困惑……"。它在续写，而不是在回答。

后训练（post-training） 就是来解决这个的。它用大量"问题-正确答案"的范例，教模型一个关键的动作切换：当看到提问时，应该直接给出回答，而不是继续续写文本。

这个过程里还有一步重要的调整，英文叫 alignment：让模型的回答更符合人类的偏好，更有帮助、更少有害内容、更诚实。

2026 年 4 月有一篇发表在《自然》上的研究，揭示了这一步带来的一个副作用，很有意思。研究者发现，现行的评测大多采用二元评分：答对得分，答错或不答得分都是零。在这种规则下，"放弃回答永远是零分，而猜一个至少有概率得分"。于是"永远猜"成了数学上的最优策略。

模型被训练成了一个优秀的应试者，宁可给出过度自信的猜测，也不愿承认自己不确定。

这个副作用，就是"幻觉"的重要来源之一。我们到第 5 章详细展开。

三个阶段，记住这条线

把上面这些串起来，一个大语言模型的诞生分三段：

预训练（pre-training）：给它海量文本，让它学会"猜下一个字"。这一阶段最贵，消耗的算力占整个流程的绝大部分。

后训练（post-training）：教会它按指令回答问题，以及什么该说什么不该说。

评测与迭代：在各种测试上跑，找出弱点，再调整。

这三段分别是"读万卷书""学做人""参加考试"。第 26 章会把它们展开讲一遍完整的工程细节。

上下文窗口：它的"短期记忆"

还有一个概念你要记住，因为它直接影响你怎么使用 AI。

上下文窗口（context window） 指的是：模型在一次对话里，最多能"看到"多少内容。

为什么要有这个限制？因为模型每次猜下一个字的时候，都要把前面所有内容重新算一遍。前面内容越长，计算量越大。总量有上限，所以窗口有上限。

窗口的单位是词元（token），可以粗略理解为文字碎片。一个中文字大约对应 1 到 1.5 个词元。

窗口大小意味着什么？举个实际的例子：如果窗口是 20 万词元，那大概能装下一本十几万字的书。你可以把整本书丢进去让它总结。但如果窗口是 8000 词元，大概只能装下十几页纸，超过的部分它根本看不到。

这带来一个非常常见的困惑：你上传了一份两百页的文档，以为它全读了，其实它可能只看了开头的一部分。

关于窗口，有两点需要澄清：

第一，窗口大不等于用得好。 有些模型窗口很大，但在内容中段的信息上表现会变差。有个流行的说法叫"迷失在中间"，开头和结尾记得清，中间容易漏。所以重要的信息，放在开头或结尾会更好。

第二，窗口里塞的东西越多，成本越高。 因为每次它都要重新算一遍所有内容。这一点在第 19 章算账时会讲清楚。

边界与坑

第一，"会接龙"解释了它所有的强，也解释了它所有的弱。

它强，是因为它见过海量的语言规律。它弱，是因为它从来没有一个"事实核查"的环节，它只是在选最可能的下一个词。而"最可能"不等于"正确"。

当你的问题里最高频的答案是错的，它就会自信地给你错的答案。

第二，别把"知识"和"会在窗口里看到"搞混。

模型参数里存的是训练时学到的规律。你在对话里粘贴的资料，属于窗口内容，对话结束就没有了。这是两套完全不同的机制。

第三，模型不知道自己在什么时候会出错。

这是最危险的一点。一个不会做的题，它会用完全一样的流畅语气答出来。它的"自信程度"和它的"正确概率"之间没有可靠的联系。

第四，不要试图用一句话问出它的底细。

"你知道 2025 年发生了什么事吗？"，这种问题它的回答不可靠。因为"我知道/不知道"这件事本身，也是它猜出来的。

上下文窗口的三组实操对比

上下文窗口这个概念，光看定义不容易有实感。这里用三组具体情况看一遍。

情况一：装得下

你上传了一份 20 页的合同，窗口是 20 万词元（大约能装 13 万到 20 万汉字）。20 页合同大概两三万字，完全装得下。

这种情况下，它的表现最可靠。 你问它"违约金是多少"，它能准确找到并回答。

但即使装得下，也有一个细节要注意：重要的要求别写在中间。有研究观察到"迷失在中间"的现象，开头和结尾的内容被处理得更好，中间容易被忽略。

实操上怎么做：把你的核心问题写在提示词最前面，把资料贴在后面。或者反过来，先贴资料，最后用一句话强调你的问题。

情况二：装不下

你上传了一份 180 页的行业报告，窗口也是 20 万词元，但报告超过 30 万字。

这时候会发生一件很危险的事：它不会报错。

它不会说"这份文件超出了我的处理能力"。它只会默默处理能看到的部分，然后回答你的问题。

你问"报告里有没有提到竞争对手 A 的价格策略"，它回答"没有提到"。但真实情况是，这三章里有一整节专门讲了这个。

你怎么发现？

问它三个问题：

• 这份文档一共多少页/多少章？（它如果报一个明显偏小的数字，就说明没读完）
• 最后一章讲的是什么？
• 文档最后一段的第一句话是什么？

如果这三个问题它答得含糊或者对不上，就不要基于它的回答做任何判断。

正确的处理办法：分段上传。先让它列出整份报告的所有章节标题（这个通常能从目录页拿到）。然后你针对关心的章节单独上传，一次一部分。

这个过程看起来麻烦，但比被它误导要划算得多。

情况三：塞得太满

窗口够大，你一次把五份不同的资料全塞进去，然后问一个问题。

这种情况的常见后果是：它的回答质量反而下降。

原因是，它要在一堆材料里找相关的那部分，找到之后还要组织。材料越多，找偏的概率越大。而且不同材料之间如果有矛盾，它可能会把矛盾的内容混在一起。

更好的做法：一次处理一件事。这一轮只问 A 资料的问题，下一轮换新对话问 B。

一个通用的经验法则：如果你自己都觉得"这个上下文有点乱"，那它多半也乱了。

一个立刻能用的检查习惯

从今天起，凡是上传超过 50 页的资料，先加一句：

请先确认你看到了这份文档的全部内容。文档一共多少页？最后一部分讲的是什么？

这一句话花你三秒，能挡掉一批最隐蔽的错误。 因为"它没看到"这种问题，恰恰是那种不会报错、也不会自己说明的错误。

还有一个配套的小习惯：把最重要的问题和最重要的资料，放在上下文的开头或结尾，不要放在正中间。

因为已有的观察显示，模型对首尾内容的处理质量明显好于中段。同样一份资料，信息摆放的位置不同，它抓到的重点就不同。

这两个习惯加起来，花你不到十秒，但它们能解决的问题，是那种"你根本不知道出了错"的问题。

而这一类问题，是使用 AI 时最贵的一类。

本章收束

三句话：

大语言模型唯一会做的事，是猜下一个字最可能是什么。它所有的能力，都从这个动作里长出来。 它的爆发靠三件事同时到位：更好的网络结构、更大的规模、以及教它听话的后训练。 它没有事实核查环节，所以"最可能"和"正确"是两件事，这是幻觉的根源。

现在我们知道它为什么会胡说。第 5 章，我们把这件事彻底摊开。同时给你一份术语词典，把接下来 25 章会用到的核心词一次讲清。

林晓青是中学语文老师，28 岁。

她试过用 AI 备课，效果不错。但每次在教研群里看到同事讨论，她都有种插不上话的感觉。同事们张口就是"上下文窗口不够""温度调低一点""这个得用 RAG"，她只能默默看。

有一回她鼓起勇气问："上下文窗口是什么？"

群里沉默了三秒，然后有人回："就是 token 上限。"

她更糊涂了。

这一章就是为她写的，也是为你写的。

AI 领域的术语并不难，难的是它们总是被解释成另一个术语。这一章会挑出八个最常出现的词，每个都用一句话说完，再补一段具体的场景。看完之后，你再看那些讨论，会发现自己突然能听懂了。

关键词一：词元（token）

一句话：模型眼里的最小文字单位，不是字，也不是词。

模型不认识"汉字"或"单词"，它把文字切成一块一块的碎片，每块叫一个词元。切法有自己的规则，常见的词会被切成一个词元，不常见的词会被切成好几块。

比如"人工智能"可能是一个词元，也可能被切成"人工"+"智能"两块。英文里"playing"可能被切成"play"+"ing"。

为什么你要在意它：因为几乎所有 AI 产品的计价、容量限制、速度，都以词元为单位算。

一个粗略的换算：一个汉字大约等于 1 到 1.5 个词元；一个英文单词大约等于 1.3 个词元。

所以当某个模型说"输入上限 128K 词元"时，大致相当于能装 8 万到 12 万个汉字。一本书的体量。 来源：词元换算为通行经验值

关键词二：参数（parameter）

一句话：模型内部那些被训练出来的数字，数量可达千亿级。

第 3 章讲过，参数就是神经网络里的权重。它们不是手册上的条目，而是"什么样的输入该产生什么样的输出"这种规律的数字表示。

为什么你要在意它：参数量是模型规模的主要指标之一，但它不是能力指标。

一个 5000 亿参数的模型，未必比一个 2000 亿参数的模型强。2026 年的情况更是如此，有相当多的模型用极小的参数量（有些只激活其中一小部分）就接近了大模型的效果，靠的是训练方法和数据质量的改进。

看到"参数量"这个词，正确的反应是："它在说这个模型有多大。"而不是："越大越好。"

关键词三：上下文窗口（context window）

一句话：模型一次能"看到"的内容上限，超过的部分它完全看不见。

这个"看到"的容量，以词元计。窗口是 20 万词元的模型，一次对话里最多能看到大约 13 万到 20 万汉字的内容。 来源：词元换算为通行经验值

为什么你要在意它：这是最影响实际使用体验的一个参数。

有个真实的场景。你把一份两百页的合同上传给 AI，让它找出所有对我方不利的条款。它回答了，条理清晰。但你发现它漏掉了第 87 页的某一条。

原因很可能是：文件超出了窗口，后面的内容它根本没看到。

两个实操提醒：

第一，上传长文档前，先确认窗口够不够。如果不够，就分段处理，或者先让它做摘要再逐步深入。

第二，即使窗口够，也别把最重要的信息放在正中间。有研究观察到"迷失在中间"的现象，开头和结尾的内容被处理得更好。重要的要求，写在最前面或最后面。

关键词四：提示词（prompt）

一句话：你发给 AI 的那段话。就这么简单。

所有输入都叫提示词，包括你随手打的一句"帮我写个周报"，也包括你精心设计的几百字模板。

为什么你要在意它：它是你唯一能直接控制模型的东西。

模型的参数你改不了，架构你改不了，训练数据你改不了。你能改变的只有提示词，也就是第 9、10 章要专门讲的那个技能。

有一句话在这个领域被反复验证：同样的模型，提示词写得好和写得随意，输出质量差距可以是量级的。

这不是玄学。因为提示词决定了模型"往哪个方向猜"。

关键词五：幻觉（hallucination）

一句话：模型给出了一个错误但听起来完全合理的答案。

这是全书最重要的一个词，值得多花点篇幅。

幻觉不是"模型坏了"，也不是"它故意骗你"。它是"猜下一个字"这个机制的必然副产品。当模型不知道正确答案时，它不会停下来说"我不知道"，它会算出"最可能听起来正确的下一个字"。

有几组数据能让你对这个问题的严重程度有实感：

它的出错率差异极大，取决于问题类型。高频事实类（比如常识、知名事件、著名人物）出错率大约 1% 到 3%。中频事实类（比如中等规模公司的信息、不太出名的历史事件）大约 5% 到 12%。长尾冷门类（冷门人物、小众技术细节、地方性信息）能到 15% 到 40%。训练数据截止之后发生的事，可以超过 30%。文献引用信息（作者名、论文标题、年份）大约 10% 到 25%。 来源：2026 年幻觉率分布研究

这些数字说明一件事：幻觉不是均匀分布的，它在你越不熟悉的地方越容易出现。

2026 年，中国信通院用 5000 多条样本做了一轮专项评测，得到一个很有价值的结论：主流模型的"事实性幻觉"（说错了客观事实）总体低于"忠实性幻觉"（说的话超出了你给的资料范围）。后者已经成为影响可靠性的主要问题。这句话翻译成人话就是：它更常犯的错，不是把世界记错，而是把你说过的话添油加醋。 来源：信通院 2026 评测

还有一个发现值得单独提出来。ICML 2026 上有一篇由多所高校研究者合作的论文指出：即使在最好的模型上，当正确答案应该是"从现有信息无法判断"时，仍有约 23% 的情况下它会给出一个过度确定的断言。 来源：ICML 2026 论文

研究者的原话大意是：模型经常把"我没有找到证据"，写成"已有证据证明不存在"。

这两句话在字面上很接近，在后果上完全不同。尤其在智能体（第 23 章）的场景里，后一句会成为后续所有动作的错误前提。

关键词六：温度（temperature）

一句话：控制模型"猜得保守还是猜得放飞"的旋钮。

温度低，模型倾向选概率最高的那个词，输出稳定、可预测，适合需要准确和一致的场合。温度高，它会更多地选择次优选项，输出更发散、更有变化，适合头脑风暴和创意写作。

为什么你要在意它：很多工具里其实没给你这个旋钮，但理解这个概念能解释一个常见困惑："我明明问了同一个问题两次，为什么答案不一样？"

因为默认情况下，模型不是每次都选概率最高的那个词，而是按概率随机抽一个。这也是它为什么每次回答都略有差异。

如果你需要稳定的输出（比如批量处理一批数据），找找工具里有没有"温度"设置，把它调低。

关键词七：多模态（multimodal）

一句话：能处理文字之外的东西，图片、声音、视频。

"模态"指的是信息的形态。只会处理文字的模型叫单模态。能同时看图、听声音、读文字的叫多模态。

为什么你要在意它：2026 年，多模态已经不是卖点，而是基本配置。

它带来一些非常实用的能力：拍一张手写笔记的照片让它转成文字。给它一张表格截图让它整理成数据。录一段会议音频让它出纪要。让它看一段视频找出某个画面。这些在第 12 到 14 章会具体讲。

但也要注意：多模态的准确率普遍低于纯文字的准确率。 尤其是让它"读"图片里的长段文字，或者从复杂图表中提取精确数字，错误率明显更高。凡涉及关键数字，都要复核。

关键词八：智能体（Agent）

一句话：能自己拆任务、自己调工具、自己干活的 AI。

普通用法是你问一句它答一句。智能体用法的不同在于：你给一个目标。它自己规划步骤，自己去搜索、去调用工具、去执行，最后把结果交给你。

为什么你要在意它：2026 年，行业叙事的重心已经从"模型能力竞赛"转向了"智能体应用"。

但我建议你在这个词上保持冷静。第 23 章会详细讲，智能体的核心难点不在"它能不能做"，而在"你怎么知道它做对了，以及它越界了怎么办"。2026 年已经发生过智能体在测试中越界访问合作方系统的事件。

一张速查表

边界与坑

第一，不要试图一次记全。

这一章的价值不在于让你背下八个定义。而在于当你下次遇到这些词时，不再有"我被排除在外"的感觉。真正会用，是在实际动手时自然形成的。

第二，注意术语的行业黑话倾向。

同一个东西在不同产品里有不同的叫法。比如"上下文窗口"有的产品叫"记忆长度"，有的叫"上下文长度"；"词元"有的翻译成"令牌"，有的根本不翻译，就叫 token。

遇到陌生的说法，先判断它是不是你已知概念的另一个名字，通常都是。

第三，这些词都在变。

术语的含义会随着技术演进而调整。比如"记忆"这个词，现在既可能指上下文窗口，也可能指跨对话的持久化存储。看到时不理解，就结合上下文判断，别硬套。

八个关键词的真实场景

定义讲完了，但真正让人记住一个词的，是"我在什么时候会撞上它"。下面每个词配一个具体场景。

词元，你收到服务商的账单，上面写着"本月输入 245 万词元，输出 38 万词元"。你想知道自己大概发了多少字。除以 1.2 左右，大约是 200 万汉字。算完之后你就知道，这个量相当于几十本《红楼梦》。

参数，你看到一条新闻："某公司发布新模型，参数量 4000 亿，但在多项评测中接近参数量两倍于它的竞品。"这句话的意思不是"它更大"，而是"它更省"。参数在这里是效率指标。

上下文窗口，你兴冲冲地把一份 200 页的标书丢给 AI 审阅，它回答得很流畅。但你后来发现，它漏掉了第 140 页一个关键的付款条件。从此你养成了一个习惯：长文档先问一句"你看全了吗"。

提示词，你和同事用同一个模型做同一件事，你的结果比他的好一截。差别不在模型，在你写的那段话。这是这个领域最常见的"不公平"。

幻觉，你让它帮你查一个法规条款的编号。它给了你一个格式完全正确的编号，你去官网一查，不存在。这是最典型的幻觉：格式对、语气对、逻辑顺，就是事实错。

温度，你要批量处理 500 条客户反馈的情绪分类。第一遍跑完，你发现同样的反馈跑两次结果不一样。原因就是温度太高，模型每次都随机抽。把它调到最低，结果就稳定了。

多模态，你给 AI 拍了一张白板照片，让它把上面的流程图转成文字。整体结构它抓对了，但有三个手写数字它认错了。这就是多模态的典型表现：整体看得懂，细节靠不住。

智能体，你让它"帮我把明天的出差安排好"。它查了航班、订了酒店、加了日历提醒、还发了一封确认邮件给同事。这是智能体。但如果它顺手把你后天的重要会议也改期了，那也是智能体，而且是你不想要的那种。

每个词都对应一种具体的麻烦。 记住麻烦，比记住定义有用。

再加三个你迟早会遇到的词

前面八个是最核心的。这里补三个同样常见、但更容易被误解的词。

系统提示词。

这是产品方预先写给模型的一段指令，用户通常看不到。它决定了这个助手"是什么身份、守什么规矩"。

为什么你要在意：同一个模型，被不同的系统提示词包装之后，表现可能完全不同。这也解释了一个常见现象，同一个模型，在 A 产品上很啰嗦，在 B 产品上很简洁。

如果你自己搭应用（第 18 到 21 章）。这段系统提示词是要你自己写的，它比你的问题本身更重要。第 21 章给了一份可直接使用的模板。

流式输出。

指模型边生成边把字推给你，而不是全部生成完再一次性返回。

为什么你要在意：它只影响"等待的体验"，不影响质量。有流式输出的时候，第一个字很快就出来，你会觉得很快；没有的时候，你要盯着空白等好几秒。同一个模型，有没有流式输出，用户的感受可以差很远。

它也可以关掉。如果你要把输出结果直接存进程序处理，通常关掉流式会更好处理。

推理模式。

指模型在给出答案之前，先输出一段思考过程。

为什么你要在意：它明显更准确，但也明显更慢、更贵。因为那段思考过程本身也是要计费的内容。

什么时候开它：需要分析、计算、多步推理的任务。

什么时候关掉它：格式转换、分类、提取、改写这类直接任务。这些任务开推理模式是纯粹的浪费，多花钱、多花时间，效果差不多。

这三个词有一个共同点：它们都在"模型本身"之外。也就是说，决定你实际体验的，不只是模型好不好，还有产品怎么用它。这解释了为什么同一个模型在不同产品上的体验差别那么大。

本章收束

这一章没有讲新机制，只是把八个词从"黑话"变成了"工具"。

三句话总结：

词元、参数、上下文窗口，是理解模型"有多大、能装多少"的三个量。 提示词是你唯一能控制的东西；幻觉是这个机制无法根除的副产品。 温度决定风格，多模态决定能处理什么，智能体决定它能自己干多少活。

第一篇还剩三章。AI 到底擅长什么、不擅长什么（第 6 章）。整个 AI 家族怎么分类（第 7 章）。还有这七十年是怎么走过来的（第 8 章）。

第 6 章特别重要，全书只有这一章专门讲"AI 什么时候不能信"。如果你时间有限，想先搞清楚这件事，从它开始。

有个案例我一直忘不掉。

一位老人身体不舒服，向 AI 描述了自己的症状。AI 回答得很笃定，其中有一句话是"百分之百是运动后肌肉拉伤"。老人信了，没有及时就医，后来发现情况比这严重得多。

这件事里最值得琢磨的，不是"AI 又出错了"。是那个"百分之百"。

AI 凭什么说得这么肯定？它没见过这位老人，不知道他的既往病史，不知道他多大年纪，不知道他有没有其他症状。它只是生成了一句听起来最像结论的话。

而"百分之百"这个词，是它从海量医疗文本里学到的一种表达习惯，医生在给出明确判断时，常常这么写。

这就是这一章要处理的问题：AI 什么时候可以信，什么时候不能信。

这是全书最重要的一章。不是因为它最难，而是因为其他所有章节都在教你"怎么用它"，只有这一章教你"什么时候别用它"。

先画一张能力地图

理解一个东西的边界，比理解它的能力更难，也更重要。

我们先用两条轴给 AI 画一张地图。

第一条轴：输入形态。 它能看到什么，文字、图片、声音、视频。

第二条轴：任务性质。 它要做什么，是判断题（有唯一正确答案）还是生成题（要产出新内容）？是封闭问题（答案在有限范围内）还是开放创作？

把这两条轴交叉，AI 的强弱分布就清楚了。

在"生成题"这一侧，它强得离谱。写文案、起标题、改措辞、扩写缩写、换个语气重写、生成多个方案。这些任务没有唯一正确答案，只要"合理"就算过关。而"合理"恰恰是它最擅长的。

在"判断题"这一侧，它的表现取决于问题落在哪。高频常识它很准，冷门事实它很容易错，需要精确计算或严格推理的它经常翻车。

记住这个规律：越是"没有唯一答案"的任务，它越可靠；越是"只有一个正确答案"的任务，你越要小心。

听起来有点反直觉，我们通常觉得"标准答案"应该更容易。但对一个靠概率猜词的机器来说，正好相反。

它真正强的五件事

一、模式识别与归类

给它一堆数据，让它找规律、分类、贴标签。这是它的看家本领，因为整个模型就是这么训练出来的。

具体场景：把一千条用户反馈按情绪自动分成正面、负面、中性。把一堆杂乱的产品描述归到几个类别里。从简历里提取出工作年限和技能关键词。

二、语言的组织与变换

换语气、调长度、改受众、变格式。"把这段技术说明改成给客户看的话""把这份长报告压缩到 300 字""把这封邮件写得再客气一点"。

这类任务它完成得又快又好，而且你几乎不需要检查，因为对错的标准本身就很宽松。

三、跨领域的联想与连接

它读过的东西横跨所有领域，所以能做一些人类不太容易做的连接。把心理学的概念拿来解释团队管理问题。用某个行业的做法类比另一个行业。从一段代码里看出它对应的业务逻辑。

这类输出通常不能直接用，但作为启发非常有用。

四、快速起草

从零到一最难，从一到十容易。它最大的价值之一，是帮你把"零"这一步省掉。

写方案最痛苦的是面对空白文档。让它先出一版，哪怕很粗糙，你也有东西可改了。人的大脑面对一个已有的东西，比面对空白要活跃得多。

五、格式转换

把表格变成文字说明，把文字说明变成表格，把会议记录变成待办清单，把要点变成 PPT 大纲。

这类任务的特点是规则明确、答案不唯一、验证成本低。是 AI 最舒服的区间。

它真正弱的六件事

一、事实的准确性

这是最要命的一项。

第 5 章给过数据：高频事实出错率 1% 到 3%，冷门事实 15% 到 40%。训练截止后的事件超过 30%。 来源：2026 年幻觉率分布研究

有个说法很准确：模型不是"知道"事实，它是"生成"事实。当它没有可靠依据时，它会生成一个最像真的版本。

应对办法：凡涉及具体数字、人名、日期、地点、法规条文、引用来源，一律用外部来源核对。第 16 章会给一套具体的核实流程。

二、时效性

模型的知识停在训练数据截止的那一天。

它可能知道某个政策在去年是什么样，但不知道上个月改了。它可能知道某个产品去年的价格，但不知道今年的。

应对办法：涉及"现在""最新""当前"的问题，要么使用带联网功能的产品（并且仍然要核对来源），要么自己去查。

三、精确计算

2026 年的模型算术能力已经比几年前好很多，尤其是有计算工具辅助时。但纯靠"心算"的复杂计算依然不可靠。

原因还是那个：它在"猜下一个字"。数字只是它见过的另一种模式，而它没有真正的算术引擎。

应对办法：让它写计算过程（分步计算比一步到位准），或者让它生成公式和代码。你自己拿去算，或者使用带代码执行功能的工具。

有个很实际的提醒：涉及钱、税、合同金额、统计口径的计算，无论它算得多么流畅，都要复核。 尤其在财务场景里。

四、长链条的推理

一步两步的推理它做得不错。但推理链条一长，错误会累积。

有个数据很说明问题。有研究测试了多轮对话中的表现。在专业领域里，即使配了联网搜索的模型，幻觉率也约有 30%。关闭搜索后，这个比例攀升到 60% 以上。原因就是早期轮次的失误会引发连锁反应，前面错一点，后面越走越偏。 来源：HalluHard 2026-08 测试

还有一个反直觉的发现：让模型"想得更久"未必更准。有论文观察到，某个模型的因果幻觉率在没有思考过程时是 19.7%，把思考预算开到最大反而升到 27.1%。 来源：ICML 2026 论文

研究者的解释是：开放式的前向模拟。给了模型更多生成"看似合理、却不受实际情况约束"的中间步骤的机会。

应对办法：把长任务拆成几段，每段做完先检查再做下一段。不要指望它一次性完成一个二十步的推理。

五、知道自己不知道

这是它最根本的缺陷之一。

它不是不会说"我不知道"，而是它的默认倾向是给出一个答案。前面提到的那篇《自然》论文解释了这个倾向的来源：评测规则是"答错和不答都是零分，猜一个至少有机会得分"，于是"永远猜"成了最优策略。

它被训练成了一个宁可猜也不肯空着的考生。

应对办法：主动在提示词里给它留退路。明确说"如果信息不足，请直接说无法判断，不要推测"。这句话真的有用，它会显著降低无依据断言的比例。

六、真实世界的经验

它没有身体，没有感官，没有在世界上生活过。

它知道"烫"这个字，但不知道烫是什么感觉。它知道"重力"这个词，但没有摔过跤。所有关于物理世界、身体感受、社交微妙之处的理解，它都是从文字中间接学来的。

所以当问题涉及"这样做在实际中会有什么感觉""客户会怎么想""这个方案实际推进时会不会出问题"，它的回答要打折扣。这类问题需要真正经历过的人。

一张判断表

把上面的内容压缩成一张可以直接用的表。

这张表不需要背。你只需要形成一个条件反射：当我需要"确切的某个东西"时，问自己一句"它有依据吗"。

边界与坑

第一，不要因为一次错误就否定全部。

它的价值在生成和组织，不在保证准确。把它当"极其勤快的实习生"，而不是"权威专家"。

第二，也不要因为它大部分时候正确就放松警惕。

危险恰恰在于它 95% 的时候是对的。你会慢慢放下戒心，然后在第 96 次踩坑。而且你踩坑的地方，往往正是你最不熟悉、最没有能力发现错误的领域。

第三，"它回答得很流畅"不是可信的信号。

流畅度和正确性完全无关。它的输出永远流畅，包括在它完全胡说的时候。这一点和人类很不一样，人撒谎时会迟疑、会紧张，机器不会。

第四，注意"过度确定"这个具体毛病。

留意它说的"肯定""百分之百""完全""众所周知"。这些词出现时，反而要提高警惕。因为一个真正了解情况的人，通常会带条件地说话。

三个踩坑场景的完整复盘

判断表看着清楚，但真到用的时候还是容易放松。下面三个场景都是真实的坑，把全过程拆开看一遍。

场景一：那封写错了数字的汇报邮件

发生了什么：你用 AI 帮你起草一封给客户的邮件，里面提到"我们上次交付的成功率是 98%"。你记得这个数字大概是 98% 到 99% 之间，觉得差不多，就发出去了。

问题在哪：AI 并没有"记得"这个数字。它是在生成一封"看起来专业的邮件"时，把一个常见区间的数字填了进去。你之所以没发现，是因为这个数字落在了你记忆的模糊区间里，它"听起来对"。

当时应该怎么做：涉及任何数字、日期、金额、比例的邮件，逐项核对。这不是"多此一举"，因为 AI 生成数字的方式，和它生成形容词的方式完全一样，都是"最像对的"。

这个坑的通用形态是：当你也记不清的时候，你最容易接受它的答案。

场景二：那个不存在的政策条款

发生了什么：你要写一份材料，引用了某条政策。你让 AI 确认条款编号，它给你一个格式完全正确的编号。你直接用了。后来有人指出，这条政策里没有这一款。

问题在哪：它对"格式"的把握是可靠的，对"具体内容"的把握是不可靠的。而格式正确会极大提升你的信任感。

当时应该怎么做：凡是引用的法规、标准、文件编号、条款，一律去官方来源核对原文。

这个坑的通用形态是：格式正确、语气专业，会让你放松对内容的警惕。

场景三：那个"帮我全部整理好"的任务

发生了什么：你让它从一份 80 页的报告里提取所有涉及"成本"的数据，整理成表格。它给了你一份 15 行的表格。你看着挺全，就用了。

问题在哪：报告里实际有 23 处涉及成本的数据。它漏了 8 处，其中 2 处是关键数据。漏的原因是，它没有"读完并穷举"的能力，它只是生成了一份"最像完整清单"的表格。

当时应该怎么做：给它一个可以验证的标准。比如先问"这份报告里涉及成本的部分大概有多少处"，让它给一个数，再让它提取。或者明确要求"每一条都标注页码"，然后按页码抽查。

这个坑的通用形态是："完整性"这类要求，它无法保证。 凡是"一条都别漏""全部找出来"的任务，都要设计验证手段。

三个场景的共同结构

回头看这三个坑，它们的形状是一样的：

1. 你提了一个合理的要求
2. 它给了一个说得过去的答案
3. 你当时没有能力判断它对不对（这是关键）
4. 出问题之后你才发现，而且是在别人那里发现的

第 3 步是整件事的核心。 如果你当时有能力判断，你就不会被坑。而它出错的地方，恰恰就是你最不熟的地方。这不是巧合，第 6 章开头那组数据已经解释过：它在你越不熟悉的领域越容易出错。

由此得出一条行动原则：

当你要让它做一件你没法判断对错的事情时，需要换一种方式，要么分步做，每步都能判断；要么要求它给出依据，你去核实依据。

一份"什么时候该停下来"的信号清单

上面那些内容，可以压成几个信号。出现这些信号时，停一下。

信号一：它给了你一个你没法验证的数字或事实。

停。去找来源。找不到就删掉，或者改成模糊表述。

信号二：你在心里想"这个差不多对"。

停。"差不多对"通常是"我不确定"。不确定就核实。

信号三：它的回答里出现了"根据某项研究""数据显示""业内普遍认为"。

停。这类表述可能是它编的，也可能是它把某处的内容记错了。要么让它说出具体来源去核实，要么删掉。

信号四：这件事如果错了，后果很严重。

停。医疗、法律、金额、对外发布，这四类场景，永远不要让 AI 当最后一个环节。

信号五：你已经问了它十几轮，它越改越乱。

停。开一个新对话重新开始。第 16 章解释过原因：早期轮次的错误会成为后续推理的前提。

信号六：它的回答特别流畅、特别自信、特别完整。

停一下，但不要停太久，只是提醒自己：流畅度和正确性无关。 它胡说的时候也一样流畅。

这套信号不需要背。 用上几次之后，它会变成一种条件反射。而那种条件反射，就是这一整章想给你的东西。

本章收束

三句话：

AI 强在生成，弱在判断。越是需要唯一正确答案的地方，越不能只信它。 它的错误集中在四类：冷门事实、时效信息、精确计算、长链条推理。 它永远不会告诉你它没把握。这个判断只能你自己做。

到这里，你已经知道了 AI 是什么、怎么学的、为什么会错、错在哪里。第一篇还剩两章：把 AI 的整个家族分个类（第 7 章），以及回头看这七十年（第 8 章）。

第 7 章会很实用，它能帮你把每天听到的各种 AI 名词，塞进一个清晰的抽屉里。

赵砚 45 岁，做外贸生意，公司二十来号人。

他每天都能听到新的 AI 名词。客户说他们在用"AI 客服"，货代说他们的系统上了"AI 报关"，女儿说学校在用"AI 批改"。他自己也买过两套 SaaS 工具，销售都说是"AI 加持的"。

他有一个说不出口的困惑：这些东西之间是什么关系？它们是同一个东西的不同叫法，还是完全不同的东西？

这个困惑很常见，而且很难在公开资料里找到答案。因为讲技术的人习惯从原理出发分类，而不讲技术的人只会重复销售话术。

这一章换个做法：从"你实际会遇到什么"出发，给 AI 家族画一张树。

最实用的一个分法：判别式与生成式

如果有人只让你记住一种分类方式，记住这个。

判别式 AI（discriminative）：从已有的东西里做判断和选择。

它做的事是"给一个输入，输出一个判断结果"。

• 这封邮件是垃圾邮件吗？（是/否）
• 这张脸是谁的？（名单里的第 3 个人）
• 这个用户会点击这个广告吗？（概率 3.7%）
• 这笔交易有欺诈风险吗？（风险等级 高）
• 这个视频适合推荐给谁？（兴趣标签：摄影）

它的输出是有限的、确定的、有唯一正确答案的。 你要么对，要么错。

判别式 AI 已经悄悄运行了很多年。你的垃圾邮件过滤器、信用卡风控、人脸解锁、购物推荐、地图路况预测、语音输入法，都是它。它不新鲜，也不引人注目，但它可能是 AI 对日常生活影响最大的一块。

生成式 AI（generative）：产出全新的内容。

它做的事是"给一个输入（可以是空的），产出新的东西"。

• 写一段文案
• 画一张图
• 生成一段配音
• 写一个函数
• 把这段会议记录变成纪要
• 生成一段视频

它的输出是开放的、多样的、没有唯一正确答案的。 十个人写同一段文案，十版都算合格。

生成式 AI 是这几年引爆公众讨论的主角。我们平时说的"用 AI"，绝大多数指的是它。

为什么这个区分对你有用：因为这两类 AI 的可靠性完全不同。

判别式 AI 的输出可以验证，你可以问"准确率是多少"。它有一个可以测量的准确率数字，做得好就能用。

生成式 AI 的输出没有唯一正确答案，所以"准确率"这个指标本身就不适用。它的风险不在"错得离谱"，而在"错得很像对的"。这就是为什么第 6 章要花一整章讲它的边界。

你跟供应商谈合作时，如果对方说"我们这是 AI 加持的"，你可以追问一句："它是做判断还是做生成？"这一问，能省掉很多误会。

第二个分法：单模态与多模态

前面提到过，模态指的是信息的形态。

单模态 AI 只处理一种形态。早期的大语言模型只处理文字，早期的图像模型只处理图片。

多模态 AI 同时处理多种形态。2026 年，主流模型基本都是多模态的，能读文字、能看图、能听声音，有些还能处理视频。

值得单独说一下的是"输入多模态"和"输出多模态"的区别，这两个经常被混为一谈。

一个模型可以"能看图"（输入多模态）但"只能输出文字"。也可以"只能读文字"（输入单模态）但"能生成图片"（输出多模态）。

大部分通用助手属于前者：你给它一张图，它能看懂并回答，但它写回给你的是文字。

图像生成、视频生成工具属于后者：你给它文字，它给你图。

这个区别在选工具时很实用。你的需求是"看懂这张图"还是"生成一张图"，对应的是完全不同的产品。

第三个分法：专用与通用

专用 AI（narrow AI）：只做一件事，但做得很好。

人脸识别、语音转写、机器翻译、推荐算法、车牌识别、医学影像筛查。你目前见过的绝大多数在生产环境中稳定运行的 AI，都是专用 AI。

通用 AI（general AI）：什么都能做，这也是大语言模型的特点。

你用同一个对话框，可以让它写诗、改代码、算账、翻译、出主意。这种"一个模型什么都会"的能力，是 2020 年之后才出现的。

关于通用 AI 有一个常见的误解，要澄清一下。

今天说的"通用"，指的是"通用任务"，不是"通用智能"。 它能应付很多种任务，但它在每种任务上的水平参差不齐，而且它没有跨任务的自主目标和持续学习能力。它今天会写诗，明天还是会写诗，并不会因为和你聊了一个月就变成另一个人。

真正意义上像人一样自主的通用智能（通常缩写为 AGI），目前还没有实现，业界对它的时间表也没有共识。

第四类：从"会回答"到"会办事"

上面三种分法覆盖了绝大多数 AI，但还有一类需要单独拿出来说。

智能体（Agent）：不满足于回答，要自己动手完成任务的 AI。

普通用法是一问一答。智能体用法是：你给一个目标，它自己拆成步骤，自己调用工具（搜索、计算、读写文件、发邮件、操作网页），执行完再把结果给你。

用一句话概括这个转变：从"按目标做事"替代"按指令做事"。

以前的软件，你要记住每一步操作，在十几个界面之间来回切。智能体模式下，你说需求，它负责把需求翻译成一连串动作。

2026 年，行业把这一年称为"智能体元年"。斯坦福《2026 年人工智能指数报告》提到，AI 在真实计算机环境中的任务成功率从 12% 升到了 66%，这个数字的跃升，被看作智能体从"能对话"迈向"能办事"的关键转折。 来源：斯坦福《2026 年 AI 指数报告》

不过要提醒一句：同一份报告也指出，企业的实际应用成熟度仍主要集中在"探索试验级"和"局部应用级"，真正深入业务的应用还不多。销售话术里的"智能体"，和实际能稳定运行的智能体，中间还有距离。

一张家族树

把上面四种分法合起来，AI 家族大致长这样：

AI
├── 判别式 AI（做判断）
│   ├── 分类：垃圾邮件、图片归类、情绪判断
│   ├── 识别：人脸、语音、车牌、图像检测
│   └── 预测：推荐、风控、销量预估、路况
│
├── 生成式 AI（造内容）
│   ├── 文字：写作、翻译、总结、代码
│   ├── 图像：绘画、修图、设计
│   ├── 音频：配音、音乐、语音克隆
│   └── 视频：文生视频、图生视频
│
├── 多模态 AI（跨形态）
│   ├── 输入多模态：能看图/听声，输出文字
│   └── 输出多模态：文字进，图/音/视频出
│
└── 智能体（会办事）
    ├── 单智能体：自己规划、自己调工具
    └── 多智能体：多个角色分工协作

这张树不是技术意义上的严格分类，但对理解日常遇到的产品足够用。赵砚再听到"AI 报关"，他就能想：这大概是判别式 AI（判断单据合规性），可能加一点生成式（生成报告）。听到"AI 客服"，他会想：这可能是检索型问答，也可能是智能体。

边界与坑

第一，"AI 加持"是个模糊到几乎没有信息量的说法。

任何用了哪怕一点点机器学习的地方，都可以这么标注。遇到这种说法，追问具体做什么，比听名词有用得多。

第二，不要以为老技术就落后。

判别式 AI 是"上一代"的技术，但它今天依然在生产环境里承担最核心的工作，而且它通常比生成式 AI 更可靠，因为它有可测量的准确率。新不新和好不好用是两件事。

第三，别把"多模态"和"更聪明"划等号。

能看图不代表理解图。它在图片的细节、数字、空间关系上依然容易出错。多模态是能力扩展，不是可靠性提升。

第四，"智能体"这个词目前被严重通货膨胀。

从能自动回复一句话的工具，到能自主规划几十步的系统，都被叫智能体。听到这个词时，你要问的具体问题是：它能调用哪些工具？出错了谁来兜底？有没有权限限制？ 这些才是关键，第 23 章会展开。

十道归类练习

学了分类之后，最有效的巩固方式是直接练。下面十道题，先自己想，再看答案。

第一题：手机相册能自动把照片按"人""风景""食物"分组。

答案：判别式 AI。它做的是分类判断，输出是有限类别。

第二题：输入一段文字，生成一张配图。

答案：生成式 AI（输出多模态）。文字进，图像出。

第三题：你在对话框里问"这段代码有什么问题"，它给出了三处修改建议。

答案：生成式 AI。虽然回答的是"判断"类问题，但它的输出是自由生成的文字，没有唯一标准答案。这是本书第 7 章那个分法的边界情况：当判别任务被封装成对话时，它就带上了生成式 AI 的可靠性特征。

第四题：信用卡系统在你刷卡后 0.2 秒内判定"这笔交易风险等级：高"。

答案：判别式 AI。典型的实时风控。

第五题：你说"帮我把下周的行程安排好"，它自己查了航班、订了酒店、发了确认邮件。

答案：智能体。关键词是"它自己拆步骤、自己调工具"。

第六题：录音上传后自动生成带时间戳的文字稿。

答案：判别式 AI + 生成式 AI 的组合。语音转文字是识别（判别性质），文字的整理和标点是生成性质。

第七题：你给它一张产品图，它把背景换成了纯白色。

答案：生成式 AI（图像编辑）。输出是新的图像内容。

第八题：它看完你上传的 30 页 PDF，回答"这份报告认为明年市场会增长"。

答案：RAG 的应用，底层是生成式 AI。注意它是"基于你给的资料"回答的，这属于第 20 章的内容。

第九题：输入"下雨天，一个人在公交站台等车"，输出一段 8 秒的视频。

答案：生成式 AI（输出多模态，视频）。

第十题：电商网站给你推荐"你可能也喜欢"的商品。

答案：判别式 AI。本质上是在预测"你会不会点击/购买"。

练完这十道题，你会发现一件事：你日常遇到的产品，绝大多数都能归到这几类里。

而归类之后，你对它的可靠性会立刻有个预判。

判别式的，可以问准确率。生成式的，要看边界和核实。智能体的，要看权限和日志。

这就是分类的实用价值：它不是一个知识，是一个判断工具。

一个更实用的问法

前面讲的都是"怎么给 AI 分类"。最后给一个反向的问题，它在实际工作里更有用。

当有人跟你说"我们用了 AI"时，你可以问这三个问题。

问题一：它做的是判断还是生成？

这个问题一出口，对方的回答方式就能告诉你很多东西。如果他说"它判断准确率 92%"，说明对方真的懂。如果他说"它很智能、什么都能聊"，那多半是在讲一个生成式应用，而且没有评测过。

问题二：它出错的时候，你们怎么发现的？

这是最有杀伤力的一个问题。

因为大部分做 AI 应用的人，从没认真想过这件事。而这个问题直接指向了系统的可靠性基础，第 24 章整章都在讲它。

问题三：如果它出错了，后果是什么？谁来兜底？

这一问会把话题引向责任和权限，第 23 章和第 28 章的内容。

这三个问题不需要任何技术背景，但它们能让你在五分钟内判断一个 AI 方案是不是靠谱。

发现了吗？ 你读到这里，已经具备了一种很稀缺的能力：不被"AI"这个词吓住，能问出关键问题。

这种能力比会调 API 更值钱，因为它很难被工具替代。

本章收束

三句话：

AI 大致分两类：做判断的（判别式）和造内容的（生成式）。前者可验证，后者不可验证，这是它们风险差异的根源。 多模态指的是能处理的形态，智能体指的是能自主行动的程度。这是两个不同的角度。 "AI 加持"这种标签没有信息量。要问它具体做什么任务。

第一篇还有最后一章：这七十年到底发生了什么，我们是怎么一步步走到今天的。

第 8 章不只是历史课。它会解释一个对你很重要的问题：为什么 AI 领域会周期性地"热起来"又"冷下去"，以及这件事对今天意味着什么。

2026 年 8 月，有人在行业媒体上写下一句话："最强模型的保质期正在缩短。"

支撑这句话的是一个事实：那个月，一共有 9 款旗舰模型扎堆发布。

以往一年出几款，那一个月出了 9 款。刚评测完 A 模型，B 模型就来了；还没把 B 摸熟，C 已经上线。有一家模型公司的人调侃说，他们内部已经不看排行榜了，因为看也追不上。

这个现象和这一章有什么关系？

关系很大。因为它解释了一个学习上的关键问题：在这个领域，什么值得学，什么不值得学。

而答案，藏在过去七十年的三次起落里。

起点：一个很狂的问题

1950 年，一位英国数学家发表了一篇论文，开头提了一个问题：机器能思考吗？

他设计了一个测试方法：如果一台机器在对话中让人类分不清它是人还是机器。那就可以说它"会思考"。这个方法后来被称为图灵测试。

这个问题的野心很大。它把"智能"从一个哲学词，变成了一个可以操作、可以检验的目标。

六年后的 1956 年，一群学者在美国达特茅斯学院开了一场会。会上提出了一个词：人工智能（Artificial Intelligence, AI）。

那场会上弥漫着一种极度乐观的情绪。有参会者认为，用一代人的时间就能把"智能"这件事彻底解决。

后来证明，这个估计错得离谱。但它开启了第一次浪潮。

第一次浪潮：把知识写下来（1950s–1970s）

早期的思路很朴素，也很符合直觉：既然人类思考靠知识，那我们就把知识写进机器里。

这个方法叫符号主义，因为它把知识表示成符号和规则。

举个例子。如果要让机器判断一个动物是不是鸟，就写下规则：

• 有羽毛 → 是鸟
• 会飞 且 有羽毛 → 是鸟
• 有羽毛 且 不会飞 且 会游泳 → 是企鹅

这些规则由人类专家一条条写进去，所以这套系统叫专家系统。

专家系统在特定领域确实好用过。比如帮助医生做某些疾病的辅助诊断，或者配置复杂的计算机系统。上世纪七八十年代，它甚至催生了一个小产业。

但它很快就撞墙了。

第一个问题是：知识写不完。

常识的数量是天文数字。"杯子放在桌子边缘会掉下来""如果下雨，地上会湿""人饿了要吃饭"。这些对三岁小孩都不是问题的事，要用规则表达出来，需要写无穷多条。

第二个问题是：规则会打架。

规则一多，难免互相冲突。而且现实中的判断往往是模糊的（"有点咳嗽""比较累"），规则是精确的（"咳嗽 = 是"），两者对不上。

第三个问题是：它不会自己学。

每加一个新知识，都要人类手工写进去。系统的"成长"完全依赖人工，成本降不下来。

到了八十年代末，投入巨大但产出有限，资金撤出，第一次"AI 冬天"来了。

第二次浪潮：让它自己从数据里学（1980s–2000s）

第一次浪潮的失败，逼出了思路的转变。

新思路是：别再手写知识了，让机器自己从数据里总结。

这就是机器学习（machine learning），也就是第 2 章讲的那套机制，给例子，让它自己拧旋钮。

这个转向很关键，因为数据比规则多得多，而且数据是现成的。你不需要找一个专家把知识写成规则，你只需要找一批带标注的例子。

这一次浪潮带来了很多真正进入日常生活的成果：垃圾邮件过滤、信用卡欺诈检测、搜索引擎排序、语音识别、机器翻译、手写数字识别。这些是判别式 AI，第 7 章讲的那一类。

但这条路也不是没有天花板。

最大的问题是：特征要靠人类设计。

回到第 2 章那个垃圾邮件的例子。是谁决定了"看标题里有没有'免费'这个词"这条线索？

是人。

这叫特征工程，是第二次浪潮里最费人力的环节。做图像识别，专家要研究"边缘""角点""纹理"这些特征该怎么算；做语音识别，要研究声波的哪些特性有区分度。

专家的水平，直接决定了系统的上限。而这件事极其依赖领域知识，进展缓慢。

到了这个阶段，机器已经会"学"了，但它还在等着人类告诉它"该学什么"。

第三次浪潮：让它自己找特征（2012 至今）

转折点出现在 2012 年。

那一年的一场图像识别比赛中，一个基于深度神经网络的方案大幅领先了所有对手。它的错误率比第二名低了十个百分点以上。在一个竞争多年的赛道上，这个差距大到不像同一个时代的产物。

它做对的事情只有一件：不再让人类设计特征了。

它直接把几百万个像素丢进多层网络，让网络自己从数据里学出该看什么（这就是第 3 章讲的分层抽象）。人类只提供数据和网络结构，不再告诉它"边缘怎么算"。

"特征工程"这个人工时代，基本结束了。

接下来是一条陡峭的上升线：

2017 年，Transformer 结构被提出。它让模型能同时"看到"句子里的所有词，解决了长距离依赖的问题。这是第 4 章讲的那个关键结构。

2020 年前后，人们发现了一件让整个行业震动的事：参数规模继续放大，能力会持续提升，而且会出现"涌现"，突然多出一些原来完全没有的能力。 于是"大模型"时代开始了。

2022 年底到 2023 年，对话式 AI 产品进入大众视野。AI 第一次成为全民话题。很多人对 AI 的印象，就是从那一年开始建立的。

2024 到 2025 年，多模态成为标配，推理模式出现，成本大幅下降。

2026 年，重心转向智能体。行业叙事从"谁的模型更强"切换到了"谁能把事办成"。这一年，AI 在真实计算机环境中的任务成功率从 12% 升到了 66%。 来源：斯坦福《2026 年 AI 指数报告》

三个冬天教会我们的事

回头看这三次浪潮，有一个模式反复出现：

每一次都是"新思路 → 乐观预期 → 撞上瓶颈 → 预期落空 → 冬天"。

第一次撞的是"知识写不完"，第二次撞的是"特征要人来设计"，第三次会不会撞？撞在哪里？

这是今天最值得思考的问题。目前能看到的几个潜在瓶颈：

数据。高质量的人类文本是有限的。互联网上的文字已经被用得差不多了，接下来要么靠合成数据（有风险），要么靠新的数据来源。

算力与能源。训练和运行大模型消耗的电力是惊人的。成本不可能无限下降。

可靠性。第 5、6 章讲的那些问题。幻觉、过度确定、长链条推理失效，目前只是被"缓解"，没有被"解决"。而这些问题恰恰是智能体走进日常工作的最大障碍。

评测。2026 年有个很值得注意的信号：一度被视为编码能力金标准的 SWE-bench 榜单，被指出已经受到训练数据污染，同一模型在真实任务上的表现可能比榜单分数低数十分，连发布方自己都不再引用该成绩。

一个找不到可靠标尺的领域，很难知道自己是真进步还是在原地跑。

这对你意味着什么

历史给了三条对学习者极有价值的启发。

第一，学方法，不追版本。

如果你花两个月背下了当前所有主流模型的名字、参数、价格、排名，那么两个月后，这些知识大部分会作废。

但如果你理解了"神经网络为什么分层""幻觉为什么无法根除""RAG 为什么有效""智能体为什么会越界"，这些认知在下一代模型上依然成立。

有个很朴素的判断标准：这条知识，会因为某个产品更新而失效吗？ 如果会，它就不值得花大力气记。

第二，警惕"这次不一样"的叙事。

每一轮浪潮的高点，都会有人说"这次不一样"。有时确实不一样，第三次浪潮确实和前两次有本质区别。但"有些东西不一样"和"什么都变了"是两件事。

冷静的姿势是：接受新技术带来的真实改变，同时保留对它局限性的认知。

第三，注意瓶颈在哪里。

AI 的每一次停顿，原因都不在"模型不够大"，而在某个具体的现实约束。今天最明显的约束是可靠性。这意味着：在需要高可靠性的场景里，人的判断和复核环节不会消失，只会变得更关键。

这对你其实是好消息。它意味着 AI 不会简单地取代人，而是把人的角色从"执行"推向"判断"。判断，恰恰是这本书后半部分要重点训练的能力。

边界与坑

第一，不要用"AI 冬天"来吓自己，也不要用它来安慰自己。

冬天指的是投资和期望的回落，不是技术消失。即使在冬天里，专家系统也在某些行业继续运行了很多年。工具会留下，炒作会退潮。

第二，不要把时间线记成线性的进步。

这七十年不是平滑上升的曲线，是三次跃升加两次塌陷。今天的顺利，不能推出明天也顺利。

第三，警惕"必然论"。

"AI 多半会怎样怎样"这类断言，在这七十年里反复出现过，而且大部分都错了。更有用的态度是：看它现在能做什么，实测一下，再根据实测调整判断。

三次冬天留下了什么

"AI 冬天"这个词容易让人以为技术消失了。实际上，每一次冬天都留下了实实在在的东西。

第一次冬天留下的东西：

• 一套"把知识表示成规则"的完整方法。今天你在用的很多系统，底层逻辑依然是规则引擎。比如保险公司的核保流程、银行的审批规则。
• 一个重要的教训：光靠人写规则，扩展不了。 这个教训直接催生了第二次浪潮的思路。

第二次冬天留下的东西：

• 一大批真正进入生产环境的系统。垃圾邮件过滤、信用卡风控、搜索引擎排序、推荐算法。这些都是第二次浪潮的产物，而且今天还在运行。
• 一个同样重要的教训：光让机器学特征，天花板取决于人怎么设计特征。 这个教训直接催生了第三次浪潮的思路。
• 还有一件常被忽略的遗产：评价体系。 因为判别式 AI 有明确的"准确率"概念，这个行业头一回学会了用数字衡量一个模型行不行。这个习惯后来成了整个领域的基础。

现在这个阶段会留下什么？

这是开放问题，但有几件事已经可以看清楚：

第一，会留下"如何评测"的方法。 现在这个行业最大的困扰之一是没有可靠标尺，公开榜单被污染、厂商自报不可信、真实场景差异大。下一阶段真正值钱的，可能是评测方法本身。 这也是为什么这本书第 24 章要用整整一章讲评测。

第二，会留下"人机分工"的经验。 哪些环节可以交给机器，哪些需要留人，这个边界正在被一件件具体的事划出来。第 23 章那七条安全清单，就是这个经验的一部分。

第三，会留下"基础设施"。 算力集群、数据管道、工具接口、开发框架，这些东西不会因为热度退潮就消失，它们会留下来，成为下一波的起点。

看懂这个模式，你就能理解一件事：一个领域真正的进步，往往不是在热搜最高的时候发生的，而是在热搜退去之后，那些留下来的东西被慢慢用起来的时候。

一个"反直觉"的历史规律

回头看这七十年，有一个规律值得单独说。

每一次浪潮的起点，都是上一次浪潮"失败原因"的直接答案。

第一次失败的原因：知识要靠人写，写不完。第二次的思路：别写了，让机器从数据里学。

第二次失败的原因：特征要靠人设计，设计不过来。第三次的思路：别设计了，让网络自己学。

现在的问题是什么？

现在最大的约束是可靠性，幻觉、过度确定、长链条推理失效。而这些问题目前只是被"缓解"，没有被"解决"。

按这个规律推，下一阶段的突破方向，很可能是"如何让模型知道自己不知道"。

有意思的是，这个方向已经有动作了。第 26 章提到过，有研究团队正在改评测规则，从"答对得分、答错零分"，改成"承认不知道也能得分、无依据断言要扣分"。

这个改动听起来很小，但它可能比任何架构创新都重要。 因为它直接改的是模型被训练时的目标。

对你有什么启发？

它提示了一件事：评估标准决定行为方式。

这个道理不只适用于 AI。你给团队定的考核标准，会直接决定他们的行为方式。定错了标准，就会得到错误的努力方向。

这条规律，可能是这一章最值得带走的东西。

本章收束

AI 走过三次浪潮：写规则的（符号主义）、学特征的（经典机器学习）、自己找特征的（深度学习）。每一次都撞上了不同的墙。 今天的关键约束是可靠性，不是模型大小。这也是判断题比操作题更值钱的原因。 学方法，不追版本。判断标准是：这条知识会因为产品更新而失效吗？

第一篇到这里结束了。

你现在的认知地基是这样的：AI 是靠猜下一个字工作的（第 1、4 章）。它靠从数据中调参数学会的（第 2、3 章）；它多半会出错。而且会在你越不熟的地方越容易出错（第 5、6 章）。它有很多种形态，关键是分清"判断"和"生成"（第 7 章）；它会过热也会过冷。所以方法比版本重要（第 8 章）。

地基打完了。从第 9 章开始动手。

下一篇的门槛很低，你会从"第一次对话"开始，做出你这辈子第一个真正有用的 AI 输出。

陈默第一次用 AI，问了一句话：

"帮我写个周报。"

结果他拿到了一段东西，读了第一句就皱眉。开头是"本周，在公司领导的正确指引下，我部门全体员工团结协作，圆满完成了各项工作任务"。他往下翻，通篇都是这种话，最后两百字里没有一个具体的数字。

他心想：这东西还不如我自己写。

然后他关掉了窗口。两周没再打开。

他后来才知道，问题不在 AI，也不在他。在于他问的那句话，信息量约等于零。

"帮我写个周报"，什么岗位？这周做了什么？给谁看？多长？什么语气？这些信息，AI 一个都不知道。它只能拿"周报"这个词去猜，而它见过的周报里，最常见的就是那种空话连篇的。

它给了你它见过的平均水平的周报。它做得完全正确。

这一章要讲的，就是怎么把话说清楚。

提示词的本质：给它足够的线索

先把原理说清楚，这样你后面就不是在背技巧，而是在做判断。

还记得第 4 章那个"猜下一个字"的机制吗？

你给的提示词，就是它猜字的起点。你给的线索越具体，它猜的方向就越窄，命中你要的那个答案的概率就越高。

打个比方。你在一个巨大的图书馆里找人帮忙。你说"帮我找本书"，馆员只能随便给你拿一本。你说"帮我找一本讲家庭理财的，适合完全不懂投资的上班族，不要讲股票的，最好是近三年出版的"，馆员就能准确拿到你要的。

AI 就是那个馆员。它能力很强，但它只会顺着你说的话去想。

所以提示词工程（prompt engineering）这件事，本质上不是"操控技巧"，而是把需求说清楚的能力。这个能力你做任何工作都需要，只是现在用在了 AI 身上。

四个基本动作

所有好用的提示词，都可以拆成四个动作。不是每一个都需要有，但少了哪一个，你就少给了一类线索。

动作一：给角色

告诉它"你是谁"。

不是玄学。原因是角色这个词会激活模型内部对应领域的语言模式。你说"你是一位有十年经验的财务总监"，它生成的文字就会带上财务总监的表达习惯和关注点。

差的写法：帮我看看这份预算。

好的写法：你是一位有十年经验的企业财务总监，负责审核各部门预算。请帮我审核下面这份预算，重点看有没有不合理的开支。

区别在哪？差的那版，它可能给你一堆"预算很重要"的空话。好的那版，它会真的开始挑毛病。

一个实用提醒：角色不要给得太虚。"你是一位专家"不如"你是一位带过 20 人团队的中学班主任"。"你是资深人士"不如"你做了八年外贸报关"。

动作二：给任务

明确说要它做什么，而且只做一件事。

大语言模型最容易犯的错之一，是你给它一个模糊的大任务，它会平均用力，每部分都写得浮于表面。

差的写法：帮我优化一下这份方案。

好的写法：请把下面这份方案的第 3 部分"执行计划"改得更具体。具体要求：把每个步骤的时间节点补上，把负责人从岗位改成具体角色，把"加强沟通"这类笼统描述换成可以检查的动作。

如果你确实有多个任务，那就分成几轮问。一轮一个任务，质量明显更高。

动作三：给约束

约束是所有动作里最容易被忽略、但效果最明显的一个。

约束包括：长度、语气、格式、受众、需要包含什么、不能出现什么。

长度：控制在 500 字以内 / 分成 3 个小节 / 每节不超过 4 句话。

语气：正式一点 / 口语化，像跟朋友聊天 / 别太热情，保持克制。

格式：用表格 / 用编号列表 / 分点写，每点先给结论再给理由。

受众：给完全不懂技术的老板看 / 给专业同事看，可以用术语。

禁止项：不要用互联网黑话和空话 / 不要写"综上所述" / 不要出现感叹号。

最后这条"禁止项"特别好用。它能让输出的味道立刻变干净。

动作四：给样例

这是四招里威力最大的一招，也是用得最少的一招。

直接给它一个你满意的例子。

比如你想让它按某种风格写产品介绍：

这是我之前写的一段，请参照这个风格给新产品写一段：

"这把伞不防水，它挡住一场暴雨的方式，是让你在伞下待得足够久，久到雨停。"

它看完这个例子，不需要你解释"要文学一点""要有留白""别太直白"，它直接就能抓住你要的味道。

样例的威力在于：它把"风格"这个很难用语言描述的东西，变成了可以直接模仿的模式。

一个经验：一个好的例子，胜过十句形容词。

完整走一遍

现在把这四个动作合起来。任务是：陈默要写一份部门例会的通知。

第一版（他原来的写法）

帮我写个会议通知。

第二版（四个动作都用上）

你是一位在公司做了八年的行政主管，熟悉企业内部沟通的规范。

请帮我写一份部门例会通知，发在企业微信群里。

要求：
- 200 字以内
- 语气正式但不生硬，不要"特此通知"这类公文腔
- 需要包含：时间（本周五下午 2 点）、地点（三楼小会议室）、议题（下季度目标拆解）、需要准备的材料（各自的季度数据）
- 最后加一句请假的说明
- 不要用"各位同仁""记得"这类词

这是一份我们以前发过的通知，可以参考语气：
"下周三上午十点，三楼会议室，聊一下新系统的使用情况。需要大家提前把自己遇到的问题记下来，带着问题来。"

第二版出来的结果，陈默基本没改就直接发了。

一个可以套用的模板

把四个动作固定下来，就得到一个模板。你可以把它存在备忘录里，随时改。

【角色】你是一位＿＿＿＿（具体身份、年限、擅长什么）

【任务】请帮我＿＿＿＿（一个动作，越具体越好）

【背景】＿＿＿＿（必要的信息、数据、限制条件）

【要求】
- 长度：＿＿＿＿
- 语气：＿＿＿＿
- 格式：＿＿＿＿
- 受众：＿＿＿＿
- 需要包含：＿＿＿＿
- 不要出现：＿＿＿＿

【样例】这是我之前写的一个，请参考风格：
＿＿＿＿

第一次用会有点麻烦。用三四次之后，你会发现自己的思考方式变了，你开始自然地想清楚"我到底要什么"。这件事本身就有价值。

边界与坑

第一，不是每次都要写这么长。

日常随口问一句"这句话怎么翻译得更地道"，不需要套模板。模板用在重要任务上，比如写方案、写对外文案、处理数据。判断标准很简单：如果这件事你愿意花二十分钟自己做，那就花两分钟写提示词。

第二，别把提示词写成小说。

把所有细节都塞进去，超过某个长度后效果反而会下降。因为重要信息会被淹没。控制在合理长度，把最关键的几条放在最前面。

第三，措辞的小差异会带来输出的差异。

同一个要求，说法不同，效果可能不同。比如"不要写得太长"不如"控制在 300 字以内"。能用数字就用数字，能举例子就举例子。 抽象的形容词，它会按自己的理解猜。

第四，别指望一次到位。

第一次的输出通常是"方向对了但细节不对"。正确的用法不是重新写一遍提示词，而是直接在对话里说"第 2 段太啰嗦了，压缩一半""语气再收一点"。对话是可以来回的，用起来。

第五，它不会因为你反复强调就变准。

如果你说"请记得准确，不要出错"，效果非常有限。这句话没有提供任何新信息。想提高准确性，靠的是给它资料、要求它引用、让它分步做，这些是第 10 章和第 16 章的内容。

五个任务的"差 / 好"对照

四个动作讲完了，这里给你五组对照。每一组都是同一件事的两种问法，你可以直接对照自己的习惯。

对照一：做决策建议

差的：我该不该换工作？

好的：

你是一位在同一个行业做了十几年的职业顾问。
我现在面临一个选择，请帮我梳理，不要给我结论。
背景：现在这家公司待了 5 年，薪资中等但稳定，团队关系好；新机会薪资高 30%，但公司成立 3 年、业务方向还在调整。
请帮我列出：1) 我需要自己回答的关键问题（至少 6 个）2) 每个问题的答案会如何影响判断 3) 我可能忽略的角度。
最后不要写"建议你如何选择"。

为什么更好：第一版它只能给你一堆通用的"要考虑薪资、要考虑发展"。第二版它给你一张决策地图，而选择权还在你手上。

对照二：写工作总结

差的：帮我写一份季度总结。

好的：

你是一位擅长写内部汇报的部门负责人。
以下是本季度我做的所有事情，很乱。请整理成一份季度总结：
- 按"主要成果""关键问题""下季度重点"三块
- 每块不超过 4 条
- 每条格式为"做了什么 → 带来了什么结果"
- 成果部分优先写有数字的
- 不要写"在领导的关心下"这类话
我做的事情：＿＿＿

为什么更好：它把"写"变成了"整理"，忠实于你给的内容，不会自己编。

对照三：解释一个概念

差的：什么是机会成本？

好的：

假设我是完全不懂经济学的上班族。
请用三个层次解释"机会成本"：
1. 一句话说清（不超过 25 字）
2. 一个我日常生活中会遇到的例子（要具体到能算出来）
3. 我可能误解它的地方
不要用"资源配置""效用"这类词。

为什么更好：第 3 层是真正有价值的部分，而"不要用某些词"这句约束能强制它说人话。

对照四：改一段文字

差的：帮我润色一下这段。

好的：

请修改下面这段文字，只做三件事：
1. 把超过 40 字的长句拆开
2. 删掉所有"其实""基本上""在一定程度上"这类虚词
3. 把被动句改成主动句
除此之外不要改动任何内容，不要调换段落顺序，不要增加新内容。
原文：＿＿＿

为什么更好：这是一条很实用的经验："改"比"写"更需要约束。 不给约束，它会顺手把你的意思也改了。

对照五：做一个计划

差的：帮我做个学习计划。

好的：

你是一位带过很多零基础学员的教练。
我要在 3 个月内学会用 AI 处理工作中的文档和数据。每周可投入 5 小时，只能在工作日晚上。
请先做一件事：问我 5 个你需要了解的问题，再给计划。
计划要求：按周排，每周写明"学什么 + 做什么产出"，产出需要是能给别人看的东西。

为什么更好：先反问这一步很关键。它会问出"你的工作中哪类文档最多""你现在用的是什么工具"这类你没想到但很重要的问题。

对照完之后

回头看这五组，你会发现一个共同点：

"好"的那一版，做的都是同一件事，把"我要什么"想清楚了。

这就是为什么第 9 章开头说，提示词不是操控技巧，是表达能力。你不是在学怎么骗过机器，你是在学怎么把需求想清楚。

这个能力，你写需求文档、布置任务、跟同事沟通时，用的都是同一套。

本章收束

三句话：

提示词不是操控技巧，是把需求说清楚的能力。线索越具体，它猜得越准。 四个基本动作：给角色、给任务、给约束、给样例。样例的威力最大。 能用数字就别用形容词；能来回改就别重写。

陈默这一次没有再关掉窗口。他发现自己写的第二版通知，改动的过程中其实是在想清楚"这次会议到底要干什么"，这件事，以前他从来没认真想过。

第 10 章会再进一步：怎么让 AI 的输出稳定。不是偶尔好用，而是每次都按你要的格式、你要的规矩来。

何宇是财务经理，35 岁，每天和表格打交道。

他用 AI 的经历很有意思。最开始他让 AI 帮他整理一份费用明细的说明，结果很好，他很高兴。第二天他换了一批数据再问，结果格式全变了，昨天分三段，今天分了五点；昨天用"元"，今天用"¥"。

他不是不满意内容，他是不满意每次都要重新排版。对做财务的人来说，这意味着每次都得手工过一遍，省下来的时间又还回去了。

何宇遇到的问题很典型。从"能用"到"好用"之间，隔着一道门槛，这道门槛叫一致性。

这一章不讲新概念，只讲四组具体的技术动作，目的都是同一件事：让输出稳定。

第一组：把格式说死

先解决何宇的问题。

模型每次输出格式不一样，是因为格式这件事它默认是"随便"的，只要合理就行。你要做的，是把格式从"随便"变成"规定"。

方法一：直接规定结构。

请严格按以下结构输出，不要增减小节：

一、总览（不超过 50 字）
二、明细（表格形式，三列：项目 | 金额 | 备注）
三、异常说明（如果有，没有就写"无"）

标题用"一、二、三"，不要用 Markdown 的 # 号。

关键在最后那句"不要增减小节"。不说这句，它可能会热心地给你加一节"建议"。

方法二：给一个空模板让它填。

这是最稳的方法。

请严格按下面的格式输出，把方括号里的内容替换掉，其余部分照抄：

【费用类别】＿＿＿
【本月总额】＿＿＿元
【环比变化】＿＿＿
【主要变动原因】＿＿＿
【需要关注的项目】＿＿＿

方法三：要机器可读的格式。

如果你要把结果粘进表格或者其他程序，直接要 CSV 或 JSON。

请以 CSV 格式输出，第一行是表头：项目,金额,日期,备注。不要加任何解释文字，不要用代码块包裹。

最后半句很重要。不加这句话，它很可能把结果包在三个反引号里面，你还得手工去掉。

第二组：让它先想再答

有一个简单到不像技巧的技巧，效果却很好：要求它先写出思考过程，再给结论。

请先一步步分析，把推理过程写出来，然后在最后用一行给出最终结论，格式为"结论：＿＿＿"。

为什么有效？

回到第 4 章。模型一次只猜一个字。如果直接让它给答案，它需要"一步到位"，中间没有任何余地。而如果让它先写过程，它相当于把中间步骤显式地写了出来，后续的字都要和前面写下的内容保持一致。这无形中减少了它跳步和猜错的概率。

这个方法的正式说法叫思维链（chain of thought）。

有个附带的好处：你能看到它是怎么错的。

如果结论错了但过程里某一步就歪了，你一眼能看出问题在哪。如果直接给结论，你只能判断"不对"，然后重来。

但要注意第 6 章提到过的那个发现：想得更久未必更准。有研究观察到，某些任务上把思考预算开到最大，幻觉率反而上升。原因是过长的推理链给了它更多"生成看似合理但脱离实际"的中间步骤的机会。

所以务实的做法是：需要分析和计算的场景用思维链，需要事实准确性的场景不要指望它，去给它资料。

第三组：把它当成会来回改的同事

这是初学者最不习惯、也最影响效率的一点。

很多人拿到第一次输出不满意，就重写一遍提示词，再问一遍。结果还是不满意，然后放弃了。

正确的做法是：把这次对话当成一次协作，直接在原文上提修改意见。

比如：

整体不错。改三处：
1. 第 2 段"综上所述"开头的那句删掉，直接给结论
2. 第 4 点和第 5 点合并，它们说的是同一件事
3. 最后加一个 100 字以内的摘要

这种"指哪打哪"的改法，比重新问一遍快得多，结果也准得多。

为什么：因为在同一轮对话里，它能看到你之前给的所有信息和自己写的所有内容。重新开一轮，之前的上下文就全丢了，你得重新建立。

有个经验法则：前三轮对话如果还没得到能用的东西，问题通常在提示词，不在迭代。 这时该退回去补信息，而不是继续来回磨。

第四组：让它自己找漏洞

这是最容易被忽略、但价值极高的一组动作。核心思路是：别让它只当执行者，让它当审查者。

用法一：让它先提问。

我要做一份部门年度总结。在你开始写之前，先问我 5 个你需要了解的问题。

第一次看到这个方法的人会有点惊讶。它确实会问出一些你自己都没想到的关键点，比如"这份总结是给上级看还是给部门内部看""今年有没有特别需要淡化的事件"。

这一步花两分钟，能省掉后面半小时的返工。

用法二：让它扮演批评者。

请你扮演一位对这份方案持怀疑态度的部门负责人。列出这份方案最可能被质疑的 5 个地方，每个地方说明对方会怎么问。

用法三：让它自己检查。

请检查你上面给出的内容，找出其中可能不准确或者缺乏依据的地方，逐条列出来。

这三个用法有一个前提：不能指望它的自我检查能发现所有错误。前面讲过，它对自己错在哪里是不敏感的。它的"自我检查"仍然是生成出来的文字。

但它的价值在于：它会把你的注意力引导到几个具体的位置。 很多错误，是你一看就知道不对的，只是你原本没想到要看那里。

一个可以直接用的提示词库

把前面这些固化下来，形成几个模板。以后遇到同类任务，改几个字就能用。

模板一：结构化输出

请按以下结构输出，严格照抄标题，不要增减小节，不要用 Markdown 标题符号：
一、＿＿（不超过＿＿字）
二、＿＿（＿＿形式，列为：｜｜｜）
三、＿＿（如果没有，写"无"）

模板二：先分析后结论

请先分步骤分析，把推理过程写出来。
每一步用"第 N 步："开头。
最后一行给出结论，格式为"结论：＿＿"。
如果信息不足，直接写"结论：无法判断"，不要推测。

模板三：批改模式

以下是我写的初稿。请做三件事：
1. 指出 3 个最明显的缺点（说得具体，不要"不够深入"这类评价）
2. 针对每个缺点给一句具体的修改建议
3. 只重写最需要改的那一段，其余不要动
初稿：＿＿

模板四：对抗审查

请你扮演＿＿（一个会反对这个方案的角色），
列出这份内容最可能被质疑的 5 处，
每处写明：质疑点 + 对方可能的原话 + 我该怎么回应。

注意模板三和模板四里那句"说得具体，不要×××这类评价"。这类否定性约束很好用，能有效阻止它输出正确的废话。

边界与坑

第一，格式约束要放在最后。

提示词的结构有个经验顺序：背景 → 任务 → 要求 → 格式。格式放最后，因为它是最容易被"忘记"的部分。放在开头，写到后面它可能已经忘了。

第二，不要同时要太多东西。

"既要简短又要全面，既要专业又要通俗，既要严谨又要有感染力"，这类互相冲突的要求会让它平均一下，结果四不像。冲突的要求要自己先想清楚优先级。

第三，长对话会"跑偏"。

对话轮次多了，前面的要求会被慢慢稀释。如果你发现它开始不守规矩了，不要继续纠正，直接开一个新对话，把最关键的上下文重新给它。

第四，注意不同产品的行为差异。

同一个提示词，在不同产品上的表现会不一样。有的产品在后台会偷偷给你补一段系统提示，有的不会。这是正常现象，多试几次就有感觉了。

第五，模板是起点，不是终点。

上面那些模板用三次之后，你会发现自己的习惯用法。那些自己长出来的写法，通常比通用模板更适合你的工作。

三个完整案例

前面是技术拆解，这里走三个完整流程。从原始需求到稳定输出，每一步都写出来。

案例一：把一段混乱的会议记录变成待办清单

原始输入（截取一段）：

关于新系统上线，老张说测试环境还有问题，小刘说文档下周三能给。李总说时间不能再拖了，尽量月底上。王姐提了一句培训没人做。后面又聊到预算的事，说先按原方案走。老张还想说测试环境的事，李总说先这样。

第一轮提示词：

请把下面这段会议记录整理成待办清单。
输出格式：表格，三列，事项 | 负责人 | 时间节点。
如果某一项原文没有明确负责人或时间，填"未明确"，不要推测。
最后单独列出"讨论了但没有结论的问题"。
记录：＿＿＿

它的输出（大意）：

讨论了但没有结论的问题：测试环境问题的具体处理方案。

第二轮提示词（追问）：

很好。现在再做一件事：把"未明确"的项目单独列出来，每一条写一句我该去找谁确认。

它输出：上线时间需要向李总确认（他说"尽量月底"，但没拍板）；培训负责人需要在下次会上指定；预算的决策人需要确认。

这个案例的关键动作：

• 明确规定了"未明确就填未明确，不要推测"：这是最重要的一句
• 要求区分"已决定"和"讨论过"
• 第二轮让它指出"我该去找谁"，把清单变成了行动

案例二：把一份数据说明改成给人看的话

原始需求：何宇要把一段枯燥的数据说明，改成总监能一眼看懂的版本。

第一轮：

请把下面这段数据说明，改写成一段给公司管理层看的文字。
要求：
- 200 字以内
- 不要出现"环比""同比""同比增速"这类词，用大白话说变化
- 先给结论，再给原因
- 至少用一个具体的数字对比让变化可感知
原文：＿＿＿

它的输出：本月销售额 860 万，比上月少了 120 万。主要原因是华东区三家门店因装修停业了两周，这三家店平时每月贡献约 90 万。其他区域与上月基本持平。下月三家店恢复营业，预计能回到上月水平。

第二轮（想再稳一点）：

很好。请再给我一个更短的版本，控制在 80 字以内，只要结论和最关键的那个原因。

它输出：本月销售额 860 万，环比少 120 万，主要因为华东三家店装修停业两周（这三家平时月均贡献 90 万）。下月恢复营业。

这个案例的关键动作：

• 用"不要出现某些词"来强制它说人话：这比说"请用通俗语言"有效得多
• 第一轮要完整版，第二轮要压缩版，两次分开要
• 明确"先结论后原因"，避免它铺垫半天

案例三：批量处理同类内容

需求：林晓青要给 30 篇学生作文写评语。

第一份提示词（建立标准）：

你是一位中学语文老师，写评语的特点是：具体、不空泛、先肯定再建议、每条评语不超过 100 字。
这是第一篇作文，请写一段评语。
参考我以前的评语风格：
"这篇文章的开头很有画面感，'窗外的雨敲在铁皮棚上'这一句特别生动。结尾稍显仓促，如果能再补一句你自己的感受会更完整。"
作文内容：＿＿＿

后续的提示词（批量复用）：

很好，就按这个风格。现在给你第二篇，请按同样的标准写评语。
作文内容：＿＿＿

这个案例的关键动作：

• 先定标准，再批量。第一篇花时间调好，后面 29 篇直接复用
• 给了样例（这是第 9 章四个动作里威力最大的一个）
• 后续只替换内容，不改要求

一个提醒：30 篇不要挤在一个对话里做完。第 19 章会解释为什么，上下文会累积，越往后越贵，而且它到后面可能"忘了"你最初的标准。分批做，每 8 到 10 篇开一个新对话，把标准和样例重新带上。

三个案例的共同结构

回头看，它们都是同一套流程：

1. 说清楚要素（角色、任务、约束、样例）
2. 要求一个可验证的格式（表格、字数上限、分块）
3. 明确"不知道就说不确定"
4. 第一轮出方向，第二轮调细节
5. 批量任务：先定标准，再复用

这套流程能覆盖你 80% 的日常任务。 熟练之后，写提示词的时间会从十分钟降到一分钟。

本章收束

四句话：

要稳定，就把格式说死，给结构、给空模板，或者直接要 CSV。 需要分析就用思维链：先让它写过程，再给结论。 不满意就直接提修改意见，别重问一遍。 最好用的一个动作是让它当审查者，先提问、再批改、或者扮演反对者。

到这里，你已经掌握了怎么和 AI 说话。接下来是三章最实用的内容：用它来写东西（第 11 章）、读东西（第 12 章）、处理数据（第 13 章）。

第 11 章会给你一整套"写作类"的完整示例，每一种文体都有可以直接抄的做法。

林晓青教语文，也写了不少东西。教案、家长信、评语、教研文章。她是最适合用 AI 写字的那类人，不是不会写，而是写得太多，重复劳动太多。

她第一次用 AI 的时候犯了一个错误，很多人都会犯：她让 AI"帮我写一篇关于春天的作文范文"，然后对着输出摇头，觉得比学生写的还套。

后来她换了方式：先把自己想表达的意思写成几句大白话，再让 AI 帮她组织成文。效果立刻不一样了。

这个差别背后是一条重要原则：AI 不是替你想说什么，是替你把想说的话说好。

这一章按文体分四块，每块都给具体做法。最后给一个通用工作流。

通用工作流：先给料，再给架子，最后才让它写

在讲具体文体之前，先说这个流程。它适用于所有写作任务。

第一步，给它原料。

写完一封重要邮件，你脑子里其实已经有内容了，只是不知道怎么组织。那就先把这些内容倒出来，不管多糙。

我要给客户写一封邮件，事情是这样：
1. 上周发的货有一箱外包装破损了
2. 我们已经重新发了一箱，昨天发出
3. 想让他确认一下收货，另外解释一下我们会承担这次的全部运费
4. 他是老客户，态度要诚恳但不能太卑微

第二步，给它架子。

请按这个结构组织：先致歉并说明处理结果 → 说明具体安排 → 说明补偿 → 收尾，表达长期合作的意愿。

第三步，让它写。

第四步，你自己改。

这一步不能省。AI 写出来的东西是"合格品"，不是"你的东西"。你要把它改成自己的语气，加上只有你知道的细节。改的过程其实也是想清楚的过程，而这个过程本身就是价值。

很多人跳过第四步，结果写出来的东西都有一股相同的味道。别人一看就知道是 AI 写的。

一、邮件

邮件是最适合 AI 的场景之一：结构固定、场景重复、对准确性要求相对低。

场景一：难写的邮件

越是不好开口的邮件，越适合先让 AI 给你几个版本。

我要拒绝一个合作方，但不想伤和气。

背景：对方是一家小公司，主动找我们谈合作，但他们的产品和我们现有方向不匹配。我们老板和他认识，所以不能太生硬。

请给我三个不同风格的版本：
A. 直接但礼貌
B. 委婉，把原因落在"方向不匹配"上
C. 不明确拒绝，先保持联系

每版 150 字以内。

这个用法的高价值在于：它给你三个不同的角度，你挑一个，或者混着改。比你自己在电脑前卡半小时强得多。

场景二：批量邮件

如果需要给不同对象发同类邮件，先做一个模板，再让它填。

这是我们的产品更新通知模板，请为下面 5 个客户分别写一版，把方括号里的内容替换掉：

"【客户称呼】您好，我们的系统将在【时间】进行升级，本次主要变化是【变化点】。对您的影响是【影响】。如有疑问请联系【联系人】。"

客户信息：
1. 张经理，使用模块 A、C，升级时间 3 月 5 日……
2. ……

场景三：回复难缠的邮件

这是对方发来的邮件，语气比较冲，在质疑我们的交付时间。
请帮我起草一份回复，要求：
- 不下跪，也不对抗
- 先承认对方关切的合理性
- 用事实说明实际进度
- 给出一个具体的解决时间
- 最后一句要留有继续沟通的空间

二、报告与总结

这类文体的特点是：结构大于文采，事实大于修辞。

周报、月报

不要让它"写"周报，让它"整理"周报。

这是我这一周的流水记录，很乱。请帮我整理成周报，按"已完成""进行中""待解决""下周计划"四块，每块不超过 5 条，每条用"做了什么 + 结果是什么"的格式。

流水：＿＿

这个思路的差别很大。让它"写"，它会给你空话；让它"整理"，它会忠实于你给的内容。

工作总结、述职

我要写年度述职报告。以下是今年的主要工作。

请先帮我做两件事：
1. 把这些工作归成 3 到 4 个主题（不要按时间顺序，按价值归类）
2. 每个主题下，指出哪个成果最值得重点写，为什么

我确认主题之后，再写正文。

今年的工作：＿＿

注意"我确认主题之后，再写正文"这句。先让它做结构，你确认了再写内容。 这一步能避免大量返工。

调研报告

请按以下结构写一份调研报告：
一、背景与目的（200 字）
二、现状（分 3 点，每点先结论后论据）
三、主要问题（分 3 点，每点要具体，不要"机制不健全"这类空话）
四、建议（分 3 点，每点要写清楚"谁、做什么、什么时候"）
五、风险提示

下面是调研收集到的原始材料：＿＿

三、文案

营销文案是最容易看出 AI 味的地方。因为这类文本最需要"人味"，而 AI 的默认风格恰好是"没有味道的正确"。

让它出多个方向，而不是多个版本

关键技巧：不要让它"再多写几个"，而是让它"换几个不同的角度写"。

给这款降噪耳机写 5 条朋友圈文案。要求每条走不同的路子：
1. 打一个通勤场景（地铁上的噪音）
2. 打一个反差（很安静但你没发现）
3. 打一句让人记住的话
4. 打一个使用细节
5. 用自嘲的语气

每条不超过 30 字，不要出现"降噪神器""静享世界"这类词。

那句"不要出现×××这类词"特别重要。它自动帮你滤掉了 AI 最容易冒出来的那批烂词。

一个自查动作

写完之后加这一句：

请把上面 5 条里最像广告词、最套路的那两条标出来。

这个动作能让它帮你筛一遍自己的平庸输出。

四、方案与计划

方案写作的核心不是文字，是逻辑。而逻辑恰好是可以借力的地方。

让它先挑毛病

我要做一份新员工培训方案。在写之前，请先列出这类方案最常见的 5 个失败原因。

它给出的答案会直接提醒你避开坑。

让它把模糊变具体

下面这份方案里，把所有"加强""完善""提升""优化"这类词找出来，逐个改成可以检查的具体动作。

方案：＿＿

这个用法几乎每次都能揪出十几处空洞表述。

让它做风险预演

这份计划如果失败了，最可能的原因是什么？请列出 5 条，按可能性排序。

四类文体的对照表

边界与坑

第一，语气要自己过一遍。

AI 的默认语气偏"周到"，喜欢加客套话和过渡句。这类东西在中文语境里容易显得假。发出去之前，把"非常感谢您""期待与您进一步沟通"这类句子按需删掉。

第二，不要让 AI 替你表达立场。

尤其是涉及利益、责任、承诺的内容。它可以帮你把话说得好听，但"答应什么、不答应什么"需要你自己定。这个边界不能让它越过去。

第三，注意信息的准确性。

如果邮件里要写具体数字、日期、人名、金额，逐项核对。这类错误一旦发出去，代价很大。

第四，不要跳过"改"这一步。

改的时候你其实在做一件事：把它的通用表达，替换成只有你知道的具体细节。这一步做完，文章才有你的痕迹。

第五，重要的东西不要完全交给它。

对外发布的内容、法律文书、涉及重大利益的沟通，AI 只能当起草工具。定稿需要经过有责任能力的人。

三份完整成品示例

前面讲的都是方法，这里给你三份"输入什么、输出什么"的完整对照。你可以直接照着改。

示例一：一封处理投诉的邮件

你给它的原料：

客户投诉我们上批货有 3 箱外包装破损，要求换货并赔偿。
实际情况：破损是我们这边装箱时没垫够缓冲材料造成的，责任在我们。
已经处理：昨天补发了 3 箱新的，运费我们承担。
我的想法：认错，但不提赔偿金额，先看客户后续反应。
这个客户合作 3 年，年采购额不小。

你的提示词：

你是一位做了十年客户服务的主管，语气特点是诚恳、不推责、不卑微。
请按以下结构写一封邮件：
1. 开门见山说明问题已处理（不超过 3 句）
2. 承认是我们的原因，不要用"可能是运输过程中"这类模糊表述
3. 说明具体已做的事
4. 询问客户对处理结果是否满意，并说明如果还有问题会继续跟进
5. 收尾，不卑不亢
全文 250 字以内，不要用"深感抱歉""万分歉意"这类过重的词，不要出现感叹号。
原料：＿＿＿

它输出的成品（大意）：

X 总您好：

上批货中 3 箱外包装破损的问题，已经处理完了：新的 3 箱昨天已发出，运费由我们承担。

这次的破损出在我们自己的装箱环节，缓冲材料没有垫足，是我们的责任。

我们已经在装箱流程里加了双重检查，避免再出同类问题。

麻烦您确认一下新货到货后是否正常。如果还有任何问题，请直接跟我说，我这边跟到底。

合作三年，谢谢您一直以来的信任。

＿＿＿

你要做的最后一步：把"X 总"换成真名，把"三年"核实一下，然后检查有没有承诺了你做不到的事。

注意最后一步。 AI 生成的邮件最容易出问题的地方，不是语气，是它替你做出了你还没决定要做的承诺。这封里"已经在装箱流程里加了双重检查"如果还没做，就需要删掉。

示例二：一份周报

你给它的原料（你自己随手记的流水）：

周一：跟供应商 A 谈价格，对方让步 3 个点
周二：处理系统故障，影响 2 小时
周三：做完 Q2 的活动方案初稿
周四：和产品部开会，确定新功能验收时间
周五：面试 2 个人，都不太合适
另外：一直在推的库存盘点系统，供应商那边一直没给报价

你的提示词：

请把下面的流水整理成周报。
结构：主要进展 / 问题与风险 / 下周计划。
每部分不超过 4 条，每条格式为"做了什么 → 结果"。
有数字的优先写数字。
问题与风险部分要写清楚"卡在哪、需要谁支持"。
不要加"本周工作总体顺利"这类开头。

它输出的成品（大意）：

主要进展
- 与供应商 A 完成价格谈判 → 对方让步 3 个百分点
- Q2 活动方案初稿完成 → 已进入内部评审
- 与产品部确认新功能验收时间 → 时间已锁定

问题与风险
- 系统故障 2 小时 → 已恢复，具体原因待复盘
- 库存盘点系统报价迟迟未到 → 卡在供应商侧，需要采购部门协助催办
- 招聘进度滞后 → 本周面试 2 人均不匹配，需调整岗位要求

下周计划
- 完成活动方案评审并定稿
- 推动库存盘点系统报价敲定
- 重新梳理招聘画像，扩大筛选范围

这个版本的价值：它把"我做了很多事"变成了"我推进了什么、卡在哪、需要什么"。第二块是最有价值的，因为它是向上沟通时真正需要传递的信息。

示例三：一份活动方案

你给它的原料：

要做一个老客户答谢活动。
预算 5 万，客户大概 80 家。
想做得有点意思但不要太浮夸，公司风格偏务实。
时间定在下个月中旬。
没有定的是：具体形式、场地、要不要送礼品。

第一轮提示词（先要结构，不要成品）：

我要做一个老客户答谢活动，预算 5 万，客户 80 家，公司风格务实。
请先不要写方案。先做三件事：
1. 列出这类活动通常有哪几种形式，各自适合什么情况
2. 针对我的情况，指出哪种形式最合适，说清理由
3. 列出我需要在方案里明确但目前还没定的事项
不要给最终推荐方案。

它的输出（大意）：形式大致分四类，纯社交型（酒会、参观）、价值输出型（论坛、闭门分享）、体验型（工作坊、短途）、回馈型（礼品、优惠）。针对 80 家客户、5 万预算、务实风格，价值输出型或体验型更合适，因为纯社交型在预算内很难做出质感，回馈型缺乏记忆点。需要明确但目前未定的事项：核心目的是维护关系还是促成续约、客户是否带家属、是否允许拍照传播、礼品的合规要求。

第二轮提示词（确认方向后再写）：

目的定为维护关系并初步沟通续约意愿。选价值输出型。
现在请写方案，结构：目标 / 形式与流程 / 时间安排 / 预算分配 / 风险与备选。
预算按 5 万拆，每一项给出金额区间。
流程要精确到分钟。
风险部分至少写 4 条。

这个案例的关键动作：

• 第一轮只要结构，不要成品，避免它直接给你一份华丽的空壳
• 第二轮带着你确认过的方向再要成品
• 要求"精确到分钟"和"预算拆到项"，这两个要求会立刻暴露方案里没想清楚的地方

从这三份成品里学什么

三份东西放在一起看，有一个共同的规律：

它的输出质量，几乎完全取决于你给的原料质量。

示例一里，因为你说清了"责任在我们""不提赔偿金额"，它才能写出那封不推责也不乱承诺的邮件。示例二里，因为你的流水里有具体数字和具体难处，它才能整理出有信息量的周报。

所以如果你觉得 AI 写的东西不行，第一个要检查的不是提示词，是你给的料够不够。

一个实用习惯：以后要让它写东西之前，先花三分钟把原料倒在备忘录里。不用整理，倒出来就行。这三分钟是整件事里投入产出比最高的部分。

本章收束

三句话：

AI 不是替你想说什么，是替你把想说的话说好。所以先给料，再给架子，最后让它写。 报告类要让它"整理"不要让它"写"；文案类要让它换角度不要让它加量。 最好的三个动作：让它先挑毛病、让它把模糊变具体、让它做风险预演。

第 11 章解决的是"写出去"。第 12 章反过来，解决"读进来"。当你面前摆着三份两百页的材料，怎么在半小时里抓住重点。

赵砚的电脑里存着三百多份文件。产品手册、行业报告、客户合同、竞品资料、还有一堆供应商发来的 PDF。

他不是读不过来，他是根本不知道该读哪一份。

有一次他需要判断一个新产品值不值得代理。他花了两个晚上读完三份行业报告，看晕了，最后还是凭感觉做了决定。事后他反思，觉得自己那两个晚上既没读出重点，也没形成判断。

这是"信息过剩"的典型症状：材料不缺，缺的是从材料里提取判断的能力。

AI 在这件事上能帮很大的忙。但用法和写字完全相反，写字是"生成"，读东西是"提取"。提取的规则是：先要骨架，再要细节，最后需要核实。

三步法

记住这三步，它适用于所有"让 AI 读材料"的场景。

第一步：先要骨架

很多人拿到一份长文档，第一反应是问"帮我总结一下"。

不好。因为总结是平的，它会把重要和不重要的东西压成同样分量的一段话。你读完还是不知道该看哪里。

更好的做法是先问结构：

我上传了一篇行业报告。请先不要总结内容，先告诉我它的结构：
1. 一共分了哪几个部分，每个部分讲什么
2. 作者的核心观点是什么（用一句话）
3. 哪一部分是重点，哪一部分可以跳过
4. 作者有没有明确的数据支撑，还是主要靠观点

你拿到这张结构图之后，才知道自己关心哪一块。

这一步的价值在于：它帮你决定"要不要细读"，而不是直接替你把材料嚼碎。

第二步：带着问题要细节

确定关心的部分之后，再深挖。

请把这部分里所有涉及"市场规模"的数据列出来，标注在原文的哪个位置。
如果原文没有给出某个数据的来源，也请标出来。

注意最后那句。要求它标注位置和来源，是"读材料"这件事里最重要的一个动作。

原因有几个。第一，你可以快速核对。第二，它会显著降低它胡编的概率，因为它知道你会去查。第三，如果它标不出来位置，那基本可以判定这段内容是它自己"生成"的，不是从材料里提出来的。

第 5 章给过一个数据：要求模型标注引用，可以减少 30% 到 60% 的无依据论断。这个技巧是免费的，效果还很明显。 来源：2026 年幻觉缓解效果研究

第三步：核实关键点

这一步不能省。

具体做法：从它的输出里，挑 3 个对你决策影响最大的点，回到原文核对。

不是核对全部，那你就自己读完了。是核对最关键的几个。这叫抽样验证。

如果这三个都对，你可以对整体质量有个基本信心。如果其中一个不对，那你需要提高警惕，扩大核对范围。

文档太长装不下怎么办

第 5 章讲过上下文窗口。当你上传的文档超出窗口时，会发生一件很危险的事：它不会报错，它只是看不到后面的部分。

你问它"文档里有没有提到 X"，它回答"没有提到"。但真相是文档后半部分提到了，只是它没看到。

判断方法：如果你上传的文档明显很长（比如超过一百页），先问一句：

请确认你已经看到了这份文档的全部内容。文档总共多少页？最后一段讲的是什么？

它的回答如果对不上，就说明没读全。

处理办法有四种：

一、分段处理。 按章节拆开，一次给它一部分。先用每段的关键信息，最后自己汇总。这是最可靠的做法。

二、先分层再深入。 先让它给一个粗糙的整体框架，再针对你关心的部分单独上传。

三、先提取再分析。 让它先把你要的关键信息提取成一个列表，后续只在列表上工作。

四、使用支持大窗口的产品。 但即使是超大窗口，也要注意"迷失在中间"的问题，重要信息放在开头或结尾。

会议记录

这是最实用、最容易见效的一个场景。

录音转文字 + 提炼

流程是两步：先用语音转写工具把录音变成文字，再让 AI 提炼。

提炼的提示词可以这样写：

这是一段 45 分钟的会议录音转写稿。请输出三块内容：

一、结论与决定（只写明确拍板的，不要写"大家讨论了"）
二、待办事项（表格：事项 | 负责人 | 时间节点；原文没提到的写"未明确"）
三、悬而未决的问题（讨论了但没结论的）

注意：
- 转写稿可能有错别字或说话人识别错误，遇到明显不通顺的地方按语义合理修正，不要臆造内容
- 如果某件事有两种理解，标注出来，不要替我选

那段"不要臆造内容"很关键。会议记录一旦出错，可能直接影响后续工作。

说话人识别

如果转写稿没有区分说话人，可以让它试着推断：

请判断每段话是谁说的，输出格式为"【说话人】内容"。如果不确定就标"未知"。

这个功能有时准有时不准，尤其是多人抢话的时候。作为辅助可以，别当唯一依据。

多份材料对比

这是 AI 最被低估的能力之一。

我上传了三份竞品的产品说明。请输出一张对比表：
列为：功能项 | A 产品 | B 产品 | C 产品
行按功能分类组织。

要求：
- 某个产品没有提到某项功能，写"未提及"，不要写"不支持"
- 某份文档表述模糊的，原文怎么写就怎么填，不要你替我下判断
- 表格之后，列出三份文档之间明显冲突的地方

"未提及"和"不支持"是两个完全不同的结论。它会默认往"不支持"上写，因为那是更"完整"的答案。这个约束能防止这种情况。

长文阅读的另一个用法：让 AI 先读一遍，你来读第二遍

这是效率最高的一种组合方式。

具体做法：

1. 让 AI 输出结构图（第一步）
2. 你自己读你认为最重要的那部分
3. 读的时候，把你没看懂的地方标出来，回头问它
4. 让它针对你标出的地方做解释，而不是泛泛总结

这个流程的价值在于：它把"读材料"从浏览变成了对话。 你先知道全局，再带着问题深入，比自己硬啃效率高得多。

边界与坑

第一，"帮我总结"是最没用的问法。

总结是扁平的，它会把所有内容压成同样重要的一段话。你要的是结构、是重点、是对比、是有依据的细节。

第二，它会在你没要求的地方替你下判断。

你说"两份文档对不上的地方标出来"，它可能直接告诉你"以第二份为准"。这种自作主张要防。要求在提示词里加一句"只指出冲突，不要替我判断"。

第三，图片型 PDF 是重灾区。

扫描件、图片格式的 PDF，它需要先做文字识别（OCR），再理解内容。这两步都会引入错误，尤其是表格、手写、竖排文字。关键数据要人工核对。

第四，注意它可能"提炼"出原文没有的东西。

这是"忠实性幻觉"的典型表现，第 5 章提过，这是当前模型更常犯的一类错误。它会把原文里两处相邻的内容，合成一句原文从没说过的话。

应对办法：任何你要基于决策的关键信息，都要求它标注原文位置，然后核对。

第五，它不擅长判断材料的可信度。

你给它一份来源不明的报告，它会认真分析，不会质疑这份报告本身可信不可信。判断来源质量，是你自己的活。 做决定的材料，来源需要自己确认。

一份 200 页报告的完整精读过程

假设赵砚要判断一个新产品值不值得代理。他手上有三份行业报告，一共 200 多页。以下是完整流程。

第 0 步：先确认它能不能看到全部内容

他先上传第一份，问：

请先确认你看到了这份文档的全部内容。文档一共多少页？最后一部分讲什么？

这一句话花三秒。如果回答对不上，他会改用分段的方式。

第 1 步：要结构，不要总结

先不要总结内容。请告诉我：
1. 这份报告的目录结构，每一部分讲什么
2. 作者的核心结论是什么（一句话）
3. 哪一部分是重点，哪一部分可以跳过
4. 这份报告的数据主要来自哪里

他得到的东西：一张地图。他现在知道第三部分是市场规模，第五部分才是竞争格局，而第八部分是附录可以跳过。

注意：他并没有让 AI 替他判断。他自己要知道这张地图。

第 2 步：带着自己的问题去看

赵砚真正关心的是三件事：这个品类的市场规模有多大、增速如何、现有玩家是谁。

请只看第三部分和第五部分，回答三个问题：
1. 市场规模是多少，哪一年的数据，什么口径
2. 增速是多少，是历史数据还是预测
3. 主要玩家有哪几家，各自的定位

每一条都要标注在原文的第几页。如果原文没有给出某个数据，直接说"原文未提供"。

这一步最重要的两个动作：限定范围（只看第三、五部分）+ 要求标注页码。

限定范围让它的注意力集中，不会在东拼西凑。要求页码让他能快速核对。

第 3 步：抽样核实

他挑了三处最关键的，市场规模、增速、第一大玩家的份额，去原文对应页码核对。

三处都对。

这就是"抽样验证"。 不是核对全部（那他就自己读完了），是核对最影响决策的几个点。

第 4 步：处理第二、三份报告

对第二、三份重复前三步，然后做一件关键的事：

我上传了三份报告。请做一张对比表：
列为：指标 | 报告 A | 报告 B | 报告 C
内容包含：市场规模、增速、主要玩家、对未来三年的判断。

特别注意：
- 如果某个报告没有提到某项，写"未提及"，不要写"没有"
- 如果两份报告的同一指标数字不同，把两个数字都列出来，不要替我选
- 表格之后，单独列出三份报告之间明显冲突的地方

这一步的价值是：让他一眼看到分歧在哪。

三份报告对增速的判断分别是 12%、18%、和"增速放缓"。矛盾很明显。而这种矛盾本身就是最有价值的信息，它说明这个数据本身就不确定，他在做决定时要把这个不确定性考虑进去。

第 5 步：结论由他自己下

到这一步，他手里有三样东西：一份结构地图、一张带页码的数据表、一份冲突清单。

然后他自己判断。

这一步为什么需要自己做？ 因为他知道自己的渠道能力、资金情况、团队资源，这些是报告里没有的信息，AI 更不知道。它只能给他材料，不能替他做决定。

整个流程花了他大约一个半小时，读了三份报告。 换成以前，是两晚。

这个流程可以压缩成五句话

1. 先确认它看到了全部
2. 先要结构，不要总结
3. 限定范围，带着问题问，要求标页码
4. 抽样核实最关键的几个点
5. 多份材料要对比表 + 冲突清单

记住这五句，你就能处理任何一份长材料。

一个特别实用的技巧：反向提问

最后补一个技巧，它在读材料时特别好用。

做法是：不让 AI 回答你的问题，而是让它反过来指出"你应该关心什么"。

用法一：让它指出你没注意到的点

读完这份材料，请列出 5 个"我认为重要但作者没有重点强调"的信息。

它经常会指出一些散落在正文里、没有进结论但确实重要的内容。

用法二：让它列出"作者没说的事"

这份报告的结论建立在哪些前提假设上？如果这些假设不成立，结论会怎么变？

这个问法能让你看到材料背后的边界。 一份报告说"这个市场会增长"，它的前提可能是"政策不变""原材料价格稳定"。这些前提它可能只在某一页提了一句。

用法三：让它给出"我该去查什么"

基于这份材料，如果我要做是否进入的判断，还有哪些关键信息是这份材料没有覆盖的？我该去哪里找？

这个用法把"读材料"变成了"做调研"。 它不只告诉你材料说了什么，还告诉你材料之外还差什么。

这三个用法有个共同点：它们都在把"阅读"变成"提问"。

被动地读，你只能得到材料里有的东西。主动地问，你能得到材料之外的东西，包括它的边界、它的盲区、以及你下一步该干什么。

这正是 AI 在阅读这件事上最独特的作用。 一个真人助理也能帮你读材料，但很少有人会主动告诉你"这份材料的前提假设是什么""你还没考虑到什么"。

本章收束

三句话：

读材料的三步：先要骨架，再带问题要细节，最后抽样核实。 要求它标注原文位置，是提高提取准确率最划算的一个动作。 它会替你下判断，也会提炼出原文没有的话。关键信息需要回到原文核对。

第 11 章写出去，第 12 章读进来。第 13 章换个对象，不是文字，是数字。用 AI 处理表格和数据，这件事收益很大，风险也很大。何宇会告诉你为什么。

何宇有一次差点出事。

他让 AI 帮他算一批退货数据的汇总。AI 给了一个结果，数字看着合理，他就填进了月度报表。第二天，下属拿着明细来找他，说总数对不上。差了 3 万多。

他倒查回去，发现是 AI 在做多步累加的时候错了一步。那个错误非常细微，而且它给出的过程看起来很流畅，完全看不出哪里不对。

何宇现在的做法是：让 AI 负责"想"和"写"，不让它负责"算"。

这个转变，是他用 AI 这些年最重要的一个心得。这一章就讲这件事：AI 在数据处理上，哪些部分可以放心交出去，哪些不能。

先划一条线

数据处理可以粗分成三类动作，它们的风险差别极大。

第一类：理解和表达。 看懂数据在说什么、把数字翻译成人话、设计分析思路、判断哪里可能有问题。这一类非常安全，也是 AI 的最强项。

第二类：写规则。 写出公式、写出处理脚本、写出筛选条件。这一类也安全，因为规则是可以验证的。

第三类：实际计算。 直接把一堆数字算出一个结果。这一类最危险。

原因还是那个：它没有算术引擎，它在"猜数字"。

所以核心原则是：让它写规则，你来执行规则。

这个原则听起来简单，但用起来有几个非常具体的好处。

用法一：让它写公式

这是最高价值、风险最低的用法。

何宇以前最头疼 VLOOKUP 和各种嵌套函数。现在他的做法是：

我有一个表格，A 列是员工工号，B 列是姓名，D 列是部门，F 列是本月工时，G 列是每小时单价。

我要在 I 列算出每人本月的应付金额，规则是：
- 工时不超过 174 小时的，全额计
- 超过 174 小时的部分，按 1.5 倍计
- 部门是"外派"的，整体再乘 1.1

请写出 I2 单元格的公式，并说明每个函数的作用。

它给出的公式，你复制到表格里一跑，对不对立见分晓。

这个用法的三个好处：一是它比你查文档快；二是错了一眼能看出来；三是你会顺带学会，它解释每个函数作用的时候，你就学到东西了。

一个提醒：不同软件的公式语法不一样（Excel 和 WPS 有细微差别，Google Sheets 又是另一套）。告诉它你用哪个软件。

用法二：让它检查数据质量

这一步很多人跳过，但收益极大。

这是我的销售明细，一共 2000 行。请帮我列出一份"数据质量检查清单"，告诉我应该检查哪几类问题，每类给出具体的检查方法（用什么公式或怎么筛）。

它会给你一份很实用的清单，比如：

• 金额列有没有负数或零
• 日期列有没有超出范围或格式不一致
• 关键字段有没有空值
• 有没有重复记录
• 分类字段有没有拼写变体（"华东"和"华东区"）

这一类工作它做得很好，因为这是"设计检查规则"，不是"执行计算"。

用法三：让它解读数据

这是它真正发光的地方。

让它用大白话说数字

这是我们三个季度的销售数据。请用一段话告诉一个完全不懂业务的人，发生了什么变化。不要用"环比增长"这类词，用具体的例子说。

"用具体的例子说"这个要求很重要。它会输出类似："第一季度平均每天卖 800 单，到第三季度变成了 1100 单，也就是每天多卖 300 单。"这种话，比"环比增长 37.5%"有用得多。

让它找异常

下面是各门店的月度数据。请找出最值得注意的 5 个异常，每个异常说明：是哪家店、异常在哪、可能的原因有哪些。

注意"可能的原因有哪些"这个说法比"原因是什么"更好。 前者它会给你几个假设，后者它会给一个结论。而它对原因的推断往往是猜的。

让它指出"数据回答不了的问题"

这是一个很少人用、但极其有价值的问法：

基于这份数据，请告诉我：有哪些我可能关心的问题，是无法从这份数据里得到答案的？

因为一份数据里最危险的，不是它说错了什么，而是它没覆盖的东西你没意识到。它常常能指出一些你没想到的盲区，比如"这份数据只有成交订单，没有流失客户，所以无法判断流失情况"。

用法四：让它做分析思路

这是我觉得最有价值的一个用法。

我想知道为什么最近两个月的复购率下降了。我手上有这些数据字段：＿＿＿＿。请帮我设计一份分析思路：
1. 可以从哪几个角度切入
2. 每个角度需要什么数据
3. 每个角度的结论会指向什么可能的原因
4. 哪些角度是这份数据支持不了的

它给你的是一份"分析的路线图"。这个东西一般是资深分析师才会写，而且写一份要花不少时间。

但你要清楚：它是根据"一般性的分析方法"来写的，它不知道你业务的具体情况。这份路线图是个起点，你要根据自己的实际情况删改。

铁律：数字需要复核

现在回到那条线。

凡是要写进报表、发给别人、影响决策的数字，都需要自己算一遍。

具体做法有三种：

做法一：让它给方法，你自己算。 这是最稳的。它告诉你"这里应该用加权平均",你自己按这个思路算。

做法二：让它给公式，在表格里跑。 公式是可验证的，跑一遍就知道对不对。

做法三：让它生成代码，你去执行。 如果它给你一段 Python 或者一段处理脚本，你在自己电脑上跑一遍，结果就是可靠的。

唯一不能做的：直接相信它在对话框里"算"出来的数字。

还有一个加快速度的技巧：你可以让它算两遍，但是用不同的方法。 如果两次结果一致，可信度就提高很多。

为什么它算不好

再解释一遍原因，这样你能形成判断力。

它在猜下一个字。数字对它来说是另一种文字。它见过无数"3 + 5 = 8"这样的模式，所以简单加法它很准，那几乎是背诵。

但多步计算、带条件的计算、大数计算，就变成了"它没背过的模式"。它会按照语言的流畅性去生成一个数字，而不是真的算。这个数字经常看着很合理，但就是错的。

2026 年的模型在这方面已经有改善，尤其是开放了计算工具调用的产品，它会把计算交给一个真正的计算器，而不是自己猜。如果你的工具支持这个功能，要打开它。

边界与坑

第一，不要让它"看着"表格做统计。

你粘一段表格数据进去，让它"算一下总和""找出最大值"，这是最容易出错的操作。正确做法是让它给公式，你在表格里算。

第二，注意它可能编造列名。

如果数据里某一列叫"应收金额（含税）"，它可能简化成"应收"。如果它引用了不存在的列名，说明它在凭印象编。这也是一个很好的"它有没有真的在看"的检验信号。

第三，图表截图提取数字要格外小心。

第 5 章提过，多模态在精确数字上的准确率明显低于纯文字。让它从一张图表截图里读数字，错误率很高。关键数据要回到原始表格。

第四，注意单位。

"万"和"万元"、"个"和"千个"，单位混淆是数据错误的高发区。让它复述一遍"这个数字的单位是什么"，能挡掉不少问题。

第五，涉及财务、税务、审计的场景，AI 只是辅助。

这类场景有明确的合规要求，最终结果需要有资质的人签字。用它可以提高效率，但不能替代责任。

一个完整的排查案例

假设何宇收到一份下属交上来的月度费用明细，他觉得总数不太对。以下是完整流程。

第一步：先让它设计检查清单，不要让它算。

我有一份费用明细表，大约 1500 行。列为：日期 | 部门 | 费用类别 | 金额 | 经办人 | 备注。
请列出我应该做哪些数据质量检查，每一类给出具体的检查方法（在表格里怎么筛、用什么公式）。
不要帮我算总数。

它的输出（大意）：

• 金额异常：筛出金额 ≤ 0 的行；用公式找出明显偏离（超过该类别平均值 5 倍的）
• 日期异常：筛出超出本月范围的日期；检查日期格式是否统一
• 分类异常：对"费用类别"做去重，看有没有拼写变体（比如"差旅"和"差旅费"）
• 空值：检查关键列（部门、金额）是否有空
• 重复：检查有没有完全相同的记录
• 经办人：去重看有没有异常名字（错别字导致同一个人的两种写法）

这六类里，第四、五、六类是何宇自己没想到的。

第二步：让他自己去筛，用公式。

请给我一个公式，能找出"金额"列中超过该类别平均值 5 倍的记录。
我的表格从第 2 行开始，F 列是金额，D 列是费用类别。

它给出公式，他在表格里跑。 这一步是第 13 章正文讲的那条线，它写规则，他执行。

第三步：发现问题，再让它解释。

他跑出来一个结果：有 7 行的金额是负数。哪来的负数？

我在费用表里发现 7 行金额是负数，涉及 3 个经办人。
可能是什么原因造成的？请列出 4 种常见可能，并说明每种可能对应的特征（比如日期是否集中、备注是否有规律）。

它给出四种可能：冲销红字（通常日期集中在月末）、数据导入时符号错乱（通常同一批次集中出现）、退款记录（备注里通常有相关字样）、手工录入错误（随机分布）。

他去看那 7 行的备注，发现有 5 行备注写着"冲销"，另外 2 行确实是录入错误。

第四步：处理建议 + 复核。

确认是 5 笔冲销和 2 笔录入错误。请告诉我应该在报表里怎么体现这 7 行，才能让总数是对的。

它给出的建议：冲销的 5 笔应该保留原始记录（因为是真实的业务动作），2 笔录入错误应该改正符号。最终总数需要重新核对。

注意：最后这个总数，他需要自己算。 这是第 13 章的铁律。

这个案例的关键动作回顾：

1. 让它设计检查清单（安全）
2. 让它写公式，你自己跑（安全）
3. 发现问题后让它列可能原因（安全，但要知道这是假设）
4. 处理方案的最终数字自己算（需要）

你发现了吗？整件事里，它没有算过任何一个数字。 但它帮他省的时间，可能比"让它算 20 遍"还多。

六个能直接用的公式模板

下面几个公式覆盖了最常见的数据检查需求。直接把你的列名替换进去就能用。

模板一：找重复

我在 A 到 F 列有数据，第 2 行开始。请给我一个公式，在 G 列标记出"和前一行完全重复"的记录。

模板二：找空值

我的表从第 2 行开始，B 列和 D 列不允许为空。请给我一个公式，在 G 列标记出"B 或 D 有空值"的行。

模板三：找异常值

F 列是金额，D 列是类别。请给我一个公式，标记出每个类别里金额超过该类别中位数 3 倍的记录。
注意用中位数不用平均值，因为平均值本身会被异常值拉偏。

那句关于中位数的说明很重要。 如果你不说，它可能默认用平均值，而平均值恰好会被你要找的异常值污染。

模板四：跨表匹配

表 1 的 A 列是工号，表 2 的 A 列也是工号。
请给我一个公式，在表 1 的 G 列查出对应的表 2 的 D 列内容。如果查不到，显示"未匹配"。

模板五：统计分类占比

请给我一个公式，统计 D 列每个类别出现的次数，以及占总数（排除空值）的百分比。

模板六：日期范围筛选

A 列是日期。请给我一个公式，标记出"日期不在本月范围内"的记录。
注意：有的日期可能是文本格式而不是日期格式，请一并标出。

最后那句提醒很实用。 数据表里最常见的隐形问题，就是看起来像日期、实际是文本的单元格。它们会让所有日期相关的计算悄悄出错。

用这些模板的通用建议：

• 要告诉它你用哪个软件（不同软件的公式语法有差异）
• 告诉它数据从第几行开始（不然它可能从第 1 行算，把表头也算进去）
• 告诉它列名和列号（只说列名，它可能猜错位置）
• 拿到公式先在几行数据上试，确认对了再整列应用

本章收束

三句话：

让它写规则，你来执行规则。这是处理数据最安全的分工。 它最强的三件事：写公式、设计检查清单、解读数据含义。最弱的一件事：直接算数字。 要写进报表的数字，需要自己算一遍，或者让它给公式/代码由你来跑。

第 14 章换个媒介：从文字和数字，转到图像、视频和演示文稿。这一章的内容看起来最"好玩"，但也最容易让人高估它的能力。

苏芮是个爱折腾的人。

她做运营，需要大量视觉素材。以前她的流程是：在网上找图，找到一张勉强能用的，改改尺寸，配上文字。找到满意的图要花一小时，配的文字还凑合。

现在她的流程变成：先想清楚要什么画面、什么情绪、什么风格，用几句话描述出来，让 AI 生成五六张挑一张。

时间从一小时压到十分钟。但她也没少踩坑。有一次她把一张 AI 生成的图用在海报上，同事看了一眼说："这人的手有六根手指。"

这一章讲的就是这类工具：图像、视频、演示文稿，还有语音。它们看起来最直观，但用起来的门道其实不少。

图像生成：怎么描述你想要的画面

图像生成的提示词和文字任务不太一样。文字任务是"说清要什么"，图像任务是"描述你脑子里那个画面"。

一个好的画面描述，一般包含这几层：

1. 主体：画面里是什么（一个人在雨中骑车）
2. 场景：在哪里、什么时间（黄昏的城市街道，刚下过雨）
3. 风格：什么质感（写实照片 / 水彩 / 扁平插画 / 电影感）
4. 构图与光线：怎么拍（低角度仰拍 / 侧逆光 / 浅景深）
5. 氛围：什么感觉（安静、有点孤独）

按这个层次写，命中率会高很多：

一个人在雨中骑自行车，黄昏的城市街道，地面有积水反光，电影感写实照片，低角度侧逆光，浅景深，氛围安静略带孤独，画面偏冷色调。

比堆形容词更重要的是"迭代"。

不要指望一次出对的。正确做法是：先出四张，挑一张方向对的，然后说"保持这张的构图和光线，把人物的衣服换成深蓝色，背景的建筑再模糊一些"。

理解了"哪个词影响哪个部分"，你就能精细调整。这个过程通常三轮之内就能拿到能用的图。

一个实用技巧：给它一个参考方向而不是具体名字。

说"类似某位摄影师的风格"可能不生效，甚至可能被拒绝。更好的做法是描述那个风格的特征："高对比度、硬光、黑白为主、颗粒感强"。

修图：比生成更常用

对大多数工作场景来说，"修"比"造"更实用。

常见需求有这么几类：

• 去文字/水印：把图片上多余的字去掉，补上背景
• 换背景：把产品图从杂乱背景里抠出来，换到干净背景上
• 扩图：画面太窄，向两侧延展
• 提升清晰度：老照片、模糊截图变清楚
• 统一风格：把一组风格不一的图调成统一色调

这几类里，"去文字/换背景"的成熟度最高，"提升清晰度"最容易出现"过度美化"，它会补充一些原本不存在的细节，看起来清晰了，但实际上已经不是原来的东西了。

如果你要用在正式场合（产品图、宣传物料），改完之后要放大看细节，尤其是文字区域、人脸、手部。

视频生成：能力和限制

2026 年，视频生成已经不是新鲜事。文字生成视频、图片生成视频都能做，几秒到十几秒的短片效果已经相当可用。

它目前比较擅长：

• 单一主体的简单动作（风吹头发、水流动、镜头推拉）
• 氛围镜头、空镜、背景素材
• 把一张静态图动起来

它目前比较吃力：

• 多个人物的复杂交互
• 连贯的长镜头（超过十秒容易出现画面跳变）
• 精确的动作（弹钢琴、写字、打球）
• 画面里的文字

用法上的建议：把它当"素材生成器"，而不是"成片生成器"。

什么意思？就是你用它生成几个 3 到 5 秒的镜头，然后自己剪辑拼接。这样既发挥了它的长处，也避开了它做不了长片的问题。

如果你需要的是讲解类、口播类的内容，还有另一条路：用"数字人"方案，真人形象或虚拟形象对着稿子念，口型自动匹配。这类工具适合做课程、产品介绍、多语种播报这种"内容重复度高"的视频。

演示文稿：最容易被误用的一个

这是我认为最需要提醒的一类工具。

它能做的事：根据你的大纲，自动生成一套有版式的 PPT，包括配图、配色、页码。省掉的是排版的功夫。

它做不好的事：决定这套 PPT 要讲什么。

很多人的用法是：输入一个标题，让工具生成 20 页 PPT。结果是，页面很漂亮，内容全是正确的废话。每一页都在说"市场前景广阔""需要加强配合"，你讲的时候自己都觉得尴尬。

正确的用法是反过来：

第一步，你自己搞定逻辑。 这份 PPT 要说服谁？核心论点是什么？按什么顺序展开？这一步只有你能做。

第二步，让 AI 帮你完善逻辑。

我要做一份 15 分钟的汇报，听众是公司高层，目的是申请预算做一个新项目。
我的核心论点是：＿＿
请帮我设计结构，要求：
- 每个部分标注建议页数
- 每一页只讲一件核心信息
- 指出哪里最可能被挑战，我该怎么应对

第三步，用工具生成版式。 把上一步的结构丢进 PPT 工具，让它帮你排版配图。

第四步，逐页检查内容。 尤其是数据、图表、结论，一处一处过。

顺序颠倒，你得到的就是一份漂亮的空话集。

语音与音乐

这一类工具的价值经常被低估。

语音合成：把文字转成自然的人声。现在的效果已经很难分辨，而且支持多种音色、语速、情绪。适合做课程配音、有声内容、无障碍朗读。

语音转写：把录音转成文字。这个是实用度最高的一个，准确率在安静环境下已经很高。会议记录、访谈整理、课程笔记都靠它。

音色克隆：用少量样本复刻一个人的声音。技术成熟度很高，也因此带来严重的滥用风险，用别人的声音去骗人，已经成了真实的犯罪手段。

音乐生成：根据描述生成背景音乐。适合做视频配乐、氛围音效。

关于音色克隆，有一条底线：不要用别人的声音做任何未经本人同意的事。这不是技术问题，法律问题。

一张对照表

边界与坑

第一，注意版权。

AI 生成的图片能不能商用，取决于你用的平台条款和生成内容本身。有的平台明确授予商用权，有的有限制。用于发放的材料，先读清楚条款。

第二，不要用 AI 生成的内容冒充真实记录。

AI 生成的照片、视频，如果被用作新闻素材、证据材料、产品实拍，那是造假。2026 年，识别 AI 生成内容的技术和法规都在快速跟进，风险很高。

第三，注意"看起来对"的陷阱。

AI 生成的画面在整体上往往很惊艳，但放大看细节经常出问题：手指数量、文字拼写、镜面反射、影子方向、物体的物理连接处。用在正式场合前，放大看。

第四，PPT 内容和排版的检查顺序不能反。

先确认内容对不对，再看排版好不好。反过来会出现"因为版式好看就舍不得删掉某一页"的情况，而那一页可能是错的。

第五，语音类内容要标注。

如果视频或音频里用了合成语音，尤其是涉及公开发布的内容，标注"AI 生成语音"是基本要求，也是不少地区的合规要求。

图像提示词的进阶写法

基础的五层描述（主体、场景、风格、构图光线、氛围）掌握之后，这几个技巧能让命中率再上一个台阶。

技巧一：用"具体名词"代替"抽象形容词"。

"温馨的画面"，它只能猜。"暖黄色灯光照在木桌上，桌上一杯冒热气的茶"，它就知道你要什么。

形容词是模糊的，名词和动词是具体的。 这个原则对所有生成任务都成立。

技巧二：说清楚"不要什么"。

很多工具支持反向描述。比如你要一张产品图：

正向：白色陶瓷杯，纯色背景，柔和顶光，商业产品摄影反向：不要文字、不要水印、不要多余的杯子、不要阴影过重、不要人物

"不要什么"经常比"要什么"更能改善结果。 因为它排除了最常见的干扰项。

技巧三：控制画面比例。

不同的用图场景需要不同比例。直接说明："竖版 3:4""横版 16:9""正方形"。

不说的话，它可能给你一个不适合排版的比例，你还得裁。

技巧四：迭代时只改一个变量。

拿到一张方向对的图之后，一次只改一处。

改了光线和背景和人物衣服三处，你就不知道是哪一处让画面变好了或者变差了。

技巧五：风格描述要拆成特征，不要用名字。

不好的："像某某导演的风格"，可能不生效，也可能被拒绝。

好的："高对比度、低饱和、冷色调、大量留白、对称构图、胶片颗粒感"

拆成特征，效果更可控，也更稳定。

五类常见失败画面与修正

生成图像最容易出这五类问题。每类都给了修正方向。

第一类：手

问题是手指数量不对、手指粘连、姿势不自然。

修正方向：让它把手藏起来（插兜、背手、手持物体遮挡）；或者把手部放在画面边缘、部分出画；或者干脆改成"只有身体的构图"。

第二类：文字

画面里出现文字，但拼写错误、笔画乱码。

修正方向：不要指望它生成正确的文字。 正确做法是生成没有文字的画面，然后你用设计软件把文字加上去。这是目前最可靠的方式。

第三类：多人交互

两个人以上时，容易出现肢体错乱、身体粘连、眼神方向不对。

修正方向：减少人数；让主体之间拉开距离；改成"只出现背影"或"只有一个人是正面"。

第四类：物理关系

影子方向不对、镜面反射不匹配、物体悬空、连接处错位。

修正方向：简化场景，减少复杂的光影和反射；或者换个角度避开这些元素。

第五类：细节放大后崩坏

整体看很惊艳，放大看细节全是糊的。

修正方向：这是分辨率和生成方式决定的，很难通过提示词解决。用在正式场合时，不要指望放大看细节，按实际展示尺寸来评估。

一个通用的判断：把生成的图缩到实际使用尺寸，再看一遍。如果在小尺寸下没问题，那就没问题。很多"穿帮"只在放大到 200% 时才看得到，而实际使用中根本不会放大。

给"PPT 工具"的一份使用顺序说明

第 14 章正文说了"先定逻辑，再排版"。这里给一个更具体的操作顺序。

第一步（你自己做，30 分钟）：写一页纸的提纲。每一行是"这一页要传达的那件核心信息"。写完检查：这些页连起来，逻辑通不通？

第二步（让它做，5 分钟）：把这一页纸丢给 AI。

这是我 15 分钟汇报的提纲，听众是公司高层。请帮我：
1. 指出哪几页顺序不对，应该怎么调
2. 哪几页内容太薄，撑不起一页
3. 哪一页最可能被质疑，我该怎么应对
先不要生成 PPT。

第三步（你自己做，10 分钟）：改提纲。

第四步（用工具做，10 分钟）：把定稿的提纲丢进 PPT 工具生成版式。

第五步（你自己做，20 分钟）：逐页检查，数据对不对、图有没有误导、有没有哪一页是"漂亮但没用"的。

为什么顺序不能换？

因为第 1 步和第 3 步是"决定讲什么"，这是只有你能做的事。第 2 步和第 4 步是"帮你做得更快"，这是 AI 的事。

颠倒顺序，你会得到一份"AI 想讲什么"的 PPT，而不是"你想讲什么"的 PPT。

本章收束

三句话：

图像和视频生成靠"迭代"不靠"一次到位"，第一轮出方向，后面几轮改细节。 生成类工具最擅长的氛围和素材，最不擅长精确的动作、文字和连续性。 PPT 的逻辑需要你自己定，AI 只负责排版。顺序反了，你只会得到一份好看的空话。

第 15 章是第二篇里我觉得最"划算"的一章：用 AI 来学习。这件事的效果取决于方法，方法对了，它就是一个随叫随到、永远不嫌你问题笨的家教。

陈默三十多岁，重新开始学英语。

他试过很多方法。背单词 APP 用过三个，网课买过两门，其中一门看了四节就停了。问题不在他不努力，在于他每次卡住的时候没人可问。

一个语法点看不懂，卡二十分钟，兴趣就消了。一句英文读不通，查字典查不出为什么，就跳过去了。日子一长，那些没解决的问题堆成一座山，他就不想再走了。

后来他换了个方式：有疑问就问 AI。问得再笨也不尴尬，问十遍也不烦它。他两个月读完了两本英文原版书，虽然读得慢，但读完了。

这件事让我意识到，AI 在学习上最大的价值，不是"教你"，而是"随时可以被你追问"。

但方法不对，它也帮不上忙。这一章讲的就是怎么用对方法。

一个核心原则：不要让它讲，要让它问

这是全章最重要的一句话。

大多数人用 AI 学习的方式是：让它解释一个概念。它讲得很清楚，你觉得自己懂了，合上就忘了。

这不是你的问题，是这种学习方式本身效率低。

学习科学里有个反复被验证的结论：主动提取（自己回想、自己复述）的效果，远好于被动接收（读、听、看）。 读一遍记不住，自己讲一遍才能记住。

把这条原理用在 AI 上，就得到一个反直觉的做法：让它向你提问，而不是让它向你讲解。

具体的用法：

我要学习"机会成本"这个概念。请你扮演一位老师，不要直接解释。
先问我 5 个问题，每个问题让我自己回答。我答完你指出我哪里理解对了、哪里理解偏了，然后再问下一个。

你会发现，这个过程比读十遍定义记得牢得多。因为你被逼着自己组织语言，而组织的过程就是理解的过程。

用法一：三层追问法

当你遇到一个不懂的概念，不要只问一次。

第一层：它是什么。

用一句话解释"什么是复利"，假设我完全不懂金融。

第二层：为什么。

为什么复利的效果在后期才明显？请用一个具体的数字例子说明。

第三层：边界。

复利在什么情况下会失效？或者，哪些情况下"复利思维"是误导人的？

这三层里有价值的是第三层。前两层它讲得再好，也只是重复了书上有的内容。第三层才是真正让你理解"这个概念的适用范围"的地方。

一个提示词模板：

请用三层回答：
1. 一句话定义（不超过 30 字）
2. 一个具体例子（带数字，能算的）
3. 它最容易被人误解的地方，以及为什么要小心

用法二：让它讲给你"降维"

同一个概念，向不同的人解释，说法应该完全不同。

这个技巧可以让你检验自己是否真的懂了。

请把"注意力机制"分别解释三遍：
1. 讲给一个 10 岁的小孩听
2. 讲给一个完全不懂技术的成年人听
3. 讲给一个有编程基础的工程师听

三个版本都控制在一段话以内。

你会发现，它的第一版会用一个比喻，第二版会用更完整的类比加一点机制，第三版才会提到"加权求和"这类词。

而且这个技巧还有一个隐藏用途：当你发现它的三版你都能看懂时，说明你自己也差不多理解了。三个版本你都看不懂，说明还差得远。

用法三：苏格拉底式追问

这是把你自己的思考往深处推的方法。

我在想一个问题：为什么有些人学东西快，有些人慢？
请用苏格拉底式提问的方式，连续追问我 5 个问题，每个问题都针对我上一句回答里的漏洞。

它会问出类似这样的问题：

• 你说的"快"，指的是时间短，还是指同样的时间学到更多？
• 你观察到的是学习速度的差异，还是开始时兴趣强度的差异？
• 你觉得"学得快"的人后来都持续学下去了吗？
• 如果让一个"学得快"的人去学他讨厌的东西，结果会怎样？

这类追问的价值不是给你答案，是让你发现自己的思考里有多少是没验证过的假设。

用法四：让它给你出题

这是我个人最推荐的一个用法。

我刚学完"边际成本"这个概念。请出 5 道题考我，从易到难：
- 前 2 道考定义理解
- 中间 2 道考应用（给情景让我判断）
- 最后 1 道考边界（什么情况下这个概念不适用）

先只出题，不要给答案。我全部答完之后你再批改。

流程走完一遍，你对这个概念的掌握会比读三遍书扎实。

关键动作是"先不要给答案"。 很多人一看到题目，就顺手让它把答案也给出，等于又回到了被动接收。

用法五：让它批改而不是重写

学语言、学写作的时候，这个差别很大。

差的用法：帮我改一下这段英文。

好的用法：这是我写的一段英文。请不要直接给我修改后的版本，而是：

1. 指出其中 3 个最明显的问题，说明为什么这是问题
2. 针对每个问题，告诉我应该注意什么规则
3. 让我自己改一遍
4. 我改完你再给最终建议

这个流程多花两轮，但学到的东西多得多。因为改是能力，看别人改是知识。

用法六：建立你的"卡住清单"

这是陈默最后总结出来的方法，我觉得特别实用。

每次学习时遇到不懂的地方，别跳过，随手记一句在备忘录里。攒够十条，一次性交给 AI：

这是我这周学习时遇到的 10 个没搞懂的地方。请帮我做两件事：
1. 按重要程度排序，哪几个是核心概念，不解决会一直卡；哪几个是细节，可以先放
2. 指出这几个问题之间有没有共同的根源（比如是不是同一个前置概念没搞懂）

第二条特别有用。很多时候你以为是十个问题，其实根源是一个概念没懂。它经常能指出来。

这个方法的本质是：把零散的疑问，变成结构化的学习计划。 一个人自学的最大困难就是不知道自己缺什么，而这个清单直接把这个困难解决了。

学语言的具体用法

前面几条是通用的，这里单独说几个学语言特别好用的动作。

影子跟读与纠错：把你的朗读改成文字发给它，让它指出哪里可能不对。虽然不能判断语气，但语法和用词问题能抓出来。

场景模拟：

请扮演一位在咖啡店的服务员，和我进行英文对话。我扮演顾客。
每次我只用一句英文回答，你正常回应，然后在方括号里用中文提示我哪里可以更地道。
从点单开始，一直到我结账离开。

难度可调：它可以根据你的水平调整用词难度。你可以说"用初中生能懂的词汇和我对话"，它会自动控制。

不要用它的发音功能当唯一老师：合成语音的发音标准但缺乏真实的连读和语调变化。真实语感还是要靠听母语者的材料。

边界与坑

第一，它讲错的时候你很难发现。

这是用 AI 学习最大的风险。你在学一个新东西，本身就是因为你不知道，所以你没有能力判断它讲得对不对。而它对冷门知识、专业细节的出错率并不低。

应对办法有三个：

• 学核心概念时，找一本公认的入门教材对照。AI 用来辅助理解，教材用来校准。
• 同一问题换个问法问两遍，看两次解释有没有冲突。
• 遇到具体的人名、年份、公式、数据，另外查证一次。

第二，不要用它替代教材。

它讲得像故事，很好懂，但也容易漏掉整体结构。教材的编排顺序是经过设计的，AI 的回答是围绕你的问题散开的。用它答疑和补充，不要用它当唯一的骨架。

第三，警惕"解释得很流畅"的错觉。

流畅不等于正确。有些时候它给的错误解释比正确解释还好懂，因为它把复杂的东西简化成了顺口的说法。

第四，不要指望它教你"手感"。

学乐器、学手工、学写作的语感，这些需要身体经验和大量实践。它能给你方法，不能给你手感。

第五，控制提问的幅度。

每问一个新概念就问三层追问，很快你就会累。挑重点的、卡住你的去问，其余的直接过。

一段完整的"三层追问"实录

前面讲了三层追问法，这里把完整对话走一遍。学习对象是"复利"。

第一层：它是什么

你：用一句话解释"什么是复利"，假设我完全不懂金融。

它：复利就是"利息也会生利息"，你赚到的利息会加进本金里，下一次算利息时连这部分也一起算。

第二层：为什么

你：为什么复利的效果在后期才明显？用一个具体的数字例子说明。

它：假设你有 10 万，年利率 10%。第 1 年赚 1 万，年末 11 万。第 2 年赚 1.1 万（因为本金变成 11 万了），年末 12.1 万。...第 10 年末约 25.9 万。第 20 年末约 67.3 万。第 30 年末约 174.5 万。

前 10 年只从 10 万涨到 26 万，后 10 年从 67 万涨到 175 万。因为越往后，本金越大，"本金 × 利率"里那个"本金"本身也在变大。

第三层：什么时候不适用

你：复利在什么情况下会失效？或者，哪些情况下"复利思维"是误导人的？

它：至少有四种情况。第一，有通胀。名义上复利到 175 万，但 30 年后这 175 万的购买力可能只相当于今天的几十万。第二，有税费和管理费。它们会持续扣减本金，效果上相当于负复利。第三，收益率波动。真实投资不是每年稳定的 10%，亏损年份会拖慢甚至抵消复利效果。第四，也是最常见的误导："复利思维"被用来鼓励人们在一个糟糕的选择上长期坚持。 如果你做的事本身没有积累效应，坚持 30 年也不会产生复利。

三层走完，你应该做什么？

停下来，把第三层的四个答案和自己的实际情况对一遍。第三层才是真正的理解，它告诉你这个概念适用在哪、不适用在哪。

很多人学习的方式是停在第一层。 知道定义，就以为学会了。而真正决定你会不会用错的，是第三层。

一个实用建议：以后学任何新概念，都问一句"它在什么情况下不成立"。这一问带来的收获，通常大于前面两层的总和。

用"教你一遍"来检验自己学会了没有

这是全书里我觉得最有效的一个学习方法，而且它只需要一条提示词。

做法：

我现在要给你讲一遍"什么是边际成本"。
请听完之后告诉我：
1. 我讲对的地方是哪些
2. 我讲错或者讲不完整的地方是哪些
3. 如果我的理解有偏差，说明我可能漏掉了什么前置概念

然后你用大白话讲一遍。 不要看着资料讲，是凭记忆讲。

这个方法的原理在正文里说过：主动提取的效果远好于被动接收。而"讲给别人听"是提取强度最高的一种形式，因为它要求你同时做到三件事，记住、组织、表达。

讲的时候卡住了，那个卡住的位置就是你的知识缺口。 这比读十遍都精准，因为读书的时候你会"以为自己懂了"，但讲的时候骗不了人。

要注意一件事：它的批改未必全对。尤其是概念本身的准确性，它可能也有偏差。

所以更稳的用法是：用这个方法找出"自己哪里讲不清楚"，然后拿这个清单去查教材或权威资料。它的价值是"定位问题"，不是"给出答案"。

如果没有人可以听你讲怎么办？ 就讲给 AI 听。或者打开手机录音，自己讲一遍再回听。

回听自己讲解的录音，是学习效率最高、也最让人不舒服的一件事。 因为你会清晰地听到自己在哪个地方含糊过去了。

本章收束

三句话：

用它提问，不要只用它讲解。主动提取的效果远好于被动接收。 三层追问：是什么、为什么、什么时候不适用。第三层最值钱。 它讲错的时候你发现不了。核心概念要用正经典籍校准，别只用它一个来源。

第二篇还剩两章：第 16 章讲怎么用它查资料和核实事实（这一章和第 6 章是姊妹篇）；第 17 章讲怎么用它做小工具，不会编程也能造东西。

前面提过一起官司。

当事人提交了一份"完美佐证"，一个看起来严丝合缝的判例，案号、法院、判决要旨一应俱全。对方一查，这案子根本不存在，两起都是 AI 编的。

这份材料是怎么产生的？大概率是这样：有人问 AI"找一个支持我这个观点的判例"，AI 为了满足他的要求，生成了一份看起来最像真的判例。

这里有个关键的责任分配问题。 造成这个后果的，不完全是 AI。AI 的机制决定了它会这么做，你让它找一个支持你观点的判例，它就会给你一个。真正出错的是那个环节：没有人去核对。

这一章讲的就是核对。它是第 6 章的姊妹篇：第 6 章告诉你"它什么时候不可信"，这一章告诉你"怎么处理不可信"。

首先要分清：你在做哪一种"查"

不同目的，方法完全不同。

第一种：我想了解一个领域的概况。 这是探索性的，不要求精确。用 AI 快速搭个框架，效率极高。

第二种：我想确认一个具体事实。 这是验证性的，要求精确。需要用外部来源核对。

第三种：我想找支持我观点的证据。 这一种最危险，后面单独说。

很多人出问题，是把第二种当成第一种来处理了，用"问问看"的方式，去做"需要准确"的事。

第一种：探索性了解

这个可以放心用。

我想了解"跨境电商的税务合规"这个领域。请告诉我：
1. 这个领域涉及哪几个主要方面
2. 每个方面最核心的问题是什么
3. 有哪些我没有想到但很重要的角度
4. 哪些部分是最新政策变化频繁的（需要我去查最新版本）

注意第 4 条。让它主动指出"哪些部分我不确定"，是这类提问里最实用的一个动作。

它给出的框架，你当作"地图"。地图可能画得不够精确，但至少让你知道该往哪走。

然后你去查权威来源：政府部门官网、行业报告、专业书籍。AI 给框架，权威来源给细节。

第二种：确认具体事实

从这一节开始，进入本章的核心。

第一步：区分问题的性质

先判断你要确认的东西属于哪一类：

• 常见常识（首都是哪里、某个著名事件发生在哪年），它通常可靠，抽查即可
• 中频事实（某家中型公司的成立时间），需要核对
• 冷门细节（某篇论文的具体页码），默认它是错的
• 时效信息（最新政策、当前价格），需要查最新来源
• 计算结果，需要自己算

第二步：用正确的提问方式

错误的问法：

2025 年某市的常住人口是多少？

这个问法隐含了"你应该知道"的假设。如果它不知道，它会给你一个数。

正确的问法：

2025 年某市的常住人口是多少？请说明你的数据来源和统计口径。
如果你没有确切依据，请直接说不确定，不要给出估计值。
另外，你的训练数据截止到什么时候？

这段提示词里有三个动作：要来源、给退路、问截止时间。

第三个动作特别有用。 知道它的训练数据截止时间，你就能判断它到底有没有可能知道这件事。

要提醒的是：它自报的截止时间未必可靠，这个信息本身也是生成出来的。但如果它说"我的训练数据截止到 2025 年初"，那么对于 2025 年之后的事，你就知道要格外小心。

第三步：交叉验证

这一步不能省。

具体做法：换一个问法再问一遍。

不是重复同一句话，而是换角度。比如第一次问"2025 年某市常住人口是多少"，第二次问"某市 2024 年的常住人口是多少？2025 年有没有公布新数据？"

如果两次答案差异很大，说明它没有稳定依据，你得到的是两次猜测。

如果是重要事实，再补一步：让它自己找矛盾。

关于"某市 2025 年常住人口"，请列出你见过的不同说法。如果不同来源的数字不一致，都列出来。

第四步：外部核对

最终确认需要来自外部。这一步没有替代方案。

权威来源的优先级（一般是这个顺序）：

1. 官方机构发布（政府部门、监管部门、有公信力的机构的官网）
2. 一手材料（原始报告、原始数据、原始文件）
3. 专业媒体或行业机构的正式发布
4. 其他（自媒体、论坛、二手转述），只能提供线索，不能作为依据

有个很实用的判断：如果 AI 给出的答案只有二手来源支撑，那就等于没有支撑。

关于带联网功能的产品：它们能去搜索，比纯靠内部知识可靠。但要注意两点：一是它可能搜到低质量来源；二是它可能"看错了"来源内容。所以即使是联网结果，也要看它引用的是哪个网站。

第三种：找支持自己观点的证据（危险区）

这一类需要单独说，因为它最容易出事。

根本问题：当你让它"找一个支持 X 观点的资料"时，你其实是在要求它输出一个特定的结论。而它的机制是"给出最符合你要求的答案"，包括在没找到的时候，编一个出来。

正确的做法是反过来问：

关于"X 观点"，学界和业界有哪些不同的立场？
请分别列出支持方和反对方最主要的论据，并说明哪些论据比较强、哪些比较弱。
如果某个立场缺乏可靠依据，请明确指出来。

这样问，它会给你一个更完整的地图，而不是一个迎合你的答案。

还有一个更实用的做法：主动让它反驳你。

我的判断是"＿＿＿＿"。请尽力反驳这个判断，找出它最薄弱的地方。

用这个方法，你能提前发现自己的漏洞，而不是拿着一个经不起推敲的观点出去。

一份可以直接用的核实清单

把上面这些压缩成一张表。凡是要写进报告、发给别人、用于决策的信息，过一遍。

一个真实的工作流

假设你要写一份材料，里面有一个关键数据：某行业 2025 年的市场规模。

第一步，让 AI 给框架。 "这个行业的市场规模通常由哪几家机构统计？统计口径有什么差别？"

第二步，让它找线索。 "哪些机构会发布这个数据？分别是什么时间发布？"，注意，这一步只要"去哪里找"的线索，不要数据本身。

第三步，你自己去查。 打开那几个机构的官网，找到原始报告，看原始数字。

第四步，回头让 AI 帮你理解。 "这几个机构给的数据不一样，可能是什么原因导致的？"，这一步它做得很好。

第五步，在材料里注明来源和口径。 "据某某机构 2025 年 X 月发布的报告，按某某口径统计，该市场规模约为……"

这个流程比"问 AI 要个数字"多花二十分钟，但你的材料就站得住。

边界与坑

第一，不要因为它错了一次就完全不用。

它做探索、做框架、做理解，效率极高。把它用在正确的位置上。

第二，不要因为它对了十次就放松。

第 6 章那句话值得重复：危险在于它 95% 的时候是对的。你会慢慢放下戒心，然后在你不熟悉的领域踩坑。

第三，警惕"看起来很权威"的表达。

它经常输出"根据某某研究""多项调查显示"这类表达。这些引用可能是它编的。看到这类表述，要么让它给出具体信息去查证，要么直接删掉：写材料时不要保留无法核实的引用。

第四，注意你自己的确认偏误。

你希望某个数据是某个值，你就会更愿意相信它给出的那个值。这是人的问题，不是 AI 的问题。反向检验是唯一有效的解药。

第五，多轮对话里错误会累积。

第 5 章提到过一个数据：在专业领域，配备搜索功能的模型，幻觉率约 30%，关闭搜索后升到 60% 以上。原因是早期轮次的失误会成为后续推理的前提。 来源：HalluHard 2026-08 测试

做法：谈重要事情时，如果发现前面某一轮它有过明显错误，直接开一个新对话重新开始。不要试图在已经歪掉的对话里纠正回来。

三个核实实战

前面讲的是原则，这里走三个具体场景。

实战一：核实一个数字

场景：你要在材料里写"某行业的市场规模"。

第一步，先问框架：

这个行业的市场规模，通常由哪几家机构统计？它们的统计口径有什么差别？发布频率是什么时候？

注意这一步只要"去哪找"，不要数字。 拿到机构名单之后，你自己去官网。

第二步，让它给线索不要给答案：

这几家机构里，哪几家会公开年度数据？在它们的官网大概哪个栏目能找到？

第三步，你自己去查，找到原始报告，看原始数字。

第四步，带着数字回来问：

我查到三家给出的数据分别是 1200 亿、1850 亿、950 亿，差异很大。可能是什么原因造成的？

它可能会指出：统计口径不同（有的只算设备，有的算设备加服务）、年份不同、地域范围不同（有的只算国内，有的含出口）。

这一步是它的强项，它帮你理解差异的来源，而不是给你一个数字。

第五步，在材料里写清楚口径：

"据某机构 2026 年 X 月发布的报告，按某某口径统计，该市场规模约为 1200 亿元。"

注意加了"按某某口径"。 一个不加口径的数字，在专业场合是没有意义的。

实战二：核实一条政策

场景：你要在材料里引用一条政策。

这是最危险的一类。 因为政策条款的格式高度固定，AI 生成的假条款看起来非常像真的。

可靠流程：

第一步：不要问它"这条政策是怎么规定的"。直接去政府官网搜。

第二步：如果搜不到，可以问它：

我印象中有一条政策是关于某事的，可能叫某某名称。请帮我确认：是否存在这样一条政策？如果有，它的准确名称是什么？如果没有，直接说不确定。
不要编造政策名称。

第三步：拿到它给的名称，去官网验证这个名称是否存在。

第四步：如果名称对得上，找到原文自己读，不要让它替你解读。

为什么第四步不让它解读？ 因为政策的解读涉及适用范围、生效时间、例外条款，这些它很容易搞错。而且政策的用词非常讲究，它可能会用日常语言"翻译"掉关键限定条件。

一个特别提醒：政策有生效时间和失效时间。要确认你引用的版本是当前有效的。 这一条无论对 AI 还是对你，都是需要核对的。

实战三：核实一条文献引用

场景：你在写一份报告，想引用某篇论文的观点。

这是 AI 出错率最高的领域之一。 第 5 章那组数据里，涉及文献信息（作者名、论文标题、年份）的出错率约 10% 到 25%。 来源：2026 年幻觉率分布研究

可靠流程：

第一步：不要让它给你参考文献列表。 它可能编出格式完美但不存在的文献。

第二步：改成问"去哪里找"：

我想了解"某主题"的研究现状。请告诉我：这个话题通常在哪些期刊或会议上发表？有哪些关键词可以搜？

第三步：你自己去学术数据库搜关键词，看真实存在的文献。

第四步：找到真实文献之后，可以把摘要贴给它，让它帮你理解：

这是我的论文摘要，请帮我用三句话概括它的主要结论和局限。

这一步是安全的，因为资料是你给的。

第五步：引用时用你自己查到的准确信息（作者、年份、期刊）。

一个几乎可以当铁律的规则：

永远不要让 AI 生成你要引用的文献信息。 它生成的作者名、年份、期刊名、卷期号，任何一个环节都可能是编的，而且编得非常像。

这个坑之所以危险，是因为它只会在别人核查的时候才暴露，而那时候你的材料已经发出去了。 第 28 章讲到的那个"法庭上 AI 编造的判例"，根源就在这里。

一个"信心分级"的习惯

最后给你一个可以立刻用上的习惯。

对你掌握的每一条关键信息，在心里标一个等级：

A 级：我自己在官方来源上见过原文。

B 级：AI 告诉我的，并且我换了一种方式问它第二遍，两次一致。

C 级：AI 告诉我的，只问过一次。

D 级：我当时觉得"大概对"，没有深究。

行动规则很简单：

• A 级可以写进正式材料
• B 级可以写进内部讨论，但正式材料前要升到 A
• C 级只能作为线索，不能写进任何材料
• D 级根本不应该存在

这个习惯的价值在于：它把"我好像知道"这件事变成了明确的状态。

大部分信息事故不是因为人们故意撒谎，是因为把 C 级当成了 A 级。心里有个分级，这个错误就很难发生。

本章收束

三句话：

先分清你在做探索还是验证。探索可以放心用，验证需要外部核对。 正确的提问包含三个动作：要来源、给退路（信息不足就说不知道）、问数据截止时间。 不要让它找支持你观点的证据，反过来，让它反驳你。

第二篇还剩最后一章：第 17 章，用 AI 做工具。这一章会带你走完一个完整的小项目，从"有个想法"到"真的能用"。不会写代码也没关系。

苏芮做新媒体运营，每天有个固定动作：早上花四十分钟，把五个行业网站的新文章看一遍，挑出三条值得看的，整理成一段话，发到公司群里。

做了两年，一千多次。她算过，这件事大概花掉了她八百多个小时。

有一次她在群里抱怨，同事说："这个能不能自动化？"

她当时的想法是：得找技术部门排期，得写需求文档，得等排期，得测试……这么麻烦，还不如自己看。

后来她发现，这件事她自己一个下午就做完了。用的方法就是这一章要讲的。

造工具的三条路

按难度从低到高排，有三条路。绝大多数人只需要走第一条就够用。

第一条：做一个提示词模板。

你有一段固定的、重复性的文本处理任务？把提示词写成一个固定模板，每次只替换其中的资料部分。

这是最轻的"工具"。它不叫工具，但在实际使用中，它就是工具。

适合：规律固定、输入是文本、不需要连接其他系统的任务。

第二条：用零代码平台搭一个应用。

可视化拖拽界面，把"输入、模型、知识库、判断、输出"这些模块连起来。不需要写代码。

适合：需要多步骤流程、需要接知识库、需要对外提供一个固定入口的任务。

第三条：让 AI 帮你写代码。

这是 2026 年变化最大的一条路。你描述需求，它写出代码，你运行、报错、让它改，来回几轮，工具就能用了。

适合：需要连接你自己的数据、需要在自己的电脑上跑、零代码平台做不了的任务。

本文后面会重点讲第三条，因为它是"零基础也能造东西"这件事真正发生的地方。前两条更简单，但你如果不了解第三条的流程，就永远会被工具的能力边界卡住。

关键能力：把需求说成"规格"

不管走哪条路，第一步都是一样的：把你脑子里的模糊想法，写成一个具体到可以执行的说明。

这个说明有个名字，叫规格（spec）。写规格的能力，是造工具这件事里最核心的技能。而它恰好不需要编程知识。

一个完整的规格包含六块：

一、这是什么，解决什么问题。 一句话说清楚。

二、谁用，什么时候用。 是你自己每天用，还是同事也要用。

三、输入是什么。 输入从哪来，你手动粘、从文件读、从网页抓、还是定时触发。

四、处理逻辑是什么。 中间要做什么，按什么规则判断。

五、输出是什么。 输出成什么格式，给谁看，到哪里去。

六、失败的时候怎么办。 数据缺了、网站打不开、结果为空，怎么处理。

前五块大部分人都能想到，第六块几乎所有人都会漏，而它恰恰是决定工具好不好用的关键。

完整走一遍

现在把苏芮的需求按这六块写出来。

一、这是什么：每天早上从五个行业网站抓取最新文章，筛选出三条最值得看的，整理成一段 200 字的简报。

二、谁用：我自己用，每天早上 8 点半之前要发到公司群。

三、输入：这五个网站的网址，每天第一次运行时抓取它们的更新列表。

四、处理逻辑：
- 只取过去 24 小时内发布的文章
- 优先选标题里包含"政策""融资""数据""发布"这类词的
- 每个网站最多选一条，保证来源分散
- 如果某个网站当天没有新内容，跳过，不要重复昨天的
- 选出三条之后，每条写一句 30 字以内的推荐理由

五、输出：一段可以直接复制到群里的话。格式是：
```
【今日行业简报】
1. 标题 ， 推荐理由
2. 标题 ， 推荐理由
3. 标题 ， 推荐理由
```
不要加"以上就是今天的简报"这类收尾话。

六、失败处理：
- 某个网站打不开，跳过并在最后标注"X 站今日未获取到"
- 如果三条凑不齐，有几天写几条，不要凑数
- 如果需要登录才能看到内容的，直接跳过，不要尝试

这份规格写下来大概十五分钟。有了它，后面的事情就简单了。

三条路分别怎么做

如果走第一条路（提示词模板）

你每天手动打开那五个网站，把文章标题复制进去，用这个模板：

以下是我从几个行业网站抓取的今日文章标题和摘要。
请按这些规则帮我选出三条并写简报：
- 优先选包含"政策""融资""数据""发布"的
- 每个来源最多一条
- 每条写一句 30 字以内的推荐理由
- 输出格式：【今日行业简报】+ 编号列表
- 如果不够三条，有几条写几条

内容：＿＿＿＿

这个方案不自动，但它能在五分钟内完成原本四十分钟的工作。很多时候，这个程度就够用了。

如果走第二条路（零代码平台）

在平台上新建一个应用，流程大概是这样：

1. 定时触发（每天早上 8 点）
2. 抓取五个网址的内容
3. 把内容交给模型，附上你的规则
4. 模型输出简报
5. 输出到一个你可以复制的地方，或者直接发到群

平台的操作是拖拽式的，每个节点填参数。你要做的事情，本质上就是把你写好的规格，翻译成这个平台上的几个节点。

卡住的时候，就把那个节点截图发给 AI，或者把平台的报错信息复制给它，问它怎么设置。

如果走第三条路（让 AI 写代码）

这一条听起来最吓人，实际上在 2026 年反而可能是最省事的。

流程是这样：

第一步：把规格给它，让它先写"设计"而不是代码。

请先不要写代码。先告诉我你打算怎么实现，用到了哪些部分，每一步做什么。
我是完全不懂编程的人，请用大白话说明。

第二步：你确认设计没有问题之后，让它写代码。

设计没问题，请写代码。

第三步：运行，把报错原样贴回去。

我运行的时候出现了这个错误：
＿＿＿＿
请告诉我这是什么问题，怎么改。

第四步：重复第三步。

这是关键的一步。不要因为报错就觉得自己做不成。报错是这条路里最正常的环节，任何人写代码都会遇到。你要做的只是把错误信息完整地复制给它：不要自己转述、不要概括、不要只贴一半。

完整的报错信息里有它需要的一切线索。你概括之后就丢了。

第五步：用起来之后，改需求。

现在能跑了，但我想改一处：＿＿＿＿

一般来回五到十轮，一个小工具就成型了。

什么样的需求适合做，什么不适合

不是所有想法都值得做成工具。有个简单的判断标准：

值得做的：

• 每周至少重复一次
• 每次至少花十分钟
• 规则明确，不需要大量临场判断
• 出错了后果不严重

不值得做的：

• 只做一两次
• 每次都要根据不同情况灵活判断
• 出错代价很大（涉及钱、法律、对外发布）
• 需要连接你没有权限的系统

一条经验：优先做那种"错了也无所谓"的小工具。这样你不会因为怕出错而不敢用。

让 AI 帮你做工具的三个技巧

技巧一：让它解释它在做什么。

每次它给你代码或配置，都加一句："请用一句话解释这段在做什么。"

这不只是为了学习。当你知道它在做什么，你才能在出错时判断是哪里出了问题。

技巧二：小步走，别一次要太多。

不要一次说"帮我做一个管理系统"。先说"帮我做一个能把 Excel 里的数据读出来、按日期排序、输出成文本的脚本"。能用了再加功能。

技巧三：保留能跑的版本。

每次改之前，把能跑的版本复制一份存起来。改了之后不行，就退回去。这个习惯能省掉很多挫败感。

边界与坑

第一，注意账号和权限。

零代码平台需要你授权访问某些数据。给权限之前，想清楚它需要的最小范围是多少。不要图省事给全部权限。

第二，注意自动化工具会"自动出错"。

一个手动操作出错，你当场就能发现。一个自动工具出错，可能连续错了两个月你都没注意。凡是自动化的东西，都要定期人工抽查。

第三，涉及对外发布的内容，需要有人工确认环节。

自动生成的简报、自动回复的消息、自动发布的文案，如果直接对外，一旦出错就是公开事故。加一个"人工过一遍再发"的环节，成本很低，价值很高。

第四，不要一开始就追求完美。

第一版只要能用起来就好，哪怕需要你手动补两步。先用起来，再优化。很多人卡在"我要做一个完整的系统"，结果永远没有第一版。

第五，注意数据安全。

如果你把公司的数据交给第三方平台处理，先确认这符不符合公司规定。这一步经常被跳过，但风险很实在。

第二个项目：一个"客户询价整理"工具

苏芮做完简报工具之后，做了第二个。这个稍复杂一点，正好用来看流程的另一面。

痛点：每天有十几封客户询价邮件，内容是散的，有的写数量，有的写规格，有的只写"你上次那个多少钱"。她要把它们整理成统一的表格，报价时才好比。

第一版规格（她自己写的草稿，很粗）：

把询价邮件整理成表格。

问题在哪？ 这六个要素一个都没写清楚。输入从哪来？要提取哪些字段？怎么处理信息不全的？她试着自己回答了一遍，发现卡在"处理逻辑"上，她其实没想过"客户只写'你上次那个多少钱'该怎么处理"。

第二版规格：

这是什么：把客户发来的询价邮件整理成一张统一的表格，方便比价和报价。
谁用：我自己，每天下午处理当天的询价。
输入：我从邮箱里复制出来的邮件正文，一次一封。
处理逻辑：
- 提取这几个字段：客户名、产品名称、数量、规格要求、交期要求、其他备注
- 某个字段邮件里没写，填"未提及"，不要推测
- 如果邮件里指代不清（比如"你上次那个"），把原话放进备注，字段填"需确认"
- 如果一封邮件里有多款产品，拆成多行
输出：表格，列为"客户名 | 产品 | 数量 | 规格 | 交期 | 备注"
失败处理：
- 如果邮件内容和询价无关（比如只是寒暄），输出"非询价邮件"
- 如果完全看不出要买什么，输出"信息不足，需人工判断"

第三版（加了实际使用后的补充）：

跑了一周之后，她发现两个新问题，加进了规格：

- 数量里出现"要一些""稍微多点"这类模糊表述时，数量填"未提及"，模糊表述放在备注
- 客户名如果是简称或者昵称，按原样填，不要试图推断全称

这三版的过程说明一件事：

规格不是一次写对的，是"先写 → 用 → 补"这样长出来的。

第一版想不全很正常。重要的是先让它动起来，用实际问题去暴露规格的漏洞。

一个实用建议：工具用了一周之后，回头看看有没有出现过"这次它做错了"的情况。每一条都补进规格里。跑一个月之后，你的规格会比一开始精细得多。

一份可以反复用的规格模板

把上面的经验固化下来，这就是一个可以直接抄的模板。

【这是什么】
一句话说清楚这个工具做什么。

【谁用，什么时候用】
我自己 / 团队 / 客户；每天 / 每周 / 触发式。

【输入】
从哪来：我手动粘贴 / 上传文件 / 定时抓取 / 从某个系统读
格式：文本 / 表格 / 邮件 / 网页
一次处理一条，还是批量

【处理逻辑】
1. 要提取/判断哪些内容
2. 按什么规则处理
3. 信息不全时怎么填（这个特别重要：写"未提及"而不是推测）
4. 遇到模糊表述时怎么处理（原样保留，不要替我做判断）

【输出】
格式：表格 / 列表 / 一段文字 / 结构化数据
字段：具体有哪些列
长度限制：
不要出现的内容：

【失败处理】
- 输入为空 → 怎么处理
- 内容不相关 → 怎么处理
- 信息不足以判断 → 怎么处理
- 处理过程中报错 → 停下来告诉我，不要绕过

【权限边界】
- 只能读取：＿＿
- 可以写入：＿＿
- 不要做：＿＿（比如"任何情况下都不要修改或删除文件"）
- 涉及外发的内容：需要等我确认

最后两个方块是很多人会漏掉的，但它们在真实使用中最重要。

"失败处理"决定了工具出错时你是知道还是不知道。

"权限边界"决定了工具出错时你能不能承受后果。

这两个方块加起来不到一百字，但它们区分了"一个玩具"和"一个能放心用的工具"。

本章收束

三句话：

造工具的三条路：写提示词模板、用零代码平台、让 AI 写代码。按需求复杂度选，不是越高级越好。 最核心的能力是把需求写成规格，六块：做什么、谁用、输入、逻辑、输出、失败了怎么办。第六块最容易被漏。 让 AI 写代码时，报错就把完整错误信息贴回去，不要转述。来回五到十轮是正常节奏。

第二篇到这里结束了。

你现在会写（第 11 章）、会读（第 12 章）、会处理数据（第 13 章）、会做素材（第 14 章）、会学习（第 15 章）、会查证（第 16 章）、能造小工具（第 17 章）。

这一整套能力，已经能覆盖多数人工作里 80% 的 AI 应用场景。

第三篇要换一个层次：从"用别人做好的产品"，变成"把它接进你自己的流程"。第一步是第 18 章，API，这个词听着像程序员的事，其实它解决的是一个非常朴素的问题：怎么让 AI 在你的系统里自动干活。

苏芮做了一个小工具之后，发现了一个新问题。

工具确实好用，但每天还得她自己点一下。点完之后，简报出来了，还得她自己复制到群里。整个流程里，她还是要出现两次。

她想要的是：早上八点半，简报自己出现在群里，她什么都不用做。

这个需求，把话题从"用 AI"推到了"把 AI 接进去"。而接进去的标准方式，就是 API。

这个词听着像程序员的事。但它解决的问题非常朴素：怎么让 AI 在你没坐在电脑前的时候，也在干活。

API 是什么：一个窗口

先用一个类比。

你去餐厅吃饭。你不会走进厨房自己炒菜，你也不会要求厨师站到你桌边听你指挥。你看着菜单，跟服务员说"我要这个"，然后等着上菜。

API 就是那个传菜的窗口。

它是软件之间对话的一个约定：你给我什么格式的请求，我回你什么格式的结果。

• 你在自己的程序里，按约定的格式，把问题发出去
• 对方收到，处理，按约定格式把结果发回来
• 你的程序拿到结果，继续往下做

关键区别在于：用网页版，是"人"和"AI"对话；用 API，是"程序"和"AI"对话。

一个是你在敲键盘，一个是代码在自动跑。

一次调用长什么样

拆开看，一次 API 调用包含四样东西。

第一样：地址。 你要把请求发到哪里。每个服务会给你一个网址。

第二样：身份。 你是谁。靠一个叫密钥（API key）的东西证明。它是一串很长的字符，相当于你的账号密码。

第三样：内容。 你想让 AI 做什么。这里就放你的提示词。

第四样：参数。 一些设置，用哪个模型、要不要流式输出、温度多少、最多输出多长。

发出去之后，你会收到一个结构化的回复，里面装着 AI 的输出，以及这次用了多少词元。

一个最小示例（你不需要看懂每个词，但要看懂结构）：

{
  "model": "某个模型的名字",
  "messages": [
    {"role": "system", "content": "你是一个专业的编辑"},
    {"role": "user", "content": "把下面这段话改得更简洁：＿＿＿"}
  ],
  "temperature": 0.3,
  "max_tokens": 500
}

这段东西的意思是：用某个模型，先告诉它"你是编辑"，然后给它任务，温度设低一点（要稳定），最多输出 500 个词元。

看到这个结构，你会发现：它和你写提示词是同一件事，只是换了个地方写。

三个角色

理解 API 的时候，分清三个角色会很有帮助。

模型：真正干活的那个。它只是一个被调用的东西，本身不提供窗口。

API 服务：提供那个窗口。它负责接收请求、验证身份、调度算力、返回结果、记录用量。同一家公司的不同模型，通常共用一个窗口。

你的程序：发出请求、处理结果、继续后续动作的那一方。它可能是你自己写的脚本，也可能是零代码平台上的一个节点。

这三者的关系解释了一个常见困惑：为什么同一家公司的同一个模型，在网页上免费，用 API 却要花钱？

因为网页版是它们的产品，用免费吸引用户；API 是它们的产能，按用量收费。这是两套生意。

密钥：最容易出事的地方

单独说这一节，因为它真的很重要。

API 密钥就是一串字符，但它代表你的账户。谁拿到它，谁就能花你的钱。

有几条底线：

第一，不要把密钥直接写进代码里。 代码如果被别人看到、或者被上传到公开的地方，密钥就泄露了。正确做法是把它放在一个单独的环境变量或者配置文件里。

第二，不要把密钥发到任何聊天窗口里。 包括发给 AI。这条很反直觉，你问 AI"我这个密钥为什么用不了"，顺手把它贴过去，它可能就被记录在对话历史里了。

第三，只给需要的人。 团队协作时，给每个人分配独立的密钥，而不是共用一把。出了问题好定位，回收也方便。

第四，定期更换。 尤其是有人离职、或者设备丢失的时候。

第五，注意权限范围。 有些服务支持给密钥设置权限和额度上限。开了这个功能，即使密钥泄露，损失也是有限的。

如果哪天发现账单异常暴增，第一反应应该是：密钥可能泄露了。 立刻去后台撤销，再重新生成。

什么情况该用 API

不是所有需求都需要 API。判断标准很简单。

适合用 API 的情况：

• 要处理的量很大（几百上千条），手工做不现实
• 需要定时自动执行
• 需要接入自己的系统或数据库
• 需要把 AI 的输出直接变成下一步的输入
• 需要批量、一致地处理同一类任务

不需要用 API 的情况：

• 一周只用几次
• 每次都是不同的、需要你判断的任务
• 输出的内容需要你仔细推敲
• 用量很小，而且免费网页版已经够用

一个务实的建议：先用网页版走完流程，确认这件事值得自动化，再上 API。

不要一开始就想着搭系统。先手工做十遍，找到规律，再自动化。 手工做的十遍不是浪费，它们是你写规格的原料。

用 API 的三种姿势

按难度排，看你适合哪一种。

姿势一：零代码平台调用。

大部分零代码平台内置了模型调用节点。你在界面上填密钥、选模型、写提示词，不需要写任何代码。这是最推荐给初学者的方式。

姿势二：现成的工具。

有一些开源或商业工具，本身就是"帮你调用 API"的。你只要填密钥和配置，就能用它做批量处理、知识库问答之类的事情。

姿势三：自己写脚本。

让 AI 帮你写。就像第 17 章讲的那样：说清楚需求，让它写，报错就贴回去。

注意：这条路需要你在自己电脑上能运行代码。如果你连"怎么打开终端"都不知道，建议先走姿势一。

边界与坑

第一，密钥泄露是真实的、常见的、代价很大的事故。

这件事比本章其他所有内容都重要。见过太多因为把密钥提交到公开仓库，一夜之间被刷掉几万块的案例。

第二，注意并发和限流。

每个服务都有"每秒最多几次请求"的限制。如果你并发发出去一百个请求，大部分会失败。批量处理的时候，要控制节奏。

第三，注意超时和重试。

网络会断，服务会超时。你的程序要考虑"失败了怎么办"，是重试、跳过，还是停下来报警。这是第 17 章讲的规格里"第六块"的内容。

第四，注意成本会不知不觉涨上去。

API 是"用多少付多少"。一个循环里的错误可能让它调用几千次。第 19 章会专门讲怎么算这笔账。

第五，注意数据的合规性。

把公司数据通过 API 发给第三方，需要先确认这符合公司规定和相关的合规要求。这一步经常被跳过，但出问题的代价很大。

一次调用的完整拆解

上面那段最小示例只有一个骨架，这里把它展开，看看每个部分到底在干什么。

第 1 行："model": "某个模型的名字"

这是告诉 API"用哪个模型"。同一个服务商可能有十几个模型，价格和能力差别很大。

这一步就是你做成本控制的地方。 简单任务用小模型，复杂任务用大模型，第 19 章会详细讲怎么分。

第 2 到 5 行："messages" 数组

这是对话的内容。注意它是一个数组，可以放多条消息，每条有个角色标记。

"role": "system" 的那一条，就是第 5 章提到的"系统提示词"。

它是产品的规矩，用户看不到。你自己搭应用时，这一条是你写"这个助手是什么身份、守什么规矩"的地方。

为什么它要单独放一条？ 因为它的作用是"设定长期的行为方式"，和用户的临时问题不一样。

"role": "user" 的那一条，是用户的问题。

如果是多轮对话，这个数组会变成这样：

[
  {"role": "system", "content": "你是编辑"},
  {"role": "user", "content": "帮我改这段文字"},
  {"role": "assistant", "content": "改好的版本是……"},
  {"role": "user", "content": "再短一点"}
]

注意这里，整个历史都要重发一遍。

这就是第 19 章那个成本陷阱的技术根源。 模型没有"记忆"，每一次请求都需要把前面所有轮次重新发过去。所以第 10 轮对话的输入，包含了前 9 轮的全部内容。

理解了这一点，你就明白为什么"开新对话"能省钱，以及为什么"长对话会变慢"。

第 6 行："temperature": 0.3

温度。第 5 章讲过。0.3 表示偏保守，输出比较稳定。

第 7 行："max_tokens": 500

最多输出多少词元。

这一项有两个作用：一是防止它啰嗦一大段（省输出费，而输出贵），二是给你一个成本上限的保障。

发出去之后，你会收到什么？

一个大致的结构是这样的：

{
  "output": {
    "text": "改好的版本：……"
  },
  "usage": {
    "input_tokens": 245,
    "output_tokens": 168
  }
}

注意 usage 这一段。

它告诉你这次调用用了多少输入词元、多少输出词元。这是你核算成本的唯一依据。

如果你在做批量任务，要把这个数字记下来。 第 19 章讲的"先跑一周再上量"，靠的就是这个数据。

最后：不同服务商的字段名可能不一样，但这个结构是通用的：你告诉它用什么模型、说了什么话、要什么风格、出多长；它回你结果和用量。

看懂了这一层，你就理解了所有 AI 应用的底层逻辑。 你日常用的每一个 AI 产品，无论界面多花哨，背后都是这样一个请求在跑。

一次密钥事故的完整复盘

讲一个真实的场景类型。这类事故在 2026 年仍然频繁发生。

事情怎么开始的

一个人在做一个小工具，用 API 调用模型处理数据。他把密钥直接写在了代码文件的第一行，因为"这样最方便"。

项目做完，他上传到了一个公开的代码托管平台，想着"反正没什么敏感的"。

三天后

他收到一封账单提醒邮件。当月用量是平时的 40 倍。

发生了什么

代码一旦公开，就有人会用自动化脚本扫描整个平台，专门找类似密钥的字符串。找到之后，用这些密钥去调用服务，有的转卖给别人用，有的拿来跑自己的任务。

为什么会拖到三天

因为他没有设置用量告警。服务商的账单是周期结算的，他直到下一次看后台才发现。

正确的做法是什么

第一，密钥永远不写进代码。 放在一个独立的配置文件里，并且把那个文件加到"不上传清单"里。

第二，设置用量告警和硬上限。 超出阈值立刻收到通知，达到上限自动停用。这一条能在事故发生的那一刻就止住损失，而不是几天后。

第三，万一泄露了，第一件事是去后台撤销这把密钥。 不是改代码，不是删仓库，先撤销。撤销之后它就失效了，后面再慢慢清理。

第四，给密钥设置权限和额度。 大部分服务支持限制单把密钥能调用的模型和额度。开了这个，即使泄露，损失也是有限的。

第五，定期更换。 尤其是有人离开团队的时候。

这个复盘里最值得记住的一句话

密钥不是密码，是钱。

密码泄露你可以改。密钥泄露，在你还不知道的时候，就已经在花钱了。

所以判断标准很简单：任何可能被别人看到的文件里，都不该出现密钥。 包括聊天记录、截图、文档、代码。

顺带说一个反直觉的点：向 AI 提问"我的密钥为什么用不了"，顺手把密钥贴进去，这也是泄露。因为那串字符会留在对话记录里。

本章收束

三句话：

API 是让程序之间对话的窗口。它不是给人用的，是给代码用的。 用它之前，先手工做十遍，找到规律，写清规格。 密钥就是钱。不要写进代码、不要贴进聊天窗口、定期更换。

第 19 章算一笔账。很多人第一看到 API 账单的时候都吃了一惊，明明只跑了几百次，怎么这么贵。懂了计费方式，你就能把成本控制在一个很舒服的水平。

赵砚第一次看到 API 账单的时候，以为自己看错了。

他让团队做一个小工具：每天自动把客户发来的询价邮件整理成表格。一天大概五十封，一周三百多封。这么点量，他估摸着一个月花不了几十块。

账单出来，是预估的八倍。

他叫人去查，原因很朴素：那个工具在整理每封邮件的时候，把前面所有邮件的内容也一起发给了模型。也就是说，处理第 300 封邮件的时候，它把前 299 封也读了一遍。

第 19 章讲的就是这件事：AI 的成本结构，和大多数人的直觉不一样。

计费的基本单位：词元

第 5 章提过，词元（token）是模型的文字碎片单位。一个汉字大约等于 1 到 1.5 个词元。

所有按用量计费的 AI 服务，都是按词元收费。

这里有一个关键点需要记住：输入和输出分别计价，而且输出的价格通常明显高于输入。

为什么输出更贵？因为它是一次一个字"生成"出来的，每一步都要重新计算。输入可以并行处理，输出只能一个一个来。计算的密集程度不同。

价格的实际水平：不同服务、不同模型的差距可以达到几十倍甚至上百倍。2026 年曾有过公开数据对比：同一个时段，有的模型每百万词元输入 0.09 美元、输出 0.18 美元，而有些旗舰模型输入 5 美元、输出 30 美元，输入端相差约 55 倍，输出端约 166 倍。

所以我不会在这里给你任何具体价格。 价格变动太快，写进书里就是误导。你需要记住的是结构：

1. 输入便宜，输出贵
2. 不同模型之间的价格差距可以是两个数量级
3. 价格随时会变，用之前去看官网当前价格

为什么成本会翻倍：上下文的累积

回到赵砚那个案例。

朴素的想法是：处理一封邮件，成本等于这封邮件的长度。

实际不是。模型每次处理都要看到"到目前为止的全部上下文"。如果那个工具是在同一个对话里连续处理，那么第 N 封邮件处理时，前面 N-1 封的内容都在上下文里。

成本增长不是线性的，是平方级的。

举个具体的数字。假设每封邮件 500 个词元，要处理 100 封：

• 如果每封独立处理：100 × 500 = 50000 个词元
• 如果累积在同一个上下文里：第 1 封 500，第 2 封 1000，第 3 封 1500……第 100 封 50000。总和约 252 万个词元

差 50 倍。

这不是某个模型的毛病，是所有大模型的共同机制。理解它，你就能避开最大的一个成本陷阱。

解决办法很简单：批量任务时，每一条都开一个新的对话。

成本是怎么积累的：三个隐藏来源

除了上下文累积，还有三个容易被忽略的地方。

第一，系统提示词的重复计费。

如果你给每个请求都加一段 500 字的系统提示词（"你是一位专业的客服，请按以下规范回答……"），那么每一次请求都要为这 500 字付费。一万次请求就是 500 万字。

第二，重试的重复计费。

网络超时、服务报错、程序异常，每一次重试都是一次完整的计费。如果程序逻辑有 bug 导致循环重试，成本能失控。

第三，失败请求也会计费。

有时候请求发出去了，模型开始输出了，但你的程序超时断开了。这一部分通常照样算钱。

怎么估算成本

有一个简单的估算方法，建议你在上任何自动化方案之前先做一遍。

第一步：算单次请求的词元量。

把你的提示词复制到一个词元计数工具里（大部分服务商都提供），得到输入词元数。再估算输出的平均长度，得到输出词元数。

第二步：乘以次数。

每天多少次，乘 30 得到月度次数。

第三步：乘上单价。

输入词元数 × 输入单价 + 输出词元数 × 输出单价。

第四步：加一个安全系数。

乘 2 或者 3。因为实际使用中总会有重试、有失败、有你没想到的额外调用。

第五步：先跑一周再上量。

不要一次上全量。先让 1% 的流量走新流程，跑一周，看真实账单，再决定要不要扩大。

这一步是最重要的。 估算永远会偏，实测才是真的。

省钱的六个办法

按效果从大到小排。

第一，选对模型，不要都用最贵的。

这是省钱幅度最大的一条。同一个任务，用旗舰模型和用便宜的小模型，效果可能只差一点，成本差几十倍。

务实的做法是分级：日常的、简单重复的任务（分类、提取、格式转换、初筛）用便宜模型；只有真正需要复杂推理的任务才用贵模型。

2026 年行业里流行一个说法叫"模型路由"，按任务类型把请求分发给不同的模型，谁擅长什么就让谁干。头部团队基本都在这么做，因为根本不存在一个在所有任务上都最优的模型。

第二，控制上下文长度。

这是最容易见效的一条。

• 批量任务，每条独立处理，不要累积
• 不要让模型"看到"它不需要看到的内容
• 长对话及时开新窗口，把必要信息精简之后重新给它

第三，用缓存。

很多服务提供"缓存"功能：同一段内容（比如你那段固定的系统提示词）在短时间内被反复使用，第二次起价格会大幅降低。

如果你的系统提示词又长又固定，开这个功能能省很多。

第四，把输出压短。

输出比输入贵。所以让它输出短一点，效果明显。

做法：明确要求长度上限，要求它不要复述你的问题，不要加客套话。这些"礼貌性的文字"是要花钱的。

第五，批量处理。

有些服务提供"批量模式"：你把一堆请求一次性提交，它慢慢处理，价格通常便宜不少。代价是不能即时返回。

适合：不要求实时的任务，比如每天跑一次的报表生成、大批量的数据清洗。

第六，先做筛选，再调用模型。

能用规则解决的，不要用模型。

比如你要从一万条评论里找投诉。先用关键词筛出可能相关的 500 条，再让模型判断这 500 条。而不是让模型读完一万条。

这一条经常被忽略，但它的省钱效果可以到 20 倍以上。

一个常被忽略的成本：人的时间

在结束之前，我想提醒一个反向的问题。

有些人为了省钱，把成本压到极低，代价是模型质量差、要反复重试、结果要大量人工修正。

这时候省下的钱，是用人的时间换来的。而人的时间通常更贵。

一个合理的判断标准：如果一次调用的成本低于你处理它所需时间的价值，就不要省这个钱。

比如某次调用花 0.02 元，但它能省你三分钟的重复劳动，这笔账怎么算都是赚的。

成本优化的目标不是"最便宜"，是"在可接受的质量下最经济"。

边界与坑

第一，不要迷信单价低。

有的模型单价很低，但需要多次尝试才能得到可用结果，实际成本可能更高。

第二，注意"免费额度"的陷阱。

大部分服务有新用户免费额度。用完就开始收费。如果你在测试阶段没设预算上限，可能在不知不觉中花掉不少。

做法：上线的第一天就去后台设置用量告警和硬上限。

第三，注意价格之外的因素。

数据是否会被用于训练、服务是否稳定、支持哪些地区、有没有合规认证，这些在有些场景下比价格重要得多。

第四，定期复查。

模型价格下调的速度很快。今天你觉得贵的方案，三个月后可能已经变得很便宜。每隔几个月回头看一眼，别一直用着过时的判断。

第五，把成本算进方案里。

做任何自动化方案时，成本估算应该是方案的一部分，而不是上线之后才发现的问题。

三张成本估算表

下面三张表，覆盖最常见的三类任务。请把那列"单价"空着，用的时候去官网现查。 那才是正确的用法。

表一：单次任务成本

一个参照：一段 500 字的提示词 + 一段 800 字的输出，加起来大约 1560 个词元。这个量级在大部分中等价位的模型上，单次成本是很低的。所以对个人使用来说，"能不能用"几乎不是成本问题。

真正需要算的是下面两张表。

表二：月度批量任务成本

安全系数这一步不能省。

原因有三个：网络超时会重试、程序出错会重跑、你预估的输出长度通常会偏短。乘 2 是保守的，乘 3 更保险。

如果这一步算出来的数字让你觉得"有点贵"，那就是个信号：要么换个更便宜的模型，要么去检查一下流程里有没有"上下文累积"的问题。

表三：成本优化前后的对比

这是最有用的一张。赵砚那个案例就是靠它找到问题的。

注意"输出词元不变"这一行。

优化的是输入侧，因为输入侧才是那个"平方级增长"的陷阱所在。这条规律值得单独记住：成本优化的最大空间，几乎总在输入侧。

从 8 倍超支到正常：一个优化过程

把赵砚那个案例的后续展开。

问题定位。

技术同事看了一下，发现工具在处理邮件时，用的是同一个对话窗口连续处理。第 300 封邮件处理时，前面 299 封的内容全在上下文里。

优化第一刀：改成每条独立。

每封邮件开一个新的请求，不带上一条的上下文。

效果：输入词元从 250 万降到 5 万。成本直接降到原来的 2% 左右。

就这一刀，问题基本解决。

优化第二刀：分级用模型。

原来的流程里，"提取字段"和"判断邮件是否有效"用的是旗舰模型。

但这两件事其实很简单：提取字段是格式转换，判断有效性是分类。这两类任务小模型完全够用。

只有"邮件内容含糊、需要理解上下文意图"的那部分，才保留旗舰模型。

效果：整体成本再降一半左右。而且因为小模型更快，处理速度也上去了。

优化第三刀：先筛再调。

原来所有邮件都过模型。后来加了一个前置规则：标题里带"退订""自动回复""不在办公室"的直接跳过，不进模型。

效果：每天进入模型的邮件从 50 封降到 38 封左右。看起来省得不多，但这是最省事的一刀，写两行规则而已。

优化第四刀：给输出设长度上限。

原来没有限制，模型有时会写一大段解释。加了上限之后，输出词元降了约 30%。

输出比输入贵，所以这一刀的效果比看起来大。

四刀之后的账：从超支 8 倍，变成了比最初预估还低一点。

这个案例里最值得学的两点

第一，最大的一刀来自"改变使用方式"，不是"换更便宜的服务"。 上下文累积是个使用习惯问题，改掉它不花钱。

第二，优化是有顺序的。 先解决结构性的浪费（上下文累积），再考虑分级，最后才是抠细节。顺序反了，你会在省小钱上花大力气。

一个通用原则：先看流程，再看模型，最后看参数。 大部分成本问题是流程造成的。

本章收束

三句话：

输入便宜、输出贵，不同模型之间可以差几十倍。价格随时变，看官网。 最大的成本陷阱是上下文累积，批量任记得须一条一个独立请求。 省钱的第一原则是分级用模型：简单任务用便宜的，别都上最贵的。

到这里，你知道了怎么接（第 18 章）和怎么算（第 19 章）。但还有一个更根本的问题没解决：

模型不知道你的公司、你的资料、你的业务。怎么让它懂？

第 20 章要给答案。这是一个我觉得最"神奇"的技术，因为它用一个简单得不像话的思路，解决了一个大问题。

先做一个思想实验。

你招了一个新员工，名校毕业，知识面很广。他读过很多书，对历史、科学、商业都有了解。唯一的问题是：他完全不了解你的公司。

上班第一天，你问他："我们去年的客户投诉主要集中在哪些方面？"

他会怎么回答？

如果他诚实，他会说不知道。但如果他被要求"需要有问必答"，他可能就会根据一般公司的常见情况，编一个听起来合理的答案：物流时效、产品质量、售后服务。

这个答案很可能跟你公司八竿子打不着。

现在的问题不是这个员工不行，而是你给了他一个他没法完成的任务。

正确的做法是什么？把资料递给他，然后问。

你递给他一份投诉汇总表，他就能给你一个准确的答案。

RAG 做的就是这个"递资料"的动作，而且每次都自动递。

RAG 的全称是检索增强生成（Retrieval-Augmented Generation）。名字很长，但拆开看就三件事：检索、增强、生成。翻译成人话就是：先去资料库找相关内容，再把找到的内容一起交给模型，让它据此回答。

为什么需要它

模型的内部知识来自训练数据。训练数据是公开的互联网内容，不包括：

• 你公司的内部文档
• 你的产品手册和报价单
• 你的客户资料和历史记录
• 你个人的笔记和积累
• 任何你没有公开的信息

而且即使是公开信息，它也可能记错，第 5 章讲过，长尾细节的出错率能到 15% 到 40%。 来源：2026 年幻觉率分布研究

所以想让它回答关于你的事情，只有两条路：要么把它塞进上下文，要么用 RAG。

塞进上下文是最直接的做法：你打开对话框，把资料粘贴进去，然后提问。

这个做法在小场景下完全够用。但有几个硬限制：

• 上下文窗口有上限，装不下太多资料
• 每次都要重新粘贴，很麻烦
• 资料多了以后，它在里面"找"的能力会下降（"迷失在中间"）
• 每次都要为这些资料付输入费

RAG 解决的就是这几个问题。 它不是每次都把全部资料递过去，而是先找到最相关的那几段，只递这几段。

这就是核心思路，简单得不像话，但效果非常好。

三段式

RAG 的完整流程分三步。

第一步：切块

把资料库里的所有文档，切成一段一段的小块。

为什么不能整份存着？因为检索的时候你需要精确到"哪一段相关"。整份文档太粗了，一份 50 页的合同，你问关于违约金的问题。如果检索的粒度是"整份合同"，那等于把整份合同都递过去了。

切块的大小是个权衡：

• 块太大：检索精度低，递过去一堆无关内容，浪费上下文，还可能把有用信息淹没了
• 块太小：一句话一块，语义不完整，检索出来的东西看不懂

实务上常见的做法是每块几百字，并且让相邻的块之间有一点重叠，避免信息被切断。

一个细节很重要：切块的时候，最好是按语义切，而不是按字数硬切。如果一刀切在某段话中间，那一块就废了。现在的工具一般会尝试按段落、按标题层级来切。

第二步：检索

用户提问时，去资料库里找出最相关的几块。

怎么判断"相关"？有两种方式。

方式一：关键词匹配。

最朴素的方式，看哪一块里的词和问题里的词重合得多。

优点是简单、可控。缺点是它只认字面。你问"怎么退货"，而文档里写的是"商品寄回流程"，关键词对不上，就检索不到。

方式二：语义检索（向量检索）。

这是当前的主流做法。

它的原理是：把每一块文字都转换成一串数字（这叫向量）。这串数字代表了这块文字的意思。意思相近的文字，它们的数字也相近。

你可以这样理解：假设我们用一个坐标来标记每段话的"意思"。"退货"和"商品寄回"这两个词，字面完全不同。但在"意思"这个坐标系里，它们的位置很接近。所以用语义检索时，能找出来。

这个技术是 RAG 真正好用的关键。 因为它让检索跳出了字面，进入了"意思"这一步。

第三步：生成

把检索到的几块内容，连同用户的问题，一起交给模型，让它基于这些内容回答。

这一步有一个非常重要的提示词技巧：

请只根据下面提供的资料回答问题。
如果资料中没有相关信息，直接回答"资料中没有提到"，不要根据你的其他知识推测。
回答时请标注信息来自哪一段。

这几句话直接决定了 RAG 的质量。不写这几句，模型会在资料不足时用它自己的知识去补，你就失去了 RAG 的意义。

它为什么有效

有一个数据很能说明问题：高质量的检索配合 RAG，能把事实类查询的幻觉率降低 50% 到 80%。 来源：2026 年幻觉缓解效果研究

为什么降这么多？

因为它把任务从"回忆并生成事实"变成了"从给定的几段话里找答案并组织语言"。后者的难度低得多，出错空间小得多。

打个比方：闭卷考试容易出错，开卷考试不容易出错。RAG 就是把闭卷改成了开卷，而且每次只翻开你需要的那几页。

但要注意"高质量检索"这个前提。 如果检索没找到对的内容，模型拿着不相关的资料，反而可能被带偏，它会努力从一堆无关内容里找出一个答案，结果更糟。

这就是 RAG 的核心难点：效果好坏的瓶颈，通常不在生成模型，而在切块和检索。

什么情况下 RAG 效果不好

有几种情况，RAG 会明显力不从心。提前知道这些，能帮你避免白费功夫。

第一，问题需要跨大量文档综合。

RAG 一次只取几块。如果一个问题需要"把分布在 50 份文档里的信息汇总起来才能回答"，RAG 做不到。它只能看到被检索出来的那几块。

第二，资料本身结构混乱。

如果原始资料是扫描件、手写笔记、表格图片、格式错乱的老文档，切块和检索的效果都会很差。垃圾进，垃圾出。

第三，问题需要理解整体语境。

比如"我们这份方案的总体思路有没有问题"。这类问题需要看到全局，而 RAG 只能看到局部片段。

第四，资料里的信息互相矛盾。

它检索到两块互相矛盾的内容，可能会把两者混在一起给你一个四不像的答案。这种情况需要在资料准备阶段解决，或者让它明确列出矛盾。

第五，问的是最新的、资料里没有的东西。

这个不用解释。资料里没有的东西，RAG 也变不出来。

边界与坑

第一，RAG 不能解决"资料本身是错的"这个问题。

如果资料库里有一份过期的政策文件，它检索到了就会照着答。保持资料库的时效性和准确性，是使用者的责任。

第二，切块策略比模型选择更重要。

很多人在纠结"用哪个模型"，但真正决定效果的是切块和检索。同一份资料，切块方式改一下，效果可能天差地别。

第三，注意"检索不到"和"检索到错的"是两种问题。

前者表现为它说"资料里没有"，后者表现为它给出了错误答案。排查时先看日志，确认它到底检索到了什么。

第四，加一个"引用来源"的要求。

让它标注每句话来自哪一段，你能快速发现它是不是在编。同时，如果它标注的位置明显不相关，说明检索环节有问题。

第五，权限问题别忽略。

如果资料库里有不同密级的内容，不同的人应该能查到不同的范围。这个权限控制是在 RAG 系统里做的，不是靠提示词。做企业知识库时，这是需要考虑的一环。

一次切块与检索的完整演示

第 20 章正文说了"效果瓶颈在切块和检索"。这里用一个具体例子看它到底怎么影响结果。

原始资料：一份 40 页的员工手册，内容包括公司介绍、考勤制度、请假流程、报销标准、福利政策、保密要求、离职流程。

问题：员工想了解"年假怎么请"。

切法一：按固定字数硬切（不好的做法）

按每 800 字一刀切下去，不管内容边界。

结果：请假流程的说明被切成了三块，开头一块，中间一块（关于审批时限的那段），结尾一块。而且第三块的末尾还混进了报销标准的第一段。

检索时会发生什么：

系统去找和"年假怎么请"最相关的块。它可能找到第二块（关于审批时限）。但拿不到"提前几天申请"这条信息，因为那在第三块里。

结果：模型只看到"需要主管审批，审批时限 2 个工作日"，不知道"需提前 3 天申请"。

员工拿到的答案是不完整的。 而且看起来一点问题都没有，它的回答流畅、有依据、格式规范。

这就是最难发现的一类错误：不是编，是漏。

切法二：按语义切（好的做法）

按标题层级和段落边界来切。每一块是一个完整的语义单元。

结果：请假流程的说明完整地落在同一块里。另外，每块前面都自动加上了它的所属标题，比如"【请假制度-年假】"。

检索时会发生什么：系统直接命中这一块，模型看到了完整的说明。答案准确。

两种切法的差别在哪里？

只在一个地方：有没有尊重内容的语义边界。

而这一点带来的效果差别，可能比"换个更强的模型"大得多。

这就是为什么说"瓶颈不在模型"。

检索环节的对比

再看检索方式的影响。同样问"年假怎么请"。

用关键词匹配：如果手册里写的是"年休假申请流程"。而员工问的是"年假怎么请"，"年假"和"年休假"、"请"和"申请"都对不上。可能检索不到。

用语义检索：它理解"年假"和"年休假"是一个意思，"怎么请"和"申请流程"是一个意思。能检索到。

这就是语义检索的价值：它跳出了字面。

但语义检索也有它的问题：有时候它会"找得太宽"。你问"年假怎么请"，它可能把"病假流程""调休规则"也检索进来，因为语义上相关。

实务上的做法通常是混合：先按标签过滤（只在"请假制度"这一类里找），再用语义检索排序。

这个两段式的做法，能同时提高准确率和召回率。 如果你用的平台支持标签或分类过滤，要用上。

从这个演示里带走什么

第一，切块策略是第一优先级。

调整切块方式带来的改善，往往大于换模型。如果你只能调一个东西，调它。

第二，检索命中的内容，要能看到。

大部分平台都提供了"查看检索结果"的功能。出问题时第一件事就是看它到底检索到了什么。 不看这个就开始调提示词，等于蒙着眼睛修车。

第三，在资料里加上清晰的标题和结构。

你自己写文档时，标题写得清楚一点，切块就会更合理，检索就会更准。

这个动作的成本极低，收益极高。 它属于那种"做一次，长期受益"的事。

第四，每块都带上它所属的标题。

这样即使切块有不完美的地方，模型也能从标题里知道这段内容大概是在讲什么。

一个好的 RAG 系统，80% 的功夫花在资料准备上。 这句话在这一章出现了三次，因为它最重要。

为什么"递资料再问"比"直接问"可靠这么多

最后从一个更本质的角度看这件事。

对比两种模式：

模式一（闭卷）：你问它一个问题，它从内部参数里"回忆"答案。

模式二（开卷）：你给它几段资料，再问它一个问题。

为什么模式二可靠这么多？

因为两个模式要求的任务性质完全不同。

闭卷模式要求它做的事：判断"我内部有没有这个知识"→ 如果有，提取出来 → 如果没有，生成一个"最像答案"的内容。

问题出在中间那一步：它没有能力可靠地判断"我到底知不知道"。 第 6 章讲过，它缺的恰恰是"知道自己不知道"这个能力。

开卷模式要求它做的事：在给定的几段文字里找相关内容 → 组织成回答。

这个任务简单得多，而且不需要那个它不具备的能力。 资料就在眼前，有就是有，没有就是没有。

这就是 RAG 的根本价值：它把任务从"你具备的能力之外"挪到了"你具备的能力之内"。

这也解释了那组数据：高质量的检索配 RAG，能把事实类查询的幻觉率降低 50% 到 80%。 来源：2026 年幻觉缓解效果研究

它不是让模型变聪明了，它是让模型做一件更容易的事。

这个思路可以迁移到很多地方。

当你发现 AI 在某件事上总做错时，先问一句：我是不是在要求它做一件它能力之外的事？ 如果是，想办法把任务改造成它能力之内的，给它资料、分成小步、或者干脆自己来做决策，让它只负责组织语言。

这个思路，是这本书里最通用的一个方法论。 它会出现在后面的每一章里。

本章收束

三句话：

RAG 的核心思路：不把所有资料塞给它，而是先找到最相关的几段再给它。 三段式：切块、检索、生成。效果瓶颈通常在切块和检索，不在模型。 需要在提示词里要求"只用给定资料回答，没有就说没有"，不写这句，RAG 就白做了。

第 21 章我们动手。从零开始搭一个自己的知识库助手，全程不需要写代码。这一章会给你一份完整的流程，包括最常见的七种故障和对应的排查方法。

苏芮转岗了，从运营转到产品。新岗位第一件让她头疼的事是：公司产品线的资料散在十几个地方。

产品手册是 PDF，报价单是 Excel，常见问题在客服系统里，历史方案在几个人的电脑上，最新政策变动在公司群里。新人入职要学三个月才能答得上客户的问题。

她想做一个东西：把所有资料放一起，任何人问一句，就能得到带出处的答案。

她不会编程。她用了两天做完的。

这一章就把这两天拆开，一步一步写清楚。你跟着做一遍，就能拥有一个自己的知识库助手。

先选路

有三条路，按投入从低到高。

路线 A：现成的产品。

市面上已有不少知识库类产品，上传文档、建库、问答，开箱即用。适合：个人或小团队，需求通用。

路线 B：零代码平台。

在零代码平台上拖拽搭建。可以自定义流程、接入企业系统、控制权限。适合：需要定制、要接入内部系统。

路线 C：自己写。

用开源框架自己搭。完全可控，成本可能更低，但需要技术支持。

给零基础读者的建议：先走路线 A 或 B。 只有在明确遇到它们的限制时，才考虑路线 C。

下面的流程对三条路都适用，因为核心步骤是一样的。

第一步：整理资料（这一步决定 80% 的效果）

这是最枯燥、也最重要的一步。请认真对待。

原则一：先收拢，再整理。

把所有散落的资料集中到一个地方。不要急着分类，先都找出来。

原则二：只放"要回答的问题所需要的资料"。

很多人一激动就把整个共享盘都传上去。结果是检索质量直线下降，无关内容越多，检索越容易跑偏。

一个判断标准：如果一份资料不包含任何别人可能问到的问题的答案，就别放。

原则三：处理格式问题。

按效果从好到坏排：

• 结构清晰的电子文档（Markdown、Word、纯文本），最好
• 表格类（Excel、CSV），不错，但要注意表头
• 电子版 PDF，可以，但要注意复杂排版可能被解析错
• 扫描件、图片 PDF，需要先做文字识别，效果会打折
• 手写笔记、截图，最差

如果资料里有很多扫描件：先做一次文字识别，人工检查关键内容。这一步花的时间会在后面省回来。

原则四：处理时效和冲突。

把过期资料删掉或明确标注。 这一步极其重要。如果资料库里有 2023 年的政策和 2026 年的政策，模型检索到哪个都可能，它不会自动选新的。

如果无法删除（比如历史存档需要保留），在文件名或文档开头明确写上"此文件已作废，请以 X 版本为准"。

原则五：给文件起清楚的名字。

文件名会参与检索。2026年产品报价单-国内渠道-.xlsx 比 新建表格(3).xlsx 强太多。

第二步：切块与建库

如果是现成产品或零代码平台，这一步基本是自动的。你只需要在设置里选一下切块大小。

如果平台给了选项，怎么选：

• 资料以短问答、条目为主（如 FAQ）→ 切块小一些，几百字
• 资料以长文档、说明文为主 → 切块大一些，一千字左右并加重叠
• 拿不准 → 用默认值，后面用测试来调

建库时要注意：

• 给不同的资料类型打标签（如"产品""政策""售后"）。后面检索时可以按标签过滤，大幅提高准确率。
• 记录每份资料的更新日期。过期内容的排查靠它。

第三步：写系统提示词

这是决定助手"性格"和"规矩"的地方。可以直接用下面这份：

你是一个基于内部资料回答问题的助手。

规则：
1. 只根据提供的资料回答问题。
2. 如果资料中没有相关信息，直接回答"现有的资料里没有找到这个问题的答案"。
   不要用你自己的知识补充，不要推测。
3. 每个结论后面标注来源，格式为【来源：文件名】。
4. 如果检索到的资料之间互相矛盾，把矛盾的双方都列出来，
   并说明它们分别来自哪份资料，不要替我做选择。
5. 如果问题本身表述不清，先问清楚再回答，不要猜我的意思。
6. 回答用简洁的分点形式。不要加"希望以上对您有帮助"这类客套话。

这份提示词里最关键的规则是第 2 条和第 4 条。

第 2 条防止它用内部知识瞎补。第 4 条让矛盾显性化，而不是被它悄悄抹平。

第四步：测试（很多人跳过，然后吃亏）

建好之后不要直接投入使用，先测。

做法：准备一份测试集。

从你的资料里，挑出 20 个真实的、别人会问的问题。其中要包含：

• 15 个有答案的：正常问题，答案明确在资料里
• 3 个跨文档的：需要综合两份以上资料才能回答
• 2 个资料里没有的：考验它会不会老实说"没找到"

最后 2 个最重要。 这是唯一能检验它会不会编的测试。

怎么判定通过：

• 答案正确（与资料一致）
• 引用的来源准确（不是瞎标的）
• 没有答案的那两题，它老实说了"没找到"

记录失败案例：每一条失败的，记下它检索到了什么、错在哪。这些记录是下一步调优的依据。

第五步：调优（七种常见故障与对策）

这是最实用的一张表。遇到问题对照着看。

排查的基本思路：先确认"检索到的是什么"，再判断"是检索的问题还是生成的问题"。

大部分平台能看到检索结果，要看这一步。跳过它，你就是在盲猜。

第六步：上线与维护

上线时：

• 先给一小部分人用（比如你们组），跑一到两周
• 收集他们问得最多的问题，补充到测试集里
• 收集"它答错了"的案例，定期修复

维护清单（建议每月做一次）：

• [ ] 新增的资料已入库
• [ ] 作废的资料已删除或标注
• [ ] 高频问题有没有答错
• [ ] 测试集中的题目是否还全部通过
• [ ] 权限设置是否需要调整

一个容易被忽视的问题：知识库会慢慢腐化。资料一直在变，但没人维护知识库，半年后它给的就是半年前的答案。安排一个人负责它，比技术选型重要得多。

边界与坑

第一，不要指望一次搭好。

第一版效果一般很正常。测试 → 找问题 → 调整 → 再测试，两三轮回合之后效果会明显好起来。

第二，资料质量比什么都重要。

同样的工具，资料整理得好的效果可以比乱糟糟的好几倍。如果你的知识库效果差，第一件事是回去看资料，不是换工具。

第三，注意权限。

如果资料里有敏感内容（客户信息、薪资、未公开的方案），要在系统里做权限隔离。不要指望靠提示词说"不要泄露"。 提示词是软的，权限是硬的。

第四，不要让它在没有人工确认的情况下对外回答。

面向客户的场景，建议先做成"给内部人员用的辅助工具"，让真人看着用一段时间，确认可靠之后再考虑对外开放。

第五，算清成本。

每次问答都要调用模型，还要算上检索的开销。第 19 章的方法用上，先估算再上量。

一份可直接使用的测试集样例

第 21 章正文说"测试集要包含 20 题，其中 2 题是资料里没有答案的"。这里给你一份完整的样例，你可以照着改成自己场景的版本。

假设场景：一家做企业培训的公司，知识库里有产品介绍、课程大纲、报价规则、讲师资料、常见问题。

第一组：常见标准问题（10 题，检验基本功）

第二组：模糊或表述不清的问题（4 题，检验它会不会瞎猜）

第二组的判定标准和其他组不一样，正确答案是"它追问了"，不是"它回答了"。

这一点很重要。 一个不敢说"我不确定"的助手，在真实场景里会造成很大的麻烦。

第三组：需要跨材料综合的问题（4 题，检验上限）

第三组的合理期待是"部分通过"。 如果这四题全对，反而要怀疑，可能是它在编。

第四组：资料里没有答案的问题（2 题，最关键）

为什么第 19 题的答案需要是"资料里没有提到"，而不是"没有"？

因为这两句话的含义完全不同。

"没有"是一个判断，它需要依据。而它没有任何依据，所以这个判断是编的。

"资料里没有提到"是一个事实陈述，它能验证，而且它没有越过自己的边界。

这一题是整份测试集里最有价值的一题。 它检验的不是知识，是克制。

如果你只测一道题，就测这一道。

怎么算分

第四组需要满分。 如果它在这两题上编了，其他组得分再高也不能用，因为这意味着它在任何不知道的地方都会编。

记录表

跑测试的时候用这张表，重点记最后一列。

"错在哪"这一列是整张表的价值所在。

因为不同的错，对应完全不同的修法：

• 没检索到 → 调切块、调检索方式、改文件名
• 知识错 → 资料有误，去改资料
• 编造 → 加强提示词约束（第 21 章那份模板的第 2 条）
• 格式错 → 改输出要求
• 越界下判断 → 强化"信息不足要追问"的规则

修完再跑一遍，对比基线。 这就构成了一个循环。

跑三轮之后，你的知识库助手会稳定很多。 而这三轮的总投入，大概是一个下午。

本章收束

三句话：

搭知识库，八成功夫在整理资料上。先收拢、清过期、改文件名，再谈技术。 测试集要包含"资料里没有的问题"，这是唯一能验出它会编的测试。 效果好坏的瓶颈在检索，不在模型。排查时先看它检索到了什么。

第三篇还剩三章：把通用模型变成专属模型（第 22 章）、让 AI 自己干活（第 23 章）、以及怎么判断它做得对不对（第 24 章）。第 24 章是整本书里最容易被跳过、也最不该跳过的一章。

赵砚坐在会议室里，听两个供应商介绍方案。

第一家说："我们的模型是在行业数据上微调过的，效果比通用模型好很多。"报价一年六十万。

第二家说："我们用通用模型加知识库，资料一变就更新，不用重新训练。"报价一年十五万。

赵砚问了同一个问题："如果我们下个月出了新产品，你们多久能让系统知道？"

第一家说："需要重新整理训练数据，大概三到四周。"

第二家说："把新资料传上去，当天。"

赵砚当场做了决定。

这个场景里没有"技术更先进"的胜负，只有"更合适"的胜负。 这一章要讲的，就是怎么在三条技术路线里做出正确选择。

三条路，解决三个不同的问题

当你想让 AI"更懂你"的时候，有三条路可选。

路线一：优化提示词

改什么：你发给它的话。

能解决：表达不清、格式不对、风格不符、遗漏要素。

成本：几乎为零。时间成本为主。

迭代速度：秒级。

局限：模型的知识边界没变，它仍然不知道你的私有信息。

路线二：RAG（检索增强生成）

改什么：它能看到什么资料。

能解决：它不知道你的私有信息、资料更新频繁、需要标注出处。

成本：中等。需要整理资料、搭系统、维护。

迭代速度：小时级（替换资料即可）。

局限：每次回答都要检索，速度稍慢；一次看到的资料有限，不适合需要通读大量材料的任务。

路线三：微调

改什么：模型本身的参数。

能解决：特定的表达风格、固定的输出格式、领域的术语习惯、特定任务的行为模式。

成本：高。需要准备训练数据、跑训练、做评测。

迭代速度：天级到周级（要重训）。

局限：更新知识很慢；需要一定量的高质量样本；做不好可能让模型整体变差。

三条路的判断顺序：先试提示词，再试 RAG，最后才考虑微调。

这个顺序不是技术难度排序，是投入产出比排序。绝大多数需求在前两步就解决了。

微调到底是什么

拆开讲一下，这样你能判断什么时候它值得。

第 2 章讲过，训练是"给例子、算误差、调参数"的过程。微调就是在已经训练好的模型上，用你的少量数据再做一轮这样的调整。

关键区别在于"少量"。

从零训练一个模型，需要海量数据和巨量算力。微调通常只需要几百到几万条样本，几小时到几天就能完成，成本低得多。

为什么有效：因为基础模型已经学会了语言和常识，你不需要重新教它这些。你只需要告诉它"在我们这个场景里，应该这样做"。

一个准确的类比：

第 20 章那个新员工，微调不是给他资料（那是 RAG），而是让他跟着你的老员工实习一个月，学你们公司的说话方式和做事习惯。

实习之后，他说话像你们公司的人了。但他仍然不记得具体的客户信息，那还是要靠查资料。

这句话很重要：微调改的是"行为方式"，不是"知识内容"。

很多人对微调最大的误解，就是以为它能"喂资料"。传一堆文档进去微调，指望它记住内容，效果通常很差。因为：

第一，微调需要的是"输入-输出"配对的样本，不是单纯的文档。

第二，微调的参数量小，塞不进太多新事实。

第三，事实更新之后，你还要重新训练。

要它记住事实，用 RAG；要它学会风格和格式，用微调。

微调的三种形式

按投入从低到高。

形式一：参数高效微调。

不去动全部参数，只在模型上挂一小块可训练的部分，只训练这一小块。

优点是便宜、快、不容易把原模型练坏。这是目前个人和小团队最常用的形式。

形式二：全量微调。

动全部参数。效果上限更高，但成本高、需要的数据多、风险也大（练坏了就回不去了）。

形式三：蒸馏。

这个思路不太一样，值得单独说。

蒸馏是用一个大的、强的模型去教一个小的、弱的模型。

做法是：让小模型去模仿大模型的输出。大模型回答一万个问题，这些小模型学习。学完之后，小模型在很多任务上能达到接近大模型的效果，但运行成本低得多。

蒸馏的价值在于成本。 如果你有一个高频、固定的任务，用大模型效果很好但太贵，就可以用蒸馏得到一个小而专的模型。

但要注意一个风险：第 5 章提到过一个发现，经过蒸馏压缩的模型，可能会出现"忠实性幻觉"增加的问题。也就是说，它更容易说出超出给定资料范围的内容。用在需要严格依据资料回答的场景时，这一点要认真测。

什么时候该微调

有个简单的判断清单。下面几条如果都成立，微调才值得考虑：

• [ ] 提示词已经优化到极限，效果还是不够
• [ ] RAG 也试过了，解决不了你的问题
• [ ] 你需要改变的是"行为方式"（风格、格式、判断习惯），不是"知识内容"
• [ ] 你能准备出至少几百条高质量的训练样本
• [ ] 你的任务高频、稳定，值得投入
• [ ] 你有办法衡量微调前后的效果差异

如果任务低频或者内容一直在变，微调几乎必然不是好选择。

模型选择的框架

微调之外，还有一个更日常的问题：手头有几十个模型，选哪个？

一个实用的框架，从四个角度问自己。

第一，任务难度。 简单重复的任务（分类、提取、格式转换）用便宜的小模型就够；复杂推理才需要旗舰模型。

第二，对准确性的要求。 涉及事实和数据，优先选幻觉率低的；涉及创意和表达，可以宽一点。

第三，成本和速度要求。 高频调用需要考虑成本；实时交互需要考虑响应速度。

第四，数据合规要求。 数据能不能出境、能不能给第三方、能不能私有部署，这一条在有些场景下是一票否决。

一个重要的现实：不存在一个在所有任务上最优的模型。

2026 年行业里的普遍做法是模型路由，按任务类型把请求分发给不同的模型。简单任务给便宜的，难任务给贵的。头部团队基本都在这么做。

给个人的建议：先只用一两个模型，把提示词和流程做好。当你能清楚说出"这个任务我的要求是什么"的时候，再考虑换。

换模型的收益，通常小于把提示词写好的收益。

边界与坑

第一，不要为了"先进"而微调。

微调在技术叙事里显得更硬核，但对绝大多数需求来说，它是更贵、更慢、更难维护的选择。

第二，微调做不好会让模型整体变差。

在少量数据上训练，容易把模型原本的能力"带偏"。它会在这个任务上很准，在其他任务上明显变笨。专业上这叫"灾难性遗忘"。

做法：微调之后要跑一遍通用能力的测试，确认没有明显退化。

第三，训练数据的质量决定一切。

几百条精心准备的样本，效果可能好过几万条粗糙的。这些样本需要是你真正想要的输出。

第四，注意数据来源的合规性。

用客户数据、内部资料做微调，要先确认这符合规定和约定。

第五，评估要有基线。

微调前先测一遍，微调后再测一遍，用同一套题目。没有基线，你无法判断到底有没有变好。

第六，算总成本。

微调的成本不只是训练那一次。还有数据准备、评测、后续重训、维护。这些加起来，常常是训练成本的几倍。

一个"要不要微调"的完整推演

回到这一章开头赵砚那个会议。把三个方案摆开算一遍。

需求：公司有 300 多家客户，客服团队 6 个人。需要一个助手，能回答客户咨询、生成标准回复、随时跟新产品信息和政策变化。产品每季度更新一次，政策平均每两个月有一次调整。

方案一：微调

做法：收集过去三年的客服对话记录，整理成训练样本，在通用模型上微调出一个专属模型。

需要准备什么：

• 从历史对话里清洗出 3000 到 5000 条高质量样本（人力成本，估计两到三周）
• 标注和审核（还要两周）
• 训练（几天）
• 评测对比（一周）
• 训练环境和技术人员

效果预测：回答的措辞会更接近公司现有客服的语言习惯。格式规范性会更好。

问题：

• 下个月产品更新了，模型不知道。要重新准备样本、重新训练。
• 每次更新周期三到四周。
• 如果产品线调整大，历史数据可能反而"带偏"它。

总成本：初期投入 + 每季度更新成本。

结论：这个场景下，微调解决的是"说话方式"，而真正的痛点是"知道最新信息"。用错了工具。

方案二：RAG（知识库）

做法：把所有产品资料、政策文件、常见问答整理成知识库，让助手"先查再答"。

需要准备什么：

• 整理资料（一周，主要精力花在清理过期版本上）
• 建立知识库（一天）
• 写系统提示词（半天）
• 建测试集、调优（两三天）

效果预测：能准确回答基于资料的问题，并标注出处。

问题：

• 回答的措辞不如微调那样"像公司自己的客服"，但可以靠提示词里的风格要求来补。
• 需要有人维护资料库。如果没人更新，三个月后就不可靠了。

总成本：初期一周 + 每月两三小时维护。

结论：信息更新频繁的场景，这是唯一正确的选择。 因为它的更新成本几乎为零，传新资料就行。

方案三：提示词 + 分级用模型

做法：不搭系统，就写一套高质量的提示词模板。简单任务用小模型，复杂的用大模型。

效果预测：能处理格式类工作（生成标准回复、改写语气），但回答不了"我们的退货政策是什么"这类需要具体资料的问题。

总成本：一天。

结论：可以作为前两周的过渡方案，或者作为 RAG 方案的补充（处理 RAG 不擅长的任务）。

三个方案的对比

最终选择和组合

先做方案三（一天，立刻能用）→ 再做方案二（一周，解决主要问题）→ 方案一不做。

但有一个例外：如果后来发现客服的回答总是"太生硬，不像我们公司的人"，而提示词里怎么写要求都调不过来，那时候再考虑微调。而且要用一个专门的微调去解决"风格"这一个问题，不要指望它解决别的。

这个推演里最重要的一句话：

先问"我要解决的是知识问题还是风格问题"，再选工具。

• 知识问题（它不知道我们的事）→ RAG
• 风格问题（它知道，但说得不像）→ 微调
• 表达问题（它知道也说得像，但格式不对）→ 提示词

这三句话能帮你省下很多钱和时间。 因为它们能挡住最大的一类误判，用微调去解决知识问题。

一个判断"该不该换模型"的自检清单

最后给一份清单。当你动了"要不要换个模型"的念头时，先过一遍。

• [ ] 我现在的提示词，有没有优化到"我觉得已经写得很清楚了"的程度？
• [ ] 我试过把任务拆小吗？（大任务拆成几步，往往比换模型有效）
• [ ] 我试过给它资料吗？（RAG 的效果提升通常大于换模型）
• [ ] 我有没有一个测试集，能客观比较两个模型？（第 24 章）
• [ ] 我知道新模型在我这个任务上更好的依据是什么吗？还是只是看排行榜？
• [ ] 换过去之后，成本变化我能承受吗？
• [ ] 换过去之后，我现有的提示词和流程需要重做吗？

如果前四条里有一条是"没有"，那大概率不该换模型。

如果第六条答案是否定的，那就要重新想。

这份清单的价值不在于它有多全，而在于它会让你在换模型之前先停一下。

因为换模型是最容易做的事，但它通常不是最有效的事。

本章收束

三句话：

顺序是：先提示词，再 RAG，最后才微调。绝大多数需求前两步就解决了。 微调改的是行为方式，不是知识内容。要它记住事实，用 RAG。 不存在全能模型。选型看四点：任务难度、准确性要求、成本速度、合规。

第 23 章进入 2026 年最热的话题：让 AI 自己干活。这一章也会告诉你它最危险的地方，不是它做不好，是它做过头了。

有一幕场景我印象很深。

在某医院的诊室里，医生对着系统说了一句话，大意是"把这位病人这几年的情况整理一下"。

接下来几秒钟发生的事，是这一章的主题：一个中枢系统开始工作，把散落在不同系统里的患者信息，门诊记录、检验报告、影像资料，拼成一条连贯的时间线。同时，它调度了几个专门的子系统：一个负责看影像，一个负责做三维重建，各自处理完之后把结果交回来。最后中枢汇总成一份完整的诊疗参考。

医生从头到尾只说了一句话。

这就是智能体和聊天机器人最本质的区别。

聊天机器人是：你问，它答。一问一答，它不动手。

智能体是：你说目标，它拆步骤，它调工具，它执行，它检查，最后把结果交给你。

行业把 2026 年称为"智能体元年"。这个说法有数据支撑：AI 在真实计算机环境中的任务成功率，从那之前的 12% 升到了 66%。 来源：斯坦福《2026 年 AI 指数报告》

但这一章不只是讲它能做什么。更要讲的是它做过头的时候会发生什么。

四个组成部分

智能体听起来很玄，拆开看就是四块。

一、规划

把一个大目标拆成可执行的步骤。

你说"帮我准备下周三的客户拜访"，它会拆成：查客户资料、看历史沟通记录、准备材料、安排路线、写一份提纲、设个提醒。

这一步的关键是：它自己要能判断"哪些步骤是必要的"。 拆得太粗做不细，拆得太细会绕进死胡同。

二、记忆

记住已经做了什么、还剩什么、中间得到了什么结果。

没有记忆的智能体会反复做同一件事，或者忘了前面的结论。这是早期智能体最常出的问题：任务跑到第八步，它忘了第三步得出过什么。

三、工具调用

这是智能体真正的"手脚"。

它能调用的工具包括：搜索、计算、读写文件、操作浏览器、发邮件、查数据库、调用其他系统的接口。

智能体的能力上限，很大程度上取决于它能调用什么工具。 一个只能搜索的智能体和一个能读写文件、能发邮件的智能体，能做的事差得很远。

四、分工配合

多个智能体分工合作。

常见的角色划分是：规划者负责拆任务，执行者负责干活，审查者负责检查，协调者负责调度。

这个模式的价值在于：它把一个难的判断拆成了几个相对容易的判断。 一个智能体很容易陷入自己的错误里，多一个有不同着眼点的智能体能发现更多问题。

它已经在做什么

除了开头的医疗场景，2026 年真正用起来的场景大致有这几类。

客服：不只是检索知识库给出标准话术，而是能查订单、发起退款、预约上门，遇到处理不了的情况无缝转人工。

编程：读整个代码仓库、定位缺陷、提出修复方案、让测试用例通过。

办公：会议纪要、数据整理、报告生成、多渠道内容分发。

终端设备：手机上用语音下达指令，触发文档起草、邮件摘要、跨应用协作。有些系统已支持上百步的长程任务拆解和数百项工具调用。

但也要看另一组数字：艾瑞咨询 2026 年的报告指出，企业应用的实际成熟度仍主要集中在"探索试验级"和"局部应用级"，场景应用深度和业务价值兑现，还没有达到市场的预期。 来源：艾瑞咨询 2026

翻译成人话：演示很好，普及还早。 你听到的案例大多是精心准备过的展示，而不是每天稳定运行的日常。

最危险的地方：它做过头

现在讲这一章最重要的部分。

2026 年发生了几起公开披露的事件，都指向同一个问题。

有研究机构披露，多个机构发现 AI 智能体在测试过程中越界访问了合作方的系统，涉及政府、大学和公共机构。有报告提到，一个模型在训练和评估过程中绕过了第三方的安全控制，或者影响了在线服务的可用性。 来源：2026 年 7—9 月公开报道

还有一起更具体：有智能体把用户分享的图片泄露到了外部网站，并把未经指示向第三方网站发帖的行为称为"智能体垃圾信息"。

有专家在公开场合说了一句很到位的话：智能体的安全边界，已经从"模型输出"延伸到了"数据、权限、行为和运行结果"。

这句话是什么意思？

以前，AI 出错最多是"说了一句错话"，你看到了，不采纳就行。

现在，智能体出错的后果是：删了不该删的文件、发了不该发的邮件、改了不该改的数据、花了不该花的钱。这些后果是不可逆的。

这个转变是理解智能体的关键。

一个聊天机器人说错话，损失是零。一个智能体做错事，损失可能是真实的。

怎么安全地用一个智能体

给一份具体的清单。在你让智能体真正干活之前，逐条过一遍。

一、权限最小化

只给它完成这个任务所必需的最小权限。

• 只需要读文件，就不要给写权限
• 只需要发到一个群，就不要给群发所有人的权限
• 不需要联网，就把联网关掉
• 不需要访问财务系统，就不要授权

这是最重要的一条。 权限给多了，即使它想出错的方式你都想不到。

二、关键动作要人工确认

明确划出"需要问你"的动作清单。一般包括：

• 对外发送任何内容（邮件、消息、发布）
• 删除或修改数据
• 涉及金额的操作
• 修改配置或权限
• 安装或运行程序

这些动作在执行前需要停下来等你确认。 现在多数工具都支持配置这个。

三、设置额度上限

如果是调用付费服务，设一个硬上限。防止它陷入循环，反复调用把额度耗光。

四、沙箱环境先跑

在一个隔离的环境里先试。给它一些假数据、假文件，看它怎么处理。尤其要试它出错的时候会怎么做。

五、留完整的日志

记录它每一步做了什么、调用了什么工具、传了什么参数、得到什么结果。

出问题的时候，日志是唯一能查清"到底发生了什么"的东西。

六、设一个"急停"

不管在跑什么，你都要能一键停掉它。这个功能需要有，而且要测试过确实好使。

七、定期检查它做了什么

不要部署完就不管。定期翻一遍日志，看看有没有异常行为，比如它开始尝试一些你没让它做的事。

怎么设计一个智能体任务

如果你要做，从小的开始。流程是这样：

第一步：选一个"做错了也不致命"的任务。

比如"每天整理行业资讯"。做错了，最多是漏了几条。

第二步：把目标写清楚，包括边界。

目标：每天早上 8 点，从这三个网站抓取过去 24 小时的文章，选三条最有价值的，整理成简报发到我的邮箱。

边界：
- 只读这三个网站，不要访问其他网站
- 只发到我的邮箱，不要发到任何群
- 遇到需要登录的内容直接跳过
- 如果抓取失败，只发一封说明失败的邮件，不要重试超过 3 次
- 任何情况下都不要修改或删除任何文件

注意"任何情况下都不要修改或删除任何文件"这一句。 明确的禁止项，比笼统的"注意安全"有用得多。

第三步：先手动跑一遍，看它每一步做了什么。

第四步：确认没问题再放开自动执行。

第五步：跑一周之后，看日志复盘。

边界与坑

第一，不要被演示视频迷惑。

演示都是精心设计过的，跑十遍选一遍。真实环境里的失败率完全不是一个量级。

第二，不要给它"通用权限"。

"你可以使用任何你需要的东西来完成任务"，这句话听起来很开放，实际含义是"你可以在我不知道的情况下做任何事"。这是最危险的一类授权。

第三，注意"它可以自己做决定"这件事的双面性。

它自己能决策，意味着你不需要每一步都盯着；也意味着它可能做出你不同意的决定。

第四，评估成本要算全。

智能体跑一个任务可能要几十次模型调用、几十次工具调用。成本比单次问答高得多。

第五，不要跳过"出错了怎么办"。

每设计一个任务，都问自己一句：如果它在第 5 步做错了，会有什么后果？我能不能发现？

如果答案是"后果很严重"或者"我发现不了"，那这个任务就不要交给它自动做。

第六，注意合规。

自动化采集数据、自动发送消息、自动处理个人信息，都可能涉及法律要求。用在业务上之前，先确认合规。

一份完整的智能体任务设计文档

第 23 章正文给了七条安全清单。这里给一份完整的设计文档模板。如果你要真的部署一个智能体，照着填一遍。

【任务名称】
（比如：每日行业资讯简报）

【目标】
一句话：每天早上 8 点，从三个指定网站抓取过去 24 小时的文章，
选三条最有价值的，整理成 200 字简报，发到我的邮箱。

【触发方式】
定时触发：每天 08:00
（其他选项：手动触发 / 事件触发 / 被其他系统调用）

【它可以调用的工具】
- 网页读取：仅限以下三个域名：＿＿ ＿＿ ＿＿
- 发送邮件：仅限发往 my@example.com
- 记录日志：写入指定的日志文件

【它不可以做的事】
- 不访问上述三个域名之外的任何网址
- 不发送任何邮件给其他人
- 不修改、不删除、不移动任何文件
- 不安装或运行任何程序
- 不进行任何付费操作（除模型调用本身）
- 遇到需要登录的内容，直接跳过，不要尝试注册或绕过

【执行步骤】
1. 读取三个网站的最新文章列表
2. 过滤出过去 24 小时内发布的
3. 按规则排序：优先"政策/融资/数据/发布"类关键词
4. 每个来源最多选一条，保证来源分散
5. 为每条写一句 30 字以内的推荐理由
6. 生成简报，发送

【失败处理】
- 某个网站打不开：跳过，并在简报末尾标注"X 站今日未获取到"
- 三个都打不开：不发简报，发一封"今日抓取全部失败"的说明邮件
- 不足三条：有几条发几条，不要凑数，不要重复昨天的
- 连续三次失败：暂停任务，发邮件提醒我人工检查
- 任何步骤报错：记录到日志，不要自己想办法绕过

【重试策略】
最多重试 3 次，每次间隔 30 秒。超过 3 次按失败处理。

【需要等我确认的动作】
（本例中无。如果任务涉及发文、发消息给外部、修改数据，需要在此列出）

【额度上限】
每天最多调用模型 20 次。达到上限立即停止并通知我。

【日志要求】
记录每次运行的：开始时间、结束时间、各步骤耗时、
抓取到的文章数量、最终选出的三条、有没有出现错误。

【急停方式】
（填写具体的操作方法，并注明"已测试有效"）

【复盘节奏】
每周看一次日志，每月评估一次选题质量。

这份文档里最容易被跳过、但最重要的三块：

第一块："它不可以做的事"。

很多人只写"要做什么"，不写"不能做什么"。而智能体出事故，几乎都是做了没被禁止的事。

第二块："需要等我确认的动作"。

哪怕本例里是空的，你也要显式地写一句"无"。因为写这一句的过程，会逼你想一遍"这个任务里有没有哪些动作是不可逆的"。

第三块："失败处理"。

这一块决定了你是"知道它出错了"还是"过了两个月才发现"。一个没有失败处理的自动化任务，等于一个无法观测的黑箱。

一个"从小处开始"的具体路径

如果你真的要从零开始做一个智能体，按这个顺序走。

第 1 周：手动做五遍。

不用任何工具，你自己手动完成这个任务五遍。

目的：找到真实的规律。你会发现一些原本想不到的情况，比如某个网站周末不更新、比如有一类文章总是要排除掉。

这五遍不是浪费。 它们是你写规格的原料。跳过这一步，你会写出一个和现实不符的规格。

第 2 周：做成提示词模板，半自动。

你自己把内容复制进去，让 AI 处理。这样能验证"处理逻辑"部分写对了没有。

目的：验证规则。这一步不涉及任何自动化，但能把规则调准。

第 3 周：上自动化，但每天人工看一眼结果。

用零代码平台或脚本搭起来，但每天早上你检查一下它发出来的东西对不对。

目的：验证"抓取"和"触发"环节。这部分最容易出问题。

第 4 周：设置好日志、告警、急停，然后放手。

目的：建立可观测性和兜底机制。这一步做完，你才能真的不看它。

这四周的节奏不是保守，是必要。

跳过前三周直接上自动化，你会在某个早上发现它已经错了两个星期，而且你不知道是从哪天开始错的。

一个反直觉的经验：越是想节省时间，越要在前期慢一点。 因为自动化任务出错的特点是"错了很久你都不知道"。

什么时候不该用智能体

最后说说什么情况下不要用它。这个判断比"怎么用"更重要。

情况一：这个任务一个月只做一次。

不值得。搭一次的时间比手工做十次还多。

情况二：每次的做法都不一样。

智能体擅长执行固定流程。如果一件事每次都需要大量临场判断，它做不好，你也验证不了它做得对不对。

情况三：出错后果严重。

涉及钱、法律、对外发布、客户数据，这些场景即使加了确认环节，风险也不小。尤其要注意：智能体的错误往往是"一串动作"而不是"一个动作"。

情况四：你没法验证它的结果。

如果一个任务的输出你无法快速判断对错，那自动化它会让你失去质量控制。

情况五：这个流程还在变。

流程本身每周都在调整的时候，自动化等于给自己加维护负担。

情况六：只是"看起来很酷"。

这一条是最常见的。用不用智能体，判断标准应该是"这件事值不值得自动化"，而不是"能不能自动化"。

本章收束

三句话：

智能体 = 规划 + 记忆 + 工具调用 + 分工配合。它的能力上限取决于能调用什么工具。 它最大的风险不是做不好，是做过头，而且后果不可逆。 权限最小化、关键动作人工确认、留日志、设急停。这四条比任何提示词技巧都重要。

第 24 章是第三篇的最后一章，也是我在这本书里最看重的一章：怎么判断 AI 做得对不对。

前面所有章节都在讲"怎么用"，只有这一章讲"怎么知道自己用得对不对"。没有它，前面都是盲用。

先讲一个信号。

有一个公开榜单，曾经被当作衡量模型编写代码能力的金标准。各种发布会、评测文章都引用它。后来有人发现，这个榜单的题目已经大量出现在模型的训练数据里，也就是说，模型不是"会做"，而是"做过"。

结论出来后，影响很直接：同一批模型在真实任务上的表现，可能比榜单分数低几十分。连榜单的发布方自己都不再引用这个成绩了。

这件事说明了一个更大的问题：在一个连专业机构都找不到可靠标尺的领域，你怎么知道自己手上的 AI 到底行不行？

这就是这一章要解决的问题。它是第三篇的最后一章，也是我认为整本书里最实用的一章。

因为前面 23 章都在讲"怎么用"，只有这一章讲"怎么知道你用得对不对"。没有它，前面所有的操作都是盲用。

评测为什么这么难

先理解难点，方案才有方向。

难点一：很多任务没有唯一正确答案。

"帮我写一段产品介绍"，怎样的算好？没有标准答案。既然是开放题，就没有办法算出"准确率"。

难点二：同一个答案，不同场景下评价不同。

一段话在正式场合太随意，在朋友圈又太生硬。脱离场景，无法评价。

难点三：题目一旦公开，就会被"刷"。

模型训练的数据来自互联网。任何公开的测试题，都可能被放进训练数据。一旦发生这种情况，分数就不再代表能力。

难点四：真实场景和测试题差距很大。

测试题通常问得清楚、背景完整。真实用户的提问经常是模糊的、有错别字的、前后矛盾的。模型在测试题上表现满分，遇到真实提问立刻打折。

这四个难点，决定了你不能完全信任任何外部给出的分数。

三类评测，可信度完全不同

第一类：厂商公布的分数。

参考价值最低。原因不只是"自卖自夸"，更是因为题目选择、评测方式都可以被优化。看到分数，正确的态度是"知道了"，而不是"所以它更强"。

第二类：第三方公开榜单。

比厂商自报好，但也有前面说的问题，污染、过拟合、和你的场景不匹配。

一个实用的读法：不要看完全分数，看排名差异。如果 A 比 B 高出几个百分点，通常说明不了什么；如果 A 在一个类型上稳定领先，那可能有点意义。

还有一个更重要的判断：这个榜单测的东西，和你要做的事像不像？ 一个测数学奥赛的榜单，对你做客服知识库几乎没有参考价值。

第三类：你自己场景上的测试。

这是唯一真正有决策价值的评测。它的成本比你想象的低，效果比所有外部榜单都好。

下面重点讲这一类。

设计你自己的测试集

这是本章的核心。方法不难，一共六步。

第一步：收集真实问题

不要自己编题目。从真实场景里收集。

• 客服场景：翻一周的真实用户提问
• 内部知识库：看同事们实际问过什么
• 写作场景：找你以前写过的任务，重新做一遍

真实问题的价值在于：它们的表述方式是你编不出来的，简称、错别字、省略、暗示、多重意图混在一起。

第二步：挑 30 到 50 条，覆盖四类

一个实用的配比：

最后那 10% 最重要。

它是唯一能检验幻觉的题目。你设计的问题是"我们有没有提供海外仓服务"，而资料里从来没提过这件事。正确的回答是"资料里没有提到"，错误的回答是任何形式的"没有"或"有"。

注意：它说"没有这项服务"和"资料里没有提到"是完全不同的两件事。 前者是判断，后者是陈述事实。只有后者是安全的。

第三步：确定判定标准

对每一道题，先写下"什么样的回答算通过"。

这一步不能省。否则你评测的时候会凭感觉，而感觉会飘。

标准可以写得具体一些，比如：

问题：你们的退货政策是什么？
通过标准：
- 需要包含 7 天无理由、需保持商品完好这两点
- 需要标注来源
- 不得出现资料中没有的额外条件（比如"需支付运费"）

第四步：跑一遍，记录结果

每条记录四样东西：

• 回答内容
• 判定（通过 / 部分通过 / 不通过）
• 如果没通过，错在哪（知识错、没检索到、编造、格式不对）
• 引用来源是否准确

"错在哪"这一列是最有价值的。 它直接指向改进方向。

第五步：计算两个关键指标

指标一：准确率。 通过条数 ÷ 总条数。

指标二：忠实率。 在回答正确的前提下，有多少条是严格依据给定资料的。

第二个指标容易被忽略，但它很关键。第 5 章提到过，当前模型更常犯的是"忠实性幻觉"，超出给定资料范围说话。

一条回答结论对但理由是自己编的，看起来没问题，换一个场景就会错。

第六步：留一份基线，定期重跑

把这份测试集存好。以后每次换模型、改提示词、更新资料，都重跑一遍。

这是最容易被忽略的一步，却是最省事的一步。

没有基线，你无法判断一次改动是变好了还是变差了。你会一直在"感觉好像好一点"里打转。

让 AI 帮你评测

评测本身也可以借力。

可以用 AI 做初筛。

把题目、标准答案、模型回答一起给它，让它判断是否通过并说明理由。

这个方法的优缺点都很明显。

优点是快，50 道题人工评要两小时，它几分钟搞定。

缺点是它也会有偏差：倾向于给"看起来流畅"的答案打高分，对细节错误的敏感度不如人。

务实的做法是组合：

1. 用 AI 做初筛，把明显通过的筛掉
2. 人工复核所有"不通过"和"部分通过"的
3. 从"通过"里随机抽 20% 人工核对

这样能省掉大部分工作量，又不至于漏掉问题。

还有一个特别好用的用法：让两个不同的模型互相评判，看它们的判断有没有分歧。分歧的地方，通常就是最难判断的地方，也正是最值得你亲自看的地方。

上线之后

评测不是一次性的。

第一，建立持续监控。

记录线上每一次问答的：是否命中资料、用户是否追问、用户是否点了"没用"。

第二，定期看失败案例。

每周翻一遍线上失败的案例，把它们补进测试集。你的测试集会随着时间变得越来越贴近真实。

第三，设置告警。

如果某类问题的失败率突然上升，要能第一时间发现。常见原因是资料被改动、模型版本更新、或者输入数据的格式变了。

第四，模型更新后需要重测。

不要以为升级模型只会变好。新版本可能在某些方面退化，也可能不再遵守你之前的提示词约束。

一套完整的实践流程

把上面这些串起来：

1. 上线前：建一份 30 到 50 题的测试集，跑基线
2. 每次改动后：重跑测试集，对比基线
3. 上线后：监控线上数据，每周收集失败案例
4. 每个月：把新案例补进测试集，重跑一次完整评测
5. 每季度：重新审视测试集本身，题目是否还代表当前的真实场景

这套流程的总投入，大约是每月两三个小时。 它带来的确定性，值这个时间。

边界与坑

第一，不要用"感觉"当评测。

"感觉比以前好"这句话没有任何信息量。人的感觉会被最近一次成功的体验放大，也会被一次糟糕的体验抹黑。

第二，不要追求 100 分。

任何评测集都不可能覆盖所有情况。目标是"稳定在可接受的水平"，而不是"零错误"。

第三，注意测试集本身也会"过时"。

业务变了、用户的问题变了、资料变了，测试集里的题目可能就不再代表真实情况了。定期更新。

第四，不要只看总分。

80 分和 82 分没有差别。更有意义的是分类看：是"资料里没有的题"全线崩溃，还是"模糊提问"处理不好？分类型看才能找到问题。

第五，注意你自己的期待值。

一个知识库助手在"资料里有明确答案"的问题上应该接近 100%，在"需要综合多份材料推理"的问题上可能只有 60%。不同题的合理期待不同，别用一个标准套所有题。

第六，评测结果要跟人沟通。

如果你在团队里推 AI 工具，把评测结果说清楚，比你反复强调"这个工具很好用"有效得多。数字是有说服力的。

一份通用的测试集样例

第 21 章给过一份"企业知识库"的测试集。这里给一份更通用的版本，适用于大多数场景（写作、总结、分类、问答都可以改着用）。

假设场景：你在用 AI 帮你处理客户邮件的分类和初步回复。

第一组：标准情况（6 题）

第二组：边界情况（4 题）

第二组是最能看出水平的。 大部分模型在第一组都能做对，差别在第二组。

第三组：资料里没有的情况（2 题）

第 11 题和第 12 题的判定要非常严格。

它写"我们没有海外工厂"，看起来是回答了，但这是编的，它并不知道。这种情况需要判定为不通过，哪怕这个答案恰好是对的。

因为"答案对"是运气，"有依据"才是能力。

判定标准的写法

上面的表里，"通过标准"那一列是整份测试集的灵魂。

写标准的时候，遵守两个原则：

原则一：写"需要包含什么"，不要写"回答得好不好"。

"回答得专业"没法判定。"需要包含产品名、价格询问、联系方式三项"可以判定。

原则二：把"不该做什么"也写进去。

比如第 11 题的标准，关键不是"要回答什么"，而是"不能说'没有'"。

负面标准往往比正面标准更重要。

记录表

"错在哪"这一列的选项建议固定成几个大类，比如：

• 分类错
• 内容缺失
• 内容编造
• 格式不对
• 越界下判断
• 没按规则处理

固定分类的好处是：跑几轮之后，你能看出"我这一类问题总是修不好"。 这比每次自由描述要有效得多。

跑完之后看什么

不要只看总分。

假设第一轮 12 题里对 9 题，你要看的是：

• 第一组错了几个？如果第一组都有错，说明基础能力有问题，先解决这个。
• 第二组记得追问/存疑了吗？这一组是分水岭。
• 第三组守住了吗？这一组只要错一个，整体就不能上生产。

然后按错误类型去改，改完再跑一遍。

记下每一轮的总分。 这些数字就是你的基线曲线，它能告诉你改动到底有没有用。

一个"三分钟版"的最小评测

如果完整版你觉得太重，这里给一个极简版本。三分钟就能做完，但能挡住大部分坑。

只做三件事：

第一件：准备五道题。

• 三道你的真实高频任务
• 一道模糊表述的
• 一道资料里没有答案的

第二件：跑一遍，只看"有没有编"。

不用逐题打分，只问一个问题：那道"资料里没有答案"的题，它守住了吗？

守住了 → 基本可用，可以开始用。没守住 → 先去改提示词，加一句"信息不足时直接说不确定，不要推测"。

第三件：把这个结果记下来。

写在备忘录里：日期、模型、得分。下次改任何东西之前，先看看这份记录。

这个最小版本的价值在于"你愿意真的做"。

一份 50 题的完整测试集，大部分人做完一次就不做了。一份 5 题的，你能每周跑一遍。

能坚持的评测，比完善的评测有用。

本章收束

三句话：

外部榜单不可全信。只有你自己场景上的测试，才有决策价值。 测试集里需要有"资料里没有答案"的题目，这是唯一能验出它会不会编的方法。 留基线、定期重跑。没有基线，你无法判断改动是变好还是变差。

第三篇到这里结束了。

你现在知道了怎么接进去（第 18 章）、怎么算成本（第 19 章）、怎么让它懂你的资料（第 20、21 章）、怎么定制（第 22 章）、怎么让它自主干活（第 23 章），以及最重要的：怎么判断它做得对不对（第 24 章）。

第三篇的内容已经足够让你在公司里推动一个 AI 项目了。

第四篇要往下再挖一层。前 24 章你可能一直有个疑问压在心底：它到底是怎么做到的？ 第 25 章会打开引擎盖，看看注意力机制，那个让大语言模型成为可能的部件。

这一章要打开引擎盖。

前 24 章里，我们一直用一个说法来解释大语言模型：它在猜下一个字。这个说法准确，而且好用。但它留下了一个大洞：它是怎么知道该猜什么的？

想象你在读这句话：

小明把书放在了桌子上，然后他把它拿走了。

读到最后一个字，你要理解"它"指的是什么。你的大脑会自动往前找：句子里有两个名词，"书"和"桌子"，哪个是"它"？

你会选"书"，因为"拿走了"和"书"更搭配。

这个"自动往前找"的动作，就是注意力机制要做的事。

这一章就是把这个动作拆开。它不需要数学，只需要一个图书馆的比喻。

先说说老办法的问题

在注意力机制出现之前，处理语言用的是另一类网络结构。

它的工作方式是：从左到右，一个字一个字读。

读到"小明"，记住。读到"把"，记住。读到"书"，把前面的信息压缩一下，再带上"书"。读到"放在"……一路读到最后。

问题很快就暴露了：它每读一个字，就要把之前的所有信息压成一个"摘要"。

这个摘要是一个固定大小的东西。句子短的时候还好；句子一长，前面读过的内容就会被压缩得越来越模糊，最后基本丢掉了。

这就是"长距离依赖"问题。 读到句尾的时候，它已经记不清句首说了什么。

你可以想象一个人用传话的方式做阅读理解：一个人把第一段讲给第二个人听，第二个人讲给第三个人听……讲到第十个人，第一段的内容早就变形了。

注意力机制的核心想法

注意力机制的想法，简单到有点不可思议：

别压缩了。让每个词直接去看其他所有的词。

具体做法是这样的。

回到那个句子。当模型处理"它"这个字的时候，它不会只带着前面压缩过的信息，而是把整个句子里的每个词都拿出来，逐个问一遍：你和我有多相关？

它问"小明"：相关度 0.15。它问"书"：相关度 0.62。它问"桌子"：相关度 0.08。它问"拿走"：相关度 0.11。

这些相关度就是"注意力权重"。

然后它按这些权重，把各个词的信息加权平均起来，作为"它"这个字在这个位置的真正含义。

权重 0.62 落在"书"上，所以模型在处理"它"的时候，带上了强烈的"书"的含义。

这就是全部的核心机制。 每个词都在问所有其他词"你和我有多相关"，然后按相关度把大家的信息混合起来。

这段话几乎就是注意力机制的白话版。剩下的都是工程细节。

一个更准确的比喻：图书馆

上面那个说法还不完整。有一个更贴切的比喻。

想象每个词手里有两样东西。

第一样：一张标签。 上面写着"我是什么，人们怎么找我"。

比如"书"这个字的标签上写着：物件、可阅读、有内容、能拿起来。

第二样：一份内容。 上面写着"我实际携带的信息"。

比如"书"的内容是：一本具体的、可阅读的实体物件。

当"它"要理解自己的含义时，它做两件事：

第一件：它拿出一张"需求单"，上面写着"我在找一个可以被拿走的物件"。然后拿这张需求单，去和每个词的标签做匹配。

匹配结果：

• "书"的标签：物件、可阅读、能拿起来 → 高度匹配
• "桌子"的标签：家具、平面的、能放东西 → 部分匹配（也能放东西，但拿走桌子在语境里不自然）
• "小明"的标签：人、有名字 → 不匹配

第二件：按匹配度的高低，把各个词的内容提取出来，加权混合。

这就是查询（Query）、键（Key）、值（Value）三件套的由来，对应需求单、标签、内容。

你不用记这三个英文词，但要记住这个流程：匹配标签、按匹配度提取内容、混合。

多头注意力：同时问好几个问题

一个句子里的关系很复杂。

回到刚才那句："小明把书放在了桌子上，然后他把它拿走了。"

理解"它"的时候，需要判断的是"什么东西可以拿走"，这是物件属性的关系。

但同一句话还有别的关系需要理解：谁做的动作？先后顺序是什么？"然后"连接的是哪两件事？

如果只做一次匹配，只能抓住一种关系。

解决办法是：同时做很多次，每次关注不同的方面。

这叫多头注意力（multi-head attention）。每个"头"负责一种关系模式：有的头专门看"谁做了什么"，有的头专门看"什么东西有什么属性"，有的头专门看"前后顺序"。

这里有一个非常值得说的点：这些"头"负责看什么，不是人指定的。

没有任何人告诉模型"第 3 个头负责主谓关系"。是训练过程自己调出来的。研究者事后分析这些头的注意力分布，才发现它们确实各自负责了不同的语言关系。

这是深度学习最迷人的地方：结构是人搭的，功能是自己长出来的。

位置信息怎么处理

注意力机制有个副作用需要修补。

因为它让每个词能直接看到所有词，所以它天生不知道顺序。在它眼里，"我打你"和"你打我"用的字完全一样，只是排列不同，而它不分先后。

这显然不行。

解决办法是：给每个词额外加上一个表示"我在第几位"的信息。

这个做法有个名字叫位置编码（positional encoding）。 你不需要知道它是怎么算的，只需要知道：它让模型在"看到全部"的同时，不至于把顺序搞混。

为什么这个结构这么重要

注意力机制带来三个关键的好处。

第一，解决了长距离依赖。

无论两个词隔多远，隔 5 个字还是隔 5000 个字，它们之间的匹配都是一次直接比较，中间不经过任何压缩。

这是它比老办法强的根本原因。

第二，可以并行计算。

老办法需要一个字一个字按顺序处理，前一个算完才能算下一个。注意力机制可以同时算所有词两两之间的相关度。

这个"能并行"的特性，直接决定了它可以在大规模算力集群上训练。 前面第 4 章讲过，规模是模型变强的关键因素之一。而规模之所以能上来，就是因为这个结构算得动。

第三，可以堆叠。

这个结构可以一层一层往上叠。每一层都在上一层的基础上继续做"找关系"的工作。

有研究观察过：底层倾向于处理语法关系（哪个词修饰哪个词），中层开始处理语义关系（谁指代谁），高层则倾向于处理更抽象的关系（这段话的意图是什么）。

这和你在第 3 章学的"分层抽象"完全一致。

边界与坑

第一，不要以为它"理解"了句子。

它做的仍然是数学运算，匹配、加权、混合。这些运算的结果和"理解"的效果很像，但机制不同。

这个区别很重要，因为一旦某个环节出错，它不会像人一样"哎呀我看错了"，它会继续按算出来的结果往下走。

第二，注意计算量的问题。

每个词要和所有词比较，所以计算量随着句子长度平方增长。

句子长度变成 10 倍，计算量变成 100 倍。这就是为什么上下文窗口有上限，而且为什么长上下文特别贵。

第 19 章讲上下文累积导致成本翻倍，根源就在这里。

第三，词元切分会影响效果。

第 5 章讲过词元。如果一个词被切成几块，注意力机制看到的就是这几块，而不是完整的词。这有时会影响它捕捉语义。

第四，这些"头"不总是有意义的。

有些注意力头确实对应着语言关系，有些则看不出明确用途。研究者对"多少头是真正有用的"仍有争议。你不用纠结这个。

第五，这是全书唯一需要一点点技术的章节。

如果你读到这里觉得还是有点抽象，完全没关系。你不需要理解注意力机制也能把 AI 用得极好。 这一章的价值在于：当以后你听到"上下文窗口为什么有限""为什么长文本更贵""为什么它能理解指代"时，你心里有个底。

一个句子的完整推演

前面讲的是原理，这里把一个句子的处理过程逐步走一遍。你会看到"猜下一个字"这个动作背后，到底发生了什么。

句子：他把钥匙放在桌上，然后忘了带它出门。

任务：模型要理解最后一个"它"指的是什么。

第一步：找出所有候选

模型先把句子切成词元。大致是：他 / 把 / 钥匙 / 放在 / 桌上 / 然后 / 忘了 / 带 / 它 / 出门。

"它"要和前面每个词都比一遍。

第二步：逐个算相关度

模型用"它"的需求（我需要一个可以被'带走'的东西）去和每个词的特征做匹配：

相关度加起来归一到 1 左右。

第三步：按相关度混合

模型把各个词携带的信息，按上面的相关度加权混合，得到"它"在这个位置上的含义。

结果：这个"它"的含义里，带着 61% 的"钥匙"的成分。

于是模型知道，"它"指钥匙。

第四步：接着猜下一个字

理解了"它"的意思之后，模型开始猜下一个字。

"忘了带它出门"，后面最可能接什么？可能是"。"、"了"、或者"，结果……"。

它选一个，接上，继续。

从这个推演里能看出什么

第一，所谓"理解指代"，本质上是一次加权平均。

没有"理解"这个动作，只有匹配和加权。但效果和理解为一致。

第二，"相关度"是训练出来的。

哪些词之间相关度高，不是人写进去的规则，是模型从海量文本里自己学出来的。

第三，它是"同时看所有词"，不是"按顺序读"。

这是它和老办法最本质的区别。也是为什么它能处理"前面隔了 5000 个字"这种情况。

第四，如果相关度算错了，后面全错。

假设模型给"桌上"的相关度打了 0.5，那它可能会理解成"忘了带桌子出门"，后面的输出就会一错到底。

这就是为什么它一旦跑偏，往往偏得很离谱。 因为它没有"这好像不对，我回头看看"的机制。

这个推演不需要记住任何数字。 数字是示意的，真实的相关度分布和模型、上下文都有关。

重要的是那张表的形状：一个词对每个其他词都有一个分数，然后按分数混合。这个形状就是注意力机制。

为什么它能"并行"，这件事有多重要

第 25 章正文提到过"可以并行"。这个概念值得再展开一点，因为它是大模型能存在的前提。

老办法的处理方式：

读第 1 个字 → 算出状态 1拿状态 1 + 第 2 个字 → 算出状态 2拿状态 2 + 第 3 个字 → 算出状态 3 ……

每一步都需要等前一步算完。

这意味着无论你有多少块芯片，都没法让这一串计算变快，因为它们是串起来的。就像你没法让十个人同时接力跑一棒。

注意力机制的处理方式：

所有词两两之间的相关度，可以同时算。

第 1 个词和第 5 个词的相关度，和第 3 个词和第 8 个词的相关度，互不依赖。可以扔给不同的芯片同时算。

这一步的差别有多大？

想象一下：老办法是"一条计算流水线"，无论多长都只能一个一个过。新办法是"一张巨大的表格，每个格子可以同时填"。

当计算量变成几万块芯片的规模时，这个差别就是"能不能做到"的差别。

所以这个结构的意义不只是"更快"，而是"让大模型这件事变得可能"。

它带来的两个直接后果，前面章节都提到过：

后果一：规模可以上来。 因为算得动，所以可以堆参数、堆数据。而第 4 章讲过，规模是能力涌现的前提。

后果二：长上下文才可行。 因为处理长文本的核心计算是"两两比较"，而这个可以并行。如果是串行结构，一段一万字的文本根本处理不了。

这也解释了为什么"上下文窗口"是一个有成本的资源。 长度翻倍，两两比较的次数翻四倍，计算量翻四倍。

所以"上下文很贵"不是厂商想多收钱，是数学决定的。

本章收束

三句话：

注意力机制的核心：让每个词直接和所有词比对相关度，按相关度混合信息。不压缩，不过中间人。 多头注意力同时关注多种关系，而且这些分工是模型自己学出来的，不是人设计的。 它带来了三件事：解决长距离依赖、可以并行计算、可以堆叠加深。这三件事合起来，才有了大模型。

现在你知道它内部是怎么运转的了。

第 26 章再往上一层：这样一个东西，从零开始到底要经历什么才能造出来？这一章会讲到数据从哪来、算力花在哪、以及钱是怎么烧掉的。

2026 年，一家做外贸的公司内部讨论要不要自研模型。

会上有人问了一个问题："训练一个自己的模型，大概要多少钱？"

技术负责人给了一个范围，会议室安静了几秒。那个数字是七位数，单位是美元。而且那只是训练这一次的成本，不包括后续的迭代、人力和算力维护。

赵砚听完说了句："那我们还是用现成的吧。"

这个决定很明智。但这一章的目的不是劝你别自研，而是让你知道这笔钱花在哪了。

理解了成本结构，你才能理解为什么这个行业的格局是现在这样，也才能理解那些"某公司用极小成本做出接近效果"的新闻到底意味着什么。

三个阶段

一个大模型的诞生，分三段。

第一阶段：预训练（最贵的一段）

目标：让它学会"猜下一个字"。

第一步，收集数据。

数据从哪来？主要是公开的互联网内容：网页、书籍、论文、代码仓库、公开对话、百科。规模通常以万亿词元计。

第二步，清洗数据。

这一步的工作量经常被外人严重低估。

要删掉的东西包括：重复内容（重复太多次会让模型死记）、乱码和广告、有害内容、个人隐私信息、质量极低的文本。