WEBVTT

00:00:00.000 --> 00:00:06.200
接下来我们来讲一下CodexAgence.md配置与架构设计。

00:00:07.140 --> 00:00:17.160
那这个Agence.md的话其实是Codex在这个规范化编程这一块做的一些整个架构的一个设计。

00:00:18.080 --> 00:00:29.380
它系统这个里面定义了一个规范,我们可以在这个Agence.md里面可以把项目的一些实际的一些开发规范,包括我们整个项目的一些结构,

00:00:29.380 --> 00:00:31.160
放到这个文件里面

00:00:31.160 --> 00:00:33.640
那么在Codex加载的时候

00:00:33.640 --> 00:00:36.140
我们去分析整个项目结构的时候

00:00:36.140 --> 00:00:40.740
他会优先去读取这个agents.md文件

00:00:40.740 --> 00:00:41.700
这样的话

00:00:41.700 --> 00:00:46.040
他就相当于了解了我们项目的全局的一些

00:00:46.040 --> 00:00:47.380
这个大致的一些情况

00:00:47.380 --> 00:00:51.440
所以说这个agents.md的话

00:00:51.440 --> 00:00:54.440
其实就是作为一个规范

00:00:54.440 --> 00:00:56.320
这个驱动开发的一种方式

00:00:56.320 --> 00:00:59.020
通过整个全局的一个说明

00:00:59.020 --> 00:01:01.760
包括我们整个目录层级

00:01:01.760 --> 00:01:05.140
它的一些关键的一些文件在哪里

00:01:05.140 --> 00:01:06.280
比如说像一些文档

00:01:06.280 --> 00:01:08.280
我们整个项目的一个架构文档

00:01:08.280 --> 00:01:09.900
设计文档 API文档

00:01:09.900 --> 00:01:12.740
通过这个agents.md文件

00:01:12.740 --> 00:01:16.480
把我们相当于这个代码地图描述了非常清楚

00:01:16.480 --> 00:01:19.980
那这个AI就可以快速了解到

00:01:19.980 --> 00:01:22.440
我们项目里面的一些重点信息

00:01:22.440 --> 00:01:23.340
这样的话

00:01:23.340 --> 00:01:25.580
那你让它去生成代码的时候

00:01:25.580 --> 00:01:27.500
相当于它已经把你整个项目

00:01:27.500 --> 00:01:29.180
大致做了一个了解了

00:01:29.180 --> 00:01:31.100
这样他去找文件的时候

00:01:31.100 --> 00:01:32.780
他的一个效率就会非常高

00:01:32.780 --> 00:01:33.800
速度也非常快

00:01:33.800 --> 00:01:37.900
那么Codex他是如何发现

00:01:37.900 --> 00:01:39.720
这些个文件的呢

00:01:39.720 --> 00:01:40.820
首先的话

00:01:40.820 --> 00:01:42.640
他会启动的时候

00:01:42.640 --> 00:01:44.820
他会整理出一条本次运行

00:01:44.820 --> 00:01:46.340
需要使用的一个指令链

00:01:46.340 --> 00:01:50.060
那么他首先会做一个检查

00:01:50.060 --> 00:01:51.340
他这个检查的话

00:01:51.340 --> 00:01:53.340
是有一个顺序层级的

00:01:53.340 --> 00:01:55.820
首先第一层的话叫做全局层

00:01:55.820 --> 00:01:57.580
那这个的话

00:01:57.580 --> 00:02:00.060
就是在我们的这个Codex主目录里面

00:02:00.060 --> 00:02:02.060
有个叫点Codex目录

00:02:02.060 --> 00:02:04.560
就是在当前登录用户的这个目录里面

00:02:04.560 --> 00:02:06.820
有一个叫点Codex的一个目录

00:02:06.820 --> 00:02:09.500
当然我们也可以在环境面量里面

00:02:09.500 --> 00:02:12.060
去指定这个Codex Home

00:02:12.060 --> 00:02:15.300
通过这个环境面量去指定指定的一个目录

00:02:15.300 --> 00:02:17.580
那我们指定之后的话

00:02:17.580 --> 00:02:19.240
Codex在运行的时候

00:02:19.240 --> 00:02:22.180
它就会把它的一些文件

00:02:22.180 --> 00:02:24.560
就是系统的一些文件

00:02:24.560 --> 00:02:26.660
默认的会去存放到这个目录里面去

00:02:26.660 --> 00:02:28.440
如果大家没有设定的话

00:02:28.440 --> 00:02:31.180
它就是在当前登录用户的这个

00:02:31.180 --> 00:02:33.540
一个目录下面

00:02:33.540 --> 00:02:35.580
有一个叫.codex这么一个目录

00:02:35.580 --> 00:02:38.180
那么在这个目录下面的话

00:02:38.180 --> 00:02:40.460
我们可以去指定一个叫

00:02:40.460 --> 00:02:43.000
agents.overload.md

00:02:43.000 --> 00:02:44.480
那么这个的话

00:02:44.480 --> 00:02:48.100
就是一个全局的一个agents.md

00:02:48.100 --> 00:02:50.120
那么在这个里面的话

00:02:50.120 --> 00:02:52.160
我们写的内容

00:02:52.160 --> 00:02:53.620
它会优先去读取

00:02:53.620 --> 00:02:55.080
要是没有的话

00:02:55.080 --> 00:02:58.460
他再会去读取这个agency.md文件

00:02:58.460 --> 00:03:01.380
所以说他这个里面就是一个规范啊

00:03:01.380 --> 00:03:04.020
首先从最外层去开始去找找这个文件

00:03:04.020 --> 00:03:06.080
如果能找到的话就优先使用它

00:03:06.080 --> 00:03:09.900
找不到的话再往下一层级去找agency.md

00:03:09.900 --> 00:03:13.080
好然后第二个层级叫项目级

00:03:13.080 --> 00:03:14.260
比如说啊

00:03:14.260 --> 00:03:16.080
我们这个项目里面

00:03:16.080 --> 00:03:19.920
我们在项目里面也可以去写这个agency.md

00:03:19.920 --> 00:03:21.820
比如说我们整个项目啊

00:03:21.820 --> 00:03:23.720
它是什么一个结构

00:03:23.720 --> 00:03:25.040
规范是怎么样的

00:03:25.040 --> 00:03:26.780
包括它的一些后代命令

00:03:26.780 --> 00:03:28.020
有哪些数据库配置

00:03:28.020 --> 00:03:29.040
有哪些等等的

00:03:29.040 --> 00:03:29.860
这些个内容

00:03:29.860 --> 00:03:30.820
我们都可以写到

00:03:30.820 --> 00:03:32.100
agents.md里面去

00:03:32.100 --> 00:03:33.620
然后的话就是

00:03:33.620 --> 00:03:35.480
我们如果在项目层

00:03:35.480 --> 00:03:36.900
写了agents.md

00:03:36.900 --> 00:03:37.920
但是呢

00:03:37.920 --> 00:03:39.200
全局层又没有写的话

00:03:39.200 --> 00:03:40.880
它会优先使用

00:03:40.880 --> 00:03:42.920
项目层里面的agents.md

00:03:42.920 --> 00:03:45.560
去做一个读取

00:03:45.560 --> 00:03:46.360
那这里面

00:03:46.360 --> 00:03:47.740
它也会去优先去找

00:03:47.740 --> 00:03:49.980
agents.overload.md

00:03:49.980 --> 00:03:50.980
如果找不到的话

00:03:50.980 --> 00:03:51.860
他就会找这个

00:03:51.860 --> 00:03:54.380
所以说我们在项目里面写agentsmd

00:03:54.380 --> 00:03:56.980
如果又没有配置其他的这个md文件的话

00:03:56.980 --> 00:03:58.880
他的优先级这个就是最高

00:03:58.880 --> 00:04:01.440
所以这个就是项目层

00:04:01.440 --> 00:04:04.280
全局层的话就是比如说啊

00:04:04.280 --> 00:04:07.320
大家在本地我开发多个项目啊

00:04:07.320 --> 00:04:08.740
我有python的这个项目

00:04:08.740 --> 00:04:09.800
有java的项目

00:04:09.800 --> 00:04:12.400
如果说你需要所有的这个规范啊

00:04:12.400 --> 00:04:13.340
做一个对齐的话

00:04:13.340 --> 00:04:16.480
那这里面大家就可以去全局层里面

00:04:16.480 --> 00:04:19.040
去把这个agentsmd做一个定义啊

00:04:19.040 --> 00:04:21.800
比如说我是作为一个个人开发者

00:04:21.800 --> 00:04:24.460
然后他的一个规范是怎么样的

00:04:24.460 --> 00:04:26.980
就是所有的项目都是按这个规范来的

00:04:26.980 --> 00:04:28.560
按照我个人的一个编码风格来

00:04:28.560 --> 00:04:30.200
不管你是什么语言的项目

00:04:30.200 --> 00:04:31.640
都得按我这个风格来

00:04:31.640 --> 00:04:33.280
这个就比较适合放全局

00:04:33.280 --> 00:04:34.920
放项目的话

00:04:34.920 --> 00:04:37.580
就是每个项目的一些特定的一些配置

00:04:37.580 --> 00:04:39.340
比如说后端项目

00:04:39.340 --> 00:04:41.280
那后端项目肯定有一些接口啊

00:04:41.280 --> 00:04:42.360
架构设计啊

00:04:42.360 --> 00:04:44.660
包括一些数据库脚本啊等等的

00:04:44.660 --> 00:04:46.980
那如果是你是个前端项目的话啊

00:04:46.980 --> 00:04:48.120
那比如说有这个

00:04:48.120 --> 00:04:49.840
npm 包的一个设置

00:04:49.840 --> 00:04:50.140
是吧

00:04:50.140 --> 00:04:51.500
有 package 点 json

00:04:51.500 --> 00:04:53.020
还有一些这个像

00:04:53.020 --> 00:04:54.220
vio 的一些酷啊

00:04:54.220 --> 00:04:55.660
react 的一些酷啊

00:04:55.660 --> 00:04:55.920
是吧

00:04:55.920 --> 00:04:59.380
这个就是前端的一些这个层级

00:04:59.380 --> 00:05:01.340
包括一些路由配置啊等等啊

00:05:01.340 --> 00:05:02.300
那每个项目的话

00:05:02.300 --> 00:05:04.440
它的规范也不一样啊

00:05:04.440 --> 00:05:05.620
我们用前端跟后端

00:05:05.620 --> 00:05:07.740
所以这个项目层里面

00:05:07.740 --> 00:05:09.900
肯定是要区分这个agents.md的

00:05:09.900 --> 00:05:12.100
这个就比较适用于放到这一层

00:05:12.100 --> 00:05:13.100
呃

00:05:13.100 --> 00:05:13.760
然后的话

00:05:13.760 --> 00:05:14.660
最后啊

00:05:14.660 --> 00:05:16.280
如果两个都写了怎么办呢

00:05:16.280 --> 00:05:17.160
都写的话

00:05:17.160 --> 00:05:19.180
都是他就是都会去读取

00:05:19.180 --> 00:05:23.380
然后越靠近当前目录的文件越靠后

00:05:23.380 --> 00:05:27.980
所以说他会覆盖前面更通用的一些说明

00:05:27.980 --> 00:05:30.260
他就是按照这么一个层形去做覆盖

00:05:30.260 --> 00:05:32.880
那空文件的话就会被跳过

00:05:32.880 --> 00:05:36.380
合并总大小一旦达到他设定的一个上限的话

00:05:36.380 --> 00:05:40.000
这个Codex就不会加入更多的一些文件了

00:05:40.000 --> 00:05:42.620
所以说他是有一个上限的

00:05:42.620 --> 00:05:44.300
当然这个参数也可以去调

00:05:44.300 --> 00:05:48.080
也就是我们整个文档

00:05:48.080 --> 00:05:49.300
你也不能放太大了

00:05:49.300 --> 00:05:50.920
因为这个的话是Codex

00:05:50.920 --> 00:05:54.920
它工作的时候默认会加载的一个文档

00:05:54.920 --> 00:05:57.040
如果大家把这个文档做的很大

00:05:57.040 --> 00:05:58.300
比如说做一兆是吧

00:05:58.300 --> 00:05:58.740
非常大

00:05:58.740 --> 00:06:00.440
直接就超过这个上下文了

00:06:00.440 --> 00:06:02.760
那这个显然是不太合适的

00:06:02.760 --> 00:06:04.880
就是对于首先成本消耗

00:06:04.880 --> 00:06:06.240
包括上下文窗口的话

00:06:06.240 --> 00:06:07.560
一下子可能就超出去了

00:06:07.560 --> 00:06:10.840
所以agents.md里面要写的内容

00:06:10.840 --> 00:06:13.540
比如说你是项目层的这个agents.md

00:06:13.540 --> 00:06:16.200
一定要写跟项目相关的一些

00:06:16.200 --> 00:06:18.340
比如说这个命令啊

00:06:18.340 --> 00:06:18.620
是吧

00:06:18.620 --> 00:06:20.440
然后工程规范啊

00:06:20.440 --> 00:06:21.720
项目结构啊

00:06:21.720 --> 00:06:24.260
这是一些非常核心的内容

00:06:24.260 --> 00:06:26.140
那么我们就写到这个里面

00:06:26.140 --> 00:06:28.500
基本上大概就是100行左右啊

00:06:28.500 --> 00:06:29.200
不能太多

00:06:29.200 --> 00:06:31.840
太多的话就很容易超过这个上下文线

00:06:31.840 --> 00:06:34.320
所以这个是一个细节点啊

00:06:34.320 --> 00:06:37.240
那么大家就可以在这个

00:06:37.240 --> 00:06:38.640
按照上面我们

00:06:38.640 --> 00:06:41.560
就是确认好的一个这个层级啊

00:06:41.560 --> 00:06:43.200
你可以在全局层里面啊

00:06:43.200 --> 00:06:44.900
就在这个里面去加agency.md

00:06:44.900 --> 00:06:46.200
那我们这里的话

00:06:46.200 --> 00:06:48.740
主要是带大家在项目里面去讲啊

00:06:48.740 --> 00:06:50.420
在项目里我们用了最多的方案

00:06:50.420 --> 00:06:53.260
还是在项目里面去加agency.md

00:06:53.260 --> 00:06:56.100
所以最外层的这个用户目录下

00:06:56.100 --> 00:06:57.220
那个agency.md的话

00:06:57.220 --> 00:06:58.920
我们一般来说不会去改

00:06:58.920 --> 00:07:02.380
因为我们一般是按项目来去做一个驱动啊

00:07:02.380 --> 00:07:03.960
这是实际啊

00:07:03.960 --> 00:07:04.960
实践的这个场景

00:07:04.960 --> 00:07:07.460
就是在项目里面加agency.md比较多啊

00:07:07.460 --> 00:07:09.080
当然大家如果确实有需要的话

00:07:09.080 --> 00:07:10.540
你可以去那个里面改啊

00:07:10.540 --> 00:07:13.780
那我们盖完之后的话

00:07:13.780 --> 00:07:14.680
就是在这个里面

00:07:14.680 --> 00:07:15.820
我们会写哪些东西呢

00:07:15.820 --> 00:07:18.340
比如说你是做一个前端项目

00:07:18.340 --> 00:07:20.460
那你肯定要去写一些这个

00:07:20.460 --> 00:07:22.480
NPM的一些命令啊

00:07:22.480 --> 00:07:23.440
一些描述是吧

00:07:23.440 --> 00:07:25.640
那整个这个项目

00:07:25.640 --> 00:07:28.040
他就是去比如说添加一些依赖的时候

00:07:28.040 --> 00:07:29.100
需要做一个确认

00:07:29.100 --> 00:07:33.100
那这个就是我们针对前端这种项目啊

00:07:33.100 --> 00:07:34.720
可以写的一个agency MD

00:07:34.720 --> 00:07:36.280
但肯定不会这么简单

00:07:36.280 --> 00:07:37.920
我们还可以可以写很多内容

00:07:37.920 --> 00:07:40.180
所以说啊

00:07:40.540 --> 00:07:41.740
这个里面啊

00:07:41.740 --> 00:07:44.700
就大家首先要搞清楚这么一个场景啊

00:07:44.700 --> 00:07:48.560
如果说你确实要去写一些全局的这个agents.md的话

00:07:48.560 --> 00:07:50.300
那你就写到用户目里面去

00:07:50.300 --> 00:07:55.700
如果说你只是做一个这个项目的一个场景的话

00:07:55.700 --> 00:07:58.360
你就放到项目的这个agents.md里面去

00:07:58.851 --> 00:08:02.151
那么这个agents.md的话

00:08:02.151 --> 00:08:04.691
它这个里面的话

00:08:04.691 --> 00:08:07.311
我们可以首先在根目录里面去加

00:08:07.311 --> 00:08:08.331
然后的话

00:08:08.331 --> 00:08:11.091
比如说你还需要做这个覆盖

00:08:11.091 --> 00:08:11.451
是吧

00:08:11.451 --> 00:08:12.411
你要做覆盖的话

00:08:12.411 --> 00:08:14.551
你就可以去创建agents.md

00:08:14.551 --> 00:08:18.211
那它就会去覆盖当前的agents.md

00:08:18.211 --> 00:08:20.811
那这个就比较适用于

00:08:20.811 --> 00:08:24.251
那比如说根目录啊

00:08:24.251 --> 00:08:26.371
我加了这个agents.md了

00:08:26.371 --> 00:08:27.191
但是呢

00:08:27.191 --> 00:08:29.211
在某一些模块下啊

00:08:29.211 --> 00:08:29.891
不同因为我们

00:08:29.891 --> 00:08:31.891
我们就做项目开发的

00:08:31.891 --> 00:08:33.571
大家知道是分模块开发的是吧

00:08:33.571 --> 00:08:36.151
那有的模块它是别的小组

00:08:36.151 --> 00:08:38.631
那人家别的小组有自己的一套规范

00:08:38.631 --> 00:08:41.451
他不想说跟着你规范一起调了

00:08:41.451 --> 00:08:42.911
我们有自己的一套规范

00:08:42.911 --> 00:08:44.051
所以的话

00:08:44.051 --> 00:08:46.571
我们可能在某个模块下面

00:08:46.571 --> 00:08:48.691
加一个agency.md.org

00:08:48.691 --> 00:08:49.711
这样的话

00:08:49.711 --> 00:08:52.051
我们就直接可以去覆盖之前的一个配置

00:08:52.051 --> 00:08:56.371
所以这个是比较适合于做一些覆盖的一场景

00:08:56.371 --> 00:08:58.931
就当于每一个团队都有自己的一个特色

00:08:58.931 --> 00:09:00.551
那并且的话

00:09:00.551 --> 00:09:03.471
我们也可以在某个模块去启用这个Codex

00:09:03.471 --> 00:09:04.911
然后去做一个执行

00:09:04.911 --> 00:09:05.791
OK

00:09:05.791 --> 00:09:09.091
这个就是我们可以在不同的模块下面啊

00:09:09.091 --> 00:09:10.631
去加这个Agence.md

00:09:10.631 --> 00:09:11.931
好

00:09:11.931 --> 00:09:13.511
然后的话

00:09:13.511 --> 00:09:15.451
就是这里面一个逻辑就是Codex

00:09:15.451 --> 00:09:17.831
首先会去报告全局文件

00:09:17.831 --> 00:09:20.071
然后再去报告仓库的根目录

00:09:20.071 --> 00:09:21.511
最后再去报告

00:09:21.511 --> 00:09:22.891
某个模块

00:09:22.891 --> 00:09:24.411
比如说像这个支付模块

00:09:24.411 --> 00:09:25.691
下面的一些覆盖文件

00:09:25.691 --> 00:09:26.231
是吧

00:09:26.231 --> 00:09:28.491
那么Codex在搜索的时候

00:09:28.491 --> 00:09:31.331
会达到这个当前目录的话

00:09:31.331 --> 00:09:32.091
就会停止

00:09:32.091 --> 00:09:34.371
所以说尽量应该把覆盖文件

00:09:34.371 --> 00:09:35.631
靠在专门

00:09:35.631 --> 00:09:38.231
就是按照规范去做一个存储

00:09:38.231 --> 00:09:39.971
所以说我们

00:09:39.971 --> 00:09:42.231
加了这个模块之后

00:09:42.231 --> 00:09:43.311
你就在这个模块下面

00:09:43.311 --> 00:09:45.491
直接就放这个MD文件就可以了

00:09:45.491 --> 00:09:47.551
所以它是相当于

00:09:47.551 --> 00:09:49.451
我们可以在不同的模块下面

00:09:49.451 --> 00:09:51.191
就不只是根目录可以讲

00:09:51.191 --> 00:09:53.171
不同的服务下面都可以去讲

00:09:53.171 --> 00:09:55.111
然后并且的话

00:09:55.111 --> 00:09:57.471
我们还可以去自定一些备用文件名

00:09:57.471 --> 00:10:02.211
比如说像仓库里面已经在使用其他名字

00:10:02.211 --> 00:10:02.491
是吧

00:10:02.491 --> 00:10:05.831
那你可以把它加入到这个备用列表里面去

00:10:05.831 --> 00:10:07.911
让Codex把它当作说明

00:10:07.911 --> 00:10:09.411
什么意思呢

00:10:09.411 --> 00:10:10.051
就比如说

00:10:10.051 --> 00:10:14.131
你现在有一个团队的这个手册是吧

00:10:14.131 --> 00:10:17.191
就是我们所有的项目都按这个手册来操作的

00:10:17.191 --> 00:10:20.371
那这个就比较适合于付放全局的这么一个

00:10:20.371 --> 00:10:22.351
叫做config.tom文件

00:10:22.351 --> 00:10:23.671
这个是Codex

00:10:23.671 --> 00:10:28.251
它整个应用的一个配置文件

00:10:28.251 --> 00:10:30.451
这个配置文件下是全局的

00:10:30.451 --> 00:10:31.691
也就是说你在这个里面

00:10:31.691 --> 00:10:32.711
加这个规范之后

00:10:32.711 --> 00:10:33.831
整个团队啊

00:10:33.831 --> 00:10:35.851
都是按照这个规范去执行

00:10:35.851 --> 00:10:37.751
所以这个是一个全局的

00:10:37.751 --> 00:10:38.591
一个配置文件

00:10:38.591 --> 00:10:40.331
我们可以把它加到这个里面去

00:10:40.331 --> 00:10:44.151
也就是大家除了这个agents.md以外

00:10:44.151 --> 00:10:44.471
是吧

00:10:44.471 --> 00:10:45.611
那你比如说

00:10:45.611 --> 00:10:47.451
我不想用agents.md这个文件

00:10:47.451 --> 00:10:48.611
这个名称

00:10:48.611 --> 00:10:49.611
我想换一个

00:10:49.611 --> 00:10:51.171
比如说叫teamgather

00:10:51.171 --> 00:10:53.751
那我就放到这个里面去

00:10:53.751 --> 00:10:55.471
这个也是OK的

00:10:55.471 --> 00:10:59.131
所以说整个一个文件命名的话

00:10:59.131 --> 00:11:01.091
就是大家可以很个性化

00:11:01.091 --> 00:11:03.491
但只是说你要去做一个配置

00:11:03.491 --> 00:11:05.531
多余的做一个配置

00:11:05.531 --> 00:11:07.271
你如果不想配置的话

00:11:07.271 --> 00:11:09.831
你就用agents.md会方便很多

00:11:09.831 --> 00:11:14.631
所以说大家有备用的一些文件需要加载

00:11:14.631 --> 00:11:18.011
还是说你就用agents.md里面加载

00:11:18.011 --> 00:11:19.271
它都是支持的

00:11:19.271 --> 00:11:20.511
它都有这么一个规范

00:11:20.511 --> 00:11:24.291
然后如果说你不希望使用不同的配置档的话

00:11:24.291 --> 00:11:27.591
比如说某个项目专用的这个自动化账号

00:11:27.591 --> 00:11:30.551
可以设置这个codex.home环境变量

00:11:30.551 --> 00:11:34.191
那这个里面的话就是

00:11:34.191 --> 00:11:37.251
我们可以单独去做一个search

00:11:37.251 --> 00:11:40.031
就单独去做一个page

00:11:40.031 --> 00:11:45.471
某些场景下面我们就用不同的这个codex.home环境变量就可以了

00:11:45.471 --> 00:11:48.091
这个也可以做不同的这个page

00:11:48.091 --> 00:11:50.591
然后配置完之后的话

00:11:50.591 --> 00:11:52.331
我们怎么样去验证呢

00:11:52.331 --> 00:11:52.611
是吧

00:11:52.611 --> 00:11:54.611
验证这个到底有没有效果呢

00:11:54.611 --> 00:11:57.451
那我们可以去看一下

00:11:57.451 --> 00:11:59.931
比如说我现在就在

00:11:59.931 --> 00:12:02.791
全局的这个agency.md里面

00:12:02.791 --> 00:12:03.911
给大家来看一下

00:12:03.911 --> 00:12:05.931
比如说我们在当前用户

00:12:05.931 --> 00:12:08.391
这个.codex目录

00:12:08.391 --> 00:12:12.031
.codex目录

00:12:12.031 --> 00:12:14.731
.codex目录下面有一个agency.md

00:12:14.731 --> 00:12:18.211
你看现在我们是什么都没写

00:12:18.211 --> 00:12:18.551
是吧

00:12:18.551 --> 00:12:21.091
那我们就比如说可以写一下

00:12:21.091 --> 00:12:22.431
这是

00:12:22.431 --> 00:12:25.931
全局的

00:12:25.931 --> 00:12:29.151
配置文件

00:12:29.151 --> 00:12:32.271
那就是说比如说

00:12:32.271 --> 00:12:35.091
我个人的开发规范

00:12:41.311 --> 00:12:42.771
比如说是采用

00:12:42.771 --> 00:12:46.911
DDD

00:12:46.911 --> 00:12:50.471
就是这种领域驱动的方式

00:12:50.471 --> 00:12:51.251
进行

00:12:51.251 --> 00:12:53.111
编程

00:12:53.111 --> 00:12:55.391
进行这个

00:12:55.391 --> 00:12:58.731
功能开发

00:13:06.731 --> 00:13:08.551
就是我个人的一个规范

00:13:08.551 --> 00:13:11.251
我们写在这个根目录的这个agents点目定里面

00:13:11.251 --> 00:13:12.671
然后我

00:13:12.771 --> 00:13:16.471
是现在我就切换到这个Codex目录里面

00:13:16.471 --> 00:13:19.671
然后我们去这个打开啊

00:13:19.671 --> 00:13:21.431
这个我一般建议是用

00:13:21.431 --> 00:13:23.651
终端的管理员的方式打开

00:13:23.651 --> 00:13:25.771
不然的话他可能会有权限的一些问题

00:13:25.771 --> 00:13:27.871
然后切换到底盘

00:13:27.871 --> 00:13:29.651
切换到Codex目录啊

00:13:29.651 --> 00:13:32.391
然后这里我们就进去啊

00:13:32.391 --> 00:13:33.331
说这个Codex

00:13:33.331 --> 00:13:36.251
然后你就随便问他啊

00:13:36.251 --> 00:13:37.651
就是我们在这个里面加的东西

00:13:37.651 --> 00:13:39.211
然后你就问

00:13:39.211 --> 00:13:43.891
我个人的开发规范有哪些啊

00:13:43.891 --> 00:13:45.011
你就这么来问

00:13:45.011 --> 00:13:47.771
然后我们看一下它能不能加载啊

00:13:47.771 --> 00:13:49.011
你看

00:13:49.011 --> 00:13:52.111
功能开发采用DDD领域驱动啊

00:13:52.111 --> 00:13:53.251
所以这个就是

00:13:53.251 --> 00:13:55.851
我们放这个应用层是吧

00:13:55.851 --> 00:13:58.251
就是所有的项目都会采这个规范啊

00:13:58.251 --> 00:14:01.011
就不管你是哪个项目的是吧

00:14:01.011 --> 00:14:04.071
那你都要按照我DDD的这个领域驱动的方式

00:14:04.071 --> 00:14:05.311
做一些功能开发啊

00:14:05.311 --> 00:14:06.471
这是我个人一个小习惯

00:14:06.471 --> 00:14:08.151
然后比如说啊

00:14:08.151 --> 00:14:10.151
我们现在单独的

00:14:10.151 --> 00:14:11.911
我们再建一个项目

00:14:11.911 --> 00:14:14.391
比如说这个里面

00:14:14.391 --> 00:14:16.111
这个叫什么呢

00:14:16.111 --> 00:14:17.991
叫做

00:14:17.991 --> 00:14:20.811
test

00:14:20.811 --> 00:14:23.811
或者怎么叫project

00:14:23.811 --> 00:14:25.191
project2

00:14:25.191 --> 00:14:29.611
那我们在这个里面建一个文件

00:14:29.611 --> 00:14:35.491
叫做agents

00:14:35.491 --> 00:14:37.691
agents.md

00:14:37.691 --> 00:14:39.131
是吧

00:14:39.131 --> 00:14:39.331
好

00:14:39.331 --> 00:14:42.451
然后这个里面啊

00:14:42.451 --> 00:14:47.091
我们就给他改一下是吧

00:14:47.091 --> 00:14:48.691
加一些特定的一些规范

00:14:48.691 --> 00:14:52.691
比如说我们用这个里面的一些规范来定一下啊

00:14:52.691 --> 00:14:56.251
我就随便找一个吧

00:14:56.251 --> 00:14:58.691
比如说我就

00:14:58.691 --> 00:15:00.691
就把这个规范加进去

00:15:00.691 --> 00:15:07.531
放到这个规范里面去

00:15:07.531 --> 00:15:10.911
然后

00:15:10.911 --> 00:15:12.571
就这样

00:15:12.571 --> 00:15:15.731
然后我们现在切换到那个木里面去

00:15:15.731 --> 00:15:20.291
CD到这个project2

00:15:20.291 --> 00:15:20.811
是吧

00:15:20.811 --> 00:15:22.471
然后注入codex

00:15:22.471 --> 00:15:26.371
然后你就问他

00:15:26.371 --> 00:15:29.391
当前项目

00:15:29.391 --> 00:15:32.531
开发规范

00:15:32.531 --> 00:15:34.251
由

00:15:34.251 --> 00:15:36.511
哪些

00:15:36.511 --> 00:15:42.251
大家看啊

00:15:42.251 --> 00:15:42.491
你看

00:15:42.491 --> 00:15:45.511
这个是我自己的项目规范是吧

00:15:45.511 --> 00:15:46.691
什么pr

00:15:46.691 --> 00:15:49.151
pr前线运行mpm run

00:15:49.151 --> 00:15:49.771
lint

00:15:49.771 --> 00:15:51.251
这是我个人的一个习惯

00:15:51.251 --> 00:15:54.131
然后你看我们刚刚写的那个全局的应用规范

00:15:54.131 --> 00:15:55.351
是不是也在啊

00:15:55.351 --> 00:15:56.991
这个有限级非常高啊

00:15:56.991 --> 00:15:58.671
就是这你不管签哪个项目

00:15:58.671 --> 00:16:00.131
它都会有这么一个规范

00:16:13.064 --> 00:16:16.304
这个就是我们实际的规范

00:16:16.304 --> 00:16:18.144
好

00:16:18.144 --> 00:16:21.804
这个就是大家可以自己的去写不同的这个规范

00:16:21.804 --> 00:16:22.164
是吧

00:16:22.164 --> 00:16:27.404
然后你还可以去创建这个agency.overload的这么一个MD文件

00:16:27.404 --> 00:16:28.884
然后我们来做一个覆盖

00:16:28.884 --> 00:16:33.124
比如说我们就在这个里面

00:16:33.124 --> 00:16:43.384
修改行为时

00:16:43.384 --> 00:16:47.164
试一下把这个给覆盖一下

00:16:47.164 --> 00:16:49.404
比如说现在是有这么一个

00:16:49.404 --> 00:16:53.924
修改的时候需要在docs里面记录是吧

00:16:53.924 --> 00:16:56.884
那我现在比如说我现在想做一个覆盖

00:16:56.884 --> 00:17:00.044
在uproad里面再加一个东西

00:17:00.044 --> 00:17:01.324
把这句话

00:17:01.324 --> 00:17:04.764
我的call过来

00:17:04.764 --> 00:17:06.764
我现在同样的也是call这个

00:17:06.764 --> 00:17:07.844
然后在这个里面

00:17:07.844 --> 00:17:10.604
然后我现在把这个覆盖一下

00:17:10.604 --> 00:17:13.924
在比如说在logs里面

00:17:13.924 --> 00:17:16.584
在logs里面去记录工具的一个变化

00:17:16.584 --> 00:17:17.784
记到日志里面去

00:17:17.784 --> 00:17:20.444
我们看一下它加载策略是什么

00:17:20.444 --> 00:17:21.844
先退出去

00:17:21.844 --> 00:17:23.224
然后codex

00:17:23.224 --> 00:17:29.044
当前项目开发规范有哪些

00:17:29.044 --> 00:17:47.164
嗯他说这个有编码问题

00:17:47.164 --> 00:17:50.864
看一下他能不能会帮我们解决这个问题啊

00:17:50.864 --> 00:17:53.084
你看是不是覆盖了

00:17:53.084 --> 00:17:55.924
我现在这个优先级更高是吧

00:17:55.924 --> 00:17:58.064
不管你这里写的是DOC什么的

00:17:58.064 --> 00:17:59.124
因为我这个下面

00:17:59.124 --> 00:18:02.184
然后这里写了这个重载了

00:18:02.184 --> 00:18:02.504
是吧

00:18:02.504 --> 00:18:06.364
所以他还是会用这个logs去制写

00:18:06.364 --> 00:18:10.904
这个就是叫agents.overload.md

00:18:10.904 --> 00:18:12.244
他的一个作用

00:18:12.244 --> 00:18:16.484
就是我们想在同一套规范下面

00:18:16.484 --> 00:18:17.544
不同团队

00:18:17.544 --> 00:18:19.244
不同小组

00:18:19.244 --> 00:18:22.104
要单独写一些自己的小规范

00:18:22.104 --> 00:18:23.124
要覆盖一些

00:18:23.124 --> 00:18:25.704
就是在公司的这个规范基础之上

00:18:25.704 --> 00:18:28.104
或者在大团队的规范基础之上

00:18:28.104 --> 00:18:29.704
然后再加我们这个

00:18:29.704 --> 00:18:31.904
小团队的这么一个规范

00:18:31.904 --> 00:18:33.004
那么啊

00:18:33.004 --> 00:18:34.864
比如说这个是公司有很多业务线

00:18:34.864 --> 00:18:36.204
我支付这个线里面

00:18:36.204 --> 00:18:37.744
我有自己的一些规范

00:18:37.744 --> 00:18:42.004
这个就比较适合用这个agency.overall的MD

00:18:42.004 --> 00:18:44.184
所以这个大家根据自己的情况

00:18:44.184 --> 00:18:46.824
去选择不同的这个MD文件啊

00:18:46.824 --> 00:18:49.104
好

00:18:49.104 --> 00:18:51.284
这个就是我们效果的一个验证

00:18:51.284 --> 00:18:54.364
然后包括我们其实也可以去配置一些

00:18:54.364 --> 00:18:56.884
这个团队的一些文档啊

00:18:56.884 --> 00:18:58.424
这个就根据实际需求去了

00:18:58.424 --> 00:18:59.824
调整了啊

00:18:59.824 --> 00:19:02.004
基本上我们用在根目里面

00:19:02.004 --> 00:19:03.244
配这两个的话

00:19:03.244 --> 00:19:04.424
基本上够用啊

00:19:04.424 --> 00:19:05.384
就这两个场景

00:19:05.384 --> 00:19:08.004
基本上按项目去配差不多了

00:19:08.004 --> 00:19:10.724
除非你确实有公司的这个

00:19:10.724 --> 00:19:12.564
级别的一些规范是吧

00:19:12.564 --> 00:19:14.264
那你可以加到这个里面去啊

00:19:14.264 --> 00:19:17.544
这个就是他的一个层级啊

00:19:17.544 --> 00:19:19.064
大家首先要搞清楚这个点

00:19:19.064 --> 00:19:21.944
呃

00:19:21.944 --> 00:19:22.724
然后验证的话

00:19:22.724 --> 00:19:24.404
我们刚刚其实也带大家去验证了

00:19:24.404 --> 00:19:26.864
当然你也可以去执行一些命令啊

00:19:26.864 --> 00:19:29.304
然后去看一下它到底有没有覆盖啊

00:19:29.304 --> 00:19:30.324
这个都是OK的

00:19:30.324 --> 00:19:35.404
那比如说我们经常可能会出现的一个问题是什么呢

00:19:35.404 --> 00:19:37.464
就是大家可以去排查啊

00:19:37.464 --> 00:19:38.904
就是哎

00:19:38.904 --> 00:19:42.284
有时候会发现它这个到底有没有加载是吧

00:19:42.284 --> 00:19:44.624
这个文件里面有没有一些

00:19:44.624 --> 00:19:47.024
就什么都没加载啊

00:19:47.024 --> 00:19:48.384
就看一下到底什么问题

00:19:48.384 --> 00:19:50.024
大家可以执行这个Codex

00:19:50.024 --> 00:19:51.364
Status啊

00:19:51.364 --> 00:19:52.204
去分析一下

00:19:52.204 --> 00:19:54.064
比如说我们在这个里面先退出去

00:19:54.064 --> 00:19:56.144
至今Codex status

00:19:56.144 --> 00:20:00.544
那它这个里面的话就会进入了

00:20:00.544 --> 00:20:02.404
去分析它的一个status

00:20:02.404 --> 00:20:03.864
然后我们在这个里面

00:20:03.864 --> 00:20:07.904
它可以去分析整个工作区的一个状态

00:20:07.904 --> 00:20:10.124
就是比如说它没有加载

00:20:10.124 --> 00:20:11.684
那你可以去检查一下

00:20:11.684 --> 00:20:14.984
看一下这个里面到底有没有问题

00:20:14.984 --> 00:20:15.324
是吧

00:20:15.324 --> 00:20:16.584
你看它这里分析出来

00:20:16.584 --> 00:20:19.164
就是它不是一个Git仓库啊

00:20:19.164 --> 00:20:23.204
所以他在分析有一些这个信息的时候

00:20:23.204 --> 00:20:24.624
他可能就会少一些内容

00:20:24.624 --> 00:20:27.684
所以他可以得出来

00:20:27.684 --> 00:20:29.904
这个到底有没有是不是空目录是吧

00:20:29.904 --> 00:20:30.924
是不是空仓库

00:20:30.924 --> 00:20:32.144
他可以给你分析出来

00:20:32.144 --> 00:20:34.944
然后的话大家会发现啊

00:20:34.944 --> 00:20:37.304
就是你有时候那个配置啊

00:20:37.304 --> 00:20:38.464
就是你写了

00:20:38.464 --> 00:20:39.344
但是他没有生效

00:20:39.344 --> 00:20:41.344
这时候大家就要去检查一下

00:20:41.344 --> 00:20:45.084
我的上一集到底有没有这个啊

00:20:45.084 --> 00:20:48.044
更高层级的一些目录是吧

00:20:48.044 --> 00:20:49.364
有一些MD文件

00:20:49.364 --> 00:20:50.844
是不是也给它覆盖掉了

00:20:50.844 --> 00:20:52.164
那这个里面的话

00:20:52.164 --> 00:20:55.424
就是我们要去检查一下

00:20:55.424 --> 00:20:56.444
就是你会发现

00:20:56.444 --> 00:20:57.284
你加了一个配置之后

00:20:57.284 --> 00:20:57.884
它没有生效

00:20:57.884 --> 00:20:59.244
但是的话

00:20:59.244 --> 00:21:00.604
你的配置加上去了

00:21:00.604 --> 00:21:01.104
没问题

00:21:01.104 --> 00:21:02.644
但是你一执行

00:21:02.644 --> 00:21:03.724
就发现这没生效

00:21:03.724 --> 00:21:04.484
那你就可以看一下

00:21:04.484 --> 00:21:06.084
上级有没有更高的一些

00:21:06.084 --> 00:21:08.944
这个规范

00:21:08.944 --> 00:21:10.444
是不是把它给覆盖掉了

00:21:10.444 --> 00:21:11.884
这个大家可以去检查一下

00:21:11.884 --> 00:21:13.584
就我刚刚提到那几个层级

00:21:13.584 --> 00:21:14.464
一个是全局的

00:21:14.464 --> 00:21:16.404
还有一个是用户级别的

00:21:16.404 --> 00:21:17.804
用户级别就是项目级别的

00:21:17.804 --> 00:21:19.344
项目级别的你要看是

00:21:19.344 --> 00:21:22.324
有没有agents.overall.md文件啊

00:21:22.324 --> 00:21:25.184
所以这个要特别的去检查一下

00:21:25.184 --> 00:21:27.164
然后包括一些这个

00:21:27.164 --> 00:21:29.124
你加了一些备用文件名了

00:21:29.124 --> 00:21:30.724
你会发现他也没有加载

00:21:30.724 --> 00:21:32.144
那你就要检查一下

00:21:32.144 --> 00:21:34.164
哎路径对不对啊是吧

00:21:34.164 --> 00:21:37.504
然后这个配置有没有生效啊

00:21:37.504 --> 00:21:39.264
其实大家遇到这个问题之后啊

00:21:39.264 --> 00:21:41.104
如果说你确实排查不出来的话

00:21:41.104 --> 00:21:43.664
你可以把你的一个配置丢给codex

00:21:43.664 --> 00:21:44.984
让他自己去分析

00:21:44.984 --> 00:21:46.524
排查到底是哪里出错了

00:21:46.524 --> 00:21:48.704
它的分析能力很强的

00:21:48.704 --> 00:21:50.224
它一看可能你就知道

00:21:50.224 --> 00:21:52.124
你这个确实哪里参数拼的有问题

00:21:52.124 --> 00:21:53.564
比如说路径写的有问题

00:21:53.564 --> 00:21:53.944
是吧

00:21:53.944 --> 00:21:55.704
或者一些其他的参数写的有问题

00:21:55.704 --> 00:21:57.424
它马上就可以给你分析出来

00:21:57.424 --> 00:21:59.144
这个里面的话

00:21:59.144 --> 00:22:02.304
我们可以利用Codex这个分析能力

00:22:02.304 --> 00:22:03.404
帮我们去做很多事情

00:22:03.404 --> 00:22:06.804
然后包括一些指令被截断了

00:22:06.804 --> 00:22:07.784
也就是说大家

00:22:07.784 --> 00:22:09.444
你写了一堆东西是吧

00:22:09.444 --> 00:22:10.204
写了很多

00:22:10.204 --> 00:22:11.944
写了几百行几千行

00:22:11.944 --> 00:22:13.584
你发现最后执行的话

00:22:13.584 --> 00:22:15.144
可能就识别到了几百行

00:22:15.144 --> 00:22:18.004
那这个的话就大家要把这个

00:22:18.004 --> 00:22:19.224
有一个参数啊

00:22:19.224 --> 00:22:20.524
叫project dockmarks

00:22:20.524 --> 00:22:23.984
但是这个参数不是越大越好啊

00:22:23.984 --> 00:22:25.044
你改的越大的话

00:22:25.044 --> 00:22:27.924
对于token的这个成本消耗也是比较大的

00:22:27.924 --> 00:22:30.424
就相当于我们对话都没开始呢

00:22:30.424 --> 00:22:32.044
一开始就给你加了一堆内容去了

00:22:32.044 --> 00:22:33.144
下到上下往里面去了

00:22:33.144 --> 00:22:36.284
这样就会导致我们整个每次对话的时候

00:22:36.284 --> 00:22:38.384
成本就会上升

00:22:38.384 --> 00:22:42.524
所以agency.md里面绝对不是内容越多越好啊

00:22:42.524 --> 00:22:44.524
而是越精简越好

00:22:44.524 --> 00:22:46.124
越核心越好

00:22:46.124 --> 00:22:46.804
这样的话

00:22:46.804 --> 00:22:48.384
因为它的目标

00:22:48.384 --> 00:22:50.084
它就是去用来定规范的

00:22:50.084 --> 00:22:51.104
你不要把一些

00:22:51.104 --> 00:22:52.384
无关紧要的内容

00:22:52.384 --> 00:22:53.804
写到agency.md里面去

00:22:53.804 --> 00:22:55.164
这样反而可能会

00:22:55.164 --> 00:22:58.404
导致这个上下文超长

00:22:58.404 --> 00:22:58.704
是吧

00:22:58.704 --> 00:23:00.744
或者是它出现截断的这个问题

00:23:00.744 --> 00:23:02.244
就明明你写这个指令

00:23:02.244 --> 00:23:03.544
你发现它就是没有执行

00:23:03.544 --> 00:23:05.044
那是因为它被截断了

00:23:05.044 --> 00:23:05.844
都没加载进来

00:23:05.844 --> 00:23:07.044
肯定就没法执行

00:23:07.044 --> 00:23:09.884
然后包括这个配置

00:23:09.884 --> 00:23:10.364
是吧

00:23:10.364 --> 00:23:10.744
配置档

00:23:10.744 --> 00:23:11.964
就是我们当前

00:23:11.964 --> 00:23:13.404
大家会发现

00:23:13.404 --> 00:23:15.704
就是你我们已经在这个当前的

00:23:15.704 --> 00:23:16.924
用户目录下

00:23:16.924 --> 00:23:20.244
这个.codex目里面改了这个agents.md了

00:23:20.244 --> 00:23:22.084
你发现他就是不生效

00:23:22.084 --> 00:23:23.864
那这时候你可以去看一下

00:23:23.864 --> 00:23:25.604
当前你有没有设置过环境变量

00:23:25.604 --> 00:23:28.164
把codex这个目录是吧

00:23:28.164 --> 00:23:29.984
你给他设置到其他地方去了

00:23:29.984 --> 00:23:33.064
所以导致他整个逻辑的方法

00:23:33.064 --> 00:23:34.144
就是没有被执行到

00:23:34.144 --> 00:23:36.324
这个也是大家需要去确认的

00:23:36.324 --> 00:23:39.564
我们要把整个逻辑给他去确认一下

00:23:39.564 --> 00:23:42.684
所以这个里面是一个非常关键的点

00:23:42.684 --> 00:23:44.604
就是你这些目录你最基本的

00:23:44.604 --> 00:23:46.084
你要做一个确认

00:23:46.084 --> 00:23:46.844
是吧

00:23:46.844 --> 00:23:49.224
那这样就不会出现一些

00:23:49.224 --> 00:23:50.524
细节的一些问题

00:23:50.524 --> 00:23:54.364
然后是agents.md到底应该怎么来写呢

00:23:54.364 --> 00:23:54.964
是吧

00:23:54.964 --> 00:23:57.104
那大家可以写哪些内容呢

00:23:57.104 --> 00:23:58.444
我这里给他看一个例子

00:24:14.039 --> 00:24:14.999
前段项目啊

00:24:14.999 --> 00:24:16.799
你看前段项目就是这套规范

00:24:16.799 --> 00:24:18.739
大家如果不知道怎么去写的话

00:24:18.739 --> 00:24:19.879
其实很简单啊

00:24:19.879 --> 00:24:21.439
很简单怎么来干呢

00:24:21.439 --> 00:24:23.039
你可以打开这个codex啊

00:24:23.039 --> 00:24:27.499
我这个是一个这个插件版的codex啊

00:24:27.499 --> 00:24:30.279
你就直接这么跟他说啊

00:24:30.279 --> 00:24:36.079
请帮我分析一下当前项目结构

00:24:36.079 --> 00:24:43.439
然后输出一份agents.md

00:24:43.439 --> 00:24:48.279
当前项目结构和代码规范

00:24:49.439 --> 00:24:51.839
然后输出一份agentsmd就完了

00:24:51.839 --> 00:24:52.879
就很简单啊

00:24:52.879 --> 00:24:56.539
就大家你直接让AI来帮你分析输出一份

00:24:56.539 --> 00:24:58.139
然后看他怎么写的

00:24:58.139 --> 00:25:01.939
然后你再去参考再去调整是吧

00:25:01.939 --> 00:25:04.339
这也是一种学习方式啊

00:25:04.339 --> 00:25:07.339
就让AI他肯定比你写的好啊

00:25:07.339 --> 00:25:08.639
写的更加的完善

00:25:08.639 --> 00:25:10.339
所以你看他怎么写就完事了

00:25:10.339 --> 00:25:13.699
但是我这里面已经有了

00:25:13.699 --> 00:25:14.899
我就不重新生成了

00:25:14.899 --> 00:25:16.479
我只是给大家讲一下这个方法

00:25:16.479 --> 00:25:17.939
因为生成这个东西的话

00:25:17.939 --> 00:25:19.379
他也要去做各种分析

00:25:19.379 --> 00:25:21.279
也比较时间比较久

00:25:21.279 --> 00:25:23.539
所以这个大家可以自己去生成

00:25:23.539 --> 00:25:25.819
我这个就是用AI生成的

00:25:25.819 --> 00:25:28.699
你看他这个里面就帮我分析出来了

00:25:28.699 --> 00:25:30.759
我这个用了这个Codex

00:25:30.759 --> 00:25:32.419
Harness Engineering的一些

00:25:32.419 --> 00:25:34.059
这个实现是吧

00:25:34.059 --> 00:25:35.739
然后我的项目结构

00:25:35.739 --> 00:25:36.479
有POM

00:25:36.479 --> 00:25:37.759
有Admin模块

00:25:37.759 --> 00:25:38.779
有Framework

00:25:38.779 --> 00:25:39.819
有System

00:25:39.819 --> 00:25:40.959
有UI

00:25:40.959 --> 00:25:42.259
这个UI是个前段项目

00:25:42.259 --> 00:25:43.859
然后它的一个工程规范

00:25:43.859 --> 00:25:45.959
就是一些渣滑包

00:25:45.959 --> 00:25:46.419
是吧

00:25:46.419 --> 00:25:47.819
然后还有一些买白利斯

00:25:47.819 --> 00:25:50.779
等等的一些细节是怎么样的

00:25:50.779 --> 00:25:53.239
包括我们这个Harness Engineer

00:25:53.239 --> 00:25:55.359
它的一个工作流应该是怎么样的

00:25:55.359 --> 00:25:56.559
这个就是我之前

00:25:56.559 --> 00:25:59.239
落地的一套Harness Engineer

00:25:59.239 --> 00:26:02.699
包括它的一些核心的后段命令

00:26:02.699 --> 00:26:03.799
这个打包的是吧

00:26:03.799 --> 00:26:04.459
编译的

00:26:04.459 --> 00:26:06.019
这都是非常核心的一个命令

00:26:06.019 --> 00:26:07.919
然后数据库与配置

00:26:07.919 --> 00:26:09.199
质量门槛

00:26:09.819 --> 00:26:12.859
就是这个就是做一些执行啊

00:26:12.859 --> 00:26:14.739
要去确认的一些点

00:26:14.739 --> 00:26:16.759
这个是后端的

00:26:16.759 --> 00:26:18.799
那前端的话其实也是一样的

00:26:18.799 --> 00:26:20.799
前端他特殊的规范的话

00:26:20.799 --> 00:26:22.959
就是无非也就是结构啊

00:26:22.959 --> 00:26:23.239
是吧

00:26:23.239 --> 00:26:24.459
比如技术战是什么

00:26:24.459 --> 00:26:25.919
是VU还是React

00:26:25.919 --> 00:26:27.999
然后一些啊

00:26:27.999 --> 00:26:29.139
包是吧

00:26:29.139 --> 00:26:30.019
一些文件奖

00:26:30.019 --> 00:26:31.539
他应该放什么组件

00:26:31.539 --> 00:26:33.199
他的编码规范啊

00:26:33.199 --> 00:26:33.599
是什么

00:26:33.599 --> 00:26:35.779
然后JavaScript的

00:26:35.779 --> 00:26:37.799
他的编码风格应该是什么样的

00:26:37.799 --> 00:26:39.439
包括一些前端命令

00:26:39.439 --> 00:26:40.599
MPM的一些命令

00:26:40.599 --> 00:26:42.219
包括连条的一些约束

00:26:42.219 --> 00:26:44.519
这个就是前端

00:26:44.519 --> 00:26:48.399
这个agents.md需要关注一点

00:26:48.399 --> 00:26:50.859
所以大家你说怎么写呢

00:26:50.859 --> 00:26:52.219
如果你也不知道怎么去写

00:26:52.219 --> 00:26:52.719
很简单

00:26:52.719 --> 00:26:54.099
你就让AI帮你去生神

00:26:54.099 --> 00:26:55.559
让他去分析

00:26:55.559 --> 00:26:57.599
大家一定要加这个分析这两个字

00:26:57.599 --> 00:26:58.559
就是你不要说

00:26:58.559 --> 00:27:00.519
你就直接帮我写一份agents.md

00:27:00.519 --> 00:27:01.839
但是你没有提到

00:27:01.839 --> 00:27:03.519
让他分析当前项目

00:27:03.519 --> 00:27:05.799
但他还是会分析当前项目的

00:27:05.799 --> 00:27:08.119
所以你最好写清楚一点

00:27:08.119 --> 00:27:10.999
就分析当前项目结构跟代码规范

00:27:10.999 --> 00:27:12.039
这样的话

00:27:12.039 --> 00:27:15.099
他肯定会把那些目录给他扫一遍

00:27:15.099 --> 00:27:15.419
是吧

00:27:15.419 --> 00:27:17.399
所以这个就是一个

00:27:17.399 --> 00:27:20.179
使用习惯的这个提示词

00:27:20.179 --> 00:27:21.739
大家可以做一些优化

00:27:21.739 --> 00:27:23.319
所以

00:27:23.319 --> 00:27:25.759
agents.md里面大家就可以看到

00:27:25.759 --> 00:27:27.519
你看基本上是100行以内

00:27:27.519 --> 00:27:28.359
是吧

00:27:28.359 --> 00:27:30.779
并且的话写的都是一些关键内容

00:27:30.779 --> 00:27:33.039
就是一些非常核心的模块

00:27:33.039 --> 00:27:34.259
命令啊

00:27:34.259 --> 00:27:37.559
然后配置啊等等的是吧

00:27:37.559 --> 00:27:38.639
包括结构

00:27:38.639 --> 00:27:40.199
但是非常核心的内容

00:27:40.199 --> 00:27:41.819
就大家后段项目

00:27:41.819 --> 00:27:43.839
你就可以参考这个去做啊

00:27:43.839 --> 00:27:44.459
就这个规范

00:27:44.459 --> 00:27:45.279
你可以参考一下

00:27:45.279 --> 00:27:46.559
如果是前端的话

00:27:46.559 --> 00:27:48.839
你也可以去看一下啊

00:27:48.839 --> 00:27:51.779
包括其实我们之前啊

00:27:51.779 --> 00:27:54.359
这里写了一个小游戏是吧

00:27:54.359 --> 00:27:57.619
这个是我之前写的一个小游戏的这么一个

00:27:57.619 --> 00:28:00.019
pacent.md是吧

00:28:00.019 --> 00:28:00.799
就是让他分析

00:28:00.799 --> 00:28:02.659
我这个里面用python写的啊

00:28:02.659 --> 00:28:04.119
你看这个就是python的一套

00:28:04.119 --> 00:28:06.319
agent.md的描述是吧

00:28:06.319 --> 00:28:09.299
所以怎么来写啊

00:28:09.299 --> 00:28:10.799
规范是怎么样的

00:28:10.799 --> 00:28:12.779
这里我也给大家说一下技巧

00:28:12.779 --> 00:28:13.939
首先啊

00:28:13.939 --> 00:28:14.739
大家不知道怎么写

00:28:14.739 --> 00:28:17.039
你可以参考一下我这个规范是吧

00:28:17.039 --> 00:28:18.799
我这个的话也是用Codex分析

00:28:18.799 --> 00:28:19.419
让它写出来

00:28:19.419 --> 00:28:22.559
然后大家也可以自己用Codex去分析出来

00:28:22.559 --> 00:28:24.119
然后在此基础之上啊

00:28:24.119 --> 00:28:25.639
这个是可以改的啊

00:28:25.639 --> 00:28:26.719
就比如说AI

00:28:26.719 --> 00:28:29.279
它有可能也没有分析出来啊

00:28:29.279 --> 00:28:32.699
这个真实的一个情况啊

00:28:32.699 --> 00:28:34.199
它有可能是分析错了

00:28:34.199 --> 00:28:35.599
所以这个就需要我们

00:28:35.599 --> 00:28:37.659
作为开发人员你要去纠正嘛

00:28:37.659 --> 00:28:40.939
就是AI他也不能百分百说就没有问题了

00:28:40.939 --> 00:28:44.559
所以这里面大家需要自己去看一下啊

00:28:44.559 --> 00:28:46.119
就是有问题你就调一下

00:28:46.119 --> 00:28:50.079
因为有一些规范的话

00:28:50.079 --> 00:28:51.479
AI他分析出来的话

00:28:51.479 --> 00:28:53.859
他的描述会有点怪怪的啊

00:28:53.859 --> 00:28:57.839
就是没有我们自己作为开发人员那种理解能力啊

00:28:57.839 --> 00:29:00.179
就是他可能还不够强啊

00:29:00.179 --> 00:29:02.219
当然基本上啊

00:29:02.219 --> 00:29:03.379
这个很准啊

00:29:03.379 --> 00:29:04.099
大家可以去试一下

00:29:04.099 --> 00:29:05.079
看你用什么模型

00:29:05.079 --> 00:29:06.379
比如说你用Cloud的模型

00:29:06.379 --> 00:29:07.959
或者用Codex 5.3

00:29:07.959 --> 00:29:08.819
它的效果很好

00:29:08.819 --> 00:29:10.279
但是你用其他模型的话

00:29:10.279 --> 00:29:11.719
这个就不敢保证了

00:29:11.719 --> 00:29:13.879
所以这个回头大家可以去试一下