WEBVTT

00:00:00.000 --> 00:00:09.600
然後就是Codex裡面一些CLI的一些命令,如何高效的去使用。

00:00:09.600 --> 00:00:11.400
然後它的規範是怎麼樣的。

00:00:11.400 --> 00:00:24.400
那大家掌握了這個CLI的一個高效的交互方式之後,你就會知道你的整個效率就可以得到快速的提升。

00:00:24.400 --> 00:00:31.020
首先的话就是我们最开始通过Codex命令性能

00:00:31.020 --> 00:00:31.340
是吧

00:00:31.340 --> 00:00:33.460
那我们可以看到一些什么命令

00:00:33.460 --> 00:00:34.780
就是这个里面

00:00:34.780 --> 00:00:37.400
我们在这个Cli里面

00:00:37.400 --> 00:00:40.400
首先啊

00:00:40.400 --> 00:00:43.780
这个里面

00:00:43.780 --> 00:00:46.520
大家首先会看到各种各样的一些命令

00:00:46.520 --> 00:00:46.840
是吧

00:00:46.840 --> 00:00:48.560
那你可以用一个help

00:00:48.560 --> 00:00:52.800
这个里面还没有help

00:00:54.400 --> 00:00:59.620
我们在外面看一下

00:00:59.620 --> 00:01:00.800
Codex

00:01:00.800 --> 00:01:04.020
来给大家看

00:01:04.020 --> 00:01:05.720
就是你可以看到

00:01:05.720 --> 00:01:07.020
你在这个通过这种方式

00:01:07.020 --> 00:01:07.920
你可以查询一下

00:01:07.920 --> 00:01:09.620
它目前有哪一些命名

00:01:09.620 --> 00:01:12.460
如果大家看不懂的话

00:01:12.460 --> 00:01:13.380
你可以这样来

00:01:13.380 --> 00:01:15.900
因为它是全是英文的

00:01:15.900 --> 00:01:16.760
你可以正好

00:01:16.760 --> 00:01:18.640
比如说你Codex进去

00:01:18.640 --> 00:01:22.640
帮我执行下Codex

00:01:22.640 --> 00:01:24.440
help

00:01:24.440 --> 00:01:36.840
然后将帮助输出为中文表达

00:01:36.840 --> 00:01:42.140
他会先执行这个啊

00:01:42.140 --> 00:01:44.120
然后把内容给我们翻译一下

00:01:44.120 --> 00:01:48.280
就这个是教大家怎么样去学习

00:01:48.280 --> 00:01:51.340
他的一个命令行的一个使用啊

00:01:51.340 --> 00:01:53.740
因为英文大家可能看不太明白

00:01:53.740 --> 00:01:55.020
用这种Cli的话

00:01:55.020 --> 00:01:57.140
你就能看得更加清晰一些

00:01:57.140 --> 00:02:00.340
来大家可以看到他有哪些Cli呢

00:02:00.340 --> 00:02:02.260
首先是执行是吧

00:02:02.260 --> 00:02:05.900
这个叫以非交互式的方式去执行

00:02:05.900 --> 00:02:07.940
我们这里来对照来给大家讲啊

00:02:10.060 --> 00:02:11.580
我再开一个这个终端

00:02:13.700 --> 00:02:15.620
一定要以终端管理员啊

00:02:18.300 --> 00:02:20.220
然后切换到地盘

00:02:21.340 --> 00:02:22.540
codex mode

00:02:22.540 --> 00:02:26.620
切换到myproject

00:02:26.620 --> 00:02:29.580
好

00:02:29.580 --> 00:02:31.520
然后首先的话就是

00:02:31.520 --> 00:02:33.680
比如说这个里面

00:02:33.680 --> 00:02:37.000
我们就可以以这个命令的方式去分析一下

00:02:37.000 --> 00:02:40.660
就你可以在外面去执行这个codex命令

00:02:40.660 --> 00:02:43.260
然后这个是什么意思呢

00:02:43.260 --> 00:02:45.600
你在外面起了一个问题是吧

00:02:45.600 --> 00:02:47.940
然后它会切换到这个窗口里面去

00:02:47.940 --> 00:02:48.820
然后执行这个

00:02:48.820 --> 00:02:50.720
然后执行完之后的话

00:02:50.720 --> 00:02:54.120
他会给你一个结果的一个输出

00:02:54.120 --> 00:02:56.700
就是这么一个效果

00:02:56.700 --> 00:02:58.980
就是你可以直接用一个命令的方式进去

00:02:58.980 --> 00:03:01.000
或者你直接用Codex的方式进去

00:03:01.000 --> 00:03:01.840
都是OK的

00:03:01.840 --> 00:03:05.380
你看他现在是帮你去分析整个的一个目录结构

00:03:05.380 --> 00:03:06.080
是吧

00:03:06.080 --> 00:03:11.600
就是我们可以以一个Codex命令

00:03:11.600 --> 00:03:14.780
加上一个提示词的方式进入到这个Codex页面

00:03:14.780 --> 00:03:16.080
然后他就真心的任务

00:03:16.080 --> 00:03:17.540
那有些东西说

00:03:17.540 --> 00:03:19.800
比如说我现在不想进入到那个命令行

00:03:19.800 --> 00:03:21.600
我现在只想拿一个结果怎么办呢

00:03:21.600 --> 00:03:23.160
就大家可以这种方式

00:03:23.160 --> 00:03:25.400
叫做exec

00:03:25.400 --> 00:03:28.000
就要以非交互式的方式

00:03:28.000 --> 00:03:30.700
非交互式就是我不想去对话了

00:03:30.700 --> 00:03:31.900
直接给我结果就完了

00:03:31.900 --> 00:03:33.300
exec

00:03:33.300 --> 00:03:34.260
然后

00:03:34.260 --> 00:03:37.560
你说帮我分析一下

00:03:37.560 --> 00:03:40.620
当前项目结构

00:03:40.620 --> 00:03:44.100
跳过vip

00:03:44.100 --> 00:03:47.060
他说要把我们把这个命令给他加上

00:03:47.060 --> 00:03:48.140
那我就加一下

00:03:49.800 --> 00:03:52.260
来大家看

00:03:52.260 --> 00:03:53.080
接下来就是

00:03:53.080 --> 00:03:56.300
他会以命令行的方式去跑啊

00:03:56.300 --> 00:03:59.000
就是我们纯粹就是跑一个命令行

00:03:59.000 --> 00:04:00.820
也没有什么交互页面了

00:04:00.820 --> 00:04:02.540
直接就给你结果了

00:04:02.540 --> 00:04:04.960
大家看就没有进入到那个对话页面了

00:04:04.960 --> 00:04:07.120
这里面应该大家能理解啊

00:04:07.120 --> 00:04:09.660
就是我现在整个就是以

00:04:09.660 --> 00:04:11.600
执行命令的方式去给结果

00:04:11.600 --> 00:04:13.980
然后我就不要进入到那个交互了啊

00:04:13.980 --> 00:04:15.680
这个就叫做非交互式的方式

00:04:15.680 --> 00:04:16.440
去运行codex

00:04:16.440 --> 00:04:17.900
这好处是什么呢

00:04:17.900 --> 00:04:19.360
好处就在于比如说

00:04:19.360 --> 00:04:22.360
我现在有一些传统的运维方式

00:04:22.360 --> 00:04:24.640
是以命令的方式去运行的

00:04:24.640 --> 00:04:25.960
它不需要交互界面

00:04:25.960 --> 00:04:27.840
我现在就相当于调用一个

00:04:27.840 --> 00:04:29.500
是要命令的方式去使用Codex

00:04:29.500 --> 00:04:33.260
那你就要以加一个exec的这个参数

00:04:33.260 --> 00:04:34.760
然后就做一个调用

00:04:34.760 --> 00:04:37.580
那现在是不是我们给它分析出来了

00:04:37.580 --> 00:04:38.680
结果是吧

00:04:38.680 --> 00:04:39.400
完了之后

00:04:39.400 --> 00:04:41.780
它就会退回到这个继续终端页面

00:04:41.780 --> 00:04:44.100
所以整个就是

00:04:44.100 --> 00:04:46.180
它就是把Codex当做一个命令来跑

00:04:46.180 --> 00:04:47.880
这个就是exec

00:04:47.880 --> 00:04:52.420
然后就是包括还有一些这个clean是吧

00:04:52.420 --> 00:04:54.620
那我们可以在这个对话里面

00:04:54.620 --> 00:04:57.740
大家直接去实用这个clean啊

00:04:57.740 --> 00:04:59.860
就直接给它清理上下文了啊

00:04:59.860 --> 00:05:01.840
包括使用copy的一些命令

00:05:01.840 --> 00:05:02.980
这个是斜杠命令啊

00:05:02.980 --> 00:05:04.160
这个我们等一下专门来说

00:05:04.160 --> 00:05:07.840
然后还有一些比较好的一些使用的命令

00:05:07.840 --> 00:05:09.960
叫做恢复对话啊

00:05:09.960 --> 00:05:12.680
这个恢复对话的话是用来干嘛的呢

00:05:12.680 --> 00:05:14.520
就是比如说啊

00:05:14.520 --> 00:05:16.200
比如说大家现在在

00:05:16.200 --> 00:05:20.820
我们刚刚问了一个问题是这个帮助是吧

00:05:20.820 --> 00:05:22.980
我现在不小心退出去了

00:05:22.980 --> 00:05:25.020
我现在退出去了怎么办呢

00:05:25.020 --> 00:05:26.560
退出去之后的话

00:05:26.560 --> 00:05:29.200
你大家就执行这个什么叫resume

00:05:29.200 --> 00:05:32.580
就它会恢复到最近的一个绘画

00:05:32.580 --> 00:05:35.260
比如说我们现在把它执行一下

00:05:35.260 --> 00:05:36.980
然后在这个里面

00:05:36.980 --> 00:05:39.280
来大家看这里它就会选

00:05:39.280 --> 00:05:42.300
就是我之前聊过多少次

00:05:42.300 --> 00:05:44.620
那我现在要切回去怎么办呢

00:05:44.620 --> 00:05:46.220
那比如说选最近的

00:05:46.220 --> 00:05:47.920
他这里会有一个时间啊

00:05:47.920 --> 00:05:48.880
两分钟之前

00:05:48.880 --> 00:05:51.220
然后这边是之前的一个列表

00:05:51.220 --> 00:05:51.520
是吧

00:05:51.520 --> 00:05:54.320
然后我来切回去

00:05:54.320 --> 00:05:56.420
然后大家看是不是就我就切回来了

00:05:56.420 --> 00:05:57.280
是吧

00:05:57.280 --> 00:05:59.620
但是这个切的不是我刚刚那个

00:05:59.620 --> 00:06:01.720
所以我还得再切一下

00:06:01.720 --> 00:06:03.220
刚刚那个应该是这个

00:06:03.220 --> 00:06:04.820
来大家看是不是切过去了

00:06:04.820 --> 00:06:07.320
就我可以快速的去恢复一个对话

00:06:07.320 --> 00:06:07.860
啊

00:06:07.860 --> 00:06:11.020
然后我还可以去指定某个会话 id

00:06:11.020 --> 00:06:11.620
啊

00:06:11.620 --> 00:06:12.860
这个会话 id 的话啊

00:06:12.860 --> 00:06:14.520
这就是在哪个地方呢

00:06:14.620 --> 00:06:17.360
呃

00:06:17.360 --> 00:06:18.320
继续

00:06:18.320 --> 00:06:19.520
继续

00:06:19.520 --> 00:06:20.180
继续画ID

00:06:20.180 --> 00:06:21.740
这里还看不到

00:06:21.740 --> 00:06:23.180
看一下

00:06:23.180 --> 00:06:23.740
继续

00:06:23.740 --> 00:06:25.460
加一下这个命令

00:06:25.460 --> 00:06:29.800
继续

00:06:29.800 --> 00:06:32.040
这个是所有的这个对话啊

00:06:32.040 --> 00:06:34.240
一个是当前目录的

00:06:34.240 --> 00:06:35.760
这个是当前目录的

00:06:35.760 --> 00:06:37.740
这个是所有目录的啊

00:06:37.740 --> 00:06:39.420
就历史我聊过的

00:06:39.420 --> 00:06:41.140
都会出现在这个里面去

00:06:41.140 --> 00:06:43.860
所以这个是我之前聊过的所谓记录

00:06:43.860 --> 00:06:46.360
然后绘画ID的话

00:06:46.360 --> 00:06:49.260
看一下怎么来查看这个绘画ID

00:06:49.260 --> 00:06:51.600
last

00:06:51.600 --> 00:06:56.200
这个直接是跳转到上次对话

00:06:56.200 --> 00:07:02.920
看一下last绘画ID

00:07:02.920 --> 00:07:04.920
绘画ID status

00:07:04.920 --> 00:07:07.860
那比如说我现在要切到那个

00:07:07.860 --> 00:07:09.200
我首先切到

00:07:09.200 --> 00:07:13.120
比如说我现在resume

00:07:13.860 --> 00:07:15.960
我切换到这个

00:07:15.960 --> 00:07:17.700
然后这个status

00:07:17.700 --> 00:07:23.200
然后这里大家看啊

00:07:23.200 --> 00:07:24.460
它的绘画ID

00:07:24.460 --> 00:07:26.160
我看这里有没有啊

00:07:26.160 --> 00:07:28.040
绘画ID

00:07:28.040 --> 00:07:33.220
这里好像没有绘画ID

00:07:33.220 --> 00:07:33.800
这个啊

00:07:33.800 --> 00:07:34.900
这个就是绘画ID啊

00:07:34.900 --> 00:07:37.720
就是我们输入这个status命令

00:07:37.720 --> 00:07:40.480
就这里可以看到一个stationID啊

00:07:40.480 --> 00:07:42.320
然后大家把这个东西复制一下

00:07:42.320 --> 00:07:43.680
然后我们退出去

00:07:43.680 --> 00:07:46.560
然后再说一个resume

00:07:46.560 --> 00:07:47.060
是吧

00:07:47.060 --> 00:07:48.440
codex resume

00:07:48.440 --> 00:07:51.080
然后加station id

00:07:51.080 --> 00:07:53.360
也能切回来

00:07:53.360 --> 00:07:54.780
我觉得这几种方式

00:07:54.780 --> 00:07:56.260
基本上就够用了

00:07:57.104 --> 00:08:12.104
然後我們退出去。然後我再說一個resume。codexresume。然後加sessionID。也能切回來。我覺得這幾種方式基本上就夠用了。然後非交互式命令的方式也可以。比如說我們帶上這個exec。非交互式命令就我直接想把每一次的會話結果給它說出來。是吧?那我們就把這個ID給它拉上。

00:08:12.104 --> 00:08:15.344
那就它直接会给我一个结果

00:08:15.344 --> 00:08:18.244
Resume

00:08:18.244 --> 00:08:19.044
诶

00:08:19.044 --> 00:08:21.264
NoGram

00:08:21.264 --> 00:08:27.644
NoPro

00:08:27.644 --> 00:08:31.864
诶它这里不是那个ID是吧

00:08:31.864 --> 00:08:32.884
看一下

00:08:32.884 --> 00:08:38.864
Codex.exec.resume

00:08:42.104 --> 00:08:52.804
我看一下这个命令是不是哪里错了

00:08:52.804 --> 00:08:56.544
大家遇到这种命令错误的情况下

00:08:56.544 --> 00:08:58.044
你可以这么来解决

00:08:58.044 --> 00:09:00.944
你就直接把这个错误丢给他

00:09:00.944 --> 00:09:03.604
帮我分析一下

00:09:03.604 --> 00:09:04.684
这个

00:09:04.684 --> 00:09:10.444
是什么错误

00:09:10.444 --> 00:09:15.084
然后输出修正的指令

00:09:15.084 --> 00:09:18.884
你就让Codex帮你去修复就完了

00:09:18.884 --> 00:09:25.204
但是某个参数写的有问题

00:09:25.204 --> 00:09:28.184
他会给你一个修正的命令

00:09:28.184 --> 00:09:33.904
这里还要加一个提示词是吧

00:09:33.904 --> 00:09:36.384
还要加一个这么一个提示词

00:09:36.384 --> 00:09:37.524
但是他这里又

00:09:37.524 --> 00:09:39.264
后面写了

00:09:39.264 --> 00:09:40.884
他需要加加这个提示词

00:09:40.884 --> 00:09:42.024
我说少了一个参数

00:09:42.024 --> 00:09:43.544
那我就加一下呗

00:09:43.544 --> 00:09:45.904
还要加一个参数

00:09:45.904 --> 00:09:49.624
要跳过这个有一个report的一个检查

00:09:49.624 --> 00:09:57.744
他就是以一个定时任务啊

00:09:57.744 --> 00:10:00.524
就是一个提示词的方式去执行一个命令

00:10:00.524 --> 00:10:02.404
然后这个命令会把之前的那个

00:10:02.404 --> 00:10:05.144
在之前的绘画基础之上再加一个提示词

00:10:05.144 --> 00:10:06.064
继续做一个对话

00:10:06.064 --> 00:10:08.084
听起来给结果给你说出来

00:10:08.084 --> 00:10:09.924
这个就是非交互式的运行

00:10:09.924 --> 00:10:11.244
也就是说我相当于

00:10:11.244 --> 00:10:13.804
我在之前对话的一个基础之上

00:10:13.804 --> 00:10:15.644
再去让他执行一个

00:10:15.644 --> 00:10:19.344
这个给他做一个对话

00:10:19.344 --> 00:10:19.664
是吧

00:10:19.664 --> 00:10:20.404
做一个对话之后

00:10:20.404 --> 00:10:23.044
把这个结果再以命令的方式返回回来

00:10:23.044 --> 00:10:25.144
但是我不要进入到那个对话页面

00:10:25.144 --> 00:10:26.864
这个是交互的方式

00:10:26.864 --> 00:10:29.564
所以这个场景可能再也用的不多

00:10:29.564 --> 00:10:30.384
但是要知道

00:10:30.384 --> 00:10:32.724
如果你想以命令的方式去跑的话

00:10:32.724 --> 00:10:34.244
你就按照规范去写就完了

00:10:34.244 --> 00:10:38.324
然后是模型跟推理

00:10:38.324 --> 00:10:39.824
最开始我们给他讲了

00:10:39.824 --> 00:10:41.764
这个切换模型这里面就是

00:10:41.764 --> 00:10:44.184
这里面我给他提的一个建议

00:10:44.184 --> 00:10:47.304
就是如果说你要做一些对话

00:10:47.304 --> 00:10:47.744
是吧

00:10:47.744 --> 00:10:48.764
做一个推理

00:10:48.764 --> 00:10:50.324
然后做一些研究

00:10:50.324 --> 00:10:53.024
存交流的话

00:10:53.024 --> 00:10:55.084
那你就用GBT5.5就完了

00:10:55.084 --> 00:10:57.164
最新的模型肯定没什么问题

00:10:57.164 --> 00:10:59.984
然后当然他也可以写淡网

00:10:59.984 --> 00:11:03.344
但是如果说你要专门写淡网的话

00:11:03.344 --> 00:11:05.844
你就用5.3的那个Codex版本

00:11:05.844 --> 00:11:07.464
这是我给大家一个建议

00:11:07.464 --> 00:11:08.964
这是专门用了写代码的一个版本

00:11:08.964 --> 00:11:09.884
做个调优的

00:11:09.884 --> 00:11:11.624
所以它的效果肯定是好一些

00:11:11.624 --> 00:11:15.204
这个是模型跟推理这一块的一个权衡

00:11:15.204 --> 00:11:19.384
这个5.5这个模型擅长做任务规划

00:11:19.384 --> 00:11:21.504
你拿写文档你可以用5.5去做

00:11:21.504 --> 00:11:22.884
它的效果会更好

00:11:22.884 --> 00:11:25.464
然后包括一个图片输入

00:11:25.464 --> 00:11:27.264
就是你可以在Codex里面

00:11:27.264 --> 00:11:30.224
你可以去把一个截图

00:11:30.224 --> 00:11:32.724
就是去做一个什么呢

00:11:32.724 --> 00:11:33.684
哎

00:11:33.684 --> 00:11:35.724
就给大家去生成出来

00:11:35.724 --> 00:11:37.164
比如说我们现在啊

00:11:37.164 --> 00:11:39.424
我们现在这个项目下面

00:11:39.424 --> 00:11:42.284
呃有一个这个图片是吧

00:11:42.284 --> 00:11:42.824
有一个图片

00:11:42.824 --> 00:11:45.764
我现在要分析一下这个图片内容是什么

00:11:45.764 --> 00:11:48.464
比如说我们加上这个

00:11:48.464 --> 00:11:49.464
codex-r

00:11:49.464 --> 00:12:01.104
把这个图片名

00:12:01.104 --> 00:12:02.804
文件名改一下

00:12:02.804 --> 00:12:04.264
文件名是

00:12:04.264 --> 00:12:06.424
它就是一个贪吃蛇的测试截图嘛

00:12:06.424 --> 00:12:09.264
然后你就这么说一下

00:12:09.264 --> 00:12:16.464
分析一下这张图片

00:12:16.464 --> 00:12:19.424
所以大家你直接让他分析就完了

00:12:19.424 --> 00:12:21.124
他会进入到这个对话里面

00:12:21.124 --> 00:12:22.364
然后去分析那个图片

00:12:22.364 --> 00:12:26.704
这张图是一个网页端的摊志舌游戏界面

00:12:26.704 --> 00:12:27.784
然后偏科技风

00:12:27.784 --> 00:12:29.444
你看他分析没什么问题吧

00:12:29.444 --> 00:12:31.804
所以说这个场景一般用的什么地方呢

00:12:31.804 --> 00:12:33.784
就是我们现在项目里面有一些暴错

00:12:33.784 --> 00:12:36.044
大家不好用语言去表达的时候

00:12:36.044 --> 00:12:38.284
你直接结个图有一个错误在里面

00:12:38.284 --> 00:12:38.644
是吧

00:12:38.644 --> 00:12:40.344
你直接把图丢给AI就行了

00:12:40.344 --> 00:12:43.824
那么Codex他也能帮你去把这个图片给识别出来

00:12:43.824 --> 00:12:45.324
然后去解决这个问题

00:12:45.324 --> 00:12:46.684
并且你有多张图的话

00:12:46.684 --> 00:12:47.784
你可以使用image

00:12:47.784 --> 00:12:49.284
把这个是吧

00:12:49.284 --> 00:12:50.944
多张图指定一下就可以了

00:12:50.944 --> 00:12:52.364
他目前支持PNG

00:12:52.364 --> 00:12:54.504
这笔机的一些常见格式

00:12:54.504 --> 00:12:56.604
除了输入图以外

00:12:56.604 --> 00:12:57.944
他还可以生生图

00:12:57.944 --> 00:12:58.884
生生图的话

00:12:58.884 --> 00:13:00.464
有几种方式

00:13:00.464 --> 00:13:03.764
就是他可以调用一些API生生图

00:13:03.764 --> 00:13:04.084
是吧

00:13:04.084 --> 00:13:05.904
还有的话就是他可以通过

00:13:05.904 --> 00:13:08.144
OpenAI官方的一些模型

00:13:08.144 --> 00:13:09.984
比如说像L1E3模型

00:13:09.984 --> 00:13:12.184
比如说像GBT image2模型

00:13:12.184 --> 00:13:14.144
比如说你就直接跟他说

00:13:14.144 --> 00:13:19.584
帮我生成一张猫的图片

00:13:19.584 --> 00:13:21.504
你就直接这么跟他说

00:13:21.504 --> 00:13:24.104
那么他就会想尽一些办法

00:13:24.104 --> 00:13:24.884
帮你去生成图

00:13:24.884 --> 00:13:28.024
他会可能比如说调用一些scale

00:13:28.024 --> 00:13:28.524
是吧

00:13:28.524 --> 00:13:29.824
他内置的一些scale

00:13:29.824 --> 00:13:32.924
去调用一些模型帮你去生成图

00:13:32.924 --> 00:13:34.924
或者说他调用一些公共的API

00:13:34.924 --> 00:13:35.904
去生成一张图

00:13:35.904 --> 00:13:36.624
都有可能

00:13:36.624 --> 00:13:38.344
所以看大家一个需求

00:13:38.344 --> 00:13:39.784
比如说你想了他就是用

00:13:39.784 --> 00:13:41.884
GPG的这个image2去生成

00:13:41.884 --> 00:13:43.104
那你就提示词里面

00:13:43.104 --> 00:13:44.304
提提醒一下

00:13:44.304 --> 00:13:46.284
你要用这个模型去生成就完了

00:13:46.284 --> 00:13:47.904
这个就生成图片

00:13:47.904 --> 00:13:49.404
这个也很好理解

00:13:49.404 --> 00:13:52.104
你看现在已经生成了一个猫的图片了

00:13:53.104 --> 00:13:55.604
你看就是他生成的是吧

00:13:55.604 --> 00:13:57.624
这个就猫的一个图片

00:13:57.624 --> 00:13:59.424
所以说

00:13:59.424 --> 00:14:01.064
这个里面的话

00:14:01.064 --> 00:14:03.444
就是这个效果就是看大家

00:14:03.444 --> 00:14:06.004
你具体你要让他用什么模型去做

00:14:06.004 --> 00:14:08.044
但这个功能他都是支持的

00:14:08.044 --> 00:14:11.424
然后是语法的这个

00:14:11.424 --> 00:14:13.264
高亮与主题

00:14:13.264 --> 00:14:15.164
这个是什么意思呢

00:14:15.164 --> 00:14:15.764
就是比如说

00:14:15.764 --> 00:14:17.704
大家你看这个页面是吧

00:14:17.704 --> 00:14:18.824
你看的不爽

00:14:18.824 --> 00:14:20.784
那我现在要改个主题

00:14:20.784 --> 00:14:24.064
就是我进入到这个Colex

00:14:24.064 --> 00:14:27.204
输入这个Theme

00:14:27.204 --> 00:14:28.584
就大家看

00:14:28.584 --> 00:14:30.564
你可以改这个是吧

00:14:30.564 --> 00:14:31.264
可以改这个

00:14:31.264 --> 00:14:33.744
就是我们什么亮色暗色

00:14:33.744 --> 00:14:35.264
各种终端的这个图

00:14:35.264 --> 00:14:35.584
是吧

00:14:35.584 --> 00:14:37.264
比如说我现在想改成这个效果

00:14:37.264 --> 00:14:38.264
然后就看一下

00:14:38.264 --> 00:14:39.844
帮我生成一个

00:14:39.844 --> 00:14:50.704
无子其游戏

00:14:50.704 --> 00:14:54.684
寄与html

00:14:54.684 --> 00:14:57.444
实现

00:14:57.444 --> 00:15:01.284
然后大家就可以看到他的这个代码主题

00:15:01.284 --> 00:15:05.364
我们就可以看到他就有一些变化

00:15:05.364 --> 00:15:09.984
就他生成代码的时候

00:15:09.984 --> 00:15:11.964
这个里面就有一些逻辑

00:15:11.964 --> 00:15:19.004
就是相当于这个就是改语法

00:15:19.004 --> 00:15:21.144
就是我们改这个一些

00:15:21.144 --> 00:15:22.964
Diff高量的

00:15:22.964 --> 00:15:24.144
这个很好理解

00:15:24.144 --> 00:15:28.004
然后是这个比较一个实用的功能

00:15:28.004 --> 00:15:29.824
叫做运行本地代码评审

00:15:29.824 --> 00:15:32.444
这个是用来干嘛

00:15:32.444 --> 00:15:34.884
大家看这个效果是不是就变了

00:15:34.884 --> 00:15:35.344
是吧

00:15:35.364 --> 00:15:38.024
就是这个改了一个这个效果嘛

00:15:38.024 --> 00:15:38.964
是吧

00:15:38.964 --> 00:15:40.564
呃

00:15:40.564 --> 00:15:42.124
这个review啊

00:15:42.124 --> 00:15:43.584
就是运行本地代码评审

00:15:43.584 --> 00:15:44.284
这个比较

00:15:44.284 --> 00:15:46.344
这个功能比较好用啊

00:15:46.344 --> 00:15:46.904
什么意思呢

00:15:46.904 --> 00:15:48.044
就是大家可以在

00:15:48.044 --> 00:15:51.404
这个codex里面去输入这个什么呢

00:15:51.404 --> 00:15:52.384
叫做review

00:15:52.384 --> 00:15:53.744
review

00:16:07.030 --> 00:16:08.990
还有一个就是大家啊

00:16:08.990 --> 00:16:10.730
你已经提交了一些PR了

00:16:10.730 --> 00:16:11.950
那你可以用

00:16:11.950 --> 00:16:13.950
把一个PR的链接给他

00:16:13.950 --> 00:16:15.490
让他去check也是可以的

00:16:15.490 --> 00:16:16.810
但是你要把一些

00:16:16.810 --> 00:16:18.690
比如说GitHub的一个权限给他配合

00:16:18.690 --> 00:16:20.450
让他能够拉到那个PR

00:16:20.450 --> 00:16:22.350
但是如果是公共仓库就不用管了

00:16:22.350 --> 00:16:23.490
公共仓库都有权限

00:16:23.490 --> 00:16:26.370
但是最好还是配一个token去访问

00:16:26.370 --> 00:16:27.730
这样就不会被限制

00:16:27.730 --> 00:16:29.370
所以这个里面的话

00:16:29.370 --> 00:16:30.750
这个review的话

00:16:30.750 --> 00:16:32.770
主要就是我们可以做代码评审

00:16:32.770 --> 00:16:34.710
比如说我现在

00:16:34.710 --> 00:16:35.950
我刚刚那个

00:16:35.950 --> 00:16:39.170
贪吃蛇游戏是吧

00:16:39.170 --> 00:16:41.950
那你就把这个代码告诉他

00:16:41.950 --> 00:16:45.610
比如说我们现在要review

00:16:45.610 --> 00:16:51.210
at这个文件是吧

00:16:51.210 --> 00:16:52.990
帮我

00:16:52.990 --> 00:16:59.670
执行一下代码

00:16:59.670 --> 00:17:01.770
评审

00:17:01.770 --> 00:17:05.710
就我们来看一下这个生人代码有什么问题

00:17:05.710 --> 00:17:07.050
那就分析一下

00:17:07.050 --> 00:17:07.470
对吧

00:17:07.470 --> 00:17:10.190
那么他这个里面的话

00:17:10.190 --> 00:17:11.290
就会去执行一些

00:17:11.290 --> 00:17:12.450
Git的一些命令啊

00:17:12.450 --> 00:17:13.530
因为有时候

00:17:13.530 --> 00:17:15.350
他要分析有没有提交嘛

00:17:15.350 --> 00:17:16.610
所以他用到用到Git

00:17:16.610 --> 00:17:17.610
但是我们这个

00:17:17.610 --> 00:17:19.030
他不是一个Git项目嘛

00:17:19.030 --> 00:17:21.010
那他直接就可以分析内容了

00:17:21.010 --> 00:17:23.230
那我这里面还有一个项目啊

00:17:23.230 --> 00:17:24.870
是我之前找的一个

00:17:24.870 --> 00:17:25.910
开源的一个项目啊

00:17:25.910 --> 00:17:27.150
一个洛伊的项目

00:17:27.150 --> 00:17:28.310
那么这个项目的话

00:17:28.310 --> 00:17:30.470
是我改了一些代码的啊

00:17:30.470 --> 00:17:31.770
我等一下拉下拉分析一下

00:17:31.770 --> 00:17:32.930
我改的这个代码里面

00:17:32.930 --> 00:17:34.170
有没有什么问题啊

00:17:34.170 --> 00:17:37.070
所以我这里开开两个给大家来看一下这个效果

00:17:37.070 --> 00:17:42.170
那这里面我们还是要用终端管理员啊

00:17:43.170 --> 00:17:48.610
切换到洛伊

00:17:48.610 --> 00:17:51.210
然后这个里面

00:17:51.210 --> 00:17:54.170
你这里一样的啊

00:17:54.170 --> 00:17:55.410
Codex

00:17:55.410 --> 00:17:57.630
review

00:17:57.630 --> 00:18:00.750
然后我们就直接review

00:18:00.750 --> 00:18:03.230
然后这里面大家看会有一个提示啊

00:18:03.230 --> 00:18:04.630
第一个的话就是pr

00:18:04.630 --> 00:18:07.690
就是我们现在基于这个分支去check

00:18:07.690 --> 00:18:10.490
然后第二个就是我们没有提交的一些change

00:18:10.490 --> 00:18:12.490
就我现在有一些代码没提交嘛

00:18:12.490 --> 00:18:13.350
刚刚那些代码

00:18:13.350 --> 00:18:14.530
我们去check一下

00:18:14.530 --> 00:18:16.390
然后是已经已提交的

00:18:16.390 --> 00:18:20.290
基本上就是这个是自定义的这种审查

00:18:20.290 --> 00:18:23.230
我们现在这个场景选择第二个

00:18:23.230 --> 00:18:27.050
那去扫描执行一些get命令

00:18:27.050 --> 00:18:28.830
看一下我提的代码也没问题

00:18:28.830 --> 00:18:29.350
是吧

00:18:29.350 --> 00:18:32.270
你看但是他现在

00:18:32.270 --> 00:18:34.870
给我的结果是英文的是吧

00:18:34.870 --> 00:18:36.510
那么大家可以这里加一下

00:18:38.030 --> 00:18:42.110
你就使用中文输出结果

00:18:43.310 --> 00:18:45.110
这里给大家提示一下就可以了

00:18:46.910 --> 00:18:48.830
然后这里面我们其实也可以加一下

00:18:51.670 --> 00:18:52.310
Codex

00:18:54.430 --> 00:18:55.030
review

00:19:00.630 --> 00:19:01.390
这里还改不了

00:19:01.390 --> 00:19:02.850
那我们就直接让它输出吧

00:19:02.850 --> 00:19:03.830
等一下

00:19:03.830 --> 00:19:05.270
它的出来的结果

00:19:05.270 --> 00:19:07.890
我们可以让它再翻一下就可以了

00:19:07.890 --> 00:19:11.550
这个就是两种

00:19:11.550 --> 00:19:13.230
一种是Git有项目的

00:19:13.230 --> 00:19:14.370
就有提交记录的

00:19:14.370 --> 00:19:15.590
这种是没有提交记录

00:19:15.590 --> 00:19:16.870
指定单文件的审查

00:19:16.870 --> 00:19:18.030
这个都是OK的

00:19:18.030 --> 00:19:19.190
看大家具体

00:19:19.190 --> 00:19:21.190
你是什么一个场景

00:19:21.190 --> 00:19:22.650
都是OK的

00:19:22.650 --> 00:19:25.270
然后就是比如说

00:19:25.270 --> 00:19:28.750
我们还可以去自定义一些评审命理

00:19:28.750 --> 00:19:30.890
比如说你想这个

00:19:30.890 --> 00:19:32.650
重点关注某一个

00:19:32.650 --> 00:19:33.550
是吧

00:19:33.550 --> 00:19:35.850
你要自己定义一套机制

00:19:35.850 --> 00:19:38.650
然后去做一些这个审查

00:19:38.650 --> 00:19:39.490
是吧

00:19:39.490 --> 00:19:41.930
那么他都可以去做一个处理啊

00:19:41.930 --> 00:19:43.630
这个是你要自定一些评审命令

00:19:43.630 --> 00:19:46.010
基本上我们用不到那么麻烦

00:19:46.010 --> 00:19:47.250
你直接就让他去

00:19:47.250 --> 00:19:49.230
check你有没有提交了

00:19:49.230 --> 00:19:52.330
因为这个尽量是自己提交上去代码

00:19:52.330 --> 00:19:52.830
没什么问题

00:19:52.830 --> 00:19:53.850
自己先check一下

00:19:53.850 --> 00:19:56.210
所以大部分你用这个场景就可以了

00:19:56.210 --> 00:19:57.350
或者是已经提交的

00:19:57.350 --> 00:19:59.990
让专门的审查人员看你的PR就可以了

00:19:59.990 --> 00:20:01.810
这也是OK的

00:20:01.810 --> 00:20:07.290
你看这个就是我们分析的这个结果

00:20:07.290 --> 00:20:09.210
就是刚刚分析那个摊摊蛇

00:20:09.210 --> 00:20:10.110
那个游戏是吧

00:20:10.110 --> 00:20:11.670
写的代码有没有问题

00:20:11.670 --> 00:20:12.490
我们去看一下

00:20:12.490 --> 00:20:14.550
然后这里面你看是不是就分析出来了

00:20:14.550 --> 00:20:17.510
空格暂停被双肩停抵消

00:20:17.510 --> 00:20:18.790
然后什么什么规则

00:20:18.790 --> 00:20:20.490
什么反转是吧

00:20:20.490 --> 00:20:22.070
然后什么误判呀

00:20:22.070 --> 00:20:26.430
就是他给你提了三个问题是吧

00:20:26.430 --> 00:20:27.770
P1 P2 P3

00:20:27.770 --> 00:20:28.650
三个问题

00:20:28.650 --> 00:20:31.290
这是他给的一些反馈啊

00:20:31.290 --> 00:20:33.130
这个结果还是

00:20:33.130 --> 00:20:35.490
比较准确的

00:20:35.490 --> 00:20:36.530
那这个里面描述

00:20:36.530 --> 00:20:38.230
这个你看损坏的

00:20:38.230 --> 00:20:39.850
这个就是字符集的问题

00:20:39.850 --> 00:20:41.890
然后你比如说根据这个审查结果

00:20:41.890 --> 00:20:42.610
你就可以来提到

00:20:42.610 --> 00:20:44.630
参考上述

00:20:44.630 --> 00:20:47.550
审查结果

00:20:47.550 --> 00:20:49.750
帮我修复

00:20:49.750 --> 00:20:52.370
代码

00:20:52.370 --> 00:20:53.910
就是审查完之后

00:20:53.910 --> 00:20:54.630
这些个东西

00:20:54.630 --> 00:20:56.450
你就可以让它自动修复了

00:20:56.450 --> 00:20:57.630
这么就是

00:20:57.630 --> 00:20:59.550
是不是就全自动了是吧

00:20:59.550 --> 00:21:01.370
就你让它这个完

00:21:01.370 --> 00:21:02.710
让它自己修复

00:21:02.710 --> 00:21:04.730
你再去看一下有没有问题

00:21:04.730 --> 00:21:07.110
这就是做一个循环啊

00:21:07.110 --> 00:21:09.550
让它不断的去修正完善是吧

00:21:09.550 --> 00:21:13.590
然后这个里面它也是这个英文的

00:21:13.590 --> 00:21:14.790
你就这么来说

00:21:14.790 --> 00:21:21.570
上面输出的结果

00:21:21.570 --> 00:21:25.850
帮我翻译为中文输出

00:21:25.850 --> 00:21:27.990
就夹夹一个这样就可以

00:21:27.990 --> 00:21:31.790
他就会给你把那个这个里面你看

00:21:31.790 --> 00:21:34.090
是吧

00:21:34.090 --> 00:21:36.250
这个是我之前的改了一些这个代码

00:21:36.250 --> 00:21:36.490
是吧

00:21:36.490 --> 00:21:37.330
改了一些脚本

00:21:37.330 --> 00:21:39.650
然后包括一些这个style啊

00:21:39.650 --> 00:21:40.250
一些酷啊

00:21:40.250 --> 00:21:41.090
然后做一些调整

00:21:41.090 --> 00:21:42.930
他都帮我分析出来了啊

00:21:42.930 --> 00:21:44.330
这个就是评审的一些细节

00:21:44.330 --> 00:21:47.250
然后你看已经审查修复了啊

00:21:47.250 --> 00:21:47.770
修复完之后

00:21:47.770 --> 00:21:49.030
你还可以让他去测试一下

00:21:49.030 --> 00:21:49.350
是吧

00:21:49.350 --> 00:21:51.610
然后你就比如说你再去这个一下

00:21:51.610 --> 00:22:00.970
再执行向代码审查

00:22:00.970 --> 00:22:11.330
看一下

00:22:11.330 --> 00:22:19.730
之前那些之前审查

00:22:19.730 --> 00:22:28.370
问题有没有修复

00:22:28.370 --> 00:22:35.690
输出一个对照表格

00:22:35.690 --> 00:22:43.190
比如说原问题

00:22:43.190 --> 00:22:49.970
问题修复

00:22:49.970 --> 00:22:54.010
关键点

00:22:54.010 --> 00:22:56.870
然后修复

00:22:56.870 --> 00:23:02.670
代码文件

00:23:02.670 --> 00:23:04.090
修复代码

00:23:04.090 --> 00:23:04.910
代码好吗

00:23:04.910 --> 00:23:05.750
因为就一个文件

00:23:05.750 --> 00:23:06.130
是吧

00:23:06.130 --> 00:23:07.950
就是他修完之后

00:23:07.950 --> 00:23:10.090
我怎么知道他有没有修呢

00:23:10.090 --> 00:23:11.550
我们让他说出一个对照

00:23:11.550 --> 00:23:12.470
是吧

00:23:12.470 --> 00:23:14.110
让他做一个总结嘛

00:23:14.110 --> 00:23:16.430
不然你也不知道他改了成功没有

00:23:16.430 --> 00:23:18.290
然后你也不知道到底代码

00:23:18.290 --> 00:23:18.930
动用哪些

00:23:18.930 --> 00:23:19.770
虽然上面有

00:23:19.770 --> 00:23:22.070
但是我还是希望看到一个表格

00:23:22.070 --> 00:23:22.970
是吧

00:23:22.970 --> 00:23:24.650
这是我们看的更加清晰一些

00:23:24.650 --> 00:23:28.510
所以大家就可以通过这些个提示词

00:23:28.510 --> 00:23:30.290
不断的让他就优化

00:23:30.290 --> 00:23:31.010
调整

00:23:31.010 --> 00:23:32.850
做一些归纳

00:23:32.850 --> 00:23:35.910
这样的话你这个效率是不是就提升了

00:23:35.910 --> 00:23:38.170
而且你还做了一把check

00:23:38.170 --> 00:23:40.270
它的准确性也会高很多

00:23:40.270 --> 00:23:45.090
所以这些个细节问题啊

00:23:45.090 --> 00:23:46.670
就是大家你可以去

00:23:46.670 --> 00:23:50.110
适当的把这个东西给它用起来啊

00:23:50.110 --> 00:23:51.710
这样的话我们整个效率的话

00:23:51.710 --> 00:23:52.850
就会得到一个提升

00:23:56.190 --> 00:24:08.790
然後,請用中文再輸出上面的結果。

00:24:09.190 --> 00:24:19.450
他没有帮我把之前的那个结果列出来是吧

00:24:19.450 --> 00:24:22.330
他现在又帮我啊

00:24:22.330 --> 00:24:23.890
我执行的是review是吧

00:24:23.890 --> 00:24:25.810
那我还不能加那个review了

00:24:25.810 --> 00:24:29.590
那我是不能加那个review的

00:24:29.590 --> 00:24:31.410
我加了review之后

00:24:31.410 --> 00:24:34.650
他既又又直起的那个是吧

00:24:34.650 --> 00:24:35.210
那我就

00:24:35.210 --> 00:24:38.990
那我就不能不能加review了

00:24:38.990 --> 00:24:39.850
加review之后

00:24:39.850 --> 00:24:42.110
他还是在帮我做代码审查的

00:24:42.110 --> 00:24:44.790
我就直接这么来

00:24:44.790 --> 00:24:46.990
直接说一个提示词

00:24:46.990 --> 00:24:48.410
就不要加入review了

00:24:48.410 --> 00:24:50.290
就不要再做代码审查

00:24:50.290 --> 00:24:52.450
直接让他给我结果就行了

00:24:52.450 --> 00:24:58.650
所以review他根本的这个点的话

00:24:58.650 --> 00:25:00.310
还是要去做什么呢

00:25:00.310 --> 00:25:01.510
去做review的

00:25:01.510 --> 00:25:03.870
他不会帮你去做其他的一个操作的

00:25:08.990 --> 00:25:12.250
你看他是不是这里就修复了

00:25:12.250 --> 00:25:12.710
是吧

00:25:12.710 --> 00:25:17.510
看一下

00:25:17.510 --> 00:25:19.210
这是不是有一个表格

00:25:19.210 --> 00:25:20.870
以修复

00:25:20.870 --> 00:25:22.390
你看原问题是什么

00:25:22.390 --> 00:25:24.090
修复关键点是什么

00:25:24.090 --> 00:25:24.470
是吧

00:25:24.470 --> 00:25:26.750
然后修复代码行

00:25:26.750 --> 00:25:27.670
以修复

00:25:27.670 --> 00:25:29.870
这个是不是就比较清晰了

00:25:29.870 --> 00:25:32.250
然后最后又代码审查出来一个未修复

00:25:32.250 --> 00:25:34.330
那你就继续在他

00:25:34.330 --> 00:25:35.330
再修复

00:25:35.330 --> 00:25:36.170
再去check

00:25:36.170 --> 00:25:37.410
再不断的

00:25:37.410 --> 00:25:38.630
直到把所有的问题修完

00:25:38.630 --> 00:25:40.370
这个问题是不是就解决了

00:25:40.370 --> 00:25:41.510
这个就是一个思路

00:25:41.510 --> 00:25:42.090
OK

00:25:42.090 --> 00:25:44.030
好

00:25:44.030 --> 00:25:45.370
然后是Web搜索

00:25:45.370 --> 00:25:46.730
那这个的话

00:25:46.730 --> 00:25:48.390
就是我们可以用一些

00:25:48.390 --> 00:25:49.870
这个检索工具

00:25:49.870 --> 00:25:51.030
比如说抓取一些新闻

00:25:51.030 --> 00:25:52.330
或者检索一些信息

00:25:52.330 --> 00:25:54.430
那这个的话

00:25:54.430 --> 00:25:55.930
我们可以用YOLO模式

00:25:55.930 --> 00:25:58.450
就是因为整个对话的话

00:25:58.450 --> 00:26:00.270
因为它要反复的给你去

00:26:00.270 --> 00:26:01.970
有一些问题

00:26:01.970 --> 00:26:02.550
你确认

00:26:02.550 --> 00:26:03.910
比如说能不能调用API

00:26:03.910 --> 00:26:04.990
能不能调用一些工具

00:26:04.990 --> 00:26:07.210
这个大家可以加一个YOLO

00:26:07.210 --> 00:26:08.350
加一个YOLO

00:26:08.350 --> 00:26:11.390
然后包括我们还加一个search

00:26:11.390 --> 00:26:12.990
就是我们可以去检索

00:26:12.990 --> 00:26:14.850
就是你把这个参数带进去

00:26:14.850 --> 00:26:18.150
他在默认的时候就会去达到这个search

00:26:18.150 --> 00:26:20.350
这么一个目的

00:26:21.450 --> 00:26:23.350
比如说我们退出去

00:26:23.350 --> 00:26:25.350
codex

00:26:26.250 --> 00:26:27.550
形容这个ULA模式

00:26:27.550 --> 00:26:35.350
然后再加上这个search

00:26:35.350 --> 00:26:37.350
加一个search

00:26:37.350 --> 00:26:49.990
比如说帮我抓取最最热门的十条AI资讯

00:26:55.790 --> 00:26:58.110
那我现在就要search了是吧

00:26:58.110 --> 00:26:58.910
要抓取嘛

00:26:58.910 --> 00:27:00.790
你看现在是不是就在search

00:27:00.790 --> 00:27:03.490
就你明确的加上这个search命令之后的话

00:27:03.490 --> 00:27:07.190
那么他接下来要工作的一个逻辑就是

00:27:07.350 --> 00:27:13.030
要优先从这个web这个search里面去拿那个结果

00:27:13.030 --> 00:27:13.330
是吧

00:27:13.330 --> 00:27:18.230
当然这个search结果是OpenAI自己维护的一个网页结果检索

00:27:18.230 --> 00:27:21.830
所以你看到的可能是这个缓存是吧

00:27:21.830 --> 00:27:24.290
但是也不一定是最新的抓取页面

00:27:24.290 --> 00:27:25.290
这个看情况

00:27:25.290 --> 00:27:27.430
得看他具体search的时候

00:27:27.430 --> 00:27:30.610
是不是调用了一些实时的API去search的

00:27:30.610 --> 00:27:32.250
他有可能会命中缓存啊

00:27:32.250 --> 00:27:34.750
所以大家看到结果不一定是对的

00:27:34.750 --> 00:27:36.470
所以这个最保险的话

00:27:36.470 --> 00:27:38.430
你就是还是要去指令一个API

00:27:38.430 --> 00:27:41.490
比如说使用这个Telry那个search

00:27:41.490 --> 00:27:43.050
使用Beamsearch

00:27:43.050 --> 00:27:45.190
这个指定的这个工具去search

00:27:45.190 --> 00:27:46.770
这样的话效果会更好一些

00:27:46.770 --> 00:27:51.050
你看这个结果

00:27:51.050 --> 00:27:52.250
5月31号

00:27:52.250 --> 00:27:56.390
结果还是看着好像是没什么问题的

00:27:56.390 --> 00:27:58.190
但是没抓到最新的是吧

00:27:58.190 --> 00:28:00.110
只抓到5月28号的

00:28:00.110 --> 00:28:02.030
所以这个里面还是会有一些缓存的

00:28:02.030 --> 00:28:04.290
它没有最新的嘛

00:28:04.290 --> 00:28:06.990
说明可能命中缓存了

00:28:06.990 --> 00:28:10.670
所以大家还可以去装一些插件啊

00:28:10.670 --> 00:28:13.970
比如说用Tile Research的这种方式去检索啊

00:28:13.970 --> 00:28:15.530
那么还有一些场景

00:28:15.530 --> 00:28:17.030
比如说我这个对话

00:28:17.030 --> 00:28:18.790
我不需要参考Web Search

00:28:18.790 --> 00:28:21.450
我永远以内部的一些文档为准

00:28:21.450 --> 00:28:24.050
那你就要把这个Web Search给disable掉

00:28:24.050 --> 00:28:24.670
关闭

00:28:24.670 --> 00:28:26.210
不然的话有时候去Search

00:28:26.210 --> 00:28:28.250
这个结果反而是不准的

00:28:28.250 --> 00:28:30.610
然后的话

00:28:30.610 --> 00:28:32.850
这个大家也可以去结合这个Codex

00:28:32.850 --> 00:28:35.110
这个非终端的这种方式

00:28:35.110 --> 00:28:35.390
是吧

00:28:35.390 --> 00:28:37.710
非交互式的去执行

00:28:37.710 --> 00:28:39.070
就你只要给结果啊

00:28:39.070 --> 00:28:41.750
我也不关心什么控制台聊天什么的

00:28:41.750 --> 00:28:43.630
就不需要关注这个点了

00:28:43.630 --> 00:28:50.790
然后是我们可以直接用输入提示词去运行

00:28:50.790 --> 00:28:53.430
就是我们前面给他讲

00:28:53.430 --> 00:28:54.190
这个Codex

00:28:54.190 --> 00:28:56.930
他的一个这个EXEC是吧

00:28:56.930 --> 00:28:59.290
这个交互式的

00:28:59.290 --> 00:29:01.450
就是各种交互式的话

00:29:01.450 --> 00:29:04.390
他都可以跳过这个交互式UI

00:29:04.390 --> 00:29:06.190
直接给结果

00:29:06.190 --> 00:29:06.850
并且的话

00:29:06.850 --> 00:29:08.750
你还可以加一些pass的参数

00:29:08.750 --> 00:29:11.450
然后去指定目录去做处理

00:29:11.450 --> 00:29:15.250
比如说我现在想切换到低盘

00:29:15.250 --> 00:29:17.950
比如我们加一个codex

00:29:17.950 --> 00:29:21.610
codex

00:29:21.610 --> 00:29:27.930
比如说我们想换一个

00:29:27.930 --> 00:29:30.750
分析一下

00:29:30.750 --> 00:29:32.290
这个项目

00:29:32.550 --> 00:29:33.310
然后

00:29:35.350 --> 00:29:36.390
pass

00:29:38.690 --> 00:29:39.450
d 盘

00:29:43.290 --> 00:29:44.310
codex

00:29:45.090 --> 00:29:46.870
然后我让他分析这个

00:29:47.130 --> 00:29:47.910
落一吧

00:29:47.910 --> 00:29:48.930
分析这个项目

00:29:58.910 --> 00:30:00.190
这里输错了

00:30:00.750 --> 00:30:02.750
exec

00:30:10.750 --> 00:30:12.750
pass

00:30:14.750 --> 00:30:16.750
notFont

00:30:16.750 --> 00:30:19.750
要加到前面去

00:30:30.750 --> 00:30:34.750
分析一下这个项目

00:30:40.750 --> 00:30:42.750
去PASS一个value

00:30:45.750 --> 00:30:48.750
这里直接这样试一下

00:30:48.750 --> 00:30:50.750
那我就

00:30:52.750 --> 00:30:54.750
没事我就让那个来修正

00:30:54.750 --> 00:30:56.750
让Codex帮我修正吧

00:30:56.750 --> 00:30:59.750
我们也不知道哪个地方有问题是吧

00:31:00.750 --> 00:31:08.950
帮我修正下这个命令输出

00:31:08.950 --> 00:31:10.550
这我们遇到问题

00:31:10.550 --> 00:31:12.250
直接让Codex帮我们修正就完了

00:31:12.250 --> 00:31:14.930
他会自己去查帮助文档

00:31:14.930 --> 00:31:16.670
帮我们去优化这个命令呢

00:31:16.670 --> 00:31:19.430
所以有问题也没关系

00:31:19.430 --> 00:31:21.710
直接让他输出就可以了

00:31:21.710 --> 00:31:25.850
然后用-c

00:31:25.850 --> 00:31:30.210
不在get仓库里面加-c

00:31:30.210 --> 00:31:32.310
在get仓库里面

00:31:32.310 --> 00:31:33.670
那我们就用c吧

00:31:33.670 --> 00:31:35.510
它不是pass啊

00:31:35.510 --> 00:31:35.730
好

00:31:35.730 --> 00:31:36.670
我推出去

00:31:36.670 --> 00:31:40.890
好可以了

00:31:40.890 --> 00:31:42.170
要用-c啊

00:31:42.170 --> 00:31:44.090
就不是pass了

00:31:44.090 --> 00:31:47.570
那现在是不是就可以了

00:31:47.570 --> 00:31:47.890
是吧

00:31:47.890 --> 00:31:51.110
他会帮我们把这个整个目录给他分析一下啊

00:31:51.110 --> 00:31:52.870
这个就是

00:31:54.025 --> 00:31:59.025
這個就是我們可以用非交互式的方式去用一些。

00:31:59.025 --> 00:32:01.025
然後是審批模式。

00:32:01.025 --> 00:32:05.025
那這個審批模式的話,這裡面是什麼意思呢?

00:32:05.025 --> 00:32:07.025
比如說大家,

00:32:07.025 --> 00:32:09.525
你现在习惯到Codex

00:32:09.525 --> 00:32:12.105
你让他执行一些命令是吧

00:32:12.105 --> 00:32:14.065
那有些情况下

00:32:14.065 --> 00:32:15.745
执行一些命令是需要授权的

00:32:15.745 --> 00:32:18.365
这里面他有几种授权模式啊

00:32:18.365 --> 00:32:19.165
叫Promissions

00:32:19.165 --> 00:32:23.405
默认的话是这个需要授权啊

00:32:23.405 --> 00:32:24.825
比如说你跑一些编辑文件

00:32:24.825 --> 00:32:25.905
一些敏感命令的时候

00:32:25.905 --> 00:32:26.905
他是需要授权的

00:32:26.905 --> 00:32:30.565
或者是你只分析一些文档

00:32:30.565 --> 00:32:30.865
是吧

00:32:30.865 --> 00:32:31.945
你不想编辑的话

00:32:31.945 --> 00:32:32.725
你就用ReadOn

00:32:32.725 --> 00:32:34.425
他不能改

00:32:34.425 --> 00:32:36.065
你就用只读模式

00:32:36.065 --> 00:32:39.485
这个是非管理员的这个杀箱模式

00:32:39.485 --> 00:32:40.745
这是推荐的啊

00:32:40.745 --> 00:32:42.745
运行一些敏感命令是需要授权的

00:32:42.745 --> 00:32:45.765
特别是访问一些网络编辑一些文件的时候需要授权

00:32:45.765 --> 00:32:48.485
然后第三个的话是自动的review

00:32:48.485 --> 00:32:50.345
他会根据实际的一些情况

00:32:50.345 --> 00:32:52.925
是针对性的去做一些审查

00:32:52.925 --> 00:32:55.565
但是在某些情况下还是需要授权的

00:32:55.565 --> 00:32:57.425
全访问就是yolo模式

00:32:57.425 --> 00:33:01.765
就是我们现在是不需要任何授权了

00:33:01.765 --> 00:33:03.105
直接什么命令都可以执行

00:33:03.105 --> 00:33:04.805
然后在这个APP里面

00:33:04.805 --> 00:33:06.145
这边有也有一个啊

00:33:06.145 --> 00:33:09.905
左下角你看默认权限自动审查啊

00:33:09.905 --> 00:33:11.525
如果大家做项目开发的话

00:33:11.525 --> 00:33:14.405
你如果不想有很多交互性的东西出来的话

00:33:14.405 --> 00:33:17.285
你就选最后一个完全防御权限就完事了啊

00:33:17.285 --> 00:33:18.345
这个很好理解

00:33:18.345 --> 00:33:20.385
就是把所有的权限都给codex

00:33:20.385 --> 00:33:21.425
让他去干活

00:33:21.425 --> 00:33:24.405
不需要给你反复确认啊

00:33:24.405 --> 00:33:27.905
因为这个反老师要你确认的话也挺烦的啊

00:33:27.905 --> 00:33:28.625
耽误时间

00:33:28.625 --> 00:33:34.785
然后是脚本化的这个方式去执行这个codex

00:33:34.785 --> 00:33:37.405
那这个的话就是我们

00:33:37.405 --> 00:33:40.305
比如说现在想用

00:33:40.305 --> 00:33:42.405
这个exec的子命令

00:33:42.405 --> 00:33:44.845
然后去接入自动化的一些工作

00:33:44.845 --> 00:33:47.405
包括我们想接入传统的一些摄要脚本

00:33:47.405 --> 00:33:49.345
大家就可以把这个codex

00:33:49.345 --> 00:33:52.225
exec这个命令给它整合成一个脚本

00:33:52.225 --> 00:33:53.105
是吧

00:33:53.105 --> 00:33:55.225
比如说我们现在

00:33:55.225 --> 00:33:58.145
应该也可以结合GERP

00:33:58.145 --> 00:33:59.665
EP那个命令

00:33:59.665 --> 00:34:02.665
比如说我们现在来分析一下

00:34:02.665 --> 00:34:07.125
可以怎么来用呢

00:34:07.125 --> 00:34:07.965
比如说我现在

00:34:07.965 --> 00:34:09.665
你看这个目录下面

00:34:09.665 --> 00:34:11.185
现在有很多目录文件是吧

00:34:11.185 --> 00:34:13.125
那我们想让它分析一下

00:34:13.125 --> 00:34:19.225
比如说分析一下

00:34:19.225 --> 00:34:23.085
当前有哪些目录

00:34:23.085 --> 00:34:24.645
然后这里面

00:34:24.645 --> 00:34:27.445
我看这里面用这个gr1p

00:34:27.445 --> 00:34:31.945
然后这个用这个络一给它过滤一下

00:34:32.665 --> 00:34:34.825
看这样行不行

00:34:34.825 --> 00:34:37.965
我们把这个复制一下

00:34:37.965 --> 00:34:39.505
这个命令是错的

00:34:39.505 --> 00:34:42.065
那我们就用Codex来输出一下

00:34:42.065 --> 00:34:46.545
帮我修正一下这个命令

00:34:46.545 --> 00:34:53.485
就我想让他理解一下

00:34:53.485 --> 00:34:56.745
我们想要整合这个GIP的一些命令

00:34:56.745 --> 00:34:59.625
那他可能啊

00:34:59.625 --> 00:35:01.065
这个windows下面没有GIP

00:35:01.065 --> 00:35:03.225
所以他会推荐其他的这个命令

00:35:03.225 --> 00:35:05.325
所以你装了RG

00:35:05.325 --> 00:35:06.325
你可以用这个命令

00:35:06.325 --> 00:35:09.145
如果说你没有那个RG的话

00:35:09.145 --> 00:35:10.185
你就可以用这个命令

00:35:10.185 --> 00:35:18.185
这个还要加一个

00:35:26.185 --> 00:35:26.585
Trust

00:35:26.585 --> 00:35:34.385
看一下

00:35:34.385 --> 00:35:37.925
看是不是还少了什么

00:35:37.925 --> 00:35:45.965
帮我修正下命令

00:35:45.965 --> 00:35:49.925
没事哪里有问题啊

00:35:49.925 --> 00:35:52.545
禅数放错了

00:35:52.545 --> 00:35:54.925
应该先要放前面啊

00:35:54.925 --> 00:35:56.565
好追出去

00:35:56.585 --> 00:36:07.305
这个什么意思呢

00:36:07.305 --> 00:36:10.385
就是我们可以把这个子命令

00:36:10.385 --> 00:36:14.005
exec这个子命令和shale脚本组合起来

00:36:14.005 --> 00:36:15.345
但是winsor下面没有shale

00:36:15.345 --> 00:36:16.345
它是powershell

00:36:16.345 --> 00:36:18.725
它不是linux上面那个bashhell

00:36:18.725 --> 00:36:21.985
那它也可以结合那个powershell的一些命令

00:36:21.985 --> 00:36:22.985
给它做一些组合

00:36:22.985 --> 00:36:26.285
比如说我们想用这个Codex

00:36:26.285 --> 00:36:27.545
给你做完分析之后

00:36:27.545 --> 00:36:29.005
再用PowerShell的一些命令

00:36:29.005 --> 00:36:29.925
给它做些处理

00:36:29.925 --> 00:36:31.025
那这样的话

00:36:31.025 --> 00:36:32.945
也能拿到我们想要的一个结果

00:36:32.945 --> 00:36:34.605
你看这个里面

00:36:34.605 --> 00:36:35.725
它分析完之后

00:36:35.725 --> 00:36:37.405
给你把落一的这个结果

00:36:37.405 --> 00:36:38.145
给你输出了

00:36:38.145 --> 00:36:38.465
是吧

00:36:38.465 --> 00:36:39.605
三级目

00:36:39.605 --> 00:36:41.505
然后单独给你分析出来了

00:36:41.505 --> 00:36:44.025
这个就是它用了一些

00:36:44.025 --> 00:36:45.345
search的这种方式

00:36:45.345 --> 00:36:49.585
就是我们加了一些特殊的这个处理

00:36:49.585 --> 00:36:49.945
是吧

00:36:49.945 --> 00:36:50.945
做一些过滤

00:36:50.945 --> 00:36:52.505
就是你

00:36:52.505 --> 00:36:53.885
在Linux上面

00:36:53.885 --> 00:36:55.425
你就可以用GIEP的命令

00:36:55.425 --> 00:36:56.705
给它做一些处理

00:36:56.705 --> 00:36:59.905
这个就是脚本化的方式去执行

00:36:59.905 --> 00:37:01.585
然后的话

00:37:01.585 --> 00:37:02.985
就是我们还可以用at

00:37:02.985 --> 00:37:04.685
这个其实刚刚也给它演示

00:37:04.685 --> 00:37:06.325
我们可以at一些文件

00:37:06.325 --> 00:37:08.465
at指定的一些目录

00:37:08.465 --> 00:37:09.805
去做一些分析

00:37:09.805 --> 00:37:11.925
比如说我们现在

00:37:11.925 --> 00:37:14.685
锅一下面有这个box

00:37:14.685 --> 00:37:15.225
是吧

00:37:15.225 --> 00:37:18.225
有一个box的一个目录

00:37:18.225 --> 00:37:21.285
那你就可以切进去

00:37:21.285 --> 00:37:25.885
比如说cd到络一Codex

00:37:25.885 --> 00:37:33.285
帮我分析一下目录的作用

00:37:33.285 --> 00:37:36.285
atbox

00:37:48.285 --> 00:37:49.285
你就直接at

00:37:49.285 --> 00:37:51.045
at指定的一个文件

00:37:51.045 --> 00:37:53.125
比如说让他review或者怎么样的

00:37:53.125 --> 00:37:55.865
刚刚就是用一个review的命令

00:37:55.865 --> 00:37:58.185
给他演示了一下整个的一个逻辑

00:37:58.185 --> 00:37:58.545
是吧

00:37:58.545 --> 00:38:02.905
在这个里面他就可以去做一个分析

00:38:02.905 --> 00:38:08.825
然后我们还可以去加一些目录

00:38:08.825 --> 00:38:09.205
是吧

00:38:09.205 --> 00:38:10.845
然后在这个里面

00:38:10.845 --> 00:38:11.765
比如说cp

00:38:11.765 --> 00:38:14.585
这个加很多一些关联的一些目录

00:38:14.585 --> 00:38:15.945
all目录

00:38:15.945 --> 00:38:18.105
因为有时候我们这个项目

00:38:18.105 --> 00:38:19.485
就是有多个模块

00:38:19.485 --> 00:38:21.425
就在大家打开一个工程

00:38:21.425 --> 00:38:22.785
你下面发现有多个目录

00:38:22.785 --> 00:38:23.245
你都要编

00:38:24.258 --> 00:38:27.258
有前端的,有後端的。

00:38:27.258 --> 00:38:32.258
比如說像洛伊這個,大家看,它外面都是後端的。

00:38:32.258 --> 00:38:36.258
只有這個目錄是前端的,這個是前端的頁面,這個後端。

00:38:36.258 --> 00:38:39.478
有时候你可能需要暴露一些

00:38:39.478 --> 00:38:40.898
可以写的根目录

00:38:40.898 --> 00:38:42.118
因为他当前操作

00:38:42.118 --> 00:38:43.738
只在当前绘画嘛

00:38:43.738 --> 00:38:44.938
比如说跨目录了

00:38:44.938 --> 00:38:45.318
是吧

00:38:45.318 --> 00:38:46.498
有些在D盘

00:38:46.498 --> 00:38:47.098
有些在E盘

00:38:47.098 --> 00:38:47.838
有些在F盘

00:38:47.838 --> 00:38:48.818
这几个目录

00:38:48.818 --> 00:38:51.018
你都要跨目录操作的时候

00:38:51.018 --> 00:38:52.558
那你就要把权限配置一下

00:38:52.558 --> 00:38:54.578
让他可以暴露更多的根目录

00:38:54.578 --> 00:38:56.578
因为他默认只能操作当前绘画的

00:38:56.578 --> 00:38:57.058
是吧

00:38:57.058 --> 00:38:57.958
所以这个里面

00:38:57.958 --> 00:38:59.878
大家可以去指定更多的目录

00:38:59.878 --> 00:39:01.238
然后去做一个处理

00:39:01.238 --> 00:39:04.458
你看这个

00:39:04.458 --> 00:39:05.618
他们帮分析出来的

00:39:05.618 --> 00:39:07.438
Dock下面的一些目录是吧

00:39:07.438 --> 00:39:08.118
这个是我们

00:39:08.118 --> 00:39:09.018
at

00:39:09.018 --> 00:39:10.958
at那个Dock之后的一个结果

00:39:10.958 --> 00:39:14.318
所以大家可以多用一下这个at功能

00:39:14.318 --> 00:39:15.758
然后在这个里面

00:39:15.758 --> 00:39:17.598
可以去执行一下

00:39:17.598 --> 00:39:19.258
一些不同的这个结果

00:39:19.258 --> 00:39:23.158
然后我们还可以去执行一些这个命令

00:39:23.158 --> 00:39:24.478
加一些CD

00:39:24.478 --> 00:39:27.438
就是你可以在命令里面

00:39:27.438 --> 00:39:29.798
单独去指定一些参数

00:39:29.798 --> 00:39:30.878
要么加目录

00:39:30.878 --> 00:39:32.518
要么加一些指定

00:39:32.518 --> 00:39:32.938
是吧

00:39:32.938 --> 00:39:34.558
这个都是OK的

00:39:34.558 --> 00:39:37.838
然后最好我们就是在启动的时候

00:39:37.838 --> 00:39:38.878
把环境就准备好了

00:39:38.878 --> 00:39:40.698
这样子不会去浪费token

00:39:40.698 --> 00:39:41.538
还要去记忽什么

00:39:41.538 --> 00:39:44.438
因为你一开始没把这些环境准备好的话

00:39:44.438 --> 00:39:45.698
你跟他提问

00:39:45.698 --> 00:39:47.498
他又要产生各种各样的对话

00:39:47.498 --> 00:39:50.138
然后再来说让你去加一些权限

00:39:50.138 --> 00:39:52.018
就白白就浪费token了

00:39:52.018 --> 00:39:52.978
因为他就探测

00:39:52.978 --> 00:39:54.838
这个里面会带来一些

00:39:54.838 --> 00:39:56.638
不必要的一些token消耗

00:39:56.638 --> 00:39:59.418
所以大家首先你要把一些

00:39:59.418 --> 00:40:00.818
python的什么虚拟环境

00:40:00.818 --> 00:40:02.758
或者其他的一些语言环境

00:40:02.758 --> 00:40:04.398
比如说你coda

00:40:04.398 --> 00:40:05.758
一些python

00:40:05.758 --> 00:40:06.818
这些个环境

00:40:06.818 --> 00:40:07.678
你现在给它激活

00:40:07.678 --> 00:40:08.958
激活完之后

00:40:08.958 --> 00:40:10.258
相当于codex在

00:40:10.258 --> 00:40:11.858
直接命令的时候

00:40:11.858 --> 00:40:12.898
你跟它对话的时候

00:40:12.898 --> 00:40:14.478
这些个环境的话

00:40:14.478 --> 00:40:15.858
已经都整合好了

00:40:15.858 --> 00:40:17.258
都已经准备好了

00:40:17.258 --> 00:40:19.178
只有大家直接用就可以了

00:40:19.178 --> 00:40:21.478
所以说我们一开始的话

00:40:21.478 --> 00:40:23.158
你得把一些这个环境

00:40:23.158 --> 00:40:24.598
都准备好

00:40:24.598 --> 00:40:25.918
包括一些目录的话

00:40:25.918 --> 00:40:27.098
你得提前规划好

00:40:27.098 --> 00:40:29.638
在一些初始化命令的时候

00:40:29.638 --> 00:40:31.318
就是大家比如说

00:40:31.318 --> 00:40:34.258
你想把Codex整合到公司的一些

00:40:34.258 --> 00:40:36.638
传统的事要脚本里面去

00:40:36.638 --> 00:40:37.378
把它做一个命令

00:40:37.378 --> 00:40:38.178
做一个执行的话

00:40:38.178 --> 00:40:40.058
你得先给它把环境配好

00:40:40.058 --> 00:40:41.418
配好完了之后的话

00:40:41.418 --> 00:40:45.218
然后当我们执行Codex命令的时候

00:40:45.218 --> 00:40:46.958
这些上下文都已经出手法好了

00:40:46.958 --> 00:40:49.898
比如说一些运维扫描的一些目录

00:40:49.898 --> 00:40:50.458
是吧

00:40:50.458 --> 00:40:51.678
一些监控的目录在哪里

00:40:51.678 --> 00:40:52.938
一些日制目录在哪里

00:40:52.938 --> 00:40:54.638
你把这些目录都给它

00:40:54.638 --> 00:40:55.738
它准备好了

00:40:55.738 --> 00:40:57.498
那你对话的时候

00:40:57.498 --> 00:40:58.778
你就直接跟它提问你就完了

00:40:58.778 --> 00:41:00.558
比如说帮我把日制目录

00:41:00.558 --> 00:41:01.798
下面的文件清理一下

00:41:01.798 --> 00:41:05.338
帮我把那些个这个数据抓取一下

00:41:05.338 --> 00:41:07.558
你就直接这样去说就可以了

00:41:07.558 --> 00:41:08.918
因为他已经有了上线文

00:41:08.918 --> 00:41:10.298
这些目录他都知道了

00:41:10.298 --> 00:41:13.078
所以说就不会浪费token了

00:41:13.078 --> 00:41:15.298
这个就是提示与快捷方式

00:41:15.298 --> 00:41:16.218
这个就是

00:41:16.218 --> 00:41:20.178
我们要给他讲的一些内容