1
00:00:00,100 --> 00:00:04,160
本内容改编自开源项目 Easy-Vibe，为二次演绎配音版。

2
00:00:04,110 --> 00:00:06,081
你好，欢迎回来。

3
00:00:06,081 --> 00:00:11,286
这一集，我们聊一个很多人心里痒痒但从不敢碰的话题。

4
00:00:11,286 --> 00:00:15,036
不写一行代码，到底能不能做出一个东西。

5
00:00:15,036 --> 00:00:16,838
先讲一个场景。

6
00:00:16,838 --> 00:00:19,591
你脑子里可能堆着一堆点子。

7
00:00:19,591 --> 00:00:25,685
一个帮自己记账的小工具，一个记录孩子成长的网页，甚至一款小游戏。

8
00:00:25,685 --> 00:00:32,415
这些东西都不大，但每一个都曾在某个瞬间让你想过，要是有人帮我做出来就好了。

9
00:00:32,415 --> 00:00:35,552
然后下一秒钟，另一个声音响起。

10
00:00:35,552 --> 00:00:40,336
你不会写代码，你不认识程序员，你也不知道从哪儿开始。

11
00:00:40,336 --> 00:00:42,728
念头到这里，就断了。

12
00:00:42,728 --> 00:00:45,865
这一集，就是来把这个断点接上的。

13
00:00:45,865 --> 00:00:51,237
我们会给你看一组真实的数据，看看专业程序员正在怎么工作。

14
00:00:51,237 --> 00:00:54,867
我们会给你看一个六十秒就能做完的贪吃蛇。

15
00:00:54,867 --> 00:01:01,622
我们还会把一条界线画清楚，A I 能帮你走到哪一步，哪一步之外它暂时还不行。

16
00:01:01,622 --> 00:01:07,043
最后，我们陪着你，用对话的方式，做一个会写诗的贪吃蛇。

17
00:01:07,043 --> 00:01:09,026
你不需要任何基础。

18
00:01:09,026 --> 00:01:12,475
你需要的，只是把话说清楚的能力。

19
00:01:12,475 --> 00:01:14,675
这一集的路线是这样的。

20
00:01:14,675 --> 00:01:22,343
先看数据，再看边界，然后看一个六十秒的演示，最后动手，做一个会写诗的贪吃蛇。

21
00:01:22,343 --> 00:01:25,829
四段路，一段比一段更接近你的手。

22
00:01:25,972 --> 00:01:29,095
讲怎么做之前，先看几个数字。

23
00:01:29,045 --> 00:01:32,915
因为这些数字会改变你对这件事的判断。

24
00:01:32,915 --> 00:01:39,189
GitHub Copilot 的数据显示，超过一千五百万开发者正在用 A I 辅助编程。

25
00:01:39,189 --> 00:01:43,504
平均下来，百分之四十六的代码是 A I 生成的。

26
00:01:43,504 --> 00:01:47,398
在 Java 项目里，这个比例能达到百分之六十一。

27
00:01:47,398 --> 00:01:48,792
一半以上。

28
00:01:48,792 --> 00:01:50,475
更狠的是效率。

29
00:01:50,475 --> 00:01:54,441
开发者完成任务的速度提升了百分之五十五。

30
00:01:54,441 --> 00:01:59,682
原本需要九点六天才能提交的代码，现在二点四天就能搞定。

31
00:01:59,682 --> 00:02:01,653
采用率也很夸张。

32
00:02:01,653 --> 00:02:08,191
在获得访问权限的当天，就有百分之八十一的开发者第一时间完成安装并开始使用。

33
00:02:08,191 --> 00:02:13,564
其中百分之九十六的人，当天就开始采纳 A I 提供的代码建议。

34
00:02:13,564 --> 00:02:18,768
换句话说，开发者几乎是立刻把 A I 融入了日常编码工作。

35
00:02:18,768 --> 00:02:22,674
把这几个数字放在一起看，结论有点刺激。

36
00:02:22,674 --> 00:02:27,386
专业程序员正在大规模地把写代码这件事交给 A I。

37
00:02:27,386 --> 00:02:28,864
那问题来了。

38
00:02:28,864 --> 00:02:37,939
如果写代码的人都在靠 A I 写代码，我们这些不会编程的人，为什么不能直接跟 A I 对话，把自己的想法变成真的东西？

39
00:02:37,939 --> 00:02:41,761
这门课想帮你练成的，就是这项新技能。

40
00:02:41,761 --> 00:02:44,393
通过自然语言对话做应用。

41
00:02:44,393 --> 00:02:51,953
学会跟 A I 用计算机能懂的语言沟通，让 A I 帮你把脑子里的想法，变成真实可用的产品。

42
00:02:51,953 --> 00:02:54,850
这不是让你去应聘程序员。

43
00:02:54,850 --> 00:03:01,965
这是让你在想做一个东西的时候，第一反应不再是算了，而是打开网页，说一句话。

44
00:03:02,116 --> 00:03:04,926
当然，兴奋之前先看边界。

45
00:03:04,876 --> 00:03:07,220
这一节只讨论一个问题。

46
00:03:07,220 --> 00:03:12,064
完全不会写代码的你，现在的 A I 能帮你做到什么程度。

47
00:03:12,064 --> 00:03:16,715
大致来说，当前大模型的能力，可以胜任三类东西。

48
00:03:16,715 --> 00:03:22,244
简单的内部小工具，数据可视化看板，以及一些轻量级小游戏。

49
00:03:22,244 --> 00:03:28,662
这些能力用来做自用工具，从产品经理的视角验证需求，基本已经足够。

50
00:03:28,662 --> 00:03:37,641
但如果你想一键生成一个可以直接商用的成熟产品，通常还需要人工在流程设计、细节打磨上持续优化。

51
00:03:37,641 --> 00:03:39,431
翻译成大白话。

52
00:03:39,431 --> 00:03:46,475
让 A I 帮你把脑子里的想法，变成一个能打开、能点击、能玩的东西，现在是做得到的。

53
00:03:46,475 --> 00:03:54,359
让 A I 帮你把一个想法，变成一个能收钱、能扛住真实用户的产品，现在还不行，至少不能全自动。

54
00:03:54,359 --> 00:03:56,030
记住这个划分。

55
00:03:56,030 --> 00:03:58,818
它决定了你应该把 A I 当成什么。

56
00:03:58,818 --> 00:04:03,266
当成一个执行力不错的原型搭档，而不是一个许愿机。

57
00:04:03,266 --> 00:04:09,996
接下来，我们就以贪吃蛇为例，具体看看 A I 编程目前到底能做到什么程度。

58
00:04:10,156 --> 00:04:12,413
接下来是见证环节。

59
00:04:12,363 --> 00:04:16,041
我们用课程里的实验网页，做一个贪吃蛇。

60
00:04:16,041 --> 00:04:22,135
这个网页名字叫 Z 点 A I，由智谱开发，背后是智谱自研的大模型系列。

61
00:04:22,135 --> 00:04:26,810
这门教程里，我们重点用的是它的全栈开发模块。

62
00:04:26,810 --> 00:04:28,229
先说过去。

63
00:04:28,229 --> 00:04:34,094
开发一个网页应用，你得先安装编程环境，比如 Python、Node.js。

64
00:04:34,094 --> 00:04:36,402
然后配置代码编辑器。

65
00:04:36,402 --> 00:04:40,488
然后学标记语言、样式语言和脚本语言。

66
00:04:40,488 --> 00:04:43,493
最后在各种依赖和报错里挣扎。

67
00:04:43,493 --> 00:04:46,618
这套流程走完，几个月过去了。

68
00:04:46,618 --> 00:04:47,904
现在呢。

69
00:04:47,904 --> 00:04:50,284
打开浏览器，访问网页。

70
00:04:50,284 --> 00:04:53,361
用自然语言描述你想要的功能。

71
00:04:53,361 --> 00:04:57,159
A I 自动生成代码，并且实时预览效果。

72
00:04:57,159 --> 00:04:58,373
就三步。

73
00:04:58,373 --> 00:05:06,029
在输入框里打下你的需求，点击全栈开发按钮，你能实时看到网页一点点被创建出来。

74
00:05:06,029 --> 00:05:09,839
通常泡一杯咖啡的时间，网页就生成完了。

75
00:05:09,839 --> 00:05:17,099
右侧会出现一个可以浏览的界面，上下滚动看内容，点顶部的指南针按钮切全屏。

76
00:05:17,099 --> 00:05:27,712
顶部那一排按钮，从左到右依次是，展开对话历史，新建对话，刷新页面，切换全屏，下载项目，查看代码，发布项目。

77
00:05:27,712 --> 00:05:30,813
你刚上手只需要认得最后两个。

78
00:05:30,813 --> 00:05:34,382
一个把成果拿回家，一个把成果给世界看。

79
00:05:34,382 --> 00:05:39,995
这种对话即编程的模式，让编程从写代码变成了描述需求。

80
00:05:39,995 --> 00:05:44,719
你不需要关心底层技术细节，只需要讲清楚你想要什么。

81
00:05:44,719 --> 00:05:50,104
这就是 A I 时代编程的新范式，氛围式编码，英文叫 Vibe Coding。

82
00:05:50,104 --> 00:05:53,421
除了这个平台，同类工具还有很多。

83
00:05:53,421 --> 00:06:11,958
月之暗面的 Kimi Code，谷歌的 A I Studio，设计师熟悉的 Figma Make，字节跳动的 Coze，还有一批海外工具，比如 Vercel 出品的界面生成工具，StackBlitz 推出的全栈开发平台，专注界面应用的 Lovable，以及集成 A I 的在线编程环境 Replit。

84
00:06:11,958 --> 00:06:14,939
名单很长，但思路都是一个。

85
00:06:14,939 --> 00:06:17,980
输入描述，生成能跑的网页。

86
00:06:17,980 --> 00:06:22,824
入门阶段，挑一个顺手的用下去，比反复比较重要。

87
00:06:22,948 --> 00:06:25,974
贪吃蛇做完，热闹也看完了。

88
00:06:25,924 --> 00:06:29,218
现在泼点冷水，把界线画清楚。

89
00:06:29,218 --> 00:06:34,218
只靠对话，不写任何代码，A I 究竟能把事情推到哪一步。

90
00:06:34,218 --> 00:06:36,573
一个比较稳定的经验是。

91
00:06:36,573 --> 00:06:39,915
它可以帮你完成一个小而完整的东西。

92
00:06:39,915 --> 00:06:45,432
但做到什么程度就算够，每一步该怎么走，仍然需要你亲自决策。

93
00:06:45,432 --> 00:06:48,232
A I 更擅长小而清晰的应用。

94
00:06:48,232 --> 00:06:50,143
什么叫小而清晰。

95
00:06:50,143 --> 00:06:51,513
三个特征。

96
00:06:51,513 --> 00:06:56,766
范围清晰，一页网页，一个简单内部工具，一个小玩法。

97
00:06:56,766 --> 00:07:01,646
结果可见，你能立刻在浏览器里验证它是不是按预期工作。

98
00:07:01,646 --> 00:07:07,559
纠错直接，发现问题后，在下一轮对话里点明具体现象，让它改。

99
00:07:07,559 --> 00:07:12,379
在这个边界里，A I 就是一位执行力不错的辅助开发者。

100
00:07:12,379 --> 00:07:17,799
你每一轮用自然语言细化和修正需求，它快速给你可用的原型。

101
00:07:17,799 --> 00:07:25,780
但一旦超出这个范围，只指望几轮对话让 A I 端到端完成一个复杂系统，很快就会遇到上限。

102
00:07:25,780 --> 00:07:33,833
大型项目要接后端，连数据库，整合第三方服务，还牵扯权限、安全、并发和一大堆业务规则。

103
00:07:33,833 --> 00:07:39,254
它的目标是一整套与现有业务深度打通的系统，不是一页网页。

104
00:07:39,254 --> 00:07:43,232
更合理的做法，是先自己梳理整体流程。

105
00:07:43,232 --> 00:07:50,876
关键步骤是什么，每一步的输入输出和状态变化是什么，哪些节点对性能和安全最敏感。

106
00:07:50,876 --> 00:07:58,761
把这张图画出来，再把相对独立的环节拆出来，交给 A I 生成接口、模块、脚本和测试。

107
00:07:58,761 --> 00:08:04,110
拆步骤的事是你做的，架构设计、系统集成和运维，也是你的。

108
00:08:04,110 --> 00:08:06,706
A I 负责加速一个个小步骤。

109
00:08:06,706 --> 00:08:11,069
还有一个更直观的划分，叫能写和能用的区别。

110
00:08:11,069 --> 00:08:14,025
乍一看，A I 好像什么都能写。

111
00:08:14,025 --> 00:08:18,292
但写出来能不能用，能用到什么程度，分三层。

112
00:08:18,292 --> 00:08:25,287
原型、演示版、内部自用工具，非常适合先交给 A I 打第一版，再由你迭代细节。

113
00:08:25,287 --> 00:08:33,256
面向真实用户的大型产品，通常需要工程师在架构、抽象、性能和维护上长期投入。

114
00:08:33,256 --> 00:08:43,617
支付、风控、医疗这类强安全强合规的系统，在现阶段，绝不允许生成完就直接上线，必须引入严格的审查与测试流程。

115
00:08:43,617 --> 00:08:47,475
这三层不是高低之分，是信任等级之分。

116
00:08:47,475 --> 00:08:52,223
越靠近真实用户和真金白银，人的审查就要越重。

117
00:08:52,223 --> 00:08:58,665
所以现阶段，你可以相对安心地把 A I 当成一个高效的演示版与自用工具搭档。

118
00:08:58,665 --> 00:09:08,953
只要你愿意多测试、多迭代，多问几轮这里不对，帮我修一下并解释原因，在原型与内部工具这个级别，整体质量通常是够用的。

119
00:09:09,100 --> 00:09:11,718
边界讲完了，该动手了。

120
00:09:11,668 --> 00:09:15,538
接下来这个练习，是这门课最迷人的部分。

121
00:09:15,538 --> 00:09:21,151
我们要做的不是普通贪吃蛇，是一个 A I 原生的现代版贪吃蛇。

122
00:09:21,151 --> 00:09:25,105
普通贪吃蛇，蛇吃豆子，得分，结束。

123
00:09:25,105 --> 00:09:28,230
我们这个，蛇吃的是文字字符。

124
00:09:28,230 --> 00:09:31,752
每吃一个单词，单词会掉进一个盒子里。

125
00:09:31,752 --> 00:09:37,028
等蛇吃掉八个单词，大模型会根据这八个单词创作一首诗。

126
00:09:37,028 --> 00:09:41,271
诗写完，下一步自动根据这首诗生成一幅画。

127
00:09:41,271 --> 00:09:44,468
吃掉的是字，吐出来的是诗和画。

128
00:09:44,468 --> 00:09:50,959
这个例子想让你理解的，不是贪吃蛇怎么做，而是全新编程方式的核心理念。

129
00:09:50,959 --> 00:09:54,432
如何用自然语言，清晰地表达需求。

130
00:09:54,432 --> 00:09:58,759
最开始，你可以用最简单的方式跟大模型对话。

131
00:09:58,759 --> 00:10:02,497
在聊天框里输入，帮我做一个贪吃蛇游戏。

132
00:10:02,497 --> 00:10:05,225
A I 会给你一个能玩的最简版。

133
00:10:05,225 --> 00:10:08,026
然后加码，每次只加一点。

134
00:10:08,026 --> 00:10:13,170
先补第一条，可以吃不同的单词，它们会被收集在一个盒子里。

135
00:10:13,170 --> 00:10:18,807
看看这一条能做到什么程度，满意了，再把另外两条一次性加上。

136
00:10:18,807 --> 00:10:26,980
这种小步快跑的方式，比一口气写完十几条需求更稳，也更容易定位是哪句话让结果跑偏了。

137
00:10:26,980 --> 00:10:28,891
完整版是这样的。

138
00:10:28,891 --> 00:10:32,293
帮我做一个贪吃蛇游戏，它应该支持。

139
00:10:32,293 --> 00:10:36,788
一，可以吃不同的单词，它们会被收集在一个盒子里。

140
00:10:36,788 --> 00:10:45,574
二，当蛇吃了八个单词时，大模型应该根据这些单词创作一首诗，我们可以根据需要重新混合这首诗。

141
00:10:45,574 --> 00:10:51,139
三，当诗完成后，下一步自动根据这首诗创建一幅图像。

142
00:10:51,139 --> 00:10:52,762
注意这个演进。

143
00:10:52,762 --> 00:10:56,007
从一句话，到带编号的三条需求。

144
00:10:56,007 --> 00:10:58,399
这就是提示词的基本功。

145
00:10:58,399 --> 00:11:03,711
把功能拆成编号，把每一步讲具体，A I 的产出会稳定得多。

146
00:11:03,711 --> 00:11:06,848
开发过程中，你一定会遇到糟心事。

147
00:11:06,848 --> 00:11:11,812
点按钮没反应，用功能时报错，页面跟想的完全不一样。

148
00:11:11,812 --> 00:11:14,949
这时候不要慌，也不要自己硬扛。

149
00:11:14,949 --> 00:11:18,050
继续向模型提问，让它帮你修复。

150
00:11:18,050 --> 00:11:22,870
报错可以直接复制粘贴给它，界面问题可以截图给它。

151
00:11:22,870 --> 00:11:26,644
哪不对就说哪，现象越具体，修得越快。

152
00:11:26,644 --> 00:11:29,997
基本功能跑起来之后，可以加新花样。

153
00:11:29,997 --> 00:11:33,855
让蛇吃不同颜色的单词，蛇的颜色跟着变。

154
00:11:33,855 --> 00:11:35,959
给吃的过程加特效。

155
00:11:35,959 --> 00:11:39,961
引入魔法单词，比如让蛇加速或者变大。

156
00:11:39,961 --> 00:11:45,826
甚至每当蛇吃一个单词，就生成一首诗和一幅图，不用等到八个。

157
00:11:45,826 --> 00:11:50,141
没创意了，直接问大模型，它可以给你一堆建议。

158
00:11:50,141 --> 00:11:52,149
还有一个进阶玩法。

159
00:11:52,149 --> 00:11:55,682
让大模型自己生成项目级提示词。

160
00:11:55,682 --> 00:12:05,274
你可以对它说，我想让 A I 生成一个网页贪吃蛇游戏，需要一个更完整的提示词，让生成结果更令人印象深刻和有趣。

161
00:12:05,274 --> 00:12:07,750
请生成相应的提示词。

162
00:12:07,750 --> 00:12:16,500
当前目标是，生成一个贪吃蛇游戏，需要实现吃不同单词生成诗歌的功能，并且应该包含图像生成模块。

163
00:12:16,500 --> 00:12:22,064
拿到它写的提示词，再用全栈开发模式重新生成一遍项目。

164
00:12:22,064 --> 00:12:26,475
你会发现，A I 写提示词的水平，可能比你还高。

165
00:12:26,596 --> 00:12:28,733
贪吃蛇只是个起点。

166
00:12:28,683 --> 00:12:31,532
真正限制你的，是想象力。

167
00:12:31,532 --> 00:12:34,056
课程里有句话我很喜欢。

168
00:12:34,056 --> 00:12:40,113
创造任何我们想创造的东西，甚至尝试搞砸一切，然后重头再来。

169
00:12:40,113 --> 00:12:43,166
搞砸不要钱，重来只要几分钟。

170
00:12:43,166 --> 00:12:46,387
这是这个时代给普通人最大的福利。

171
00:12:46,387 --> 00:12:50,306
课程里列了一批可以试的方向，我念几个给你听。

172
00:12:50,306 --> 00:12:51,676
应用方向。

173
00:12:51,676 --> 00:12:59,657
在线画廊，用户可以上传、浏览、点赞和评论 A I 生成的艺术作品，还能按风格分类展示。

174
00:12:59,657 --> 00:13:08,647
复古游戏档案馆，致敬经典游戏，收录游戏历史与玩法指南，内置几款能在线玩的复古小游戏。

175
00:13:08,647 --> 00:13:16,267
碳足迹追踪工具，填写日常行为后自动估算碳排放，提供环保建议和每周挑战。

176
00:13:16,267 --> 00:13:22,794
虚拟厨房助手，输入家里有的食材，就推荐菜谱并给出一步步的烹饪说明。

177
00:13:22,794 --> 00:13:32,661
还有地下音乐发现平台、极简任务管理系统、科幻写作工坊、个人知识图谱、虚拟植物园、在线编程竞赛平台。

178
00:13:32,661 --> 00:13:34,488
游戏方向更野。

179
00:13:34,488 --> 00:13:42,986
可自由探索的三维开放世界角色扮演游戏，有昼夜循环、天气变化、任务系统和角色成长。

180
00:13:42,986 --> 00:13:48,467
快节奏的多人射击竞技场，支持团队死斗、夺旗等多种模式。

181
00:13:48,467 --> 00:13:54,452
能和不同难度 A I 对弈的国际象棋平台，也能在线匹配真实玩家。

182
00:13:54,452 --> 00:13:59,248
支持多种规则、私人房间和自动计分的在线麻将。

183
00:13:59,248 --> 00:14:02,794
收集卡牌、自由构建卡组的对战游戏。

184
00:14:02,794 --> 00:14:06,231
带缩圈机制和随机战利品的大逃杀。

185
00:14:06,231 --> 00:14:10,883
第一人称恐怖生存，重点是资源管理和潜行逃生。

186
00:14:10,883 --> 00:14:14,176
音符随节拍飞来的三维音乐节奏游戏。

187
00:14:14,176 --> 00:14:17,914
这份清单的价值不在抄，在于让你看到。

188
00:14:17,914 --> 00:14:23,154
这些需求的描述方式，和你描述贪吃蛇的方式，一模一样。

189
00:14:23,154 --> 00:14:27,625
把界面和交互说清楚，A I 就能拼出完整的东西。

190
00:14:27,625 --> 00:14:32,060
你能描述的世界有多大，你能做的东西就有多大。

191
00:14:32,060 --> 00:14:34,572
你不需要把二十个都做一遍。

192
00:14:34,572 --> 00:14:40,786
挑一个让你眼睛发亮的，用一个周末，把它从一句话变成能打开的网页。

193
00:14:40,786 --> 00:14:45,306
这一个周末的体验，比看一百篇教程都管用。

194
00:14:45,460 --> 00:14:46,936
最后收个尾。

195
00:14:46,886 --> 00:14:49,638
这一集你只要带走三句话。

196
00:14:49,638 --> 00:14:57,643
第一，程序员都在靠 A I 写代码，所以你直接跟 A I 对话实现想法，这件事是成立的，有数据撑腰。

197
00:14:57,643 --> 00:15:05,131
第二，A I 能做好小而清晰的东西，原型、内部工具、轻量游戏，都在射程之内。

198
00:15:05,131 --> 00:15:09,638
大型系统、支付风控医疗，暂时还在人这边。

199
00:15:09,638 --> 00:15:15,311
第三，也是最重要的，把需求说清楚，就是新时代的编程能力。

200
00:15:15,311 --> 00:15:23,905
这项能力不看你学历，不看你会不会配环境，只看你能不能把脑子里的画面，讲成 A I 能执行的话。

201
00:15:23,905 --> 00:15:28,268
如果你从没做过任何东西，这一集的作业只有一个。

202
00:15:28,268 --> 00:15:35,323
打开课程里的平台，或者任何一个同类工具，输入那句，帮我做一个贪吃蛇游戏。

203
00:15:35,323 --> 00:15:38,845
做完之后，再把它改成吃单词的版本。

204
00:15:38,845 --> 00:15:42,992
两个小时内，你会对这个世界有一点点不同的感受。

205
00:15:42,992 --> 00:15:45,372
下一集，我们继续往前。

206
00:15:45,372 --> 00:15:51,081
聊聊怎么找到值得做的好点子，怎么判断一个想法是不是真需求。

207
00:15:51,081 --> 00:15:52,956
我们下一站见。