IT之家 6 月 8 日消息，在以“智行天下能动未来”为主题的 2026 世界智能产业博览会上，砺算科技、麒麟软件、海光信息、联想开天联合带来联想开天 P5h G1t 旗舰工作站全栈国产化解决方案。 据介绍，整套解决方案将银河麒麟桌面操作系统 V11、海光 C86-4G 处理器、砺算 7G105 GPU、联想开天无界兼容方案及 CATIA 工业软件融于一体，构建起“ 国产操作系统 + 国产芯片 + 工业核心应用 ”的全栈自主创新体系。 IT之家从砺算科技新闻稿获悉，砺算 7G105 GPU 显卡驱动与银河麒麟桌面操作系统 V11 完成深度适配，3D 建模、高清场景渲染流畅无卡顿； 可稳定支撑 7×24 小时工业级不间断运行 ，适配高端制造长期高负载、高稳定的图形算力需求，有效解决传统国产图形设备在复杂渲染、重负载场景下卡顿、兼容性不足的行业痛点。
我手机root了，冻结了一大帮子系统应用，快应用、服务治理框架、全局搜索、邮件、AI写作，起码都有40-50了，可是我昨天打开京东和淘宝搜索东西，那叫一个卡，我发现我后台啥也不开的情况下，只有3G，这可不得卡吗，是不是我关闭虚拟内存的缘故。我买的时候买的还是16G，如果买的8G，那啥也干不了啊。 我查了查，我发现系统就占了7G多，这也太离谱了，开机占一半啊，再有一些零零碎碎，比如桌面再占用几百m，每个都得几百m，加起来也就不多了。 windows我用的多，我现在32G，只开网页和一些后台服务的情况下，比如梯子、番茄钟、截图、翻译等等，一共才7G，占用22%。之前用win7 内存8G，系统占用也就几百m 或者1-2G，不多啊，我记得它不会占用过多。 那现在这可咋办啊，难道是我root所故，还是它就这样，我没开虚拟内存所故，或者怎么样给操作系统瘦瘦身。 不过安卓基于java，它好像就是特别吃内存，稍微写点啥，就得干个几百m到1G，搞得手机比电脑还吃内存，甚至比电脑内存都大，有点离谱啊。 这样的话，我root还有啥意义呀，冻了快50个自带软件了，大多开机自启，现在还这样，打开个淘宝，跟我之前的旧手机一样卡，重启能好点，会从3->5 勉强可用，只能每天自启一下子嘛，谁给写的内存溢出了啊。 到现在我唯一享受到root的好处就是安装根证书抓包，坏处倒是一大堆，天天焦虑，生怕半夜安装的模块有内鬼，给我手机钱转出去了，虽然我没多少钱。银行也不能正常用，打开没问题，点击一些东西会提示繁忙之类的，但是备用机没问题。tee损坏，指纹不能正常用了 佬友可有解决办法，难道是开启虚拟内存吗？ 有没有办法给操作系统瘦瘦身，比如 -Xmx512m，给他限制限制，我也用过linux的呀，人家的系统占用也不高呀，奇了怪了 1 个帖子 - 1 位参与者 阅读完整话题
在 2026 年 Build 开发者大会上，微软正式公布名为 Project Solara 的新项目，这是一套专为运行 AI 智能体（AI agents）的硬件设备打造的全新操作系统与平台。微软将其描述为“从零开始为智能体驱动体验构建的新平台”，底层并非基于 Windows，而是构建在一个版本的Android系统之上。 在现场演示中，微软展示了两款基于 Project Solara 的概念设备：一款是桌面概念设备 Desk concept，另一款是可穿戴式的胸牌概念设备 badge concept。Desk 概念机的外形与亚马逊 Echo Show 类似，支持人脸识别解锁，解锁后用户可以直接调用不同的 AI 智能体来完成任务。 胸牌概念设备则模拟日常用于进出办公楼的工牌形态，配备摄像头和指纹识别模块。用户只需按一下指纹传感器即可唤醒内置 AI 智能体，并可一键录制周围对话并即时转录为文字；借助摄像头，智能体还能“看到”用户眼前的环境，辅助完成识别和分析等工作。 微软目前并未计划将这两款概念设备直接推向消费市场，但会将其作为参考设计，供合作伙伴在此基础上开发商业化产品。据报道，AccuWeather、百思买（Best Buy）、CVS Healthcare 和 Target 等公司已经计划启动相关硬件的试点项目。微软资深技术专家 Steven Bathiche 表示，Project Solara 面向的是“智能体优先”（agent-first）的新型设备形态，整个平台具有高度灵活性。 在操作系统选型上，微软为 Project Solara 选择了基于Android的 Microsoft Device Ecosystem Platform，而非传统的 Windows。据介绍，这一平台能够在更小型、低功耗设备上运行，同时保持企业 IT 部门所期待的管理与安全能力。 目前，Project Solara 仍处于早期阶段，但微软显然希望在 AI 硬件这一新兴赛道上抢占先机。随着未来数月乃至数年内 AI 设备市场竞争加剧，Google和 Meta 等传统竞争对手都在研发各自的 AI 小硬件，而 OpenAI 也正与前苹果首席设计师 Jony Ive 合作打造新设备。在这样的背景下，Project Solara 被视为微软布局“智能体时代”硬件生态的重要一步。 查看评论
IT之家 6 月 3 日消息，微软今天在 Build 2026 开发者大会发布专为 AI 智能体打造的“Project Solara”操作系统，并同步展示两款概念设备。 据介绍，“Project Solara”并非基于 Windows， 而是建立在 Android 之上 。 微软还在大会中展示了两款概念设备，分别是桌面终端（IT之家注：Desk Concept）和智能胸牌（Badge Concept）。前者外观类似亚马逊 Echo Show、谷歌 Nest Hub 等带屏智能音箱，用户可通过人脸识别解锁设备，并直接访问各类 AI 智能体。 而 Badge Concept 则是一款可穿戴设备，其外观类似工牌、胸牌等。 机身配备摄像头和指纹识别传感器 ，支持 5G 连接，用户只需要按一下设备，就能启动 AI 智能体。 微软在现场演绎了 Badge Concept 的使用场景：用户点击设备的按钮后开始记录对话，系统立刻生成语音转写稿。机身摄像头还能够让 AI 智能体看见用户眼前的事物，从而更好地结合环境提供帮助。 微软目前没有亲自发布这两款设备的计划。这两款概念产品将作为“参考设计”存在，让其他硬件厂商基于此设计真正的商业产品。 至于为何要采用 Android？微软表示，“Project Solara”使用了自家定制的 Android—— 微软设备生态平台（Microsoft Device Ecosystem Platform）。这种系统能够运行在尺寸较小、功耗较低的设备上，同时保留企业 IT 部门所需的安全、管理功能。 微软透露，该计划仍处于早期状态，目前已有百思买、AccuWeather、CVS Health、Target 等厂商启动相关硬件试点项目。
尝试过不同操作系统，windows 下编辑 settings.json 文件就行，linux 不可以，是 cladue CLI 版本太低的原因吗？ 1 个帖子 - 1 位参与者 阅读完整话题
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。
最近在用 Rust 写一个 AI Agent 操作系统内核，叫 Agent OS 。37 个 crate ，1232 个测试，用 craft agent 都写了十几天。 不止一个朋友问过我：你为什么不先用 Python 快速搭个原型？先验证需求，等跑通了再用 Rust 重写。 以前我会觉得这是个好建议。但这次我拒绝了。 原因很简单：我在用 AI 编程的过程中，逐渐意识到一件事——在 AI 时代，MVP 那套"先简后优"的逻辑，前提已经不存在了。 传统 MVP 的核心假设是：简易实现和高质量实现之间有显著的成本差，先用低成本验证，验证通过再投入。这个在人写代码的时代是成立的——用 Python 写个原型 2 天，用 Rust 写生产级实现 2 周，差 10 倍，所以先做简易版合理。而且代码是你自己写的，你理解每一行，以后重构只是时间问题。 但现在你对 Cursor 说"用 localStorage 存数据"和说"用 PostgreSQL 加连接池和事务管理"，生成时间差不了几分钟。既然成本一样，为什么要做简易版？ 更要命的是第二点：AI 生成的代码是黑箱，你大概率没法有效重构。 去年帮一个朋友用 Cursor 做了个小工具的 MVP ，需求很简单，AI 几分钟就生成了能跑的代码。两周后他想加个功能，打开代码，完全看不懂。不是因为代码乱，而是他不知道 AI 为什么这样写。最后他选择让 Cursor 重写一遍，而不是在原有代码上改。 这就是问题所在。你以为"以后再优化"，但你连哪里需要优化都不知道，因为你从未理解过这段代码。 所以我做 Agent OS 的时候，做了一个在很多人看来反直觉的决定：每一个架构决策都自己做，AI 只负责执行。 选语言的时候，用 Python 或 TypeScript 写个 Agent 框架，AI 几小时就能生成一个看起来很完整的 MVP 。但我选了 Rust ，理由很具体：Agent 系统需要长期运行、需要内存安全、需要跨平台——这些需求第一天就是确定的，不会因为用户量上来了才变成需求。 设计原则也是。我定了"事件溯源"——每一次操作都记录，可以回溯和重放。这在 MVP 阶段看起来是多余的，但当你的 Agent 在凌晨 2 点做了个错误决策，你需要知道它为什么做了这个决策。这不是"以后再加"的事，因为你以后根本不知道要加在哪里。 测试也一样。1232 个测试，每个模块合并前必须通过。AI 帮我写了很多测试，但测什么、怎么测、边界条件是什么——这些是我决定的。AI 很擅长为自己的代码生成"能通过"的测试，这就像自己出题自己答，当然满分。 Andrej Karpathy 自己也承认过："代码超出了我的理解范围。当 AI 修不了一个 bug 时，我就让它随机改，直到错误消失。"这是 OpenAI 联合创始人说的，不是什么新手的窘境。 我的选择是不让代码超出我的理解范围。哪怕前期慢一点。 有人会说这样不是更慢了吗？前期确实更慢。但到现在，每个模块都可以独立修改而不影响其他模块。我知道这个系统的每一块是怎么工作的。 而那些用 AI 快速搭 MVP 的项目呢？ 63% 的开发者说调试 AI 生成代码花的时间比自己写还多。470 个 GitHub PR 的分析显示，AI 生成代码出现重大逻辑错误的概率是人写的 1.7 倍，安全漏洞概率是 2.74 倍。 AI 编程还带来了一种新的技术债，和传统的不一样。传统技术债你知道它在哪——那个 hack 、那个 TODO 、那个硬编码。AI 编程的技术债是隐形的。 一种叫理解债：代码能跑，测试全过，但没人能解释它为什么这样工作。调试一段你不理解的代码比调试自己写的慢 3 到 5 倍，而 AI 大幅增加了你代码库里"不是你写的"代码的比例。 一种叫同质债：不同公司、不同产品、不同需求的团队，用 AI 解决同一个问题会得到几乎一样的代码。AI 给你的是互联网上最受欢迎的解法，不是最适合你系统的解法。农业里叫单一栽培——高产但脆弱，一场病全军覆没。 还有一种叫归属债：开发者从代码的作者变成了策展人。出问题时第一反应不是理解原因，而是让 AI 重新生成。一位资深工程师说得很直接："AI 为当下而建，不为将来而建。它对自己生成的东西没有维护的利害关系。" 这几种债有个共同特点：你的仪表盘全是绿色的。Sprint 速度在涨，PR 合并更快，测试覆盖率 94%。一切看起来很好。直到有一天你需要改一个功能，发现没有任何人知道该从哪里改起。 所以我的想法是：在 AI 编程时代，别再用 MVP 思维了。直接一步到位。 不是说花三个月做完美产品再上线。AI 已经把构建高质量实现的时间成本压到和简易版差不多了。关键是你的思维方式要从"先简后优"变成"一步到位"——对 AI 描述你要的终态而不是最简态，架构决策由人来做而不是交给 AI ，关键路径必须是人类彻底理解的。 真正的快不是写得快，是改得快、修得快、迭代得快。如果你连自己的代码都不理解，你根本快不起来。 AI 编程的本质是黑箱。你可以让黑箱帮你写代码，但你不能让黑箱帮你做决策。你没法重构一个你不理解的东西。