1
00:00:00,000 --> 00:00:15,920
首先我们来讲第一块,Codex核心能力与工程化设计的一个思想。那么Codex的话,相信大家如果是作为程序员的话,基本上多多少少都已经听说过了,或者有的同学已经用过一段时间了。

2
00:00:15,920 --> 00:00:17,080
那这里的话

3
00:00:17,080 --> 00:00:18,960
我给他做一个简单的概述啊

4
00:00:18,960 --> 00:00:22,980
Codex是OpenAI官方推出的一款AI变成工具啊

5
00:00:22,980 --> 00:00:24,240
但这个目前

6
00:00:24,240 --> 00:00:27,700
这个已经不仅仅局限于AI变成这一块了啊

7
00:00:27,700 --> 00:00:29,340
他能做的事情非常多啊

8
00:00:29,340 --> 00:00:30,760
怎么等一下逐步来展开

9
00:00:30,760 --> 00:00:35,720
那么大家可以通过这个官方的一个文档啊

10
00:00:35,720 --> 00:00:40,300
如果想去深入的了解Codex所有的一些细节的话啊

11
00:00:40,300 --> 00:00:42,380
我建议大家去看一下这个OpenAI

12
00:00:42,380 --> 00:00:45,860
出的这个官方的这个开发者文档

13
00:00:45,860 --> 00:00:47,520
这个是给开发人员看的

14
00:00:47,520 --> 00:00:49,760
里面的一些文档的话写的非常详细

15
00:00:49,760 --> 00:00:52,940
大家对一些概念性的论知

16
00:00:52,940 --> 00:00:56,660
包括一些比如说我们来查一些指南

17
00:00:56,660 --> 00:00:59,460
大家都可以通过这个文档做一个路手

18
00:00:59,460 --> 00:01:01,760
所以说这是一份非常好的学习资料

19
00:01:01,760 --> 00:01:03,480
这是我推荐给大家的

20
00:01:03,480 --> 00:01:05,400
然后的话是Codex的话

21
00:01:05,400 --> 00:01:07,440
它有一些模块的话

22
00:01:07,440 --> 00:01:08,300
它是开源的

23
00:01:08,300 --> 00:01:11,760
如果大家对它的底层原码感兴趣

24
00:01:11,760 --> 00:01:13,100
比如说像CLI

25
00:01:13,100 --> 00:01:13,820
是吧

26
00:01:13,820 --> 00:01:14,780
还有一些这个

27
00:01:14,780 --> 00:01:17,020
他的一些文档呀

28
00:01:17,020 --> 00:01:17,400
你看

29
00:01:17,400 --> 00:01:20,800
比如说他的一些agents.md的一些这个细节文档

30
00:01:20,800 --> 00:01:22,820
大家如果感兴趣啊

31
00:01:22,820 --> 00:01:26,180
可以去他的这个开源的这个仓库里面

32
00:01:26,180 --> 00:01:27,660
去深入的去研究一下

33
00:01:27,660 --> 00:01:32,100
这个也是我给大家提供的一份这个学习资料

34
00:01:32,100 --> 00:01:33,520
就是这个路口

35
00:01:33,520 --> 00:01:35,520
大家可以从这个地方去路手

36
00:01:35,520 --> 00:01:38,300
如果你对他的这个圆码也比较感兴趣

37
00:01:38,300 --> 00:01:40,940
像参与这个Codex

38
00:01:40,940 --> 00:01:42,260
他的一个开源建设的话

39
00:01:42,260 --> 00:01:44,720
大家可以在这个里面去做一个路手

40
00:01:44,720 --> 00:01:45,460
OK

41
00:01:45,460 --> 00:01:48,860
这个就是我给大家推荐的这个两份学习资料啊

42
00:01:48,860 --> 00:01:54,000
然后下面这个的话是CodexAPP的这么一个页面啊

43
00:01:54,000 --> 00:01:57,460
最开始的话Codex是没有APP版本的啊

44
00:01:57,460 --> 00:01:59,540
它是基于这个CLI命令行的

45
00:01:59,540 --> 00:02:02,000
所以最早期大家使用的话啊

46
00:02:02,000 --> 00:02:04,060
基本上是基于这个命令行啊

47
00:02:04,060 --> 00:02:08,320
比如说我们在这个里面输入一个这个Codex是吧

48
00:02:08,320 --> 00:02:10,080
那我们进入到这个命令行页面

49
00:02:10,080 --> 00:02:13,060
直接就可以做一个AI编程了

50
00:02:13,060 --> 00:02:14,860
我们最开始的使用方式是这样的

51
00:02:14,860 --> 00:02:15,360
但是的话

52
00:02:15,360 --> 00:02:18,560
目前的话Codex已经出了这个APP了

53
00:02:18,560 --> 00:02:19,760
然后也非常好用

54
00:02:19,760 --> 00:02:20,460
等一下的话

55
00:02:20,460 --> 00:02:21,760
我们就来给他讲一下

56
00:02:21,760 --> 00:02:24,060
这个APP的一个安装跟使用

57
00:02:24,060 --> 00:02:30,200
所以我们主要是基于这个CLI和这个APP

58
00:02:30,200 --> 00:02:32,160
混合的这种方式去使用

59
00:02:32,160 --> 00:02:32,960
还有的话

60
00:02:32,960 --> 00:02:35,200
就是他还有一种插件形式的

61
00:02:35,200 --> 00:02:39,000
就是我们可以用这个Coser或者VSCode

62
00:02:39,000 --> 00:02:42,800
大家可以去装一个这个Coser

63
00:02:42,800 --> 00:02:45,340
就是整个它有一个Codex插件

64
00:02:45,340 --> 00:02:46,640
这个也比较好用

65
00:02:46,640 --> 00:02:50,160
这个的话如果大家习惯性用这个WasteCode

66
00:02:50,160 --> 00:02:51,280
或者是Coser的话

67
00:02:51,280 --> 00:02:52,740
你可以把这个插件

68
00:02:52,740 --> 00:02:54,400
装一个Codex插件

69
00:02:54,400 --> 00:02:57,340
然后跟我们的这个编码结合起来去用

70
00:02:57,340 --> 00:02:58,560
这也是OK的

71
00:02:58,560 --> 00:03:00,880
这也是我比较推荐大家用的一种方式

72
00:03:00,880 --> 00:03:02,120
如果你既要改代码

73
00:03:02,120 --> 00:03:04,220
又要去做这个

74
00:03:04,220 --> 00:03:06,480
你想用这个Codex的话

75
00:03:06,480 --> 00:03:07,400
都是OK的

76
00:03:07,400 --> 00:03:10,020
但你不在这个里面装插件

77
00:03:10,020 --> 00:03:10,920
你用那个APP

78
00:03:10,920 --> 00:03:12,680
然后或者是CLI

79
00:03:12,680 --> 00:03:13,700
也是没有问题的

80
00:03:13,700 --> 00:03:15,300
只是说在这个里面的话

81
00:03:15,300 --> 00:03:17,020
切换就会比较简单一些

82
00:03:17,020 --> 00:03:19,740
不然的话你要切换这个窗口

83
00:03:19,740 --> 00:03:21,660
还是稍微有那么一点麻烦

84
00:03:21,660 --> 00:03:23,480
不过这个都是小问题

85
00:03:23,480 --> 00:03:25,260
所以说它的使用方式有

86
00:03:25,260 --> 00:03:26,340
基本上就是三种

87
00:03:26,340 --> 00:03:28,240
第一种的话就是我们用这个APP

88
00:03:28,240 --> 00:03:30,440
然后第二种的话就是用CLI

89
00:03:30,440 --> 00:03:32,680
还有的话就是一个插件形式

90
00:03:32,680 --> 00:03:34,640
基本上目前主流的使用方式的话

91
00:03:34,640 --> 00:03:35,320
就是三个

92
00:03:35,320 --> 00:03:38,200
那么它主要啊

93
00:03:38,200 --> 00:03:41,740
如果说在做这个AI编程这一块的话

94
00:03:41,740 --> 00:03:43,220
它主要的功能有哪些呢

95
00:03:43,220 --> 00:03:44,620
首先第一块的话啊

96
00:03:44,620 --> 00:03:46,640
写代码就是一个基础功能的

97
00:03:46,640 --> 00:03:48,480
那么在Codex里面的话

98
00:03:48,480 --> 00:03:51,220
大家可以非常方便的去使用一些快捷指令

99
00:03:51,220 --> 00:03:53,400
然后采用这种对话的方式

100
00:03:53,400 --> 00:03:56,440
去让它去帮你去生成这个代码

101
00:03:56,440 --> 00:03:58,480
或者说整个去开发一个项目

102
00:03:58,480 --> 00:04:00,400
搭建一个项目架构都是OK的

103
00:04:00,400 --> 00:04:01,780
还有一点的话

104
00:04:01,780 --> 00:04:04,900
就是我们可以用Codex去学习一些

105
00:04:04,900 --> 00:04:06,180
优秀的开源项目

106
00:04:06,180 --> 00:04:08,980
比如说大家对这个开源项目比较感兴趣

107
00:04:08,980 --> 00:04:10,460
就是把这个项目拉下来

108
00:04:10,460 --> 00:04:13,480
然后通过Codex命令去分析一下

109
00:04:13,480 --> 00:04:14,740
当前这个项目的话

110
00:04:14,740 --> 00:04:16,340
它的一个结构是怎么样的

111
00:04:16,340 --> 00:04:18,300
包括大家在公司里面

112
00:04:18,300 --> 00:04:22,120
你去接手一些历史的一些遗留项目

113
00:04:22,120 --> 00:04:22,420
是吧

114
00:04:22,420 --> 00:04:24,200
一些代码你看不懂怎么办呢

115
00:04:24,200 --> 00:04:25,720
那你也可以用Codex

116
00:04:25,720 --> 00:04:27,940
可以去帮你去做一个阅读

117
00:04:27,940 --> 00:04:30,200
然后帮助你快速的去理解

118
00:04:30,200 --> 00:04:33,120
团队是如何去做一个开发的

119
00:04:33,120 --> 00:04:34,380
然后包括里面的细节问题

120
00:04:34,380 --> 00:04:36,660
他都可以通过Codex去把它分析出来

121
00:04:36,660 --> 00:04:37,940
这也是一个场景

122
00:04:37,940 --> 00:04:40,380
然后的话就是审查代码

123
00:04:40,380 --> 00:04:42,740
那以前我们做那个代码审查的话

124
00:04:42,740 --> 00:04:45,500
大家习惯性的要去看那个PR是吧

125
00:04:45,500 --> 00:04:47,620
看PR里面的这个commit

126
00:04:47,620 --> 00:04:49,540
DIF里面到底给了哪些文件

127
00:04:49,540 --> 00:04:50,680
然后看一下有没有漏洞

128
00:04:50,680 --> 00:04:51,680
然后有问题的话

129
00:04:51,680 --> 00:04:53,100
还得上面标注一下

130
00:04:53,100 --> 00:04:54,400
以前的话

131
00:04:54,400 --> 00:04:56,560
这个需要耗费大量的这个人工成本

132
00:04:56,560 --> 00:04:58,360
专门需要一个代码审查

133
00:04:58,360 --> 00:05:00,520
那现在有了Codex之后的话

134
00:05:00,520 --> 00:05:01,800
我们做代码审查的话

135
00:05:01,800 --> 00:05:02,840
其实会非常简单

136
00:05:02,840 --> 00:05:04,400
就是这个里面的话

137
00:05:04,400 --> 00:05:05,640
他会去分析

138
00:05:05,640 --> 00:05:09,360
他有专门的review的这么一个斜杠命令

139
00:05:09,360 --> 00:05:11,680
这个我们等一下会给大家讲这么一个案例

140
00:05:11,680 --> 00:05:14,700
就是我们可以用review的一个命令

141
00:05:14,700 --> 00:05:16,680
去快速的去分析本次

142
00:05:16,680 --> 00:05:18,920
比如说我还没有提交的一些代码

143
00:05:18,920 --> 00:05:19,920
我想让他分析一下

144
00:05:19,920 --> 00:05:21,760
或者说我们已经提交的PR

145
00:05:21,760 --> 00:05:23,560
这个代码有没有问题

146
00:05:23,560 --> 00:05:26,180
也可以分析出来

147
00:05:26,180 --> 00:05:27,700
让我们根据这个结果

148
00:05:27,700 --> 00:05:29,400
最后去把这个代码

149
00:05:29,400 --> 00:05:31,480
就是给提一些建议

150
00:05:31,480 --> 00:05:33,780
或者给他拒绝这个皮牙合并

151
00:05:33,780 --> 00:05:34,140
是吧

152
00:05:34,140 --> 00:05:35,860
这个就是我们做代码审查

153
00:05:35,860 --> 00:05:37,560
可以结合Codex做的一些事情

154
00:05:37,560 --> 00:05:38,660
然后的话

155
00:05:38,660 --> 00:05:40,680
大家还可以通过Codex去

156
00:05:40,680 --> 00:05:42,740
排查一些线上的一些问题

157
00:05:42,740 --> 00:05:43,100
是吧

158
00:05:43,100 --> 00:05:44,400
比如我们线上发现一些bug

159
00:05:44,400 --> 00:05:45,400
有一些日志

160
00:05:45,400 --> 00:05:47,100
他定位了一些代码行

161
00:05:47,100 --> 00:05:49,100
那我们把这些日志提供给Codex

162
00:05:49,100 --> 00:05:49,900
那Codex的话

163
00:05:49,900 --> 00:05:51,920
可以快速的去帮我们找到

164
00:05:51,920 --> 00:05:53,400
这个代码到底哪里出问题了

165
00:05:53,400 --> 00:05:55,500
并针对性的给一些修复方案出来

166
00:05:55,500 --> 00:05:57,000
所以这个也是一个

167
00:05:57,000 --> 00:05:59,360
比较好的一个应用方向

168
00:05:59,360 --> 00:06:01,420
然后最后一个的话

169
00:06:01,420 --> 00:06:03,340
就是自动化开发任务啊

170
00:06:03,340 --> 00:06:05,220
那这一块也是用的比较多的一个场景

171
00:06:05,220 --> 00:06:07,920
那就是说我们可以通过Codex啊

172
00:06:07,920 --> 00:06:10,540
就是从零到一去做一个项目的一个开发

173
00:06:10,540 --> 00:06:11,720
那我们等一下的话

174
00:06:11,720 --> 00:06:13,460
也会带大家去基于这个流程

175
00:06:13,460 --> 00:06:14,800
去做一个项目啊

176
00:06:14,800 --> 00:06:16,120
就是从需求分析开始

177
00:06:16,120 --> 00:06:20,400
到整个的一个项目的一个功能拆解啊

178
00:06:20,400 --> 00:06:20,740
是吧

179
00:06:20,740 --> 00:06:22,020
核心功能开发呀

180
00:06:22,020 --> 00:06:23,180
包括测试啊

181
00:06:23,180 --> 00:06:25,480
包括整个的一个啊

182
00:06:25,480 --> 00:06:26,240
调试啊

183
00:06:26,240 --> 00:06:26,500
是吧

184
00:06:26,500 --> 00:06:31,100
这个我们等一下都会给大家去走一遍啊

185
00:06:31,100 --> 00:06:32,600
所以这几个场景的话

186
00:06:32,600 --> 00:06:33,800
都是Codex

187
00:06:33,800 --> 00:06:36,340
它比较擅长

188
00:06:36,340 --> 00:06:38,580
或者说比较主流的一些应用场景

189
00:06:38,580 --> 00:06:40,060
那么Codex

190
00:06:40,060 --> 00:06:42,260
它的一个核心能力有哪些呢

191
00:06:42,260 --> 00:06:45,160
大家要比较好的去使用Codex的话

192
00:06:45,160 --> 00:06:47,260
首先要对它的一个核心能力

193
00:06:47,260 --> 00:06:49,420
或者说对它整个的一个功能架构的话

194
00:06:49,420 --> 00:06:51,000
有一个认知

195
00:06:51,000 --> 00:06:52,520
就是要有一个大的认知

196
00:06:52,520 --> 00:06:53,040
这样的话

197
00:06:53,040 --> 00:06:55,260
你在去做一些开发的时候

198
00:06:55,260 --> 00:06:55,900
你就会想到

199
00:06:55,900 --> 00:06:58,120
原来Codex已经集成这个能力了

200
00:06:58,120 --> 00:07:00,480
那大家去直接把它去应用到

201
00:07:00,480 --> 00:07:01,700
工作当中去的话

202
00:07:01,700 --> 00:07:03,360
那这个提效就很明显了

203
00:07:03,360 --> 00:07:04,640
那大家可以看一下

204
00:07:04,640 --> 00:07:05,860
整个的一个

205
00:07:05,860 --> 00:07:07,320
它的一个能力

206
00:07:07,320 --> 00:07:09,880
那能力的话是非常多了

207
00:07:09,880 --> 00:07:11,100
最主要的话

208
00:07:11,100 --> 00:07:13,080
就是它的一个多任务处理

209
00:07:13,080 --> 00:07:14,240
就是多线程

210
00:07:14,240 --> 00:07:16,480
大家在用这个Codex过程中

211
00:07:16,480 --> 00:07:17,840
你会发现一个点

212
00:07:17,840 --> 00:07:19,300
就是整个

213
00:07:19,300 --> 00:07:21,440
它是基于多线程的一个机制

214
00:07:21,440 --> 00:07:22,960
就是你不断的跟它去对话

215
00:07:22,960 --> 00:07:24,940
它会不断的去起

216
00:07:24,940 --> 00:07:25,860
各种各样的线程

217
00:07:25,860 --> 00:07:26,860
帮你去完成任务

218
00:07:26,860 --> 00:07:28,640
并且最终做一个合并

219
00:07:28,640 --> 00:07:31,240
所以它的一个跨项目的

220
00:07:31,240 --> 00:07:32,900
多任务处理能力非常强

221
00:07:32,900 --> 00:07:36,560
就是你可以让它同时去开发三个项目

222
00:07:36,560 --> 00:07:37,940
开三个这个县城

223
00:07:37,940 --> 00:07:38,500
是吧

224
00:07:38,500 --> 00:07:39,240
然后最终

225
00:07:39,240 --> 00:07:42,820
比如说我们想让它分析三个项目的一个细节

226
00:07:42,820 --> 00:07:44,980
然后分析完之后做一个总结归纳

227
00:07:45,384 --> 00:07:47,184
最后给你输出一张表格。

228
00:07:47,184 --> 00:07:48,884
那他就是启动三个县程。

229
00:07:48,884 --> 00:07:52,984
即使是跨多项目的话,他也可以用多任务的方式去处理。

230
00:07:52,984 --> 00:07:55,084
这是他的一个非常强大的一个能力。

231
00:07:55,084 --> 00:07:59,684
然后的话,他里面内置了一个叫Git WorkTree的一个这么一个机制。

232
00:07:59,684 --> 00:08:01,444
它的一个优点是什么

233
00:08:01,444 --> 00:08:03,344
就是我们可以在一个分支下面

234
00:08:03,344 --> 00:08:06,044
可以支持加多个这个work tree

235
00:08:06,044 --> 00:08:07,424
然后去并行开发

236
00:08:07,424 --> 00:08:09,384
以前的话我们开发的话

237
00:08:09,384 --> 00:08:11,624
就是都要做分支隔离的是吧

238
00:08:11,624 --> 00:08:15,864
比如说某某同学是做这个A分支

239
00:08:15,864 --> 00:08:17,044
某某同学是B分支

240
00:08:17,044 --> 00:08:18,724
他们两个分支功能

241
00:08:18,724 --> 00:08:20,244
如果要做并行开发的话

242
00:08:20,244 --> 00:08:22,564
那得把他们两个分支给它合并了

243
00:08:22,564 --> 00:08:22,844
是吧

244
00:08:22,844 --> 00:08:24,904
这样的功能才能整合到一起

245
00:08:24,904 --> 00:08:27,824
现在有了这个getwork tree的之后的话

246
00:08:27,824 --> 00:08:29,924
Codex整合了这个之后的话

247
00:08:29,924 --> 00:08:31,684
我们可以直接在一个分支里面

248
00:08:31,684 --> 00:08:33,564
加多个worktree的方式做并行开发

249
00:08:33,564 --> 00:08:35,764
并且的话代码它是相互隔离的

250
00:08:35,764 --> 00:08:38,224
这样的话就达到了我不想见多分支

251
00:08:38,224 --> 00:08:40,664
也能实现多人协作的这么一个目标

252
00:08:40,664 --> 00:08:42,344
这是一个比较好的一个点

253
00:08:42,344 --> 00:08:43,824
然后的话就是

254
00:08:43,824 --> 00:08:46,724
我们可以通过这个Codex

255
00:08:46,724 --> 00:08:48,024
做一个远程连接啊

256
00:08:48,024 --> 00:08:52,024
就是它可以去专门连接到一个这个

257
00:08:52,024 --> 00:08:53,964
不同的这个

258
00:08:53,964 --> 00:08:55,544
比如说我们手机端是吧

259
00:08:55,544 --> 00:08:57,164
我们手机端去远程连接

260
00:08:57,164 --> 00:08:59,644
这个我们在手机档上面远程操控

261
00:08:59,644 --> 00:09:01,464
我们电脑端的这么一个Codex

262
00:09:01,464 --> 00:09:02,184
让它去干活

263
00:09:02,184 --> 00:09:04,964
这个也是一个好的一个功能

264
00:09:04,964 --> 00:09:06,844
这个就像那个小龙虾是吧

265
00:09:06,844 --> 00:09:07,504
养虾一样

266
00:09:07,504 --> 00:09:09,484
我可以远程指挥它去干活

267
00:09:09,484 --> 00:09:10,764
并且的话

268
00:09:10,764 --> 00:09:13,904
我们可以在这个Codex上面操作一些应用

269
00:09:13,904 --> 00:09:15,504
比如说在iOS上面

270
00:09:15,504 --> 00:09:17,824
去调用一些这个

271
00:09:17,824 --> 00:09:19,344
在MacOS上面

272
00:09:19,344 --> 00:09:21,084
就是我们的这个苹果系统上面

273
00:09:21,084 --> 00:09:22,864
它可以去调用各种的应用

274
00:09:22,864 --> 00:09:24,024
执行一些任务

275
00:09:24,024 --> 00:09:25,584
包括一些操作流感器

276
00:09:25,584 --> 00:09:26,864
当然都是支持的

277
00:09:26,864 --> 00:09:29,364
并且的话它可以支持应用截图识别图片

278
00:09:29,364 --> 00:09:31,664
然后做一些评审交付

279
00:09:31,664 --> 00:09:33,944
执行终端的一些命令

280
00:09:33,944 --> 00:09:35,384
然后操作浏览器

281
00:09:35,384 --> 00:09:37,744
包括它还可以去添加一些Chrome插件

282
00:09:37,744 --> 00:09:42,204
让Codex帮你去管理整个我们的这个浏览器

283
00:09:42,204 --> 00:09:42,524
是吧

284
00:09:42,524 --> 00:09:44,464
然后做一些浏览器的一些任务

285
00:09:44,464 --> 00:09:47,284
并且的话它可以去生成一些图片

286
00:09:47,284 --> 00:09:48,024
编辑图片

287
00:09:48,024 --> 00:09:49,564
因为OpenAI的话

288
00:09:49,564 --> 00:09:52,804
它本身就有一些这个图片的一些模型

289
00:09:52,804 --> 00:09:54,044
多么碳模型

290
00:09:54,044 --> 00:09:55,584
比如说像DLE3

291
00:09:55,584 --> 00:09:56,844
然后image2

292
00:09:56,844 --> 00:09:58,104
就是有它有生成

293
00:09:58,104 --> 00:09:59,404
专门生成图片的模型

294
00:09:59,404 --> 00:10:00,704
所以说它本身

295
00:10:00,704 --> 00:10:02,264
也可以去编辑图片

296
00:10:02,264 --> 00:10:03,404
这样的话

297
00:10:03,404 --> 00:10:04,104
我们相当于

298
00:10:04,104 --> 00:10:05,824
你可以把codex当做

299
00:10:05,824 --> 00:10:07,904
这个AI绘画工具来用

300
00:10:07,904 --> 00:10:09,164
这个也是可以的

301
00:10:09,164 --> 00:10:10,584
包括我们还可以做一些

302
00:10:10,584 --> 00:10:11,624
这个自动化

303
00:10:11,624 --> 00:10:13,564
就是一些这个论务

304
00:10:13,564 --> 00:10:14,004
是吧

305
00:10:14,004 --> 00:10:16,504
你做了一些这个操作之后

306
00:10:16,504 --> 00:10:17,624
你可以让它全自动的

307
00:10:17,624 --> 00:10:18,764
去调用各种各样的工具

308
00:10:18,764 --> 00:10:19,744
帮你去完成一个

309
00:10:19,744 --> 00:10:20,824
大的一个任务

310
00:10:20,824 --> 00:10:21,824
就全自动的

311
00:10:21,824 --> 00:10:23,164
然后的话

312
00:10:23,164 --> 00:10:25,124
就是我们还可以在codex上面

313
00:10:25,124 --> 00:10:26,384
去搭建一些技能

314
00:10:26,384 --> 00:10:27,164
这个我们等一下

315
00:10:27,164 --> 00:10:27,984
也会给大家讲

316
00:10:27,984 --> 00:10:29,024
就是怎么从零到一

317
00:10:29,024 --> 00:10:30,024
去搭建一个技能

318
00:10:30,024 --> 00:10:31,424
做真正企业级的

319
00:10:31,424 --> 00:10:32,384
一个scale开发

320
00:10:32,384 --> 00:10:34,004
然后怎么去使用它

321
00:10:34,004 --> 00:10:35,904
然后包括一些这个

322
00:10:35,904 --> 00:10:37,944
一些什么侧边软

323
00:10:37,944 --> 00:10:39,084
与artifactor

324
00:10:39,084 --> 00:10:40,484
这个是它的一些

325
00:10:40,484 --> 00:10:42,484
跟踪计划来源

326
00:10:42,484 --> 00:10:43,364
任务摘要和

327
00:10:43,364 --> 00:10:45,024
生成文件预览的一些功能

328
00:10:45,024 --> 00:10:45,764
这个都是它

329
00:10:45,764 --> 00:10:47,124
比较实用的一些功能

330
00:10:47,124 --> 00:10:47,964
还有包括它

331
00:10:47,964 --> 00:10:49,804
比较强大的一个插件系统

332
00:10:49,804 --> 00:10:50,564
这个我们等一下

333
00:10:50,564 --> 00:10:51,284
也会给大家讲

334
00:10:51,284 --> 00:10:52,644
这个插件功能的话

335
00:10:52,644 --> 00:10:53,644
其实也非常强大

336
00:10:53,644 --> 00:10:57,444
它可以极大程度的去拓展Codex

337
00:10:57,444 --> 00:10:58,524
能做的一些事情

338
00:10:58,524 --> 00:10:59,304
让它可以

339
00:10:59,304 --> 00:11:01,524
比如说甚至去生生视频也是可以的

340
00:11:01,524 --> 00:11:02,504
并且的话

341
00:11:02,504 --> 00:11:04,024
它可以与我们的这个IDE

342
00:11:04,024 --> 00:11:04,884
比如说与Coser

343
00:11:04,884 --> 00:11:06,424
或者是用WasteCode

344
00:11:06,424 --> 00:11:07,644
整个做一个同步

345
00:11:07,644 --> 00:11:09,784
这个就是它的一个核心能力

346
00:11:09,784 --> 00:11:11,164
那么大家有了一个

347
00:11:11,164 --> 00:11:13,224
全方位的这个认知之后的话

348
00:11:13,224 --> 00:11:14,764
后面你在用Codex的时候

349
00:11:14,764 --> 00:11:16,424
你可以把这一点给考虑进去

350
00:11:16,424 --> 00:11:18,704
如果说Codex里面已经集中这个功能的话

351
00:11:18,704 --> 00:11:21,424
那你可以完全把它做一个整合

352
00:11:21,424 --> 00:11:23,444
就大家可以可以把各种各样的功能

353
00:11:23,444 --> 00:11:25,964
整合在一起搭配去使用

354
00:11:25,964 --> 00:11:28,944
大家就是不要单独的去看待这个功能

355
00:11:28,944 --> 00:11:30,384
你一定要把它做一个什么呢

356
00:11:30,384 --> 00:11:32,064
就是整合

357
00:11:32,064 --> 00:11:33,984
就是我们把一个工作流

358
00:11:33,984 --> 00:11:35,984
你把整个串起来

359
00:11:35,984 --> 00:11:37,224
那它就可以做很多事情

360
00:11:37,224 --> 00:11:39,904
如果你只是聚焦它在单个功能上面的话

361
00:11:39,904 --> 00:11:42,224
它可能做的功能的话就比较单一

362
00:11:42,224 --> 00:11:44,024
所以大家要有一个全局的思维

363
00:11:44,024 --> 00:11:45,364
OK

364
00:11:45,364 --> 00:11:49,564
然后是Codex它的一个工程化设计思想

365
00:11:49,564 --> 00:11:52,244
那么这个设计思想有什么用呢

366
00:11:52,244 --> 00:11:55,064
那么Codex的话

367
00:11:55,064 --> 00:11:56,584
跟我们以前的这个

368
00:11:56,584 --> 00:11:58,764
AI编程助手的话

369
00:11:58,764 --> 00:12:00,784
还是有一些不一样的地方

370
00:12:00,784 --> 00:12:03,244
因为它毕竟是OpenAI出的

371
00:12:03,244 --> 00:12:05,144
它的一些设计思想的话

372
00:12:05,144 --> 00:12:06,704
跟这个Courser

373
00:12:06,704 --> 00:12:08,044
或者是Ways Code

374
00:12:08,044 --> 00:12:11,564
它们整合这个AI工具

375
00:12:11,564 --> 00:12:13,144
稍微有一点不一样

376
00:12:13,144 --> 00:12:15,544
那么它已经从一个

377
00:12:15,544 --> 00:12:17,544
简单的这个AI编码助手

378
00:12:17,544 --> 00:12:19,004
已经进化成一个叫做

379
00:12:19,004 --> 00:12:20,744
全镇开发的一个伙伴了

380
00:12:20,744 --> 00:12:21,924
为什么这么说呢

381
00:12:21,924 --> 00:12:23,384
主要有以下几个基点

382
00:12:23,384 --> 00:12:26,984
首先的话是规范工程取代了提示词工程

383
00:12:26,984 --> 00:12:29,764
以前的话大家是吧

384
00:12:29,764 --> 00:12:31,804
你做一个项目的话习惯性的

385
00:12:31,804 --> 00:12:33,924
你要把提示词给写好是吧

386
00:12:33,924 --> 00:12:37,464
那么Codex里面他已经在提供一个

387
00:12:37,464 --> 00:12:39,284
就是在强调一个点啊

388
00:12:39,284 --> 00:12:40,624
叫做规范化编程

389
00:12:40,624 --> 00:12:43,184
就是目前业界有一个非常

390
00:12:43,184 --> 00:12:44,864
这个主流的一个词啊

391
00:12:44,864 --> 00:12:46,524
叫做这个SDD是吧

392
00:12:46,524 --> 00:12:48,564
就是叫规范编程开发

393
00:12:48,564 --> 00:12:51,284
就是以规范去驱动

394
00:12:51,284 --> 00:12:52,384
我们整个的一个逻辑

395
00:12:52,384 --> 00:12:53,864
也就是说他先要

396
00:12:53,864 --> 00:12:55,204
你把这个规范写好

397
00:12:55,204 --> 00:12:56,704
比如说去写agentsmd

398
00:12:56,704 --> 00:12:57,784
写lulis

399
00:12:57,784 --> 00:12:59,244
整个这个规范给他写好

400
00:12:59,244 --> 00:13:00,104
写好完之后

401
00:13:00,104 --> 00:13:01,724
然后再去用AI生成代码

402
00:13:01,724 --> 00:13:02,524
这样的话

403
00:13:02,524 --> 00:13:04,124
他的质量会非常高

404
00:13:04,124 --> 00:13:05,584
所以以前的话

405
00:13:05,584 --> 00:13:07,944
大家没有注意规范的时候

406
00:13:07,944 --> 00:13:10,324
那他你去用自然语言

407
00:13:10,324 --> 00:13:12,384
给他去表达的时候

408
00:13:12,384 --> 00:13:14,084
那就会出现一个问题

409
00:13:14,084 --> 00:13:16,004
就是这个东西的一个边界

410
00:13:16,004 --> 00:13:16,784
就会有问题

411
00:13:16,784 --> 00:13:19,244
就是你采用一个结构化的一个输入

412
00:13:19,244 --> 00:13:21,824
整个它就会非常清晰

413
00:13:21,824 --> 00:13:24,104
就是有规则跟没规则的区别

414
00:13:24,104 --> 00:13:24,704
就是在于

415
00:13:24,704 --> 00:13:27,524
它可以有一个目标

416
00:13:27,524 --> 00:13:30,844
加边界加验收标准的一个结构

417
00:13:30,844 --> 00:13:32,684
这个就相当于我们

418
00:13:32,684 --> 00:13:34,384
大家实际在工作当中

419
00:13:34,384 --> 00:13:35,724
你去做一个事情的时候

420
00:13:35,724 --> 00:13:37,184
它有没有一个什么呢

421
00:13:37,184 --> 00:13:38,264
就是规范

422
00:13:38,264 --> 00:13:40,364
就是有没有自己的一个标准

423
00:13:40,364 --> 00:13:42,204
如果你没有标准的话

424
00:13:42,204 --> 00:13:44,264
你做一个事情的话

425
00:13:44,264 --> 00:13:45,964
就会出现各种各样的一个问题

426
00:13:45,964 --> 00:13:48,304
就是有标准的好处

427
00:13:48,304 --> 00:13:50,304
就是它可以保质保量的去验收

428
00:13:50,304 --> 00:13:53,464
就是达到这么一个效果

429
00:13:53,464 --> 00:13:56,964
所以说Codex已经在强调

430
00:13:56,964 --> 00:13:59,224
这个规范化的一个变成方式

431
00:13:59,224 --> 00:14:00,624
就是用Agent MD

432
00:14:00,624 --> 00:14:02,144
整个的一刻

433
00:14:02,144 --> 00:14:03,224
包括这个Harness

434
00:14:03,224 --> 00:14:04,524
这个Codex

435
00:14:04,524 --> 00:14:06,444
前一段时间也发了一篇文章

436
00:14:06,444 --> 00:14:06,764
是吧

437
00:14:06,764 --> 00:14:08,444
就关于这个Harness Engineering

438
00:14:08,444 --> 00:14:09,724
它整个的话

439
00:14:09,724 --> 00:14:12,444
目前就是采用了这个整个一套Harness

440
00:14:12,444 --> 00:14:13,804
去做一个落地的

441
00:14:13,804 --> 00:14:16,084
包括他自己内部

442
00:14:16,084 --> 00:14:19,464
OpenAI内部也是基于这个Harness

443
00:14:19,464 --> 00:14:23,324
去做了整个的一个项目的一个落地的

444
00:14:23,324 --> 00:14:26,104
之前他们有一篇文章里面提到了

445
00:14:26,104 --> 00:14:28,164
就是三个人

446
00:14:28,164 --> 00:14:30,084
一百多万行代码

447
00:14:30,084 --> 00:14:32,184
全部都是AI生成的

448
00:14:32,184 --> 00:14:34,564
就是用Harness Engineering去做的一个落地

449
00:14:34,564 --> 00:14:36,764
就是人工

450
00:14:36,764 --> 00:14:38,144
我们只限定规范

451
00:14:38,144 --> 00:14:39,824
把标准写好

452
00:14:39,824 --> 00:14:40,784
把目标定好

453
00:14:40,784 --> 00:14:43,264
所有的代码都是AI生成的

454
00:14:43,264 --> 00:14:45,304
人工不需要写一行代码啊

455
00:14:45,304 --> 00:14:46,684
真的是一行代码都不需要写

456
00:14:46,684 --> 00:14:49,464
他就是能把一个大型的项目给搞定

457
00:14:49,464 --> 00:14:51,144
大概是花了啊

458
00:14:51,144 --> 00:14:52,164
我记得是五到六个月

459
00:14:52,164 --> 00:14:53,584
然后给他上线了啊

460
00:14:53,584 --> 00:14:56,364
一个一百万多行的这个一个项目啊

461
00:14:56,364 --> 00:14:57,464
就是这么简单

462
00:14:57,464 --> 00:14:58,384
所以说啊

463
00:14:58,384 --> 00:14:59,704
目前啊

464
00:14:59,704 --> 00:15:03,484
Codex已经在深入的去落地这个Honest Engineering

465
00:15:03,484 --> 00:15:07,084
所以他对规范的要求是非常严格的啊

466
00:15:07,084 --> 00:15:08,664
大家等一下啊

467
00:15:08,664 --> 00:15:09,684
我们在讲解过程中

468
00:15:09,684 --> 00:15:12,124
大家就会感受到他整个这个逻辑啊

469
00:15:12,124 --> 00:15:14,244
就是会变得非常规范化

470
00:15:14,244 --> 00:15:16,164
然后第二块就是

471
00:15:16,164 --> 00:15:18,224
他在这个意图拆解

472
00:15:18,224 --> 00:15:19,164
与agent law

473
00:15:19,164 --> 00:15:20,904
我们叫任务循环这一块的话

474
00:15:20,904 --> 00:15:22,244
也会强调的比较多

475
00:15:22,244 --> 00:15:23,744
因为Konex已经

476
00:15:23,744 --> 00:15:26,644
不是单单的给你去生成一个代码了

477
00:15:26,644 --> 00:15:29,484
他是通过agent循环机制

478
00:15:29,484 --> 00:15:31,524
去模拟人类工程师的一个开发过程

479
00:15:31,524 --> 00:15:32,644
什么意思呢

480
00:15:32,644 --> 00:15:34,824
就是人是怎么干活的

481
00:15:34,824 --> 00:15:36,464
他就是怎么干活的

482
00:15:36,464 --> 00:15:38,844
就以前AI就给你写个代码就完事了

483
00:15:38,844 --> 00:15:41,104
他也不管你能不能运行

484
00:15:41,104 --> 00:15:41,604
啊

485
00:15:41,604 --> 00:15:42,304
除非你

486
00:15:55,305 --> 00:15:57,485
相当于他计划帮你做好了

487
00:15:57,485 --> 00:15:58,885
执行模式也帮你做好了

488
00:15:58,885 --> 00:16:01,705
最后你看到的结果就是没有问题的

489
00:16:01,705 --> 00:16:02,765
就是可以跑的

490
00:16:02,765 --> 00:16:04,265
所以大家现在会发现

491
00:16:04,265 --> 00:16:07,945
就是今年这些个AI编程工具的话

492
00:16:07,945 --> 00:16:09,225
它的进步非常大

493
00:16:09,225 --> 00:16:11,785
就是在Agent这一块做了非常大的一个改进

494
00:16:11,785 --> 00:16:14,785
那大家会发现目前像Cloud Code

495
00:16:14,785 --> 00:16:18,085
或者其他的一些像这个Cloud

496
00:16:18,085 --> 00:16:19,525
这个Codex

497
00:16:19,525 --> 00:16:22,765
或者像这个其他的一些编程工具

498
00:16:22,765 --> 00:16:23,685
大家会发现

499
00:16:23,685 --> 00:16:25,745
它的一个质量明显就上去了

500
00:16:25,745 --> 00:16:27,925
就是它写出来代码直接就可以用了

501
00:16:27,925 --> 00:16:30,545
基本上没什么太明显的一个问题

502
00:16:30,545 --> 00:16:34,225
所以说它内置的一个任务循环

503
00:16:34,225 --> 00:16:37,405
就保证了我们整个的一些什么呢

504
00:16:37,405 --> 00:16:39,165
一些bug一些安全性问题

505
00:16:39,165 --> 00:16:40,325
它就帮你去避免了

506
00:16:40,325 --> 00:16:42,925
因为它会按照我们人类的一个思维

507
00:16:42,925 --> 00:16:44,725
首先会做一个plan计划

508
00:16:44,725 --> 00:16:47,825
干活之前先把计划给你写清楚

509
00:16:47,825 --> 00:16:49,145
写清楚之后的话

510
00:16:49,145 --> 00:16:51,865
一步步的按照计划的一个目标

511
00:16:51,865 --> 00:16:53,725
再去确认

512
00:16:53,725 --> 00:16:55,385
然后再去编码

513
00:16:55,385 --> 00:16:56,985
而不是说

514
00:16:56,985 --> 00:16:58,665
跑到最后发现一堆问题

515
00:16:58,665 --> 00:17:01,165
所以说他是先确认

516
00:17:01,165 --> 00:17:04,005
由我们这个工程师自己去确认

517
00:17:04,005 --> 00:17:05,465
因为他有一些授权模式

518
00:17:05,465 --> 00:17:06,685
有确认模式

519
00:17:06,685 --> 00:17:09,165
也有全托管的这种优劣模式

520
00:17:09,165 --> 00:17:11,665
所以他会有一个确认过程

521
00:17:11,665 --> 00:17:13,125
当我们确认没问题之后

522
00:17:13,125 --> 00:17:14,445
他再去执行的时候

523
00:17:14,445 --> 00:17:16,005
这时候大家会发现

524
00:17:16,005 --> 00:17:17,825
他去执行任务的时候

525
00:17:17,825 --> 00:17:19,085
他会拆得更细

526
00:17:19,085 --> 00:17:21,565
就是agent这一块的话

527
00:17:21,565 --> 00:17:23,245
它会做一个大量的一个拆分

528
00:17:23,245 --> 00:17:25,945
犀利到每一个函数

529
00:17:25,945 --> 00:17:27,165
每一个模块的一个编写

530
00:17:27,165 --> 00:17:28,125
然后的话

531
00:17:28,125 --> 00:17:30,445
它会有一个非常严格的审查模式

532
00:17:30,445 --> 00:17:32,405
它会根据集合上下文去分析

533
00:17:32,405 --> 00:17:33,645
潜在的一些bug

534
00:17:33,645 --> 00:17:35,085
包括一些安全性问题

535
00:17:35,085 --> 00:17:37,185
或者一些性能瓶颈等等的

536
00:17:37,185 --> 00:17:38,965
它都会帮你分析的非常透彻

537
00:17:38,965 --> 00:17:41,765
所以大家看到Codex

538
00:17:41,765 --> 00:17:42,865
帮你升任代码之后

539
00:17:42,865 --> 00:17:44,725
基本上这个代码就没什么问题了

540
00:17:44,725 --> 00:17:45,205
可以用了

541
00:17:45,205 --> 00:17:47,325
因为它内部帮你把这个几个模式

542
00:17:47,325 --> 00:17:47,925
已经跑完了

543
00:17:47,925 --> 00:17:50,505
所以说你看到的东西都是高质量

544
00:17:50,505 --> 00:17:51,745
这也是为什么

545
00:17:51,745 --> 00:17:53,565
这个Agent Loan

546
00:17:53,565 --> 00:17:55,965
它是一个非常关键的一个点

547
00:17:55,965 --> 00:17:58,385
就它做了比较大的一个改进

548
00:17:58,385 --> 00:18:00,365
然后是上下文工程

549
00:18:00,365 --> 00:18:03,745
就Codex在工程架构这一块

550
00:18:03,745 --> 00:18:05,525
对于上下文管理这一块

551
00:18:05,525 --> 00:18:07,405
做了非常大的一个优化

552
00:18:07,405 --> 00:18:08,405
首先的话

553
00:18:08,405 --> 00:18:10,605
它会做一些精简的一个线段检索

554
00:18:10,605 --> 00:18:13,265
它会对整个代码库进行予以切分

555
00:18:13,265 --> 00:18:15,085
指向模型去注入

556
00:18:15,085 --> 00:18:16,165
与当前任务

557
00:18:16,165 --> 00:18:17,785
与特定文件相关依赖

558
00:18:17,785 --> 00:18:18,885
也就是说

559
00:18:18,885 --> 00:18:20,965
我们去问一个问题的时候

560
00:18:20,965 --> 00:18:22,785
他不是把整个都给你加载了

561
00:18:22,785 --> 00:18:23,525
不是这个意思

562
00:18:23,525 --> 00:18:26,045
他是做一个什么叫做注录

563
00:18:26,045 --> 00:18:28,245
就是你问的这个问题

564
00:18:28,245 --> 00:18:30,825
相关的一些代码片段

565
00:18:30,825 --> 00:18:33,205
还有包括一些原数据

566
00:18:33,205 --> 00:18:34,425
比如说一些markdown是吧

567
00:18:34,425 --> 00:18:35,705
有关系的时候

568
00:18:35,705 --> 00:18:38,045
再去做一个检索

569
00:18:38,045 --> 00:18:39,465
做一些这个处理

570
00:18:39,465 --> 00:18:40,685
而不是说一上来

571
00:18:40,685 --> 00:18:42,645
就把整个项目给他拉上去了

572
00:18:42,645 --> 00:18:45,265
那这个很容易出现一些上下文

573
00:18:45,265 --> 00:18:46,945
超过限制的问题是吧

574
00:18:46,945 --> 00:18:47,765
所以说这一块

575
00:18:47,765 --> 00:18:49,905
他对于这个整个线的检索

576
00:18:49,905 --> 00:18:50,825
做了一个精简

577
00:18:50,825 --> 00:18:52,605
然后是ST

578
00:18:52,605 --> 00:18:54,845
这个叫抽象语法术感知

579
00:18:54,845 --> 00:18:57,925
他会结合代码的一个数状结构

580
00:18:57,925 --> 00:19:00,745
去理解他的一个依赖引用

581
00:19:00,745 --> 00:19:03,765
也就是说代码跟代码之间的一个关系的话

582
00:19:03,765 --> 00:19:05,265
他是有依赖的

583
00:19:05,265 --> 00:19:06,125
他不是说

584
00:19:06,125 --> 00:19:10,345
简单粗暴的给你把一些这个代码拼在一起

585
00:19:10,345 --> 00:19:11,265
然后去理解的

586
00:19:11,265 --> 00:19:14,785
他是一定要把他的一个依赖关系给他分析出来

587
00:19:14,785 --> 00:19:17,165
这个做过我们这个

588
00:19:17,165 --> 00:19:18,505
加瓦项目开发啊

589
00:19:18,505 --> 00:19:19,765
就Mavin依赖的这个同学

590
00:19:19,765 --> 00:19:21,145
应该会比较清楚啊

591
00:19:21,145 --> 00:19:22,905
包括极致Python里面啊

592
00:19:22,905 --> 00:19:23,925
各种语言里面

593
00:19:23,925 --> 00:19:24,825
其实都有一些

594
00:19:24,825 --> 00:19:26,985
一些酷的一些依赖是吧

595
00:19:26,985 --> 00:19:28,905
那么如果说啊

596
00:19:28,905 --> 00:19:31,205
AI没有理解这个依赖引用的话

597
00:19:31,205 --> 00:19:32,605
就很可能出现什么呢

598
00:19:32,605 --> 00:19:34,285
就是一些编译报错呀

599
00:19:34,285 --> 00:19:35,965
或者是一些少一些模块啊

600
00:19:35,965 --> 00:19:36,145
是吧

601
00:19:36,145 --> 00:19:37,165
就很容易出现这种问题

602
00:19:37,165 --> 00:19:38,745
所以早期的AI编程工具

603
00:19:38,745 --> 00:19:39,805
它帮你设计代码的话

604
00:19:39,805 --> 00:19:41,765
有时候就就会出现这种问题

605
00:19:41,765 --> 00:19:43,025
因为它没有分析透彻

606
00:19:43,025 --> 00:19:45,225
它只是简单突破的给你去生成态

607
00:19:45,225 --> 00:19:47,485
那现在Codex这种

608
00:19:47,485 --> 00:19:49,045
最新的AI变成工具

609
00:19:49,045 --> 00:19:50,585
这些问题他们都解决了

610
00:19:50,585 --> 00:19:53,045
那么它给你把依赖分析的非常透彻

611
00:19:53,045 --> 00:19:57,685
然后是外部工具的一个协同

612
00:19:57,685 --> 00:19:59,685
那这个里面的话

613
00:19:59,685 --> 00:20:02,005
主要是就是在工程化设计中

614
00:20:02,005 --> 00:20:03,365
Codex的话

615
00:20:03,365 --> 00:20:06,625
它其实是具备了强大的一个环境交互能力

616
00:20:06,625 --> 00:20:09,025
它不是只是说一个文文生成技

617
00:20:09,025 --> 00:20:12,605
它具有非常强大的一个自主执行能力

618
00:20:13,025 --> 00:20:16,465
就是我们给了他中端环境的一个控制权

619
00:20:16,465 --> 00:20:18,065
就是他可以几乎

620
00:20:18,065 --> 00:20:20,825
你如果用的是这个bypass模式

621
00:20:20,825 --> 00:20:21,085
是吧

622
00:20:21,085 --> 00:20:22,565
你就把所有的权限交给他

623
00:20:22,565 --> 00:20:24,505
那他就可以做很多事情了

624
00:20:24,505 --> 00:20:26,085
不管是什么编译器啊

625
00:20:26,085 --> 00:20:26,725
调试器啊

626
00:20:26,725 --> 00:20:27,425
报管理器啊

627
00:20:27,425 --> 00:20:27,685
是吧

628
00:20:27,685 --> 00:20:28,445
直接调用

629
00:20:28,445 --> 00:20:30,865
因为他相当于就是超级管理员

630
00:20:30,865 --> 00:20:31,925
他可以做任何事情

631
00:20:31,925 --> 00:20:32,985
并且的话

632
00:20:32,985 --> 00:20:34,465
当代码报错的时候

633
00:20:34,465 --> 00:20:36,005
他会自动的去处理

634
00:20:36,005 --> 00:20:37,665
自动的去读取日志

635
00:20:37,665 --> 00:20:39,725
然后去定位这个原因

636
00:20:39,725 --> 00:20:40,785
并且自动修复

637
00:20:40,785 --> 00:20:41,925
所以说这是

638
00:20:41,925 --> 00:20:43,625
它非常强大的一个能力

639
00:20:43,625 --> 00:20:45,325
就是它发现问题之后

640
00:20:45,325 --> 00:20:46,945
它会自动的去修复问题

641
00:20:46,945 --> 00:20:48,145
所以大家会觉得

642
00:20:48,145 --> 00:20:50,145
目前的AI变成工具非常智能

643
00:20:50,145 --> 00:20:53,145
因为它帮你把所有的问题都解决了

644
00:20:53,145 --> 00:20:54,125
并且是全自动的

645
00:20:54,125 --> 00:20:55,825
不需要你再去提什么问题了

646
00:20:55,825 --> 00:20:57,025
所以这个是一个

647
00:20:57,025 --> 00:20:59,365
非常大的一个优化点

648
00:20:59,365 --> 00:21:00,805
好

649
00:21:00,805 --> 00:21:01,905
所以说大家首先

650
00:21:01,905 --> 00:21:03,285
要对Codex

651
00:21:03,285 --> 00:21:04,985
它的一个工程化设计思想

652
00:21:04,985 --> 00:21:06,225
要有一个认知

653
00:21:06,225 --> 00:21:09,005
那么你掌握了这个

654
00:21:09,005 --> 00:21:11,985
它的一个工程化设计思想之后的话

655
00:21:11,985 --> 00:21:13,825
大家再去

656
00:21:13,825 --> 00:21:15,065
用Codex的话

657
00:21:15,065 --> 00:21:16,805
你就会发现啊

658
00:21:16,805 --> 00:21:17,685
它的一些细节

659
00:21:17,685 --> 00:21:20,805
就会怎么样更好的去使用它

660
00:21:20,805 --> 00:21:22,605
OK