No.159 对谈蚂蚁小刀：CodeFuse 如何将程序员生产力提升 50%
48:58 Share

欢迎 大家 收听 三 五环， 我是 刘飞， 今天 邀请 到 的 是 小刀， 先 打 声 招呼。

Hello 大家好， 我是 来自 蚂蚁 集团 的 小刀， 主要是 负责 效能 这 一块 的 一些 事情。

今天 为什么 邀请 小刀 呢？ 是因为 最近 看到 一个 新闻， 然后 这个 新闻 跟 小刀 在 做 的 产品 code fields 有关系。 因为 code fields 是 面向 程序员 的对， 面向 技术， 就是 跟 写 代码 相关 的 一个 AI 产品。 我们 今天 就 顺着 这个 聊 一 聊 延伸 出来 的 一些 观点 和 话题。 好 呀 好， 在 聊 之前 能不能 小刀 先 跟 大家 介绍 一下 自己。

大家好， 我是 一名 普通 的 产品 经理， 来自 蚂蚁 集团。 然后 现在 目前 的话 是 主要 负责 和 研发 效能 相关 的 产品， cos 是 其中 的 一个。 然后 我也是 在 二三年 的 时候 和 团队 一起来 去 打造 confuse 这样的 一个 编码 助手 的 产品。 目前 的话 整个 confuse 在 蚂蚁 内 的 落地 整体 也是 我们在 负责。 所以 其实 对 今天 的 这个 话题 的话 是 有 一些 自己的 想法， 包括 我们在 蚂蚁 落地 过程 中的 一些 实践， 可以 和 大家 去做 一些 分享 的。

好， 我们 就 进入 正题， 看到 很多 地方 在 转 的 一个 新闻。 这个 新闻 说的是 国际清算银行 报告 显示 A I 编程 工具 对 程序员 生产力 提升 达 50% 以上。 在 国际清算银行 发布 的 这个 叫 年度 经济 报告， 这个 报告 说是 给 各国 中央银行 服务 的， 就 相当于 央行 各国 的 央行， 他们 会 看 这个 报告， 这个 报告 就 代表 着 可能 现在 经济 上 的 一些 变化， 或者说 一些 值得关注 的 点。 这 里面 就 提到 对 1219名 蚂蚁 的 程序员 编程 的 情况 做了 实验 跟踪。 然后 每个 程序员 跟踪 周期 是 14周。 通过观察 在 使用 code fields A I 编程 工具 的 时候 对 生产力 提升 的 情况， 得出 的 结论 就是 生产力 的 提升 在 50% 以上。 因为 这个 他 就 提到 了 就是 通过 code fields 去做 的。 那 能不能 介绍 一下 code fields 到底是什么， 以及 说 这个 实验 的 结论 到底 意味着 什么？

我 今天 先 简单 介绍 一下 code fuse， 然后 再 和 大家 分享 一下 这个 结论 的 一些 过程。 首先 co fix 其实 在 刚 开始 也 和 大家 介绍 了， 他 现在 的 定位 是 对于 编程 同学 来说 或者 程序员 来说， 它是 一个 编程 助手。 可能 大家 理解 起来 的话， 就 相当于 是 比如说 程序员 以前 是 自己 去 写 代码， 然后 包括 去做 写 代码 一些 相关 的 一些 工作。 那 这部分 的 工作 的话 可能 会 现在 借助 code fuse 这样的 产品 来 帮 他们 去 完成。 比如说 code fuse 可以 提供 一些 代码 续写 这样的 能力。 你 在 敲下 快捷键 之后， 就 可能 会 根据 你的 上下文 去 帮你 生成 相应 的 代码。

其次 的话， 他 会 在写 代码 的 过程 中帮 你 去做 一些 其他 的 事情。 你 比如说 你 要 去 检索 一些 知识 和 内容， confuse 其实 也可以 帮你 做。 所以 code fuse 它 目前 的 定位 的话 是 辅助 程序员 写 代码 的 一个 这样的 工具 或者 是 助手， 大概是 这样的 一个 定位。

有点像 我们 现在 会 用到 的 一些 A I 文档 相关 的 功能， 对 吧？ 就是我 可以 去 写 一个 文档， 我 有一个 主题 了， 我可以 让 那个 A I 帮 我 去 写下 文， 我 根据 上下文 做 一些 总结， 做 一些 判断。 生产力 提升 的这 意味着 什么 呢？

这次 的 国际 侵权 组织， 他 带来 的 这个 实验 的话， 应该 是 比较 官方 的， 或者 是 比较 三方 的 一个 权威 的 报告。 然后 蚂蚁 其实 在 这 里面 的 主要 作用 是 作为 落 地方， 就是这样 的 生产力 工具， 它 一定 是要 在 企业 落地 能够 看到 一些 效果 的那 蚂蚁 只是 说 在 整个 环境 中， 它是 作为 整个 的 数据 提供方。 我可以 简单 分享 一下 是 这个 实验 它的 一些 开展 的 思路。 基本上 的 实验 会 把 它 分成 实验组 和 对照组。 这个 所谓 的 实验组， 是 我们 去 观察 了 一些 真正 在 编码 过程中 使用 code fuse 的 这些 用户 群体， 称之为 实验组。 非 实验组 的话 就是 还是 用 传统 的 方式 再去 写 代码， 没有 去 使用 对应 的 A I 的 这些 工具。 对 我们 分成 了 这 两组， 然后 去 对比 他们 在 这个 实验 期间， 或者 是 我们 叫 观察 期间， 最终 他们 生产 看 代码 的 整个 的 量。 其实 从 综合 的 结果 来看， 我们会 发现 实验组 在 整个 期间 之内， 它 生产 的 量 其实 是 超过 50% 的。 所以 这个 50% 更多 的 是 说 在 整个 观察 期间 它 生产 代码 量 确实 是 超过 50% 了。

他们 做 的 都是 一些 真实的 业务 项目， 对 吧？ 都 是在 做 业务 的 程序员。

是的， 你可以 理解， 其实 整个 项目 对 这些 同学 是 完全 不 感知 的。 只是 说 我们在 客观存在， 在 这些 使用 人群 和 非 使用 人群 中 选择 了 一些 特征 比较 相似 的。 比如说 工龄， 然后 以往 的 代码 量 这些， 然后 去做 一个 这样的 对比 和 参照。

生产力 的 提升 它 到底 意味着 什么？ 因为 像 刚才 说 的， 听起来 code fields， 它 不是 直接 生成 代码， 对 吧？ 对它 更多 的 是 做 辅助。 这个 辅助 的 点 在 什么 地方？

其实 它 会有 整个 生产力 提升 的话， 可能 会有 我 认为 有 直接 和 间接 的这 两种 方式。 直接 的话 就像 我 刚才 提到 的， 它 会 根据 你的 上下文 直接 帮你 继续 写 代码。 那 直接 就 相当于 是 我可以 已经 帮你 去 生产 代码 了， 你 直接去 按下 tab 键 去 采纳 就行了。 这是 直接 的 一种 体验。 但是 这个 确实 不是 影响 最大 的。

其实 A I 的 这些 生产工具 带来 的 更多 的 是 一些 间接 的 体验， 怎么讲 呢？ 就是 其实 以前 大家 在写 代码 的 过程中， 不 纯粹 是在 coding 这 一件 事情。 他 可能 是 需要 去做 一些 额外 知识 的 检索， 然后 想要 去 看看 别人 以往 是 这个 方法 是 怎么 写 的对， 那 以前 的话 你 可能 是要 去 不同 的 平台 上去 检索 不同 的 知识， 然后 去 学习 别人 怎么 写， 甚至 看 多人 怎么 写， 然后 再 综合 自己 在 自己的 这个 场景 下 怎么 去 实现。 现在 的话 如果 有了 A I 这样的 工具 的话， 它 其实 帮你 减少 了 非常 多 检索 的 成本 以及 总结 的 成本， 以及 帮你 去 挑 所谓 好的 用法 的 成本。 它 其实 在 这些 方面 也 给 程序员 带来 了 非常 多 的 可能性。 对， 就 相当于 是 把 以前 非常 冗杂 的， 但是 显得 没有 那么 有 必要 的 这些 工作， 把 它 变成 了让 AI 去做， 然后 自己 就 专注 放在 自己的 业务 逻辑 本身 上面。 所以 我们 其实 评估 下来， 这个 间接 影响 其实 会 比 它 直接 扣定 的 这个 影响 带来 的 效果 是要 更 显著 的。

对你说 到 这个， 其实我 能 想到 比较 真实的 一些 场景， 我 之前 也是 计算机专业 的， 现在 写 代码 和 可能 20年 前 不一样， 就是 有 很多 开源 的 框架， 或者说 有 很多 成熟 的 经验。 可能 包括 有 一些 配置 的 过程， 配置 的 一些 问题 等等。 你是 需要 有 很多 知识 储备 的， 而 不是 简单 的 说 我 只需要 知道 这个 写 代码 里面 的 一些 循环 逻辑 或者 什么 就可以 了。 是 这个 过程 当中 会 发现 有 很多人 就会 遭遇 这种 问题。 大家 就会 去 什么 C S D N， 或者说 什么 其他 的 各种各样 的 网站 上去 搜索， 去 查询。 对， 这个 其实 是 A I 比较 能 帮助 解决 的， 它 可以 提供 很多 就 告诉你 你 这个 问题 可能 出 在哪儿， 为什么 这个 进程 运行 不了， 配置 可能 哪 有问题 等等。 我 大概 能 get 到 这个 点。

是的， 你说的 这个 其实 和 现在 程序员 遇到 的 问题 差不多。 然后 这个 其实 也是 AI 能够 帮助 他们的。 因为 我们 最近 也 刚好 在 内部 去 做了 一份 code fuse 的 这个 所谓 的 用户调研。 因为 code fuse 在 蚂蚁 应该 会 覆盖 了 百分之五六十 的 用户。 最近 我们 也 发起 了 一些 调研。 然后 我们 从 调研 问卷 里面 也能 看到， 大家 其实 是 希望 COO fuse 能够 帮 他们 做 一些 类似 于 代码 理解。 就 相当于 是 我在 看 别人 代码 的 时候， 就是 这个 理解 的 成本 比较高， 然后 你 直接 帮 我 去 把 它 解释 清楚。

对我 了解到 的 大部分 的 程序员 朋友 可能 注释 写 的 也 不是 那么 清晰。

尤其是 那个。

代码 量 多了 之后， 大家 也 知道， 组织 内 肯定 会有 各种各样 的 调整。 那一个 新的 程序员 一个 技术 来 接手 的 时候， 就会 发现 之前 他 到底 是 写 的 什么。 对， 不敢 动 了。 很多 自己 阅读 当然 能读懂， 但是 成本 很高。 对， 这个 很 像 现在 大家 对 技术 不太熟悉 的 朋友， 可能 比较 容易 理解 的。 就是你 你 开 一个 长篇 的 文档， 你 像 很多 听 播客 的 朋友 也会 把 那个 播客 转成 文字 再做 一些 总结。 就 大概 知道 他 讲 的 什么 事情， 就 包括 读 论文 的 朋友， 最近 很多 就 喜欢 用 这个 A I 做 总结。 也是 的对 对， 所以 这个 我 能 理解 到 它是 很 有 帮助。

对， 所以 其实 这些 的 影响 的话， 它 不是说 A I 直接 帮你 写 代码 这么 简单。 这就是我 刚刚 说 的 所谓 的 间接 影响。 就是 它 可以 帮你 做 除了 写 代码 以外， 就是 周边 的 一些 辅助 你 写 代码 的 一些 事情。 其实 你 刚才 也 讲 到了， 很多 同学 他 可能 不太想 自己 写 注释。 但 其实 现在 你 完全 可以 借助 A I 帮你 去 写 注释。 这样的话 让 你的 代码 的 可读性 也会 更高 一些。 甚至 它 可以 帮你 去做 一些 代码 的 重构， 让 你的 代码 看起来 就 更 优雅 之类 的。 所以 它 其实 完全 都 可以 去 帮你 去做 coding 相关 的 非常 多 的 事情。

因为我 平时 会 做 内容 创作， 就 写 很多 文字。 我 发现 他 帮忙 做 一些 辅助 的 工作， 比如说 知识 获取、 整理， 然后 总结 是 OK 的， 但是 他 直接 帮忙 写 还是 有 困难 的， 是不是？ 现在 对于 code fields 来说， 它 也 很难说， 我 就要 做 一个 什么 A P P 对 吧？ 我 做 一个 什么 功能 它 能 直接 写 出来。

这种 其实 看 场景， 因为 代码 的话 可能 会 相 比较 文本 的话， 它的 结构性 会 稍微 好 一些， 所以 其实我。 比方说 A I 可以 写 一部分 代码， 是 它 可以 理解 你的 代码 上下文 甚至 相关 的 文件。 他 知道 你 这个。

文件 这个 地方 可能 缺什么 东西， 他 就有 的 都能 补上。

对， 有什么 for 循环 或者 是 有什么 逻辑， 它 其实 是 可以 理解 一部分， 然后 帮你 去 补 一部分 的。 所以 这个 是 相 比较 文字 这种 非 结构化 的 东西 要好 一点 的。 但是 像 您 刚刚 提到 的， 他 是不是 能够 完整 写 一个 应用 出来， 告诉你， 你 要 帮 我 写 一个点 餐 小 程序， 然后 你 就 快速 帮 我 写 一个点 小 程序。 这个 我 坦白说 就是 业界 可能 看到 有 一些 这样的 场景 在 落， 但是 大范围 的 去 使用 可能 还是 是 有点 远 的对， 因为 可能 A I 的 它的 理解 的 程度 还没有 那么 深入。 我 就 换句话说， 就 相当于 是在 一些 简单 的 场景， 它 其实 是 可以 帮你 去做 一些 续写 的。 但是 如果 涉及到 相对 比较复杂 的 业务 逻辑， 我 就举 个 最简单 例子。 你 在 淘宝 下单 的 时候， 你 整个 结算 的 这个 逻辑， 它 背后 其实 对应 的 链路 非常 长。 那 这个 时候 你 想 去 加 一种 新的 结算 方式， 你 让 A I 去 写， 他 可能 就会 懵 掉。

因为我 之前 也 做 产品 经理， 你 写 过 代码 其实 是 知道 从 产品 的 需求 转化成 代码 具体 要 怎么 实现。 它 不是 一个 简单 的 说 同一个 需求 就 只有 一种 方法 实现。 它 有 很 多种 方法， 甚至 这些 方法 它 适应 不同 的 业务 逻辑。 是的， 你 可能 要 做 很多 人的 判断， 判断 对你 才能 知道 用 什么 写 出来 比较 好。 那 他 最后 确实 能 实现， 但 它 实现 的 不一定 是 满足 你 需求 的。 他 可能 用 的 架构 不对， 用 的 技术 合适 等等， 有 各种 这种 情况 会 出现 的。

是的， 对。 所以 我们 现在 比较 在 尝试 的 就是 当 他 一 拿到 一个 相对 明确 的 研发 任务 之后， 这个 研发 任务 是 指的 是你 就 帮 我 去 修改 一个 确定性 的 接口， 然后 他 就会 帮你 再去 做 这种 比较 明确 的 事情。 像 您 刚刚 提到 的 很 靠 前 的 产品 侧 的 需求， 中间 涉及到 大量 的 需求 拆解、 任务 拆解， 甚至 包括 系统 的 分析。 那 这部分 的话 确实 现在 还没有 那么 擅长。

然后 我 看到 在 新闻 里 会 提到 一个 结论， 就是 相比 直接 代码生成 A I 更能 激发 程序员 的 创造性。 那 这 里面 应该 怎么 理解 这个 创造性 呢？

首先 的话 他 会 把 程序员 的 一部分， 原来 耗 在 其他 所谓 的 繁杂 这些 事情 上 的 精力 能够 释放出来。 能够 更 让 他 有 更多 的 时间 专注 在 自己 业务 代码 本身 上面， 或者 是 自己的 这个 逻辑设计 本身 上面。 这 其实 是 一部分 的， 就是 让 他的 精力 更 集中。 另外 的话 就 刚刚 也 提到 了， 实际上 你 之前 去做 一些 检索 的话， 实际上 都是 有 比较 有 目的性 的。 但是 AI 可能 会 通过 他 自己的 一些 总结 甚至 发散， 可以 给你 带来 一些 更好 的， 甚至 出其不意 的 一些 方案 出来。 对 这方面 的话， 我 理解 对 大家 也是 一个 帮助。

对 最终 可能 还是 要人 做 判断。 因为 人 做 判断 对 但 过程 当中 可能 他 会给 你 一些 可 选 的 方案。 这个 方案 可能 之前 想不到 的， 现在 很难 做到 说 直接 让 A I 就 帮忙 生成 一个 最佳 的 方案。

坦白讲 是 比较 难 的。

是对 那 在 这个 实验 过程中 有没有 什么 觉得 有意思 的 发现？

因为 程序员 的 最终 的 产物， 当然 他 过程中 肯定 做了 非常 多 的 事情， 但 它 最终 的 产物 可能 就是 发布 到 线上 的 这些 代码。 刚刚 说到 的 50% 也 只是 说 相 比较 来说， 实验组 的 代码 量 有 50% 的 提升。 中间 过程中 的话， 我们 其实 也是 在 分析 这 50% 的 代码， 它 到 你是 怎么 来 的。 我们会 发现 其实 真正 N I 生成 部分 的 比例 是 非常少 的。 我们 现在 从 代码 写 完 到 提交， 其实 中间 也会 有 非常 多 的 所谓 的 流失。 因为 有 一部分 代码 它 可能 还会 保存 在 自己 本 你 去 运行， 并 不会 提交 到 原单 仓库。 那 真正 的这 50% 提交 到 原单 仓库 里面 的 比例 是 比较 少 的。 所以 更多 的 部分 还是 在 我 刚刚 讲到 的 A I 提供 的 这些 间接 的 影响力。

然后 我们 也 想 去 了解 这些 间接 的 影响力 到底 有什么。 所以 我们 其实 自己是 做了 一些 所谓 的 用户 访谈， 当然 后面 会有 更 科学 的 方式 来 帮 我们 去 考证 这个 更多 的 间接 影响力 在哪里。 但是 从 访谈 的 结论 来看， 就是我 刚刚 跟 您 分享 的， 可以 帮 他 去 解决 一些 知识 获取 的 难度 的 问题。 比如说 我要 去 接触 一种 新的 编程语言， 或者 是 了解 一些 新的 实现 方式， 这些 A I 都 可以 快速 的 帮 他 去做 实现。

有一个 非常 有意思 的 事情 就是， 蚂蚁 的 同学 更多 的 是在 服务端 写 的 是 java。 但是 当 我想要 去 写， 有一个 东西 是 写 排 想 去 完成 的 时候， 那 以前 对他 来说 可能 就是 一个 非常 有 挑战性 的 事情。 现在 的话 基本上 你可以 把 你的 诉求 非常 描述 清楚 之后， 他 就可以 帮你 去 实现 python 脚本 这些 的 这些 对于 大家 来说 都 是一个 非常 好的事情。

我们 还有一个 有意思 的 发现， 就是 越 会 用 A I 的 同学， 他 能够 越能 激发 整个 A I 对 他的 帮助。 但 目前 来讲， 它 还是 一个 比较 先进 的 生产力 工具。 其实 你 能 更好 的 应用 它它 才能 更好 的 帮你， 而 不是说 放在 那里 你 去 随便 运用 就可以 的对。

我的感受 也是 这样， 就是现在 的 A I 虽然 大家 都 知道 ChatGPT 引发 了 这次 的 大 模型 这个 浪潮。 大家 都 知道 A I 的 水准， A I 的 效果 已经 比 过去 的 A I 好 很多。 但是 它 并不是 一个 强 人工智能， 它 并 不是说 什么 都能 搞定， 它是 一个 大家 看到 科幻片 里 那种 机器人 一样， 一个 能 解决 一切 的 这么 一个 存在。 它 实际上 还是 一个 工具。

是的， 这个 工具 就像 有 一些 朋友 说 的， 他 觉得 这个 A I 工具 对我 帮助 不大。 我 跟 他 聊聊 半天， 他 这儿 说 的 不对， 那 说 的 不对。 但 实际上 很多 时候 你 要 知道 说 它 能 帮你 解决 什么 问题。 这 就像 我们 用 工具 一样， 你说 photoshop 好不好 用， 你你你 得 会 用。 对你 得 会 用。 你 有些 东西 不知道， 你说 他 怎么能 P 的 那么好， 对 这个 地方 怎么怎么 加 蒙版， 怎么怎么 加 这些 滤镜 效果。 对， 其实 是 需要 掌握 一些。 是的。

这个 其实 也是 我们 很 关键 的 一个 发现。 对， 很多 同学 可能 都 觉得 像 以往 的 工具， 像你 刚 讲 photoshop， 就 我自己 用 最 基础 的 那些 就 够了。 然后 要 深入 的话 我要 去 学， 他 有 这种 学 的 意识。 但是 可能 大家 现在 就 觉得 大 模型 足够 强 了， 我 好像 也 不用 深入 去 学习 它， 好像 他 就能 帮 我 发挥作用。 其实 现在 目前 这个 阶段， 其实不然， 还是 要 去 学会 去 用 它。

我们 很多 同学 他用 confuse 怎么用 呢？ 他 会 把 代码 的 注释 写 的 非常 清楚， 然后 它的 注释 是 通过 自然语言 描述 的那 写 的 清楚 之后 confuse 理解 了 这 段 逻辑性 很强 的 注释 之后， 它 就可以 帮你 去 生成 你 注释 里面 表述 想要 做 的 哪些 内容。 但是 如果你 这个 注释 本身 就 写 的 很差， 那 他 当然 理解 不了， 他 也 没法 帮助 你。 所以 其实 大家 就说 那个 prompt 是 非常重要 的， 或者 是你 得 知道 去 如何 去 写 这些 prompt， 才能够 更好 的 激发 它。

这个 跟 现存 的 大家 常用 的 A I 工具 ChatGPT 也好， made journey 也好 很 像。

对， 其实 是 类似的。 它 只是 换 了 一个 编码 场景， 而且 是 能 感知。

到 他 还是 有一个 学习曲线 的。 比如说 有 一些 程序员 他 一直 用 用 着 用 着 他 就 更 会 用了。

对， 确实 是的。 因为 我们会 和 一部分 的 用户 深入 去 沟通， 让 他 去 比较 深入 的 去 学习 或 使用。 我们会 发现 就是 用 的 越来越 溜， 这种 情况 就 跟 用 P 图 软件 一样， 也可以 用 的 越来越 溜。

在 程序员 的 一个 工作流 当中， 他们 哪些 工作内容 里 用到 的 会 多一些。

可能 要 先 大概 说说 程序员 们 每天 都在 做什么。 我不是 一个 程序员， 但是 我 周边 的 程序员 是 有 一些 的 我 对 他们的 观察 的话 不 代表 完全正确， 但是 有一个 这样的 比例 在， 其实 coding 的 部分 可能 只占 他们 工作 的 20%到30%左右。 对， 真正 他们 还要 去做 的 是我 coding 完 之后， 我 得 验证 我 这个 代码 本身 对不对。 对， 然后 再加上 我 可能 要 和 前后 端 一起 去做 一些 联调， 然后 这个 代码 如果 真的 没问题 的话， 我 可能 才 去做 发布。 所以 这 中间 过程 coding 只是 是 其中 的 一个。

包括 前期 可能 还要 做。

业务 的 沟通， 对 业务 的 沟通 需求 的 调研， 整个 架构 的 设计 等等。 对 目前 观察 的 是 我们在 比较 偏 刚才 说到 的 前端 的这 一部分， 就是 比较 偏 需求 分析 和 架构设计 这部分 confuse 目前 还 提供 的 也是 相对 比较 有限 的。 然后 自从 代码 生产 之后， 它 可能 会 发挥 一些 自己的 作用。 Coding 的 这个 环节 我 先 不用说。 另外一个 比较 值得一提 的 就是 我们 因为 现在 要 保证 你 代码 的 健壮性， 以及 代码 你是 经过 充分 验证 的。 我们 现在 有一个 环节 叫做 写 测试用例， 就 相当于 是你 写 了 一个 功能 之后， 你 得 有一个 相应 的 测试用例 去 匹配 它， 帮你 去 验证 这个 功能 是 OK 的。 所以 程序员 现在 之前 的话 会有 一部分 的 精力 在写 这个 测试用例。 那 写 测试用例 对 他们 来说 是 非常 痛苦 的， 因为 他们 得 去 便利 这 里面 非常 多 的 可能性。

对我 之前 有的 经验 是 可能 有的 时候 技术 都 写 不 完， 产品 也得 帮忙 写。

因为 场景 很多 场景 很多 很杂。 所以 其实 confuse 在 这个 时候 就 发挥 了 非常 大 的 作用， 特别是 蚂蚁 像 这样 对 整个 的 交付 质量 要求 比较高 的。 因为 它 必须 得要 你的 安全可靠 等等 这些 要求， 所以 我们是 对 整个 测试 的 覆盖率 是 有 一定 的 要求 的那 以前 的话 大家 会 花 比较 多 的 时间 去 写 测试用例。 这次 code fuse 能够 在 这个 环节， 也就是 在 测试用例 生成 的 这个 环节， 来 帮 他们 去 节约 非常 多 的 时间 和 精力。 调研 情况 来看 的话， 大家 对 这 一块 的 一些 效果 还是 相对 比较满意 的。

这种 听起来 确实 是 那种 A I 会 比较 擅长 的。 因为 确定性 很强， 也是 结构化 的， 它 可能 覆盖 到 各个 场景， 这个 的 使用 是 很多 的对 吧？

对 这个 使用 比较 多， 然后 我们 后面 还会 再 去往 整个 测试 链 领域 去做 一些 深入。 因为 比如说 你 这个 测试方法 要 测试 的话， 需要 一些 所谓 的 测试数据， 或者 叫 我们 叫 mock 一些 数据。 其实 A I 可能 也会 根据 一些 线上 的 一些 使用 情况， 就是 情况 包括 我 以往 的 一些 调用 情况， 也会 帮你 去 mock 一些 这样的 数据 出来。

这 听起来 像 比如说 debug 这个 环节 可能 也 挺 有用的。 就 我 发现 问题， 我 大概 知道 是 哪 出了 问题。

您 刚才 其实 也 提到 一个 非常 好的 场景， 就是 在 问题 定位 和 解决 的 这个 对 以前 的话， 其实 我们的 问题 定位 和 解决 都是 靠 人 去 翻 日志。 然后 我 有 经验 的话， 我知道 去 这个 日志 出来 之后 报错 是什么 原因。 对， 然后 按照 我的 经验， 我自己 就可以 进行 排查。 但是 像 对于 很多 刚 接触 这个 领域， 或者 是 刚 看到 新 类型 报错 的 时候， 几乎 都要 花 至少 半天 以上 的 时间 去 研究 问题 到底 出现 在在 那。 但是 一旦 这些 历史的经验， 包括 日志 的 内容 报错 的 类型 悲哀 学习 之后， 他 其实 可以 去 承担 很大 一部分 的 分析 和 定位 的 这样的 事情。 甚至 后续 他 可以 帮你 去做 一些 自助 的 解决。 这个 领域 也是 我们 最近 一直 在 探索， 下半年 期望 是 能有 一些 成果 的。 所以 其实 你看 这些 都是 程序员 的 工作。

对对对， 就能 看得出来。 它是 一些 确定性 很强 的， 它 能够 让 AI 比较 容易 理解 和 基本上 AI 得到 的 结论 都是 可用 的 那种。 你 比如说 你 如果 把 环节 放到 比较 偏 前面 什么 业务 沟通 的 环节， 或者说 比较 后面 的 一些 判断， 他 到底 现在 是不是 足够 安全， 是不是 有 风险， 那些 环节 可能 还是 得人 去做。

是的， 就是 您 刚刚 讲到 的， 如果 可能性 太多 的 这种 他 不太 擅长， 但是 相对 比较 确定 的， 就像 我 刚刚 讲到 的 排查 思路 了 什么的， 其实 都 不同 的 错误日志， 你 可能 会 有一套 S O P 来 去做 这种 排查， 他 就会 比较 擅长。

对于 A I 编程 的话， 会不会 在 程序员 的 画像 上 有 一些 区分度？

这个 其实 也是 我们 之前 其实 走访 过 一些 刚 入 职 的 一些 程序员 的 小 哥哥们， 然后 就 问 他们 在 入 职 之前 是不是 也是 有 使用 这样的 工具。 他们 也 反馈 也 使用过。 我会 发现 确实 新进 的 程序员 对 这些 新鲜 的 事 抱有 蛮 多 的 热情 的。

还是 回到 我 刚刚 举 的 这个 例子， 因为 以前 的 程序员 的话， 他 可能 就 仅仅 擅长 1到2种 编程语言。 但是 A I 的话 能够 让 他们 快速 的 去 get 到 其他 编程语言 的 使用 方式。 另外 的话 就是 对于 一些 以前 好像 大家 觉得 程序员 的 门槛 非常 高， 因为你 学 一种 语言 的 成本 也 非常 高。 那 现在 的话 其实 A I 可以 把 这个 成本 拉 的 相对 比较 低 一些。

之前 我们 有 个 黑客 马拉松 的 大赛， 我 对应 的 开发 同学 就 做了 一个 叫 什么 python 十天 学习， 类似 于 这个 样子 的。 他 就 相当于 是 通过 A I 的 方式 帮你 去 出了 一套 A I 自己 去 帮你 出 一套 教程。 按照 他的 理解， 你 今天 要 完成 什么样 的 题目， 然后 包括 你 中间 题目 出错 了， 他 会 帮你 去 自动 去 纠结 错， 你 会 告诉 方法。 所以 它 其实 会 让 整个 所谓 的 程序员 的 门槛 变得 稍微 低 一些。 对， 就是你 你可以 去 尝试 一下。 但是 我们 不能 保证 说 门槛 降低 了， 你 就可以 很快 的 变成 一 非常 优秀 的 程序员。 是 但 至少 能够 让 你 去 触摸 它的 这个 天花板 稍微 低 一些。 所以 这个 其实 也是 让 一些 以前 觉得 没法儿 进入 这个 领域 的 同学 有了 更多 的 可能性。 我们 从 k hub 报告 上 来看， 也会 发现 最近 一两年 整个 github 去 贡献 代码 的 程序员 的 数量 其实 是 突飞猛进 的对 这个 一定程度 上 不能 全 说 是因为 整个 A I 带来 一些 变化， 但 一定程度 上 是 会有 影响 的。

这个 跟 我 之前 的 认知 是 很 接近 的， 就是我 之前 在 用 像 A R 绘图 这些 工具 的 时候， 我 听到 一个 朋友 他的 比喻， 我 觉得 特别 好。 他 之前 是 学 过 艺术 的， 就是 他 之前 学 过 那些 素描 等等。 我们小时候 经常 听到 那种 故事， 画 个 鸡蛋 画 好久 对 吧？ 画 一个 静物 要 画 很 久要 去 学习 这种 基本 的 技法。 就是你 怎么 用笔， 怎么用 这个 笔触， 最后 画 出 呈现出 的 效果。

其实 A I 绘图 并 不是说 就让 所有的 设计师 或者 艺术 暑假 都 没有 工作， 而是 是的 让 大家 省去 了 这个 过程 当中 比较 基础 的 这些。 就像 刚才 说 的， 每 一笔 该 怎么 画的 这种 基础 技能 的 培养 的 周期 会 缩短。 因为你 会 发现 就 很多 这种 已经 成型 的 A I 绘图 的 这些 模， 它 不能 帮你 做 创意。 比如说 给我 一张 很漂亮 的 风景画， 对他 可能 不一定 能 画 出 一个 很 好的 风景画。 但是 如果你 脑海里 有一个 大概 的 想象， 或者说 你 未来 有 一些 创意， 你是 一个 漫画家， 你 像 现在 在 很多 电影 里， 他们 会 用 这个 做 分镜 的 处理 等等。 它 省去 的 是 大量 的 重新 去 学习 这个 基础 技法 的 流程。 这 有点像 你 学 写 代码， 你 不用 从 最早 的 最 基础 的 学 起， 而且 把 所有的 代码 的 框架 逻辑 都 去 记忆， 都 去做 重新 的 花 很 长时间 做 沉淀。 可能 你 学 其中 部分 的 一些 东西， 学 一些 比较 关键 的， 该 怎么 理解 这个 代码 的 架构， 该 怎么 理解， 有的 这些 东西 可能 就能 搞定， 它 省去 的 是 这种 中间 这种 最 基础 的。

因为 有的 时候 可能 我 之前 写 过 代码， 我知道你 可能 是 落 一个 分号， 或者说 有 一些 格式 稍微 出点 问题， 你的 代码 就 不能用 了。 然后 有的 时候 debug 还 很难， 你 也 找不到 问题 在哪儿。 那 这个 时候 A I 的 作用 就 很大 了。 对它 主要是 节省 这部分 的 之前 的 成本。

还有 一种 可能性， 其实我 在 想， 因为 坦白讲 国内 整个 大 模型 的 这个 技术 确实 还是 有点 落后于 GPT 那个 对。 但是 我们会 发现， 其实 如果 是 通过 GPT 这种 能力 比较 强大 模型 的话， 甚至 像 不会 写 代码 的 人。 所以 就 比如说 我 这样 产品 经理， 我 可能 只要 能把 我的 诉求 描述 的 很 清楚， 然后 不停 的 和 他 去 沟通， 让 他 去 帮 我 去 调整。 他 最终 其实 是 可以 基于 一个 所谓 的 都 不用 我自己 coding 的 过程， 来 帮 我 去 实现 一个 小的 应用 的。 之前 我 还 想着 是在 小区 里面 发 那种 宠物 上门 阐 指的 这种 接单 的 这种 小 程序， 这种 逻辑 就 很 简单。 其实 然后 再加上 它 无论是 前端 还是 服务端， 它 逻辑 都很 清晰。 这样的话 我 理解 A I 在 这些 简单 场景 上 是 可以 完整 的 帮你 去做 一个 小 应用 出来 的。

就 这种 门槛 的 降低， 我 觉得 它 会 带来 很多 我们 感觉 还 挺 有意思 的 一些 现象， 或者说 对 我们 未来 的 很多 生活 工作 的 帮助 会 比较 大对 之前 如果说 一个 编程 的 门槛 会 比较高 的话， 那 其实 我们 只能 在 一些 通用 的 需求 上能 能 用到 这种 比较 好的 线上 产品。 但是 如果 未来 这种 门槛 降低， 理想 或者 最 极致 的 情况下， 每个 人都 可以 自己 去做 一些 定制 化 对 啊 个性化 的 小东西 的 这些 小东西， 而且 成本 不高 的话。 那 其实 是一个 怎么说， 就像 过去 做 自媒体， 可能 是一个 成本 还 挺 高 的 事儿。 你 可能 要会 一些 东西， 可能 要 甚至 在 早期 是 个人 站长 时代， 你 还要 自己 建站 等等， 门槛 是 高 的。 是的， 但是 后来 公众 号 出现了， 大家 就是 人人 都能 开 个 公众 号， 再 后来 一直 门槛 在 降。 现在 有有 个 手机， 你 能 拍 一个 vlog， 也能 做 内容 出来。 对， 其实 它 也是 这么 一个 过程。

是的， 你的 比喻 非常 的 生动， 其实 就是 很 类似 这样的 感觉。

对， 门槛 越来越低。 你 像 我 前 阵子 刚 见到 一个 朋友， 他 之前 好像 就是 蚂蚁 的， 就 跟 我 讲说 他 之前 其实 也 没 怎么 写 过 代码， 但是 他 自己 现在 在 做 一个 产品， 然后 就 很 开心。 他 自己 一个人 基本上 就 靠 这种 A I 的 工具 就能 差不多 打 起来。 未来 就现在 大家 会 讲， 所谓 艺人 公司， 就 一个人 就 开 一个 公司， 一个人 去做 一个 业务， 也是 很有可能 的 了。 就像 我们是 做 产品 经理， 以前 可能 我们 写 不了 代码， 我们 之前 有 个 说法 就 缺 一个 程序员 了。 但是 后来 后面 可能 这个 程序员 只要你 需求 表达 的 清楚， 你 也会 用 这种 A I 编程 工具， 你 可能 就能 做 把 这个 产品 做出来。

是的， 我 觉得 这种 可能性 是 完全 有可能 有的 说 他 什么时候 来临 的 问题， 但是 我们 现在 基本上 也都 是 奔 着 这些 方向 去 的。 但是 你 刚刚 提到 一个 也很 关键 的 点， 就是你 你 得 学会 去去 用 它， 对， 这个 点 其实 也是 非常重要 的。

现在 你 会 觉得 遇到 最大 的 挑战 是什么 呢？

其实 刚才 我们 也 一直 在 聊到 前面 的这 所谓 的 需求 的 沟通 和 澄清 这些 环节。 因为 我们 现在 做 的 这个 事情， 如果 您 有 一定 的 编程 基因 的话， 应该 能 理解。 我们 现在 基本上都 是 基于 代码 仓库 去做 编码 的那 一个 代码 仓库 它 里面 可能 更多 的 是 存 的 是 相关 业务 的 代码， 或者 是 某 一个 功能， 或者 某 一个 小 产品 的。 但是 如果 一旦 你的 产品 过于 复杂， 它 可能 有 不同 的 系统 去 对应 解决 不同 的 功能。 然后 我们 现在 目前 是在 整个 单 仓库 的 编码 这 一块 是 比较 合适。

然后 跨 仓 户 的 这个 理解 可能 目前 是 我们 接下来 的 一个 比较 大 的 挑战。 因为 一个 产品 经理 需求 提过来 之后， 咱们 先 不说 A I 在 需求 分析 上 他 能够 做到 什么。 即使 说 当我 的 架构师 已经 把 这个 需求 拆解 清楚 了， 然后 也 拆解 成 研发 任务 了。 有 很多 研发 任务 他是 要 去做 跨 库 实现 的对， 那 这种 情况 是 我们的 一个 比较 大 的 挑战。 就是 它 不仅 是要 理解 光标 上下文， 甚至 光标 当前 所在 的 仓库， 他 可能 要 去做 一些 跨 库 理解， 所以 这部分 的 难度 还是 比较 大 的。 以及 不同 的 方法 之间 他们的 调用 关系， 仓库 和 仓库 之间 的 关系， 以及 不同 链路 上 这些 关系。 就是 相对于 这种 复杂 的 业务 逻辑， 现在 A I 的 理解 还是 比较 差 的。 然后 再 回到 我 刚刚 说 这个 所谓 的 需求 拆解 方面， 就 是从 现在 一个 需求 拆解 到 哪些 合适 的 研发 任务 这块 其实 A I 现在 能 做 的 相对 也 比较 少， 对 我们 来说 也是 一个 挑战。 就是 架构 分析师 的 那个 角色 以及 需求 拆分 的 那个 角色， 目前 A I 还 暂时 不能 去 承接。

明白， 其实 从 原理 上 听起来 跟 大 模型 的 训练 是 很 像 的。 它 也是 靠 过去 的 语料 也好， 叫 数据 也好 训练 出来 的那 其实 它是 依赖于 过去 有 代码 库 代码 库 的 这些 数据。 如果说 本身 这个 数据 的 筛选 应用， 以及 怎么 把 它 最后 做成 模型， 这 中间 肯定 还是 有 很多 工程 上 的 东西 要 解决 的。 它 并 不是说 这个 A I 足够 聪明， 他 就 真的 会 写。 可能 是 跟 过去 我们 训练 用 的 这个 数据 本身 的 质量 也有 很大 的 关系。

对 吧？ 对， 或者 是 我们 希望 他 能够 理解 更 深层次 的 一些 相关性， 这些 其实 都 挑战 还 蛮 大 的对 我们 现在 你看 无论是 我们 confuse 还是 同意， 包括 gib 他们 现在 更 多是 大家 都在 去 提。 所谓 的 补全， 就是 根据 代码 的 上下文 去做 一些 补全， 或者 是 根据 一些 简单 的 自然语言 描述， 能够 去 生成 一个 简单 的 功能。 但是 但凡 你 让 他说 个 最简单 的 场景， 我 这个 代码 仓库 你 帮 我 把 某 一个 接口 方法 重构 一下， 或者 是 里面 增加 一个 全新 的 逻辑。 那 这个 时候 的话， 他 可能 就 会要 去 分析， 原来的 这个 接口 他 到底 是 怎么 写 的？ 他 这个 写 的 代码 都 存在 哪里？ 然后 按照 新的 要求 我 该 怎么 去 改 代码。 然后 这个 改 完 之后 又 去 修改 哪些， 新增 哪些， 这些 都是 他 一系列 分析 的 过程。

这个 的话 就 相 比较 原来的 只是 基于 上下文 的 补全， 可能 就有 一定 的 难度。 但是 这个 我们 也 已经 在 尝试 了。 所以 其实 对 整个 层 就 相当于 是 我们 现在 叫 的 仓库 级 的 代码生成。 就是你 拿到 和 这个 仓库 相关 的 一些 医术， 他 就可以 直接 根据 这个 医术 来去 帮你 生成 这个 医术 相关 的 多 文件 的 代码。 对， 这个 是 我们 目前 在 做 的。

然后 进一步 的话 就 可能 回到 我 刚刚 说 的 跨 库 之间。 因为 有的 医术 不是说 你 改 完 这个 仓库 的 代码 就可以， 相关 的 代码 的 仓库 文件 也要 改。 所以 这块 的话 其实 还是 回归 到了 对 业务 本身 的 理解 上。

面对 所以 听起来 其实 离 那种 真的 完全 帮 我们 cover 掉 这个 所有 代码 的 能力 的 是 有 距离 的。 但是 现在 在 这个 具体 的 任务 上 处理 已经 效果 很 好了。 是 这样的。 这就 涉及到 一个 我 估计 很多 在 听 的 程序 朋友 就 特别 关心 的 问题， 就是 程序员 会不会 被 A I 替代 掉。 以及 说 他 到底 在 程序员 的 这个 生态 里 是一个 什么样 的 存在。 其实 刚才 我 感觉 我们。

聊 的 有 一些 结论 了， 或者说 我们的 目前 的 看法 了。

对 就 当下 他 肯定 不能 完全 替代 的， 因为 对 就 前后 的 大量 的 上下游 的 工作 还是 程序员 去做 的。 是的， 或者说 他 其实 更能 能 让 程序员 去 关注 在 他 应该 关注 的 工作 上。 是的， 不是 那种 去 码。 其实 你说 写 个 if else 循环， 写 个 for 循环， 它 能有 多大 价值？ 它 肯定 架构 的 价值 和 最后 你 能把 它 落地， 能够 保证 它的 那个 效果 的 价值 会 更大。

是的， 反正 如果 回到 这个 问题 本身， 我是 觉得 确实 不必要 有 这个 担心。 对 因为 从 聊 的 过程中 我 也会 发现， 大家 可能 以前 对于 大 模型 的 力量 或者 是什么 太 过于 乐观 了。 对， 可能 从 很多 新闻稿， 包括 一些 P R 稿子 上 就 觉得 似乎 AI 可以 帮忙 做 很多 事情。 但 这个 包括 我 刚刚 和 您 聊 的 过程中， 一个 是你 让 A I 去 写 一个 全新 的 小 程序 或者 小 应用， 和 你 让 他 基于 原有 的 系统 去做 一些 修正。 他在 这 两个 里面 能够 起到 作用 是 非常 不一样的。 你 如果 让 他 去 写 一个 全新 的 东西， 他 可以 根据 自己 历史 以往 的 一些 知识 简单 帮你 写 出来。 对， 虽然 可能 写 的 没有 那么 精细， 但 他 起码 能够 把 你 那个 框架 搭 起来。 对， 但是 如果你 让 他 一个 在 原有 的 基础 上去 做 一些 改动， 他 其实 是要 去 很 详细 的 理解 原有 的 这个 架构， 再做 个 改动。

因为 相当于 是从 0到1从 1到100， 它是 完全 不一样的 事情。 所以 其实 在 第二个 场景 它是 很难 发挥 的。 我们 很多 现在 的 程序员 更多 的 其实 是在 做 后面 的 这些 事情。 对 业务 的 对系统 的 理解 肯定 还是 要有 比较 长 的 时间 的对 然后 再加上 刚才 说 的， 他 目前 可能 还是 基于 已有 知识 的 学习。 对他 不会 能有 太多 过多 的 可是 实用性 的 创造 出来。 所以 其实我 是 觉得 在 创造 这 一部分 的话， 起码 在 编码 领域 或者 是 其他 领域， 我 觉得 可能 会有 一些 创造性 的 东西 出来 了。 但 至少 在 这个 编码 领域 或者 是 编程 领域， 它 其实 很难 有 这种 可 实用性 的 创造 的 东西 出来。

你 刚才 说 的 那个 我 也很 有 感触。 你 像 对于 内容 创作 来说 也是 一样， 有 简单 的 一句话， 一个 prompt 让 A I 去 理解， 并且 给出 一个 结论 是 简单 的。 但是 你 有 非常 长 的 上下文， 一个 长 文本， 一个 一一 本书， 两本书 给 他的 时候， 他 给出 的 效果 就会 差 很多。 要 完全 理解 所有的 这些 内容 的话， 这个 难度 是 非常 大 的。 尤其是 现在 其实 对于 一个 可能 比较 成熟 的 产品 来说， 不管 是 蚂蚁 还是 像 阿里， 像 腾讯， 大家 用 的 这些 大 的 产品。 那那 这 里面 的 代码 量 和 它 架构 的 复杂 量、 复杂度， 对它 就 不是 一个 说 我 这 几句 代码 出了 什么 问题， 或者 这 几句 代码 它 代表 的 是什么， 那种 就是 加 一个 注释 这种 任务 一样 简单， 对它 是个 很 复杂 的 任务。

是的， 其实 在 你们 code fields 在 做 实验 的 时候， 并没有 发现 那种。 就 大家 想象 中 一个 程序员 有了 A I 之后， 他 就 每天 早上 泡 杯 咖啡， 在那 看着 A I 写 代码， 对 吧？ 什么 都 不用 干， 躺在 那儿， 躺 沙发 上 躺 一天 都 不会 有 这种 场景。

完全 不会 有。 对， 因为我 刚刚 说 了， 他 本身 空 顶 也 只看 他 百分之二三十。 对， 其他 的 经历 他 可能 还是 要 去 处理 一些 其他 的 事情。

如果说 真的 到 那一天， 一个 程序员 就 泡 杯 咖啡， 坐在 那 什么 都 不用 管， 就是 光标 自己 在 动。 这个 确实 我 觉得 有点 危险 的那 可能 这个 就 对 就 不是 那么 需要 了。 但是 还 远 没有 到 那 一步。

我 我 可能 是 我也 不能 算是 偏 悲观， 只是 说 对 所有的 新 科技 都 保留 一个 比较 谨慎 慎 的 态度。 对， 所以 其实我 自己 感觉 就是 也许 你 刚刚 说 那个 状态 可能 会 来临， 但 可能 在 近 3到5年 也许 都 不太会。

比较 冷静 的 地方 在于， 你们 还是 在 做 一个 比较 明确 能 帮 大家 解决问题。 但是 也没有 很 乐观 的 说， 我 就 做 一个 一套 什么 工具， 搞 一些 噱头， 就是 告诉 大家 说 这个 工具 一定 能 替代 程序员 或者 怎么样。 并不是 那样， 而是 先 实际 帮 大家 解决问题， 看看 能 解决 到 什么 程度。 对， 那 现在 其实 有 一定 结论， 就是 它 能 一部分 帮忙 解决， 然后 另外 一些 肯定 在 整个 的 生产过程 当中， 那 也 只是 占占 一部分。

是的， 对对对， 因为 之前 其实我 自己 虽然 不是 技术 出身， 但是 我自己 的 观点 就是 技术 它 目前 看来 他 只是 工具， 就是 最 本质 的 还是 在 人 上面。 因为 我们 刚刚 聊 的 时候 也 一直 在 强调 人 你 如何 去 更好 的 去 使用 这些 工具， 最 重要 的 还是 人 这个 本身。 即使 同 一套 工具 摆在 不同 的 人 面前， 因为 每个 人的 主观能动性， 包括 他的 一些 意愿， 对 工具 使用 程度 完全 就 不一样。 所以 其实 在 现在 这个 阶段， 我 理解 它 技术 仍然 只是 一个 工具， 最 根本 的 还是 在 人。 并且 我们在 了解 一个 技术 先进性 的 同时， 其实 也要 真正 去 了解 它的 实用性。

那 基于 现在 你 对 A I 编程 的 理解， 你 觉得 它 会对 程序员 生态 产生 什么样 的 影响 呢？ 就 是不是 像 刚才 说 的， 全部 都 被 替代 掉， 肯定 也会 有 一些 变化 和 影响。

我自己 的 感觉 就是 先回到 已有 的 这些 程序员 的 这些 群体 上面 来看。 所谓 的 创造力 刚才 也 提到 过了， 因为他 其实 完全 可以 去 激发 你 更多 的 潜能 出来。 或者 是 回到 一个 具体 的 场景。 其实我 我们 现在 所谓 的 有 所谓 的 前端开发 者， 服务端 的 开发者， 大家 的 各自 的 身份 是 相对 比较 明确 的。 但 实际上 A I 起来 之后， 也许 你 一个人 就可以 承担 所谓 的 前端开发 者、 后 端 开发者 甚至 客户端 开发者 多种 角色。 以前 擅长 的 是 这 60%， 剩下 的 40% 可能 是 交给 了 另外一个 角色。 但 现在 的话， 你 其实 可以 通过 A I 来 帮你 去 完成 剩下 40% 的 内容。 所以 其实 A I 对于 程序员 来说， 它 可能 让 一个 程序员 的 技能 变得 更 丰满。

以前 的话 也许 我需要 是 在 完成 一个 小小 应用 的 开发 过程中， 我需要 十项 技能， 然后 需要 对应 的 十个 人。 但 也许 后面 就 可能 就是 一个人 就可以 去 完成 相应 的 角色 了。 所以 这个 是我 理解 会 让 程序员 的 技能 更加 充分。

对， 真正 的 都是 全 栈 程序员。

对， 真的 有点 是 全 栈 程序员 的 这个 概念， 只是 你 擅长 的， 你可以 自己 多 花点 精力， 你 不善 常 的 让 A I 去 弄。 对， 但是 以前 的话 可能 大家 就是 去 分工 非常 明确， 就 A I 起来 之后， 可能 会 让 这种 分工 相对 稍微 一定 是 一定要 A 做 A 角色 做 A B 角色 做 B 这样。 对， 可能 会 稍微 模糊 一些。 另外一个 就是 刚才 提到 的， 也许 会 让 所谓 的 程序员 这个 群体 会越来越 多， 占 比 越来越高。 就 跟 以前 你 刚刚 讲 的， 做 自媒体 的 人是 非常 小错 一人。 现在 连 我 妈妈 现在 都在 做 自媒体， 对 吧？ 对。

其实 每个人 现在 都 是一个 自媒体， 因为你 在 发 朋友圈， 你 在 发小 红书。

是的， 对对对， 就是 对 程序员 本身 这个 感知 就会 变 一下。 程序员 不 纯粹 是 说 我会 一门 非常 好的 编程语言， 我会 很 熟练 的 写 代码。 Java 对， 就是 程序员。 现在 可能 就是我 自己 只要 能够 研发 出来 一块 我自己 想 用 的 这些 小 应用， 那 我 可能 就是 所谓 的 程序员 了。 对， 也 可能 会 发生 一些 这种 观念 上 的 角色 定义 上 的 转变。

其实 也很 像 现在 用 电脑 的 人和 以前 用 电脑 的 人 也 不一样。 最早 用 电脑 的 人， 他 就是 专门 的 有有 一批 人 用 的。 就 比如说 打字员 也好， 或者说 这种 在 办公室 去做 一些 特殊 的 工种 的 才会 用。 但是 现在 电脑 是一个 标配， 对 吧？ 就 每个人都会 用 个 word， 用 个 excel。 是的， 以前 word excel 它是 一个 需要 培训 的， 你是 需要 去 学习 去 用 的。

各个领域 都在 发生 这种 变化。 你 像 photoshop， 之前 可能 大家 觉得 是一个 设计师， 一个 专门 做 美术 的 人 会 用 的。 但是 现在 大家 也会 觉得 它的 门槛 并没有 那么 高。 我可以 用 photoshop 做 一些 基础 的 处理 技术 的 工作。 那 这里 边 它 就会 让 整个 大 的 生态 发生变化， 而 不是说 只是 程序员 群体。

是的， 整个 生态 可能 都会 扩大。

这 其实 是一个 挺好的 事情。 我 觉得 就像 前面 说 的对， 一个 产品， 对 一个 功能， 一个 线上 的 服务， 它的 门槛 是在 越来越 降低。 像 之前 最早 可能 是你 要 独立 去做 一个 网站， 你 像 最早 的 那些 操作系统 上 做 去 开发 一个 产品 的 成本 是 非常 高 的。 那 现在 I O S 安卓 它 有 大 这样的 比较 成熟 的 一些 框架。 你 在 这个 基础上 开发， 然后 到 后来 现在 有 小 程序， 小 程序 的 开发。

门槛 降低 更 低 了。

然后 再到 后面 可能 会 更 低。 它 并 不是说 大家 只是 一句话 就能 编出 一些 东西 来， 而是 说 当你 想想 清楚 了 这个 功能 大概是 什么样 的那 你 可能 花点 功夫， 自己 确实 也有 条件 能把 这个 东西 做出来。 那 未来 这个 可能 会有 像 我说 的， 它 不一定 是一个 通用 的 大 的 应用 场景 下 出现 的 更大 的 产品。 我们 所说 的 和 现在 互联网 巨头 在 做 的 这些 产品 的 场景。 但是 会有 那种 小的 小 场景， 小 而 美的 场景。 因为 它的 成本 足够 低。 所以 我 并 不是说 像 以前 我 做 个 A P P 就 意味着 要 创业 了， 我 必须 要 融资， 我 必须 要招 人才 能把 这个 A P P 做出来。 现在 可能 就是你 用 一些 编程 的 工具， 能把 这个 最 基本 的 一些 简单 的 功能 实现 掉。 那 可能 你 哪怕 就 面向 一部分人， 你的 亲戚朋友？ 就是 十几二十个 人， 你 做 的 这个 东西 可能 也有 价值， 或者 你 甚至 面向 自己 做 可能 也会 有 价值。 这 是一个 比较 看起来 相对 乐观 的 一个 状况。

对对对， 其实我 觉得 您 刚刚 说 的 这个 点 非常 好。 就是 以前 所谓 的 人人 都想 改变世界， 其实 很多 都是 通过 一些 软件应用 去 改变世界 的。 以前 的话 可能 就是 这些 软件应用， 它 本身 的 开发 的 成本 非常 高， 门槛 也 非常 高。 但是 现在 软件开发 的 这个 成本 本身 降低 一点 的话， 你 会 发现 越来越多 的 人 可以 去 参与 到 所谓 的 我可以 改变世界 的 这个 事情 上去。

我 比较 好奇， 因为你 在 做 code fuel 这个 过程 当中， 会 跟 很多 程序员 朋友 接触。 我们 刚才 想 的 当然 是对 我们 来说 觉得 挺 乐观 的 一个 事情， 因为 我们 有 新的 工具 可以 用了。 那 对于 程序员 朋友 他们 会有 什么 新的 想法 吗？

对， 其实 也 和 之前 的 一个 发现 是 类似的。 我们会 发现 有些 很 高阶 的 程序员， 就是 他 自己的 代码 本身 写 的 也 非常 好， 然后 掌控 性 很强。 对他 可能 就 也不 说是 嫌弃， 他 可能 就 觉得 A I 生成 的 这些 部分 其实 不见得 特别 符合 他的 预期。 对， 这些 同学 也会 有， 但是 可能 还是 回归 到 咱们 俩 刚刚 说 的， 你 越来越 用 他他 可能 才 会越来越 了解， 你 才会 变得 更好。

当然 会 对于 一些 有些 同学 的话， 他的 开 心态 稍微 开放 积极 一些。 他 会 不停 的 去 尝试 各种类型 的 这种 工具 和 产品， 然后 再会 去 摸索 它， 如果 更好 的 能 带来 价值。 所以 其实 我们会 发现 大部分 的 同学 可能 是 相对 偏 保守 一点， 因为 也是 了解到 模型 的 一些 局限性。 但是 当 他 真正 去 感知 到 模型 对他 带来 的 帮助 之后， 他是 其实 去 愿意 更 多一些 深入 的 去 使用 的对 所以 其实我 是 觉得 在 现在 这种 场景 之下， 开放 的 心态 以及 你 能 理解 到 你 会 用 它它 才能 帮你 带来 生产力 提升， 这个 事情 是 至关重要 的。 还是 想 大家 不要 太 抱一个 相对 比较 排斥 的 这样的 心态， 要 开放 心态， 接纳 他用 它， 然后 真正 让 他 帮 到 自己。 这个 也是 我们 也 一直 比较 呼吁 的 一个 地 防， 也要 接受 他的 不完美， 帮 他 变成 自己的 助手。

对， 本来 是 准备 了 最后一个 问题 就是 关于 建议。 我 觉得 你说的 也是 建议 的 一部分， 其实 要 用 开放 心态 去 看一看。 另外 像 我们 刚才 聊 的， 并不是 只有 程序员 朋友 要 关注 这个， 可能 其他 的 朋友 只要 在 做 这个， 或者 哪怕 感兴趣 的 也可以 关注 一下 A I 编程 领域。 对， 因为 它 代表 的 可能 是 像 刚才 说 门槛 降 得 足够 低 了。 你 一个 没有 经过 系统 训练 的， 相对 有了 基础 的 一些 尝试 之后， 也能 开始 启动 做 一些 事情 了。 对， 这是 整个 生态 可能 会 发生 的 变化。

对， 是的。 生产力 的 提升 其实 也就是说 你可以 用 更 少 的 时间 或 特定 时间 完成 更多 的 事情。 那 这些 工具 的 使用 就可以 辅助 你 完成 这些 事情。

是对 是， 那 最后 还有什么 别的 建议 吗？ 给 在 关注 A I 编程 的 朋友。

我 其实 第一个 建议， 刚才 其实 也 说 了， 就是 大家 确实 可以 抱着 一个 开放性 的 心态 去 不停 的 去 使用， 然后 去 感知 发觉 它的 简历。 其实 大 模型 相较 其他 的 工具 还有一个 不同 的 点， 就是 以前 的 像 photoshop 这种， 它的 功能 也就 那么 一 将近 有 1000个。 只要你 把 这 一千个 学会， 你 就可以 做 的 非常 好。 但是 大 模型 还有一个 特点， 就是你 可能 会 不停 的 激发 它它 可能 会 表现 的 越来越好。 对， 这个 其实 是 相较 一些 传统 工具 有 个 比较 大 的 差异， 所以 我是 比较 建议 大家 去 能够 去做 更多 的 尝试， 这个 刚才 也 提到 了。 然后 第二点 就是 也 一定要 去 在 使用 它的 过程中， 保持 对 它的 这种 实用性 的 一些 基本 的 认知， 就是 不能 抱有 非常 大 的 期望。 是对， 因为 这个 过程中 你 会有 一些 所谓 的 落差 什么的， 这些 其实 也都 很 正常。 就是 大家 客观 的 去去 看待 这个 实用性， 我 觉得 这个 也是 很 关键 的。

身边 有 很多 朋友 会 来 问， 说 关于 A I 的 工具 怎么看 等等 的。 我 大部分 的 建议 就是你 先 试试看， 你 先 试试， 你 先 知道 是 怎么回事。 因为 这些 朋友 大部分 都是 过于 乐观， 过于 悲观， 也 过于 悲观 的， 就 觉得 现在 是不是 A I 就 什么 都能 解决 了， 你 很 危险 或者 怎么样。 我说 你 试试看 就 知道 了， 他 并没有 那么 他 确实 比 以前 的 A I 厉害， 但是 他 也 并没有 到 那种 想象 的 程度。 对于 那种 过分 乐观 的 朋友， 他 可能。

也是。

没没 太 用。 对， 也是 要 试一试 你 才知道， 有 一些 东西 它是 没 那么 好用 的。 你 就像 我们 能 看到 一些 很 精彩 的 A I 生成 图片， 我们 能 看到 很 精彩 的 A I 生成 的 一些 文字。 确实 在 一些 特定 场景 下， 它 确实 挺好的。 但是 你 要 知道 有 很多 它是 经过 大量 的 调试 的对， 另外 就是 它 可控性 不一定 很强。

对， 就 比如说 你 画 出来 的 一张 图 或者 是 生成 了 一个 文本， 单独 拿出来 是 可以 的。 但是 你 要 想， 如果 他 真的 要 用到 一个 现实 的 场景， 就 跟 我们 说 代码 一样， 那 他 可能 能 写出 很漂亮 的 代码 来。 但是 他 能不能 适配 这个 环境， 适配 这个 真正 的 需求。 那 这个 图 能不能 用到 真正 的 海报 上， 你 就 觉得 他 眼睛 应该 再 大 一点， 这个 再 大 一点 就 A I 就 很难 去 把 它 很 好的 完成。 对， 这个 我 觉得 都是 相通 的。 是的， 所以 真的 用了 你 就 大概 知道 问题 在哪儿。 但是 我们 现在 看到 了 很多 他 能 帮 我们 解决 的 具体 的 场景， 这 是一个 相对 乐观 的 一个 现象。 我们 可以 去 关注 它是 的。

也可以 去 了解 他。 对， 其实我 还有一个 建议， 就是 因为 像 包括 现在 那个 github copilot 这些， 它 都是 一些 现成 的 大 模型 的 或者 是 产品。 它 可能 是 通过 这个 产品， 它 可能 去 降低 一部分 你 去 真正 去 使用 大 模型 的 门槛。 因为 它 通过 产品化 帮你 去 解决 了 一些 问题。 但是 我 还有一个 建议， 就是 大家 可以 直接去 使用 大 模型， 这个 其实 也是 一个 比较 好的 路子。 对， 因为 能够 产品化 的 基本上都 是 一些 我们 认为 比较 通用， 但是 它 确实 复杂度 没有 那么 高 的。 但是 我 建议 大家 一些 相对 比较复杂 场景， 可以 直接去 用 模型 OK， 可能 会有 一些 更多 的 创造 出来。

好， 非常感谢 小刀。 我 觉得 之前 大家 可能 对 I 编程 的 很多 了解 会有 一些 误区， 或者说 有 一些 细节 不太 清楚。 今天 我们 还是 能 聊到 比较 具体 的 一些 地方 的， 希望 你 能 对 大家 也有 一些 启发 和 帮助。

然后 线上 的 有 一些 程序员 的 同学， 如果 是 觉得 我 有的 观点 说 的 不对， 或者 是 和 你们的 实际 工作 不太 相符， 那就 冒犯 了。

没有， 但是 大家 也可以 在 评论 区 留言， 多 互动 交流。 对， 是的， OK 行， 那 我们 就 聊到 这儿， 感谢 小 当我们。

下期 再见。 好， 行， 谢谢， 拜拜。

欢迎 在 小宇宙 苹果 podcast 订阅 和 收听 3、 五环， 也 欢迎 在 评论 区 留言 交流。 如果 喜欢 三、 五环 的话， 也 恳请 您 在 苹果 podcast、 spotify 或者 喜马拉雅 留下 你的 宝贵 好评， 下期 再见。