1
00:00:00,100 --> 00:00:06,432
本内容改编自小山学堂《学 AI 产品，从入门到精通》，为二次演绎配音版。

2
00:00:06,382 --> 00:00:08,954
这一集是整个系列的开篇。

3
00:00:08,954 --> 00:00:12,187
我们先不聊技术，聊一件更根本的事。

4
00:00:12,187 --> 00:00:21,550
为什么同样一句「技术上做不了」，有的人听完就点头回去改需求，有的人能当场拆开问三个问题，把对方问到改方案。

5
00:00:21,550 --> 00:00:25,540
差别不在会不会写代码，在有没有判断力。

6
00:00:25,540 --> 00:00:29,555
而判断力，正是这门课真正想给你的东西。

7
00:00:29,555 --> 00:00:36,286
你是产品经理、设计师或者运营，接下来的工作里会反复撞上这几个场景。

8
00:00:36,286 --> 00:00:40,829
评审会上工程师说这个需求做不了，你要不要接受。

9
00:00:40,829 --> 00:00:45,552
老板问这个智能功能上线要花多少钱，你怎么估。

10
00:00:45,552 --> 00:00:50,360
用户投诉模型乱答，你该改提示词还是该改流程。

11
00:00:50,360 --> 00:00:55,216
这些问题的共同点是，答案不在代码里，在判断里。

12
00:00:55,216 --> 00:00:57,211
而判断需要地基。

13
00:00:57,211 --> 00:01:01,334
这里有个很现实的分工背景值得先讲清楚。

14
00:01:01,334 --> 00:01:09,074
工程师负责把东西做出来，产品经理负责决定做哪个、值不值、以及做不出来的时候往哪退。

15
00:01:09,074 --> 00:01:15,264
这三件事都不需要你会写代码，但都需要你听得懂技术语言背后的边界。

16
00:01:15,264 --> 00:01:19,447
听不懂，你就只能接受或者拒绝这两种选择。

17
00:01:19,447 --> 00:01:23,413
听得懂，你才拥有第三种选择，改方案。

18
00:01:23,413 --> 00:01:27,512
所以这一集我们把地基铺开讲清楚四件事。

19
00:01:27,512 --> 00:01:35,552
这门课怎么分路，你现在站在哪个位置，怎么学才真的过脑子，以及为什么非得花时间讲原理。

20
00:01:35,692 --> 00:01:37,937
第一件事，先选路。

21
00:01:37,887 --> 00:01:44,029
这门课一共四百六十六节，标注时长七十八小时，你不必都学。

22
00:01:44,029 --> 00:01:46,709
课程按目标划了五档路线。

23
00:01:46,709 --> 00:01:59,882
只想会用人工智能的一百一十三节，想把它用成专业生产力的一百四十五节，做人工智能产品的三百一十三节，自己动手搭的三百七十一节，全都要的四百六十六节。

24
00:01:59,882 --> 00:02:03,476
这个划分里藏着一个容易被忽略的信息。

25
00:02:03,476 --> 00:02:08,368
每一档都不是简单地从上一档往上加课，而是在做取舍。

26
00:02:08,368 --> 00:02:17,286
比如「只想会用」这一档，会跳过全部原理和工程内容，只学它什么时候靠谱、什么时候在编、怎么问才问得出东西。

27
00:02:17,286 --> 00:02:26,132
而「把人工智能用到专业」这一档，是在会用的基础上补两块，大模型原理整篇，以及协作方法论整篇。

28
00:02:26,132 --> 00:02:30,315
它仍然跳过全部工程实现和产品设计的内容。

29
00:02:30,315 --> 00:02:45,099
再看「做人工智能产品」这一档，它在前面两档的基础上补齐上下文工程、设计模式、评测和成本工程，同时跳过代码走查、长运行智能体、安全容器化，以及三个硬核源码专题。

30
00:02:45,099 --> 00:02:58,704
动手实战那一篇里，它只保留产品视角的部分，比如生图的产品化清单、角色一致性、模型挂了怎么办，而把智能体循环和工具协议的实现留给动手路线。

31
00:02:58,704 --> 00:03:01,397
有一个细节值得单独拎出来。

32
00:03:01,397 --> 00:03:10,219
换道是零成本的，五档都从同一节起步，往下学两节自然就知道自己想走多深，进度也不会丢。

33
00:03:10,219 --> 00:03:15,243
这件事的意义在于，你不需要在做决定之前就把决定做对。

34
00:03:15,243 --> 00:03:18,897
很多人卡在门口，是因为害怕选错路。

35
00:03:18,897 --> 00:03:23,945
而选错的代价几乎为零，卡住不动的代价才是全部。

36
00:03:23,945 --> 00:03:25,676
为什么这么划？

37
00:03:25,676 --> 00:03:29,137
因为目标不同，需要的知识结构就不同。

38
00:03:29,137 --> 00:03:37,611
动手搭的人需要知道循环怎么写，做产品的人需要知道这个循环会在第几轮崩、崩了用户看到什么。

39
00:03:37,611 --> 00:03:41,192
同一个技术方案，问的问题根本不一样。

40
00:03:41,192 --> 00:03:45,411
选路这件事对产品经理还有一个额外价值。

41
00:03:45,411 --> 00:03:50,291
你一旦看清五档之间的边界，就天然获得了一张能力对照表。

42
00:03:50,291 --> 00:03:58,801
跟工程师对齐方案的时候，你能听出来他说的是「实现细节」还是「方案边界」，这两件事该用不同的方式回应。

43
00:03:58,801 --> 00:04:03,224
前者可以交给工程师自己定，后者必须你来拍。

44
00:04:03,364 --> 00:04:05,777
第二件事，定位自己。

45
00:04:05,727 --> 00:04:11,533
课程开篇就搬出了达克效应曲线，把学习过程分成三个阶段。

46
00:04:11,533 --> 00:04:13,973
第一个阶段叫愚昧之巅。

47
00:04:13,973 --> 00:04:18,540
刚接触人工智能的人最容易待在这里，觉得我懂了。

48
00:04:18,540 --> 00:04:23,396
对话就是聊天，检索增强就是搜索，提示词就是说话。

49
00:04:23,396 --> 00:04:28,708
这个阶段的人提需求最快，也最容易被工程师一句话打发。

50
00:04:28,708 --> 00:04:33,456
因为他们判断不出那句话是事实还是保守估计。

51
00:04:33,456 --> 00:04:36,052
第二个阶段叫绝望之谷。

52
00:04:36,052 --> 00:04:44,297
开始动手之后，发现模型乱答、提示词无效、检索效果差，忍不住感叹这东西怎么这么难用。

53
00:04:44,297 --> 00:04:50,126
几乎所有认真做过项目的人都会经过这里，它不是失败，是必经。

54
00:04:50,126 --> 00:04:57,266
很多团队在这个阶段放弃，把原因归结为模型不行，其实是自己还缺一套排查框架。

55
00:04:57,266 --> 00:05:03,624
这条曲线还有一个用法，多数人只拿它看自己，其实它更适合拿来看团队。

56
00:05:03,624 --> 00:05:09,670
一个项目组里，通常有人还在愚昧之巅，有人已经掉进绝望之谷。

57
00:05:09,670 --> 00:05:15,451
前者的乐观会拉高排期预期，后者的悲观会让方案反复回退。

58
00:05:15,451 --> 00:05:22,182
识别出来之后，你要做的不是说服谁，是把两类人的判断分别放到合适的位置上。

59
00:05:22,182 --> 00:05:29,249
让乐观的人做探索性方案，让悲观的人做风险评估，而不是让他们互相否定。

60
00:05:29,249 --> 00:05:33,131
第三个阶段叫平稳高原，也是课程目标。

61
00:05:33,131 --> 00:05:39,862
到了这里，你真正理解模型在做什么，能判断问题出在哪、该用什么方案解决。

62
00:05:39,862 --> 00:05:48,744
这个阶段的人开会时的表现是，他不会问能不能做，他会问做到什么程度、代价是什么、什么时候不该这么做。

63
00:05:48,744 --> 00:05:51,160
这里有一句值得记住的话。

64
00:05:51,160 --> 00:05:55,415
弱小和无知从来不是生存的障碍，傲慢才是。

65
00:05:55,415 --> 00:06:02,602
到达平稳高原不需要会写代码，但需要放下「我已经懂了」这个念头，认真理解底层逻辑。

66
00:06:02,602 --> 00:06:09,694
对产品经理来说，傲慢最常见的表现形式是，用一个名词去掩盖一个没搞懂的机制。

67
00:06:09,694 --> 00:06:21,208
评审会上说「我们加个检索增强就好了」，其实并不清楚召回率会在自己的文档形态下掉到多少，也不清楚切片粒度会怎么影响答案的完整度。

68
00:06:21,340 --> 00:06:23,477
第三件事，怎么学。

69
00:06:23,427 --> 00:06:27,850
这门课不缺内容，缺的是你停下来想一想的三十秒。

70
00:06:27,850 --> 00:06:29,953
有一个残酷的事实。

71
00:06:29,953 --> 00:06:36,540
如果你只是从头刷到尾，看完觉得嗯都懂了，那大概率三天后什么都不记得。

72
00:06:36,540 --> 00:06:40,098
这不是你的问题，是人脑的默认模式。

73
00:06:40,098 --> 00:06:44,701
输入不等于理解，理解不等于记住，记住不等于会用。

74
00:06:44,701 --> 00:06:51,492
这四件事之间每一道都是一道坎，而绝大多数学习方法只在第一道坎上用力。

75
00:06:51,492 --> 00:06:55,590
课程给了一个三步循环，外加一个输出动作。

76
00:06:55,590 --> 00:06:59,665
第一步是看到，带着问题看，不要无脑刷。

77
00:06:59,665 --> 00:07:05,542
每打开一个主题之前先问自己，这个主题跟我现在做的事有什么关系。

78
00:07:05,542 --> 00:07:10,182
哪怕暂时想不出来，这个问题本身就会让你的注意力聚焦。

79
00:07:10,182 --> 00:07:22,297
举个例子，打开「上下文窗口」这一页之前先想，我们产品的对话经常超长，是不是跟上下文窗口有关，用户说你忘了我刚才说的，是不是上下文被截断了。

80
00:07:22,297 --> 00:07:27,574
第二步是反思，每看完一个知识点停三十秒，问自己三个问题。

81
00:07:27,574 --> 00:07:30,470
这个概念解决的根本问题是什么。

82
00:07:30,470 --> 00:07:33,727
如果不知道这个，我之前会怎么做。

83
00:07:33,727 --> 00:07:37,045
知道了之后，我的做法会有什么不同。

84
00:07:37,045 --> 00:07:44,389
举个例子，看完「幻觉」这一节之后反思，原来幻觉不是程序错误，是概率采样的必然结果。

85
00:07:44,389 --> 00:07:53,223
那我之前让模型直接输出准确答案的做法就有问题，我应该设计验证环节，指望模型不出错本身就不现实。

86
00:07:53,223 --> 00:07:56,852
第三步是迁移，代入自己的业务场景。

87
00:07:56,852 --> 00:07:58,980
这是最关键的一步。

88
00:07:58,980 --> 00:08:04,449
课程里的每个案例、每个设计决策，都要翻译成你的业务语言。

89
00:08:04,449 --> 00:08:11,468
不同行业、不同产品形态、不同用户群体，同一个技术方案的适用性完全不同。

90
00:08:11,468 --> 00:08:15,434
课程教的是思考框架，不是可以照搬的答案。

91
00:08:15,434 --> 00:08:16,997
最后是输出。

92
00:08:16,997 --> 00:08:24,028
费曼学习法的核心就一句话，如果你不能用简单的话讲给外行听，说明你自己也没真懂。

93
00:08:24,028 --> 00:08:34,689
不需要写长文，哪怕在群里说一句今天学到什么、以前以为是什么、其实是什么，这个动作就能把知识从短期记忆推入长期记忆。

94
00:08:34,828 --> 00:08:37,866
第四件事，为什么非得讲原理。

95
00:08:37,816 --> 00:08:43,598
这是很多产品经理最容易想跳过的一块，也是回报最高的一块。

96
00:08:43,598 --> 00:08:46,026
课程给了一个核心论断。

97
00:08:46,026 --> 00:08:50,389
所有工程化操作，本质上都是对消息列表的处理。

98
00:08:50,389 --> 00:08:53,177
听起来抽象，我们把它摊开看。

99
00:08:53,177 --> 00:08:59,295
提示词工程，是精心构造消息列表，让模型看到正确的上下文。

100
00:08:59,295 --> 00:09:05,088
系统指令、角色定义、少样本示例，全部是往这个列表里塞内容。

101
00:09:05,088 --> 00:09:15,437
检索增强生成，是从外部知识库取回相关文档片段，拼进消息列表再发给模型，本质是在运行时扩充上下文。

102
00:09:15,437 --> 00:09:23,237
智能体工具调用，是模型输出调用请求，执行工具，把结果追加回消息列表，再次推理。

103
00:09:23,237 --> 00:09:25,821
每一轮都是在积累上下文。

104
00:09:25,821 --> 00:09:37,131
微调，是把大量理想的消息列表烧进模型权重，让模型默认就能按期望方式处理上下文，省去每次都要在提示词里说明的成本。

105
00:09:37,131 --> 00:09:43,610
把这个论断再往前推一步，你会发现它还能解释一个产品经理天天遇到的问题。

106
00:09:43,610 --> 00:09:48,321
为什么模型聊到后面就开始忘事、开始自相矛盾。

107
00:09:48,321 --> 00:09:53,910
因为消息列表变长了，而模型能同时看到的长度是有限的。

108
00:09:53,910 --> 00:09:56,795
不是它变笨了，是它看不全了。

109
00:09:56,795 --> 00:10:04,956
想解决它，你要动的不是提示词的语气，而是这段列表怎么组织、哪些内容该留、哪些该压缩。

110
00:10:04,956 --> 00:10:08,465
这两个方向的成本和效果差得很远。

111
00:10:08,465 --> 00:10:13,970
这四件事看起来是四种技术，其实是同一个动作的四种形态。

112
00:10:13,970 --> 00:10:17,372
这就是为什么理解它能省下大量时间。

113
00:10:17,372 --> 00:10:24,271
你以后看到任何一个新方案，先问一句它动的是消息列表的哪一段，答案就清楚了。

114
00:10:24,271 --> 00:10:28,273
而不理解底层，你会反复卡在三类问题上。

115
00:10:28,273 --> 00:10:35,437
提示词改了没用，因为系统提示词被截断、历史对话占满窗口，问题根本不在措辞。

116
00:10:35,437 --> 00:10:45,052
检索效果差不知道哪坏了，因为切片粒度、向量模型、相似度阈值，不了解原理就不知道该查哪里，只能瞎试。

117
00:10:45,052 --> 00:10:57,095
模型答错了该改提示词还是该做微调，因为上下文没给对和参数里压根没这个知识，是两件修复方式完全不同的事，搞错方向会浪费大量时间。

118
00:10:57,244 --> 00:11:00,655
我们用一个具体案例把这几件事串起来。

119
00:11:00,605 --> 00:11:03,970
健身房前台把计算器推到面前。

120
00:11:03,970 --> 00:11:10,521
年卡两千六百八十八元，折合每月才二百二十四元，今晚交钱再送两个月。

121
00:11:10,521 --> 00:11:12,708
月卡三百九十九元。

122
00:11:12,708 --> 00:11:16,627
销售反复提醒优惠只截止到今晚十点。

123
00:11:16,627 --> 00:11:21,278
你拿不定主意，发消息问模型，这张年卡值得办吗。

124
00:11:21,278 --> 00:11:23,490
模型秒回三条理由。

125
00:11:23,490 --> 00:11:30,389
折合每月更便宜，全场器械和团课随意使用，花钱办卡更能督促自己坚持。

126
00:11:30,389 --> 00:11:32,372
每句都挑不出毛病。

127
00:11:32,372 --> 00:11:36,579
三个月过去，门禁记录显示总共只去了四次。

128
00:11:36,579 --> 00:11:40,509
算下来，去一次的实际成本超过六百元。

129
00:11:40,509 --> 00:11:43,850
模型句句在理，为什么结果坑了你。

130
00:11:43,850 --> 00:11:46,446
因为它默认了一个理想的人。

131
00:11:46,446 --> 00:11:51,242
每周稳定去三次，器械团课随意用，办卡督促自律。

132
00:11:51,242 --> 00:11:58,369
而你真实的日常是常在八点半后下班，单程耗时三十五分钟，周末需要陪家人。

133
00:11:58,369 --> 00:12:01,903
这个案例把本集所有内容串在了一起。

134
00:12:01,903 --> 00:12:07,011
模型不会主动追问你的现实约束，这是它的工作原理决定的。

135
00:12:07,011 --> 00:12:11,903
它的回答质量上限，取决于你给进去的那段消息列表。

136
00:12:11,903 --> 00:12:15,533
你如果不理解这一点，就会以为它算错了。

137
00:12:15,533 --> 00:12:20,954
而它的算法一点没错，错的是输入里缺了最关键的三类信息。

138
00:12:20,954 --> 00:12:24,439
真实惯性、履约摩擦、止损底线。

139
00:12:24,439 --> 00:12:26,555
还有一个更隐蔽的坑。

140
00:12:26,555 --> 00:12:31,855
那三条理由里，有一条是花钱办卡更能督促自己坚持。

141
00:12:31,855 --> 00:12:36,362
这一条不是算出来的，是猜的，而且猜的是你的心理。

142
00:12:36,362 --> 00:12:41,963
模型很擅长生成这类听起来合理、实际上无法验证的说法。

143
00:12:41,963 --> 00:12:47,576
如果你不区分哪些是算术、哪些是推测，你就会把推测当成依据。

144
00:12:47,576 --> 00:12:54,403
产品上同理，模型给你的方案里常常混着事实、推测和套话，你得能分开。

145
00:12:54,403 --> 00:12:57,420
这正好解释了为什么要讲原理。

146
00:12:57,420 --> 00:13:04,776
知道了模型的回答依赖于你给的消息列表，你才会本能地去补约束，而不是怪它不准。

147
00:13:04,776 --> 00:13:08,057
同样一个道理，放到产品上也成立。

148
00:13:08,057 --> 00:13:16,206
用户说你的智能助手不好用，很多时候不是模型不行，是你没把用户的真实处境设计进输入里。

149
00:13:16,348 --> 00:13:20,636
最后，把这一集压成五条可以带走的判断依据。

150
00:13:20,586 --> 00:13:22,822
第一，先选路再学。

151
00:13:22,822 --> 00:13:27,954
四百六十六节不是让你全刷的，按目标挑出自己的那一档。

152
00:13:27,954 --> 00:13:38,952
做人工智能产品这一档是三百一十三节，它补齐的是上下文、设计模式、评测、成本工程，跳过的是代码走查和三个硬核源码专题。

153
00:13:38,952 --> 00:13:41,716
第二，警惕名词掩盖机制。

154
00:13:41,716 --> 00:13:49,216
当你在评审会上说出一个方案名词的时候，先检查一下自己能不能说清它在第几步会失效。

155
00:13:49,216 --> 00:13:52,377
说不清，就说明你还在愚昧之巅。

156
00:13:52,377 --> 00:13:57,293
补的办法不是多记名词，是去问它解决的根本问题是什么。

157
00:13:57,293 --> 00:14:00,586
第三，用三十秒换长期记忆。

158
00:14:00,586 --> 00:14:07,257
每看完一个知识点停三十秒，问根本问题是什么、之前会怎么做、之后会怎么改。

159
00:14:07,257 --> 00:14:11,428
再把它翻译成自己的业务场景，讲给一个人听。

160
00:14:11,428 --> 00:14:16,127
输出是这四步里最容易被跳过、也最有效的一步。

161
00:14:16,127 --> 00:14:20,875
第四，把一切工程化方案翻译成对消息列表的操作。

162
00:14:20,875 --> 00:14:28,014
提示词是塞内容，检索是扩充内容，工具调用是追加结果，微调是烧进权重。

163
00:14:28,014 --> 00:14:32,089
能用这句话解释的方案，你才真的看懂了。

164
00:14:32,089 --> 00:14:35,418
看不懂的方案，不要写进需求文档。

165
00:14:35,418 --> 00:14:39,072
第五，问模型之前先补三类约束。

166
00:14:39,072 --> 00:14:42,558
真实惯性、履约摩擦、止损底线。

167
00:14:42,558 --> 00:14:46,800
模型说的划算，通常是对最理想的那类人划算。

168
00:14:46,800 --> 00:14:51,248
把作息、距离和底线交代清楚，它才开始为你算账。

169
00:14:51,248 --> 00:14:53,760
最后补一句关于节奏的话。

170
00:14:53,760 --> 00:14:57,762
认真学十页，比划水刷完一百页有用十倍。

171
00:14:57,762 --> 00:15:03,171
这门课的价值不在信息量，在于它逼你停下来想的那些三十秒。

172
00:15:03,171 --> 00:15:10,034
你可以一天只推进一节，但那一节要走完看到、反思、迁移、输出这四步。

173
00:15:10,034 --> 00:15:18,820
慢就是快，这句话在人工智能这个领域尤其成立，因为工具每几个月就换一轮，能留下来的只有判断力。

174
00:15:18,820 --> 00:15:23,904
这五条里，第四条是地基，其余四条都是从它长出来的。

175
00:15:23,904 --> 00:15:28,639
下一集我们继续往前走，进入认知地基的下一层。