WEBVTT

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

00:00:15.920 --> 00:00:17.080
那这里的话

00:00:17.080 --> 00:00:18.960
我给他做一个简单的概述啊

00:00:18.960 --> 00:00:22.980
Codex是OpenAI官方推出的一款AI变成工具啊

00:00:22.980 --> 00:00:24.240
但这个目前

00:00:24.240 --> 00:00:27.700
这个已经不仅仅局限于AI变成这一块了啊

00:00:27.700 --> 00:00:29.340
他能做的事情非常多啊

00:00:29.340 --> 00:00:30.760
怎么等一下逐步来展开

00:00:30.760 --> 00:00:35.720
那么大家可以通过这个官方的一个文档啊

00:00:35.720 --> 00:00:40.300
如果想去深入的了解Codex所有的一些细节的话啊

00:00:40.300 --> 00:00:42.380
我建议大家去看一下这个OpenAI

00:00:42.380 --> 00:00:45.860
出的这个官方的这个开发者文档

00:00:45.860 --> 00:00:47.520
这个是给开发人员看的

00:00:47.520 --> 00:00:49.760
里面的一些文档的话写的非常详细

00:00:49.760 --> 00:00:52.940
大家对一些概念性的论知

00:00:52.940 --> 00:00:56.660
包括一些比如说我们来查一些指南

00:00:56.660 --> 00:00:59.460
大家都可以通过这个文档做一个路手

00:00:59.460 --> 00:01:01.760
所以说这是一份非常好的学习资料

00:01:01.760 --> 00:01:03.480
这是我推荐给大家的

00:01:03.480 --> 00:01:05.400
然后的话是Codex的话

00:01:05.400 --> 00:01:07.440
它有一些模块的话

00:01:07.440 --> 00:01:08.300
它是开源的

00:01:08.300 --> 00:01:11.760
如果大家对它的底层原码感兴趣

00:01:11.760 --> 00:01:13.100
比如说像CLI

00:01:13.100 --> 00:01:13.820
是吧

00:01:13.820 --> 00:01:14.780
还有一些这个

00:01:14.780 --> 00:01:17.020
他的一些文档呀

00:01:17.020 --> 00:01:17.400
你看

00:01:17.400 --> 00:01:20.800
比如说他的一些agents.md的一些这个细节文档

00:01:20.800 --> 00:01:22.820
大家如果感兴趣啊

00:01:22.820 --> 00:01:26.180
可以去他的这个开源的这个仓库里面

00:01:26.180 --> 00:01:27.660
去深入的去研究一下

00:01:27.660 --> 00:01:32.100
这个也是我给大家提供的一份这个学习资料

00:01:32.100 --> 00:01:33.520
就是这个路口

00:01:33.520 --> 00:01:35.520
大家可以从这个地方去路手

00:01:35.520 --> 00:01:38.300
如果你对他的这个圆码也比较感兴趣

00:01:38.300 --> 00:01:40.940
像参与这个Codex

00:01:40.940 --> 00:01:42.260
他的一个开源建设的话

00:01:42.260 --> 00:01:44.720
大家可以在这个里面去做一个路手

00:01:44.720 --> 00:01:45.460
OK

00:01:45.460 --> 00:01:48.860
这个就是我给大家推荐的这个两份学习资料啊

00:01:48.860 --> 00:01:54.000
然后下面这个的话是CodexAPP的这么一个页面啊

00:01:54.000 --> 00:01:57.460
最开始的话Codex是没有APP版本的啊

00:01:57.460 --> 00:01:59.540
它是基于这个CLI命令行的

00:01:59.540 --> 00:02:02.000
所以最早期大家使用的话啊

00:02:02.000 --> 00:02:04.060
基本上是基于这个命令行啊

00:02:04.060 --> 00:02:08.320
比如说我们在这个里面输入一个这个Codex是吧

00:02:08.320 --> 00:02:10.080
那我们进入到这个命令行页面

00:02:10.080 --> 00:02:13.060
直接就可以做一个AI编程了

00:02:13.060 --> 00:02:14.860
我们最开始的使用方式是这样的

00:02:14.860 --> 00:02:15.360
但是的话

00:02:15.360 --> 00:02:18.560
目前的话Codex已经出了这个APP了

00:02:18.560 --> 00:02:19.760
然后也非常好用

00:02:19.760 --> 00:02:20.460
等一下的话

00:02:20.460 --> 00:02:21.760
我们就来给他讲一下

00:02:21.760 --> 00:02:24.060
这个APP的一个安装跟使用

00:02:24.060 --> 00:02:30.200
所以我们主要是基于这个CLI和这个APP

00:02:30.200 --> 00:02:32.160
混合的这种方式去使用

00:02:32.160 --> 00:02:32.960
还有的话

00:02:32.960 --> 00:02:35.200
就是他还有一种插件形式的

00:02:35.200 --> 00:02:39.000
就是我们可以用这个Coser或者VSCode

00:02:39.000 --> 00:02:42.800
大家可以去装一个这个Coser

00:02:42.800 --> 00:02:45.340
就是整个它有一个Codex插件

00:02:45.340 --> 00:02:46.640
这个也比较好用

00:02:46.640 --> 00:02:50.160
这个的话如果大家习惯性用这个WasteCode

00:02:50.160 --> 00:02:51.280
或者是Coser的话

00:02:51.280 --> 00:02:52.740
你可以把这个插件

00:02:52.740 --> 00:02:54.400
装一个Codex插件

00:02:54.400 --> 00:02:57.340
然后跟我们的这个编码结合起来去用

00:02:57.340 --> 00:02:58.560
这也是OK的

00:02:58.560 --> 00:03:00.880
这也是我比较推荐大家用的一种方式

00:03:00.880 --> 00:03:02.120
如果你既要改代码

00:03:02.120 --> 00:03:04.220
又要去做这个

00:03:04.220 --> 00:03:06.480
你想用这个Codex的话

00:03:06.480 --> 00:03:07.400
都是OK的

00:03:07.400 --> 00:03:10.020
但你不在这个里面装插件

00:03:10.020 --> 00:03:10.920
你用那个APP

00:03:10.920 --> 00:03:12.680
然后或者是CLI

00:03:12.680 --> 00:03:13.700
也是没有问题的

00:03:13.700 --> 00:03:15.300
只是说在这个里面的话

00:03:15.300 --> 00:03:17.020
切换就会比较简单一些

00:03:17.020 --> 00:03:19.740
不然的话你要切换这个窗口

00:03:19.740 --> 00:03:21.660
还是稍微有那么一点麻烦

00:03:21.660 --> 00:03:23.480
不过这个都是小问题

00:03:23.480 --> 00:03:25.260
所以说它的使用方式有

00:03:25.260 --> 00:03:26.340
基本上就是三种

00:03:26.340 --> 00:03:28.240
第一种的话就是我们用这个APP

00:03:28.240 --> 00:03:30.440
然后第二种的话就是用CLI

00:03:30.440 --> 00:03:32.680
还有的话就是一个插件形式

00:03:32.680 --> 00:03:34.640
基本上目前主流的使用方式的话

00:03:34.640 --> 00:03:35.320
就是三个

00:03:35.320 --> 00:03:38.200
那么它主要啊

00:03:38.200 --> 00:03:41.740
如果说在做这个AI编程这一块的话

00:03:41.740 --> 00:03:43.220
它主要的功能有哪些呢

00:03:43.220 --> 00:03:44.620
首先第一块的话啊

00:03:44.620 --> 00:03:46.640
写代码就是一个基础功能的

00:03:46.640 --> 00:03:48.480
那么在Codex里面的话

00:03:48.480 --> 00:03:51.220
大家可以非常方便的去使用一些快捷指令

00:03:51.220 --> 00:03:53.400
然后采用这种对话的方式

00:03:53.400 --> 00:03:56.440
去让它去帮你去生成这个代码

00:03:56.440 --> 00:03:58.480
或者说整个去开发一个项目

00:03:58.480 --> 00:04:00.400
搭建一个项目架构都是OK的

00:04:00.400 --> 00:04:01.780
还有一点的话

00:04:01.780 --> 00:04:04.900
就是我们可以用Codex去学习一些

00:04:04.900 --> 00:04:06.180
优秀的开源项目

00:04:06.180 --> 00:04:08.980
比如说大家对这个开源项目比较感兴趣

00:04:08.980 --> 00:04:10.460
就是把这个项目拉下来

00:04:10.460 --> 00:04:13.480
然后通过Codex命令去分析一下

00:04:13.480 --> 00:04:14.740
当前这个项目的话

00:04:14.740 --> 00:04:16.340
它的一个结构是怎么样的

00:04:16.340 --> 00:04:18.300
包括大家在公司里面

00:04:18.300 --> 00:04:22.120
你去接手一些历史的一些遗留项目

00:04:22.120 --> 00:04:22.420
是吧

00:04:22.420 --> 00:04:24.200
一些代码你看不懂怎么办呢

00:04:24.200 --> 00:04:25.720
那你也可以用Codex

00:04:25.720 --> 00:04:27.940
可以去帮你去做一个阅读

00:04:27.940 --> 00:04:30.200
然后帮助你快速的去理解

00:04:30.200 --> 00:04:33.120
团队是如何去做一个开发的

00:04:33.120 --> 00:04:34.380
然后包括里面的细节问题

00:04:34.380 --> 00:04:36.660
他都可以通过Codex去把它分析出来

00:04:36.660 --> 00:04:37.940
这也是一个场景

00:04:37.940 --> 00:04:40.380
然后的话就是审查代码

00:04:40.380 --> 00:04:42.740
那以前我们做那个代码审查的话

00:04:42.740 --> 00:04:45.500
大家习惯性的要去看那个PR是吧

00:04:45.500 --> 00:04:47.620
看PR里面的这个commit

00:04:47.620 --> 00:04:49.540
DIF里面到底给了哪些文件

00:04:49.540 --> 00:04:50.680
然后看一下有没有漏洞

00:04:50.680 --> 00:04:51.680
然后有问题的话

00:04:51.680 --> 00:04:53.100
还得上面标注一下

00:04:53.100 --> 00:04:54.400
以前的话

00:04:54.400 --> 00:04:56.560
这个需要耗费大量的这个人工成本

00:04:56.560 --> 00:04:58.360
专门需要一个代码审查

00:04:58.360 --> 00:05:00.520
那现在有了Codex之后的话

00:05:00.520 --> 00:05:01.800
我们做代码审查的话

00:05:01.800 --> 00:05:02.840
其实会非常简单

00:05:02.840 --> 00:05:04.400
就是这个里面的话

00:05:04.400 --> 00:05:05.640
他会去分析

00:05:05.640 --> 00:05:09.360
他有专门的review的这么一个斜杠命令

00:05:09.360 --> 00:05:11.680
这个我们等一下会给大家讲这么一个案例

00:05:11.680 --> 00:05:14.700
就是我们可以用review的一个命令

00:05:14.700 --> 00:05:16.680
去快速的去分析本次

00:05:16.680 --> 00:05:18.920
比如说我还没有提交的一些代码

00:05:18.920 --> 00:05:19.920
我想让他分析一下

00:05:19.920 --> 00:05:21.760
或者说我们已经提交的PR

00:05:21.760 --> 00:05:23.560
这个代码有没有问题

00:05:23.560 --> 00:05:26.180
也可以分析出来

00:05:26.180 --> 00:05:27.700
让我们根据这个结果

00:05:27.700 --> 00:05:29.400
最后去把这个代码

00:05:29.400 --> 00:05:31.480
就是给提一些建议

00:05:31.480 --> 00:05:33.780
或者给他拒绝这个皮牙合并

00:05:33.780 --> 00:05:34.140
是吧

00:05:34.140 --> 00:05:35.860
这个就是我们做代码审查

00:05:35.860 --> 00:05:37.560
可以结合Codex做的一些事情

00:05:37.560 --> 00:05:38.660
然后的话

00:05:38.660 --> 00:05:40.680
大家还可以通过Codex去

00:05:40.680 --> 00:05:42.740
排查一些线上的一些问题

00:05:42.740 --> 00:05:43.100
是吧

00:05:43.100 --> 00:05:44.400
比如我们线上发现一些bug

00:05:44.400 --> 00:05:45.400
有一些日志

00:05:45.400 --> 00:05:47.100
他定位了一些代码行

00:05:47.100 --> 00:05:49.100
那我们把这些日志提供给Codex

00:05:49.100 --> 00:05:49.900
那Codex的话

00:05:49.900 --> 00:05:51.920
可以快速的去帮我们找到

00:05:51.920 --> 00:05:53.400
这个代码到底哪里出问题了

00:05:53.400 --> 00:05:55.500
并针对性的给一些修复方案出来

00:05:55.500 --> 00:05:57.000
所以这个也是一个

00:05:57.000 --> 00:05:59.360
比较好的一个应用方向

00:05:59.360 --> 00:06:01.420
然后最后一个的话

00:06:01.420 --> 00:06:03.340
就是自动化开发任务啊

00:06:03.340 --> 00:06:05.220
那这一块也是用的比较多的一个场景

00:06:05.220 --> 00:06:07.920
那就是说我们可以通过Codex啊

00:06:07.920 --> 00:06:10.540
就是从零到一去做一个项目的一个开发

00:06:10.540 --> 00:06:11.720
那我们等一下的话

00:06:11.720 --> 00:06:13.460
也会带大家去基于这个流程

00:06:13.460 --> 00:06:14.800
去做一个项目啊

00:06:14.800 --> 00:06:16.120
就是从需求分析开始

00:06:16.120 --> 00:06:20.400
到整个的一个项目的一个功能拆解啊

00:06:20.400 --> 00:06:20.740
是吧

00:06:20.740 --> 00:06:22.020
核心功能开发呀

00:06:22.020 --> 00:06:23.180
包括测试啊

00:06:23.180 --> 00:06:25.480
包括整个的一个啊

00:06:25.480 --> 00:06:26.240
调试啊

00:06:26.240 --> 00:06:26.500
是吧

00:06:26.500 --> 00:06:31.100
这个我们等一下都会给大家去走一遍啊

00:06:31.100 --> 00:06:32.600
所以这几个场景的话

00:06:32.600 --> 00:06:33.800
都是Codex

00:06:33.800 --> 00:06:36.340
它比较擅长

00:06:36.340 --> 00:06:38.580
或者说比较主流的一些应用场景

00:06:38.580 --> 00:06:40.060
那么Codex

00:06:40.060 --> 00:06:42.260
它的一个核心能力有哪些呢

00:06:42.260 --> 00:06:45.160
大家要比较好的去使用Codex的话

00:06:45.160 --> 00:06:47.260
首先要对它的一个核心能力

00:06:47.260 --> 00:06:49.420
或者说对它整个的一个功能架构的话

00:06:49.420 --> 00:06:51.000
有一个认知

00:06:51.000 --> 00:06:52.520
就是要有一个大的认知

00:06:52.520 --> 00:06:53.040
这样的话

00:06:53.040 --> 00:06:55.260
你在去做一些开发的时候

00:06:55.260 --> 00:06:55.900
你就会想到

00:06:55.900 --> 00:06:58.120
原来Codex已经集成这个能力了

00:06:58.120 --> 00:07:00.480
那大家去直接把它去应用到

00:07:00.480 --> 00:07:01.700
工作当中去的话

00:07:01.700 --> 00:07:03.360
那这个提效就很明显了

00:07:03.360 --> 00:07:04.640
那大家可以看一下

00:07:04.640 --> 00:07:05.860
整个的一个

00:07:05.860 --> 00:07:07.320
它的一个能力

00:07:07.320 --> 00:07:09.880
那能力的话是非常多了

00:07:09.880 --> 00:07:11.100
最主要的话

00:07:11.100 --> 00:07:13.080
就是它的一个多任务处理

00:07:13.080 --> 00:07:14.240
就是多线程

00:07:14.240 --> 00:07:16.480
大家在用这个Codex过程中

00:07:16.480 --> 00:07:17.840
你会发现一个点

00:07:17.840 --> 00:07:19.300
就是整个

00:07:19.300 --> 00:07:21.440
它是基于多线程的一个机制

00:07:21.440 --> 00:07:22.960
就是你不断的跟它去对话

00:07:22.960 --> 00:07:24.940
它会不断的去起

00:07:24.940 --> 00:07:25.860
各种各样的线程

00:07:25.860 --> 00:07:26.860
帮你去完成任务

00:07:26.860 --> 00:07:28.640
并且最终做一个合并

00:07:28.640 --> 00:07:31.240
所以它的一个跨项目的

00:07:31.240 --> 00:07:32.900
多任务处理能力非常强

00:07:32.900 --> 00:07:36.560
就是你可以让它同时去开发三个项目

00:07:36.560 --> 00:07:37.940
开三个这个县城

00:07:37.940 --> 00:07:38.500
是吧

00:07:38.500 --> 00:07:39.240
然后最终

00:07:39.240 --> 00:07:42.820
比如说我们想让它分析三个项目的一个细节

00:07:42.820 --> 00:07:44.980
然后分析完之后做一个总结归纳

00:07:45.384 --> 00:07:47.184
最后给你输出一张表格。

00:07:47.184 --> 00:07:48.884
那他就是启动三个县程。

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

00:07:52.984 --> 00:07:55.084
这是他的一个非常强大的一个能力。

00:07:55.084 --> 00:07:59.684
然后的话,他里面内置了一个叫Git WorkTree的一个这么一个机制。

00:07:59.684 --> 00:08:01.444
它的一个优点是什么

00:08:01.444 --> 00:08:03.344
就是我们可以在一个分支下面

00:08:03.344 --> 00:08:06.044
可以支持加多个这个work tree

00:08:06.044 --> 00:08:07.424
然后去并行开发

00:08:07.424 --> 00:08:09.384
以前的话我们开发的话

00:08:09.384 --> 00:08:11.624
就是都要做分支隔离的是吧

00:08:11.624 --> 00:08:15.864
比如说某某同学是做这个A分支

00:08:15.864 --> 00:08:17.044
某某同学是B分支

00:08:17.044 --> 00:08:18.724
他们两个分支功能

00:08:18.724 --> 00:08:20.244
如果要做并行开发的话

00:08:20.244 --> 00:08:22.564
那得把他们两个分支给它合并了

00:08:22.564 --> 00:08:22.844
是吧

00:08:22.844 --> 00:08:24.904
这样的功能才能整合到一起

00:08:24.904 --> 00:08:27.824
现在有了这个getwork tree的之后的话

00:08:27.824 --> 00:08:29.924
Codex整合了这个之后的话

00:08:29.924 --> 00:08:31.684
我们可以直接在一个分支里面

00:08:31.684 --> 00:08:33.564
加多个worktree的方式做并行开发

00:08:33.564 --> 00:08:35.764
并且的话代码它是相互隔离的

00:08:35.764 --> 00:08:38.224
这样的话就达到了我不想见多分支

00:08:38.224 --> 00:08:40.664
也能实现多人协作的这么一个目标

00:08:40.664 --> 00:08:42.344
这是一个比较好的一个点

00:08:42.344 --> 00:08:43.824
然后的话就是

00:08:43.824 --> 00:08:46.724
我们可以通过这个Codex

00:08:46.724 --> 00:08:48.024
做一个远程连接啊

00:08:48.024 --> 00:08:52.024
就是它可以去专门连接到一个这个

00:08:52.024 --> 00:08:53.964
不同的这个

00:08:53.964 --> 00:08:55.544
比如说我们手机端是吧

00:08:55.544 --> 00:08:57.164
我们手机端去远程连接

00:08:57.164 --> 00:08:59.644
这个我们在手机档上面远程操控

00:08:59.644 --> 00:09:01.464
我们电脑端的这么一个Codex

00:09:01.464 --> 00:09:02.184
让它去干活

00:09:02.184 --> 00:09:04.964
这个也是一个好的一个功能

00:09:04.964 --> 00:09:06.844
这个就像那个小龙虾是吧

00:09:06.844 --> 00:09:07.504
养虾一样

00:09:07.504 --> 00:09:09.484
我可以远程指挥它去干活

00:09:09.484 --> 00:09:10.764
并且的话

00:09:10.764 --> 00:09:13.904
我们可以在这个Codex上面操作一些应用

00:09:13.904 --> 00:09:15.504
比如说在iOS上面

00:09:15.504 --> 00:09:17.824
去调用一些这个

00:09:17.824 --> 00:09:19.344
在MacOS上面

00:09:19.344 --> 00:09:21.084
就是我们的这个苹果系统上面

00:09:21.084 --> 00:09:22.864
它可以去调用各种的应用

00:09:22.864 --> 00:09:24.024
执行一些任务

00:09:24.024 --> 00:09:25.584
包括一些操作流感器

00:09:25.584 --> 00:09:26.864
当然都是支持的

00:09:26.864 --> 00:09:29.364
并且的话它可以支持应用截图识别图片

00:09:29.364 --> 00:09:31.664
然后做一些评审交付

00:09:31.664 --> 00:09:33.944
执行终端的一些命令

00:09:33.944 --> 00:09:35.384
然后操作浏览器

00:09:35.384 --> 00:09:37.744
包括它还可以去添加一些Chrome插件

00:09:37.744 --> 00:09:42.204
让Codex帮你去管理整个我们的这个浏览器

00:09:42.204 --> 00:09:42.524
是吧

00:09:42.524 --> 00:09:44.464
然后做一些浏览器的一些任务

00:09:44.464 --> 00:09:47.284
并且的话它可以去生成一些图片

00:09:47.284 --> 00:09:48.024
编辑图片

00:09:48.024 --> 00:09:49.564
因为OpenAI的话

00:09:49.564 --> 00:09:52.804
它本身就有一些这个图片的一些模型

00:09:52.804 --> 00:09:54.044
多么碳模型

00:09:54.044 --> 00:09:55.584
比如说像DLE3

00:09:55.584 --> 00:09:56.844
然后image2

00:09:56.844 --> 00:09:58.104
就是有它有生成

00:09:58.104 --> 00:09:59.404
专门生成图片的模型

00:09:59.404 --> 00:10:00.704
所以说它本身

00:10:00.704 --> 00:10:02.264
也可以去编辑图片

00:10:02.264 --> 00:10:03.404
这样的话

00:10:03.404 --> 00:10:04.104
我们相当于

00:10:04.104 --> 00:10:05.824
你可以把codex当做

00:10:05.824 --> 00:10:07.904
这个AI绘画工具来用

00:10:07.904 --> 00:10:09.164
这个也是可以的

00:10:09.164 --> 00:10:10.584
包括我们还可以做一些

00:10:10.584 --> 00:10:11.624
这个自动化

00:10:11.624 --> 00:10:13.564
就是一些这个论务

00:10:13.564 --> 00:10:14.004
是吧

00:10:14.004 --> 00:10:16.504
你做了一些这个操作之后

00:10:16.504 --> 00:10:17.624
你可以让它全自动的

00:10:17.624 --> 00:10:18.764
去调用各种各样的工具

00:10:18.764 --> 00:10:19.744
帮你去完成一个

00:10:19.744 --> 00:10:20.824
大的一个任务

00:10:20.824 --> 00:10:21.824
就全自动的

00:10:21.824 --> 00:10:23.164
然后的话

00:10:23.164 --> 00:10:25.124
就是我们还可以在codex上面

00:10:25.124 --> 00:10:26.384
去搭建一些技能

00:10:26.384 --> 00:10:27.164
这个我们等一下

00:10:27.164 --> 00:10:27.984
也会给大家讲

00:10:27.984 --> 00:10:29.024
就是怎么从零到一

00:10:29.024 --> 00:10:30.024
去搭建一个技能

00:10:30.024 --> 00:10:31.424
做真正企业级的

00:10:31.424 --> 00:10:32.384
一个scale开发

00:10:32.384 --> 00:10:34.004
然后怎么去使用它

00:10:34.004 --> 00:10:35.904
然后包括一些这个

00:10:35.904 --> 00:10:37.944
一些什么侧边软

00:10:37.944 --> 00:10:39.084
与artifactor

00:10:39.084 --> 00:10:40.484
这个是它的一些

00:10:40.484 --> 00:10:42.484
跟踪计划来源

00:10:42.484 --> 00:10:43.364
任务摘要和

00:10:43.364 --> 00:10:45.024
生成文件预览的一些功能

00:10:45.024 --> 00:10:45.764
这个都是它

00:10:45.764 --> 00:10:47.124
比较实用的一些功能

00:10:47.124 --> 00:10:47.964
还有包括它

00:10:47.964 --> 00:10:49.804
比较强大的一个插件系统

00:10:49.804 --> 00:10:50.564
这个我们等一下

00:10:50.564 --> 00:10:51.284
也会给大家讲

00:10:51.284 --> 00:10:52.644
这个插件功能的话

00:10:52.644 --> 00:10:53.644
其实也非常强大

00:10:53.644 --> 00:10:57.444
它可以极大程度的去拓展Codex

00:10:57.444 --> 00:10:58.524
能做的一些事情

00:10:58.524 --> 00:10:59.304
让它可以

00:10:59.304 --> 00:11:01.524
比如说甚至去生生视频也是可以的

00:11:01.524 --> 00:11:02.504
并且的话

00:11:02.504 --> 00:11:04.024
它可以与我们的这个IDE

00:11:04.024 --> 00:11:04.884
比如说与Coser

00:11:04.884 --> 00:11:06.424
或者是用WasteCode

00:11:06.424 --> 00:11:07.644
整个做一个同步

00:11:07.644 --> 00:11:09.784
这个就是它的一个核心能力

00:11:09.784 --> 00:11:11.164
那么大家有了一个

00:11:11.164 --> 00:11:13.224
全方位的这个认知之后的话

00:11:13.224 --> 00:11:14.764
后面你在用Codex的时候

00:11:14.764 --> 00:11:16.424
你可以把这一点给考虑进去

00:11:16.424 --> 00:11:18.704
如果说Codex里面已经集中这个功能的话

00:11:18.704 --> 00:11:21.424
那你可以完全把它做一个整合

00:11:21.424 --> 00:11:23.444
就大家可以可以把各种各样的功能

00:11:23.444 --> 00:11:25.964
整合在一起搭配去使用

00:11:25.964 --> 00:11:28.944
大家就是不要单独的去看待这个功能

00:11:28.944 --> 00:11:30.384
你一定要把它做一个什么呢

00:11:30.384 --> 00:11:32.064
就是整合

00:11:32.064 --> 00:11:33.984
就是我们把一个工作流

00:11:33.984 --> 00:11:35.984
你把整个串起来

00:11:35.984 --> 00:11:37.224
那它就可以做很多事情

00:11:37.224 --> 00:11:39.904
如果你只是聚焦它在单个功能上面的话

00:11:39.904 --> 00:11:42.224
它可能做的功能的话就比较单一

00:11:42.224 --> 00:11:44.024
所以大家要有一个全局的思维

00:11:44.024 --> 00:11:45.364
OK

00:11:45.364 --> 00:11:49.564
然后是Codex它的一个工程化设计思想

00:11:49.564 --> 00:11:52.244
那么这个设计思想有什么用呢

00:11:52.244 --> 00:11:55.064
那么Codex的话

00:11:55.064 --> 00:11:56.584
跟我们以前的这个

00:11:56.584 --> 00:11:58.764
AI编程助手的话

00:11:58.764 --> 00:12:00.784
还是有一些不一样的地方

00:12:00.784 --> 00:12:03.244
因为它毕竟是OpenAI出的

00:12:03.244 --> 00:12:05.144
它的一些设计思想的话

00:12:05.144 --> 00:12:06.704
跟这个Courser

00:12:06.704 --> 00:12:08.044
或者是Ways Code

00:12:08.044 --> 00:12:11.564
它们整合这个AI工具

00:12:11.564 --> 00:12:13.144
稍微有一点不一样

00:12:13.144 --> 00:12:15.544
那么它已经从一个

00:12:15.544 --> 00:12:17.544
简单的这个AI编码助手

00:12:17.544 --> 00:12:19.004
已经进化成一个叫做

00:12:19.004 --> 00:12:20.744
全镇开发的一个伙伴了

00:12:20.744 --> 00:12:21.924
为什么这么说呢

00:12:21.924 --> 00:12:23.384
主要有以下几个基点

00:12:23.384 --> 00:12:26.984
首先的话是规范工程取代了提示词工程

00:12:26.984 --> 00:12:29.764
以前的话大家是吧

00:12:29.764 --> 00:12:31.804
你做一个项目的话习惯性的

00:12:31.804 --> 00:12:33.924
你要把提示词给写好是吧

00:12:33.924 --> 00:12:37.464
那么Codex里面他已经在提供一个

00:12:37.464 --> 00:12:39.284
就是在强调一个点啊

00:12:39.284 --> 00:12:40.624
叫做规范化编程

00:12:40.624 --> 00:12:43.184
就是目前业界有一个非常

00:12:43.184 --> 00:12:44.864
这个主流的一个词啊

00:12:44.864 --> 00:12:46.524
叫做这个SDD是吧

00:12:46.524 --> 00:12:48.564
就是叫规范编程开发

00:12:48.564 --> 00:12:51.284
就是以规范去驱动

00:12:51.284 --> 00:12:52.384
我们整个的一个逻辑

00:12:52.384 --> 00:12:53.864
也就是说他先要

00:12:53.864 --> 00:12:55.204
你把这个规范写好

00:12:55.204 --> 00:12:56.704
比如说去写agentsmd

00:12:56.704 --> 00:12:57.784
写lulis

00:12:57.784 --> 00:12:59.244
整个这个规范给他写好

00:12:59.244 --> 00:13:00.104
写好完之后

00:13:00.104 --> 00:13:01.724
然后再去用AI生成代码

00:13:01.724 --> 00:13:02.524
这样的话

00:13:02.524 --> 00:13:04.124
他的质量会非常高

00:13:04.124 --> 00:13:05.584
所以以前的话

00:13:05.584 --> 00:13:07.944
大家没有注意规范的时候

00:13:07.944 --> 00:13:10.324
那他你去用自然语言

00:13:10.324 --> 00:13:12.384
给他去表达的时候

00:13:12.384 --> 00:13:14.084
那就会出现一个问题

00:13:14.084 --> 00:13:16.004
就是这个东西的一个边界

00:13:16.004 --> 00:13:16.784
就会有问题

00:13:16.784 --> 00:13:19.244
就是你采用一个结构化的一个输入

00:13:19.244 --> 00:13:21.824
整个它就会非常清晰

00:13:21.824 --> 00:13:24.104
就是有规则跟没规则的区别

00:13:24.104 --> 00:13:24.704
就是在于

00:13:24.704 --> 00:13:27.524
它可以有一个目标

00:13:27.524 --> 00:13:30.844
加边界加验收标准的一个结构

00:13:30.844 --> 00:13:32.684
这个就相当于我们

00:13:32.684 --> 00:13:34.384
大家实际在工作当中

00:13:34.384 --> 00:13:35.724
你去做一个事情的时候

00:13:35.724 --> 00:13:37.184
它有没有一个什么呢

00:13:37.184 --> 00:13:38.264
就是规范

00:13:38.264 --> 00:13:40.364
就是有没有自己的一个标准

00:13:40.364 --> 00:13:42.204
如果你没有标准的话

00:13:42.204 --> 00:13:44.264
你做一个事情的话

00:13:44.264 --> 00:13:45.964
就会出现各种各样的一个问题

00:13:45.964 --> 00:13:48.304
就是有标准的好处

00:13:48.304 --> 00:13:50.304
就是它可以保质保量的去验收

00:13:50.304 --> 00:13:53.464
就是达到这么一个效果

00:13:53.464 --> 00:13:56.964
所以说Codex已经在强调

00:13:56.964 --> 00:13:59.224
这个规范化的一个变成方式

00:13:59.224 --> 00:14:00.624
就是用Agent MD

00:14:00.624 --> 00:14:02.144
整个的一刻

00:14:02.144 --> 00:14:03.224
包括这个Harness

00:14:03.224 --> 00:14:04.524
这个Codex

00:14:04.524 --> 00:14:06.444
前一段时间也发了一篇文章

00:14:06.444 --> 00:14:06.764
是吧

00:14:06.764 --> 00:14:08.444
就关于这个Harness Engineering

00:14:08.444 --> 00:14:09.724
它整个的话

00:14:09.724 --> 00:14:12.444
目前就是采用了这个整个一套Harness

00:14:12.444 --> 00:14:13.804
去做一个落地的

00:14:13.804 --> 00:14:16.084
包括他自己内部

00:14:16.084 --> 00:14:19.464
OpenAI内部也是基于这个Harness

00:14:19.464 --> 00:14:23.324
去做了整个的一个项目的一个落地的

00:14:23.324 --> 00:14:26.104
之前他们有一篇文章里面提到了

00:14:26.104 --> 00:14:28.164
就是三个人

00:14:28.164 --> 00:14:30.084
一百多万行代码

00:14:30.084 --> 00:14:32.184
全部都是AI生成的

00:14:32.184 --> 00:14:34.564
就是用Harness Engineering去做的一个落地

00:14:34.564 --> 00:14:36.764
就是人工

00:14:36.764 --> 00:14:38.144
我们只限定规范

00:14:38.144 --> 00:14:39.824
把标准写好

00:14:39.824 --> 00:14:40.784
把目标定好

00:14:40.784 --> 00:14:43.264
所有的代码都是AI生成的

00:14:43.264 --> 00:14:45.304
人工不需要写一行代码啊

00:14:45.304 --> 00:14:46.684
真的是一行代码都不需要写

00:14:46.684 --> 00:14:49.464
他就是能把一个大型的项目给搞定

00:14:49.464 --> 00:14:51.144
大概是花了啊

00:14:51.144 --> 00:14:52.164
我记得是五到六个月

00:14:52.164 --> 00:14:53.584
然后给他上线了啊

00:14:53.584 --> 00:14:56.364
一个一百万多行的这个一个项目啊

00:14:56.364 --> 00:14:57.464
就是这么简单

00:14:57.464 --> 00:14:58.384
所以说啊

00:14:58.384 --> 00:14:59.704
目前啊

00:14:59.704 --> 00:15:03.484
Codex已经在深入的去落地这个Honest Engineering

00:15:03.484 --> 00:15:07.084
所以他对规范的要求是非常严格的啊

00:15:07.084 --> 00:15:08.664
大家等一下啊

00:15:08.664 --> 00:15:09.684
我们在讲解过程中

00:15:09.684 --> 00:15:12.124
大家就会感受到他整个这个逻辑啊

00:15:12.124 --> 00:15:14.244
就是会变得非常规范化

00:15:14.244 --> 00:15:16.164
然后第二块就是

00:15:16.164 --> 00:15:18.224
他在这个意图拆解

00:15:18.224 --> 00:15:19.164
与agent law

00:15:19.164 --> 00:15:20.904
我们叫任务循环这一块的话

00:15:20.904 --> 00:15:22.244
也会强调的比较多

00:15:22.244 --> 00:15:23.744
因为Konex已经

00:15:23.744 --> 00:15:26.644
不是单单的给你去生成一个代码了

00:15:26.644 --> 00:15:29.484
他是通过agent循环机制

00:15:29.484 --> 00:15:31.524
去模拟人类工程师的一个开发过程

00:15:31.524 --> 00:15:32.644
什么意思呢

00:15:32.644 --> 00:15:34.824
就是人是怎么干活的

00:15:34.824 --> 00:15:36.464
他就是怎么干活的

00:15:36.464 --> 00:15:38.844
就以前AI就给你写个代码就完事了

00:15:38.844 --> 00:15:41.104
他也不管你能不能运行

00:15:41.104 --> 00:15:41.604
啊

00:15:41.604 --> 00:15:42.304
除非你

00:15:55.305 --> 00:15:57.485
相当于他计划帮你做好了

00:15:57.485 --> 00:15:58.885
执行模式也帮你做好了

00:15:58.885 --> 00:16:01.705
最后你看到的结果就是没有问题的

00:16:01.705 --> 00:16:02.765
就是可以跑的

00:16:02.765 --> 00:16:04.265
所以大家现在会发现

00:16:04.265 --> 00:16:07.945
就是今年这些个AI编程工具的话

00:16:07.945 --> 00:16:09.225
它的进步非常大

00:16:09.225 --> 00:16:11.785
就是在Agent这一块做了非常大的一个改进

00:16:11.785 --> 00:16:14.785
那大家会发现目前像Cloud Code

00:16:14.785 --> 00:16:18.085
或者其他的一些像这个Cloud

00:16:18.085 --> 00:16:19.525
这个Codex

00:16:19.525 --> 00:16:22.765
或者像这个其他的一些编程工具

00:16:22.765 --> 00:16:23.685
大家会发现

00:16:23.685 --> 00:16:25.745
它的一个质量明显就上去了

00:16:25.745 --> 00:16:27.925
就是它写出来代码直接就可以用了

00:16:27.925 --> 00:16:30.545
基本上没什么太明显的一个问题

00:16:30.545 --> 00:16:34.225
所以说它内置的一个任务循环

00:16:34.225 --> 00:16:37.405
就保证了我们整个的一些什么呢

00:16:37.405 --> 00:16:39.165
一些bug一些安全性问题

00:16:39.165 --> 00:16:40.325
它就帮你去避免了

00:16:40.325 --> 00:16:42.925
因为它会按照我们人类的一个思维

00:16:42.925 --> 00:16:44.725
首先会做一个plan计划

00:16:44.725 --> 00:16:47.825
干活之前先把计划给你写清楚

00:16:47.825 --> 00:16:49.145
写清楚之后的话

00:16:49.145 --> 00:16:51.865
一步步的按照计划的一个目标

00:16:51.865 --> 00:16:53.725
再去确认

00:16:53.725 --> 00:16:55.385
然后再去编码

00:16:55.385 --> 00:16:56.985
而不是说

00:16:56.985 --> 00:16:58.665
跑到最后发现一堆问题

00:16:58.665 --> 00:17:01.165
所以说他是先确认

00:17:01.165 --> 00:17:04.005
由我们这个工程师自己去确认

00:17:04.005 --> 00:17:05.465
因为他有一些授权模式

00:17:05.465 --> 00:17:06.685
有确认模式

00:17:06.685 --> 00:17:09.165
也有全托管的这种优劣模式

00:17:09.165 --> 00:17:11.665
所以他会有一个确认过程

00:17:11.665 --> 00:17:13.125
当我们确认没问题之后

00:17:13.125 --> 00:17:14.445
他再去执行的时候

00:17:14.445 --> 00:17:16.005
这时候大家会发现

00:17:16.005 --> 00:17:17.825
他去执行任务的时候

00:17:17.825 --> 00:17:19.085
他会拆得更细

00:17:19.085 --> 00:17:21.565
就是agent这一块的话

00:17:21.565 --> 00:17:23.245
它会做一个大量的一个拆分

00:17:23.245 --> 00:17:25.945
犀利到每一个函数

00:17:25.945 --> 00:17:27.165
每一个模块的一个编写

00:17:27.165 --> 00:17:28.125
然后的话

00:17:28.125 --> 00:17:30.445
它会有一个非常严格的审查模式

00:17:30.445 --> 00:17:32.405
它会根据集合上下文去分析

00:17:32.405 --> 00:17:33.645
潜在的一些bug

00:17:33.645 --> 00:17:35.085
包括一些安全性问题

00:17:35.085 --> 00:17:37.185
或者一些性能瓶颈等等的

00:17:37.185 --> 00:17:38.965
它都会帮你分析的非常透彻

00:17:38.965 --> 00:17:41.765
所以大家看到Codex

00:17:41.765 --> 00:17:42.865
帮你升任代码之后

00:17:42.865 --> 00:17:44.725
基本上这个代码就没什么问题了

00:17:44.725 --> 00:17:45.205
可以用了

00:17:45.205 --> 00:17:47.325
因为它内部帮你把这个几个模式

00:17:47.325 --> 00:17:47.925
已经跑完了

00:17:47.925 --> 00:17:50.505
所以说你看到的东西都是高质量

00:17:50.505 --> 00:17:51.745
这也是为什么

00:17:51.745 --> 00:17:53.565
这个Agent Loan

00:17:53.565 --> 00:17:55.965
它是一个非常关键的一个点

00:17:55.965 --> 00:17:58.385
就它做了比较大的一个改进

00:17:58.385 --> 00:18:00.365
然后是上下文工程

00:18:00.365 --> 00:18:03.745
就Codex在工程架构这一块

00:18:03.745 --> 00:18:05.525
对于上下文管理这一块

00:18:05.525 --> 00:18:07.405
做了非常大的一个优化

00:18:07.405 --> 00:18:08.405
首先的话

00:18:08.405 --> 00:18:10.605
它会做一些精简的一个线段检索

00:18:10.605 --> 00:18:13.265
它会对整个代码库进行予以切分

00:18:13.265 --> 00:18:15.085
指向模型去注入

00:18:15.085 --> 00:18:16.165
与当前任务

00:18:16.165 --> 00:18:17.785
与特定文件相关依赖

00:18:17.785 --> 00:18:18.885
也就是说

00:18:18.885 --> 00:18:20.965
我们去问一个问题的时候

00:18:20.965 --> 00:18:22.785
他不是把整个都给你加载了

00:18:22.785 --> 00:18:23.525
不是这个意思

00:18:23.525 --> 00:18:26.045
他是做一个什么叫做注录

00:18:26.045 --> 00:18:28.245
就是你问的这个问题

00:18:28.245 --> 00:18:30.825
相关的一些代码片段

00:18:30.825 --> 00:18:33.205
还有包括一些原数据

00:18:33.205 --> 00:18:34.425
比如说一些markdown是吧

00:18:34.425 --> 00:18:35.705
有关系的时候

00:18:35.705 --> 00:18:38.045
再去做一个检索

00:18:38.045 --> 00:18:39.465
做一些这个处理

00:18:39.465 --> 00:18:40.685
而不是说一上来

00:18:40.685 --> 00:18:42.645
就把整个项目给他拉上去了

00:18:42.645 --> 00:18:45.265
那这个很容易出现一些上下文

00:18:45.265 --> 00:18:46.945
超过限制的问题是吧

00:18:46.945 --> 00:18:47.765
所以说这一块

00:18:47.765 --> 00:18:49.905
他对于这个整个线的检索

00:18:49.905 --> 00:18:50.825
做了一个精简

00:18:50.825 --> 00:18:52.605
然后是ST

00:18:52.605 --> 00:18:54.845
这个叫抽象语法术感知

00:18:54.845 --> 00:18:57.925
他会结合代码的一个数状结构

00:18:57.925 --> 00:19:00.745
去理解他的一个依赖引用

00:19:00.745 --> 00:19:03.765
也就是说代码跟代码之间的一个关系的话

00:19:03.765 --> 00:19:05.265
他是有依赖的

00:19:05.265 --> 00:19:06.125
他不是说

00:19:06.125 --> 00:19:10.345
简单粗暴的给你把一些这个代码拼在一起

00:19:10.345 --> 00:19:11.265
然后去理解的

00:19:11.265 --> 00:19:14.785
他是一定要把他的一个依赖关系给他分析出来

00:19:14.785 --> 00:19:17.165
这个做过我们这个

00:19:17.165 --> 00:19:18.505
加瓦项目开发啊

00:19:18.505 --> 00:19:19.765
就Mavin依赖的这个同学

00:19:19.765 --> 00:19:21.145
应该会比较清楚啊

00:19:21.145 --> 00:19:22.905
包括极致Python里面啊

00:19:22.905 --> 00:19:23.925
各种语言里面

00:19:23.925 --> 00:19:24.825
其实都有一些

00:19:24.825 --> 00:19:26.985
一些酷的一些依赖是吧

00:19:26.985 --> 00:19:28.905
那么如果说啊

00:19:28.905 --> 00:19:31.205
AI没有理解这个依赖引用的话

00:19:31.205 --> 00:19:32.605
就很可能出现什么呢

00:19:32.605 --> 00:19:34.285
就是一些编译报错呀

00:19:34.285 --> 00:19:35.965
或者是一些少一些模块啊

00:19:35.965 --> 00:19:36.145
是吧

00:19:36.145 --> 00:19:37.165
就很容易出现这种问题

00:19:37.165 --> 00:19:38.745
所以早期的AI编程工具

00:19:38.745 --> 00:19:39.805
它帮你设计代码的话

00:19:39.805 --> 00:19:41.765
有时候就就会出现这种问题

00:19:41.765 --> 00:19:43.025
因为它没有分析透彻

00:19:43.025 --> 00:19:45.225
它只是简单突破的给你去生成态

00:19:45.225 --> 00:19:47.485
那现在Codex这种

00:19:47.485 --> 00:19:49.045
最新的AI变成工具

00:19:49.045 --> 00:19:50.585
这些问题他们都解决了

00:19:50.585 --> 00:19:53.045
那么它给你把依赖分析的非常透彻

00:19:53.045 --> 00:19:57.685
然后是外部工具的一个协同

00:19:57.685 --> 00:19:59.685
那这个里面的话

00:19:59.685 --> 00:20:02.005
主要是就是在工程化设计中

00:20:02.005 --> 00:20:03.365
Codex的话

00:20:03.365 --> 00:20:06.625
它其实是具备了强大的一个环境交互能力

00:20:06.625 --> 00:20:09.025
它不是只是说一个文文生成技

00:20:09.025 --> 00:20:12.605
它具有非常强大的一个自主执行能力

00:20:13.025 --> 00:20:16.465
就是我们给了他中端环境的一个控制权

00:20:16.465 --> 00:20:18.065
就是他可以几乎

00:20:18.065 --> 00:20:20.825
你如果用的是这个bypass模式

00:20:20.825 --> 00:20:21.085
是吧

00:20:21.085 --> 00:20:22.565
你就把所有的权限交给他

00:20:22.565 --> 00:20:24.505
那他就可以做很多事情了

00:20:24.505 --> 00:20:26.085
不管是什么编译器啊

00:20:26.085 --> 00:20:26.725
调试器啊

00:20:26.725 --> 00:20:27.425
报管理器啊

00:20:27.425 --> 00:20:27.685
是吧

00:20:27.685 --> 00:20:28.445
直接调用

00:20:28.445 --> 00:20:30.865
因为他相当于就是超级管理员

00:20:30.865 --> 00:20:31.925
他可以做任何事情

00:20:31.925 --> 00:20:32.985
并且的话

00:20:32.985 --> 00:20:34.465
当代码报错的时候

00:20:34.465 --> 00:20:36.005
他会自动的去处理

00:20:36.005 --> 00:20:37.665
自动的去读取日志

00:20:37.665 --> 00:20:39.725
然后去定位这个原因

00:20:39.725 --> 00:20:40.785
并且自动修复

00:20:40.785 --> 00:20:41.925
所以说这是

00:20:41.925 --> 00:20:43.625
它非常强大的一个能力

00:20:43.625 --> 00:20:45.325
就是它发现问题之后

00:20:45.325 --> 00:20:46.945
它会自动的去修复问题

00:20:46.945 --> 00:20:48.145
所以大家会觉得

00:20:48.145 --> 00:20:50.145
目前的AI变成工具非常智能

00:20:50.145 --> 00:20:53.145
因为它帮你把所有的问题都解决了

00:20:53.145 --> 00:20:54.125
并且是全自动的

00:20:54.125 --> 00:20:55.825
不需要你再去提什么问题了

00:20:55.825 --> 00:20:57.025
所以这个是一个

00:20:57.025 --> 00:20:59.365
非常大的一个优化点

00:20:59.365 --> 00:21:00.805
好

00:21:00.805 --> 00:21:01.905
所以说大家首先

00:21:01.905 --> 00:21:03.285
要对Codex

00:21:03.285 --> 00:21:04.985
它的一个工程化设计思想

00:21:04.985 --> 00:21:06.225
要有一个认知

00:21:06.225 --> 00:21:09.005
那么你掌握了这个

00:21:09.005 --> 00:21:11.985
它的一个工程化设计思想之后的话

00:21:11.985 --> 00:21:13.825
大家再去

00:21:13.825 --> 00:21:15.065
用Codex的话

00:21:15.065 --> 00:21:16.805
你就会发现啊

00:21:16.805 --> 00:21:17.685
它的一些细节

00:21:17.685 --> 00:21:20.805
就会怎么样更好的去使用它

00:21:20.805 --> 00:21:22.605
OK