WEBVTT

1
00:00:08.480 --> 00:00:12.840
我是蒂博。

2
00:00:10.560 --> 00:00:14.920
我现在在 OpenAI，负责构建

3
00:00:12.840 --> 00:00:18.080
Codex。

4
00:00:14.920 --> 00:00:19.840
借助 Codex，我们正在打造一名人工智能

5
00:00:18.080 --> 00:00:22.640
软件工程师。

6
00:00:19.840 --> 00:00:25.320
我个人喜欢把它想象成

7
00:00:22.640 --> 00:00:27.080
有点像人类队友。

8
00:00:25.320 --> 00:00:28.400
你可以在电脑上用它进行结对编程

9
00:00:27.080 --> 00:00:31.080
。

10
00:00:28.400 --> 00:00:33.520
你可以委托它处理。 或者，你会

11
00:00:31.080 --> 00:00:37.000
发现，即使没有明确的提示，你也可以给它分配任务

12
00:00:33.520 --> 00:00:37.000
。

13
00:00:37.680 --> 00:00:42.280
最近，

14
00:00:39.800 --> 00:00:44.120
气氛发生了巨大的变化。

15
00:00:42.280 --> 00:00:46.840
这一切始于八月份，当时我们的

16
00:00:44.120 --> 00:00:48.680
用户量相当不错，从那时起，

17
00:00:46.840 --> 00:00:51.720
感谢大家，

18
00:00:48.680 --> 00:00:54.400
我们的用户量增长了十倍。

19
00:00:51.720 --> 00:00:56.800
今天，我想先和大家分享一些

20
00:00:54.400 --> 00:00:58.280
最近发生的、造成

21
00:00:56.800 --> 00:01:00.840
这种氛围转变的更新。

22
00:00:58.280 --> 00:01:03.680
然后，我们将邀请 OpenAI 的一些工程师，

23
00:01:00.840 --> 00:01:06.120
向大家展示我们

24
00:01:03.680 --> 00:01:07.760
日常如何使用 Codex 的一些例子。   他们中的

25
00:01:06.120 --> 00:01:10.440
一些人正在

26
00:01:07.760 --> 00:01:13.280
Codex 团队中工作。 他们当中有些人只是

27
00:01:10.440 --> 00:01:15.080
OpenAI Codex 的忠实用户。

28
00:01:13.280 --> 00:01:17.040
我们先来谈谈其中的一些

29
00:01:15.080 --> 00:01:20.840
更新。

30
00:01:17.040 --> 00:01:23.640
现在，无论您构建什么，Codex 都能正常工作。

31
00:01:20.840 --> 00:01:27.080
无论是在你的 IDE、终端、

32
00:01:23.640 --> 00:01:28.840
GitHub、网页还是移动设备上。

33
00:01:27.080 --> 00:01:31.480
无论你身在何处，其

34
00:01:28.840 --> 00:01:32.680
背后都是同一个强大的引擎

35
00:01:31.480 --> 00:01:34.560
。

36
00:01:32.680 --> 00:01:37.400

37
00:01:34.560 --> 00:01:39.240
我们做出的第一个也是最重要的改进就是彻底改造了

38
00:01:37.400 --> 00:01:41.280
代理程序。

39
00:01:39.240 --> 00:01:42.800
我们认为代理人是

40
00:01:41.280 --> 00:01:45.120
两方面因素的结合体。   其

41
00:01:42.800 --> 00:01:48.040
底层逻辑模型及其

42
00:01:45.120 --> 00:01:50.480
工具链使其能够采取行动并

43
00:01:48.040 --> 00:01:51.840
影响世界，从而

44
00:01:50.480 --> 00:01:53.800
为您创造价值。

45
00:01:51.840 --> 00:01:57.480
首先是模型。

46
00:01:53.800 --> 00:02:00.520
8 月份，我们发布了 GPT-5，这是我们迄今为止最好的

47
00:01:57.480 --> 00:02:02.640
智能体模型。

48
00:02:00.520 --> 00:02:04.080
直到我们听取了你们的

49
00:02:02.640 --> 00:02:06.600
反馈意见，情况才有所改变。

50
00:02:04.080 --> 00:02:10.119
我们通过发布

51
00:02:06.600 --> 00:02:12.160
GPT-5 Codex 来认可它，该模型

52
00:02:10.119 --> 00:02:14.920
针对 Codex 内部的工作进行了进一步优化，

53
00:02:12.160 --> 00:02:17.400
通过变得更智能、更好地

54
00:02:14.920 --> 00:02:19.360
遵循代码风格和调整

55
00:02:17.400 --> 00:02:21.800
思考时间来改进。

56
00:02:19.360 --> 00:02:25.000
我最喜欢的一条

57
00:02:21.800 --> 00:02:27.280
反馈是，它感觉

58
00:02:25.000 --> 00:02:29.960
更像一位真正的

59
00:02:27.280 --> 00:02:33.760
高级工程师的风格，因为它很少

60
00:02:29.960 --> 00:02:36.840
称赞别人。 它还会反驳

61
00:02:33.760 --> 00:02:39.600
错误的想法。

62
00:02:36.840 --> 00:02:42.080
接下来，我们完全重写了线束，

63
00:02:39.600 --> 00:02:45.160
以制作大多数新型号。

64
00:02:42.080 --> 00:02:47.040
添加对规划、MCP、自动

65
00:02:45.160 --> 00:02:48.520
压缩的支持，

66
00:02:47.040 --> 00:02:50.680
以便您可以进行非常长时间的

67
00:02:48.520 --> 00:02:52.360
对话和互动，以及

68
00:02:50.680 --> 00:02:55.400
更多功能。

69
00:02:52.360 --> 00:02:58.280
从那时起，我们开始看到 CLI 的

70
00:02:55.400 --> 00:03:00.760
使用量激增。

71
00:02:58.280 --> 00:03:03.000
但是，还有更多反馈。

72
00:03:00.760 --> 00:03:06.800
这个模型手感非常好。 该代理

73
00:03:03.000 --> 00:03:09.120
很有用，但 CLI 感觉还很早。

74
00:03:06.800 --> 00:03:11.440
我们感谢大家的反馈，因此我们

75
00:03:09.120 --> 00:03:14.680
决定彻底改造 Codex

76
00:03:11.440 --> 00:03:17.840
CLI。 我们简化了审批模式，

77
00:03:14.680 --> 00:03:20.520
创建了更易读的用户界面，并进行了

78
00:03:17.840 --> 00:03:22.800
大量优化。

79
00:03:20.520 --> 00:03:25.560
默认情况下，它采用

80
00:03:22.800 --> 00:03:28.560
沙盒机制，因此默认情况下是安全的，

81
00:03:25.560 --> 00:03:30.160
但您始终拥有控制权。

82
00:03:28.560 --> 00:03:32.760
这项工作一直在进行中，我们

83
00:03:30.160 --> 00:03:36.320
上周五发布了一个重大更新。

84
00:03:32.760 --> 00:03:38.440
我们今天将再次发布新版本。   请

85
00:03:36.320 --> 00:03:40.200
大家继续提供反馈意见。

86
00:03:38.440 --> 00:03:42.560
你们当中有些人与代理人合作，并且想

87
00:03:40.200 --> 00:03:45.480
同时查看代码。

88
00:03:42.560 --> 00:03:48.560
这就是为什么我们直接将其

89
00:03:45.480 --> 00:03:52.640
作为原生扩展程序集成到 IDE 中的原因。

90
00:03:48.560 --> 00:03:54.680
在这里，它可以与你的代码协同工作，让

91
00:03:52.640 --> 00:03:56.920
你能够控制你的

92
00:03:54.680 --> 00:03:59.720
IDE，并获得这个小小的协作工具。 它

93
00:03:56.920 --> 00:04:01.840
在 VS Code、Cursor

94
00:03:59.720 --> 00:04:04.120
和其他流行的分支版本中都能正常运行。

95
00:04:01.840 --> 00:04:06.560
这立刻就流行起来了。

96
00:04:04.120 --> 00:04:08.720
第一周内，我们的用户数量就达到了 10 万

97
00:04:06.560 --> 00:04:11.440
。 我相信，你们当中很多人都在场

98
00:04:08.720 --> 00:04:14.680
。 很多用户更喜欢

99
00:04:11.440 --> 00:04:17.200
直接在 IDE 中使用 Codex。

100
00:04:14.680 --> 00:04:18.600
神奇之处在于，它是

101
00:04:17.200 --> 00:04:21.239
同一种物质。

102
00:04:18.600 --> 00:04:24.200
它与扩展程序中捆绑的 CLI 使用的是同一个开源框架

103
00:04:21.239 --> 00:04:26.360

104
00:04:24.200 --> 00:04:28.840
。

105
00:04:26.360 --> 00:04:30.600
与此同时，我们也在升级

106
00:04:28.840 --> 00:04:31.720
Codex Cloud，

107
00:04:30.600 --> 00:04:33.800
以便

108
00:04:31.720 --> 00:04:35.040
您可以并行运行更多任务

109
00:04:33.800 --> 00:04:37.280
。

110
00:04:35.040 --> 00:04:39.080
对我们来说，这仅仅是个开始，但

111
00:04:37.280 --> 00:04:42.280
我们认为能够

112
00:04:39.080 --> 00:04:45.120
通过手机控制 Codex 是一件非常酷的事情。

113
00:04:42.280 --> 00:04:46.480
云任务运行速度提升了 90%

114
00:04:45.120 --> 00:04:48.720
。 他们可以

115
00:04:46.480 --> 00:04:50.680
自动设置依赖项，并

116
00:04:48.720 --> 00:04:52.440
通过截屏并发

117
00:04:50.680 --> 00:04:54.680
送给您来验证他们的工作。

118
00:04:52.440 --> 00:04:57.240
给特工配备一台电脑，如果真的

119
00:04:54.680 --> 00:04:59.600
有效，感觉就像魔法一样。

120
00:04:57.240 --> 00:05:02.880
然后，你就可以

121
00:04:59.600 --> 00:05:05.080
在 GitHub 等工具中开始使用这样的代理了。

122
00:05:02.880 --> 00:05:07.480
或者现在也可以用Slack。

123
00:05:05.080 --> 00:05:09.680
以下是一位工程师的例子。

124
00:05:07.480 --> 00:05:11.720
你们当中有些人可能认识他。

125
00:05:09.680 --> 00:05:13.680
谁有问题？ 然后另一位

126
00:05:11.720 --> 00:05:16.000
工程师史蒂夫·李立即

127
00:05:13.680 --> 00:05:18.520
接手，并将其委托给了 Codex。 在这里，

128
00:05:16.000 --> 00:05:20.600
Codex 从线程中接收整个上下文

129
00:05:18.520 --> 00:05:22.440
并开始工作。

130
00:05:20.600 --> 00:05:24.680
几分钟后，它发布了

131
00:05:22.440 --> 00:05:26.440
解决方案以及摘要。 它

132
00:05:24.680 --> 00:05:28.880
真的去研究了整个

133
00:05:26.440 --> 00:05:31.120
问题，并编写了一些代码。

134
00:05:28.880 --> 00:05:33.280
所有这些进步意味着我们可以

135
00:05:31.120 --> 00:05:35.520
更快地编写代码，

136
00:05:33.280 --> 00:05:38.480
这也意味着我们需要

137
00:05:35.520 --> 00:05:40.680
共同审查大量的代码。

138
00:05:38.480 --> 00:05:43.120
代码验证和审查现在正

139
00:05:40.680 --> 00:05:44.720
成为一个巨大的瓶颈。

140
00:05:43.120 --> 00:05:46.720
这个问题我们已经考虑

141
00:05:44.720 --> 00:05:48.800
很久了。

142
00:05:46.720 --> 00:05:51.120

143
00:05:48.800 --> 00:05:53.560
OpenAI 过去在代码审查方面的实验表明，代码审查可能

144
00:05:51.120 --> 00:05:56.560
很有用，但也常常会产生噪音。

145
00:05:53.560 --> 00:05:58.800
之前的尝试

146
00:05:56.560 --> 00:06:00.520
由于用户抱怨

147
00:05:58.800 --> 00:06:03.800
信号不好而被取消。

148
00:06:00.520 --> 00:06:07.520
因此，我们特意训练 GPT-5 Codex 使其

149
00:06:03.800 --> 00:06:09.320
擅长进行极其彻底的代码审查。

150
00:06:07.520 --> 00:06:10.680
它会深入分析依赖关系，

151
00:06:09.320 --> 00:06:11.880
深入分析容器内的所有代码

152
00:06:10.680 --> 00:06:14.960
，

153
00:06:11.880 --> 00:06:17.320
真正探究你的

154
00:06:14.960 --> 00:06:19.000
意图与实际

155
00:06:17.320 --> 00:06:20.680
实现之间的联系，

156
00:06:19.000 --> 00:06:23.240
然后得出高质量的

157
00:06:20.680 --> 00:06:25.480
结论。 我们现在发现，许多团队

158
00:06:23.240 --> 00:06:28.920
决定默认启用它，并且

159
00:06:25.480 --> 00:06:31.600
几乎都希望将其设为强制性，

160
00:06:28.920 --> 00:06:33.200
因为它每次都能发现如此高的信号

161
00:06:31.600 --> 00:06:34.600
。

162
00:06:33.200 --> 00:06:37.200
您可以在与 Codex 结对编程时触发它

163
00:06:34.600 --> 00:06:40.720
，或者您可以

164
00:06:37.200 --> 00:06:41.840
通过在 GitHub 中的每个 PR 上运行它来完全自动化它。

165
00:06:40.720 --> 00:06:44.760
好的。

166
00:06:41.840 --> 00:06:46.160
对于这支规模虽小但正在不断

167
00:06:44.760 --> 00:06:48.840
壮大的团队来说，过去的几个月非常忙碌。

168
00:06:46.160 --> 00:06:50.440
我们一直使用 Codex 来构建 Codex。   如果

169
00:06:48.840 --> 00:06:52.560

170
00:06:50.440 --> 00:06:56.200
没有它，我们根本不可能完成这件事。

171
00:06:52.560 --> 00:06:59.200
更令人兴奋的是，我们看到 OpenAI

172
00:06:56.200 --> 00:07:00.280
整体发展速度加快。

173
00:06:59.200 --> 00:07:02.000
如今，

174
00:07:00.280 --> 00:07:04.480
 

175
00:07:02.000 --> 00:07:07.120
OpenAI 92% 的技术人员几乎

176
00:07:04.480 --> 00:07:10.800
每天都在使用 Codex。

177
00:07:07.120 --> 00:07:13.280
比去年7月左右的50%有所上升。

178
00:07:10.800 --> 00:07:16.240
使用 Codex 的工程师每周提交的 PR 数量多 70%

179
00:07:13.280 --> 00:07:18.360
。

180
00:07:16.240 --> 00:07:20.360
几乎所有 PR 都会经过

181
00:07:18.360 --> 00:07:21.880
Codex 审核。

182
00:07:20.360 --> 00:07:25.200
当它发现问题时，人们

183
00:07:21.880 --> 00:07:27.640
反而会感到兴奋。 它能节省你的时间。 您

184
00:07:25.200 --> 00:07:29.560
发货时更有信心。   最

185
00:07:27.640 --> 00:07:32.840
糟糕的情况莫过于在

186
00:07:29.560 --> 00:07:35.160
功能发布后才发现bug。

187
00:07:32.840 --> 00:07:37.920
当我们全队看到统计数据时，

188
00:07:35.160 --> 00:07:40.080
感觉棒极了。 但更好的情况是，

189
00:07:37.920 --> 00:07:42.960
和某人一起吃午饭时，对方会说：

190
00:07:40.080 --> 00:07:45.560
“嘿，我经常使用 Codex

191
00:07:42.960 --> 00:07:48.280
。我用它做了一件很酷的事情

192
00:07:45.560 --> 00:07:49.760
。你想听听吗？”

193
00:07:48.280 --> 00:07:51.440
所以我们希望让你们体验一下

194
00:07:49.760 --> 00:07:53.360
。

195
00:07:51.440 --> 00:07:54.920
那么，让我们和几位队友一起吃午饭，

196
00:07:53.360 --> 00:07:56.720
 

197
00:07:54.920 --> 00:07:59.360
听听他们的故事吧。 他们会向

198
00:07:56.720 --> 00:08:01.240
您展示我们团队的实际工作流程，以及

199
00:07:59.360 --> 00:08:03.600
他们每天如何使用它。

200
00:08:01.240 --> 00:08:06.320
请Nacho上台，

201
00:08:03.600 --> 00:08:09.270
谈谈

202
00:08:06.320 --> 00:08:12.360
ChatGPT iOS应用程序的UI迭代。

203
00:08:09.270 --> 00:08:15.000
[掌声]

204
00:08:12.360 --> 00:08:15.000
谢谢你，蒂博。

205
00:08:15.120 --> 00:08:20.960
你好。 我的名字是纳乔·索托。 我是

206
00:08:17.240 --> 00:08:22.800
OpenAI 核心 iOS 团队的成员。

207
00:08:20.960 --> 00:08:24.360
今天打算做两件事。 我将向

208
00:08:22.800 --> 00:08:26.240
你介绍我

209
00:08:24.360 --> 00:08:28.320
在构建 ChatGPT

210
00:08:26.240 --> 00:08:30.120
应用时经常使用的一种工作流程。 我想分享一个演示，向

211
00:08:28.320 --> 00:08:32.840
大家展示我是如何做到这一点的。

212
00:08:30.120 --> 00:08:32.840
我们先来看演示。

213
00:08:34.440 --> 00:08:38.719
Thibaud让我开发一个天气应用程序。

214
00:08:36.760 --> 00:08:41.560
所以，我有一个初始项目，只有

215
00:08:38.719 --> 00:08:41.560
一个空白窗口。

216
00:08:42.039 --> 00:08:45.960
我还请 ChatGPT 制作一个

217
00:08:44.200 --> 00:08:48.320
我想要的 UI 界面的模型

218
00:08:45.960 --> 00:08:48.320
。

219
00:08:48.360 --> 00:08:53.960
所以，我打算请 Codex

220
00:08:50.920 --> 00:08:53.960
来实现这个设计。

221
00:08:57.000 --> 00:09:01.160
伟大的。 趁着这个机会，让我来告诉

222
00:08:59.000 --> 00:09:03.720
你 Codex 将如何

223
00:09:01.160 --> 00:09:05.840
实现这一点的特别之处。

224
00:09:03.720 --> 00:09:07.880
在 ChatGPT 核心团队工作意味着我

225
00:09:05.840 --> 00:09:09.920
花很多时间在基础设施和

226
00:09:07.880 --> 00:09:12.080
性能方面，但也做一些

227
00:09:09.920 --> 00:09:14.160
前端工作。

228
00:09:12.080 --> 00:09:16.040
最近，我参与了一个小功能开发，

229
00:09:14.160 --> 00:09:18.160
简化了我们的个性化

230
00:09:16.040 --> 00:09:21.440
界面，使我们新的 ChatGPT

231
00:09:18.160 --> 00:09:22.640
角色更容易被发现。

232
00:09:21.440 --> 00:09:25.200
我相信你

233
00:09:22.640 --> 00:09:27.760
以前也遇到过类似的情况。 最后那 10% 的

234
00:09:25.200 --> 00:09:29.960
润色工作，比如调整页眉和

235
00:09:27.760 --> 00:09:32.640
页脚的位置，实际上要花费

236
00:09:29.960 --> 00:09:35.440
90% 的时间。

237
00:09:32.640 --> 00:09:37.000
但 Codex 可以帮你解决那 10% 的问题。

238
00:09:35.440 --> 00:09:38.800
你可以在做其他事情的同时完成这项工作

239
00:09:37.000 --> 00:09:41.480
。 或许你还在观看其他一些

240
00:09:38.800 --> 00:09:43.400
开发者日演讲。

241
00:09:41.480 --> 00:09:45.120

242
00:09:43.400 --> 00:09:48.600
如果你想成为一名

243
00:09:45.120 --> 00:09:48.600
真正的 10 倍工程师，你甚至可以同时运行九个其他终端标签页来运行 Codex。

244
00:09:50.040 --> 00:09:54.360
这里谁收到过

245
00:09:52.280 --> 00:09:55.880
初级工程师发来的拉取请求，然后在几秒钟之内就

246
00:09:54.360 --> 00:09:57.640
发现他们

247
00:09:55.880 --> 00:10:00.240
根本没测试过，因为

248
00:09:57.640 --> 00:10:00.240
这根本不可能运行？

249
00:10:00.720 --> 00:10:05.720
如果你在 6 个月前使用过 ChatGPT 或任何其他代理

250
00:10:03.600 --> 00:10:07.560
，那么你当时就是和那位

251
00:10:05.720 --> 00:10:10.440
初级工程师对接的。

252
00:10:07.560 --> 00:10:12.760
但《法典》并非如此。

253
00:10:10.440 --> 00:10:15.360
正如 Tevo 所说，我认为 Codex

254
00:10:12.760 --> 00:10:17.040
现在是一名高级工程师。

255
00:10:15.360 --> 00:10:19.640
它不会只是编写代码然后就

256
00:10:17.040 --> 00:10:21.560
想当然地认为它能正常运行。 它会验证这一点

257
00:10:19.640 --> 00:10:23.960
。

258
00:10:21.560 --> 00:10:26.880
我非常喜欢TDD（测试驱动

259
00:10:23.960 --> 00:10:29.200
开发）。 我认为 Codex 在

260
00:10:26.880 --> 00:10:31.560
这种工作流程下发展得非常顺利。

261
00:10:29.200 --> 00:10:33.600
它会运行你的测试，修复代码，然后

262
00:10:31.560 --> 00:10:36.160
再次运行测试，如此反复，

263
00:10:33.600 --> 00:10:39.000
直到测试通过为止。

264
00:10:36.160 --> 00:10:41.880
但为什么只做单​​元测试呢？

265
00:10:39.000 --> 00:10:46.160
Codex 是多模态的，这意味着它还可以通过

266
00:10:41.880 --> 00:10:48.000
视觉方式验证其工作。

267
00:10:46.160 --> 00:10:51.440
几周前，我们赋予了 Codex 能够

268
00:10:48.000 --> 00:10:53.320
看到图像的超能力。

269
00:10:51.440 --> 00:10:56.760
所以我教它

270
00:10:53.320 --> 00:10:58.120
为它编写的 UI 代码生成快照。

271
00:10:56.760 --> 00:10:59.440
最棒的是，它其实非常

272
00:10:58.120 --> 00:11:00.680
简单。

273
00:10:59.440 --> 00:11:02.839
首先，

274
00:11:00.680 --> 00:11:05.160
我创建了这个非常简单的 Makefile，它可以

275
00:11:02.839 --> 00:11:07.200
运行单元测试来提取

276
00:11:05.160 --> 00:11:09.480
SwiftUI 预览。

277
00:11:07.200 --> 00:11:11.960
这会调用一个小型 Python 脚本，

278
00:11:09.480 --> 00:11:13.680
顺便说一句，这个脚本是 Codex 编写的。

279
00:11:11.960 --> 00:11:17.120
这样就能提取这些图像，并将

280
00:11:13.680 --> 00:11:19.720
它们放入一个文件夹中，以便 Codex 可以找到它们。

281
00:11:17.120 --> 00:11:21.720
然后我在 agents.md 文件中告诉了 Codex

282
00:11:19.720 --> 00:11:25.360
这个脚本，并要求它

283
00:11:21.720 --> 00:11:26.880
使用该脚本来验证其功能。

284
00:11:25.360 --> 00:11:29.600
我们使用这种工作流程来构建

285
00:11:26.880 --> 00:11:32.040
ChatGPT iOS 和 Mac 应用。

286
00:11:29.600 --> 00:11:35.360
例如，您可以使用 Storybook 或 Playwright 等工具在网络上执行相同的操作

287
00:11:32.040 --> 00:11:37.200
。   这

288
00:11:35.360 --> 00:11:39.480
就是我的工作流程。 我给 Codex 提供了

289
00:11:37.200 --> 00:11:42.560
一些生成屏幕截图的工具，以便我们

290
00:11:39.480 --> 00:11:43.960
能够验证它编写的 UI 代码。

291
00:11:42.560 --> 00:11:46.240
我们来看看Codex的

292
00:11:43.960 --> 00:11:46.240
进展如何。

293
00:11:47.880 --> 00:11:52.680
好的，如果我往回滚动，

294
00:11:51.000 --> 00:11:54.160
看起来它写了一些代码，首先制定了

295
00:11:52.680 --> 00:11:57.360
一个计划，

296
00:11:54.160 --> 00:12:00.120
即审查现有代码，

297
00:11:57.360 --> 00:12:03.600
实现用户界面，并提供预览

298
00:12:00.120 --> 00:12:04.720
数据来验证其是否良好。 太好了

299
00:12:03.600 --> 00:12:08.720
，看起来它已经编写了所有

300
00:12:04.720 --> 00:12:10.640
代码，并运行了快照测试。

301
00:12:08.720 --> 00:12:12.640
凉爽的。 所以，呃，

302
00:12:10.640 --> 00:12:15.680
不，我想不行，但是，请花3分钟时间

303
00:12:12.640 --> 00:12:15.680
运行一下。

304
00:12:18.880 --> 00:12:22.160
凉爽的。

305
00:12:20.960 --> 00:12:24.520
显然，这是一个非常简单的

306
00:12:22.160 --> 00:12:27.040
例子，但实际上，它可以根据需要进行

307
00:12:24.520 --> 00:12:28.880
多次更改，以匹配

308
00:12:27.040 --> 00:12:30.839
像 ChatGPT 应用程序这样的大型项目。   根据

309
00:12:28.880 --> 00:12:33.560

310
00:12:30.839 --> 00:12:36.560
任务的不同，它可以运行数小时，一遍又一遍地迭代，

311
00:12:33.560 --> 00:12:38.320
直到达到像素级的完美效果。

312
00:12:36.560 --> 00:12:40.200
说到长时间工作，

313
00:12:38.320 --> 00:12:42.200
我想把这个话题交给 Freal，他

314
00:12:40.200 --> 00:12:44.400
将向我们展示如何扩展这些

315
00:12:42.200 --> 00:12:46.200
验证循环，使其运行更

316
00:12:44.400 --> 00:12:47.200
长时间，并处理更复杂的

317
00:12:46.200 --> 00:12:48.460
问题。

318
00:12:47.200 --> 00:12:53.160
谢谢。

319
00:12:48.460 --> 00:12:54.480
[掌声]

320
00:12:53.160 --> 00:12:56.120
谢谢你，纳乔。

321
00:12:54.480 --> 00:12:57.960
我是 Freal，我的工作是提高开发者的

322
00:12:56.120 --> 00:13:00.880
生产力。

323
00:12:57.960 --> 00:13:03.160
在 OpenAI，我为

324
00:13:00.880 --> 00:13:04.280
最长会话或最多

325
00:13:03.160 --> 00:13:05.520
生成的令牌设定了高分。

326
00:13:04.280 --> 00:13:07.080
我就是那个能让 Codex

327
00:13:05.520 --> 00:13:09.120
做这件事的人。

328
00:13:07.080 --> 00:13:11.960
因为它能够使用 Codex 一次性实现

329
00:13:09.120 --> 00:13:13.640
大型功能和复杂的代码更改。

330
00:13:11.960 --> 00:13:15.800
我亲眼见过 GPT-5 Codex 模型

331
00:13:13.640 --> 00:13:18.480
高效运行超过 7 个小时。 这就是我的

332
00:13:15.800 --> 00:13:20.200
提示。 或者在马拉松式的会话中处理超过 1.5 亿个

333
00:13:18.480 --> 00:13:22.720
代币

334
00:13:20.200 --> 00:13:22.720
。

335
00:13:23.520 --> 00:13:27.920
这是其中一个项目。

336
00:13:25.480 --> 00:13:31.040
这是一个复杂的重构，是

337
00:13:27.920 --> 00:13:33.240
我个人 JSON 解析器项目的一项主要功能。

338
00:13:31.040 --> 00:13:34.960
对于像这样的大型项目，

339
00:13:33.240 --> 00:13:36.320
可能会出现很长一段时间，

340
00:13:34.960 --> 00:13:38.040

341
00:13:36.320 --> 00:13:39.720
所有测试似乎都失败了，直到

342
00:13:38.040 --> 00:13:41.920
工作完成为止，尤其是

343
00:13:39.720 --> 00:13:43.320
在进行核心更改时。

344
00:13:41.920 --> 00:13:44.960
这是一个专为

345
00:13:43.320 --> 00:13:47.160
流式工具调用而构建的 JSON 解析器，

346
00:13:44.960 --> 00:13:49.760
一个面向人工智能时代的解析器。

347
00:13:47.160 --> 00:13:51.240
这个人提交的这个 PR

348
00:13:49.760 --> 00:13:52.960
修改了超过 15,000 行代码，这是他花了

349
00:13:51.240 --> 00:13:54.080
几个小时从

350
00:13:52.960 --> 00:13:56.360
Codex 上学习而来的，

351
00:13:54.080 --> 00:13:57.960
而我只花了短短几分钟，只给了他一些

352
00:13:56.360 --> 00:13:59.880
提示。

353
00:13:57.960 --> 00:14:02.200
让我们一起来看看我是如何从提出问题

354
00:13:59.880 --> 00:14:04.120
到提交拉取请求的。

355
00:14:02.200 --> 00:14:06.360
我们只需几个提示就能完成。

356
00:14:04.120 --> 00:14:09.200
首先，我们会告诉 Codex，我们希望他们

357
00:14:06.360 --> 00:14:11.200
制定一个实现我们功能的计划。

358
00:14:09.200 --> 00:14:14.040
然后，我们将审查该计划

359
00:14:11.200 --> 00:14:16.480
并指示其执行。 最后，我们开始

360
00:14:14.040 --> 00:14:16.480
发货。   在

361
00:14:18.920 --> 00:14:23.560
这里，我已经用 VS Code 打开了我的项目，

362
00:14:21.520 --> 00:14:25.160
我也会打开我们的 Codex 扩展

363
00:14:23.560 --> 00:14:26.800
。

364
00:14:25.160 --> 00:14:28.200
嗯，我有一个相当复杂的功能

365
00:14:26.800 --> 00:14:29.760
想要实现，我已经把

366
00:14:28.200 --> 00:14:31.240
它写成文档，方便我自己

367
00:14:29.760 --> 00:14:32.920
阅读。

368
00:14:31.240 --> 00:14:34.560
我打算告诉 Codex，我希望它

369
00:14:32.920 --> 00:14:36.440
制定一个实现此

370
00:14:34.560 --> 00:14:37.640
功能的计划，我已经描述了最终

371
00:14:36.440 --> 00:14:39.600
状态。

372
00:14:37.640 --> 00:14:41.880
但我希望 Codex 能帮我完成繁重的工作，

373
00:14:39.600 --> 00:14:44.600
研究如何将此

374
00:14:41.880 --> 00:14:46.959
库集成到我的解析器中。

375
00:14:44.600 --> 00:14:48.240
所以我的做法是请 Codex 编写一份

376
00:14:46.959 --> 00:14:49.520
规范。   接下来，

377
00:14:48.240 --> 00:14:51.200
我将正式开始

378
00:14:49.520 --> 00:14:53.079
。

379
00:14:51.200 --> 00:14:55.480
实际上，我打算在这里关闭自动

380
00:14:53.079 --> 00:14:57.520
上下文功能。 顺便提一下，

381
00:14:55.480 --> 00:15:00.240
我已经演练过几次了，

382
00:14:57.520 --> 00:15:02.480
实际上它从

383
00:15:00.240 --> 00:15:05.000
我的 Git 历史记录中找到了完整的规范，然后作弊并直接复制粘贴

384
00:15:02.480 --> 00:15:07.120
到了流程的最后。

385
00:15:05.000 --> 00:15:09.000
所以，我要让它真正发挥

386
00:15:07.120 --> 00:15:10.440
作用。

387
00:15:09.000 --> 00:15:11.720

388
00:15:10.440 --> 00:15:13.839
你会注意到我不需要

389
00:15:11.720 --> 00:15:15.680
多费口舌。 我已经给了它我的例子，我告诉

390
00:15:13.839 --> 00:15:17.079
它去做一些研究，并

391
00:15:15.680 --> 00:15:19.760
按照我已有的代码示例进行操作

392
00:15:17.079 --> 00:15:19.760
。

393
00:15:20.959 --> 00:15:23.800
所以，

394
00:15:22.440 --> 00:15:27.520
趁着这个方法奏效，让我来向你解释一下

395
00:15:23.800 --> 00:15:29.959
我所说的计划或执行规范是什么意思。

396
00:15:27.520 --> 00:15:31.400
这是我的 plans.md 文件。 我在

397
00:15:29.959 --> 00:15:34.320
这里都做了缩写，这样我们就不用

398
00:15:31.400 --> 00:15:36.480
全部阅读了。 一共160行。

399
00:15:34.320 --> 00:15:38.959
呃，但实际上我在这里做的是

400
00:15:36.480 --> 00:15:40.360
为设计文档编写设计

401
00:15:38.959 --> 00:15:41.920
文档。

402
00:15:40.360 --> 00:15:43.760
Codex 现在毕竟是一名高级工程师，

403
00:15:41.920 --> 00:15:46.320
所以我们也应该要求它

404
00:15:43.760 --> 00:15:48.920
自己完成一些文书工作。

405
00:15:46.320 --> 00:15:50.839
就像大多数工程师编写设计

406
00:15:48.920 --> 00:15:54.200
文档一样，他会从复制

407
00:15:50.839 --> 00:15:55.480
示例开始。 我这里有一个。

408
00:15:54.200 --> 00:15:57.560
我告诉

409
00:15:55.480 --> 00:15:59.360
大家，这个计划将会

410
00:15:57.560 --> 00:16:01.560
是一份动态文件。 它将

411
00:15:59.360 --> 00:16:03.200
描述其整体情况。 它

412
00:16:01.560 --> 00:16:04.920
会有一个待办事项清单，并

413
00:16:03.200 --> 00:16:07.000
持续更新进度信息。

414
00:16:04.920 --> 00:16:09.320
我还想问，

415
00:16:07.000 --> 00:16:11.000
为什么我一直说执行计划？

416
00:16:09.320 --> 00:16:13.560
我这样做是因为我想

417
00:16:11.000 --> 00:16:16.680
给模型一个可以作为锚点的术语，并且

418
00:16:13.560 --> 00:16:19.680
知道当我使用“执行计划”这个术语时，要

419
00:16:16.680 --> 00:16:21.400
使用 plans.md 来设计它，对其进行迭代

420
00:16:19.680 --> 00:16:22.800
，并进行后续跟进。

421
00:16:21.400 --> 00:16:24.560
最好给它取一个

422
00:16:22.800 --> 00:16:26.480
独特的名称，这样它就知道要记住这个名称

423
00:16:24.560 --> 00:16:28.200
。 我说这话的时候，指的是它很

424
00:16:26.480 --> 00:16:31.000
特别，它不仅仅是一份设计

425
00:16:28.200 --> 00:16:32.120
文档或实现规范。

426
00:16:31.000 --> 00:16:34.360
所以，

427
00:16:32.120 --> 00:16:35.959
在这份规范中，我们记录了我们的进展、

428
00:16:34.360 --> 00:16:37.320
惊喜和发现。

429
00:16:35.959 --> 00:16:39.839
这里甚至还有一个决策日志，方便我

430
00:16:37.320 --> 00:16:40.720
跟踪它一直在做什么。

431
00:16:39.839 --> 00:16:42.839
 

432
00:16:40.720 --> 00:16:44.600
通常情况下，我不会要求工程师写这么多东西

433
00:16:42.839 --> 00:16:46.020
。 我只有在

434
00:16:44.600 --> 00:16:47.720
不太喜欢他们的项目时才会那样做。

435
00:16:46.020 --> 00:16:50.560
[笑声]

436
00:16:47.720 --> 00:16:52.560
但在这种情况下，这有助于 Codex

437
00:16:50.560 --> 00:16:56.120
完成项目。 这是它在

438
00:16:52.560 --> 00:16:58.520
执行这项宏伟计划时所积累的记忆。

439
00:16:56.120 --> 00:17:01.120
演讲结束后，我们将把

440
00:16:58.520 --> 00:17:02.880
plans.md 配方上传到我们的 OpenAI cookbooks 中，

441
00:17:01.120 --> 00:17:05.360
以便你们中的任何人都可以在自己的代码库中采用它

442
00:17:02.880 --> 00:17:06.480
。

443
00:17:05.360 --> 00:17:07.839
那么，

444
00:17:06.480 --> 00:17:10.720
它是如何知道

445
00:17:07.839 --> 00:17:12.280
如何使用 plans.md 文件的呢？ 正如我

446
00:17:10.720 --> 00:17:14.360
之前提到的，

447
00:17:12.280 --> 00:17:16.120
我使用了我的 agents.md 文件。

448
00:17:14.360 --> 00:17:18.839
我在 agents.md 文件中添加了几行代码

449
00:17:16.120 --> 00:17:20.760
，只是一些简单的说明。 当

450
00:17:18.839 --> 00:17:22.600
你处理复杂的事情时，

451
00:17:20.760 --> 00:17:24.199
这就是执行计划的作用，请参考

452
00:17:22.600 --> 00:17:26.400
plans.md 文件，

453
00:17:24.199 --> 00:17:28.240
确保你遵循该计划。

454
00:17:26.400 --> 00:17:30.360
现在，正如你所看到的，它

455
00:17:28.240 --> 00:17:31.720
在这里进行了很多额外的研究，所以

456
00:17:30.360 --> 00:17:34.200
让我们来看看一个完整的

457
00:17:31.720 --> 00:17:34.200
规格说明。

458
00:17:34.360 --> 00:17:39.960
所以，我已经切换到一个已完成的

459
00:17:36.400 --> 00:17:43.360
会话，并且已经写好了我的规范。

460
00:17:39.960 --> 00:17:43.360
让我在这里详细说明一下这个计划。

461
00:17:43.480 --> 00:17:46.160
所以，

462
00:17:44.840 --> 00:17:48.640
我可以审核一下。 我可以给出

463
00:17:46.160 --> 00:17:50.440
反馈。 我可以看看，好吧，这看起来

464
00:17:48.640 --> 00:17:51.760

465
00:17:50.440 --> 00:17:54.840
好像有很多字，但这正是我

466
00:17:51.760 --> 00:17:56.400
想要做的，而且它有一个计划。

467
00:17:54.840 --> 00:17:58.080
看起来像是几个峰值，一些

468
00:17:56.400 --> 00:18:00.360
它想要实现的功能，

469
00:17:58.080 --> 00:18:01.600
当然还有文档。 我觉得这样

470
00:18:00.360 --> 00:18:02.679
挺好。 我打算

471
00:18:01.600 --> 00:18:05.040
告诉

472
00:18:02.679 --> 00:18:06.880
Codex，我们开始

473
00:18:05.040 --> 00:18:09.920

474
00:18:06.880 --> 00:18:09.920
实施吧。

475
00:18:10.840 --> 00:18:14.640
我们今天不能打字。 好了。

476
00:18:13.520 --> 00:18:17.080
 

477
00:18:14.640 --> 00:18:19.080
所以，在它运行期间，呃，我喜欢

478
00:18:17.080 --> 00:18:20.720
关注 Codex。

479
00:18:19.080 --> 00:18:23.760
我的屏幕上一直有东西在滚动。 我的经理知道

480
00:18:20.720 --> 00:18:23.760
我还在工作。

481
00:18:23.880 --> 00:18:28.640
我喜欢看测试赛。 所以，接下来

482
00:18:27.159 --> 00:18:31.000
我将启动这些

483
00:18:28.640 --> 00:18:32.000
测试。 他们跑得很快。

484
00:18:31.000 --> 00:18:34.280
顺便说一句，Codex 帮助我编写了所有这些测试，

485
00:18:32.000 --> 00:18:36.520
从简单的属性测试或

486
00:18:34.280 --> 00:18:38.040
简单的单元测试到详尽的

487
00:18:36.520 --> 00:18:39.720
属性测试。

488
00:18:38.040 --> 00:18:42.840
这个箱子里甚至还有一些绒毛。

489
00:18:39.720 --> 00:18:45.200
所以，我会密切关注这件事，

490
00:18:42.840 --> 00:18:46.679
如果它长时间保持红色，我可能会

491
00:18:45.200 --> 00:18:48.520
介入并说，你知道，Codex，

492
00:18:46.679 --> 00:18:51.919
也许我们需要退出。 或许这个

493
00:18:48.520 --> 00:18:54.360
计划有点偏离轨道了。

494
00:18:51.919 --> 00:18:57.320
好的，我们来看看

495
00:18:54.360 --> 00:18:59.360
这个项目完成了哪些工作。 所以，

496
00:18:57.320 --> 00:19:01.080
我已经

497
00:18:59.360 --> 00:19:03.480
完成了那项任务，直接跳到 Codex 部分。 顺便说一下，我

498
00:19:01.080 --> 00:19:04.840
上次讲这个花了超过一个小时

499
00:19:03.480 --> 00:19:06.919
，所以我们这次要跳过很多

500
00:19:04.840 --> 00:19:08.480
内容。 而且它似乎还编写了

501
00:19:06.919 --> 00:19:10.800
一些新的测试用例。

502
00:19:08.480 --> 00:19:11.640
嗯，他们都通过了，这太好了。

503
00:19:10.800 --> 00:19:13.120
嗯，我们接下来看看有哪些

504
00:19:11.640 --> 00:19:14.600
变化。

505
00:19:13.120 --> 00:19:16.840
好的。

506
00:19:14.600 --> 00:19:19.480
哇，看起来它似乎引入了

507
00:19:16.840 --> 00:19:21.240

508
00:19:19.480 --> 00:19:23.400
上游库，甚至可能对其进行了分支或更新，以进行一些更改来

509
00:19:21.240 --> 00:19:24.280
实现它需要做的事情。

510
00:19:23.400 --> 00:19:26.120
现在，

511
00:19:24.280 --> 00:19:27.640
我又没有一整天的时间把这些都读

512
00:19:26.120 --> 00:19:30.600
给你听，所以我打算

513
00:19:27.640 --> 00:19:33.000
再次打开计划。

514
00:19:30.600 --> 00:19:35.040
于是，我打开计划，可以看到

515
00:19:33.000 --> 00:19:37.560
进度条上已经勾选了一些重要

516
00:19:35.040 --> 00:19:38.960
项目。 它完成了一些尖峰。

517
00:19:37.560 --> 00:19:40.440

518
00:19:38.960 --> 00:19:42.320
README 文件中有更新的文档。

519
00:19:40.440 --> 00:19:44.200
Plans.md 明确规定所有这些

520
00:19:42.320 --> 00:19:45.600
计划都必须是一个动态文件，

521
00:19:44.200 --> 00:19:48.159
因此我可以将其用作执行

522
00:19:45.600 --> 00:19:49.360
摘要，了解计划已完成的内容。

523
00:19:48.159 --> 00:19:52.120
这样我就不用自己阅读所有

524
00:19:49.360 --> 00:19:52.120
代码了。

525
00:19:54.400 --> 00:19:57.640
好的。

526
00:19:55.600 --> 00:19:59.040
看起来已经完成了，测试也

527
00:19:57.640 --> 00:20:00.080
通过了。

528
00:19:59.040 --> 00:20:01.240
所以，

529
00:20:00.080 --> 00:20:03.400
 

530
00:20:01.240 --> 00:20:04.560
我今天向大家展示的是，我们可以

531
00:20:03.400 --> 00:20:05.160
从一个简单的

532
00:20:04.560 --> 00:20:07.360
 

533
00:20:05.160 --> 00:20:11.680
实现想法、

534
00:20:07.360 --> 00:20:14.480
一个功能提示，到提交一个 PR，只需要几个步骤。

535
00:20:11.680 --> 00:20:15.720
严密的计划和彻底的测试

536
00:20:14.480 --> 00:20:17.600
使得该模型能够在这一

537
00:20:15.720 --> 00:20:19.000
功能上持续运行一段时间。

538
00:20:17.600 --> 00:20:21.720
我们来看看

539
00:20:19.000 --> 00:20:21.720
它写了多少行代码。

540
00:20:28.800 --> 00:20:31.880
崩溃了。

541
00:20:30.440 --> 00:20:32.880
好的。

542
00:20:31.880 --> 00:20:36.240
好的。

543
00:20:32.880 --> 00:20:37.600
4200 行代码，大约

544
00:20:36.240 --> 00:20:38.840
耗时一个小时。

545
00:20:37.600 --> 00:20:39.720
极好的。

546
00:20:38.840 --> 00:20:41.440
现在，

547
00:20:39.720 --> 00:20:42.760
我可以直接合并这段代码，但我

548
00:20:41.440 --> 00:20:44.440
真的希望有其他人能看一下

549
00:20:42.760 --> 00:20:45.920
。

550
00:20:44.440 --> 00:20:48.920
幸好，接下来由丹尼尔来

551
00:20:45.920 --> 00:20:48.920
谈谈代码审查。

552
00:20:54.400 --> 00:20:56.880
你好。

553
00:21:03.880 --> 00:21:09.240
好的，我叫丹尼尔，我是

554
00:21:05.960 --> 00:21:13.160
Codex 团队的一名工程师。

555
00:21:09.240 --> 00:21:15.000
今天我想谈谈代码审查。

556
00:21:13.160 --> 00:21:16.680
正如 Thibault 所提到的，我们

557
00:21:15.000 --> 00:21:19.320
几个月前在 GitHub 上推出了代码审查功能，

558
00:21:16.680 --> 00:21:20.040
并且取得了巨大的成功。

559
00:21:19.320 --> 00:21:21.720
嗯，

560
00:21:20.040 --> 00:21:24.120
无论是外部审查，还是

561
00:21:21.720 --> 00:21:26.640
内部审查，我们都非常喜欢。 我们在

562
00:21:24.120 --> 00:21:28.320
所有 PR 中都运行了这些工具，

563
00:21:26.640 --> 00:21:30.720
它们发现了很多我们

564
00:21:28.320 --> 00:21:33.320
原本会错过的错误。 有些

565
00:21:30.720 --> 00:21:35.320
漏洞非常复杂，你甚至需要

566
00:21:33.320 --> 00:21:36.880
反复阅读注释好

567
00:21:35.320 --> 00:21:39.120
几遍才能理解

568
00:21:36.880 --> 00:21:41.240
它到底在说什么。 因此，我强烈

569
00:21:39.120 --> 00:21:42.960
建议您为

570
00:21:41.240 --> 00:21:44.360
所有 GitHub PR 启用代码审查。

571
00:21:42.960 --> 00:21:46.760
嗯，

572
00:21:44.360 --> 00:21:48.760
这是我提交到 Codex 仓库的一个 PR 的例子

573
00:21:46.760 --> 00:21:49.680
。 它是

574
00:21:48.760 --> 00:21:50.960
开源的。

575
00:21:49.680 --> 00:21:52.320
所以，

576
00:21:50.960 --> 00:21:54.320
我

577
00:21:52.320 --> 00:21:57.880
提交了一个功能，然后

578
00:21:54.320 --> 00:22:00.760
Codex 立即开始审查我的代码，并

579
00:21:57.880 --> 00:22:02.960
发现了一个 P1 问题。 伟大的。

580
00:22:00.760 --> 00:22:04.880
呃，然后我说：“谢谢，Codex。

581
00:22:02.960 --> 00:22:07.560
请修复它。” 于是，后台启动了一个

582
00:22:04.880 --> 00:22:09.840
任务来进行

583
00:22:07.560 --> 00:22:12.120
更改。 然后，合并完成后，我

584
00:22:09.840 --> 00:22:13.840
说：“好了，Codex，

585
00:22:12.120 --> 00:22:15.400
现在你们有了这些，

586
00:22:13.840 --> 00:22:18.080
有了这些更改，再审查一遍。

587
00:22:15.400 --> 00:22:20.560
确保我们没有任何问题。”

588
00:22:18.080 --> 00:22:23.480
然后它又发现了另一个问题。

589
00:22:20.560 --> 00:22:25.920
然后，呃，我就觉得很尴尬。

590
00:22:23.480 --> 00:22:28.080
 

591
00:22:25.920 --> 00:22:30.560
这让我开始思考。

592
00:22:28.080 --> 00:22:32.280
如果有一种工作流程，你可以先

593
00:22:30.560 --> 00:22:34.040
创建一个功能，

594
00:22:32.280 --> 00:22:35.840
然后检查它是否有错误，

595
00:22:34.040 --> 00:22:37.200
如果有错误，就修复它，

596
00:22:35.840 --> 00:22:39.440
然后再检查一次，如此反复，

597
00:22:37.200 --> 00:22:41.320
直到

598
00:22:39.440 --> 00:22:42.360
理论上你的代码没有任何

599
00:22:41.320 --> 00:22:43.679
问题，那会怎么样？

600
00:22:42.360 --> 00:22:45.480
所以，

601
00:22:43.679 --> 00:22:48.200
我们决定让

602
00:22:45.480 --> 00:22:49.600
代码审查变得超级简单，也把它引入到本地环境中。

603
00:22:48.200 --> 00:22:51.480
接下来我将向你展示如何使用

604
00:22:49.600 --> 00:22:53.480
斜杠命令来实现这一点。 这是我

605
00:22:51.480 --> 00:22:55.800
每天提交

606
00:22:53.480 --> 00:22:55.800
PR 之前都会做的事情。

607
00:22:56.600 --> 00:23:00.760
好的。

608
00:22:57.880 --> 00:23:03.320
嗯，我正在开发一个小功能。

609
00:23:00.760 --> 00:23:04.720
你可以看到它有三个

610
00:23:03.320 --> 00:23:05.720
不同的提交记录。 它很小

611
00:23:04.720 --> 00:23:08.320
。

612
00:23:05.720 --> 00:23:10.679
嗯，我旁边还运行着命令行界面

613
00:23:08.320 --> 00:23:13.160
。 所以，

614
00:23:10.679 --> 00:23:14.640
我只需要输入{slash}

615
00:23:13.160 --> 00:23:17.240
评论，

616
00:23:14.640 --> 00:23:17.240
按下回车键，

617
00:23:17.480 --> 00:23:20.200
然后你就会看到这里有几个

618
00:23:18.720 --> 00:23:22.760
不同的选项。

619
00:23:20.200 --> 00:23:24.360
因此，第一种选择是

620
00:23:22.760 --> 00:23:26.640
针对基础分支进行审查，就像 PR 一样。

621
00:23:24.360 --> 00:23:28.080
所以，这会选取你

622
00:23:26.640 --> 00:23:29.679
基础分支中的所有提交，将

623
00:23:28.080 --> 00:23:31.160
其与主分支进行比较，就像

624
00:23:29.679 --> 00:23:33.760
一个普通的 PR 一样，然后

625
00:23:31.160 --> 00:23:35.120
查看整个差异并尝试找出任何

626
00:23:33.760 --> 00:23:36.640
问题。

627
00:23:35.120 --> 00:23:38.280
还有其他选择，例如

628
00:23:36.640 --> 00:23:39.679
查看未提交的更改或

629
00:23:38.280 --> 00:23:42.120
特定的提交或自定义审查

630
00:23:39.679 --> 00:23:43.480
说明，但

631
00:23:42.120 --> 00:23:46.080
一天结束时，当我有很多

632
00:23:43.480 --> 00:23:47.640
不同的提交时，我通常会做的就是审查

633
00:23:46.080 --> 00:23:49.720
所有内容。 所以我选择第一个

634
00:23:47.640 --> 00:23:51.840
选项。 现在，我需要选择一个基础

635
00:23:49.720 --> 00:23:53.360
分支。 通常主程序是第一个，

636
00:23:51.840 --> 00:23:56.160
所以我再次按下回车键。

637
00:23:53.360 --> 00:23:58.600
现在开始代码审查。

638
00:23:56.160 --> 00:23:58.600
所以，

639
00:23:58.640 --> 00:24:02.840
我的问题是，

640
00:24:00.440 --> 00:24:05.000
它为什么这么好？

641
00:24:02.840 --> 00:24:06.760
为什么 GPT-5 Codex 在代码审查方面如此出色

642
00:24:05.000 --> 00:24:09.240
？ 因为我们专门训练它

643
00:24:06.760 --> 00:24:12.160
来查找非常技术性的

644
00:24:09.240 --> 00:24:14.000
错误，它会长时间地

645
00:24:12.160 --> 00:24:16.360
研究各种不同的

646
00:24:14.000 --> 00:24:18.200
文件，然后当它对

647
00:24:16.360 --> 00:24:21.720
可能出错的事情提出假设时，它

648
00:24:18.200 --> 00:24:24.240
甚至会编写测试脚本，并执行

649
00:24:21.720 --> 00:24:28.200
它们，以确保它只给出

650
00:24:24.240 --> 00:24:29.560
一个或最多两个

651
00:24:28.200 --> 00:24:31.520
你必须在提交 PR 之前修复的关键问题

652
00:24:29.560 --> 00:24:33.640
。 它不会像某些游戏那样，仅仅通过查看你的差异就能

653
00:24:31.520 --> 00:24:37.720
一击制胜 20 或 30 种不同的方法

654
00:24:33.640 --> 00:24:39.520
。 它

655
00:24:37.720 --> 00:24:42.320
不会浪费你的时间。

656
00:24:39.520 --> 00:24:44.520
嗯，是的

657
00:24:42.320 --> 00:24:45.600
，这里确实存在一个漏洞。

658
00:24:44.520 --> 00:24:47.880
呃，

659
00:24:45.600 --> 00:24:49.520
如果有人收到的话，哦，真好。

660
00:24:47.880 --> 00:24:54.280
它帮我们搞定了。

661
00:24:49.520 --> 00:24:57.120
嗯，所以，它是 P0。 伟大的。 嗯，

662
00:24:54.280 --> 00:24:59.280
完全正确。 所以，我们不

663
00:24:57.120 --> 00:25:01.080
应该在代码中硬编码这个字符串

664
00:24:59.280 --> 00:25:04.040
。 我们应该

665
00:25:01.080 --> 00:25:07.679
动态地获取这些信息。 所以，

666
00:25:04.040 --> 00:25:10.160
我现在要做的就是告诉 Codex，

667
00:25:07.679 --> 00:25:10.160
请修复这个问题。

668
00:25:11.720 --> 00:25:16.200
呃，而且我通常根本不看

669
00:25:14.800 --> 00:25:17.560
评论，所以

670
00:25:16.200 --> 00:25:19.160
呃，就这么算了

671
00:25:17.560 --> 00:25:20.880
。

672
00:25:19.160 --> 00:25:23.000
但是，是的

673
00:25:20.880 --> 00:25:25.440
，

674
00:25:23.000 --> 00:25:26.760
CLI 中评论的一个好处是，它实际上会

675
00:25:25.440 --> 00:25:28.400
从父线程生成一个单独的线程

676
00:25:26.760 --> 00:25:30.679
。 假设你一直在

677
00:25:28.400 --> 00:25:32.280
开发这个功能，但它

678
00:25:30.679 --> 00:25:33.560
非常具有偏见，你知道，你必须

679
00:25:32.280 --> 00:25:35.440
这样做这个功能，你必须那样

680
00:25:33.560 --> 00:25:37.240
实现它。

681
00:25:35.440 --> 00:25:40.679
评论帖是单独的。 它拥有

682
00:25:37.240 --> 00:25:43.120
全新的视角、全新的背景、全新的

683
00:25:40.679 --> 00:25:45.600
聊天方式，因此它没有同样的

684
00:25:43.120 --> 00:25:47.600
实现偏差，可以帮助

685
00:25:45.600 --> 00:25:50.200
你找到这些错误。

686
00:25:47.600 --> 00:25:53.440
嗯，是的，这件事会继续进行，嗯，

687
00:25:50.200 --> 00:25:54.840
你知道，给我们一些

688
00:25:53.440 --> 00:25:57.120
改变。 在这段时间里，我想向

689
00:25:54.840 --> 00:25:59.960
你展示如何

690
00:25:57.120 --> 00:26:02.640
为你的所有 PR 启用评论功能。 所以，请访问

691
00:25:59.960 --> 00:26:03.840
chat.openai.com/codex。

692
00:26:02.640 --> 00:26:06.000
然后

693
00:26:03.840 --> 00:26:07.080
你只需连接你的GitHub账号即可。

694
00:26:06.000 --> 00:26:08.560
然后这里还有一个名为“

695
00:26:07.080 --> 00:26:10.040
启用代码审查”的按钮。

696
00:26:08.560 --> 00:26:12.280
这样会带你进入代码

697
00:26:10.040 --> 00:26:14.520
审查设置，你可以进行类似

698
00:26:12.280 --> 00:26:17.160
仓库级别的设置，比如指定某个

699
00:26:14.520 --> 00:26:19.200
仓库需要代码审查，而另一个仓库

700
00:26:17.160 --> 00:26:21.280
不需要。但我

701
00:26:19.200 --> 00:26:23.160
这里只有一个开关，我把它设置成

702
00:26:21.280 --> 00:26:25.120
“审查我的所有拉取请求。请

703
00:26:23.160 --> 00:26:26.679
确保我不会将任何回归问题发布

704
00:26:25.120 --> 00:26:28.120
到生产环境。”

705
00:26:26.679 --> 00:26:29.360
那么，

706
00:26:28.120 --> 00:26:30.560
我们回去吧。

707
00:26:29.360 --> 00:26:33.640
极好的。

708
00:26:30.560 --> 00:26:35.080
嗯，它做出了改变。 让我们来看看。

709
00:26:33.640 --> 00:26:36.920
看起来没错。 是的，现在它可以

710
00:26:35.080 --> 00:26:41.200

711
00:26:36.920 --> 00:26:42.640
动态获取提示符目录了。 既然这件事已经完成了，

712
00:26:41.200 --> 00:26:44.560
我想做的就是

713
00:26:42.640 --> 00:26:47.840
再次运行 {slash} 审查。

714
00:26:44.560 --> 00:26:50.320
于是，我点击了{slash}评论，然后按回车键，再按回车键。

715
00:26:47.840 --> 00:26:53.120
伟大的。 所以，这将开启另一个

716
00:26:50.320 --> 00:26:55.280
评论帖。 然后，一旦运行

717
00:26:53.120 --> 00:26:56.280
完成，希望不会发现任何问题，

718
00:26:55.280 --> 00:26:57.520
但如果出现任何问题，您可以

719
00:26:56.280 --> 00:26:59.840
再次继续运行。

720
00:26:57.520 --> 00:27:01.640
嗯，然后完成之后，它会给

721
00:26:59.840 --> 00:27:03.120
你竖起大拇指。

722
00:27:01.640 --> 00:27:05.600
你承诺了。

723
00:27:03.120 --> 00:27:08.640
你努力争取。 然后你的

724
00:27:05.600 --> 00:27:10.240
PR 又得到了 Codex 的最终认可，

725
00:27:08.640 --> 00:27:11.480
你的 PR 就被合并了。

726
00:27:10.240 --> 00:27:13.320
所以，

727
00:27:11.480 --> 00:27:15.920
这就是我每天在

728
00:27:13.320 --> 00:27:18.320

729
00:27:15.920 --> 00:27:20.120
创建 PR 之前，都会在日常工作流程中使用 {slash} review 来进行审核的做法。

730
00:27:18.320 --> 00:27:23.560
非常感谢，我会把它交还给

731
00:27:20.120 --> 00:27:23.560
蒂博让他收拾好。

732
00:27:25.220 --> 00:27:29.080
[音乐]

733
00:27:27.520 --> 00:27:30.320
好了，各位。   就是这样。

734
00:27:29.080 --> 00:27:32.400

735
00:27:30.320 --> 00:27:33.600
我希望今天的演示能让大家了解我们

736
00:27:32.400 --> 00:27:36.000
 

737
00:27:33.600 --> 00:27:39.360
如何借助 Codex 更快、更有

738
00:27:36.000 --> 00:27:41.440
信心地交付产品，以及

739
00:27:39.360 --> 00:27:44.840
我们未来的发展方向。

740
00:27:41.440 --> 00:27:47.000
如果你还没有尝试过 Codex，只需运行 npm

741
00:27:44.840 --> 00:27:48.840
install 即可。 这样就能

742
00:27:47.000 --> 00:27:51.280
在终端里直接打开 Codex 了。 然后你只需输入

743
00:27:48.840 --> 00:27:52.600
Codex，就可以开始使用

744
00:27:51.280 --> 00:27:54.880
我们今天演示的很多功能了

745
00:27:52.600 --> 00:27:57.720
。 今天我们展示的所有东西都是

746
00:27:54.880 --> 00:28:00.920
真实的，你可以立即使用。

747
00:27:57.720 --> 00:28:02.440

748
00:28:00.920 --> 00:28:05.720
参与 Codex 团队工作的 Gabriel Peel 刚刚

749
00:28:02.440 --> 00:28:08.040
发消息告诉我，

750
00:28:05.720 --> 00:28:09.840
CLI 的 V045 版本现在已经发布了。 它进行了

751
00:28:08.040 --> 00:28:12.880
一些

752
00:28:09.840 --> 00:28:14.880
增量更新，并且还支持

753
00:28:12.880 --> 00:28:17.840
OAuth MCP，我觉得这非常棒

754
00:28:14.880 --> 00:28:18.960
。 呃，那就去安装吧。 嗯，

755
00:28:17.840 --> 00:28:20.720
这样就能得到最新

756
00:28:18.960 --> 00:28:23.560
版本了。 如果你想

757
00:28:20.720 --> 00:28:25.720
和 Codex 的一些开发者们聚聚，那就

758
00:28:23.560 --> 00:28:26.919
来我们的展位吧。

759
00:28:25.720 --> 00:28:29.200
嗯，我们当中会有人到场，

760
00:28:26.919 --> 00:28:32.360

761
00:28:29.200 --> 00:28:33.760
OpenAI 的一些 Codex 顶级用户也会到场。 我们还在 Discord 上有

762
00:28:32.360 --> 00:28:37.360
一个问答环节，

763
00:28:33.760 --> 00:28:39.320
你可以加入，

764
00:28:37.360 --> 00:28:41.760
很快就会开始。 所以，过来打个

765
00:28:39.320 --> 00:28:43.340
招呼吧。 别害羞。 呃，谢谢各位

766
00:28:41.760 --> 00:28:43.770
今天的参与。

767
00:28:43.340 --> 00:28:48.529
[音乐]

768
00:28:43.770 --> 00:28:48.529
[掌声]


