2026版AI+Codex零基础全套视频课程，Codex从入门到大神AI编程开发，涵盖安装配置、代码分析、Bug修复及完整项目实战 p03 2、Codex 核心能力与工程化设计思想揭秘

AI大模型全栈 首頁 每日列表 原始影片
實際影片長度：21:22.966。原文、繁中、雙語可點擊句子跳轉影片。
0:00.000–0:05.673
zh首先我们来讲第一块,Codex核心能力与工程化设计的一个思想。
0:05.673–0:15.920
zh那么Codex的话,相信大家如果是作为程序员的话,基本上多多少少都已经听说过了,或者有的同学已经用过一段时间了。
0:15.920–0:17.080
zh那这里的话
0:17.080–0:18.960
zh我给他做一个简单的概述啊
0:18.960–0:22.980
zhCodex是OpenAI官方推出的一款AI编程工具啊
0:22.980–0:24.240
zh但这个目前
0:24.240–0:27.700
zh这个已经不仅仅局限于AI编程这一块了啊
0:27.700–0:29.340
zh他能做的事情非常多啊
0:29.340–0:30.760
zh怎么等一下逐步来展开
0:30.760–0:35.720
zh那么大家可以通过这个官方的一个文档啊
0:35.720–0:40.300
zh如果想去深入的了解Codex所有的一些细节的话啊
0:40.300–0:42.380
zh我建议大家去看一下这个OpenAI
0:42.380–0:45.860
zh出的这个官方的这个开发者文档
0:45.860–0:47.520
zh这个是给开发人员看的
0:47.520–0:49.760
zh里面的一些文档的话写的非常详细
0:49.760–0:52.940
zh大家对一些概念性的认知
0:52.940–0:56.660
zh包括一些比如说我们来查一些指南
0:56.660–0:59.460
zh大家都可以通过这个文档做一个入手
0:59.460–1:01.760
zh所以说这是一份非常好的学习资料
1:01.760–1:03.480
zh这是我推荐给大家的
1:03.480–1:05.400
zh然后的话是Codex的话
1:05.400–1:07.440
zh它有一些模块的话
1:07.440–1:08.300
zh它是开源的
1:08.300–1:11.760
zh如果大家对它的底层源码感兴趣
1:11.760–1:13.100
zh比如说像CLI
1:13.100–1:13.820
zh是吧
1:13.820–1:14.780
zh还有一些这个
1:14.780–1:17.020
zh他的一些文档呀
1:17.020–1:17.400
zh你看
1:17.400–1:20.800
zh比如说他的一些agents.md的一些这个细节文档
1:20.800–1:22.820
zh大家如果感兴趣啊
1:22.820–1:26.180
zh可以去他的这个开源的这个仓库里面
1:26.180–1:27.660
zh去深入的去研究一下
1:27.660–1:32.100
zh这个也是我给大家提供的一份这个学习资料
1:32.100–1:33.520
zh就是这个入口
1:33.520–1:35.520
zh大家可以从这个地方去入手
1:35.520–1:38.300
zh如果你对他的这个源码也比较感兴趣
1:38.300–1:40.940
zh像参与这个Codex
1:40.940–1:42.260
zh他的一个开源建设的话
1:42.260–1:44.720
zh大家可以在这个里面去做一个入手
1:44.720–1:45.460
enOK
1:45.460–1:48.860
zh这个就是我给大家推荐的这个两份学习资料啊
1:48.860–1:54.000
zh然后下面这个的话是CodexAPP的这么一个页面啊
1:54.000–1:57.460
zh最开始的话Codex是没有APP版本的啊
1:57.460–1:59.540
zh它是基于这个CLI命令行的
1:59.540–2:02.000
zh所以最早期大家使用的话啊
2:02.000–2:04.060
zh基本上是基于这个命令行啊
2:04.060–2:08.320
zh比如说我们在这个里面输入一个这个Codex是吧
2:08.320–2:10.080
zh那我们进入到这个命令行页面
2:10.080–2:13.060
zh直接就可以做一个AI编程了
2:13.060–2:14.860
zh我们最开始的使用方式是这样的
2:14.860–2:15.360
zh但是的话
2:15.360–2:18.560
zh目前的话Codex已经出了这个APP了
2:18.560–2:19.760
zh然后也非常好用
2:19.760–2:20.460
zh等一下的话
2:20.460–2:21.760
zh我们就来给他讲一下
2:21.760–2:24.060
zh这个APP的一个安装跟使用
2:24.060–2:30.200
zh所以我们主要是基于这个CLI和这个APP
2:30.200–2:32.160
zh混合的这种方式去使用
2:32.160–2:32.960
zh还有的话
2:32.960–2:35.200
zh就是他还有一种插件形式的
2:35.200–2:39.000
zh就是我们可以用这个 Cursor 或者 VSCode
2:39.000–2:42.800
zh大家可以去装一个这个 Cursor
2:42.800–2:45.340
zh就是整个它有一个Codex插件
2:45.340–2:46.640
zh这个也比较好用
2:46.640–2:50.160
zh这个的话如果大家习惯性用这个 VSCode
2:50.160–2:51.280
zh或者是 Cursor 的话
2:51.280–2:52.740
zh你可以把这个插件
2:52.740–2:54.400
zh装一个Codex插件
2:54.400–2:57.340
zh然后跟我们的这个编码结合起来去用
2:57.340–2:58.560
zh这也是OK的
2:58.560–3:00.880
zh这也是我比较推荐大家用的一种方式
3:00.880–3:02.120
zh如果你既要改代码
3:02.120–3:04.220
zh又要去做这个
3:04.220–3:06.480
zh你想用这个Codex的话
3:06.480–3:07.400
zh都是OK的
3:07.400–3:10.020
zh但你不在这个里面装插件
3:10.020–3:10.920
zh你用那个APP
3:10.920–3:12.680
zh然后或者是CLI
3:12.680–3:13.700
zh也是没有问题的
3:13.700–3:15.300
zh只是说在这个里面的话
3:15.300–3:17.020
zh切换就会比较简单一些
3:17.020–3:19.740
zh不然的话你要切换这个窗口
3:19.740–3:21.660
zh还是稍微有那么一点麻烦
3:21.660–3:23.480
zh不过这个都是小问题
3:23.480–3:25.260
zh所以说它的使用方式有
3:25.260–3:26.340
zh基本上就是三种
3:26.340–3:28.240
zh第一种的话就是我们用这个APP
3:28.240–3:30.440
zh然后第二种的话就是用CLI
3:30.440–3:32.680
zh还有的话就是一个插件形式
3:32.680–3:34.640
zh基本上目前主流的使用方式的话
3:34.640–3:35.320
zh就是三个
3:35.320–3:38.200
zh那么它主要啊
3:38.200–3:41.740
zh如果说在做这个AI编程这一块的话
3:41.740–3:43.220
zh它主要的功能有哪些呢
3:43.220–3:44.620
zh首先第一块的话啊
3:44.620–3:46.640
zh写代码就是一个基础功能的
3:46.640–3:48.480
zh那么在Codex里面的话
3:48.480–3:51.220
zh大家可以非常方便的去使用一些快捷指令
3:51.220–3:53.400
zh然后采用这种对话的方式
3:53.400–3:56.440
zh去让它去帮你去生成这个代码
3:56.440–3:58.480
zh或者说整个去开发一个项目
3:58.480–4:00.400
zh搭建一个项目架构都是OK的
4:00.400–4:01.780
zh还有一点的话
4:01.780–4:04.900
zh就是我们可以用Codex去学习一些
4:04.900–4:06.180
zh优秀的开源项目
4:06.180–4:08.980
zh比如说大家对这个开源项目比较感兴趣
4:08.980–4:10.460
zh就是把这个项目拉下来
4:10.460–4:13.480
zh然后通过Codex命令去分析一下
4:13.480–4:14.740
zh当前这个项目的话
4:14.740–4:16.340
zh它的一个结构是怎么样的
4:16.340–4:18.300
zh包括大家在公司里面
4:18.300–4:22.120
zh你去接手一些历史的一些遗留项目
4:22.120–4:22.420
zh是吧
4:22.420–4:24.200
zh一些代码你看不懂怎么办呢
4:24.200–4:25.720
zh那你也可以用Codex
4:25.720–4:27.940
zh可以去帮你去做一个阅读
4:27.940–4:30.200
zh然后帮助你快速的去理解
4:30.200–4:33.120
zh团队是如何去做一个开发的
4:33.120–4:34.380
zh然后包括里面的细节问题
4:34.380–4:36.660
zh他都可以通过Codex去把它分析出来
4:36.660–4:37.940
zh这也是一个场景
4:37.940–4:40.380
zh然后的话就是审查代码
4:40.380–4:42.740
zh那以前我们做那个代码审查的话
4:42.740–4:45.500
zh大家习惯性的要去看那个PR是吧
4:45.500–4:47.620
zh看PR里面的这个commit
4:47.620–4:49.540
zhDiff里面到底给了哪些文件
4:49.540–4:50.680
zh然后看一下有没有漏洞
4:50.680–4:51.680
zh然后有问题的话
4:51.680–4:53.100
zh还得上面标注一下
4:53.100–4:54.400
zh以前的话
4:54.400–4:56.560
zh这个需要耗费大量的这个人工成本
4:56.560–4:58.360
zh专门需要一个代码审查
4:58.360–5:00.520
zh那现在有了Codex之后的话
5:00.520–5:01.800
zh我们做代码审查的话
5:01.800–5:02.840
zh其实会非常简单
5:02.840–5:04.400
zh就是这个里面的话
5:04.400–5:05.640
zh他会去分析
5:05.640–5:09.360
zh他有专门的review的这么一个斜杠命令
5:09.360–5:11.680
zh这个我们等一下会给大家讲这么一个案例
5:11.680–5:14.700
zh就是我们可以用review的一个命令
5:14.700–5:16.680
zh去快速的去分析本次
5:16.680–5:18.920
zh比如说我还没有提交的一些代码
5:18.920–5:19.920
zh我想让他分析一下
5:19.920–5:21.760
zh或者说我们已经提交的PR
5:21.760–5:23.560
zh这个代码有没有问题
5:23.560–5:26.180
zh也可以分析出来
5:26.180–5:27.700
zh让我们根据这个结果
5:27.700–5:29.400
zh最后去把这个代码
5:29.400–5:31.480
zh就是给提一些建议
5:31.480–5:33.780
zh或者给他拒绝这个PR合并
5:33.780–5:34.140
zh是吧
5:34.140–5:35.860
zh这个就是我们做代码审查
5:35.860–5:37.560
zh可以结合Codex做的一些事情
5:37.560–5:38.660
zh然后的话
5:38.660–5:40.680
zh大家还可以通过Codex去
5:40.680–5:42.740
zh排查一些线上的一些问题
5:42.740–5:43.100
zh是吧
5:43.100–5:44.400
zh比如我们线上发现一些bug
5:44.400–5:45.400
zh有一些日志
5:45.400–5:47.100
zh他定位了一些代码行
5:47.100–5:49.100
zh那我们把这些日志提供给Codex
5:49.100–5:49.900
zh那Codex的话
5:49.900–5:51.920
zh可以快速的去帮我们找到
5:51.920–5:53.400
zh这个代码到底哪里出问题了
5:53.400–5:55.500
zh并针对性的给一些修复方案出来
5:55.500–5:57.000
zh所以这个也是一个
5:57.000–5:59.360
zh比较好的一个应用方向
5:59.360–6:01.420
zh然后最后一个的话
6:01.420–6:03.340
zh就是自动化开发任务啊
6:03.340–6:05.220
zh那这一块也是用的比较多的一个场景
6:05.220–6:07.920
zh那就是说我们可以通过Codex啊
6:07.920–6:10.540
zh就是从零到一去做一个项目的一个开发
6:10.540–6:11.720
zh那我们等一下的话
6:11.720–6:13.460
zh也会带大家去基于这个流程
6:13.460–6:14.800
zh去做一个项目啊
6:14.800–6:16.120
zh就是从需求分析开始
6:16.120–6:20.400
zh到整个的一个项目的一个功能拆解啊
6:20.400–6:20.740
zh是吧
6:20.740–6:22.020
zh核心功能开发呀
6:22.020–6:23.180
zh包括测试啊
6:23.180–6:25.480
zh包括整个的一个啊
6:25.480–6:26.240
zh调试啊
6:26.240–6:26.500
zh是吧
6:26.500–6:31.100
zh这个我们等一下都会给大家去走一遍啊
6:31.100–6:32.600
zh所以这几个场景的话
6:32.600–6:33.800
zh都是Codex
6:33.800–6:36.340
zh它比较擅长
6:36.340–6:38.580
zh或者说比较主流的一些应用场景
6:38.580–6:40.060
zh那么Codex
6:40.060–6:42.260
zh它的一个核心能力有哪些呢
6:42.260–6:45.160
zh大家要比较好的去使用Codex的话
6:45.160–6:47.260
zh首先要对它的一个核心能力
6:47.260–6:49.420
zh或者说对它整个的一个功能架构的话
6:49.420–6:51.000
zh有一个认知
6:51.000–6:52.520
zh就是要有一个大的认知
6:52.520–6:53.040
zh这样的话
6:53.040–6:55.260
zh你在去做一些开发的时候
6:55.260–6:55.900
zh你就会想到
6:55.900–6:58.120
zh原来Codex已经集成这个能力了
6:58.120–7:00.480
zh那大家去直接把它去应用到
7:00.480–7:01.700
zh工作当中去的话
7:01.700–7:03.360
zh那这个提效就很明显了
7:03.360–7:04.640
zh那大家可以看一下
7:04.640–7:05.860
zh整个的一个
7:05.860–7:07.320
zh它的一个能力
7:07.320–7:09.880
zh那能力的话是非常多了
7:09.880–7:11.100
zh最主要的话
7:11.100–7:13.080
zh就是它的一个多任务处理
7:13.080–7:14.240
zh就是多线程
7:14.240–7:16.480
zh大家在用这个Codex过程中
7:16.480–7:17.840
zh你会发现一个点
7:17.840–7:19.300
zh就是整个
7:19.300–7:21.440
zh它是基于多线程的一个机制
7:21.440–7:22.960
zh就是你不断的跟它去对话
7:22.960–7:24.940
zh它会不断的去起
7:24.940–7:25.860
zh各种各样的线程
7:25.860–7:26.860
zh帮你去完成任务
7:26.860–7:28.640
zh并且最终做一个合并
7:28.640–7:31.240
zh所以它的一个跨项目的
7:31.240–7:32.900
zh多任务处理能力非常强
7:32.900–7:36.560
zh就是你可以让它同时去开发三个项目
7:36.560–7:37.940
zh开三个这个线程
7:37.940–7:38.500
zh是吧
7:38.500–7:39.240
zh然后最终
7:39.240–7:42.820
zh比如说我们想让它分析三个项目的一个细节
7:42.820–7:45.384
zh然后分析完之后做一个总结归纳
7:45.384–7:47.184
zh最后给你输出一张表格。
7:47.184–7:48.884
zh那他就是启动三个线程。
7:48.884–7:52.984
zh即使是跨多项目的话,他也可以用多任务的方式去处理。
7:52.984–7:55.084
zh这是他的一个非常强大的一个能力。
7:55.084–7:59.684
zh然后的话,他里面内置了一个叫Git WorkTree的一个这么一个机制。
7:59.684–8:01.444
zh它的一个优点是什么
8:01.444–8:03.344
zh就是我们可以在一个分支下面
8:03.344–8:06.044
zh可以支持加多个这个work tree
8:06.044–8:07.424
zh然后去并行开发
8:07.424–8:09.384
zh以前的话我们开发的话
8:09.384–8:11.624
zh就是都要做分支隔离的是吧
8:11.624–8:15.864
zh比如说某某同学是做这个A分支
8:15.864–8:17.044
zh某某同学是B分支
8:17.044–8:18.724
zh他们两个分支功能
8:18.724–8:20.244
zh如果要做并行开发的话
8:20.244–8:22.564
zh那得把他们两个分支给它合并了
8:22.564–8:22.844
zh是吧
8:22.844–8:24.904
zh这样的功能才能整合到一起
8:24.904–8:27.824
zh现在有了这个 git worktree 的之后的话
8:27.824–8:29.924
zhCodex整合了这个之后的话
8:29.924–8:31.684
zh我们可以直接在一个分支里面
8:31.684–8:33.564
zh加多个worktree的方式做并行开发
8:33.564–8:35.764
zh并且的话代码它是相互隔离的
8:35.764–8:38.224
zh这样的话就达到了我不想见多分支
8:38.224–8:40.664
zh也能实现多人协作的这么一个目标
8:40.664–8:42.344
zh这是一个比较好的一个点
8:42.344–8:43.824
zh然后的话就是
8:43.824–8:46.724
zh我们可以通过这个Codex
8:46.724–8:48.024
zh做一个远程连接啊
8:48.024–8:52.024
zh就是它可以去专门连接到一个这个
8:52.024–8:53.964
zh不同的这个
8:53.964–8:55.544
zh比如说我们手机端是吧
8:55.544–8:57.164
zh我们手机端去远程连接
8:57.164–8:59.644
zh这个我们在手机端上面远程操控
8:59.644–9:01.464
zh我们电脑端的这么一个Codex
9:01.464–9:02.184
zh让它去干活
9:02.184–9:04.964
zh这个也是一个好的一个功能
9:04.964–9:06.844
zh这个就像那个小龙虾是吧
9:06.844–9:07.504
zh养虾一样
9:07.504–9:09.484
zh我可以远程指挥它去干活
9:09.484–9:10.764
zh并且的话
9:10.764–9:13.904
zh我们可以在这个Codex上面操作一些应用
9:13.904–9:15.504
zh比如说在iOS上面
9:15.504–9:17.824
zh去调用一些这个
9:17.824–9:19.344
zh在MacOS上面
9:19.344–9:21.084
zh就是我们的这个苹果系统上面
9:21.084–9:22.864
zh它可以去调用各种的应用
9:22.864–9:24.024
zh执行一些任务
9:24.024–9:25.584
zh包括一些操作浏览器
9:25.584–9:26.864
zh当然都是支持的
9:26.864–9:29.364
zh并且的话它可以支持应用截图识别图片
9:29.364–9:31.664
zh然后做一些评审交付
9:31.664–9:33.944
zh执行终端的一些命令
9:33.944–9:35.384
zh然后操作浏览器
9:35.384–9:37.744
zh包括它还可以去添加一些Chrome插件
9:37.744–9:42.204
zh让Codex帮你去管理整个我们的这个浏览器
9:42.204–9:42.524
zh是吧
9:42.524–9:44.464
zh然后做一些浏览器的一些任务
9:44.464–9:47.284
zh并且的话它可以去生成一些图片
9:47.284–9:48.024
zh编辑图片
9:48.024–9:49.564
zh因为OpenAI的话
9:49.564–9:52.804
zh它本身就有一些这个图片的一些模型
9:52.804–9:54.044
zh多模态模型
9:54.044–9:55.584
zh比如说像 DALL-E 3
9:55.584–9:56.844
zh然后image2
9:56.844–9:58.104
zh就是有它有生成
9:58.104–9:59.404
zh专门生成图片的模型
9:59.404–10:00.704
zh所以说它本身
10:00.704–10:02.264
zh也可以去编辑图片
10:02.264–10:03.404
zh这样的话
10:03.404–10:04.104
zh我们相当于
10:04.104–10:05.824
zh你可以把codex当做
10:05.824–10:07.904
zh这个AI绘画工具来用
10:07.904–10:09.164
zh这个也是可以的
10:09.164–10:10.584
zh包括我们还可以做一些
10:10.584–10:11.624
zh这个自动化
10:11.624–10:13.564
zh就是一些这个任务
10:13.564–10:14.004
zh是吧
10:14.004–10:16.504
zh你做了一些这个操作之后
10:16.504–10:17.624
zh你可以让它全自动的
10:17.624–10:18.764
zh去调用各种各样的工具
10:18.764–10:19.744
zh帮你去完成一个
10:19.744–10:20.824
zh大的一个任务
10:20.824–10:21.824
zh就全自动的
10:21.824–10:23.164
zh然后的话
10:23.164–10:25.124
zh就是我们还可以在codex上面
10:25.124–10:26.384
zh去搭建一些技能
10:26.384–10:27.164
zh这个我们等一下
10:27.164–10:27.984
zh也会给大家讲
10:27.984–10:29.024
zh就是怎么从零到一
10:29.024–10:30.024
zh去搭建一个技能
10:30.024–10:31.424
zh做真正企业级的
10:31.424–10:32.384
zh一个 skill 开发
10:32.384–10:34.004
zh然后怎么去使用它
10:34.004–10:35.904
zh然后包括一些这个
10:35.904–10:37.944
zh一些什么侧边栏
10:37.944–10:39.084
zh与 artifact
10:39.084–10:40.484
zh这个是它的一些
10:40.484–10:42.484
zh跟踪计划来源
10:42.484–10:43.364
zh任务摘要和
10:43.364–10:45.024
zh生成文件预览的一些功能
10:45.024–10:45.764
zh这个都是它
10:45.764–10:47.124
zh比较实用的一些功能
10:47.124–10:47.964
zh还有包括它
10:47.964–10:49.804
zh比较强大的一个插件系统
10:49.804–10:50.564
zh这个我们等一下
10:50.564–10:51.284
zh也会给大家讲
10:51.284–10:52.644
zh这个插件功能的话
10:52.644–10:53.644
zh其实也非常强大
10:53.644–10:57.444
zh它可以极大程度的去拓展Codex
10:57.444–10:58.524
zh能做的一些事情
10:58.524–10:59.304
zh让它可以
10:59.304–11:01.524
zh比如说甚至去生生视频也是可以的
11:01.524–11:02.504
zh并且的话
11:02.504–11:04.024
zh它可以与我们的这个IDE
11:04.024–11:04.884
zh比如说与 Cursor
11:04.884–11:06.424
zh或者是用 VS Code
11:06.424–11:07.644
zh整个做一个同步
11:07.644–11:09.784
zh这个就是它的一个核心能力
11:09.784–11:11.164
zh那么大家有了一个
11:11.164–11:13.224
zh全方位的这个认知之后的话
11:13.224–11:14.764
zh后面你在用Codex的时候
11:14.764–11:16.424
zh你可以把这一点给考虑进去
11:16.424–11:18.704
zh如果说 Codex 里面已经集成这个功能的话
11:18.704–11:21.424
zh那你可以完全把它做一个整合
11:21.424–11:23.444
zh就大家可以可以把各种各样的功能
11:23.444–11:25.964
zh整合在一起搭配去使用
11:25.964–11:28.944
zh大家就是不要单独的去看待这个功能
11:28.944–11:30.384
zh你一定要把它做一个什么呢
11:30.384–11:32.064
zh就是整合
11:32.064–11:33.984
zh就是我们把一个工作流
11:33.984–11:35.984
zh你把整个串起来
11:35.984–11:37.224
zh那它就可以做很多事情
11:37.224–11:39.904
zh如果你只是聚焦它在单个功能上面的话
11:39.904–11:42.224
zh它可能做的功能的话就比较单一
11:42.224–11:44.024
zh所以大家要有一个全局的思维
11:44.024–11:45.364
enOK
11:45.364–11:49.564
zh然后是Codex它的一个工程化设计思想
11:49.564–11:52.244
zh那么这个设计思想有什么用呢
11:52.244–11:55.064
zh那么Codex的话
11:55.064–11:56.584
zh跟我们以前的这个
11:56.584–11:58.764
zhAI编程助手的话
11:58.764–12:00.784
zh还是有一些不一样的地方
12:00.784–12:03.244
zh因为它毕竟是OpenAI出的
12:03.244–12:05.144
zh它的一些设计思想的话
12:05.144–12:06.704
zh跟这个 Cursor
12:06.704–12:08.044
zh或者是 VS Code
12:08.044–12:11.564
zh它们整合这个AI工具
12:11.564–12:13.144
zh稍微有一点不一样
12:13.144–12:15.544
zh那么它已经从一个
12:15.544–12:17.544
zh简单的这个AI编码助手
12:17.544–12:19.004
zh已经进化成一个叫做
12:19.004–12:20.744
zh全栈开发的一个伙伴了
12:20.744–12:21.924
zh为什么这么说呢
12:21.924–12:23.384
zh主要有以下几个基点
12:23.384–12:26.984
zh首先的话是规范工程取代了提示词工程
12:26.984–12:29.764
zh以前的话大家是吧
12:29.764–12:31.804
zh你做一个项目的话习惯性的
12:31.804–12:33.924
zh你要把提示词给写好是吧
12:33.924–12:37.464
zh那么Codex里面他已经在提供一个
12:37.464–12:39.284
zh就是在强调一个点啊
12:39.284–12:40.624
zh叫做规范化编程
12:40.624–12:43.184
zh就是目前业界有一个非常
12:43.184–12:44.864
zh这个主流的一个词啊
12:44.864–12:46.524
zh叫做这个 SDD 是吧
12:46.524–12:48.564
zh就是叫规范编程开发
12:48.564–12:51.284
zh就是以规范去驱动
12:51.284–12:52.384
zh我们整个的一个逻辑
12:52.384–12:53.864
zh也就是说他先要
12:53.864–12:55.204
zh你把这个规范写好
12:55.204–12:56.704
zh比如说去写 agents.md
12:56.704–12:57.784
zh写 rules
12:57.784–12:59.244
zh整个这个规范给他写好
12:59.244–13:00.104
zh写好完之后
13:00.104–13:01.724
zh然后再去用AI生成代码
13:01.724–13:02.524
zh这样的话
13:02.524–13:04.124
zh他的质量会非常高
13:04.124–13:05.584
zh所以以前的话
13:05.584–13:07.944
zh大家没有注意规范的时候
13:07.944–13:10.324
zh那你去用自然语言
13:10.324–13:12.384
zh给他去表达的时候
13:12.384–13:14.084
zh那就会出现一个问题
13:14.084–13:16.004
zh就是这个东西的一个边界
13:16.004–13:16.784
zh就会有问题
13:16.784–13:19.244
zh就是你采用一个结构化的一个输入
13:19.244–13:21.824
zh整个它就会非常清晰
13:21.824–13:24.104
zh就是有规则跟没规则的区别
13:24.104–13:24.704
zh就是在于
13:24.704–13:27.524
zh它可以有一个目标
13:27.524–13:30.844
zh加边界加验收标准的一个结构
13:30.844–13:32.684
zh这个就相当于我们
13:32.684–13:34.384
zh大家实际在工作当中
13:34.384–13:35.724
zh你去做一个事情的时候
13:35.724–13:37.184
zh它有没有一个什么呢
13:37.184–13:38.264
zh就是规范
13:38.264–13:40.364
zh就是有没有自己的一个标准
13:40.364–13:42.204
zh如果你没有标准的话
13:42.204–13:44.264
zh你做一个事情的话
13:44.264–13:45.964
zh就会出现各种各样的一个问题
13:45.964–13:48.304
zh就是有标准的好处
13:48.304–13:50.304
zh就是它可以保质保量的去验收
13:50.304–13:53.464
zh就是达到这么一个效果
13:53.464–13:56.964
zh所以说Codex已经在强调
13:56.964–13:59.224
zh这个规范化的一个编程方式
13:59.224–14:00.624
zh就是用 Agent MD
14:00.624–14:02.144
zh整个的一套
14:02.144–14:03.224
zh包括这个Harness
14:03.224–14:04.524
zh这个Codex
14:04.524–14:06.444
zh前一段时间也发了一篇文章
14:06.444–14:06.764
zh是吧
14:06.764–14:08.444
zh就关于这个 Harness Engineering
14:08.444–14:09.724
zh它整个的话
14:09.724–14:12.444
zh目前就是采用了这个整个一套Harness
14:12.444–14:13.804
zh去做一个落地的
14:13.804–14:16.084
zh包括他自己内部
14:16.084–14:19.464
zhOpenAI内部也是基于这个Harness
14:19.464–14:23.324
zh去做了整个的一个项目的一个落地的
14:23.324–14:26.104
zh之前他们有一篇文章里面提到了
14:26.104–14:28.164
zh就是三个人
14:28.164–14:30.084
zh一百多万行代码
14:30.084–14:32.184
zh全部都是AI生成的
14:32.184–14:34.564
zh就是用Harness Engineering去做的一个落地
14:34.564–14:36.764
zh就是人工
14:36.764–14:38.144
zh我们只限定规范
14:38.144–14:39.824
zh把标准写好
14:39.824–14:40.784
zh把目标定好
14:40.784–14:43.264
zh所有的代码都是AI生成的
14:43.264–14:45.304
zh人工不需要写一行代码啊
14:45.304–14:46.684
zh真的是一行代码都不需要写
14:46.684–14:49.464
zh他就是能把一个大型的项目给搞定
14:49.464–14:51.144
zh大概是花了啊
14:51.144–14:52.164
zh我记得是五到六个月
14:52.164–14:53.584
zh然后给他上线了啊
14:53.584–14:56.364
zh一个一百万多行的这个一个项目啊
14:56.364–14:57.464
zh就是这么简单
14:57.464–14:58.384
zh所以说啊
14:58.384–14:59.704
zh目前啊
14:59.704–15:03.484
zhCodex已经在深入的去落地这个Harness Engineering
15:03.484–15:07.084
zh所以他对规范的要求是非常严格的啊
15:07.084–15:08.664
zh大家等一下啊
15:08.664–15:09.684
zh我们在讲解过程中
15:09.684–15:12.124
zh大家就会感受到他整个这个逻辑啊
15:12.124–15:14.244
zh就是会变得非常规范化
15:14.244–15:16.164
zh然后第二块就是
15:16.164–15:18.224
zh他在这个意图拆解
15:18.224–15:19.164
zh与agent loop
15:19.164–15:20.904
zh我们叫任务循环这一块的话
15:20.904–15:22.244
zh也会强调的比较多
15:22.244–15:23.744
zh因为Codex已经
15:23.744–15:26.644
zh不是单单的给你去生成一个代码了
15:26.644–15:29.484
zh他是通过agent循环机制
15:29.484–15:31.524
zh去模拟人类工程师的一个开发过程
15:31.524–15:32.644
zh什么意思呢
15:32.644–15:34.824
zh就是人是怎么干活的
15:34.824–15:36.464
zh他就是怎么干活的
15:36.464–15:38.844
zh就以前AI就给你写个代码就完事了
15:38.844–15:41.104
zh他也不管你能不能运行
15:41.104–15:41.604
zh啊
15:41.604–15:55.305
zh除非你
15:55.305–15:57.485
zh相当于他计划帮你做好了
15:57.485–15:58.885
zh执行模式也帮你做好了
15:58.885–16:01.705
zh最后你看到的结果就是没有问题的
16:01.705–16:02.765
zh就是可以跑的
16:02.765–16:04.265
zh所以大家现在会发现
16:04.265–16:07.945
zh就是今年这些个AI编程工具的话
16:07.945–16:09.225
zh它的进步非常大
16:09.225–16:11.785
zh就是在Agent这一块做了非常大的一个改进
16:11.785–16:14.785
zh那大家会发现目前像Claude Code
16:14.785–16:18.085
zh或者其他的一些像这个Claude
16:18.085–16:19.525
zh这个Codex
16:19.525–16:22.765
zh或者像这个其他的一些编程工具
16:22.765–16:23.685
zh大家会发现
16:23.685–16:25.745
zh它的一个质量明显就上去了
16:25.745–16:27.925
zh就是它写出来代码直接就可以用了
16:27.925–16:30.545
zh基本上没什么太明显的一个问题
16:30.545–16:34.225
zh所以说它内置的一个任务循环
16:34.225–16:37.405
zh就保证了我们整个的一些什么呢
16:37.405–16:39.165
zh一些bug一些安全性问题
16:39.165–16:40.325
zh它就帮你去避免了
16:40.325–16:42.925
zh因为它会按照我们人类的一个思维
16:42.925–16:44.725
zh首先会做一个plan计划
16:44.725–16:47.825
zh干活之前先把计划给你写清楚
16:47.825–16:49.145
zh写清楚之后的话
16:49.145–16:51.865
zh一步步的按照计划的一个目标
16:51.865–16:53.725
zh再去确认
16:53.725–16:55.385
zh然后再去编码
16:55.385–16:56.985
zh而不是说
16:56.985–16:58.665
zh跑到最后发现一堆问题
16:58.665–17:01.165
zh所以说他是先确认
17:01.165–17:04.005
zh由我们这个工程师自己去确认
17:04.005–17:05.465
zh因为他有一些授权模式
17:05.465–17:06.685
zh有确认模式
17:06.685–17:09.165
zh也有全托管的这种模式
17:09.165–17:11.665
zh所以他会有一个确认过程
17:11.665–17:13.125
zh当我们确认没问题之后
17:13.125–17:14.445
zh他再去执行的时候
17:14.445–17:16.005
zh这时候大家会发现
17:16.005–17:17.825
zh他去执行任务的时候
17:17.825–17:19.085
zh他会拆得更细
17:19.085–17:21.565
zh就是agent这一块的话
17:21.565–17:23.245
zh它会做一个大量的一个拆分
17:23.245–17:25.945
zh犀利到每一个函数
17:25.945–17:27.165
zh每一个模块的一个编写
17:27.165–17:28.125
zh然后的话
17:28.125–17:30.445
zh它会有一个非常严格的审查模式
17:30.445–17:32.405
zh它会根据集合上下文去分析
17:32.405–17:33.645
zh潜在的一些bug
17:33.645–17:35.085
zh包括一些安全性问题
17:35.085–17:37.185
zh或者一些性能瓶颈等等的
17:37.185–17:38.965
zh它都会帮你分析的非常透彻
17:38.965–17:41.765
zh所以大家看到Codex
17:41.765–17:42.865
zh帮你升任代码之后
17:42.865–17:44.725
zh基本上这个代码就没什么问题了
17:44.725–17:45.205
zh可以用了
17:45.205–17:47.325
zh因为它内部帮你把这个几个模式
17:47.325–17:47.925
zh已经跑完了
17:47.925–17:50.505
zh所以说你看到的东西都是高质量
17:50.505–17:51.745
zh这也是为什么
17:51.745–17:53.565
zh这个Agent Loan
17:53.565–17:55.965
zh它是一个非常关键的一个点
17:55.965–17:58.385
zh就它做了比较大的一个改进
17:58.385–18:00.365
zh然后是上下文工程
18:00.365–18:03.745
zh就Codex在工程架构这一块
18:03.745–18:05.525
zh对于上下文管理这一块
18:05.525–18:07.405
zh做了非常大的一个优化
18:07.405–18:08.405
zh首先的话
18:08.405–18:10.605
zh它会做一些精简的一个线段检索
18:10.605–18:13.265
zh它会对整个代码库进行予以切分
18:13.265–18:15.085
zh指向模型去注入
18:15.085–18:16.165
zh与当前任务
18:16.165–18:17.785
zh与特定文件相关依赖
18:17.785–18:18.885
zh也就是说
18:18.885–18:20.965
zh我们去问一个问题的时候
18:20.965–18:22.785
zh他不是把整个都给你加载了
18:22.785–18:23.525
zh不是这个意思
18:23.525–18:26.045
zh他是做一个什么叫做索引
18:26.045–18:28.245
zh就是你问的这个问题
18:28.245–18:30.825
zh相关的一些代码片段
18:30.825–18:33.205
zh还有包括一些元数据
18:33.205–18:34.425
zh比如说一些markdown是吧
18:34.425–18:35.705
zh有关系的时候
18:35.705–18:38.045
zh再去做一个检索
18:38.045–18:39.465
zh做一些这个处理
18:39.465–18:40.685
zh而不是说一上来
18:40.685–18:42.645
zh就把整个项目给他拉上去了
18:42.645–18:45.265
zh那这个很容易出现一些上下文
18:45.265–18:46.945
zh超过限制的问题是吧
18:46.945–18:47.765
zh所以说这一块
18:47.765–18:49.905
zh他对于这个整个线的检索
18:49.905–18:50.825
zh做了一个精简
18:50.825–18:52.605
zh然后是 AST
18:52.605–18:54.845
zh这个叫抽象语法树感知
18:54.845–18:57.925
zh他会结合代码的一个数状结构
18:57.925–19:00.745
zh去理解他的一个依赖引用
19:00.745–19:03.765
zh也就是说代码跟代码之间的一个关系的话
19:03.765–19:05.265
zh他是有依赖的
19:05.265–19:06.125
zh他不是说
19:06.125–19:10.345
zh简单粗暴的给你把一些这个代码拼在一起
19:10.345–19:11.265
zh然后去理解的
19:11.265–19:14.785
zh他是一定要把他的一个依赖关系给他分析出来
19:14.785–19:17.165
zh这个做过我们这个
19:17.165–19:18.505
zhJava 项目开发啊
19:18.505–19:19.765
zh就 Maven 依赖的这个同学
19:19.765–19:21.145
zh应该会比较清楚啊
19:21.145–19:22.905
zh包括至于 Python 里面啊
19:22.905–19:23.925
zh各种语言里面
19:23.925–19:24.825
zh其实都有一些
19:24.825–19:26.985
zh一些库的一些依赖是吧
19:26.985–19:28.905
zh那么如果说啊
19:28.905–19:31.205
zhAI没有理解这个依赖引用的话
19:31.205–19:32.605
zh就很可能出现什么呢
19:32.605–19:34.285
zh就是一些编译报错呀
19:34.285–19:35.965
zh或者是一些少一些模块啊
19:35.965–19:36.145
zh是吧
19:36.145–19:37.165
zh就很容易出现这种问题
19:37.165–19:38.745
zh所以早期的AI编程工具
19:38.745–19:39.805
zh它帮你设计代码的话
19:39.805–19:41.765
zh有时候就就会出现这种问题
19:41.765–19:43.025
zh因为它没有分析透彻
19:43.025–19:45.225
zh它只是简单粗暴的给你去生成代码
19:45.225–19:47.485
zh那现在Codex这种
19:47.485–19:49.045
zh最新的AI编程工具
19:49.045–19:50.585
zh这些问题他们都解决了
19:50.585–19:53.045
zh那么它给你把依赖分析的非常透彻
19:53.045–19:57.685
zh然后是外部工具的一个协同
19:57.685–19:59.685
zh那这个里面的话
19:59.685–20:02.005
zh主要是就是在工程化设计中
20:02.005–20:03.365
zhCodex的话
20:03.365–20:06.625
zh它其实是具备了强大的一个环境交互能力
20:06.625–20:09.025
zh它不是只是说一个文本生成技术
20:09.025–20:13.025
zh它具有非常强大的一个自主执行能力
20:13.025–20:16.465
zh就是我们给了它终端环境的一个控制权
20:16.465–20:18.065
zh就是他可以几乎
20:18.065–20:20.825
zh你如果用的是这个bypass模式
20:20.825–20:21.085
zh是吧
20:21.085–20:22.565
zh你就把所有的权限交给他
20:22.565–20:24.505
zh那他就可以做很多事情了
20:24.505–20:26.085
zh不管是什么编译器啊
20:26.085–20:26.725
zh调试器啊
20:26.725–20:27.425
zh包管理器啊
20:27.425–20:27.685
zh是吧
20:27.685–20:28.445
zh直接调用
20:28.445–20:30.865
zh因为他相当于就是超级管理员
20:30.865–20:31.925
zh他可以做任何事情
20:31.925–20:32.985
zh并且的话
20:32.985–20:34.465
zh当代码报错的时候
20:34.465–20:36.005
zh他会自动的去处理
20:36.005–20:37.665
zh自动的去读取日志
20:37.665–20:39.725
zh然后去定位这个原因
20:39.725–20:40.785
zh并且自动修复
20:40.785–20:41.925
zh所以说这是
20:41.925–20:43.625
zh它非常强大的一个能力
20:43.625–20:45.325
zh就是它发现问题之后
20:45.325–20:46.945
zh它会自动的去修复问题
20:46.945–20:48.145
zh所以大家会觉得
20:48.145–20:50.145
zh目前的AI编程工具非常智能
20:50.145–20:53.145
zh因为它帮你把所有的问题都解决了
20:53.145–20:54.125
zh并且是全自动的
20:54.125–20:55.825
zh不需要你再去提什么问题了
20:55.825–20:57.025
zh所以这个是一个
20:57.025–20:59.365
zh非常大的一个优化点
20:59.365–21:00.805
zh好
21:00.805–21:01.905
zh所以说大家首先
21:01.905–21:03.285
zh要对Codex
21:03.285–21:04.985
zh它的一个工程化设计思想
21:04.985–21:06.225
zh要有一个认知
21:06.225–21:09.005
zh那么你掌握了这个
21:09.005–21:11.985
zh它的一个工程化设计思想之后的话
21:11.985–21:13.825
zh大家再去
21:13.825–21:15.065
zh用Codex的话
21:15.065–21:16.805
zh你就会发现啊
21:16.805–21:17.685
zh它的一些细节
21:17.685–21:20.805
zh就会怎么样更好的去使用它
21:20.805–21:22.605
enOK
0:00.000–0:05.673
首先我们来讲第一块,Codex核心能力与工程化设计的一个思想。
0:05.673–0:15.920
那么Codex的话,相信大家如果是作为程序员的话,基本上多多少少都已经听说过了,或者有的同学已经用过一段时间了。
0:15.920–0:17.080
那这里的话
0:17.080–0:18.960
我给他做一个简单的概述啊
0:18.960–0:22.980
Codex是OpenAI官方推出的一款AI编程工具啊
0:22.980–0:24.240
但这个目前
0:24.240–0:27.700
这个已经不仅仅局限于AI编程这一块了啊
0:27.700–0:29.340
他能做的事情非常多啊
0:29.340–0:30.760
怎么等一下逐步来展开
0:30.760–0:35.720
那么大家可以通过这个官方的一个文档啊
0:35.720–0:40.300
如果想去深入的了解Codex所有的一些细节的话啊
0:40.300–0:42.380
我建议大家去看一下这个OpenAI
0:42.380–0:45.860
出的这个官方的这个开发者文档
0:45.860–0:47.520
这个是给开发人员看的
0:47.520–0:49.760
里面的一些文档的话写的非常详细
0:49.760–0:52.940
大家对一些概念性的认知
0:52.940–0:56.660
包括一些比如说我们来查一些指南
0:56.660–0:59.460
大家都可以通过这个文档做一个入手
0:59.460–1:01.760
所以说这是一份非常好的学习资料
1:01.760–1:03.480
这是我推荐给大家的
1:03.480–1:05.400
然后的话是Codex的话
1:05.400–1:07.440
它有一些模块的话
1:07.440–1:08.300
它是开源的
1:08.300–1:11.760
如果大家对它的底层源码感兴趣
1:11.760–1:13.100
比如说像CLI
1:13.100–1:13.820
是吧
1:13.820–1:14.780
还有一些这个
1:14.780–1:17.020
他的一些文档呀
1:17.020–1:17.400
你看
1:17.400–1:20.800
比如说他的一些agents.md的一些这个细节文档
1:20.800–1:22.820
大家如果感兴趣啊
1:22.820–1:26.180
可以去他的这个开源的这个仓库里面
1:26.180–1:27.660
去深入的去研究一下
1:27.660–1:32.100
这个也是我给大家提供的一份这个学习资料
1:32.100–1:33.520
就是这个入口
1:33.520–1:35.520
大家可以从这个地方去入手
1:35.520–1:38.300
如果你对他的这个源码也比较感兴趣
1:38.300–1:40.940
像参与这个Codex
1:40.940–1:42.260
他的一个开源建设的话
1:42.260–1:44.720
大家可以在这个里面去做一个入手
1:44.720–1:45.460
OK
1:45.460–1:48.860
这个就是我给大家推荐的这个两份学习资料啊
1:48.860–1:54.000
然后下面这个的话是CodexAPP的这么一个页面啊
1:54.000–1:57.460
最开始的话Codex是没有APP版本的啊
1:57.460–1:59.540
它是基于这个CLI命令行的
1:59.540–2:02.000
所以最早期大家使用的话啊
2:02.000–2:04.060
基本上是基于这个命令行啊
2:04.060–2:08.320
比如说我们在这个里面输入一个这个Codex是吧
2:08.320–2:10.080
那我们进入到这个命令行页面
2:10.080–2:13.060
直接就可以做一个AI编程了
2:13.060–2:14.860
我们最开始的使用方式是这样的
2:14.860–2:15.360
但是的话
2:15.360–2:18.560
目前的话Codex已经出了这个APP了
2:18.560–2:19.760
然后也非常好用
2:19.760–2:20.460
等一下的话
2:20.460–2:21.760
我们就来给他讲一下
2:21.760–2:24.060
这个APP的一个安装跟使用
2:24.060–2:30.200
所以我们主要是基于这个CLI和这个APP
2:30.200–2:32.160
混合的这种方式去使用
2:32.160–2:32.960
还有的话
2:32.960–2:35.200
就是他还有一种插件形式的
2:35.200–2:39.000
就是我们可以用这个 Cursor 或者 VSCode
2:39.000–2:42.800
大家可以去装一个这个 Cursor
2:42.800–2:45.340
就是整个它有一个Codex插件
2:45.340–2:46.640
这个也比较好用
2:46.640–2:50.160
这个的话如果大家习惯性用这个 VSCode
2:50.160–2:51.280
或者是 Cursor 的话
2:51.280–2:52.740
你可以把这个插件
2:52.740–2:54.400
装一个Codex插件
2:54.400–2:57.340
然后跟我们的这个编码结合起来去用
2:57.340–2:58.560
这也是OK的
2:58.560–3:00.880
这也是我比较推荐大家用的一种方式
3:00.880–3:02.120
如果你既要改代码
3:02.120–3:04.220
又要去做这个
3:04.220–3:06.480
你想用这个Codex的话
3:06.480–3:07.400
都是OK的
3:07.400–3:10.020
但你不在这个里面装插件
3:10.020–3:10.920
你用那个APP
3:10.920–3:12.680
然后或者是CLI
3:12.680–3:13.700
也是没有问题的
3:13.700–3:15.300
只是说在这个里面的话
3:15.300–3:17.020
切换就会比较简单一些
3:17.020–3:19.740
不然的话你要切换这个窗口
3:19.740–3:21.660
还是稍微有那么一点麻烦
3:21.660–3:23.480
不过这个都是小问题
3:23.480–3:25.260
所以说它的使用方式有
3:25.260–3:26.340
基本上就是三种
3:26.340–3:28.240
第一种的话就是我们用这个APP
3:28.240–3:30.440
然后第二种的话就是用CLI
3:30.440–3:32.680
还有的话就是一个插件形式
3:32.680–3:34.640
基本上目前主流的使用方式的话
3:34.640–3:35.320
就是三个
3:35.320–3:38.200
那么它主要啊
3:38.200–3:41.740
如果说在做这个AI编程这一块的话
3:41.740–3:43.220
它主要的功能有哪些呢
3:43.220–3:44.620
首先第一块的话啊
3:44.620–3:46.640
写代码就是一个基础功能的
3:46.640–3:48.480
那么在Codex里面的话
3:48.480–3:51.220
大家可以非常方便的去使用一些快捷指令
3:51.220–3:53.400
然后采用这种对话的方式
3:53.400–3:56.440
去让它去帮你去生成这个代码
3:56.440–3:58.480
或者说整个去开发一个项目
3:58.480–4:00.400
搭建一个项目架构都是OK的
4:00.400–4:01.780
还有一点的话
4:01.780–4:04.900
就是我们可以用Codex去学习一些
4:04.900–4:06.180
优秀的开源项目
4:06.180–4:08.980
比如说大家对这个开源项目比较感兴趣
4:08.980–4:10.460
就是把这个项目拉下来
4:10.460–4:13.480
然后通过Codex命令去分析一下
4:13.480–4:14.740
当前这个项目的话
4:14.740–4:16.340
它的一个结构是怎么样的
4:16.340–4:18.300
包括大家在公司里面
4:18.300–4:22.120
你去接手一些历史的一些遗留项目
4:22.120–4:22.420
是吧
4:22.420–4:24.200
一些代码你看不懂怎么办呢
4:24.200–4:25.720
那你也可以用Codex
4:25.720–4:27.940
可以去帮你去做一个阅读
4:27.940–4:30.200
然后帮助你快速的去理解
4:30.200–4:33.120
团队是如何去做一个开发的
4:33.120–4:34.380
然后包括里面的细节问题
4:34.380–4:36.660
他都可以通过Codex去把它分析出来
4:36.660–4:37.940
这也是一个场景
4:37.940–4:40.380
然后的话就是审查代码
4:40.380–4:42.740
那以前我们做那个代码审查的话
4:42.740–4:45.500
大家习惯性的要去看那个PR是吧
4:45.500–4:47.620
看PR里面的这个commit
4:47.620–4:49.540
Diff里面到底给了哪些文件
4:49.540–4:50.680
然后看一下有没有漏洞
4:50.680–4:51.680
然后有问题的话
4:51.680–4:53.100
还得上面标注一下
4:53.100–4:54.400
以前的话
4:54.400–4:56.560
这个需要耗费大量的这个人工成本
4:56.560–4:58.360
专门需要一个代码审查
4:58.360–5:00.520
那现在有了Codex之后的话
5:00.520–5:01.800
我们做代码审查的话
5:01.800–5:02.840
其实会非常简单
5:02.840–5:04.400
就是这个里面的话
5:04.400–5:05.640
他会去分析
5:05.640–5:09.360
他有专门的review的这么一个斜杠命令
5:09.360–5:11.680
这个我们等一下会给大家讲这么一个案例
5:11.680–5:14.700
就是我们可以用review的一个命令
5:14.700–5:16.680
去快速的去分析本次
5:16.680–5:18.920
比如说我还没有提交的一些代码
5:18.920–5:19.920
我想让他分析一下
5:19.920–5:21.760
或者说我们已经提交的PR
5:21.760–5:23.560
这个代码有没有问题
5:23.560–5:26.180
也可以分析出来
5:26.180–5:27.700
让我们根据这个结果
5:27.700–5:29.400
最后去把这个代码
5:29.400–5:31.480
就是给提一些建议
5:31.480–5:33.780
或者给他拒绝这个PR合并
5:33.780–5:34.140
是吧
5:34.140–5:35.860
这个就是我们做代码审查
5:35.860–5:37.560
可以结合Codex做的一些事情
5:37.560–5:38.660
然后的话
5:38.660–5:40.680
大家还可以通过Codex去
5:40.680–5:42.740
排查一些线上的一些问题
5:42.740–5:43.100
是吧
5:43.100–5:44.400
比如我们线上发现一些bug
5:44.400–5:45.400
有一些日志
5:45.400–5:47.100
他定位了一些代码行
5:47.100–5:49.100
那我们把这些日志提供给Codex
5:49.100–5:49.900
那Codex的话
5:49.900–5:51.920
可以快速的去帮我们找到
5:51.920–5:53.400
这个代码到底哪里出问题了
5:53.400–5:55.500
并针对性的给一些修复方案出来
5:55.500–5:57.000
所以这个也是一个
5:57.000–5:59.360
比较好的一个应用方向
5:59.360–6:01.420
然后最后一个的话
6:01.420–6:03.340
就是自动化开发任务啊
6:03.340–6:05.220
那这一块也是用的比较多的一个场景
6:05.220–6:07.920
那就是说我们可以通过Codex啊
6:07.920–6:10.540
就是从零到一去做一个项目的一个开发
6:10.540–6:11.720
那我们等一下的话
6:11.720–6:13.460
也会带大家去基于这个流程
6:13.460–6:14.800
去做一个项目啊
6:14.800–6:16.120
就是从需求分析开始
6:16.120–6:20.400
到整个的一个项目的一个功能拆解啊
6:20.400–6:20.740
是吧
6:20.740–6:22.020
核心功能开发呀
6:22.020–6:23.180
包括测试啊
6:23.180–6:25.480
包括整个的一个啊
6:25.480–6:26.240
调试啊
6:26.240–6:26.500
是吧
6:26.500–6:31.100
这个我们等一下都会给大家去走一遍啊
6:31.100–6:32.600
所以这几个场景的话
6:32.600–6:33.800
都是Codex
6:33.800–6:36.340
它比较擅长
6:36.340–6:38.580
或者说比较主流的一些应用场景
6:38.580–6:40.060
那么Codex
6:40.060–6:42.260
它的一个核心能力有哪些呢
6:42.260–6:45.160
大家要比较好的去使用Codex的话
6:45.160–6:47.260
首先要对它的一个核心能力
6:47.260–6:49.420
或者说对它整个的一个功能架构的话
6:49.420–6:51.000
有一个认知
6:51.000–6:52.520
就是要有一个大的认知
6:52.520–6:53.040
这样的话
6:53.040–6:55.260
你在去做一些开发的时候
6:55.260–6:55.900
你就会想到
6:55.900–6:58.120
原来Codex已经集成这个能力了
6:58.120–7:00.480
那大家去直接把它去应用到
7:00.480–7:01.700
工作当中去的话
7:01.700–7:03.360
那这个提效就很明显了
7:03.360–7:04.640
那大家可以看一下
7:04.640–7:05.860
整个的一个
7:05.860–7:07.320
它的一个能力
7:07.320–7:09.880
那能力的话是非常多了
7:09.880–7:11.100
最主要的话
7:11.100–7:13.080
就是它的一个多任务处理
7:13.080–7:14.240
就是多线程
7:14.240–7:16.480
大家在用这个Codex过程中
7:16.480–7:17.840
你会发现一个点
7:17.840–7:19.300
就是整个
7:19.300–7:21.440
它是基于多线程的一个机制
7:21.440–7:22.960
就是你不断的跟它去对话
7:22.960–7:24.940
它会不断的去起
7:24.940–7:25.860
各种各样的线程
7:25.860–7:26.860
帮你去完成任务
7:26.860–7:28.640
并且最终做一个合并
7:28.640–7:31.240
所以它的一个跨项目的
7:31.240–7:32.900
多任务处理能力非常强
7:32.900–7:36.560
就是你可以让它同时去开发三个项目
7:36.560–7:37.940
开三个这个线程
7:37.940–7:38.500
是吧
7:38.500–7:39.240
然后最终
7:39.240–7:42.820
比如说我们想让它分析三个项目的一个细节
7:42.820–7:45.384
然后分析完之后做一个总结归纳
7:45.384–7:47.184
最后给你输出一张表格。
7:47.184–7:48.884
那他就是启动三个线程。
7:48.884–7:52.984
即使是跨多项目的话,他也可以用多任务的方式去处理。
7:52.984–7:55.084
这是他的一个非常强大的一个能力。
7:55.084–7:59.684
然后的话,他里面内置了一个叫Git WorkTree的一个这么一个机制。
7:59.684–8:01.444
它的一个优点是什么
8:01.444–8:03.344
就是我们可以在一个分支下面
8:03.344–8:06.044
可以支持加多个这个work tree
8:06.044–8:07.424
然后去并行开发
8:07.424–8:09.384
以前的话我们开发的话
8:09.384–8:11.624
就是都要做分支隔离的是吧
8:11.624–8:15.864
比如说某某同学是做这个A分支
8:15.864–8:17.044
某某同学是B分支
8:17.044–8:18.724
他们两个分支功能
8:18.724–8:20.244
如果要做并行开发的话
8:20.244–8:22.564
那得把他们两个分支给它合并了
8:22.564–8:22.844
是吧
8:22.844–8:24.904
这样的功能才能整合到一起
8:24.904–8:27.824
现在有了这个 git worktree 的之后的话
8:27.824–8:29.924
Codex整合了这个之后的话
8:29.924–8:31.684
我们可以直接在一个分支里面
8:31.684–8:33.564
加多个worktree的方式做并行开发
8:33.564–8:35.764
并且的话代码它是相互隔离的
8:35.764–8:38.224
这样的话就达到了我不想见多分支
8:38.224–8:40.664
也能实现多人协作的这么一个目标
8:40.664–8:42.344
这是一个比较好的一个点
8:42.344–8:43.824
然后的话就是
8:43.824–8:46.724
我们可以通过这个Codex
8:46.724–8:48.024
做一个远程连接啊
8:48.024–8:52.024
就是它可以去专门连接到一个这个
8:52.024–8:53.964
不同的这个
8:53.964–8:55.544
比如说我们手机端是吧
8:55.544–8:57.164
我们手机端去远程连接
8:57.164–8:59.644
这个我们在手机端上面远程操控
8:59.644–9:01.464
我们电脑端的这么一个Codex
9:01.464–9:02.184
让它去干活
9:02.184–9:04.964
这个也是一个好的一个功能
9:04.964–9:06.844
这个就像那个小龙虾是吧
9:06.844–9:07.504
养虾一样
9:07.504–9:09.484
我可以远程指挥它去干活
9:09.484–9:10.764
并且的话
9:10.764–9:13.904
我们可以在这个Codex上面操作一些应用
9:13.904–9:15.504
比如说在iOS上面
9:15.504–9:17.824
去调用一些这个
9:17.824–9:19.344
在MacOS上面
9:19.344–9:21.084
就是我们的这个苹果系统上面
9:21.084–9:22.864
它可以去调用各种的应用
9:22.864–9:24.024
执行一些任务
9:24.024–9:25.584
包括一些操作浏览器
9:25.584–9:26.864
当然都是支持的
9:26.864–9:29.364
并且的话它可以支持应用截图识别图片
9:29.364–9:31.664
然后做一些评审交付
9:31.664–9:33.944
执行终端的一些命令
9:33.944–9:35.384
然后操作浏览器
9:35.384–9:37.744
包括它还可以去添加一些Chrome插件
9:37.744–9:42.204
让Codex帮你去管理整个我们的这个浏览器
9:42.204–9:42.524
是吧
9:42.524–9:44.464
然后做一些浏览器的一些任务
9:44.464–9:47.284
并且的话它可以去生成一些图片
9:47.284–9:48.024
编辑图片
9:48.024–9:49.564
因为OpenAI的话
9:49.564–9:52.804
它本身就有一些这个图片的一些模型
9:52.804–9:54.044
多模态模型
9:54.044–9:55.584
比如说像 DALL-E 3
9:55.584–9:56.844
然后image2
9:56.844–9:58.104
就是有它有生成
9:58.104–9:59.404
专门生成图片的模型
9:59.404–10:00.704
所以说它本身
10:00.704–10:02.264
也可以去编辑图片
10:02.264–10:03.404
这样的话
10:03.404–10:04.104
我们相当于
10:04.104–10:05.824
你可以把codex当做
10:05.824–10:07.904
这个AI绘画工具来用
10:07.904–10:09.164
这个也是可以的
10:09.164–10:10.584
包括我们还可以做一些
10:10.584–10:11.624
这个自动化
10:11.624–10:13.564
就是一些这个任务
10:13.564–10:14.004
是吧
10:14.004–10:16.504
你做了一些这个操作之后
10:16.504–10:17.624
你可以让它全自动的
10:17.624–10:18.764
去调用各种各样的工具
10:18.764–10:19.744
帮你去完成一个
10:19.744–10:20.824
大的一个任务
10:20.824–10:21.824
就全自动的
10:21.824–10:23.164
然后的话
10:23.164–10:25.124
就是我们还可以在codex上面
10:25.124–10:26.384
去搭建一些技能
10:26.384–10:27.164
这个我们等一下
10:27.164–10:27.984
也会给大家讲
10:27.984–10:29.024
就是怎么从零到一
10:29.024–10:30.024
去搭建一个技能
10:30.024–10:31.424
做真正企业级的
10:31.424–10:32.384
一个 skill 开发
10:32.384–10:34.004
然后怎么去使用它
10:34.004–10:35.904
然后包括一些这个
10:35.904–10:37.944
一些什么侧边栏
10:37.944–10:39.084
与 artifact
10:39.084–10:40.484
这个是它的一些
10:40.484–10:42.484
跟踪计划来源
10:42.484–10:43.364
任务摘要和
10:43.364–10:45.024
生成文件预览的一些功能
10:45.024–10:45.764
这个都是它
10:45.764–10:47.124
比较实用的一些功能
10:47.124–10:47.964
还有包括它
10:47.964–10:49.804
比较强大的一个插件系统
10:49.804–10:50.564
这个我们等一下
10:50.564–10:51.284
也会给大家讲
10:51.284–10:52.644
这个插件功能的话
10:52.644–10:53.644
其实也非常强大
10:53.644–10:57.444
它可以极大程度的去拓展Codex
10:57.444–10:58.524
能做的一些事情
10:58.524–10:59.304
让它可以
10:59.304–11:01.524
比如说甚至去生生视频也是可以的
11:01.524–11:02.504
并且的话
11:02.504–11:04.024
它可以与我们的这个IDE
11:04.024–11:04.884
比如说与 Cursor
11:04.884–11:06.424
或者是用 VS Code
11:06.424–11:07.644
整个做一个同步
11:07.644–11:09.784
这个就是它的一个核心能力
11:09.784–11:11.164
那么大家有了一个
11:11.164–11:13.224
全方位的这个认知之后的话
11:13.224–11:14.764
后面你在用Codex的时候
11:14.764–11:16.424
你可以把这一点给考虑进去
11:16.424–11:18.704
如果说 Codex 里面已经集成这个功能的话
11:18.704–11:21.424
那你可以完全把它做一个整合
11:21.424–11:23.444
就大家可以可以把各种各样的功能
11:23.444–11:25.964
整合在一起搭配去使用
11:25.964–11:28.944
大家就是不要单独的去看待这个功能
11:28.944–11:30.384
你一定要把它做一个什么呢
11:30.384–11:32.064
就是整合
11:32.064–11:33.984
就是我们把一个工作流
11:33.984–11:35.984
你把整个串起来
11:35.984–11:37.224
那它就可以做很多事情
11:37.224–11:39.904
如果你只是聚焦它在单个功能上面的话
11:39.904–11:42.224
它可能做的功能的话就比较单一
11:42.224–11:44.024
所以大家要有一个全局的思维
11:44.024–11:45.364
OK
11:45.364–11:49.564
然后是Codex它的一个工程化设计思想
11:49.564–11:52.244
那么这个设计思想有什么用呢
11:52.244–11:55.064
那么Codex的话
11:55.064–11:56.584
跟我们以前的这个
11:56.584–11:58.764
AI编程助手的话
11:58.764–12:00.784
还是有一些不一样的地方
12:00.784–12:03.244
因为它毕竟是OpenAI出的
12:03.244–12:05.144
它的一些设计思想的话
12:05.144–12:06.704
跟这个 Cursor
12:06.704–12:08.044
或者是 VS Code
12:08.044–12:11.564
它们整合这个AI工具
12:11.564–12:13.144
稍微有一点不一样
12:13.144–12:15.544
那么它已经从一个
12:15.544–12:17.544
简单的这个AI编码助手
12:17.544–12:19.004
已经进化成一个叫做
12:19.004–12:20.744
全栈开发的一个伙伴了
12:20.744–12:21.924
为什么这么说呢
12:21.924–12:23.384
主要有以下几个基点
12:23.384–12:26.984
首先的话是规范工程取代了提示词工程
12:26.984–12:29.764
以前的话大家是吧
12:29.764–12:31.804
你做一个项目的话习惯性的
12:31.804–12:33.924
你要把提示词给写好是吧
12:33.924–12:37.464
那么Codex里面他已经在提供一个
12:37.464–12:39.284
就是在强调一个点啊
12:39.284–12:40.624
叫做规范化编程
12:40.624–12:43.184
就是目前业界有一个非常
12:43.184–12:44.864
这个主流的一个词啊
12:44.864–12:46.524
叫做这个 SDD 是吧
12:46.524–12:48.564
就是叫规范编程开发
12:48.564–12:51.284
就是以规范去驱动
12:51.284–12:52.384
我们整个的一个逻辑
12:52.384–12:53.864
也就是说他先要
12:53.864–12:55.204
你把这个规范写好
12:55.204–12:56.704
比如说去写 agents.md
12:56.704–12:57.784
写 rules
12:57.784–12:59.244
整个这个规范给他写好
12:59.244–13:00.104
写好完之后
13:00.104–13:01.724
然后再去用AI生成代码
13:01.724–13:02.524
这样的话
13:02.524–13:04.124
他的质量会非常高
13:04.124–13:05.584
所以以前的话
13:05.584–13:07.944
大家没有注意规范的时候
13:07.944–13:10.324
那你去用自然语言
13:10.324–13:12.384
给他去表达的时候
13:12.384–13:14.084
那就会出现一个问题
13:14.084–13:16.004
就是这个东西的一个边界
13:16.004–13:16.784
就会有问题
13:16.784–13:19.244
就是你采用一个结构化的一个输入
13:19.244–13:21.824
整个它就会非常清晰
13:21.824–13:24.104
就是有规则跟没规则的区别
13:24.104–13:24.704
就是在于
13:24.704–13:27.524
它可以有一个目标
13:27.524–13:30.844
加边界加验收标准的一个结构
13:30.844–13:32.684
这个就相当于我们
13:32.684–13:34.384
大家实际在工作当中
13:34.384–13:35.724
你去做一个事情的时候
13:35.724–13:37.184
它有没有一个什么呢
13:37.184–13:38.264
就是规范
13:38.264–13:40.364
就是有没有自己的一个标准
13:40.364–13:42.204
如果你没有标准的话
13:42.204–13:44.264
你做一个事情的话
13:44.264–13:45.964
就会出现各种各样的一个问题
13:45.964–13:48.304
就是有标准的好处
13:48.304–13:50.304
就是它可以保质保量的去验收
13:50.304–13:53.464
就是达到这么一个效果
13:53.464–13:56.964
所以说Codex已经在强调
13:56.964–13:59.224
这个规范化的一个编程方式
13:59.224–14:00.624
就是用 Agent MD
14:00.624–14:02.144
整个的一套
14:02.144–14:03.224
包括这个Harness
14:03.224–14:04.524
这个Codex
14:04.524–14:06.444
前一段时间也发了一篇文章
14:06.444–14:06.764
是吧
14:06.764–14:08.444
就关于这个 Harness Engineering
14:08.444–14:09.724
它整个的话
14:09.724–14:12.444
目前就是采用了这个整个一套Harness
14:12.444–14:13.804
去做一个落地的
14:13.804–14:16.084
包括他自己内部
14:16.084–14:19.464
OpenAI内部也是基于这个Harness
14:19.464–14:23.324
去做了整个的一个项目的一个落地的
14:23.324–14:26.104
之前他们有一篇文章里面提到了
14:26.104–14:28.164
就是三个人
14:28.164–14:30.084
一百多万行代码
14:30.084–14:32.184
全部都是AI生成的
14:32.184–14:34.564
就是用Harness Engineering去做的一个落地
14:34.564–14:36.764
就是人工
14:36.764–14:38.144
我们只限定规范
14:38.144–14:39.824
把标准写好
14:39.824–14:40.784
把目标定好
14:40.784–14:43.264
所有的代码都是AI生成的
14:43.264–14:45.304
人工不需要写一行代码啊
14:45.304–14:46.684
真的是一行代码都不需要写
14:46.684–14:49.464
他就是能把一个大型的项目给搞定
14:49.464–14:51.144
大概是花了啊
14:51.144–14:52.164
我记得是五到六个月
14:52.164–14:53.584
然后给他上线了啊
14:53.584–14:56.364
一个一百万多行的这个一个项目啊
14:56.364–14:57.464
就是这么简单
14:57.464–14:58.384
所以说啊
14:58.384–14:59.704
目前啊
14:59.704–15:03.484
Codex已经在深入的去落地这个Harness Engineering
15:03.484–15:07.084
所以他对规范的要求是非常严格的啊
15:07.084–15:08.664
大家等一下啊
15:08.664–15:09.684
我们在讲解过程中
15:09.684–15:12.124
大家就会感受到他整个这个逻辑啊
15:12.124–15:14.244
就是会变得非常规范化
15:14.244–15:16.164
然后第二块就是
15:16.164–15:18.224
他在这个意图拆解
15:18.224–15:19.164
与agent loop
15:19.164–15:20.904
我们叫任务循环这一块的话
15:20.904–15:22.244
也会强调的比较多
15:22.244–15:23.744
因为Codex已经
15:23.744–15:26.644
不是单单的给你去生成一个代码了
15:26.644–15:29.484
他是通过agent循环机制
15:29.484–15:31.524
去模拟人类工程师的一个开发过程
15:31.524–15:32.644
什么意思呢
15:32.644–15:34.824
就是人是怎么干活的
15:34.824–15:36.464
他就是怎么干活的
15:36.464–15:38.844
就以前AI就给你写个代码就完事了
15:38.844–15:41.104
他也不管你能不能运行
15:41.104–15:41.604
啊
15:41.604–15:55.305
除非你
15:55.305–15:57.485
相当于他计划帮你做好了
15:57.485–15:58.885
执行模式也帮你做好了
15:58.885–16:01.705
最后你看到的结果就是没有问题的
16:01.705–16:02.765
就是可以跑的
16:02.765–16:04.265
所以大家现在会发现
16:04.265–16:07.945
就是今年这些个AI编程工具的话
16:07.945–16:09.225
它的进步非常大
16:09.225–16:11.785
就是在Agent这一块做了非常大的一个改进
16:11.785–16:14.785
那大家会发现目前像Claude Code
16:14.785–16:18.085
或者其他的一些像这个Claude
16:18.085–16:19.525
这个Codex
16:19.525–16:22.765
或者像这个其他的一些编程工具
16:22.765–16:23.685
大家会发现
16:23.685–16:25.745
它的一个质量明显就上去了
16:25.745–16:27.925
就是它写出来代码直接就可以用了
16:27.925–16:30.545
基本上没什么太明显的一个问题
16:30.545–16:34.225
所以说它内置的一个任务循环
16:34.225–16:37.405
就保证了我们整个的一些什么呢
16:37.405–16:39.165
一些bug一些安全性问题
16:39.165–16:40.325
它就帮你去避免了
16:40.325–16:42.925
因为它会按照我们人类的一个思维
16:42.925–16:44.725
首先会做一个plan计划
16:44.725–16:47.825
干活之前先把计划给你写清楚
16:47.825–16:49.145
写清楚之后的话
16:49.145–16:51.865
一步步的按照计划的一个目标
16:51.865–16:53.725
再去确认
16:53.725–16:55.385
然后再去编码
16:55.385–16:56.985
而不是说
16:56.985–16:58.665
跑到最后发现一堆问题
16:58.665–17:01.165
所以说他是先确认
17:01.165–17:04.005
由我们这个工程师自己去确认
17:04.005–17:05.465
因为他有一些授权模式
17:05.465–17:06.685
有确认模式
17:06.685–17:09.165
也有全托管的这种模式
17:09.165–17:11.665
所以他会有一个确认过程
17:11.665–17:13.125
当我们确认没问题之后
17:13.125–17:14.445
他再去执行的时候
17:14.445–17:16.005
这时候大家会发现
17:16.005–17:17.825
他去执行任务的时候
17:17.825–17:19.085
他会拆得更细
17:19.085–17:21.565
就是agent这一块的话
17:21.565–17:23.245
它会做一个大量的一个拆分
17:23.245–17:25.945
犀利到每一个函数
17:25.945–17:27.165
每一个模块的一个编写
17:27.165–17:28.125
然后的话
17:28.125–17:30.445
它会有一个非常严格的审查模式
17:30.445–17:32.405
它会根据集合上下文去分析
17:32.405–17:33.645
潜在的一些bug
17:33.645–17:35.085
包括一些安全性问题
17:35.085–17:37.185
或者一些性能瓶颈等等的
17:37.185–17:38.965
它都会帮你分析的非常透彻
17:38.965–17:41.765
所以大家看到Codex
17:41.765–17:42.865
帮你升任代码之后
17:42.865–17:44.725
基本上这个代码就没什么问题了
17:44.725–17:45.205
可以用了
17:45.205–17:47.325
因为它内部帮你把这个几个模式
17:47.325–17:47.925
已经跑完了
17:47.925–17:50.505
所以说你看到的东西都是高质量
17:50.505–17:51.745
这也是为什么
17:51.745–17:53.565
这个Agent Loan
17:53.565–17:55.965
它是一个非常关键的一个点
17:55.965–17:58.385
就它做了比较大的一个改进
17:58.385–18:00.365
然后是上下文工程
18:00.365–18:03.745
就Codex在工程架构这一块
18:03.745–18:05.525
对于上下文管理这一块
18:05.525–18:07.405
做了非常大的一个优化
18:07.405–18:08.405
首先的话
18:08.405–18:10.605
它会做一些精简的一个线段检索
18:10.605–18:13.265
它会对整个代码库进行予以切分
18:13.265–18:15.085
指向模型去注入
18:15.085–18:16.165
与当前任务
18:16.165–18:17.785
与特定文件相关依赖
18:17.785–18:18.885
也就是说
18:18.885–18:20.965
我们去问一个问题的时候
18:20.965–18:22.785
他不是把整个都给你加载了
18:22.785–18:23.525
不是这个意思
18:23.525–18:26.045
他是做一个什么叫做索引
18:26.045–18:28.245
就是你问的这个问题
18:28.245–18:30.825
相关的一些代码片段
18:30.825–18:33.205
还有包括一些元数据
18:33.205–18:34.425
比如说一些markdown是吧
18:34.425–18:35.705
有关系的时候
18:35.705–18:38.045
再去做一个检索
18:38.045–18:39.465
做一些这个处理
18:39.465–18:40.685
而不是说一上来
18:40.685–18:42.645
就把整个项目给他拉上去了
18:42.645–18:45.265
那这个很容易出现一些上下文
18:45.265–18:46.945
超过限制的问题是吧
18:46.945–18:47.765
所以说这一块
18:47.765–18:49.905
他对于这个整个线的检索
18:49.905–18:50.825
做了一个精简
18:50.825–18:52.605
然后是 AST
18:52.605–18:54.845
这个叫抽象语法树感知
18:54.845–18:57.925
他会结合代码的一个数状结构
18:57.925–19:00.745
去理解他的一个依赖引用
19:00.745–19:03.765
也就是说代码跟代码之间的一个关系的话
19:03.765–19:05.265
他是有依赖的
19:05.265–19:06.125
他不是说
19:06.125–19:10.345
简单粗暴的给你把一些这个代码拼在一起
19:10.345–19:11.265
然后去理解的
19:11.265–19:14.785
他是一定要把他的一个依赖关系给他分析出来
19:14.785–19:17.165
这个做过我们这个
19:17.165–19:18.505
Java 项目开发啊
19:18.505–19:19.765
就 Maven 依赖的这个同学
19:19.765–19:21.145
应该会比较清楚啊
19:21.145–19:22.905
包括至于 Python 里面啊
19:22.905–19:23.925
各种语言里面
19:23.925–19:24.825
其实都有一些
19:24.825–19:26.985
一些库的一些依赖是吧
19:26.985–19:28.905
那么如果说啊
19:28.905–19:31.205
AI没有理解这个依赖引用的话
19:31.205–19:32.605
就很可能出现什么呢
19:32.605–19:34.285
就是一些编译报错呀
19:34.285–19:35.965
或者是一些少一些模块啊
19:35.965–19:36.145
是吧
19:36.145–19:37.165
就很容易出现这种问题
19:37.165–19:38.745
所以早期的AI编程工具
19:38.745–19:39.805
它帮你设计代码的话
19:39.805–19:41.765
有时候就就会出现这种问题
19:41.765–19:43.025
因为它没有分析透彻
19:43.025–19:45.225
它只是简单粗暴的给你去生成代码
19:45.225–19:47.485
那现在Codex这种
19:47.485–19:49.045
最新的AI编程工具
19:49.045–19:50.585
这些问题他们都解决了
19:50.585–19:53.045
那么它给你把依赖分析的非常透彻
19:53.045–19:57.685
然后是外部工具的一个协同
19:57.685–19:59.685
那这个里面的话
19:59.685–20:02.005
主要是就是在工程化设计中
20:02.005–20:03.365
Codex的话
20:03.365–20:06.625
它其实是具备了强大的一个环境交互能力
20:06.625–20:09.025
它不是只是说一个文本生成技术
20:09.025–20:13.025
它具有非常强大的一个自主执行能力
20:13.025–20:16.465
就是我们给了它终端环境的一个控制权
20:16.465–20:18.065
就是他可以几乎
20:18.065–20:20.825
你如果用的是这个bypass模式
20:20.825–20:21.085
是吧
20:21.085–20:22.565
你就把所有的权限交给他
20:22.565–20:24.505
那他就可以做很多事情了
20:24.505–20:26.085
不管是什么编译器啊
20:26.085–20:26.725
调试器啊
20:26.725–20:27.425
包管理器啊
20:27.425–20:27.685
是吧
20:27.685–20:28.445
直接调用
20:28.445–20:30.865
因为他相当于就是超级管理员
20:30.865–20:31.925
他可以做任何事情
20:31.925–20:32.985
并且的话
20:32.985–20:34.465
当代码报错的时候
20:34.465–20:36.005
他会自动的去处理
20:36.005–20:37.665
自动的去读取日志
20:37.665–20:39.725
然后去定位这个原因
20:39.725–20:40.785
并且自动修复
20:40.785–20:41.925
所以说这是
20:41.925–20:43.625
它非常强大的一个能力
20:43.625–20:45.325
就是它发现问题之后
20:45.325–20:46.945
它会自动的去修复问题
20:46.945–20:48.145
所以大家会觉得
20:48.145–20:50.145
目前的AI编程工具非常智能
20:50.145–20:53.145
因为它帮你把所有的问题都解决了
20:53.145–20:54.125
并且是全自动的
20:54.125–20:55.825
不需要你再去提什么问题了
20:55.825–20:57.025
所以这个是一个
20:57.025–20:59.365
非常大的一个优化点
20:59.365–21:00.805
好
21:00.805–21:01.905
所以说大家首先
21:01.905–21:03.285
要对Codex
21:03.285–21:04.985
它的一个工程化设计思想
21:04.985–21:06.225
要有一个认知
21:06.225–21:09.005
那么你掌握了这个
21:09.005–21:11.985
它的一个工程化设计思想之后的话
21:11.985–21:13.825
大家再去
21:13.825–21:15.065
用Codex的话
21:15.065–21:16.805
你就会发现啊
21:16.805–21:17.685
它的一些细节
21:17.685–21:20.805
就会怎么样更好的去使用它
21:20.805–21:22.605
OK
0:00.000–0:05.673
zh首先我们来讲第一块,Codex核心能力与工程化设计的一个思想。
首先我们来讲第一块,Codex核心能力与工程化设计的一个思想。
0:05.673–0:15.920
zh那么Codex的话,相信大家如果是作为程序员的话,基本上多多少少都已经听说过了,或者有的同学已经用过一段时间了。
那么Codex的话,相信大家如果是作为程序员的话,基本上多多少少都已经听说过了,或者有的同学已经用过一段时间了。
0:15.920–0:17.080
zh那这里的话
那这里的话
0:17.080–0:18.960
zh我给他做一个简单的概述啊
我给他做一个简单的概述啊
0:18.960–0:22.980
zhCodex是OpenAI官方推出的一款AI编程工具啊
Codex是OpenAI官方推出的一款AI编程工具啊
0:22.980–0:24.240
zh但这个目前
但这个目前
0:24.240–0:27.700
zh这个已经不仅仅局限于AI编程这一块了啊
这个已经不仅仅局限于AI编程这一块了啊
0:27.700–0:29.340
zh他能做的事情非常多啊
他能做的事情非常多啊
0:29.340–0:30.760
zh怎么等一下逐步来展开
怎么等一下逐步来展开
0:30.760–0:35.720
zh那么大家可以通过这个官方的一个文档啊
那么大家可以通过这个官方的一个文档啊
0:35.720–0:40.300
zh如果想去深入的了解Codex所有的一些细节的话啊
如果想去深入的了解Codex所有的一些细节的话啊
0:40.300–0:42.380
zh我建议大家去看一下这个OpenAI
我建议大家去看一下这个OpenAI
0:42.380–0:45.860
zh出的这个官方的这个开发者文档
出的这个官方的这个开发者文档
0:45.860–0:47.520
zh这个是给开发人员看的
这个是给开发人员看的
0:47.520–0:49.760
zh里面的一些文档的话写的非常详细
里面的一些文档的话写的非常详细
0:49.760–0:52.940
zh大家对一些概念性的认知
大家对一些概念性的认知
0:52.940–0:56.660
zh包括一些比如说我们来查一些指南
包括一些比如说我们来查一些指南
0:56.660–0:59.460
zh大家都可以通过这个文档做一个入手
大家都可以通过这个文档做一个入手
0:59.460–1:01.760
zh所以说这是一份非常好的学习资料
所以说这是一份非常好的学习资料
1:01.760–1:03.480
zh这是我推荐给大家的
这是我推荐给大家的
1:03.480–1:05.400
zh然后的话是Codex的话
然后的话是Codex的话
1:05.400–1:07.440
zh它有一些模块的话
它有一些模块的话
1:07.440–1:08.300
zh它是开源的
它是开源的
1:08.300–1:11.760
zh如果大家对它的底层源码感兴趣
如果大家对它的底层源码感兴趣
1:11.760–1:13.100
zh比如说像CLI
比如说像CLI
1:13.100–1:13.820
zh是吧
是吧
1:13.820–1:14.780
zh还有一些这个
还有一些这个
1:14.780–1:17.020
zh他的一些文档呀
他的一些文档呀
1:17.020–1:17.400
zh你看
你看
1:17.400–1:20.800
zh比如说他的一些agents.md的一些这个细节文档
比如说他的一些agents.md的一些这个细节文档
1:20.800–1:22.820
zh大家如果感兴趣啊
大家如果感兴趣啊
1:22.820–1:26.180
zh可以去他的这个开源的这个仓库里面
可以去他的这个开源的这个仓库里面
1:26.180–1:27.660
zh去深入的去研究一下
去深入的去研究一下
1:27.660–1:32.100
zh这个也是我给大家提供的一份这个学习资料
这个也是我给大家提供的一份这个学习资料
1:32.100–1:33.520
zh就是这个入口
就是这个入口
1:33.520–1:35.520
zh大家可以从这个地方去入手
大家可以从这个地方去入手
1:35.520–1:38.300
zh如果你对他的这个源码也比较感兴趣
如果你对他的这个源码也比较感兴趣
1:38.300–1:40.940
zh像参与这个Codex
像参与这个Codex
1:40.940–1:42.260
zh他的一个开源建设的话
他的一个开源建设的话
1:42.260–1:44.720
zh大家可以在这个里面去做一个入手
大家可以在这个里面去做一个入手
1:44.720–1:45.460
enOK
OK
1:45.460–1:48.860
zh这个就是我给大家推荐的这个两份学习资料啊
这个就是我给大家推荐的这个两份学习资料啊
1:48.860–1:54.000
zh然后下面这个的话是CodexAPP的这么一个页面啊
然后下面这个的话是CodexAPP的这么一个页面啊
1:54.000–1:57.460
zh最开始的话Codex是没有APP版本的啊
最开始的话Codex是没有APP版本的啊
1:57.460–1:59.540
zh它是基于这个CLI命令行的
它是基于这个CLI命令行的
1:59.540–2:02.000
zh所以最早期大家使用的话啊
所以最早期大家使用的话啊
2:02.000–2:04.060
zh基本上是基于这个命令行啊
基本上是基于这个命令行啊
2:04.060–2:08.320
zh比如说我们在这个里面输入一个这个Codex是吧
比如说我们在这个里面输入一个这个Codex是吧
2:08.320–2:10.080
zh那我们进入到这个命令行页面
那我们进入到这个命令行页面
2:10.080–2:13.060
zh直接就可以做一个AI编程了
直接就可以做一个AI编程了
2:13.060–2:14.860
zh我们最开始的使用方式是这样的
我们最开始的使用方式是这样的
2:14.860–2:15.360
zh但是的话
但是的话
2:15.360–2:18.560
zh目前的话Codex已经出了这个APP了
目前的话Codex已经出了这个APP了
2:18.560–2:19.760
zh然后也非常好用
然后也非常好用
2:19.760–2:20.460
zh等一下的话
等一下的话
2:20.460–2:21.760
zh我们就来给他讲一下
我们就来给他讲一下
2:21.760–2:24.060
zh这个APP的一个安装跟使用
这个APP的一个安装跟使用
2:24.060–2:30.200
zh所以我们主要是基于这个CLI和这个APP
所以我们主要是基于这个CLI和这个APP
2:30.200–2:32.160
zh混合的这种方式去使用
混合的这种方式去使用
2:32.160–2:32.960
zh还有的话
还有的话
2:32.960–2:35.200
zh就是他还有一种插件形式的
就是他还有一种插件形式的
2:35.200–2:39.000
zh就是我们可以用这个 Cursor 或者 VSCode
就是我们可以用这个 Cursor 或者 VSCode
2:39.000–2:42.800
zh大家可以去装一个这个 Cursor
大家可以去装一个这个 Cursor
2:42.800–2:45.340
zh就是整个它有一个Codex插件
就是整个它有一个Codex插件
2:45.340–2:46.640
zh这个也比较好用
这个也比较好用
2:46.640–2:50.160
zh这个的话如果大家习惯性用这个 VSCode
这个的话如果大家习惯性用这个 VSCode
2:50.160–2:51.280
zh或者是 Cursor 的话
或者是 Cursor 的话
2:51.280–2:52.740
zh你可以把这个插件
你可以把这个插件
2:52.740–2:54.400
zh装一个Codex插件
装一个Codex插件
2:54.400–2:57.340
zh然后跟我们的这个编码结合起来去用
然后跟我们的这个编码结合起来去用
2:57.340–2:58.560
zh这也是OK的
这也是OK的
2:58.560–3:00.880
zh这也是我比较推荐大家用的一种方式
这也是我比较推荐大家用的一种方式
3:00.880–3:02.120
zh如果你既要改代码
如果你既要改代码
3:02.120–3:04.220
zh又要去做这个
又要去做这个
3:04.220–3:06.480
zh你想用这个Codex的话
你想用这个Codex的话
3:06.480–3:07.400
zh都是OK的
都是OK的
3:07.400–3:10.020
zh但你不在这个里面装插件
但你不在这个里面装插件
3:10.020–3:10.920
zh你用那个APP
你用那个APP
3:10.920–3:12.680
zh然后或者是CLI
然后或者是CLI
3:12.680–3:13.700
zh也是没有问题的
也是没有问题的
3:13.700–3:15.300
zh只是说在这个里面的话
只是说在这个里面的话
3:15.300–3:17.020
zh切换就会比较简单一些
切换就会比较简单一些
3:17.020–3:19.740
zh不然的话你要切换这个窗口
不然的话你要切换这个窗口
3:19.740–3:21.660
zh还是稍微有那么一点麻烦
还是稍微有那么一点麻烦
3:21.660–3:23.480
zh不过这个都是小问题
不过这个都是小问题
3:23.480–3:25.260
zh所以说它的使用方式有
所以说它的使用方式有
3:25.260–3:26.340
zh基本上就是三种
基本上就是三种
3:26.340–3:28.240
zh第一种的话就是我们用这个APP
第一种的话就是我们用这个APP
3:28.240–3:30.440
zh然后第二种的话就是用CLI
然后第二种的话就是用CLI
3:30.440–3:32.680
zh还有的话就是一个插件形式
还有的话就是一个插件形式
3:32.680–3:34.640
zh基本上目前主流的使用方式的话
基本上目前主流的使用方式的话
3:34.640–3:35.320
zh就是三个
就是三个
3:35.320–3:38.200
zh那么它主要啊
那么它主要啊
3:38.200–3:41.740
zh如果说在做这个AI编程这一块的话
如果说在做这个AI编程这一块的话
3:41.740–3:43.220
zh它主要的功能有哪些呢
它主要的功能有哪些呢
3:43.220–3:44.620
zh首先第一块的话啊
首先第一块的话啊
3:44.620–3:46.640
zh写代码就是一个基础功能的
写代码就是一个基础功能的
3:46.640–3:48.480
zh那么在Codex里面的话
那么在Codex里面的话
3:48.480–3:51.220
zh大家可以非常方便的去使用一些快捷指令
大家可以非常方便的去使用一些快捷指令
3:51.220–3:53.400
zh然后采用这种对话的方式
然后采用这种对话的方式
3:53.400–3:56.440
zh去让它去帮你去生成这个代码
去让它去帮你去生成这个代码
3:56.440–3:58.480
zh或者说整个去开发一个项目
或者说整个去开发一个项目
3:58.480–4:00.400
zh搭建一个项目架构都是OK的
搭建一个项目架构都是OK的
4:00.400–4:01.780
zh还有一点的话
还有一点的话
4:01.780–4:04.900
zh就是我们可以用Codex去学习一些
就是我们可以用Codex去学习一些
4:04.900–4:06.180
zh优秀的开源项目
优秀的开源项目
4:06.180–4:08.980
zh比如说大家对这个开源项目比较感兴趣
比如说大家对这个开源项目比较感兴趣
4:08.980–4:10.460
zh就是把这个项目拉下来
就是把这个项目拉下来
4:10.460–4:13.480
zh然后通过Codex命令去分析一下
然后通过Codex命令去分析一下
4:13.480–4:14.740
zh当前这个项目的话
当前这个项目的话
4:14.740–4:16.340
zh它的一个结构是怎么样的
它的一个结构是怎么样的
4:16.340–4:18.300
zh包括大家在公司里面
包括大家在公司里面
4:18.300–4:22.120
zh你去接手一些历史的一些遗留项目
你去接手一些历史的一些遗留项目
4:22.120–4:22.420
zh是吧
是吧
4:22.420–4:24.200
zh一些代码你看不懂怎么办呢
一些代码你看不懂怎么办呢
4:24.200–4:25.720
zh那你也可以用Codex
那你也可以用Codex
4:25.720–4:27.940
zh可以去帮你去做一个阅读
可以去帮你去做一个阅读
4:27.940–4:30.200
zh然后帮助你快速的去理解
然后帮助你快速的去理解
4:30.200–4:33.120
zh团队是如何去做一个开发的
团队是如何去做一个开发的
4:33.120–4:34.380
zh然后包括里面的细节问题
然后包括里面的细节问题
4:34.380–4:36.660
zh他都可以通过Codex去把它分析出来
他都可以通过Codex去把它分析出来
4:36.660–4:37.940
zh这也是一个场景
这也是一个场景
4:37.940–4:40.380
zh然后的话就是审查代码
然后的话就是审查代码
4:40.380–4:42.740
zh那以前我们做那个代码审查的话
那以前我们做那个代码审查的话
4:42.740–4:45.500
zh大家习惯性的要去看那个PR是吧
大家习惯性的要去看那个PR是吧
4:45.500–4:47.620
zh看PR里面的这个commit
看PR里面的这个commit
4:47.620–4:49.540
zhDiff里面到底给了哪些文件
Diff里面到底给了哪些文件
4:49.540–4:50.680
zh然后看一下有没有漏洞
然后看一下有没有漏洞
4:50.680–4:51.680
zh然后有问题的话
然后有问题的话
4:51.680–4:53.100
zh还得上面标注一下
还得上面标注一下
4:53.100–4:54.400
zh以前的话
以前的话
4:54.400–4:56.560
zh这个需要耗费大量的这个人工成本
这个需要耗费大量的这个人工成本
4:56.560–4:58.360
zh专门需要一个代码审查
专门需要一个代码审查
4:58.360–5:00.520
zh那现在有了Codex之后的话
那现在有了Codex之后的话
5:00.520–5:01.800
zh我们做代码审查的话
我们做代码审查的话
5:01.800–5:02.840
zh其实会非常简单
其实会非常简单
5:02.840–5:04.400
zh就是这个里面的话
就是这个里面的话
5:04.400–5:05.640
zh他会去分析
他会去分析
5:05.640–5:09.360
zh他有专门的review的这么一个斜杠命令
他有专门的review的这么一个斜杠命令
5:09.360–5:11.680
zh这个我们等一下会给大家讲这么一个案例
这个我们等一下会给大家讲这么一个案例
5:11.680–5:14.700
zh就是我们可以用review的一个命令
就是我们可以用review的一个命令
5:14.700–5:16.680
zh去快速的去分析本次
去快速的去分析本次
5:16.680–5:18.920
zh比如说我还没有提交的一些代码
比如说我还没有提交的一些代码
5:18.920–5:19.920
zh我想让他分析一下
我想让他分析一下
5:19.920–5:21.760
zh或者说我们已经提交的PR
或者说我们已经提交的PR
5:21.760–5:23.560
zh这个代码有没有问题
这个代码有没有问题
5:23.560–5:26.180
zh也可以分析出来
也可以分析出来
5:26.180–5:27.700
zh让我们根据这个结果
让我们根据这个结果
5:27.700–5:29.400
zh最后去把这个代码
最后去把这个代码
5:29.400–5:31.480
zh就是给提一些建议
就是给提一些建议
5:31.480–5:33.780
zh或者给他拒绝这个PR合并
或者给他拒绝这个PR合并
5:33.780–5:34.140
zh是吧
是吧
5:34.140–5:35.860
zh这个就是我们做代码审查
这个就是我们做代码审查
5:35.860–5:37.560
zh可以结合Codex做的一些事情
可以结合Codex做的一些事情
5:37.560–5:38.660
zh然后的话
然后的话
5:38.660–5:40.680
zh大家还可以通过Codex去
大家还可以通过Codex去
5:40.680–5:42.740
zh排查一些线上的一些问题
排查一些线上的一些问题
5:42.740–5:43.100
zh是吧
是吧
5:43.100–5:44.400
zh比如我们线上发现一些bug
比如我们线上发现一些bug
5:44.400–5:45.400
zh有一些日志
有一些日志
5:45.400–5:47.100
zh他定位了一些代码行
他定位了一些代码行
5:47.100–5:49.100
zh那我们把这些日志提供给Codex
那我们把这些日志提供给Codex
5:49.100–5:49.900
zh那Codex的话
那Codex的话
5:49.900–5:51.920
zh可以快速的去帮我们找到
可以快速的去帮我们找到
5:51.920–5:53.400
zh这个代码到底哪里出问题了
这个代码到底哪里出问题了
5:53.400–5:55.500
zh并针对性的给一些修复方案出来
并针对性的给一些修复方案出来
5:55.500–5:57.000
zh所以这个也是一个
所以这个也是一个
5:57.000–5:59.360
zh比较好的一个应用方向
比较好的一个应用方向
5:59.360–6:01.420
zh然后最后一个的话
然后最后一个的话
6:01.420–6:03.340
zh就是自动化开发任务啊
就是自动化开发任务啊
6:03.340–6:05.220
zh那这一块也是用的比较多的一个场景
那这一块也是用的比较多的一个场景
6:05.220–6:07.920
zh那就是说我们可以通过Codex啊
那就是说我们可以通过Codex啊
6:07.920–6:10.540
zh就是从零到一去做一个项目的一个开发
就是从零到一去做一个项目的一个开发
6:10.540–6:11.720
zh那我们等一下的话
那我们等一下的话
6:11.720–6:13.460
zh也会带大家去基于这个流程
也会带大家去基于这个流程
6:13.460–6:14.800
zh去做一个项目啊
去做一个项目啊
6:14.800–6:16.120
zh就是从需求分析开始
就是从需求分析开始
6:16.120–6:20.400
zh到整个的一个项目的一个功能拆解啊
到整个的一个项目的一个功能拆解啊
6:20.400–6:20.740
zh是吧
是吧
6:20.740–6:22.020
zh核心功能开发呀
核心功能开发呀
6:22.020–6:23.180
zh包括测试啊
包括测试啊
6:23.180–6:25.480
zh包括整个的一个啊
包括整个的一个啊
6:25.480–6:26.240
zh调试啊
调试啊
6:26.240–6:26.500
zh是吧
是吧
6:26.500–6:31.100
zh这个我们等一下都会给大家去走一遍啊
这个我们等一下都会给大家去走一遍啊
6:31.100–6:32.600
zh所以这几个场景的话
所以这几个场景的话
6:32.600–6:33.800
zh都是Codex
都是Codex
6:33.800–6:36.340
zh它比较擅长
它比较擅长
6:36.340–6:38.580
zh或者说比较主流的一些应用场景
或者说比较主流的一些应用场景
6:38.580–6:40.060
zh那么Codex
那么Codex
6:40.060–6:42.260
zh它的一个核心能力有哪些呢
它的一个核心能力有哪些呢
6:42.260–6:45.160
zh大家要比较好的去使用Codex的话
大家要比较好的去使用Codex的话
6:45.160–6:47.260
zh首先要对它的一个核心能力
首先要对它的一个核心能力
6:47.260–6:49.420
zh或者说对它整个的一个功能架构的话
或者说对它整个的一个功能架构的话
6:49.420–6:51.000
zh有一个认知
有一个认知
6:51.000–6:52.520
zh就是要有一个大的认知
就是要有一个大的认知
6:52.520–6:53.040
zh这样的话
这样的话
6:53.040–6:55.260
zh你在去做一些开发的时候
你在去做一些开发的时候
6:55.260–6:55.900
zh你就会想到
你就会想到
6:55.900–6:58.120
zh原来Codex已经集成这个能力了
原来Codex已经集成这个能力了
6:58.120–7:00.480
zh那大家去直接把它去应用到
那大家去直接把它去应用到
7:00.480–7:01.700
zh工作当中去的话
工作当中去的话
7:01.700–7:03.360
zh那这个提效就很明显了
那这个提效就很明显了
7:03.360–7:04.640
zh那大家可以看一下
那大家可以看一下
7:04.640–7:05.860
zh整个的一个
整个的一个
7:05.860–7:07.320
zh它的一个能力
它的一个能力
7:07.320–7:09.880
zh那能力的话是非常多了
那能力的话是非常多了
7:09.880–7:11.100
zh最主要的话
最主要的话
7:11.100–7:13.080
zh就是它的一个多任务处理
就是它的一个多任务处理
7:13.080–7:14.240
zh就是多线程
就是多线程
7:14.240–7:16.480
zh大家在用这个Codex过程中
大家在用这个Codex过程中
7:16.480–7:17.840
zh你会发现一个点
你会发现一个点
7:17.840–7:19.300
zh就是整个
就是整个
7:19.300–7:21.440
zh它是基于多线程的一个机制
它是基于多线程的一个机制
7:21.440–7:22.960
zh就是你不断的跟它去对话
就是你不断的跟它去对话
7:22.960–7:24.940
zh它会不断的去起
它会不断的去起
7:24.940–7:25.860
zh各种各样的线程
各种各样的线程
7:25.860–7:26.860
zh帮你去完成任务
帮你去完成任务
7:26.860–7:28.640
zh并且最终做一个合并
并且最终做一个合并
7:28.640–7:31.240
zh所以它的一个跨项目的
所以它的一个跨项目的
7:31.240–7:32.900
zh多任务处理能力非常强
多任务处理能力非常强
7:32.900–7:36.560
zh就是你可以让它同时去开发三个项目
就是你可以让它同时去开发三个项目
7:36.560–7:37.940
zh开三个这个线程
开三个这个线程
7:37.940–7:38.500
zh是吧
是吧
7:38.500–7:39.240
zh然后最终
然后最终
7:39.240–7:42.820
zh比如说我们想让它分析三个项目的一个细节
比如说我们想让它分析三个项目的一个细节
7:42.820–7:45.384
zh然后分析完之后做一个总结归纳
然后分析完之后做一个总结归纳
7:45.384–7:47.184
zh最后给你输出一张表格。
最后给你输出一张表格。
7:47.184–7:48.884
zh那他就是启动三个线程。
那他就是启动三个线程。
7:48.884–7:52.984
zh即使是跨多项目的话,他也可以用多任务的方式去处理。
即使是跨多项目的话,他也可以用多任务的方式去处理。
7:52.984–7:55.084
zh这是他的一个非常强大的一个能力。
这是他的一个非常强大的一个能力。
7:55.084–7:59.684
zh然后的话,他里面内置了一个叫Git WorkTree的一个这么一个机制。
然后的话,他里面内置了一个叫Git WorkTree的一个这么一个机制。
7:59.684–8:01.444
zh它的一个优点是什么
它的一个优点是什么
8:01.444–8:03.344
zh就是我们可以在一个分支下面
就是我们可以在一个分支下面
8:03.344–8:06.044
zh可以支持加多个这个work tree
可以支持加多个这个work tree
8:06.044–8:07.424
zh然后去并行开发
然后去并行开发
8:07.424–8:09.384
zh以前的话我们开发的话
以前的话我们开发的话
8:09.384–8:11.624
zh就是都要做分支隔离的是吧
就是都要做分支隔离的是吧
8:11.624–8:15.864
zh比如说某某同学是做这个A分支
比如说某某同学是做这个A分支
8:15.864–8:17.044
zh某某同学是B分支
某某同学是B分支
8:17.044–8:18.724
zh他们两个分支功能
他们两个分支功能
8:18.724–8:20.244
zh如果要做并行开发的话
如果要做并行开发的话
8:20.244–8:22.564
zh那得把他们两个分支给它合并了
那得把他们两个分支给它合并了
8:22.564–8:22.844
zh是吧
是吧
8:22.844–8:24.904
zh这样的功能才能整合到一起
这样的功能才能整合到一起
8:24.904–8:27.824
zh现在有了这个 git worktree 的之后的话
现在有了这个 git worktree 的之后的话
8:27.824–8:29.924
zhCodex整合了这个之后的话
Codex整合了这个之后的话
8:29.924–8:31.684
zh我们可以直接在一个分支里面
我们可以直接在一个分支里面
8:31.684–8:33.564
zh加多个worktree的方式做并行开发
加多个worktree的方式做并行开发
8:33.564–8:35.764
zh并且的话代码它是相互隔离的
并且的话代码它是相互隔离的
8:35.764–8:38.224
zh这样的话就达到了我不想见多分支
这样的话就达到了我不想见多分支
8:38.224–8:40.664
zh也能实现多人协作的这么一个目标
也能实现多人协作的这么一个目标
8:40.664–8:42.344
zh这是一个比较好的一个点
这是一个比较好的一个点
8:42.344–8:43.824
zh然后的话就是
然后的话就是
8:43.824–8:46.724
zh我们可以通过这个Codex
我们可以通过这个Codex
8:46.724–8:48.024
zh做一个远程连接啊
做一个远程连接啊
8:48.024–8:52.024
zh就是它可以去专门连接到一个这个
就是它可以去专门连接到一个这个
8:52.024–8:53.964
zh不同的这个
不同的这个
8:53.964–8:55.544
zh比如说我们手机端是吧
比如说我们手机端是吧
8:55.544–8:57.164
zh我们手机端去远程连接
我们手机端去远程连接
8:57.164–8:59.644
zh这个我们在手机端上面远程操控
这个我们在手机端上面远程操控
8:59.644–9:01.464
zh我们电脑端的这么一个Codex
我们电脑端的这么一个Codex
9:01.464–9:02.184
zh让它去干活
让它去干活
9:02.184–9:04.964
zh这个也是一个好的一个功能
这个也是一个好的一个功能
9:04.964–9:06.844
zh这个就像那个小龙虾是吧
这个就像那个小龙虾是吧
9:06.844–9:07.504
zh养虾一样
养虾一样
9:07.504–9:09.484
zh我可以远程指挥它去干活
我可以远程指挥它去干活
9:09.484–9:10.764
zh并且的话
并且的话
9:10.764–9:13.904
zh我们可以在这个Codex上面操作一些应用
我们可以在这个Codex上面操作一些应用
9:13.904–9:15.504
zh比如说在iOS上面
比如说在iOS上面
9:15.504–9:17.824
zh去调用一些这个
去调用一些这个
9:17.824–9:19.344
zh在MacOS上面
在MacOS上面
9:19.344–9:21.084
zh就是我们的这个苹果系统上面
就是我们的这个苹果系统上面
9:21.084–9:22.864
zh它可以去调用各种的应用
它可以去调用各种的应用
9:22.864–9:24.024
zh执行一些任务
执行一些任务
9:24.024–9:25.584
zh包括一些操作浏览器
包括一些操作浏览器
9:25.584–9:26.864
zh当然都是支持的
当然都是支持的
9:26.864–9:29.364
zh并且的话它可以支持应用截图识别图片
并且的话它可以支持应用截图识别图片
9:29.364–9:31.664
zh然后做一些评审交付
然后做一些评审交付
9:31.664–9:33.944
zh执行终端的一些命令
执行终端的一些命令
9:33.944–9:35.384
zh然后操作浏览器
然后操作浏览器
9:35.384–9:37.744
zh包括它还可以去添加一些Chrome插件
包括它还可以去添加一些Chrome插件
9:37.744–9:42.204
zh让Codex帮你去管理整个我们的这个浏览器
让Codex帮你去管理整个我们的这个浏览器
9:42.204–9:42.524
zh是吧
是吧
9:42.524–9:44.464
zh然后做一些浏览器的一些任务
然后做一些浏览器的一些任务
9:44.464–9:47.284
zh并且的话它可以去生成一些图片
并且的话它可以去生成一些图片
9:47.284–9:48.024
zh编辑图片
编辑图片
9:48.024–9:49.564
zh因为OpenAI的话
因为OpenAI的话
9:49.564–9:52.804
zh它本身就有一些这个图片的一些模型
它本身就有一些这个图片的一些模型
9:52.804–9:54.044
zh多模态模型
多模态模型
9:54.044–9:55.584
zh比如说像 DALL-E 3
比如说像 DALL-E 3
9:55.584–9:56.844
zh然后image2
然后image2
9:56.844–9:58.104
zh就是有它有生成
就是有它有生成
9:58.104–9:59.404
zh专门生成图片的模型
专门生成图片的模型
9:59.404–10:00.704
zh所以说它本身
所以说它本身
10:00.704–10:02.264
zh也可以去编辑图片
也可以去编辑图片
10:02.264–10:03.404
zh这样的话
这样的话
10:03.404–10:04.104
zh我们相当于
我们相当于
10:04.104–10:05.824
zh你可以把codex当做
你可以把codex当做
10:05.824–10:07.904
zh这个AI绘画工具来用
这个AI绘画工具来用
10:07.904–10:09.164
zh这个也是可以的
这个也是可以的
10:09.164–10:10.584
zh包括我们还可以做一些
包括我们还可以做一些
10:10.584–10:11.624
zh这个自动化
这个自动化
10:11.624–10:13.564
zh就是一些这个任务
就是一些这个任务
10:13.564–10:14.004
zh是吧
是吧
10:14.004–10:16.504
zh你做了一些这个操作之后
你做了一些这个操作之后
10:16.504–10:17.624
zh你可以让它全自动的
你可以让它全自动的
10:17.624–10:18.764
zh去调用各种各样的工具
去调用各种各样的工具
10:18.764–10:19.744
zh帮你去完成一个
帮你去完成一个
10:19.744–10:20.824
zh大的一个任务
大的一个任务
10:20.824–10:21.824
zh就全自动的
就全自动的
10:21.824–10:23.164
zh然后的话
然后的话
10:23.164–10:25.124
zh就是我们还可以在codex上面
就是我们还可以在codex上面
10:25.124–10:26.384
zh去搭建一些技能
去搭建一些技能
10:26.384–10:27.164
zh这个我们等一下
这个我们等一下
10:27.164–10:27.984
zh也会给大家讲
也会给大家讲
10:27.984–10:29.024
zh就是怎么从零到一
就是怎么从零到一
10:29.024–10:30.024
zh去搭建一个技能
去搭建一个技能
10:30.024–10:31.424
zh做真正企业级的
做真正企业级的
10:31.424–10:32.384
zh一个 skill 开发
一个 skill 开发
10:32.384–10:34.004
zh然后怎么去使用它
然后怎么去使用它
10:34.004–10:35.904
zh然后包括一些这个
然后包括一些这个
10:35.904–10:37.944
zh一些什么侧边栏
一些什么侧边栏
10:37.944–10:39.084
zh与 artifact
与 artifact
10:39.084–10:40.484
zh这个是它的一些
这个是它的一些
10:40.484–10:42.484
zh跟踪计划来源
跟踪计划来源
10:42.484–10:43.364
zh任务摘要和
任务摘要和
10:43.364–10:45.024
zh生成文件预览的一些功能
生成文件预览的一些功能
10:45.024–10:45.764
zh这个都是它
这个都是它
10:45.764–10:47.124
zh比较实用的一些功能
比较实用的一些功能
10:47.124–10:47.964
zh还有包括它
还有包括它
10:47.964–10:49.804
zh比较强大的一个插件系统
比较强大的一个插件系统
10:49.804–10:50.564
zh这个我们等一下
这个我们等一下
10:50.564–10:51.284
zh也会给大家讲
也会给大家讲
10:51.284–10:52.644
zh这个插件功能的话
这个插件功能的话
10:52.644–10:53.644
zh其实也非常强大
其实也非常强大
10:53.644–10:57.444
zh它可以极大程度的去拓展Codex
它可以极大程度的去拓展Codex
10:57.444–10:58.524
zh能做的一些事情
能做的一些事情
10:58.524–10:59.304
zh让它可以
让它可以
10:59.304–11:01.524
zh比如说甚至去生生视频也是可以的
比如说甚至去生生视频也是可以的
11:01.524–11:02.504
zh并且的话
并且的话
11:02.504–11:04.024
zh它可以与我们的这个IDE
它可以与我们的这个IDE
11:04.024–11:04.884
zh比如说与 Cursor
比如说与 Cursor
11:04.884–11:06.424
zh或者是用 VS Code
或者是用 VS Code
11:06.424–11:07.644
zh整个做一个同步
整个做一个同步
11:07.644–11:09.784
zh这个就是它的一个核心能力
这个就是它的一个核心能力
11:09.784–11:11.164
zh那么大家有了一个
那么大家有了一个
11:11.164–11:13.224
zh全方位的这个认知之后的话
全方位的这个认知之后的话
11:13.224–11:14.764
zh后面你在用Codex的时候
后面你在用Codex的时候
11:14.764–11:16.424
zh你可以把这一点给考虑进去
你可以把这一点给考虑进去
11:16.424–11:18.704
zh如果说 Codex 里面已经集成这个功能的话
如果说 Codex 里面已经集成这个功能的话
11:18.704–11:21.424
zh那你可以完全把它做一个整合
那你可以完全把它做一个整合
11:21.424–11:23.444
zh就大家可以可以把各种各样的功能
就大家可以可以把各种各样的功能
11:23.444–11:25.964
zh整合在一起搭配去使用
整合在一起搭配去使用
11:25.964–11:28.944
zh大家就是不要单独的去看待这个功能
大家就是不要单独的去看待这个功能
11:28.944–11:30.384
zh你一定要把它做一个什么呢
你一定要把它做一个什么呢
11:30.384–11:32.064
zh就是整合
就是整合
11:32.064–11:33.984
zh就是我们把一个工作流
就是我们把一个工作流
11:33.984–11:35.984
zh你把整个串起来
你把整个串起来
11:35.984–11:37.224
zh那它就可以做很多事情
那它就可以做很多事情
11:37.224–11:39.904
zh如果你只是聚焦它在单个功能上面的话
如果你只是聚焦它在单个功能上面的话
11:39.904–11:42.224
zh它可能做的功能的话就比较单一
它可能做的功能的话就比较单一
11:42.224–11:44.024
zh所以大家要有一个全局的思维
所以大家要有一个全局的思维
11:44.024–11:45.364
enOK
OK
11:45.364–11:49.564
zh然后是Codex它的一个工程化设计思想
然后是Codex它的一个工程化设计思想
11:49.564–11:52.244
zh那么这个设计思想有什么用呢
那么这个设计思想有什么用呢
11:52.244–11:55.064
zh那么Codex的话
那么Codex的话
11:55.064–11:56.584
zh跟我们以前的这个
跟我们以前的这个
11:56.584–11:58.764
zhAI编程助手的话
AI编程助手的话
11:58.764–12:00.784
zh还是有一些不一样的地方
还是有一些不一样的地方
12:00.784–12:03.244
zh因为它毕竟是OpenAI出的
因为它毕竟是OpenAI出的
12:03.244–12:05.144
zh它的一些设计思想的话
它的一些设计思想的话
12:05.144–12:06.704
zh跟这个 Cursor
跟这个 Cursor
12:06.704–12:08.044
zh或者是 VS Code
或者是 VS Code
12:08.044–12:11.564
zh它们整合这个AI工具
它们整合这个AI工具
12:11.564–12:13.144
zh稍微有一点不一样
稍微有一点不一样
12:13.144–12:15.544
zh那么它已经从一个
那么它已经从一个
12:15.544–12:17.544
zh简单的这个AI编码助手
简单的这个AI编码助手
12:17.544–12:19.004
zh已经进化成一个叫做
已经进化成一个叫做
12:19.004–12:20.744
zh全栈开发的一个伙伴了
全栈开发的一个伙伴了
12:20.744–12:21.924
zh为什么这么说呢
为什么这么说呢
12:21.924–12:23.384
zh主要有以下几个基点
主要有以下几个基点
12:23.384–12:26.984
zh首先的话是规范工程取代了提示词工程
首先的话是规范工程取代了提示词工程
12:26.984–12:29.764
zh以前的话大家是吧
以前的话大家是吧
12:29.764–12:31.804
zh你做一个项目的话习惯性的
你做一个项目的话习惯性的
12:31.804–12:33.924
zh你要把提示词给写好是吧
你要把提示词给写好是吧
12:33.924–12:37.464
zh那么Codex里面他已经在提供一个
那么Codex里面他已经在提供一个
12:37.464–12:39.284
zh就是在强调一个点啊
就是在强调一个点啊
12:39.284–12:40.624
zh叫做规范化编程
叫做规范化编程
12:40.624–12:43.184
zh就是目前业界有一个非常
就是目前业界有一个非常
12:43.184–12:44.864
zh这个主流的一个词啊
这个主流的一个词啊
12:44.864–12:46.524
zh叫做这个 SDD 是吧
叫做这个 SDD 是吧
12:46.524–12:48.564
zh就是叫规范编程开发
就是叫规范编程开发
12:48.564–12:51.284
zh就是以规范去驱动
就是以规范去驱动
12:51.284–12:52.384
zh我们整个的一个逻辑
我们整个的一个逻辑
12:52.384–12:53.864
zh也就是说他先要
也就是说他先要
12:53.864–12:55.204
zh你把这个规范写好
你把这个规范写好
12:55.204–12:56.704
zh比如说去写 agents.md
比如说去写 agents.md
12:56.704–12:57.784
zh写 rules
写 rules
12:57.784–12:59.244
zh整个这个规范给他写好
整个这个规范给他写好
12:59.244–13:00.104
zh写好完之后
写好完之后
13:00.104–13:01.724
zh然后再去用AI生成代码
然后再去用AI生成代码
13:01.724–13:02.524
zh这样的话
这样的话
13:02.524–13:04.124
zh他的质量会非常高
他的质量会非常高
13:04.124–13:05.584
zh所以以前的话
所以以前的话
13:05.584–13:07.944
zh大家没有注意规范的时候
大家没有注意规范的时候
13:07.944–13:10.324
zh那你去用自然语言
那你去用自然语言
13:10.324–13:12.384
zh给他去表达的时候
给他去表达的时候
13:12.384–13:14.084
zh那就会出现一个问题
那就会出现一个问题
13:14.084–13:16.004
zh就是这个东西的一个边界
就是这个东西的一个边界
13:16.004–13:16.784
zh就会有问题
就会有问题
13:16.784–13:19.244
zh就是你采用一个结构化的一个输入
就是你采用一个结构化的一个输入
13:19.244–13:21.824
zh整个它就会非常清晰
整个它就会非常清晰
13:21.824–13:24.104
zh就是有规则跟没规则的区别
就是有规则跟没规则的区别
13:24.104–13:24.704
zh就是在于
就是在于
13:24.704–13:27.524
zh它可以有一个目标
它可以有一个目标
13:27.524–13:30.844
zh加边界加验收标准的一个结构
加边界加验收标准的一个结构
13:30.844–13:32.684
zh这个就相当于我们
这个就相当于我们
13:32.684–13:34.384
zh大家实际在工作当中
大家实际在工作当中
13:34.384–13:35.724
zh你去做一个事情的时候
你去做一个事情的时候
13:35.724–13:37.184
zh它有没有一个什么呢
它有没有一个什么呢
13:37.184–13:38.264
zh就是规范
就是规范
13:38.264–13:40.364
zh就是有没有自己的一个标准
就是有没有自己的一个标准
13:40.364–13:42.204
zh如果你没有标准的话
如果你没有标准的话
13:42.204–13:44.264
zh你做一个事情的话
你做一个事情的话
13:44.264–13:45.964
zh就会出现各种各样的一个问题
就会出现各种各样的一个问题
13:45.964–13:48.304
zh就是有标准的好处
就是有标准的好处
13:48.304–13:50.304
zh就是它可以保质保量的去验收
就是它可以保质保量的去验收
13:50.304–13:53.464
zh就是达到这么一个效果
就是达到这么一个效果
13:53.464–13:56.964
zh所以说Codex已经在强调
所以说Codex已经在强调
13:56.964–13:59.224
zh这个规范化的一个编程方式
这个规范化的一个编程方式
13:59.224–14:00.624
zh就是用 Agent MD
就是用 Agent MD
14:00.624–14:02.144
zh整个的一套
整个的一套
14:02.144–14:03.224
zh包括这个Harness
包括这个Harness
14:03.224–14:04.524
zh这个Codex
这个Codex
14:04.524–14:06.444
zh前一段时间也发了一篇文章
前一段时间也发了一篇文章
14:06.444–14:06.764
zh是吧
是吧
14:06.764–14:08.444
zh就关于这个 Harness Engineering
就关于这个 Harness Engineering
14:08.444–14:09.724
zh它整个的话
它整个的话
14:09.724–14:12.444
zh目前就是采用了这个整个一套Harness
目前就是采用了这个整个一套Harness
14:12.444–14:13.804
zh去做一个落地的
去做一个落地的
14:13.804–14:16.084
zh包括他自己内部
包括他自己内部
14:16.084–14:19.464
zhOpenAI内部也是基于这个Harness
OpenAI内部也是基于这个Harness
14:19.464–14:23.324
zh去做了整个的一个项目的一个落地的
去做了整个的一个项目的一个落地的
14:23.324–14:26.104
zh之前他们有一篇文章里面提到了
之前他们有一篇文章里面提到了
14:26.104–14:28.164
zh就是三个人
就是三个人
14:28.164–14:30.084
zh一百多万行代码
一百多万行代码
14:30.084–14:32.184
zh全部都是AI生成的
全部都是AI生成的
14:32.184–14:34.564
zh就是用Harness Engineering去做的一个落地
就是用Harness Engineering去做的一个落地
14:34.564–14:36.764
zh就是人工
就是人工
14:36.764–14:38.144
zh我们只限定规范
我们只限定规范
14:38.144–14:39.824
zh把标准写好
把标准写好
14:39.824–14:40.784
zh把目标定好
把目标定好
14:40.784–14:43.264
zh所有的代码都是AI生成的
所有的代码都是AI生成的
14:43.264–14:45.304
zh人工不需要写一行代码啊
人工不需要写一行代码啊
14:45.304–14:46.684
zh真的是一行代码都不需要写
真的是一行代码都不需要写
14:46.684–14:49.464
zh他就是能把一个大型的项目给搞定
他就是能把一个大型的项目给搞定
14:49.464–14:51.144
zh大概是花了啊
大概是花了啊
14:51.144–14:52.164
zh我记得是五到六个月
我记得是五到六个月
14:52.164–14:53.584
zh然后给他上线了啊
然后给他上线了啊
14:53.584–14:56.364
zh一个一百万多行的这个一个项目啊
一个一百万多行的这个一个项目啊
14:56.364–14:57.464
zh就是这么简单
就是这么简单
14:57.464–14:58.384
zh所以说啊
所以说啊
14:58.384–14:59.704
zh目前啊
目前啊
14:59.704–15:03.484
zhCodex已经在深入的去落地这个Harness Engineering
Codex已经在深入的去落地这个Harness Engineering
15:03.484–15:07.084
zh所以他对规范的要求是非常严格的啊
所以他对规范的要求是非常严格的啊
15:07.084–15:08.664
zh大家等一下啊
大家等一下啊
15:08.664–15:09.684
zh我们在讲解过程中
我们在讲解过程中
15:09.684–15:12.124
zh大家就会感受到他整个这个逻辑啊
大家就会感受到他整个这个逻辑啊
15:12.124–15:14.244
zh就是会变得非常规范化
就是会变得非常规范化
15:14.244–15:16.164
zh然后第二块就是
然后第二块就是
15:16.164–15:18.224
zh他在这个意图拆解
他在这个意图拆解
15:18.224–15:19.164
zh与agent loop
与agent loop
15:19.164–15:20.904
zh我们叫任务循环这一块的话
我们叫任务循环这一块的话
15:20.904–15:22.244
zh也会强调的比较多
也会强调的比较多
15:22.244–15:23.744
zh因为Codex已经
因为Codex已经
15:23.744–15:26.644
zh不是单单的给你去生成一个代码了
不是单单的给你去生成一个代码了
15:26.644–15:29.484
zh他是通过agent循环机制
他是通过agent循环机制
15:29.484–15:31.524
zh去模拟人类工程师的一个开发过程
去模拟人类工程师的一个开发过程
15:31.524–15:32.644
zh什么意思呢
什么意思呢
15:32.644–15:34.824
zh就是人是怎么干活的
就是人是怎么干活的
15:34.824–15:36.464
zh他就是怎么干活的
他就是怎么干活的
15:36.464–15:38.844
zh就以前AI就给你写个代码就完事了
就以前AI就给你写个代码就完事了
15:38.844–15:41.104
zh他也不管你能不能运行
他也不管你能不能运行
15:41.104–15:41.604
zh啊
啊
15:41.604–15:55.305
zh除非你
除非你
15:55.305–15:57.485
zh相当于他计划帮你做好了
相当于他计划帮你做好了
15:57.485–15:58.885
zh执行模式也帮你做好了
执行模式也帮你做好了
15:58.885–16:01.705
zh最后你看到的结果就是没有问题的
最后你看到的结果就是没有问题的
16:01.705–16:02.765
zh就是可以跑的
就是可以跑的
16:02.765–16:04.265
zh所以大家现在会发现
所以大家现在会发现
16:04.265–16:07.945
zh就是今年这些个AI编程工具的话
就是今年这些个AI编程工具的话
16:07.945–16:09.225
zh它的进步非常大
它的进步非常大
16:09.225–16:11.785
zh就是在Agent这一块做了非常大的一个改进
就是在Agent这一块做了非常大的一个改进
16:11.785–16:14.785
zh那大家会发现目前像Claude Code
那大家会发现目前像Claude Code
16:14.785–16:18.085
zh或者其他的一些像这个Claude
或者其他的一些像这个Claude
16:18.085–16:19.525
zh这个Codex
这个Codex
16:19.525–16:22.765
zh或者像这个其他的一些编程工具
或者像这个其他的一些编程工具
16:22.765–16:23.685
zh大家会发现
大家会发现
16:23.685–16:25.745
zh它的一个质量明显就上去了
它的一个质量明显就上去了
16:25.745–16:27.925
zh就是它写出来代码直接就可以用了
就是它写出来代码直接就可以用了
16:27.925–16:30.545
zh基本上没什么太明显的一个问题
基本上没什么太明显的一个问题
16:30.545–16:34.225
zh所以说它内置的一个任务循环
所以说它内置的一个任务循环
16:34.225–16:37.405
zh就保证了我们整个的一些什么呢
就保证了我们整个的一些什么呢
16:37.405–16:39.165
zh一些bug一些安全性问题
一些bug一些安全性问题
16:39.165–16:40.325
zh它就帮你去避免了
它就帮你去避免了
16:40.325–16:42.925
zh因为它会按照我们人类的一个思维
因为它会按照我们人类的一个思维
16:42.925–16:44.725
zh首先会做一个plan计划
首先会做一个plan计划
16:44.725–16:47.825
zh干活之前先把计划给你写清楚
干活之前先把计划给你写清楚
16:47.825–16:49.145
zh写清楚之后的话
写清楚之后的话
16:49.145–16:51.865
zh一步步的按照计划的一个目标
一步步的按照计划的一个目标
16:51.865–16:53.725
zh再去确认
再去确认
16:53.725–16:55.385
zh然后再去编码
然后再去编码
16:55.385–16:56.985
zh而不是说
而不是说
16:56.985–16:58.665
zh跑到最后发现一堆问题
跑到最后发现一堆问题
16:58.665–17:01.165
zh所以说他是先确认
所以说他是先确认
17:01.165–17:04.005
zh由我们这个工程师自己去确认
由我们这个工程师自己去确认
17:04.005–17:05.465
zh因为他有一些授权模式
因为他有一些授权模式
17:05.465–17:06.685
zh有确认模式
有确认模式
17:06.685–17:09.165
zh也有全托管的这种模式
也有全托管的这种模式
17:09.165–17:11.665
zh所以他会有一个确认过程
所以他会有一个确认过程
17:11.665–17:13.125
zh当我们确认没问题之后
当我们确认没问题之后
17:13.125–17:14.445
zh他再去执行的时候
他再去执行的时候
17:14.445–17:16.005
zh这时候大家会发现
这时候大家会发现
17:16.005–17:17.825
zh他去执行任务的时候
他去执行任务的时候
17:17.825–17:19.085
zh他会拆得更细
他会拆得更细
17:19.085–17:21.565
zh就是agent这一块的话
就是agent这一块的话
17:21.565–17:23.245
zh它会做一个大量的一个拆分
它会做一个大量的一个拆分
17:23.245–17:25.945
zh犀利到每一个函数
犀利到每一个函数
17:25.945–17:27.165
zh每一个模块的一个编写
每一个模块的一个编写
17:27.165–17:28.125
zh然后的话
然后的话
17:28.125–17:30.445
zh它会有一个非常严格的审查模式
它会有一个非常严格的审查模式
17:30.445–17:32.405
zh它会根据集合上下文去分析
它会根据集合上下文去分析
17:32.405–17:33.645
zh潜在的一些bug
潜在的一些bug
17:33.645–17:35.085
zh包括一些安全性问题
包括一些安全性问题
17:35.085–17:37.185
zh或者一些性能瓶颈等等的
或者一些性能瓶颈等等的
17:37.185–17:38.965
zh它都会帮你分析的非常透彻
它都会帮你分析的非常透彻
17:38.965–17:41.765
zh所以大家看到Codex
所以大家看到Codex
17:41.765–17:42.865
zh帮你升任代码之后
帮你升任代码之后
17:42.865–17:44.725
zh基本上这个代码就没什么问题了
基本上这个代码就没什么问题了
17:44.725–17:45.205
zh可以用了
可以用了
17:45.205–17:47.325
zh因为它内部帮你把这个几个模式
因为它内部帮你把这个几个模式
17:47.325–17:47.925
zh已经跑完了
已经跑完了
17:47.925–17:50.505
zh所以说你看到的东西都是高质量
所以说你看到的东西都是高质量
17:50.505–17:51.745
zh这也是为什么
这也是为什么
17:51.745–17:53.565
zh这个Agent Loan
这个Agent Loan
17:53.565–17:55.965
zh它是一个非常关键的一个点
它是一个非常关键的一个点
17:55.965–17:58.385
zh就它做了比较大的一个改进
就它做了比较大的一个改进
17:58.385–18:00.365
zh然后是上下文工程
然后是上下文工程
18:00.365–18:03.745
zh就Codex在工程架构这一块
就Codex在工程架构这一块
18:03.745–18:05.525
zh对于上下文管理这一块
对于上下文管理这一块
18:05.525–18:07.405
zh做了非常大的一个优化
做了非常大的一个优化
18:07.405–18:08.405
zh首先的话
首先的话
18:08.405–18:10.605
zh它会做一些精简的一个线段检索
它会做一些精简的一个线段检索
18:10.605–18:13.265
zh它会对整个代码库进行予以切分
它会对整个代码库进行予以切分
18:13.265–18:15.085
zh指向模型去注入
指向模型去注入
18:15.085–18:16.165
zh与当前任务
与当前任务
18:16.165–18:17.785
zh与特定文件相关依赖
与特定文件相关依赖
18:17.785–18:18.885
zh也就是说
也就是说
18:18.885–18:20.965
zh我们去问一个问题的时候
我们去问一个问题的时候
18:20.965–18:22.785
zh他不是把整个都给你加载了
他不是把整个都给你加载了
18:22.785–18:23.525
zh不是这个意思
不是这个意思
18:23.525–18:26.045
zh他是做一个什么叫做索引
他是做一个什么叫做索引
18:26.045–18:28.245
zh就是你问的这个问题
就是你问的这个问题
18:28.245–18:30.825
zh相关的一些代码片段
相关的一些代码片段
18:30.825–18:33.205
zh还有包括一些元数据
还有包括一些元数据
18:33.205–18:34.425
zh比如说一些markdown是吧
比如说一些markdown是吧
18:34.425–18:35.705
zh有关系的时候
有关系的时候
18:35.705–18:38.045
zh再去做一个检索
再去做一个检索
18:38.045–18:39.465
zh做一些这个处理
做一些这个处理
18:39.465–18:40.685
zh而不是说一上来
而不是说一上来
18:40.685–18:42.645
zh就把整个项目给他拉上去了
就把整个项目给他拉上去了
18:42.645–18:45.265
zh那这个很容易出现一些上下文
那这个很容易出现一些上下文
18:45.265–18:46.945
zh超过限制的问题是吧
超过限制的问题是吧
18:46.945–18:47.765
zh所以说这一块
所以说这一块
18:47.765–18:49.905
zh他对于这个整个线的检索
他对于这个整个线的检索
18:49.905–18:50.825
zh做了一个精简
做了一个精简
18:50.825–18:52.605
zh然后是 AST
然后是 AST
18:52.605–18:54.845
zh这个叫抽象语法树感知
这个叫抽象语法树感知
18:54.845–18:57.925
zh他会结合代码的一个数状结构
他会结合代码的一个数状结构
18:57.925–19:00.745
zh去理解他的一个依赖引用
去理解他的一个依赖引用
19:00.745–19:03.765
zh也就是说代码跟代码之间的一个关系的话
也就是说代码跟代码之间的一个关系的话
19:03.765–19:05.265
zh他是有依赖的
他是有依赖的
19:05.265–19:06.125
zh他不是说
他不是说
19:06.125–19:10.345
zh简单粗暴的给你把一些这个代码拼在一起
简单粗暴的给你把一些这个代码拼在一起
19:10.345–19:11.265
zh然后去理解的
然后去理解的
19:11.265–19:14.785
zh他是一定要把他的一个依赖关系给他分析出来
他是一定要把他的一个依赖关系给他分析出来
19:14.785–19:17.165
zh这个做过我们这个
这个做过我们这个
19:17.165–19:18.505
zhJava 项目开发啊
Java 项目开发啊
19:18.505–19:19.765
zh就 Maven 依赖的这个同学
就 Maven 依赖的这个同学
19:19.765–19:21.145
zh应该会比较清楚啊
应该会比较清楚啊
19:21.145–19:22.905
zh包括至于 Python 里面啊
包括至于 Python 里面啊
19:22.905–19:23.925
zh各种语言里面
各种语言里面
19:23.925–19:24.825
zh其实都有一些
其实都有一些
19:24.825–19:26.985
zh一些库的一些依赖是吧
一些库的一些依赖是吧
19:26.985–19:28.905
zh那么如果说啊
那么如果说啊
19:28.905–19:31.205
zhAI没有理解这个依赖引用的话
AI没有理解这个依赖引用的话
19:31.205–19:32.605
zh就很可能出现什么呢
就很可能出现什么呢
19:32.605–19:34.285
zh就是一些编译报错呀
就是一些编译报错呀
19:34.285–19:35.965
zh或者是一些少一些模块啊
或者是一些少一些模块啊
19:35.965–19:36.145
zh是吧
是吧
19:36.145–19:37.165
zh就很容易出现这种问题
就很容易出现这种问题
19:37.165–19:38.745
zh所以早期的AI编程工具
所以早期的AI编程工具
19:38.745–19:39.805
zh它帮你设计代码的话
它帮你设计代码的话
19:39.805–19:41.765
zh有时候就就会出现这种问题
有时候就就会出现这种问题
19:41.765–19:43.025
zh因为它没有分析透彻
因为它没有分析透彻
19:43.025–19:45.225
zh它只是简单粗暴的给你去生成代码
它只是简单粗暴的给你去生成代码
19:45.225–19:47.485
zh那现在Codex这种
那现在Codex这种
19:47.485–19:49.045
zh最新的AI编程工具
最新的AI编程工具
19:49.045–19:50.585
zh这些问题他们都解决了
这些问题他们都解决了
19:50.585–19:53.045
zh那么它给你把依赖分析的非常透彻
那么它给你把依赖分析的非常透彻
19:53.045–19:57.685
zh然后是外部工具的一个协同
然后是外部工具的一个协同
19:57.685–19:59.685
zh那这个里面的话
那这个里面的话
19:59.685–20:02.005
zh主要是就是在工程化设计中
主要是就是在工程化设计中
20:02.005–20:03.365
zhCodex的话
Codex的话
20:03.365–20:06.625
zh它其实是具备了强大的一个环境交互能力
它其实是具备了强大的一个环境交互能力
20:06.625–20:09.025
zh它不是只是说一个文本生成技术
它不是只是说一个文本生成技术
20:09.025–20:13.025
zh它具有非常强大的一个自主执行能力
它具有非常强大的一个自主执行能力
20:13.025–20:16.465
zh就是我们给了它终端环境的一个控制权
就是我们给了它终端环境的一个控制权
20:16.465–20:18.065
zh就是他可以几乎
就是他可以几乎
20:18.065–20:20.825
zh你如果用的是这个bypass模式
你如果用的是这个bypass模式
20:20.825–20:21.085
zh是吧
是吧
20:21.085–20:22.565
zh你就把所有的权限交给他
你就把所有的权限交给他
20:22.565–20:24.505
zh那他就可以做很多事情了
那他就可以做很多事情了
20:24.505–20:26.085
zh不管是什么编译器啊
不管是什么编译器啊
20:26.085–20:26.725
zh调试器啊
调试器啊
20:26.725–20:27.425
zh包管理器啊
包管理器啊
20:27.425–20:27.685
zh是吧
是吧
20:27.685–20:28.445
zh直接调用
直接调用
20:28.445–20:30.865
zh因为他相当于就是超级管理员
因为他相当于就是超级管理员
20:30.865–20:31.925
zh他可以做任何事情
他可以做任何事情
20:31.925–20:32.985
zh并且的话
并且的话
20:32.985–20:34.465
zh当代码报错的时候
当代码报错的时候
20:34.465–20:36.005
zh他会自动的去处理
他会自动的去处理
20:36.005–20:37.665
zh自动的去读取日志
自动的去读取日志
20:37.665–20:39.725
zh然后去定位这个原因
然后去定位这个原因
20:39.725–20:40.785
zh并且自动修复
并且自动修复
20:40.785–20:41.925
zh所以说这是
所以说这是
20:41.925–20:43.625
zh它非常强大的一个能力
它非常强大的一个能力
20:43.625–20:45.325
zh就是它发现问题之后
就是它发现问题之后
20:45.325–20:46.945
zh它会自动的去修复问题
它会自动的去修复问题
20:46.945–20:48.145
zh所以大家会觉得
所以大家会觉得
20:48.145–20:50.145
zh目前的AI编程工具非常智能
目前的AI编程工具非常智能
20:50.145–20:53.145
zh因为它帮你把所有的问题都解决了
因为它帮你把所有的问题都解决了
20:53.145–20:54.125
zh并且是全自动的
并且是全自动的
20:54.125–20:55.825
zh不需要你再去提什么问题了
不需要你再去提什么问题了
20:55.825–20:57.025
zh所以这个是一个
所以这个是一个
20:57.025–20:59.365
zh非常大的一个优化点
非常大的一个优化点
20:59.365–21:00.805
zh好
好
21:00.805–21:01.905
zh所以说大家首先
所以说大家首先
21:01.905–21:03.285
zh要对Codex
要对Codex
21:03.285–21:04.985
zh它的一个工程化设计思想
它的一个工程化设计思想
21:04.985–21:06.225
zh要有一个认知
要有一个认知
21:06.225–21:09.005
zh那么你掌握了这个
那么你掌握了这个
21:09.005–21:11.985
zh它的一个工程化设计思想之后的话
它的一个工程化设计思想之后的话
21:11.985–21:13.825
zh大家再去
大家再去
21:13.825–21:15.065
zh用Codex的话
用Codex的话
21:15.065–21:16.805
zh你就会发现啊
你就会发现啊
21:16.805–21:17.685
zh它的一些细节
它的一些细节
21:17.685–21:20.805
zh就会怎么样更好的去使用它
就会怎么样更好的去使用它
21:20.805–21:22.605
enOK
OK

影片筆記：2026版AI+Codex零基础全套视频课程，Codex从入门到大神AI编程开发，涵盖安装配置、代码分析、Bug修复及完整项目实战 p03 2、Codex 核心能力与工程化设计思想揭秘

一句話總結

本段內容深入解析 OpenAI 推出的 AI 編程工具 Codex，介紹其 CLI、APP 及 IDE 插件等多種使用方式，詳述代碼生成、審查、Bug 修復等核心功能，並重點闡述其背後的工程化設計思想，包括以規範工程取代提示詞工程、意圖拆解與 Agent Loop 機制，以及透過 AST 感知與外部工具協同進行的上下文工程優化。

核心重點

  • Codex 的多模態使用途徑：提供 APP、CLI（命令行）及 IDE 插件（如 VS Code 或 Coser）三種主要使用方式，建議安裝插件以結合開發工作流，避免窗口切換。
  • 廣泛的功能場景：涵蓋代碼生成、開源項目結構分析、歷史代碼閱讀、代碼審查（Code Review）、線上 Bug 排查及自動化全棧開發任務。
  • 強大的核心能力：
  • 多任務處理：支持多線程同時處理跨項目任務並合併結果。
  • Git WorkTree 機制：支持在同一分支下通過多個 WorkTree 進行並行開發，實現代碼隔離與無分支合併的協作。
  • 遠程控制與自動化：支持手機遠程操控電腦，調用應用、操作瀏覽器、生成與編輯圖片，並具備強大的插件系統。
  • 三大工程化設計思想：
  1. 規範工程取代提示詞工程：強調 SDD（規範驅動開發），通過撰寫 agents.md、Harness 等規範文件來限定目標與驗收標準，實現高質量代碼生成，甚至達到「零人工寫代碼」的大型項目落地案例。
  2. 意圖拆解與 Agent Loop：模擬人類工程師流程（計劃 -> 確認 -> 執行 -> 審查），提供確認模式與全託管模式，細粒度拆分任務並進行嚴格審查。
  3. 上下文工程優化：透過精簡檢索、AST（抽象語法樹）感知依賴關係，以及擁有終端環境控制權的外部工具協同，實現自動讀取日誌、定位並修復 Bug。

詳細大綱

I. Codex 概述與學習資源

  • 定義：OpenAI 官方推出的 AI 編程工具，已超越單純的 AI 編程範疇，進化成為全棧開發夥伴。
  • 推薦學習資料：
  1. OpenAI 官方開發者文檔（包含概念性論知、指南）。
  2. 開源倉庫（包含 CLI、agents.md 等細節文檔、源碼）。

II. Codex 的使用方式

  • 三種主流模式：
  1. APP 版本：目前推出，易用性高。
  2. CLI（命令行）：早期版本，基於命令交互。
  3. IDE 插件：支援 VS Code 或 Coser，推薦安裝插件以結合編碼工作流，避免窗口切換麻煩。

III. Codex 的主要功能場景

  • 代碼生成與開發：通過快捷指令和對話方式生成代碼或搭建項目架構。
  • 項目分析與閱讀：
  • 分析開源項目結構。
  • 閱讀歷史遺留代碼，理解團隊開發細節。
  • 代碼審查（Code Review）：
  • 使用 review 斜杠命令分析未提交代碼或 PR。
  • 識別漏洞，提供建議或拒絕合併。
  • 線上問題排查：提供日誌和代碼行，快速定位 Bug 並給出修復方案。
  • 自動化開發任務：從需求分析、功能拆解、核心開發、測試到調試的全流程自動化。

IV. Codex 的核心能力

  • 多任務處理（多線程）：支持同時啟動多個線程處理跨項目任務，最終合併結果。
  • Git WorkTree 機制：支持在同一分支下通過多個 WorkTree 進行並行開發，代碼相互隔離，實現無分支合併的多人協作。
  • 遠程連接與控制：
  • 支持手機端遠程連接並操控電腦端 Codex。
  • 支援調用應用、操作感測器、截圖識別、執行終端命令、操作瀏覽器及添加 Chrome 插件。
  • 多模態與自動化：
  • 生成與編輯圖片（支援多模模型，如 DLE3、image2）。
  • 全自動調用工具完成大任務。
  • 插件系統與技能搭建：
  • 支持搭建企業級技能（Scale Development）。
  • 支援側邊欄、Artifact（文件預覽）、跟蹤計劃來源等功能。
  • 極大拓展能力，甚至支援生成視頻。
  • 與 IDE（Coser/VS Code）同步。

V. Codex 的工程化設計思想

  • 核心理念：從簡單 AI 編程助手進化為「全棧開發夥伴」。
  • 設計原則 1：規範工程取代提示詞工程
  • 強調 SDD（規範驅動開發）。
  • 通過撰寫規範文件（如 agents.md、Harness）來限定目標、邊界和驗收標準。
  • 案例：OpenAI 內部使用 Harness Engineering，三人團隊在五到六個月內，人工不寫一行代碼，利用 AI 生成一百多萬行代碼並上線。
  • 設計原則 2：意圖拆解與 Agent Loop（任務循環）
  • 模擬人類工程師開發過程：計劃 -> 確認 -> 執行。
  • 提供確認模式與全託管模式。
  • 細粒度拆分任務至函數/模塊，並進行嚴格審查（分析 Bug、安全性、性能瓶頸）。
  • 設計原則 3：上下文工程優化
  • 精簡檢索：僅注入與當前任務及特定文件相關的代片段和元數據，避免上下文超限。
  • AST（抽象語法樹）感知：理解代碼依賴引用關係，避免編譯報錯或模塊缺失。
  • 外部工具協同：具備環境交互能力，擁有終端環境控制權（超級管理員權限）。
  • 自動修復：自動讀取日誌、定位原因並自動修復代碼錯誤。

工具 / 模型 / 名詞整理

  • 產品/工具：
  • Codex
  • OpenAI
  • CLI (Command Line Interface)
  • APP (應用程式)
  • VS Code
  • Coser (逐字稿提及，疑點見下)
  • Git WorkTree
  • IDE (Integrated Development Environment)
  • Chrome 插件
  • PR (Pull Request)
  • DIF (逐字稿提及，疑點見下)
  • Maven (逐字稿提及，疑點見下)
  • 模型/技術名稱：
  • agents.md
  • Harness / Harness Engineering
  • SDD (規範驅動開發)
  • Agent Loop (任務循環)
  • AST (抽象語法樹)
  • DLE3 (疑點，疑點見下)
  • image2 (疑點，疑點見下)
  • 多模碳模型 (疑點，疑點見下)

操作流程整理

  1. 選擇使用方式：根據需求選擇 APP、CLI 或安裝 IDE 插件（如 VS Code/Coser）。
  2. 執行開發任務：
  • 代碼生成：通過快捷指令或對話生成代碼/架構。
  • 項目分析：分析開源結構或閱讀歷史代碼。
  • 代碼審查：使用 review 斜杠命令分析未提交代碼或 PR，識別漏洞。
  • Bug 排查：提供日誌和代碼行，定位並修復 Bug。
  1. 利用核心能力協作：
  • 啟動多線程處理多任務。
  • 使用 Git WorkTree 進行並行開發。
  • 透過手機遠程控制電腦端 Codex。
  1. 遵循工程化設計：
  • 撰寫規範文件（agents.md、Harness）定義目標與標準。
  • 執行 Agent Loop：計劃 -> 確認 -> 執行 -> 審查。
  • 利用 AST 感知依賴，結合外部工具自動修復錯誤。

值得注意的限制或風險

  • 上下文超限風險：需透過精簡檢索機制，僅注入相關代碼片段和元數據，以避免上下文超限。
  • 依賴關係複雜性：需依賴 AST 感知來理解代碼依賴，否則可能導致編譯報錯或模塊缺失。
  • 權限與安全性：Codex 擁有終端環境控制權（超級管理員權限），在自動修復和執行命令時需注意安全性審查。
  • 識別錯誤風險：逐字稿中存在多處疑似聽寫錯誤（如 Coser、DLE3、image2、多模碳模型等），實際操作或理解時需謹慎查證，避免誤用不存在的工具或模型名稱。

逐字稿辨識疑點

  • Coser：逐字稿中多次提及「Coser」，並與 VS Code 並列作為 IDE 推薦。疑點：可能為 Cursor 的聽寫錯誤，或指代其他特定 IDE 產品，需查證。
  • DIF：逐字稿提及「看 PR 裡面的 commit DIF」，疑點：可能為 Diff 的聽寫錯誤。
  • Maven：逐字稿提及「加瓦項目開發啊 就 Maven 依賴」，疑點：「加瓦」可能為 Java 的聽寫錯誤，Maven 為 Java 項目構建工具，此處語境符合，但「加瓦」一詞需查證是否為口誤。
  • DLE3：逐字稿提及「多模碳模型 比如说像 DLE3」，疑點：OpenAI 圖片模型通常為 DALL-E 3，「DLE3」疑為聽寫錯誤。
  • image2：逐字稿提及「然后image2」，疑點：OpenAI 圖片模型版本通常為 DALL-E 2 或 DALL-E 3，「image2」疑為聽寫錯誤或指代不明確的模型版本。
  • 多模碳模型：逐字稿提及「它本身就有一些这个图片的一些模型 多么碳模型」，疑點：可能為 多模態模型 的聽寫錯誤。
  • 全棧開發：逐字稿提及「进化成一个叫做 全镇开发的一个伙伴了」，疑點：「全镇」疑為 全棧 的聽寫錯誤。
  • Honest Engineering：逐字稿後段提及「深入的去落地这个Honest Engineering」，前文提及「Harness Engineering」，疑點：「Honest」可能為 Harness 的聽寫錯誤，需查證。
  • bypass 模式：逐字稿提及「如果你用的是这个bypass 模式」，疑點：Codex 中通常稱為 Bash 模式或 Autonomous 模式，「bypass」疑為聽寫錯誤或特定術語，需查證。
  • 县程 / 县城：逐字稿多次提及「开三个这个县城」、「启动三个县程」，疑點：明顯為 線程 的聽寫錯誤。
  • 斜杠命令：逐字稿提及「专门的review的这么一个斜杠命令」，疑點：通常稱為 Slash Command，中文直譯為斜杠命令，此處表述尚可，但需確認是否為標準術語。
  • 皮牙合并：逐字稿提及「给他拒绝这个皮牙合并」，疑點：明顯為 Pull Request 合併 或 PR 合併 的聽寫錯誤，「皮牙」語義不明。
  • 论务：逐字稿提及「做一些这个论务」，疑點：可能為 任務 的聽寫錯誤。
  • 侧边软：逐字稿提及「一些什么侧边软」，疑點：可能為 側邊欄 的聽寫錯誤。
  • 集上下文：逐字稿提及「它会根据集合上下文去分析」，疑點：可能為 結合上下文 或 檢索上下文 的聽寫錯誤。

可延伸追問

  • 關於「Coser」IDE 插件，具體是指哪款編輯器？是否為 Cursor 或其他開源項目？
  • 「Harness Engineering」具體的規範文件格式和內容結構為何？如何編寫有效的 agents.md？
  • Git WorkTree 在實際大型項目協作中，如何處理衝突和代碼合併的具體流程？
  • 「多模碳模型」及「DLE3」、「image2」具體對應 OpenAI 的哪些圖像生成模型？
  • 在「全託管模式」下，Codex 自動修復 Bug 的準確率和安全性保障機制是什麼？

尚未產生學習筆記

請在 Telegram 指令最後加上「學習」，例如：videonote 網址 英文 雙語 學習