TARE-Learn/企业培训3-1逐字稿/郑州企业培训 3-1 第一天 上.md

---
source: get-note
note_id: "1912686771000116312"
note_type: "local_audio"
created: 2026-06-13 13:26:08
synced: 2026-06-15 15:54:21
link: https://biji.com/note/1912686771000116312
tags: [get笔记, 郑州企业培训, 公开分享, "AI培训", "AI编程"]
---

# 2026年06月12日 09点03分.m4a

### 📑 智能总结

#### 录音信息
- **时长**：约 2 小时 57 分钟
- **参与人数**：约 6 人
- **内容类型**：培训分享

#### 录音总结
本次为企业内部AI编程工具培训，核心围绕AI辅助研发流程，以陌生代码库理解、知识库构建为核心，讲解了AI在企业研发中的定位、使用方法与协作规则，解答了老项目适配、乱码等实际问题，明确了团队级AI协作的落地路径。

**培训整体安排与要求**
* **培训核心目标**：要求今年AI编码替代30%的研发工作量，行管中心将配合制定相关考核指标，董事会将今年AI编程培训列为重要事项。
* **课程基础信息**：本次培训共36课时，合计6天，可根据实际情况延长培训时长；要求参训人员签到，培训时间为上午9点到12点、下午2点到5点，中间预留10分钟休息时间。
* **讲师相关要求**：本次培训的两位讲师姬老师、徐老师均为大厂在职资深全栈工程师，同时是外部技术主播，要求参训人员不得拍摄照片对外宣传，避免扩散讲师个人信息。

**AI编程发展现状与普及情况**
* **行业普及数据**：根据2025年Stack Overflow权威年度报告，目前已有84%的开发者使用AI编程工具，近一半的专职开发者每天都会使用AI工具，还有大量非开发人员通过AI工具进入开发领域。
* **发展阶段划分**：AI编程从最初Github Copilot的代码补全工具，发展到IDE集成对话框的对话式开发，目前已经进入agent阶段，可打通从需求计划、代码修改、测试、上线验证到提交的全链路。
* **人机分工定位**：目前AI无法完全替代开发者，仅能替代重复性编码、低上下文任务、模板化代码生成；开发者需要转向业务判断、架构取舍、安全边界把控、质量责任把控与上线流程负责。

**AI对研发工作内容的改变**
* **工作内容转型方向**：开发者需要适应新的工作内容，包括清晰描述任务让AI理解、给AI提供有效上下文、拆解问题、验证AI输出结果、推进结果工程化。
* **体系变革方向**：AI时代带来的是整个软件研发交付体系的改变，未来开发者的差距不在于会不会用AI，而在于能否把AI嵌入标准研发流程，最终腾出精力聚焦业务判断。
* **效率提升定位**：AI提效不是压缩团队规模让少数人卷996，而是将原来10天交付的项目缩短到2天，让团队有更多精力去拓展其他业务。

**使用AI理解陌生代码库的核心方法**
* **核心解决痛点**：企业研发中大多数项目是接手的旧项目，没有AI时开发者只能通过手册、需求文档、注释了解项目，通常只熟悉自己修改的部分，对整体架构不清晰。
* **本次训练案例**：本次选择若依项目作为训练案例，原因是若依是非常标准的后端管理系统框架，支持前后端分离与不分离版本，持续保持技术更新，采用标准三元权限设计，是中小型公司做管理系统的首选框架。
* **核心训练目标**：训练内容包括查看项目整体结构、找到功能入口、追踪调用链路、验证AI输出依据；通过查看AI思考链中的文件引用，可判断AI输出结果是否可信。

**AI研发专用IDE（翠）的使用要求**
* **重新开发IDE的原因**：现有成熟IDE都是以插件形式集成AI，只有自研IDE才能打通模型底层能力，实现agent全链路循环，因此需要开发者学习使用新的AI IDE工具。
* **今日训练任务**：今日使用翠完成的任务包括理解若依前后端目录、查找登录与菜单功能入口、分析动态路由生成与权限角色、输出AI可读取的代码理解报告。
* **人工校验要求**：开发者需要人工校验AI输出，包括角色权限设计是否合理、数据权限范围是否正确、接口开放规则是否合规、敏感操作是否影响原有功能、生成结果是否可上线、权限变更是否影响现有功能。

**项目AI知识库的构建规则**
* **构建核心意义**：团队协作开发中，不需要每个人都让AI重新分析一遍整个项目，只需要由一个人构建基于项目的wiki知识库，后续所有人都基于已有的知识库查询即可，可大幅减少token消耗与算力浪费。
* **知识库更新规则**：只有当项目结构、功能模块发生调整时，才需要更新知识库，每次交付版本打tag时，需要保证代码和知识库版本一致，避免出现文档和代码对不上的问题。
* **协作落地方式**：构建完成的知识库可提交到git，所有协作者拉取代码即可同步；也可以部署到公司的远程知识库服务器，通过自定义mcp工具远程查询。

**token消耗的影响因素与优化方法**
* **消耗分类与价格**：token消耗分为上行token（用户提问的关键词）和下行token（AI输出内容），两类token价格不同，因此提问需要尽量简短清晰描述需求。
* **知识库对消耗的影响**：如果问题可以在已构建的知识库中找到答案，AI不需要重新全局搜索代码，可大幅缩短思考时间，减少token消耗；只有知识库没有的内容，才需要重新搜索代码，消耗更多token。
* **本地搜索的补充作用**：如果是已经落地到本地的md格式知识库，也可以通过本地搜索完成简单查询，不需要每次都调用大模型消耗token。

**AI输出幻觉的识别与规避方法**
* **幻觉产生原因**：即使是当前的旗舰模型，依然存在幻觉问题，尤其是分析调用链路时，AI容易基于训练数据给出不符合当前项目实际的结果。
* **幻觉验证标准**：验证AI输出是否可信的两个核心标准，一是是否符合开发者对项目的已有理解，二是是否符合项目代码事实；如果AI提到的文件在项目中不存在，基本可以判定为幻觉，需要进一步追问。
* **可信输出判断标准**：可信的AI输出需要包含四个核心要素，分别是准确的文件路径、清晰的调用关系、明确的前后端区分、标注出不确定点，满足这四个条件的输出可信度较高。

**合格AI知识库的文档规范**
* **信息密度要求**：文档描述要足够具体，避免宽泛描述，比如写“权限模块用于进行权限控制”信息密度过低，AI还是需要重新搜索；正确写法是“权限和菜单模块负责用户登录后加载角色、权限字符和动态路由，控制页面显隐”，信息密度更高。
* **标准内容结构**：一个合理的知识库需要包含每个模块的职责、核心对象、目录和文件结构、核心调用路径、权限风险、日志操作风险；改造建议和不确定结论可根据需求选择是否添加。
* **风险点与改造建议要求**：风险点需要写明具体场景，不能笼统说“权限有风险”；改造建议需要分优先级（P0到P3），开发者需要评估改造的风险和边际收益，决定是否执行改造。

**AI智能体（Agent）的配置方法**
* **智能体本质定义**：智能体本质就是一套核心提示词+工具偏好+规范约束，针对不同场景设置不同智能体，可让AI输出更符合需求。
* **配置层级规则**：可分为全局通用配置和项目级配置，企业统一的代码规范、通用规则可设置为全局配置，针对特定项目的特殊要求可设置为项目级配置。
* **智能体与Skill的区别**：如果某套提示词是你每次使用都需要的，就放到智能体里；如果只是特定场景使用，用Skill即可，二者本质都是提示词，效果差异很小。

**老项目适配AI开发的问题解答**
* **中文乱码问题解决**：老项目出现中文乱码，通常是因为老项目使用GB/GBK编码，而AI IDE默认使用UTF-8编码；解决方法是先将项目无损迁移到UTF-8编码，可先迁移到无中文的编码格式，再转成UTF-8即可解决。
* **老项目添加新功能失败原因**：老项目添加新功能效果差，核心原因是AI没有获得足够的项目上下文，不知道项目的业务逻辑和执行逻辑。
* **工程化优化方法**：可以采用渐进式开发，每个模块/文件夹下添加agent.md，约定当前模块的逻辑规则，不需要一次让AI理解整个超大项目，每次只聚焦一个模块修改即可；同时将分散的业务文档整理到AI的文档集中，让AI可以查询到代码之外的业务规则。

### 📅 章节概要
[00:00:00](https://getnotes.seek:0) **培训开场与整体安排说明**

本次培训为企业内部AI编程培训，明确今年要求AI编码替代30%研发工作量，行管中心将配合制定考核指标，董事会将本次培训列为年度重要事项。培训总课时为36课时共6天，可根据实际情况调整延长，要求参训人员签到；培训时间为上午9点到12点、下午2点到5点，中间预留10分钟休息时间。本次培训两位讲师姬老师、徐老师均为大厂在职资深全栈工程师，同时是外部技术主播，要求参训人员不得拍摄照片对外宣传，避免扩散讲师个人信息，介绍完成后邀请赵总开场。

[00:01:55](https://getnotes.seek:115) **培训发起背景说明**

从5月到7月底，团队已经集中试用AI编程工具一个月，目前大家已经掌握基本使用方法，但还存在不会系统使用、不会合理控制token消耗提升效率的问题。因此邀请专业讲师开展本次系统培训，帮助大家提升AI工具的使用效果，介绍完成后鼓掌欢迎两位讲师开始授课。

[00:03:20](https://getnotes.seek:200) **AI编程发展现状与人机分工讲解**

本次上午课程先讲解AI编程的发展，第一天核心内容是使用AI理解陌生代码库，这是企业研发中最常见的场景——多数开发者接手的都是前人维护的旧项目，很少从零开始开发新项目。根据2025年Stack Overflow权威年度报告，目前已有84%的开发者使用AI编程工具，近一半专职开发者每天都会使用，AI普及速度远超预期。AI目前无法完全替代开发者，仅能替代重复性编码、低上下文任务、模板化代码生成，开发者需要转向业务判断、架构取舍、安全边界把控、质量责任把控，工作内容会发生变化，但不会直接导致失业。

[00:07:20](https://getnotes.seek:440) **AI时代研发工作内容转型讲解**

AI时代开发者的工作内容需要转型：需要学会描述清晰任务让AI理解，适应大模型的输入习惯；学会给AI提供有效上下文，避免无用上下文干扰AI输出；学会拆解问题；学会验证AI输出结果，推进AI结果的工程化。AI带来的是整个软件研发交付体系的改变，未来的差距不在于会不会用AI，而在于能否把AI嵌入标准研发流程，最终腾出精力聚焦业务判断，提升产品的用户体验。

[00:16:32](https://getnotes.seek:992) **陌生代码库理解的核心内容讲解**

本次第一天先讲解陌生代码库的理解，核心内容包括四个部分：一是压缩AI生成范围，避免AI无意义修改原有代码，比如将原有if else无脑改成switch case，这类修改没有实际收益；二是沉淀团队共享的项目知识库，避免每个人都重复让AI分析整个项目，减少不必要的token消耗；三是选择若依项目作为训练案例，因为若依是标准的后端管理系统框架，符合大多数企业的使用场景；四是AI提效的核心是理解快、交接快、定位快、风险暴露早、知识沉淀快，最终缩短项目交付周期，而非压缩团队规模。

[00:22:32](https://getnotes.seek:1352) **AI专用IDE（翠）的开发背景讲解**

现有成熟IDE都是以插件形式集成AI，字节、谷歌等大厂都基于开源VS Code自研AI IDE，核心原因是只有自研IDE才能打通模型底层能力，实现agent的全链路循环，因此即使开发者已经有习惯的旧IDE，也需要学习使用新的AI IDE工具。代码和业务是两个维度：代码只是交付载体，可使用的功能模块才是对企业有价值的内容，AI擅长写代码，但不了解业务逻辑，业务判断依然需要开发者完成，翠只能帮开发者理解当前代码的开发方式，不能帮开发者做业务决策。

[00:26:49](https://getnotes.seek:1609) **首日训练任务与人工校验要求说明**

今日使用翠完成的训练任务包括：理解若依的前后端目录结构、查找登录和菜单功能的入口文件、分析动态路由生成逻辑与权限角色设计、让AI输出符合AI读取习惯的代码理解报告。开发者需要完成人工校验，校验内容包括：角色权限设计是否合理、数据权限范围是否正确、接口是否应该开放、敏感代码删除是否影响原有功能、AI生成结果是否可以上线、权限变更是否影响现有功能。强调不能把重大决策完全交给AI或大模型，必须经过人工校验。

[00:31:04](https://getnotes.seek:1864) **若依项目AI分析实操演示**

本次演示使用若依带微服务的前后端分离版本，微服务项目对AI的上下文能力要求更高，更能考验开发者对AI的使用能力。翠更新后已经将原有的builder和mcp合并为agent，支持普通对话模式和agent模式，仅了解代码库使用普通对话模式即可。AI分析项目会先读取项目的pom文件，通过配置文件了解项目整体架构，再逐步深入读取对应模块的代码，通过提示词限制读取范围，只读取我们需要分析的权限模块，不会读取CRM、ERP等无关模块。

[00:40:07](https://getnotes.seek:2407) **若依权限体系讲解与知识库落地说明**

若依采用标准的三元权限体系：用户绑定角色，角色授权菜单，菜单携带权限；如果有部门分组，可增加用户-部门-角色的绑定逻辑。权限分为三个层级：页面权限控制用户能否进入页面、按钮权限控制按钮是否显示、数据权限控制用户能看到哪些数据，其中数据权限是最重要的，需要和角色绑定，做好角色数据隔离，不能默认超级管理员拿到所有数据。如果要落地知识库，可让AI生成MD文档，手动维护一份团队共享的知识库，作为项目资产，后续修改代码后需要同步更新知识库，避免文档和代码对不上。

[00:44:12](https://getnotes.seek:2652) **AI分析结果输出与知识库演示**

AI分析完成后会输出项目信息，包括项目使用的框架、技术版本、项目模块划分、权限体系设计、核心库表设计，内容基本符合若依的实际设计。如果更新了项目的角色配置，需要同步更新知识库，否则会出现AI读取的知识库信息和代码对不上的问题：聪明的AI会询问以哪个为准，不够聪明的AI会直接以代码为准，构建知识库的意义就不存在了。修改项目的正确流程是：先让AI基于现有知识库生成修改方案，修改完成代码后再更新知识库，保证文档和代码一致。

[00:55:28](https://getnotes.seek:3328) **企业文档格式适配问题讨论**

有参训人员提问：企业有标准化的Word格式变更方案要求，AI生成的MD文档能不能逆向转换为符合要求的Word文档，能不能直接用Word替代MD作为AI知识库。讲师解答：MD文档样式简单、结构清晰、信息密度远高于带样式的Word文档，更适合AI读取；如果需要符合企业格式要求的Word，可以用专门的skill解析MD文字内容，套入企业标准样式生成Word，也可以将现有Word文档转换为MD供AI读取，这个问题可以后续在实战部分详细讲解。

[00:17:07](https://getnotes.seek:1027) **token消耗与知识库协作问题答疑**

有参训人员提问token消耗和知识库协作的问题，讲师解答：token分为上行和下行，都会消耗，已构建的知识库可以大幅减少重复搜索带来的token消耗；知识库落地后提交到git，所有协作者拉取即可同步，也可以部署到公司远程知识库服务器，通过自定义mcp工具查询，落地方式可根据项目实际情况选择。因为网络卡顿，约定十点半休息十分钟，十点四十继续开始。

[00:28:02](https://getnotes.seek:1682) **休息期间问题收集**

休息期间有参训人员提前提出问题：一是AI修改代码后会导致老项目的中文注释乱码，修改后无法恢复只能重写；二是AI构建知识库等待时间太长，容易分散参训人员注意力。讲师和组织者约定，将问题提前记录，后续统一答疑，不打乱授课节奏，同时调整授课方式，AI运行的时候继续讲解PPT内容，避免大家等待。

[00:37:37](https://getnotes.seek:2257) **休息后开场与知识库基础认知澄清**

十点四十准时继续课程，先澄清对知识库的认知：知识库不需要复杂的向量数据库，也不需要对MD文档做向量化处理，仅仅是记录项目关键信息的MD文档即可，实现成本很低。针对文档和代码不同步的问题，可在每个版本打tag的时候，保证代码和知识库对应同一个tag，每次版本更新都同步更新知识库，就能避免文档代码不一致的问题。

[00:40:17](https://getnotes.seek:2417) **AI输出幻觉问题讲解**

即使是当前的旗舰大模型，依然存在幻觉问题，AI很容易给出不符合当前项目实际的结论，尤其是分析调用链路的时候。判断幻觉的两个核心标准：一是是否符合开发者对项目的已有理解，二是是否符合项目的代码事实；如果AI提到的文件在项目中不存在，基本就是幻觉，需要进一步追问。分辨幻觉的方法是先抽取已经人工审核确认的代码事实到知识库，再基于知识库扩展问题，就能大幅降低幻觉的影响。

[00:51:05](https://getnotes.seek:3065) **调用链路分析与验证方法讲解**

如果只构建了后端知识库，没有构建前端知识库，AI会自动触发前端项目分析，完成后再输出调用链路结果，开发者需要人工审核结果是否可信。可信的AI输出需要满足四个要求：准确的文件路径、清晰的调用关系、明确的前后端区分、标注出不确定点，满足这四个条件的输出可信度较高。可以将AI输出和实际项目文件对比，也可以将AI输出再输入到前端项目的AI对话框中，通过二次验证确认结果是否正确。

[02:08:15](https://getnotes.seek:7695) **AI知识库文档规范讲解**

一个合理的AI知识库需要包含：每个模块的职责、核心对象、目录和文件结构、核心调用路径、权限风险、日志操作风险，改造建议和不确定结论可按需添加。文档描述需要提高信息密度，避免宽泛描述，要具体说明模块的作用，方便AI快速定位。风险点需要写明具体的风险场景，改造建议需要分P0到P3的优先级，开发者需要评估改造的风险和边际收益，决定是否执行改造。

[02:14:25](https://getnotes.seek:8065) **提示词与智能体配置讲解**

有参训人员提问思考过程的配置，以及是否会增加token消耗，讲师解答：添加约束规则一定会增加token消耗，需要开发者平衡token成本和输出可用性，两种思路（添加约束控制输出/通过多轮对话调整输出）都可行。通用的约束规则包括要求输出简洁、深度分析、渐进式开发、强制使用中文、git版本回溯要求等。规则可分为全局通用规则和项目级规则，全公司统一的规范可设置为全局规则，项目特殊要求可设置为项目级规则。

[02:21:14](https://getnotes.seek:8474) **智能体与MCP的概念讲解**

智能体本质就是一套核心提示词+工具偏好+规范约束，针对不同角色（产品经理、架构师等）设置不同的智能体，可让AI输出更符合需求。Skill和MCP都可以调用工具，二者的区别是：Skill只能在当前对话中调用，MCP可以对外输出为服务，在多个场景中调用。关键词提示词的优先级高于智能体自带的规则，即使使用了智能体，额外添加的提示词依然会生效。只要项目架构或代码没有变动，不需要频繁重新生成知识库，只需要在发生变动时触发更新即可。

[02:43:25](https://getnotes.seek:9805) **老项目适配问题答疑**

有参训人员提问：十来年的老项目，使用AI添加新功能经常把项目搞坏，从零开发新功能没问题，但老项目改造一直不成功，还会出现中文乱码问题。讲师解答：中文乱码是因为老项目使用GB/GBK编码，AI IDE默认使用UTF-8，解决方法是先将项目无损迁移到UTF-8编码即可。老项目改造效果差是因为AI没有获得足够的项目上下文，不知道项目的业务逻辑，可采用渐进式开发，每个模块添加单独的agent.md约束当前模块的逻辑，一次只改一个模块，逐步完善AI对项目的认知。

[02:51:29](https://getnotes.seek:10289) **老项目问题补充解答**

补充解答老项目问题：老项目很多业务流程是口口相传，文档不齐，AI只能靠猜，因此效果差，本质问题是如何把业务流程整理成AI可读的信息，这和新人接手项目的问题是一样的，新人能跑通，AI就能跑通。可以把分散的业务文档整理到AI的文档集中，让AI可以查询到代码之外的业务规则，AI就像一个新实习生，需要开发者逐步引导，才能逐步提升工作效率。解答完成后到午餐时间，约定下午两点在本会议室继续开始培训。

### ✨ 金句精选

- “AI能替你写代码，但没法替你去负责。你最后交付的永远是一个可用的功能。” (战略洞见)
- “未来的差距不是说我们会不会用AI，而是说能不能把AI嵌入标准的研发流程。” (战略洞见)
- “AI它擅长的是写代码，而不是说去了解你的业务。” (战略洞见)
- “一个可信的AI输出，一定包含准确的文件路径、清晰的调用关系、明确的前后端区分、标注出的不确定点。” (方法技巧)
- “AI就像一个新实习生，需要开发者逐步引导，才能逐步提升工作效率。” (思考启发)
- “AI提效并不是说我们原来十人团队有了AI变成两人，然后两个人还在卷九九六，而是说我们原来十天的一个项目，可以变成两天交付，然后我们会有更多精力去做别的业务。” (执行策略)

### 📋 待办事项

- 组织者：下午培训开始后向参训人员发放调研问卷收集问题
- 组织者：建立培训微信群，收集参训人员的问题统一答疑
- 讲师：后续实战部分专门讲解企业Word文档和MD文档的转换方法
- 讲师：课程结束后重新构建一份标准知识库，对比展示合格知识库和不合格知识库的差异

（注：输入中未包含`(我)`说话人ID，此处停止输出）

---

## 🎙️ 原始 ASR

🟢 说话人1 [00:00:00]
嗯相关的培训工作，这个至少今年 ai 编码替代，这个工作量的百分之三十啊，这个我们有一些指标要求，这个行管中心也要制，那个也会配合我们制定相关的考核数据啊。

🟢 说话人1 [00:00:22]
另外咱们这个全部课程是36课时，包含六天，这个可能根据后面情况，除了培训，和两位老师的指导也可以，你可以根据情况也就是延长，这个大家来培训要签到，这个董事会也要要求，就是说今年这个培那个 ai 编程培训做一个重要事项。另外大家这个手机静音，咱们上午培训时间是9点到12点，下午是2点到5点，这就会前后空点儿时间，大家处理流程一些工作，中间会有十分钟休息时间。

🟢 说话人1 [00:01:07]
咱们这个培训，因为这两个老师是目前还大厂在职员工。咱们尽量不要拍照片儿，涉媒在外面宣传啊，这个对两位老师不太好，就是不要扩散展示信息。简单介绍下两个老师，首先姬老师，他是那个在职的资深全栈研发工程师，外部 worker 的技术主播。

🟢 说话人1 [00:01:36]
也有多年的 agent 协作研究开发经验。另外是咱们那个徐老师，也是这个外部 worker 的主播，也是资深的全栈工程师。这个我这个简单的介绍，就到这里，就是下面欢迎赵总。

🟣 说话人2 [00:01:55]
啊，就是试这个工具，我们是七月底，大概集中大家使用就是五月份到现在吧，大概一个月。我们也了解一下情况，包括过程中大家提的一些问题，就是这个工具，就是基本的使用，可能大家都会用，但是怎么用好，用的更系统，怎么就更合理的使用这个消耗 token 提高效率。我们还是想请相对专业的老师给我们做一个系统的培训，帮助大家提升使用效果，是吧?

🟣 说话人2 [00:02:25]
就基本上说一下，然后我们鼓掌欢迎一下两位老师吧。好。好，那接下来时间就交给两位老师。

🔵 说话人3 [00:02:34]
嗯。

🔵 说话人3 [00:02:42]
那还切吗?不切这个也可以。嗯。

🔵 说话人3 [00:03:20]
可以，就直接用这个。

🔵 说话人3 [00:03:54]
各位同志大家好，就是上午的话，我们的课程是先简单说一下目前 AI 编程的一个发展。然后呢，今天一整天主要的课程就是通过 AI 去了解一个代码，了解我们不熟悉的代码库。因为我们在实际工作中，不可能每个公司或接手的项目都是从一开始，肯定有之前别人维护过的，或者我们接手的老项目。这时候，就需要我们通过在老项目中使用 AI 工具去更好的，更快的熟悉这个代码。

🔵 说话人3 [00:04:36]
如果没有 AI 之前，我们可能会用之前用户遗留的手册，或者说需求文档。还有就是代码里注释去了解这个，可能我们只熟悉自己需要改的那一块儿，对整个项目架构是没有特别清晰的了解。好，我就先简单说这个。其实这个数据是来自于25年的一份儿 stack o o follow 报告，这个报告也是在技术领域比较权威的，它每年都会有年度报告，然后也会有不同系列，比如前端的，后端的。

🔵 说话人3 [00:05:16]
然后一些主流开源的。可以看到目前有百分之八十四的人，已经使用 AI 工具了。然后有将近一半儿的人就是专职开发者，每天都会使用，剩下也会有很多之前可能不是从事开发行业的，然后通过 AI 工具加入进来。想说这个并不是说我们 AI 到今天已经非常强大，就是能完全把人替代，而是说它的普及速度已经超乎我们的想象了。

🔵 说话人3 [00:05:53]
大家有印象的应该是，我们这这次 AI 火起来，大概也就是 ChatGPT 可能也就短短的三四年时间，已经完全颠覆大家的认知了。之前每年就每次 AI 都会火一阵，可能之前叫什么机器学习，然后叫什么神经网络算法，每次火过之后就是火过去了。非非从业人员可能体会不到，但这次完全不一样。所以说我们现在去了解 AI 编程并不能说已经是一个新东西，更多的是我们要把这个已有的知识框架体系和 AI 编程去融合，更好的去使用 AI 然后把 AI 转换，把 AI 转换成一个可以交付的成果。

🔵 说话人3 [00:06:48]
这个就是 AI 的编程工具，编程工具的眼镜，最开始是从 github 出的 copilot 然后各种大厂也出什么通义灵码。然后记个记个 code 都是代码补全工具。

🔵 说话人3 [00:07:10]
一直点 table 就可以。再到最后，会在 id 工具右边集成一个对话框，然后大家通过对话去了解整个项目。

🟡 说话人4 [00:07:20]
是不是把那个电脑重启一下。power onpairing。

🔵 说话人3 [00:07:23]
嗯，再到现在呢，就已经进入了全新的阶段， agent 这个阶段。 Agent 这个阶段它的优势是在于。我们能把整个链路去完全的打通。从计划，从我们的需求计划，到整个代码修改，再到测试，再到我们的上线验证，最后我们再提交。

🔵 说话人3 [00:07:50]
所以我想的是这几天的培训，不是说让大家学会怎么写一段代码，而是说让大家能了解 AI 如何读懂一个项目，如何去找到正确的上下文，如何去观察其整个调用链路，然后判断 AI 的回答是否可信。 connected

🔵 说话人3 [00:08:14]
接下来这一点就是大家都比较关注的，都说 AI 会取代程序员，AI 的提效非常快。但实际上我们之前在做开发工作的时候，可能我们写代码的时长和我们下决策的时长是三比一或者四比一。我们可能写四个小时代码，然后用一个小时去判断我们刚写的这个代码是不是合适，逻辑是不是严谨，能不能完成正确的功能。但是 AI 来了之后，你发现写代码的人远远不如 AI 写的快。

🔵 说话人3 [00:08:52]
那我们就需要把原来写代码的时间也用来去做决策，去判断 AI 写的代码对不对，AI 生成的代码符不符合我们的项目规范。这也就导致原来我们的脑力劳动可能之前是四个小时写代码，一个小时下决策，现在会频繁地下决策，基本隔半个小时你就要决定刚刚的代码能不能用。反而来说可能对脑力消耗会更大。

🔵 说话人3 [00:09:30]
最后我觉得就目前而言 AI 来说，完全替代人是不太可能的，它更多的是能替代一些重复性的编码，还有一些低上下文的任务。还有就是生成一些模板化的东西。这个所谓低上下文的任务就是跟你的模型是契合相关的。如果你模型的上下文非常大，它可能会处理更多上下文，模型一般的话，它处理的上下文也是很有限的。我们人要做的就是更加往上层去抽象。

🔵 说话人3 [00:10:16]
比如说我们要去做业务判断，他写的这个代码符合不符合我们的当前业务。第二个就是第二个就是

🔵 说话人3 [00:10:32]
第二就是嗯嗯嗯嗯嗯嗯嗯嗯第二就是做架构的取舍。最开始的 ai ，可能就是在架构能力会偏弱一点，但现阶段旗舰模型的架构能力实际上已经很强了。但是它给的架构更多的是取决于它的训练数据，比如说它训练数据都是分三层，那么它给的架构可能也是分三层。

🟣 说话人2 [00:11:11]
可以这样的话它给的架构也是分三层，那我们就要判断它给的架构符合不符合我们的实际业务场景。

🔵 说话人3 [00:11:27]
还有一个就是安全边界。反目前来看的话，已经有不少的有不少人会爆出来，AI生成的代码存在安全漏洞，然后上线之后会有严重的问题。但这个安全边界就需要我们人去人为的把控。最后一个就是质量责任。说通俗一点就是，AI能替你写代码，但没法替你去负责。你最后交付的永远是一个可用的功能。就作为一个研发人员来说，你交付一堆代码是对企业也好，对整个项目也好是没有任何价值的，你只有交付一个完整可以使用功能模块儿的。

🔵 说话人3 [00:12:14]
可以使用的功能模块儿，这个才是有价值的。最后就是上线，人还是需要去负责整个上线的流程。

🔵 说话人3 [00:12:29]
所以说我们每个研发人员，他可能会经历一个工作内容的变化。可能未必会失去工作，但是你现在工作内容是一定会发生改变的。过去我们就写代码，查代码，然后自己改自己测。现在我们更多的是要描述清楚你的任务，我这个功能模块儿如何让 ai 能明白。说通俗一点就是我说的话可能不是带给人听的，更多的是给大模型听的，我们要适应大模型它的一个输入习惯。

🔵 说话人3 [00:13:11]
还有就是会提供上下文。目前你大模型的上下文有限，如果你提供了特别多没有用的上下文，第一个是会干扰它的决策，第二个就是输出来的效果也会被其他上下文所影响。最后就是会拆解问题。

🔵 说话人3 [00:13:36]
最后，比如最后的验证 AI 输出和 AI 结果的一个工程化。这两个是完全取决于我们当前使用的模型。就到现阶段，我们确实得承认有的模型输出的结果可靠性确实很高，但有的来说可靠性很一般。所以我们要通过它输出的一个结果，去判断能不能采用。结果工程化，这是一个比较大的课题，也是现在大家都是在想做的一个内容。我们如何把 AI 整个融入到我们的研发链路中，而不是每个人都用 AI 生成一段代码，然后再提交到 git 仓库上。

🔵 说话人3 [00:14:27]
后来其他同事再用别的 AI 再一改，然后又推荐另一种架构，然后再改完，可能功能也没有什么改变，代码行数也没有改变。但就是会产生没有用的提交，也产生了没有用的相互 talking 所以说到今天来说，AI时代它更多的是。就是你整个体系，整个体系的一个，整个软件交付体系，软件研发体系的一个改变。未来的差距不是说我们会不会用 AI 而是说能不能把 AI 嵌入标准的研发流程。

🔵 说话人3 [00:15:10]
现在就目前来看，只要是你会用豆包，会用 deepseek 的 app 就已经能超过百分之五十的人了。就有的人确实连这个对 ai 的了解程度，可能还是仅限于于是一个名词。还有一部分使用了豆包和 app 那我们要做的就是把整个 ai 嵌入到我们的研发流程，最后提供出可以交付的一个东西，然后也是会把我们的整个软件产品也增加 AI 功能。

🔵 说话人3 [00:15:47]
让大家更好的使用我们整个软件产品。当然我们就是腾出更多的手去聚焦我们的业务判断。比如说以前我们可能会考虑这个功能能不能用，能用就好，代码能跑就行。但是我们高质量的代码被 AI 替代之后，我们就要思考我现在这个业务场景符合不符合用户的使用习惯。我们的 AI ai 生成的代码能不能去更好的实现我们的业务?。

🔵 说话人3 [00:16:32]
然后今天也是我们第一天，先说陌生代码库的理解。这就我刚开始提到的，我们在做企业研发，或者就是说在做项目交付的时候，接手最多的是旧项目。很少会很少会我们一入职，或者说接手一个从零开始的项目。一定是有陆陆续续的人员流动，然后大家接手旧项目会更多。所以我们也是先基于一个成熟的项目去理解 AI AI 接入到整个陌生代码库，它应该去做点什么。

🔵 说话人3 [00:17:14]
第二个就是我们的最终调用链路判断影响范围。AI 生成代码，大家也都用过一段时间了，可能看到你随随便便聊几句，它就生成几百行代码。那你这时候你再挨行去审，可能就会比较费劲。所以我们先要压缩它生成的范围，让它不要一次性生成那么多。因为 AI 生成代码，它会有一个习惯，它会把它认为规范的代码给你再改了。比如说你原来是 if else 判断，然后你写了七八个，它可能认为你七八个 if else 是低效率的，它会给你改成 switch case 这种。

🔵 说话人3 [00:18:01]
但你这种功能对功能来说没有任何影响，但它确实是产生了一些优化。但你说这个优化的边际效益大吗?也未必，而且尤尤其是经过高级语言的编译。基本上你 if else 和 switch case 最后编译完的效率是完全一样的。还有一点就是沉淀文档。为什么要沉淀文档呢?其实你如果说我是一个个人开发者，那么我接手到项目，我随时问 AI 他让他去解释这个项目，这个是没有问题的。

🔵 说话人3 [00:18:41]
但是如果我们是一个十几人的团队或者二十几人的团队，每个人都把都把这个让 ai 去把这个项目跑一遍，这很明显是浪费 talking 然后也会消耗模型的算力。所以我们就需要比如说我们接到的项目，先有一个人基于整个项目建立一个 wiki 的知识库，然后把整个项目给沉淀下来。之后 ai 去查阅时，如果说我们的项目结构没有大调整，具体的功能模块也没有重新调整，ai查阅应该是查阅的我们的知识库。

🔵 说话人3 [00:19:21]
而不是说我们再去把整个代码链路再去调研一下。

🔵 说话人3 [00:19:31]
然后我今天的陌生代码库选的是若依。为什么选若依呢?第一个就是说我们书里有一张也提到了若依这个案例，第二个就是若依这个项目实际上是非常标准的后端管理系，后端管理系统，然后它本身也做了前后端分离，也有不分离的版本。还有就是它也一直保持了对最新技术的更新。另外就是权限设计这一块儿也是非常标准的三元权限。

🔵 说话人3 [00:20:12]
基本上可以说在前在没有 AI 时，若依这个项目作为很多小型公司做系统管理的一个首选框架。当然 github 上也会有很多基于若依的衍生版本，但是都一样。

🔵 说话人3 [00:20:38]
这刚刚已经聊过了。

🔵 说话人3 [00:20:45]
所以我们在提到 ai 能效，刚刚也提到的已经不是说在比代码儿写得更快，而是说理解的快，交接的快，然后定位更快，风险能更早的暴露，团队的知识沉淀更快。并不是说我我理想的提效并不是说我们原来十人团队有了 ai 然后咔变成两人了，然后两个人还在卷九九六。而是说我们原来十天的一个项目，可以变成两天交付，然后我们会有更多精力去做别的一些编辑业务。

🔵 说话人3 [00:21:31]
我们今天学的或者说让 ai 去跑的就是第一个结构，看整个项目的结构，第二个就是找整个项目功能的入口，第三个追踪整个 ai 调用的链路，第四个就是查找依据。

🔵 说话人3 [00:21:54]
查找依据就是 ai 在每一个关键结论，大家可以看 ai 思考时，它有那个思维链，然后你如果打开仔细看那个思维链的话，它会在每一个关键节点都会说它查了哪些文件。换了哪些函数，然后它认为哪些文件是做什么用的。我们看这个基本上可以大概能判断它的这个输出是否可信。

🔵 说话人3 [00:22:24]
好，终于进入到我们翠的这个定位。

🔵 说话人3 [00:22:32]
在这次 ai 之前，大家用的 ai 助手都是以插件形式，比如说我们用 IDE 也好，用 idea 然后用 vs code 这些，它都是把 ai 作为一个插件集成到我们系统中。但是为什么就是突然有这么多成熟的 IDE 工具，大厂还要再去做，包括字节的 tree 然后哪里 q 斗儿，以及国外的 coser 呀， code x 呀。

🔵 说话人3 [00:23:07]
谷歌的反重力，大家为什么还要自己做 IDE 尤其是基于一个开源的 VS Code 自己再去包一层。因为你只有自己做了开，自己做了开发工具，做了 IDE 你才能把一些真正模型的底层能力和你的系统去打通，然后你才能真正能把你的 agent 的整个链路去循环起来。

🔵 说话人3 [00:23:34]
所以说我们用到翠的话，肯定是如果你之前是做后端开发，可能会觉得翠这个工具跟我们之前用的工具，习惯完全一样，它可能会比之前的工具更复杂。那我们但还是要把这个工具给换过来，这是第一步。因为很多人会卡第一步，他会认为退这个工具，或者说我已经有非常习惯的 IDE 工具了，我为什么还要再去重新学习一个新的 IDE 工具?

🔵 说话人3 [00:24:14]
但如果你想要更好的使用 AI 你确实需要重新学习一个工具。

🔵 说话人3 [00:24:27]
另外就是代码和业务代码和业务完全是两个东西，就像我刚提到的，我们提交的代码是对企业没有价值的，但是我们代码开发的功能模块儿是对企业有和对项目有价值的。如果说我们把产品的就把整个项目的功能分为三个维度，比如说你第一个维度是能不能用第二个维度是，第一个维度是可不可以用，就是能不能实现用户的功能。第二个维度是好用不好用。

🔵 说话人3 [00:25:11]
第三个维度就是用户愿意不愿意去用。如果说我们这个最后研发完产品，用户每次用都捏着鼻子用，然后皱着眉头用，这很明显也是不符合我们的预期嘛，我们肯定是希望用户能更容易接受我们的产品，应用性做得更好一点。这就又回到了 AI 上，AI它擅长的是写代码，而不是说去了解你的业务。大模型它更多的是能基于你原来的事实去做，那么我们的代码就是事实，但是我们的业务对模型来说是不管是任何一个模型都是陌生的，它所熟悉的就是代码，它知道你的 if else 它知道你的 for 循环。

🔵 说话人3 [00:26:02]
它知道你的变量定义，但它不知道你为什么要去定义这个变量，为什么你这里要写一个 for 循环。所以说这个是需要人为去判断。

🔵 说话人3 [00:26:16]
所以我们在用翠的时候，它能明确帮我们的是当前系统是怎么写，当前代码是怎么开发，而不是说业务上一定要这样。

🔵 说话人3 [00:26:32]
最后就是适合翠的一些任务。当然这个只是说今天的一个模块儿，后面随着课程的深入，然后各个功能也会和大家去做介绍。

🔵 说话人3 [00:26:49]
今天来说我们主要就是通过 try 理解若依的一个前后端目录。第二个就是查找登录这个功能的一个入口文件。查找菜单的入口。还有就是分析它动态路由的生成，以及它的一些权限角色。最后就是能让它输出一份儿代码理解报告。AI 的代码，AI生成的代码理解报告和我们人去写的一些技术文档肯定是不一样的。我们人写的技术文档是给人看的，但 AI 它一定是符合它的读取习惯。

🔵 说话人3 [00:27:34]
然后我们今天要做的人工判断的任务就是这些，它的角色权限是不是更合，是不是合理，数据权限范围是不是正确。然后接口是不是应该开放?因为我们在设计权限时，我们可以前端去做权限，让用户看不到这个按钮，那么这时候我们的接口对不对用户开放?如果用户使用 Postman 或者使用 C I C U R L 这种方式能不能也换取到我们的接口?

🔵 说话人3 [00:28:06]
还有就是我们的一些敏感操作，比如说 AI 发现自己生成代码肯定有问题，但它会把整大段都删了，它会不会删，删完之后会影响我们原有的功能。最后就是代码生成的结果能不能上线?还有一个就是权限变更之后影响不影响我们现有的功能逻辑。

🔵 说话人3 [00:28:37]
这就提到了，AI可以去查找代码。但是它生成的初稿，我们必须人工去方程。我们方程的话，关注点就是它所描述的对项目的理解和用户的需求是不是一样的，或者说和我们的产品需求是不是一样的。最后就是不要把一些重大决策完全交给 tree 去做，也或者说交给模型去做。

🔵 说话人3 [00:29:20]
到这块儿的话，就可以看到基本的。稍等我把项目拖到这个屏幕上。可以看一下。

🟢 说话人1 [00:29:51]
行行行，如果有问题交流时间是不是可以说一下，或者有问题可以说一下嗯现在大家如果有什么想问的，可以提问，然后我把翠打开后投屏到这个上。

🔵 说话人3 [00:30:07]
大家现在有什么问题可以随时问。

🟠 说话人5 [00:31:04]
嗯宋总你那儿能看到不?没有你坐后面儿呢?

🟢 说话人1 [00:31:10]
可以可以像这个就是我之前已经拉了一个项目，拉的应该是他的前后端分离的一个版本，然后也是他这个版本是带微服务的。

🔵 说话人3 [00:31:32]
为什么我去拿这个版本去演示呢?因为对

🔵 说话人3 [00:31:57]
对 ai 来说，这种对 ai 这种微服务的项目架构，它是更难以理解的，因为它的上下文可能只会理解到你一个功能模块儿，那么这时候你就更考验 ai 的上下文能力和我们对 ai 使用的一个编排用户能力。

🔵 说话人3 [00:32:30]
我们刚聊到了，说让用 ai 去

🔵 说话人3 [00:32:40]
用 AI 去熟悉我们这个代码库。

🔵 说话人3 [00:32:59]
嗯，可以。

🔵 说话人3 [00:33:06]
我现在就已经跟进来了，然后大家可以看到它在新的版本更新之后，已经把原来的 builder 和 builder 类的 mcp 给合并成 agent 了。然后还有一个就是普通的对话模式。像我们现在如果只是了解 AI ，只是了解我们整个代码库，就是可以不用它的可以不用它的 agent 模式，直接用这个对话模式就可以。

🔵 说话人3 [00:33:37]
然后基于我们刚聊到的一个业务对象。这个是我之前已经跑的，让他去了解的一个东西。然后大家一会儿可以再，一会儿我再通过 AI 去生成这个东西。

🔵 说话人3 [00:34:13]
嗯啊我是现在这么说，大家可能更直观呢?还是说我切到 IDE 直接去操作整个 AI 整个 tree 大家会更容易理解呢?

🟡 说话人4 [00:34:27]
嗯看什么不是切到工程上，这样更具具象可以嗯嗯工程上那就先嗯

🔵 说话人3 [00:36:14]
像这个的话就是让 ai 去帮我们去分析整个项目。

🔵 说话人3 [00:36:27]
然后我们可以看到它整个的思维链过程，就是它会先去找整个项目下边儿的 pom 文件。整个 pom 文件就是标识了整个标识了我们项目的一个炸包儿的引用关系。然后可以通过分析这个去了解我们项目的一个大体架构。包括我们之前在没有 AI 的时候，我们去上手新项目也是。首先了解它的配置文件，通过配置文件去了解整个项目的架构。

🔵 说话人3 [00:36:57]
然后其次。再看它的一个。

🔵 说话人3 [00:37:11]
这就是已经拿到整个配置文件，然后再去。读取对应的。代码。

🔵 说话人3 [00:37:23]
可以看一下他读的代码的一个路径。

🔵 说话人3 [00:37:33]
因为我刚刚提到了，要关注的是用户以及权限，所以他可以看到他读的代码。他读的代码第一个是会有一个入口文件，第二个就是整个系统管理。这里边儿可能会有系统管理，然后有 E R P C R M。然后还有一些物联网 iot 的，以及它的一个商城，因为我拉的包是全部的。然后它根据你整个模型的定义，又去读取了你的 admin 这个对我们来说一般就是管理嘛。

🔵 说话人3 [00:38:19]
然后读到了权限和菜单，以及一些认证的，安全框架相关的。

🔵 说话人3 [00:38:37]
因为你上边儿的提示词约束了，所以它不会读取额外的模块儿，CRMERP这些，然后它会根据你当前的模块儿进行一个逐步的去深入了解。刚刚最上边儿是读取了模型定义 model 这一层，然后这一层是 ctrl 了，但实际上还是会聚焦于它这几个文件。然后我们再到下边儿，它会又通过 ctrl 再进入到 service 层，service层聚焦的还是这几个文件，最后又是实体，就是操作数据库的这一部分。

🔵 说话人3 [00:39:15]
角色的 do 和菜单的 do 所以我们在和 ai 对话首先第一个关键点就是我们要限制它的范围，不要去。就像我刚刚说的，帮我分析一下整个项目，它也可以做到去读取下边儿所有的项目。但是它会产生没有意义的 copy 这种操作我们在接手新项目，可能你做一次，然后把整个知识库去落地了。然后就会完成。后续如果你没有修改，就不用去管它，如果你修改了，一定要让 ai 同步把知识库相关的也改了。

🔵 说话人3 [00:40:07]
那这估计得跑一会儿，然后我们再切到这个课件。

🔵 说话人3 [00:40:15]
其实这个是我们自己，就是我们自己就已经清楚它的整个项目模块儿是分这么多。

🔵 说话人3 [00:40:27]
然后这些模块儿合起来也就是一个非常典型的后端管理系统。而我们今天就是说权限和菜单这两块儿，一会儿看它跑完的结果是什么。

🔵 说话人3 [00:40:42]
就这里说一下它在若依里它的一个权限角色。当然我们正常系统基本也都是这样，就是用户去绑定角色，角色去授权菜单。然后菜单里是有权限的。

🟡 说话人4 [00:40:59]
嗯嗯权限要控制到页面的按钮或接口。

🔵 说话人3 [00:41:05]
特别标准的一个三元权限。如果我们再有部门，可能就是用户下边儿再分部门，部门或者分用户组，然后再把整个组绑定到角色上边儿。

🔵 说话人3 [00:41:27]
刚刚提到的三种权限，决定用户能不能看到这个页面儿。嗯这里要提到用户能不能看到这个页面儿，只是他能不能跳转进去。对于我们的项目交付来说，最后你把代码都给到用户，用户如果说去代码里找这个页面儿，肯定是能找到的。所以就是有一些加密还是要放到后端去做，不要去相信前端的一个校验和页面加密。另外就是按钮的权限。按钮权限这个就更简单了。

🔵 说话人3 [00:42:07]
只是判断要不要显示这个按钮。最后核心的关键就是数据权限。数据权限也是最重要的。他看我们整个项目是哪些人有权限能看到所有数据，哪些只能看到当前自己的数据。还有哪些是只能看到部门的数据?这个数据权限通常是和角色绑定的。跟角色绑定，我们就要担心，我们就要去规避一个问题，我这个角色，他有没有一个继承的逻辑?比如说我的管理员角色是不是能操作所有的用户角色，所有的用户数据?

🔵 说话人3 [00:43:04]
这个我们是要做好隔离的，并不是说我们管理员就一定要拿到所有的东西，也不能说我们有个超级用户，他是能改所有的数据，这个数据一定要和角色绑定，这个角色一是你的业务角色。

🟡 说话人4 [00:43:22]
这就是我刚提到的，然后我主要让他分析了用户和权限，然后就是随着使用的深入，我们可以再把其他几个问题给添加进去。

🔵 说话人3 [00:43:59]
他这里还在跑。

🔵 说话人3 [00:44:12]
现在已经到了输出最后文档的一个阶段。

🔵 说话人3 [00:44:37]
如果我们要落地的话，其实可以刚刚让他把这个生成 MD 文档，或者就是。

🔵 说话人3 [00:45:08]
大家如果使用了比较多的 aiide ，会发现有的 ide 已经自动集成了这个功能，它会像初始化时，提示你要不要去生成微信知识库。但目前翠还没有这个，所以我们可以去手动操作。其实它内置集成这个功能也是内置了一套关键词。然后你点完之后它运行，最后就把这个文档去掉了落地这个文档怎么管理?

🟣 说话人2 [00:45:52]
就是同一个项目可能不同的人都要去分析对，所以这是我刚最开始提到的，就是说这个文档我们在项目初始化时维护一套就行，它可以作为我们的项目资产。

🔵 说话人3 [00:46:06]
实际上就是这个文档它有点儿类似于我们之前给用户交付的时候，可能会有什么详细设计，然后概要设计，需求文档，然后测试文档这种，我们整个项目也就会有一份儿。只不过那个文档是我们之前的一个交付产物，现在这个文档就是给 ai 去看，它第一次跑完之后，它会把它刚刚读到的，然后分析到的一些东西记录下来。那么我们要做的就是后续改完之后，写一个钩子也好，写一个 url 也好，就是强制要求他改完代码之后，再去对比，对比知识库有没有更，符合不符合当前项目。

🔵 说话人3 [00:47:23]
这也就说明提示词的重要性，如果我直接要求它生成 md 文档，它就不会再把这个逻辑再去跑一遍。

🟠 说话人5 [00:47:34]
现在的话，它相当于把这个逻辑又跑一遍，然后可能一会儿再要去创建一个文件。

🔵 说话人3 [00:48:00]
我就直接先把那个文档给

🔵 说话人3 [00:49:25]
既然不等他了，我把这个复制出来，复制出来给大家看一下。

🔵 说话人3 [00:49:42]
这个就是它整个的输出，输出之后会读到一些，会看到它整个整个执行的过程。这个就是开始读整个项目，然后在用这个 codebase 然后换用的工具就是 viewviewfold 这个就是查看文件夹，然后状态是成功。然后这一步应该是它整个在通过 AI 去调的 m 通过它内置的一个 agent 然后去调的 mcp 的工具。

🔵 说话人3 [00:50:20]
然后包括到这个设置 feel 也是在 mcp 的工具，然后每一步都是成功的。它就会一直在循环这个过程，一直在查看文件，查看文件。

🔵 说话人3 [00:50:34]
然后到这一步，然后文件查看完之后，它就设置整个扣的，就查找代码。

🟡 说话人4 [00:50:40]
下到这一步就是查看具体的文件，找到对应的代码，查看整个代码所在具体的文件。

🔵 说话人3 [00:50:52]
整个知识库，整个构建 wiki 知识库大概就是用了这么几个工具。当然这些如果说我们后续有自己的业务开发，或者我们要开发自己的一个 agent 构建别的 wiki 知识库，大概也用到的就是这几个。那这里面 m c p 的工具，它去循环的执行就可以。

🟡 说话人4 [00:51:24]
嗯好，这个跑完之后就可以看到它整个项目的一个架构。

🔵 说话人3 [00:51:36]
比如说项目名称，然后这些框架。这些文档是因为它已经开源了，所以它的内置文档构建也比较齐全，然后相关资料和语料网上也比较多。如果说是我们企业内部的项目，可能因为时间长，然后很多东西会有缺失。就是不一定会这么多，但是像我们常规的它构用了哪些框架，哪些库，以及技术框架版本，这个是肯定能拿到的。

🔵 说话人3 [00:52:15]
然后整个的项目模块儿。

🔵 说话人3 [00:52:22]
项目模块儿可以看到它是外部层负责整个页面，然后安全框架，像这个持久层用的是 MyBatis 。之后这些就是根据不同的控制模块儿去拆分。

🔵 说话人3 [00:52:46]
这个就是其他的一些微服务，根据整个项目交付的产物去做热发产。嗯这就到了我们今天想了解它的整个权限。

🔵 说话人3 [00:53:08]
这个就和我们刚才在课件里一样，AI是能通过我们简单提示词去分析出整个权限的体系。功能的权限，然后数据的权限以及用户隔离。不过我们如果是做整个项目内部交付的话，很少会用到多挖坑。然后他这里是把菜单权限和按钮权限放在一个了。菜单权限实际上就我们常说的页面权限，决定你能不能看到这个页面。

🔵 说话人3 [00:53:47]
他还会拿到你核心的库表设计。

🔵 说话人3 [00:54:03]
这些库表设计，我们后续开发的时候可能会有更改。也可能不会改，那么我们需要关注的点就是它这个库表设计哪些在系统里已经用到了，然后哪些媒媒体角色对应的是什么?因为我们后面儿可能要改的大部分是你的一个媒体角色，比如说我们又有了新的需求，要加一个要加一个部门管理员，或者区域管理员，我们就需要去更新这些。

🔵 说话人3 [00:54:49]
结构一般很难去改，但是你内置的一些东西会去改。涉及到更新这些，我们就需要通知整个项目的 wiki 知识库，要把这些也去同步更新了。不然的话，它会产生一个什么情况呢?比如说我项目读了 wiki 知识库，然后又会发现和我的代码儿对不上。这种呢它会聪明点的 ai 可能会谈一个问题，会问你以哪个为主，笨一点的会直接以你的代码为主，那你构建 wiki 知识库的作用就失去了。

🟣 说话人2 [00:55:28]
你要去改的话是怎么个路线?是改的话是先让它基于 wiki 去生成一个方案，再生成代码还是嗯嗯嗯这个倒不需要，这个如果是我们的一些小任务，可以直接告诉他去改哪个功能模块儿。

🔵 说话人3 [00:55:45]
然后呢我们会在 ruler ，或者那个 agent 去约束他，改之前你先看一下我现有的文档，就是你要根据我的文档去查找对应的功能。不要再去，可以看就是刚上班儿一直在 search 文件，然后去 search 代码。那么我们构建完这个之后，我们就希望他能快速定位到那块儿代码，不要再去全局 search 我们定位到这个代码之后，让他去根据以 wiki 为标准，再去改代码，改完代码之后再去更新整个 wiki 再去更新整个知识库。

🔵 说话人3 [00:56:28]
嗯，这下就到了这块儿，它的一个权限角色关联表。

🔵 说话人3 [00:56:41]
到这一步就进入了它整个权限校验的流程。可以看到它把我们的流程给画出来。用户 post 请求的是这个接口，然后换用的是这个 controller login 然后是 service login。最后再去返回 vo 在这整个链路里，如果我们之前人工去改的话，也是从看用户换的是哪个接口，再去整个代码全去搜索。嗯嗯。

🔵 说话人3 [00:58:14]
这个就是我们之前的开发流程，可能你找到，然后你先找到文件，然后再去文件里找到它对应的对应的内容，然后再一步一步点进去，再去改。

🔵 说话人3 [00:58:40]
现在我们可以就是直接去看整个知识库，看它的整个链路。

🔵 说话人3 [00:59:35]
这里它也会分析出你每一次请求你具体的一个整个流程，然后是如何去到的这一步。就以这个为例，它提取 token 再去验证 token 最后才能到返回了。

🔵 说话人3 [01:00:05]
功能权限是这一块儿的，可以看出来基本上它输出的东西是大差不差的。就是这个文档呢，就是相当于我们之前开发要在自己脑子里有的一个东西。这样你才能找到对应的功能模块儿，然后进行开发。

🔵 说话人3 [01:00:50]
在这里它会标注我们的一个核心逻辑，像我们刚提到的，它是整个代码的逻辑，就是我用户输入完用户名密码，然后点完登录按钮。他最后执行到你这个代码，那么到这一步可以看作是我们的一个业务逻辑，他会有这么三种情况。第一种是不添加过滤条件，然后你就全部放行，用户就登录进来。第二种是部门儿为空的时候，你就要返回有没有数据。

🔵 说话人3 [01:01:29]
然后这第三种就是你部门儿有条件，用户有条件，这个就是查当前登录人所在部门儿的数据。如果我们之后再要加一个只是当前登录人的数据，我们就会有情况四。根据 user 的条件再去查当前登录人的一个数据。嗯，看一下。

🔵 说话人3 [01:03:34]
这时候我们就可以直接让它去添加一个平衡数。

🔵 说话人3 [01:04:33]
啊，我刚让他去添加情况是查询当前登录人的数据，然后我们再看一下他的工作。

🔵 说话人3 [01:04:43]
当然在知识库里边儿也给了示例。

🟣 说话人2 [01:04:46]
他会把这个知识库的文件和代码一块儿改吗?

🔵 说话人3 [01:04:53]
嗯，这个如果说，嗯，如果你不要求的话，就是会看模型，如果你要求的话，基本上模型就都能做到。

🔵 说话人3 [01:05:06]
他首先看了这个文档，然后再去思考整个过程。

🔵 说话人3 [01:05:27]
其实下面知识库里就已经给了相关示例代码，可以根据当前业务去过滤。

🔵 说话人3 [01:06:22]
现在可以看到模型它的一个思考过程是英文的，这个其实也能在对也能在输入栏里去强制要求它输入中文。

🟣 说话人2 [01:06:52]
他把这个文档改了他把文档改了。

🔵 说话人3 [01:07:18]
比如说像刚刚这个事例就很有意思啊，就说我提示他让他增加根据文档增加情况四然后查询当前登录人的数据。其实我们刚才一直语境就是语义环境里是希望他去改代码，然后再把文档改了。但他很明显是受到了之前上下文的影响。他先参考了一个上下文，那么我之前的上下文就是构建知识库。然后他就会认为你当前的优先级是更改整个知识库的优先级会更高，所以他会把知识库先改了。

🔵 说话人3 [01:07:59]
这时候你再告诉他同步修改代码，或者说还有一种方式就是你要改代码，你不想让它被上下文污染，你再新加一个对话。还有就是你直接在提示词里增加，代码和文档都要改可以看见他这块儿已经那代码已经改了，注释也已经添加了。这只是一个小功能，如果我们非常熟悉这个项目，可能有敲这些关键字的时间，已经把这一行给写完了。但它整个流程是如果我后期不只是把权限这个文件去修改，涉及到整个链路去修改，我要新增加一个入口方法，然后从我的 ctrl 了一直到 service 再到最后的

🔵 说话人3 [01:09:15]
v d o 层整个持久层都要改，那肯定是 ai 会更快，但是对于我们来说提示词可能是不变的。

🟠 说话人5 [01:09:26]
然后还有一个就是比如说我刚上边儿让他去改这个，但他呢就是改了文档，改了文档这时候我再去要求他改代码，会很明显的发现他能快速定位到这个代码在哪里。

🔵 说话人3 [01:09:50]
因为你上下文就是他已经构建完知识库，他会只去 search 这一个文件，只去查找这一个文件。

🔵 说话人3 [01:10:04]
然后查找到一个文件就定位到这个问题，然后就增加了情况四。

🟡 说话人4 [01:10:09]
我们如果说我们之前没有整个构建知识库，然后也没有去让他先把这个内容给落地，那么我们这时候再去说让他去查找代码，他可能会更慢。

🔵 说话人3 [01:10:48]
你说我们可以试验一下老师我们有这种情况就是我们一般既有软件的更改，我们会去写软件变更方案嗯啊软件变更方案这个 md vkmd 文档的改动，我们会有一个变更方案，可能是嗯变更方案是什么呀?像 word 还是专门儿我们公司自己的一个 word 嘛，这种话咱实际工作中是咋处理这种事儿?就是

🟣 说话人2 [01:11:18]
就 ai 的 md 的文档，和你实际的技术文件这种变更的同步是咋处理的?就是靠人工还是有没有转化方式这个就更容易了，我们可以直接把你的技术文档，就你们已有的变更方案直接生成 md 自己做一个小的 mcp 工具。

🔵 说话人3 [01:11:39]
或者有找那个 skill 也行，直接读这个文档，然后再生成 md 再去更新 md 然后你再去通过 md 去驱动改代码那 md 这个文档还能再逆向回去我们的标准标准化文档。

🟣 说话人2 [01:11:55]
因为我们对外有一些审核要求啊md 再逆向回去对格式我们有格式要求那这个就得看那个也是做个专门儿 md 的对用 md 去做 sql 去生成对因为你这个其实大大量的工作是在处理样式。

🔵 说话人3 [01:12:17]
处理你们的标准样式，不是说处理文字，对文字放到 md 也好，放到 word 也好是一样的，主要是处理这个样式，你需要把整个样式扔给 skill 然后它能去解析这个样式，然后再给你返回。

🟣 说话人2 [01:12:33]
有没有可能我直接用我们的 word 文档去替代 md 文档去指导这个 ai 的工作??

🔵 说话人3 [01:12:41]
呃，这个也可以，但是嗯，这就为什么我说我们现在要做的就是让 ai 更好读的一个东西。

🟣 说话人2 [01:12:50]
因为 word 文档它本身是带很多样式的。但 md 文档不是，它的样式会非常简单，然后整个结构也比较简单，它的信息密度要远远比 word 高。

🔵 说话人3 [01:13:04]
因为我们 word 你可以最后你导出来之后，它会有个叉 html 它里面儿会分装很多样式。

🔵 说话人3 [01:13:14]
不过现在这种基本都会有很成熟的 skill 它能去解析你的，能解析你的 word 然后去读取出来。

🟣 说话人2 [01:13:25]
嗯这个在实战部分我专门儿说一下吧。好嗯嗯平常常用 mb 就是给体系审核的时候用但是文档的同步，有问题，需要自动化手段过程存档刚才我们只是看了这一模块儿，但之后的模块儿都是一样的。

🟢 说话人1 [01:14:09]
嗯这个我们还可以是

🔵 说话人3 [01:14:27]
知识库构建之后，刚才是我，我一直在看这个知识库，因为这个现在只是有一个，然后也相对来说会比较少。就是大家看起来还不会很费力，但是如果你后期会很多的话，其实这样查知识库也是一个非常费劲的工作。

🔵 说话人3 [01:14:53]
所以如果说你知识库多的话，你也可以直接问

🔵 说话人3 [01:15:10]
直接问那个，直接问，直接让 ai 去读你的知识库，然后你直接提出你的问题就可以。比如说我们的 talking

🔵 说话人3 [01:15:45]
但是我们可以不指定它这个文件夹。

🟤 说话人6 [01:15:49]
你现在还不指定文件夹，你可以用自然语言告诉它。

🔵 说话人3 [01:16:56]
而且像这种操作，你再去基于知识库再去跟它对话，它会快很多。

🔵 说话人3 [01:17:07]
然后它整个链路也是查找知识库，然后找到知识库的代码。

🟠 说话人5 [01:17:17]
客户打断一下，你像这种情况下消耗不消耗的消耗不消耗的消耗不消耗的肯定消耗它本地的它本地的位置也消耗了对相当于不是推展多，而是推展用户大模型了

🔵 说话人3 [01:17:32]
大模型这个 token 消耗是一个比较大的话题，就是它分为上行 token 和下行 token。比如说你问用户的问题，他会消耗 token 就你发出去的关键字会消耗 token 然后他吐出来的也会消耗 token 然后他只是这两个 token 的价格不一样，所以就是我们的关键词要简短的描述清楚自己的需求。

🟠 说话人5 [01:18:06]
哦，我想着是不是在本地也可以把关键词做着处理，如果是本地文档的话，在本地搜就行了，在文档上搜也可以啊，我们就是你看像我刚改这些东西，在本地你实际上也能找到对应的代码去改。

🔵 说话人3 [01:18:22]
但为什么还是要用 ai 去搜呢?因为这只是一个文档。后续如果你整个项目特别大，你都构建完知识库，你查知识库的精力其实也会相对比较高。人肯定不如 ai 看的快这个知识库是放在你那儿不是，这个是我刚才落地了你落地了一个一个 md 文档对，落地成一个 md 文档md 文档对那那如果多个人交。

🟠 说话人5 [01:19:04]
多个人协作的时候，这个只是你本地的，本地私有的是吧?嗯，多个人协作

🔵 说话人3 [01:19:12]
这个 wiki 知识库应该是你提交到 git 大家拉的时候都会拉下来。或者说你整个公司有远程的知识库，你最后把这些文档都上传上去，然后你 mcp 自己开发一个 mcp 查本地的工具，查本地的知识库，要查那个远远端服务器的知识库。就这个东西肯定是要落地，至于落地是根据项目的实际情况，是大家都每一个人都拉到本地，然后改完之后再推交到推到 git 上边儿的。

🔵 说话人3 [01:19:53]
还是说我们有一个专门的知识库服务器，大家都是从那儿去拿。

🔵 说话人3 [01:20:09]
然后刚才我问的不是 token 在 token 存在哪里吗?然后我们才能是。

🟥 说话人7 [01:21:10]
那套呢?

🔵 说话人3 [01:21:11]
嗯，不是网卡，不行下午就直接投屏吧。

🟥 说话人7 [01:21:28]
我闺女在这边儿浏览那个网址上打，打完之后再复制过去。

🔵 说话人3 [01:21:33]
嗯，对，先看过来。

🟥 说话人7 [01:21:37]
对行。

🟥 说话人7 [01:21:48]
要不十点半时候休息十分钟?

🔵 说话人3 [01:21:50]
啊，行，十点半的时候休息十分钟。

🔵 说话人3 [01:23:35]
然后我刚又对，我又去跟 agent 对话说请求拦截是哪里携带了 token token失效之后是怎么处理的。很明显发现他这个任务，就这一轮对话，他的思考时间会比较长。一会我们也可以看一下他为什么思考时间会比较长，和刚刚第一个对话有什么区别。

🔵 说话人3 [01:26:08]
我们可以看到就是刚刚他这一轮对话，他也去查了知识库，但是在知识库里没有找到相关内容，所以他就去找代码。这样的话整个思考过程和 token 的消耗就会比较长。所以如果我们之前构建过知识库，那么询问他的问题，则会明显缩短他的思考过程。另外一个就是它不会重复去消耗 token 现在如果我把这部分东西再落到我们的知识库里，它下次再去查找问题的时候，它就会直接从知识库里提取，然后不会再消耗 token 那不会再消耗这么多 token。

🟡 说话人4 [01:27:02]
嗯好，十点半了，那先休息十分钟，然后我们在十十点四十的时候再开始。

🟢 说话人1 [01:27:21]
咱们那个卫生间呢?

🟡 说话人4 [01:27:23]
嗯，好。

🟥 说话人7 [01:27:40]
哎，我，咱，我明天，你接下来等什么安排?不不不，我说你接下来怎么说这个东西?

🟤 说话人6 [01:27:56]
嗯，就是搞这个知识库，搞完之后呢?就今天就接下来一个半小时就搞。

🔵 说话人3 [01:28:02]
嗯，还有别的吗?

🟤 说话人6 [01:28:04]
这个知识库现场啊，演示的问题就是等时间太长，大家老师，我有个问题。就我改个代码，我改完之后，我原来里面的汉字注释呀，或者是有中文那种变量的，一改全部都乱码了。这种一般是咋整啊?我就遇见好几次，其中有些程序就没法再转不过来就睡觉了，就重写了。

🔵 说话人3 [01:28:32]
你之前项目用的是什么编码?

🟤 说话人6 [01:28:35]
项目是我我刚才刚试了一下，我拿一个我正在改的，待会试了一下就让他给我增加个看，啊国标还是你之前的项目编码是哪?

🔵 说话人3 [01:28:44]
国标还是 g b 还是 g b k?

🟥 说话人7 [01:28:47]
你这个乱码是它结构乱了，比如 js doc 乱了，还是中文看不懂了?

🟤 说话人6 [01:28:51]
就是那个编辑器打开里面中文都显，主主要是中文啊，那应该是编那个编码的问题编码问题，老项目的编码是不是用的 g b k 这一类的，因为基本上现在都是基于 u t f 杠八

🔵 说话人3 [01:29:05]
对那你可以先把那个找一个工具把你那个编这个应该就没问题那你转完后它编译器不认了咋整编译器它是因为你现在还在编译器这一块儿编那它这个 ai 它这一块儿可能只适用吗不行 ai 它只适用它也不是说只适应于点儿抗八，它是适应你大头儿的一个动力输出嗯，先确定这个你说演演示代码儿，他会等的时间会很长，慢慢就注意力就不在这儿，看看是先口喷。

🟥 说话人7 [01:30:02]
就是打完字儿之后让他转着，我们继续翻一翻这个 ppt 折回来。嗯

🟥 说话人7 [01:30:11]
这个破玩意打字这么费劲。

🔵 说话人3 [01:30:14]
有点卡，不行就那啥。

🟠 说话人5 [01:30:20]
这个月大概有一百十几号。

🟥 说话人7 [01:30:23]
他们也穿插问题，要不我就后面打算穿插的问题先记下来，记下来统一答疑，不打乱你的节奏。

🟠 说话人5 [01:30:31]
他这个刚才那个老师问的那个特色不是你这个外贸的，是 ai 儿消耗的。

🔵 说话人3 [01:30:39]
对。

🟠 说话人5 [01:30:39]
不管你提问的是其实你想的特色。

🟢 说话人1 [01:30:46]
然后就是我们想的是怎么去尽量让访问客户精准的向我们下单那你就是要看提示词了但是你这个提示词有没有具体规范?

🟠 说话人5 [01:31:02]
说怎么提怎么提问，都能会有，我们下面会详细的还有刚才那个协作那一块儿，就是协作的就是说是你

🔵 说话人3 [01:31:52]
就还是靠不了那么最后那一步就是对项目的一些核心观念没有具体的比如说我这个我 a 同事是吧然后我是 a 同事我下来了然后我对这个 a 文档进行修改然后再开始进行这一步后续修改过程中那就那就。

🟠 说话人5 [01:32:21]
我 a 同事的其实属于一个比较但是我 b 同志修改的时候其实是比较模糊的，他使用的文档虽然和项目是一致的，但是他可能就是使用的结果不同，再填进去的时候，如果我 c 同志我再去对 b 同志这个东西再去做的时候。那他就更他的就是你这个最初始的 mb 它形成的 mb 是你的项目所以说这如果你项目上如果改的话，它基本上

🔵 说话人3 [01:32:57]
你协作的时候肯定会有对，那你协作代码你肯定会更新你对应部分的内容，不是说会更新我能看到实际上就是刚刚那两个地方，它都有大部分它只是说喂你去吧你去吧

🟢 说话人1 [01:33:56]
嗯嗯嗯嗯啊我我喝的少，行，明天我喝的多了就。

🟢 说话人1 [01:34:14]
我这儿没办陈老师，我们后面比如下午，到明天，我们先把问卷给大家，问卷先汇一汇，然后机会可以我现在想对我们一会下午，我们再慢慢聊，就看大家怎么节奏，我看还是有很多问题想问。一会一会你可以说，我们一个微信群组，你让他在群里提就行。嗯嗯嗯

🟠 说话人5 [01:34:52]
哦那个啊，是吧?那没有，我不用你说的啥牌子，哎对对这个，你先弄吧。

🟠 说话人5 [01:35:14]
哦，你这样说呀，那肯定是就这，你这不动我我这咋了，这是。

🔵 说话人3 [01:37:31]
好。

🔵 说话人3 [01:37:37]
哎，10点40了，那咱们就继续开始。

🟢 说话人1 [01:37:42]
啊，好。

🔵 说话人3 [01:37:48]
刚休息的时候，有几个同事有一些问题，我觉得这个问题可能大家都会有，所以我就说再跟大家聊一下这几个问题。首先第一个就是说这个知识库。它并不是说我们非常使用向量数据库啊什么的，要去把整个 md 文档再做向量化，然后再去通过 ai 去查。没有那么复杂，只是说就一个 md 文档，然后它把这个项目的关键信息给记录了。

🔵 说话人3 [01:38:27]
这是一个，还有一个就是这个 md 文档一定会随着我们去修改项目，它会不断地去改，这时候也难免会有一些冲突，或者就是说有的人改了，但是可能这个文档没有及时更新，导致文档和代码对不上。这时候我们可以做一个全局的校验，或者说是全局的更新。比如说我定期去判断一下我整个 user 整个 md 文档和我的项目有没有发生改变。

🔵 说话人3 [01:39:12]
我们正常来说，我们每一个交付版本，做完这个 tag 之后提交到 master 分支以后，那么我们这个版本定稿，我们理应给这个版本所配套的知识库代码，它都会标记为一个 tag 在之后改的话。我们每次都应该去再同步这个你的 tag 你的 tag 标签，你的 tag 一定是项目文就知识库文档和你的代码结构是保持一致的。

🔵 说话人3 [01:39:48]
这样你才能保证之后是没有问题。

🔵 说话人3 [01:40:07]
这就是我刚刚提问的一些关键词。

🔵 说话人3 [01:40:17]
像这个用户信息和权限加载链路。

🔵 说话人3 [01:40:23]
这个我们刚刚在知识库里边已经有了，如果我们这时候再基于这个问题，他应该能很快查到。

🔵 说话人3 [01:40:35]
如果他没有很快查到，说明我们刚刚构建的知识库是不太符合预期的，我们这时候就要再思考它整个知识库的构建。需要怎么才去做?我们可以试一下。

🟡 说话人4 [01:41:07]
嗯嗯嗯这个我甚至没有让他再去根据知识库去查，然后你会发现，只要你有了这个东西之后，他会主动的去触发查询你的文档。

🔵 说话人3 [01:41:52]
一会儿我们结束后，我再重新构建一个知识库，然后大家就可以对比出一个好的知识库和你不是特别精准的，它会有哪些问题。

🟡 说话人4 [01:42:08]
嗯这是动态路由的一个加载链路。

🔵 说话人3 [01:42:40]
像这些基本都是通用的前端框架，或者通用的系统管理。获取到路由权限，然后后端返回菜单数，前端找回成路由对象，再挂载路由，然后最后用户再点击进入页面。按钮权限也是类似的一个操作。

🔵 说话人3 [01:43:10]
这个是后端接口的一个权限。

🔵 说话人3 [01:43:20]
其实，像这个需要确认的，那么我们在更新完知识库之后，这些会都在知识库里面有标记，比如说我们刚刚会看到他是进入的哪个ctrl 了，然后哪个 service 我们这时候我们再去问他。比如用户，比如用户登录的接口，ctrl 了有没有权限注解，service 有没有校验数据的权限，这里都能，这里都能看到。

🔵 说话人3 [01:43:57]
接下来就是你操作系统的一个用户链路。

🔵 说话人3 [01:44:05]
再就是调用链路分析的一个关键词。

🔵 说话人3 [01:44:56]
嗯，刚刚这个问题它已经返回了，会很明显比上边儿那个问题要快一些。然后我们现在再新开一个对话，避免上下文污染，然后我们再让它分析整个调用链路。

🔵 说话人3 [01:45:28]
这个执行完之后，会发现它和刚刚的知识库文档有一部分重合，但是又不太一样。那么我们这个链路呢?实际上就属于我们的一个业务的实际场景。至于这个业务的实际场景，要不要去落地到 md 文档里，这个就要看具体的项目了。 md 文档更多是倾向于记录项目信息，这就是早上提到的代码事实。而这个业务事实呢?它的变动会比代码支持更频繁。

🔵 说话人3 [01:46:22]
让它跑，我们看一下。

🔵 说话人3 [01:46:37]
一会跑完之后，我们看一下在。在 a 在它的输出结果里边儿会有哪些东西?。

🔵 说话人3 [01:46:51]
然后我现在一，等它跑完之后，我们再去回复这部分内容。我接着往下说。

🔵 说话人3 [01:47:14]
就是模型的幻觉。虽然现在模型已经非常强大了，但是它依旧会有幻觉的存在。那么我们就要能判断出哪些幻觉是模型。就哪些幻觉是模型是消灭不了的，它一定会有这样的幻觉，然后哪些幻觉是我们可以通过关键字，然后能去让它更好的去规避。

🔵 说话人3 [01:47:56]
其实在若依这个项目里，AI很容易给出特别不严谨的一些结论。比如说一会儿我们可以看一下它跑完的一个链路，它会把它认为的一个链，它会把它认为的一个链路，给到我们的输入文档里，但实际上这个链路不一定是项目里的链路。所以我们发现它和项目里不太对的时候，我们一定要去继续追问。那我们判断它对不对的一个标准就是两个，第一个基于我们之前对项目的理解，第二个基于我们的代码事实。

🔵 说话人3 [01:48:52]
就我们先构建完知识库，这个知识库先不管它没电了先不管它吧对先不管它的这个知识库它可能就是知识库的代码事实，这个大部分模型是不会出错的，因为它就非常简单的标记哪部分代码是做什么用的，哪部分代码是哪部分代码在哪一个文件里儿。而我刚刚那一段提示词让它去分析链路，那么它就要去基于你的代码事实，然后加上它的模型能力去产出它认为的一个结果，就很容易出现幻觉。

🔵 说话人3 [01:49:35]
所以我们在看的时候首先要对比第一个他所说的文件能不能对上?第二个就是你看到这个文件在我的代码里不存在，然后你就要问他这个文件是哪来的?是不是他凭空捏造的?一定要让他根据我们的代码事实有所依据，这样的话才是可信的。

🔵 说话人3 [01:51:05]
这是我刚给他的提示词，让他去分析整个调用链路。然后你会发现，由于我们之前只是有相关整个后端的一个，就是有个后端的 md 文档，然后没有前端的，这时候又会触发他去分析整个前端的项目。

🔵 说话人3 [01:51:32]
然后把这整个项目分析完，他才会再去读取我们的 md 文档。

🔵 说话人3 [01:51:57]
读取完 md 文档之后，它这样会输出整个结果。我们需要审的就是它这个结果是不是可信的。就像我们刚刚的。

🔵 说话人3 [01:53:07]
大家可以看一下整个两个两个的结果输出。

🔵 说话人3 [01:53:15]
刚才我们只是记录了它的一个简单的代码事实，它的一个请求流程。但是我们在分析整个调用链路时，会发现它会把核心的代码逻辑，比如说我这块儿我换的是 service 哪边儿的 login 但它能明白你这个 service service 你只是一个接口。然后你会有一个它的实现，你处理的核心逻辑是在你的实现里边儿。

🔵 说话人3 [01:53:45]
然后你会有这些处理。

🔵 说话人3 [01:53:55]
那么我们这个在如果说好的知识库，它会把这个记录完之后，那么我们再分析它的调用链路。只是从后端这部分来说，它能根据这个文档定位到它定位到我们的入口。然后我们也能查到它的核心逻辑会在哪里。

🔵 说话人3 [01:54:23]
关于这块儿，它是我们整个流程的入口，然后改的话是在改核心逻辑，需要在这里。

🔵 说话人3 [01:54:45]
这部分我们就没有必要再去把它放到我们的知识库文档里，因为你这个就是我们的业务事实，你业务逻辑可能你今天需要用户名密码，明天可能需要 oauth 二的方式，后天可能需要 sos 单点登录。那你这部分呢?你是可以交给 ai 每一次去分析你最新的代码。

🔵 说话人3 [01:55:25]
这些就是一些更具体的了。

🟡 说话人4 [01:55:31]
嗯行。

🔵 说话人3 [01:55:57]
如果说我们还需要把这个链路，我这里先。先我先写一个简单的示例，就还是以这个 login

🔵 说话人3 [01:57:38]
这时候我们发现它对不上的时候，我们就可以问它为什么没有提到这个文件。刚刚我们的知识库构建里面只是提到了其外层的 service 没有提到具体的实现。

🔵 说话人3 [01:57:56]
我们通常判断 AI 输出的结果可靠不可靠，也是会进行多方面验证。一方面是我们已经构建的一个基础事实，一方面是我们自己对项目的了解，还有一方面就是说它输出的结果在项目里找不到。

🔵 说话人3 [01:58:41]
他这里也会写到，更偏向于是概括，而不是具体的代码实现。

🔵 说话人3 [01:59:10]
所以说我们在屏蔽他幻觉的时候呢。第一个我们是先基于我们最开始已有的代码事实，就像刚刚的 md 文档，我们把这个事实抽取出来，这个事实是确定的。因为审那么几行，审那些比较少的文档，我们肯定是审得过来的。那些确定完之后，我们再基于它的内容去扩展，再找到对应的问题。这样的话，我们就能分辨出哪些是幻觉，然后哪些是没有问题的。

🔵 说话人3 [01:59:58]
所以说一个可信的，就是 AI 生成可信的，它一定是包含这几个东西的，第一个就是文件路径。比如说我们前端用了哪些 API 然后后端用的是哪个 ctrl 了，然后哪个函数。然后就是调用关系。调用关系是登录后先把 token 然后获取用户信息，get info 再把路由，再生成动态路由。

🔵 说话人3 [02:00:37]
然后不确定的点，比如说你，我们没有办法确定某一个接口是否有权限校验。

🔵 说话人3 [02:00:46]
这样的话，如果说他这四点都能做到，都能做，都能回答出来，那么基本上这个结果是可信的。

🔵 说话人3 [02:01:05]
我这里举一个简单的示例。

🔵 说话人3 [02:01:52]
以按钮权限为例，它这里提示到会有这个文件。稍等我把那个我把前端的项目也打开。

🔵 说话人3 [02:03:21]
这个就是若依配套的一个前端项目，然后这是他刚刚提到的代码生成的模板，然后就是我们去可以看这个里面的文件，然后去验证他刚才说的对不对。或许我们还有一个简单的验证方式。

🔵 说话人3 [02:04:19]
简单的验证方式就是我们再把这个文档里的一些东西再输给我们前端工程的一个对话框里

🔵 说话人3 [02:05:27]
到时候再看它的一个反馈结果，然后来验证这个结果是不是对的。

🔵 说话人3 [02:05:47]
另外像这种它会具体事例到某一个文件，然后具体哪些代码，基本上这种就是可信度比较高的。

🔵 说话人3 [02:06:17]
然后我。

🔵 说话人3 [02:06:29]
像这种回答，基本上就是没有可信度的。尤其是还会有一些问题，就是比如说我们做了一个很大的 to do to do 列表，就是做了一个很大的任务列表。然后 ai 跑完了，跟你说我这五条任务都完成了，但你实际上再去看，它可能只完成了三条或者完成了四条。它没有把全部的任务都进行完成。

🔵 说话人3 [02:07:05]
有时候我们也可以通过 ai 它整个思考和执行任务的结果和时间去看它这个任务是不是可信的。

🔵 说话人3 [02:07:21]
你看像这种可信的回答就会相对比较详细，它会具体到会用哪个方法，然后获取了什么，然后有一些核心代码的示例。然后这如果说有风险点，也会提示你有风险点。

🔵 说话人3 [02:07:48]
最后我们今天要检查的就是它的一个校验清单，比如说文件路径函数类名,调用关系,前后端的区分,不确定点，像这个我们刚刚跑完之后，基本上都会有。

🔵 说话人3 [02:08:15]
像这些问题，现在基本上旗舰模型，我现在不是用的 v 四 pro 嘛，旗舰模型基本很少会有出问题的。好，接下来

🔵 说话人3 [02:08:44]
接下来就是到了今天的最后一个模块儿。报告的主题，其实这个报告也就是说我们最后要生成对整个若依项目库的一个理解。我们如何去构造整个项目，就如何构造整个合理的知识库，我之前只是构造了一部分。

🔵 说话人3 [02:09:16]
像一个合理的知识库，它就应该有每个模块儿的职责，然后核心的对象目录和文件结构，核心的调用路径权限的风险，然后日志操作的风险。至于后面的改造建议和不确定结论，这个取决于我们需不需要，需不需要再和 ai 去沟通改造这个东西，如果说我们不需要的话，这两部分是可以省去的。

🔵 说话人3 [02:10:01]
另外就是我们在 m d m d 文档里常写的一些东西是应该怎么去写，怎么去规范 a i 它的一个输出。比如说像第一个我们权限模块是用于进行权限控制，你这样写的话会比较宽泛，然后每一次模型再去查找的时候，它读取完这句话是没有任何信息含量的。相对来说信息密度是比较低的，他还是会去触发他查找文件，查找代码。

🔵 说话人3 [02:10:42]
我们如果写的详细一点，就是权限和菜单模块是负责整个用户登录后加载角色，权限字符和动态路由是负责控制页面的显隐。那么他就会知道我们如果要去看为什么页面没有显示出来，或者为什么我这个用户信息是错误的，他就会去找用户登录后的一些操作。这个信息的密度会对 AI 来说会相对更高的。

🔵 说话人3 [02:11:26]
这就是一个核心对象的一个写法。刚刚在文档中也看到了，它会分为用户角色,菜单权限,字符,部门,以及后面的操作。

🔵 说话人3 [02:11:52]
这个就是风险点的，用户的 ai 输出风险点。像权限有风险，基本上是去年的一个模型，它会这么去输出，比如说这个功能模块儿怎么可能会有问题，但是像今年的模型已经很少会出现这么笼统的答案了。更多是会写明具体条件。比如说是只控制了前端显示，没有校验后端接口，还有一些用户可以直接绕过前端去登录。"检查,检查了有没有,有没有权限注释"。

🔵 说话人3 [02:12:44]
这个就是 AI 给的改造建议。这个改造建议通常会用到我们对我们对业务模块儿可能比较熟悉，但是又不会很了解。

🔵 说话人3 [02:13:06]
又不会很了解，那么我们可以去咨询模型，我们应该从哪里去改造，去优化它。但是这里的改造建议一定，AI输出也都是具体可落地的。比如说它会具体到它首先会有一个优先级，比如说我是 P 零，逼一，逼二，逼三，优先级越高的，它可能会越推荐你改。然后呢优先级低的，可能就是一些无关紧要的，是代码优化的一些东西。这时候我们要考虑的是改完优先级高的，他的优先级高的可能更多的是从整个逻辑出发，说要重构整个模块儿，或者说我整个模块儿要放到 a 文件里不合适。

🔵 说话人3 [02:13:57]
我要放到 b 文件里，这种我们就要思考他改完会不会影响我们的收益，就风险和我们的边际收益成不成正比。如果说我们的功能是没有问题的，那么他只是改一些优化点，让我们的代码更规范就可以。

🔵 说话人3 [02:14:25]
上午的课基本上就到了这里，然后是大家有什么问题可以提问，如果没有问题的话，我就接着往下说。

🟠 说话人5 [02:14:45]
这个老师刚才你不是说那个思考过程怎么去配置?

🔵 说话人3 [02:14:52]
而思考过程去配置这个就因为这个闪动比较快，因为我们

🔵 说话人3 [02:15:10]
在这里我们可以写一些 agentsmd 或者写一些规则，然后限制约束，这样他基本都会有很成熟的一个方案。

🟠 说话人5 [02:15:30]
那会不会造成消耗更多的成本?

🔵 说话人3 [02:15:34]
嗯这个肯定是会的，因为按照模型的一个整体逻辑，比如说我导入到把这个写完之后，它是在你每一次的上下文里都会带着这个相当于是一个求约束它一定是会消耗你的 token 然后你这时候我们就要去平衡你。的是写完这个你的收益高呢?是你是消耗一定量的 token 然后让你的产物变得更可用，还是说我不断地去对话，通过对话去约束它的一个产物，实际上是两种思路那这个在 m m 对呀。

🟠 说话人5 [02:16:22]
现在这种嗯怎么去约束它?就是说让它好好完成功能嗯这个我可以，稍等一下，我找一个

🔵 说话人3 [02:18:13]
这个是比较常用的一个规则，首先要求它比较简洁，然后就是深度分析，然后渐进式开发。

🔵 说话人3 [02:18:27]
最后就是要求中文必须使用中文。

🔵 说话人3 [02:18:35]
然后这个是版本的一些回溯要求， git 版本回溯要求。

🔵 说话人3 [02:18:46]
最后这个是一些检查的清单，如果我们根据项目，比如说根据项目有一些特殊的规范，我们才能根据项目去编写这个规则可以就是全公司统一的规则，还是某某一类项目的规则?比如说你像上边儿这些，这个是可以作为统一的规范。然后你下面儿这个的话就要看你能不能通用于所有的项目，比如像这个的配置里是因为我装了一个历史版本的插件，所以它会去查询这个。

🔵 说话人3 [02:19:37]
然后包括有一些对比的规则，甚至就是说对直接你可以直接在这边儿去

🔵 说话人3 [02:20:53]
这个他会直接去编辑整个目录。

🔵 说话人3 [02:21:02]
像这种就是我放到了点儿税，它就是关于整个项目群。

🟣 说话人2 [02:21:09]
这这是项目级的是吧?对。

🔵 说话人3 [02:21:14]
也可以在这里新建的时候会有全局和项目，然后加到全局里面，它会在你安装时，整个 tree 会有个安装文件，它会在那个安装文件里面构造一个 tree 的隐藏文件，然后里面会有这个东西。然后常见这个智能体。

🔵 说话人3 [02:21:57]
书里也提到会有一些智能体，然后不同的智能体去做不同的事情。所谓的一个智能体就是可以理解为一套核心提示词，然后有一些工具偏好，还有规范约束。所谓核心提示词就是你将会要求他，比如说你是一个产品经理，或者说你是一个架构师，然后呢你在要求他用什么工具，你必须用什么。啊，JIRA去构建流程图，或者你必须用MD去输，就是你必须每一次对话都会有档有档。

🔵 说话人3 [02:22:43]
然后你再去约束他的规则，比如说你架构师的规则就是。你所输出的架构要符合项目的实际规范。必须遵循通用的必须遵循通用的 MVC 架构，像这一类的。然后尽量使用或者尽量使用单体项目，使用微服务。这些你做好约束之后，他就会自己去根据这个你的条件去那个。或者你最简方案生成。

🔵 说话人3 [02:25:01]
甚至像刚刚的一些规则，我们也可以让 AI 去完整编写。AI 也会读到你整个项目的架构。然后他会写一套适合自己的。

🔵 说话人3 [02:25:23]
像我们之前都会有代码规范。嗯这个就是生成的。

🔵 说话人3 [02:27:24]
这时候我们就可以用我们刚加的 a 阵去跟它对话。

🔵 说话人3 [02:27:41]
其他在跑的过程，我们再看一下别的菜单。基本上现在通用的 aiid 就是这么几块儿，智能体，然后 mcp q是 tree 自己独有的。然后它的一个核心逻辑就是你在代码中，它能提供根据你代码的上下文，然后去提供它认为对的一个输出，然后你点推广，它就自动掉到文档上了。它和别的 aiide 有个大区别就是别的 aiide 会不能跨文件去内部补全，这个是可以的。

🔵 说话人3 [02:28:28]
另外这个就是模型，这里没有什么好看的。

🔵 说话人3 [02:28:35]
还有代码流，对话流。嗯其实像这个文档集，我们就可以把这个 wiki 放到它的文档集里去。

🟣 说话人2 [02:29:30]
它这个 wiki 不是所有内容还是针对某个项目?这是针对某个项目。

🔵 说话人3 [02:29:37]
这个引导词是针对于你当前的项目。

🔵 说话人3 [02:29:48]
通用的话我只建议增加企业专属对，一个是这个，还有一个就是只建议增加像通用的智能体或者通用的 skill 像这些我们可以增加通用的

🔵 说话人3 [02:30:21]
这些增加通用的，然后我们在项目里可以添加项目自己的。

🔵 说话人3 [02:30:38]
钩子这应该是新版本新增的吧?

🔵 说话人3 [02:31:17]
像刚刚这个，我们去让他用这个架构顾问的 agent 去从业务角度分析录一。

🟡 说话人4 [02:31:39]
我们还可以就是再不用这个架构，再去和他对话，用同样的提示词，这样的话我们就可以看到我们添加的这个 agent 是不是符合自己需要的，刚刚这个也是自己生成的。

🔵 说话人3 [02:32:11]
可以简单看一下它这个生成的就像这套关键词，比如说我们把它复制出来，放到你的

🔵 说话人3 [02:35:01]
就同样的提示词，然后我把刚才的 agent 变成了 sql 然后这时候你只需要分析项目架构，然后它就会调用这个 sql 它是本质上跑的还是刚刚这个架构顾问的提示词。

🟣 说话人2 [02:35:27]
效果是一样的对，效果是一样的。

🟥 说话人7 [02:35:34]
这里边儿细微的差异后面我单独说一下儿。

🟠 说话人5 [02:35:40]
但它这个不就会占用一个本身的摄象头吗?是我我理解的智能体它是可以单独开一个端口，进行一个摄象头的，比如说把之前的一些摘要给放到新的智能体里面，然后再加上这一个特定的任务，然后让子智能体去执行。但是智能体它就可能会塞到整体的摄象头儿对，所以现在我这块儿是没有选刚刚架构师的 agent 选的是他自己原来的 agent。

🔵 说话人3 [02:36:13]
他们会有一些差别，但就像你刚说的，实际上本质上还是提示词的一个差别。那么如果你觉得你每次都需要用这个提示词，你就把它放到 agent 里，你只是需要你特定场景，然后使用 skill 即可。

🔵 说话人3 [02:36:55]
然后可以看到说基本上虽然说有一些有一些格式上的出入，但是都是能把整个项目给梳理清楚的，这方面是没有一个特别大的问题。至于还会有 m c p m c p 就是调用工具。m c p 和 sql 的区别，因为现在在 sql 里也是可以通过写一些脚本或写一些代码去调用工具，所以很多时候大家会觉得是不是 sql 能替代 m c p 这种的。

🔵 说话人3 [02:37:37]
但实际上它们两个的区别是在于一个作用范围上。比如说我只是能在我当前的全局，就是我配到全局也好，配到项目也好，它只是能在我当前的绘画，我去通过绘画去调用这个，但是我 m c p 的话，我可以对外提供成服务。就是我不仅我自己能调，然后我开发出来，我在其他场景也能调。

🔵 说话人3 [02:39:01]
这个 box 的规范应该是和扣的 x 保持一致的，然后我们在里面可以定义一些它在什么情况下执行哪些脚本儿。嗯

🔵 说话人3 [02:40:57]
这个是刚刚用架构顾问这个智能体，然后让它从业务角度去分析返回的结果。可以看到它会把你的关键词加入到智能体上下文之后，它还是会以你的关键词为准，就是关键词的优先级会高于它的一个会高于智能体里面带的一个优先级。所以说它会增加一些业务的东西，就是解决了什么问题。但是可以看到从下边儿东西，从后边儿之后，更多的还是用架构的角度去分析整个项目。

🔵 说话人3 [02:41:48]
然后这个只是用了同样提示词的 skill 然后没有加关键词的约束，那么它就单纯的从整个设计架构上边儿去思考去去回复了，去梳理了整个项目，然后看到细微的差别，实际上就是在最开始上边儿有没有用，就是说这个项目是做什么的。之后可以对比大部分内容都是大差不差的。

🔵 说话人3 [02:42:31]
这也就是说，这验证了我们之前生成的 wiki 的文档可能大家每个人的提示词习惯不一样，然后它生成的东西可能也会有一些区别，但基本上内容是准的，那么我们后续就没有必要再去频繁的生成它，然后就可以在规则里去配置。只有代码或项目架构发生变动时，再去触发它的更新。

🔵 说话人3 [02:43:10]
好，那大家还有什么问题吗?

🟥 说话人7 [02:43:12]
对，我们接下来答疑吧。

🔵 说话人3 [02:43:14]
嗯，接下来答疑，然后上边儿上午这些内容大家有什么问题?

🟠 说话人5 [02:43:25]
问题你们就是既有工程的改造应该大家都遇到过，有什么实际工作有什么问题可以问一下老师说的都是干货，哎有什么实在的问题行这个这个我说一个问题，因为原来我们有这个十十来年的那个老工程对吧?然后我们比如说想新加一个功能，有新需求了我们就想着能很容易的在这边儿加，结果好像把我原来的工程搞坏了就是说然后怎么修复也修复不了。

🟠 说话人5 [02:44:01]
反正我用这个的时候，我实际用的时候，另一个就是说有时候我那个我那里面的注释啊，或者是什么呀，里面如果是中文的，还搞不清楚。

🔵 说话人3 [02:44:14]
也就是说我在使用过程中，其实它对这个老工程好像没那么友好，就是后来我还是用的那个代码平台的那种方式把问题解决掉了。如果说把工程交给他，然后我告诉他我加个什么功能，目前来说还没有完全成功过当然如果说从零做，比如说给我做个登录界面，或者给我做个收银菜单。

🟠 说话人5 [02:44:47]
这些都是可以成功的，但是在我原来的工程里面我想做的刚才实现什么功能，目前来说我们还没做成功啊，应该是可以成功的，你要反复就首先你刚说的那个中文乱码。

🔵 说话人3 [02:45:05]
中文乱码现在这个说实在的，在我刚参加工作时也碰到过，就可能有一些老项目，他用的中文编码是 GB 或者 GBK 的，但后面儿基本上都是 UTF 杠八的。所以就是说我们先第一步先把项目能无损的把它的中文编码迁移过来，这个基本上都会有现成的。

🟠 说话人5 [02:45:35]
嗯嗯无损的迁移嗯就是说能保证原有的是好的

🔵 说话人3 [02:45:46]
你看像这个它就会有配置，现在基本都是 utf 杠八的。然后对老项目也是，你就是像这种简单的问题，你直接问他他原来使用的哪些编码。如果是也是 java 项目的话，基本上大差不差，都是这种格式，它会有配置文件。你先迁移到 utf 杠八。然后迁移过程中可能就是 jdk 和 utf 杠八，它对中文对应的编码是不一样的，签完可能会有乱码，你这种你可以先迁移成一个没有中文库的语言编码。

🔵 说话人3 [02:46:37]
迁移到一个没有中文库的语言编码，然后你再转成 UTF 杠八，这样的话就能切过来。切过来之后，至于你说的，比如说他敢增加一个完全的新的功能模块儿，他就得需要足够的上下文，首先他得了解你这个项目是做什么的，你还是得先把项目丢给整个 ai。

🔵 说话人3 [02:47:12]
就大模型它本身还是一个概率模型，基于神经网络的概率模型。所以说你丢给他上下文，他是推测根据你这个上下文大家使用的哪个字符会概率更高。比如说你就问他今天天气怎么样，然后他实际上不知道今天天气怎么样，但他会去调用他的一个训练数据，然后大部分人都说今天天气是晴，那么他就会给你回复今天天气是晴，哪怕是在下雨，他也会跟你说今天天气是晴。

🔵 说话人3 [02:47:50]
这时候就是会有一些就加了 m c p 这种工具，他会你再问他今天天气怎么样。它会调用天气的接口，然后告诉你今天是下雨。所以就是你你你那个项目，它如果没有足够的训练数据，那么它确实很难推出你下一步代码是如何编写，如何开发。你需要第一个是把你的整个业务逻辑给它。

🟠 说话人5 [02:48:21]
但是把项目结构给它，业务逻辑给它，然后这时候你再去让它出方案。实际上就是我的项目的业务逻辑对吧?或者是执行逻辑，我怎么给他本身就是一个问题对吧?你比如说我是通过一句话，一句话或两句话，或者反复告知他对吧?我也测试过，反正就是测试了几次，可能还不如我把我用那个代码补全，比如说我说的在某个方法加个什么方法，马上给我，我考过去，可能稍微有

🟠 说话人5 [02:49:04]
对那个还没有那个效率高，就是说如果我自动给他，我觉得像个死循环一样，不是这儿差点就是那儿差点，就是很难因为你看啊，像你用代码补全，然后它给你加完你再粘过去。

🔵 说话人3 [02:49:20]
实际上是因为它拿到了你这一块儿代码足够多的上下文，所以它推断的会比较准。那么你就要在用 agent 的时候，就是说在让它完成整个功能模块儿开发时，你就要给它足够多的上下文，然后这个上下文怎么来呢?第一个就是你基于整个项目构建 AI 的认知，就构建模型的认知，不是说构建我们的认知，让它有了对整个项目的了解，然后你再去开发。

🔵 说话人3 [02:49:57]
开发的话，你选择应该是有个 plan 模式任务模式，这样的话它就会能更好的去执行。

🔵 说话人3 [02:50:22]
对，就是但是现在是这样，比如说我的项目对吧?

🟠 说话人5 [02:50:28]
他这个首先他背后那个比如说他那个字节那个模型，他从来没有用我们项目的代码去训练过对吧?他肯定是没有的对他肯定是没有的，就是说我怎么把我代码的这些逻辑关联关系啊对吧?你这东西给他，这本身就是问题啊。他会我喂给他以后，他就能消化，然后修改自己

🟥 说话人7 [02:51:00]
恩我打一下吧啊我我来答一下这个问题啊。刚才我也听这个 smart 刚才也回，他逐步回答了这俩问题，我觉得是相当于俩问题嘛，一个是咱这个中医编码，另一个是我们老项目在这个 ai 加入的过程中，发现不如咱这个老师傅这个经验。这个字符编码这个问题其实是个工程化的问题，刚才 smart 也答了很多，可能需要针对性去看一看我们怎么来修复。

🟥 说话人7 [02:51:29]
因为传统情况下，技术点已经确认了，就是编码的问题，字符编码的问题。那么这些模型训练时，可能本身就不会在意编码问题，产生了说我们插入乱码了，这个算是一个工程问题，可以具体去看。这个现在就变成了说我们发现这个 ai 我们尝试来帮助提升工作的时候，不好，效果不好，比较差。这里也是可以分成两个点，一个是我们工程上怎么去优化它，再一个是怎么和 ai 做协作。

🟥 说话人7 [02:51:59]
工程化做优化呢，就是刚才 smart 去提这个设置时，我们有一个叫上下文规则叫入子，或者说一个叫 agency 的 md ，它的作用呢，就是在当前模块下约定当前的逻辑规则。这个的意思呢，是不是，并不是说一个项目中只能有一个，它可以每个文件夹，每个模块有一个。这样的话，比如我们在改这个用户密码的时候，可能完全和这个用户权限完全没关系。

🟥 说话人7 [02:52:29]
所以我们就可以在合适的文件夹下，下面去添加这个 agent agent 点 md 就是约束一下，说这个模块是改这个密码的，那我们去专注这一部分业务逻辑，让他去填充说这一块是怎么做的。这样说我们有一个渐进式的流程，对你的老代码来说，或对你这个已有的现有的超超大的庞大项目来说，就可以逐步来改。因为我们很少说，一个命令下去把所有模块都改了，一般是一个模块一个模块改，所以你尝试去让 agent 去跟你协作的时候，你可以试一下，就是在不同的模块下添加这个 agent 然后来约束它的改动。

🟥 说话人7 [02:53:08]
然后让它来理解。在我之前合作的一些项目中，也有类似和你这样困惑，就是他们有一些自动化的流程，非常的靠，非常的老。靠口口相传，甚至说文档也不齐，然后 ai 去尝试理解的时候，它只能靠猜靠蒙。比如我们有一个外置的命令，大家都是说上线是统一按在这里交给一个特定的人来操作，至于怎么操作，我们不知道，那 ai 它也猜不到，就只能靠乱编了，所以就产生了说效果不好的这个东西。

🟥 说话人7 [02:53:39]
这个话题呢，就变成了我们怎么把当前的业务流程迁移到更对这个 ai 更友好，或者说对普通新人更友好的一个话题上来了。那新人进来之后，怎么能像老师傅一样把这些流程，这些业务逻辑也能跑通，如果新人能跑通，那就意味着他的这个上下文加载好了。那我们有可能会说，我们有需要加载更多的这个 word 更多的这个计划是怎么回事。

🟥 说话人7 [02:54:06]
某些环节，比如说你所有的部署你都不用参与考虑，因为这个环节是人工来完成的，甚至说需要审批来完成，那就如果我们把这些约束告诉完之后，他后面就不会尝试自己去琢磨怎么去完成这些部署，怎么去完成这些测试了。之前有一个常见的案例是，他们有一个企业是做自动移动端自动化测试的，他们要测各种安卓，安卓非常复杂，AI就尝试去做了，发现效果很差，还不如他们新来培训的这三个月的员工呢。

🟥 说话人7 [02:54:37]
就交流之下发现，哦，新员工能接受到很多文档，这文档呢，可能在网站上，在内网上，在钉钉上，就分散比较多，可回到结合这个案例呢，就变成了说我们遇到这个问题，看怎么去解决表面的问题。就把这个信息灌给他，深层的问题是怎么把这个文档更好地组织到这个代码中，或者说我们刚才这个崔里面也有一个这个文档集的一个概念，就是把这些文档喂给他。

🟥 说话人7 [02:55:05]
让他去尝试发现代码中没提到的部署怎么来做，某个模块要怎么来上线时，有可能去，他会去查这个文档集，当然这一个点又变成了具体的功能怎么来使用，然后工程上怎么来优化。这个也是我们需要点对点去看，所以回回归刚才提的这俩问题，基本都是可以从工程角度就是我们怎么去解决这个具体的问题。另一个像另一个角度就看怎么让 ai 去，他可能他能力只能读 utf 杠八，或者只能读你给的代码，你不给他文档，他就猜不到，也只能靠瞎编，怎么去引导他解决这个事。

🟥 说话人7 [02:55:44]
或者说现在相当于塞入一个实习生，他刚大学毕业，或者还在上学，怎么尽快和你有相似的认识，他可能很多细节不了解，但是你给他指点一下，他可能根据文档一步一步来操作。那 ai 和这个时候就和新实习生是一样的。能够一点一点的在你的引导下，逐步提高他的工作效率，减轻你的工作负担。

🟥 说话人7 [02:56:11]
就这样，我是想尝试说表面和深层的两个角度都看看怎么来结合，但具体能不能解答好你的问题，或者说怎么让崔来辅助好你的工作，可能需要点对点的去来看。我们去单独去讨论去去落地这个事情。

🟢 说话人1 [02:56:28]
那个要不中午就到这里，到饭点了，到下午两点，还在会议室。

🟥 说话人7 [02:56:37]
啊，你下午想说啥?我可以说。

🔵 说话人3 [02:56:43]
接着往下说。

🟥 说话人7 [02:56:44]
对你说第二天还是第一天还有内容?

🔵 说话人3 [02:56:47]
第一天基本没了，就接着说，然后不是要压缩嘛。

🟥 说话人7 [02:56:51]
嗯嗯，那个功能串点我也可以说，就是这都 ok 比如那个串刚才串库克斯的，库克斯看来他企业版才有，我查了一下，个人版还没有。这个就和科瑟对这个就和科瑟对齐了。

🔵 说话人3 [02:57:06]
吃完饭你中午可以午休，你午休也可以在这。嗯。好。



---

## 🔗 原始音频

- 链接：[音频文件](https://get-notes.umiwi.com/get_notes_prod%2F202606131325%2Fgetnotes_lcf_1a8b3a7840202a38H8r8ajID.mp3?Expires=1790150072&OSSAccessKeyId=LTAI5t7toTp72R3TvdXf9QdK&Signature=i04tcswKusEbu2u5DF6cBJf9ytU%3D)
- 时长：177分11秒