学会表达
比学会编程 更重要

打开 AI，第一句话就是"帮我做一个……"，然后看着它刷刷刷地写代码，心里还挺高兴。但做完一看，完全不是你想要的东西。

你让 AI 直接开始写代码，就像你叫一个建筑师直接开始砌墙。 没有图纸。 他不知道这栋楼要盖几层。 不知道是办公楼还是住宅。 不知道你喜欢什么风格。 不知道你的预算是多少。 但他还是要砌。因为他收到了"开始砌"的指令。 于是他就按照自己的理解砌了一面墙。 你一看，说："不对，我要的是落地窗。" 他只能把墙拆了，重新砌。

AI 也是一样。 当你告诉它"帮我做一个软件"，它收到的信息只有"开始写代码"。 其它的，它一概不知道。 它不知道你真正想解决什么问题。 它不知道谁会来用这个软件。 它不知道你在什么场景下会用。 它不知道哪些功能是必须的，哪些是以后再说。 它不知道你有什么特殊要求。 它只能猜。 猜错了，就返工。

这不是 AI 的错。 是你跳过了最重要的一步： 先让 AI 理解你，再让它写代码。

旧表达下，AI 可能会：

• 直接开始写代码，生成一个你可能根本不需要的记账页面
• 自作主张地加了很多功能，比如财务报表、预算分析、多账户管理
• 你看着一堆代码，不知道从哪里改起

新表达下，AI 会：

• 停下来，先问你问题
• 比如："你希望记录哪些类型的支出？"、"需要分类功能吗？"、"需要按月统计吗？"
• 你回答了这些问题，AI 才真正理解你要什么
• 然后再开始写代码，出来的东西就更接近你的想法

有人给了你一个已经写好的项目，让你接着做。你打开一看，文件几十个，代码上万行，完全看不懂。第一步该问 AI 什么？

零基础用户面对一个已有项目时，最容易"不知道从哪问起"，然后直接让 AI 改代码。但改代码之前，你得先搞懂这个项目是怎么运转的。就像你新到一家公司，不会一上来就钻进某个模块改代码，而是先找老员工问清楚"咱们公司整体是做什么的""支付那块代码在哪""一笔订单从下单到扣款是怎么走的"。

AI 不再"随便猜你想干什么"，而是按层级给你讲清楚项目结构：先给你一张全景图，再定位到你关心的模块，最后带你走一遍核心流程。三步走完，你对项目的理解就从"完全看不懂"变成"知道大概怎么回事"了。

你跟 AI 说："帮我加一个排行榜"、"帮我加一个打卡功能"、"帮我加一个评论区"。你说的是功能，但 AI 不知道你为什么需要这些功能。

你说"加一个排行榜"，AI 就给你加一个排行榜。 但你真正想要的，是"激励用户多使用"。 排行榜只是你想到的一种方法。 但也许还有更好的方法？ 比如积分系统、成就徽章、每日提醒、学习报告…… 你不知道这些方法。 因为你不是产品经理。 你是普通人。 你只能想到"排行榜"。 但 AI 可以想到更多。 前提是——你告诉它你的真正目标。

AI 的工作方式是这样的： 你给它一个动作，它就执行一个动作。 你给它一个目标，它就会思考如何达成目标。 如果你只告诉它"加一个排行榜"，它的思考范围就只限于"排行榜怎么实现"。 如果你告诉它"我想激励用户多使用"，它的思考范围就变成了"有哪些方法可以激励用户"。 范围大了，方案就多了。 方案多了，你就更容易找到最适合你的。

旧表达下，AI 可能会：

• 直接做一个排行榜，包括排名、积分、头像等各种功能
• 排行榜做完了，你发现它跟你整个软件的风格完全不搭
• 你也不知道这个排行榜到底能不能激励用户

新表达下，AI 会：

• 先分析"激励用户"有哪些方法
• 可能列出：排行榜、积分、徽章、每日提醒、进度条、周报
• 然后帮你分析每个方法的优缺点
• 根据你的小项目，推荐最合适的方案
• 你可能发现，一个简单的"连续打卡天数"比排行榜更有效

同样一个功能，不同的人用起来感觉完全不同。你让 AI 做出来的东西，你觉得挺好，但给朋友一看，朋友说"这什么啊，完全不会用"。

因为 AI 不知道你的用户是谁。 它默认按照"所有人"来设计。 但"所有人"是不存在的。 你的用户可能是小学生，也可能是退休老人。 可能是上班族，也可能是自由职业者。 可能是技术高手，也可能是第一次用手机的人。 不同的人，需要完全不同的设计。

举个例子。 同样是"添加一条记录"这个功能。 如果是给小学生用的，按钮要大，文字要少，颜色要鲜艳。 如果是给会计用的，界面要紧凑，信息要密集，操作要高效。 如果是给老人用的，字要特别大，步骤要特别少，每个按钮都要有说明。 AI 不知道你的用户是谁，它只能按照一个"平均人"来设计。 但"平均人"不存在。 所以做出来的东西，谁用都觉得不太对。

旧表达下，AI 可能会：

• 做一个通用的学习软件，功能很多但都不精准
• 可能加入游戏化元素，但考研学生不需要这些
• 可能设计成需要长时间专注的学习流程，不适合碎片时间

新表达下，AI 会：

• 知道用户是考研学生，自动过滤掉不相关的功能
• 设计适合碎片时间的功能：快速浏览、稍后复习、今日目标
• 知道用户是手机重度使用者，优先考虑移动端体验
• 界面风格更简洁高效，而不是花里胡哨

AI 做出来的功能，逻辑上没问题，但就是用起来很别扭。比如，你让 AI 做了一个记录功能，它让你填写十几个字段，但你在外面用手机的时候，只想花三秒钟记一笔。

因为 AI 不知道你在什么场景下使用。 它默认的场景是：你坐在电脑前，时间充裕，精力集中。 但真实的场景可能是： 你在地铁上，一只手抓着扶手，另一只手拿着手机。 你在开会，偷偷在桌子底下记录。 你在睡前，躺在床上，已经快睡着了。 你刚花了钱，站在收银台前，后面还有人排队。

不同的场景，需要完全不同的设计。 同样是"记录一笔支出"： 在电脑前，你可以慢慢填金额、分类、备注、日期、标签。 在地铁上，你只能快速输入一个数字，然后点确定。 在收银台前，你甚至来不及打字，最好能拍一张小票就自动识别。 AI 不知道这些。 你不说，它就按照最理想的情况来设计。 但真实生活从来不是理想的。

旧表达下，AI 可能会：

• 设计一个包含十多个字段的记账表单
• 需要填写金额、分类、日期、备注、标签、账户、币种……
• 你在地铁上根本没法用

新表达下，AI 会：

• 设计一个极简的记录页面：大数字键盘 + 几个分类按钮
• 输入金额，选分类，就完成了
• 默认日期就是今天，不需要手动选
• 电脑端另外做一个统计页面，可以慢慢看
• 手机端和电脑端各司其职，不互相干扰

你脑子里有很多想法，但说不清楚。你大概知道自己想要什么，但一旦要写出来，就不知道从哪开始。

这是正常的。 你不是产品经理。 你没有受过需求整理的训练。 你脑子里有的，是一个模糊的想法。 比如"我想做一个好用的学习工具"。 但"好用"是什么？ "学习工具"包括什么？ 你不知道怎么拆解。

但 AI 知道。 AI 非常适合做一件事：把你模糊的想法，整理成清晰的需求。 你只需要把脑子里零散的想法全部倒出来。 不用管逻辑。 不用管顺序。 不用管有没有遗漏。 就像你跟朋友聊天一样，想到什么说什么。 然后 AI 帮你整理。

这就像你跟一个很会整理的人说："我房间太乱了，你帮我看看怎么收拾。" 你不用告诉他每件东西放哪里。 你只需要告诉他你的想法。 他会帮你分类、整理、提出方案。 AI 也是一样。

旧表达下，AI 可能会：

• 不知道从何下手，因为信息太少
• 可能直接开始做一个最简单的学习软件
• 做完以后你发现缺了很多东西

新表达下，AI 会：

• 先耐心听你把你脑子里能想到的全部说出来
• 然后帮你分类：这是核心功能，这是辅助功能，这是以后再说
• 告诉你还缺什么：比如"你没有提到复习功能，需要吗？"
• 帮你排优先级：先做什么，后做什么
• 你看到整理好的清单，一下子清晰了

你跟 AI 说了很多，AI 也按照你说的做了，但做完以后你发现，还缺了很多东西。有些是你忘记说了，有些是你根本没想到。

你只是一个普通人。 你不可能在第一次描述需求时，就把所有事情都想全。 这是正常的。 但 AI 不会主动提醒你。 因为 AI 收到的指令是：按照你说的做。 它不会说："你还需要一个登录功能。" 它不会说："你只说了添加记录，但删除记录呢？" 它不会说："如果用户忘记了密码怎么办？"

但如果你明确告诉 AI：请帮我补充遗漏。 AI 就会切换到"检查模式"。 它会系统地思考：这个功能还需要什么配套？ 这个场景还有什么没考虑到？ 这种思维方式，AI 非常擅长。 但前提是——你要让它做这件事。

旧表达下，AI 可能会：

• 就按你说的三个功能做
• 做完以后，你发现：不能删除单词、不能修改、不能分类、不能导入导出
• 你又得一个一个补充，每次补充都要修改

新表达下，AI 会：

• 主动列出你可能遗漏的功能：

- 删除单词、修改单词 - 按分类整理（名词、动词、形容词） - 标记已掌握 / 未掌握 - 导入单词表 - 按日期查看学习记录 - 收藏夹 - 复习提醒

• 然后你可以选择哪些需要，哪些不需要
• 一次就把该考虑的都考虑到了

想做一个"大项目"，但打开 AI 以后，不知道从哪开始。感觉要做的东西太多了，一上来就头大了。

你看到的是一个完整的"成品"。 你想象的是：一个功能齐全的网站，或者一个完整的软件。 但 AI 不能一次做出一个完整的软件。 它需要一个功能一个功能地做。 你需要的，不是一次做完所有事情。 而是把一个大项目，拆成很多个小任务。 然后一个一个完成。

这就像你搬家。 你不能一次把所有东西都搬过去。 你需要把东西分类：先搬大件家具，再搬衣服，最后搬零碎物品。 做软件也是一样。 你需要先拆：哪些是核心功能，哪些是辅助功能，哪些可以以后再做。 但你可能不知道该怎么拆。 AI 可以帮你拆。

旧表达下，AI 可能会：

• 不知道从哪开始，可能随便选一个功能开始做
• 做了一半发现依赖另一个功能，又回去补
• 整个过程混乱，你也很焦虑

新表达下，AI 会：

• 帮你拆成清晰的阶段：

- 第一阶段：课程展示页面（学生能看到有哪些课） - 第二阶段：用户注册和登录 - 第三阶段：老师上传课程 - 第四阶段：学生学习记录 - 第五阶段：评论和讨论

• 每个阶段都很小，你每次只需要关注一件事
• 你清楚地知道：现在做到哪了，下一步做什么

AI 给了你一个方案，你照着做了，但后来发现还有更好的办法。你心想："要是当时 AI 告诉我还有别的选择就好了。"

AI 倾向于给你一个"它认为最好的方案"。 但 AI 不知道你的偏好。 它不知道你更看重速度，还是更看重质量。 它不知道你更在意简单，还是更在意功能齐全。 它不知道你的预算是多少。 它的"最好"，不一定是你心中的"最好"。

但如果你让 AI 列出多个方案，并比较它们的优缺点。 你就可以自己选择。 比如： 方案 A：简单快速，三天能做完，但功能少。 方案 B：功能齐全，但需要两周，而且维护成本高。 方案 C：中等方案，一周能做完，功能够用。 你不知道这些选项的存在。 AI 需要你明确告诉它：列出选项，让我选。

旧表达下，AI 可能会：

• 直接选一种方式实现登录
• 你也不知道有没有更好的方式
• 做完了才发现，这种方式不适合你的项目

新表达下，AI 会：

• 列出几种方案：

- 邮箱 + 密码登录（最简单，适合小项目） - 手机验证码登录（不需要记密码，但需要短信服务） - 第三方登录（微信、QQ，方便但需要额外配置） - 邮箱 + 密码 + 第三方登录（最完整，但开发量最大）

• 告诉你每种方案的优缺点和适用场景
• 你可以根据你的情况选择最合适的

看了 AI 列出的几个方案，你还是不知道怎么选。每个方案都有优点，每个方案都有缺点。你心想："我要是懂技术就好了，就能知道哪个最适合我。"

做选择需要两个条件： 一、知道有哪些选项。 二、知道哪个选项最适合你。 第一节解决了第一个条件（让 AI 列出选项）。 但第二个条件，需要你把自己的情况告诉 AI。

你不需要懂技术。 你只需要告诉 AI 你的真实情况： 你是一个人做，还是有一个小团队？ 你想尽快上线，还是可以慢慢打磨？ 你更看重简单，还是更看重功能齐全？ 你愿意花多少钱？ 你的用户有多少人？ 这些信息，AI 无法自己获取。 但一旦你告诉它，它就可以帮你判断。

旧表达下，AI 可能会：

• 推荐一个"技术上最好"的方案
• 但那个方案可能太复杂，你一个人根本做不了
• 或者推荐一个"最简单"的方案，但可能不适合你的长期需求

新表达下，AI 会：

• 根据你的实际情况推荐：

- "因为你是一个人，而且追求快速上线，我建议用邮箱+密码登录。它最简单，不需要配置第三方服务，也不需要花钱买短信。等你用户多了，以后可以再加第三方登录。"

• 这个推荐是为你量身定制的
• 而且它还告诉你以后可以怎么升级

AI 每次改代码，风格都不一样。有时候用中文写注释，有时候用英文。有时候把代码写在一个文件里，有时候又拆成很多文件。每次改完，你都不知道它到底做了什么。

因为 AI 每次都是"重新开始"。 它不记得上次是怎么做的。 它不知道你希望保持什么样的风格。 它不知道你希望它怎么报告进度。 它不知道哪些事情需要问你，哪些事情可以自己决定。

但如果你在项目一开始，就跟 AI 说清楚： "以后每次改代码，都按这些规则来。" AI 就会遵守。 因为 AI 最擅长的事情之一，就是"遵守规则"。 你给它一个规则，它就会一直遵守。 但你不给它规则，它就会按照自己的习惯来。 而它的习惯，每次都可能不一样。

旧表达下，AI 可能会：

• 每次风格都不一样，代码越来越乱
• 改完不告诉你改了哪里，你完全不知道发生了什么
• 自己决定一些重要的事情，你后来才发现
• 一次改了很多地方，出了问题很难排查

新表达下，AI 会：

• 每次都遵守同样的规则，代码风格统一
• 每次修改前先告诉你计划，你确认后再动手
• 每次修改后告诉你改了哪些文件、影响了哪些功能
• 遇到不确定的事情，主动问你
• 整个过程变得可控、可预测

你让 AI "把这些功能都做了"，它一口气改了几十个文件。你看着满屏的改动，心里发慌——改了什么？改对了吗？万一有一个地方改坏了，根本找不到。

AI 收到"把多个功能都做了"的指令，它就开始同时处理。 它不会主动告诉你"这个太多了，我们一个一个来"。 它只会尽量完成你给的任务。 但问题是：改动越多，出错的可能越大。 改动越多，你越难检查。 改动越多，出了问题越难排查。

这就像你让一个人同时搬十件家具。 他可能会打碎一两个。 但你不知道是哪个环节打碎的。 你也不知道是不是所有家具都搬到了正确的位置。 但如果你让他一次只搬一件，每搬完一件你确认一下。 就不会出问题。 AI 也是这样。

旧表达下，AI 可能会：

• 三个功能一起做，代码改动量巨大
• 功能之间互相影响，容易出问题
• 你检查的时候完全不知道从哪看起

新表达下，AI 会：

• 只做登录，改动范围很小
• 你很容易检查：登录能用了，就可以确认
• 确认后再做注册，步步为营
• 即使出了问题，也很容易定位

你发现一个功能有问题，直接告诉 AI："修一下。"AI 开始改代码，改完以后，问题还在。你又说"再修"，AI 又改，问题还在。来回好几次，你都累了。

AI 收到"修一下"的指令，就开始修。 但它不知道问题出在哪里。 它只能猜：可能是这里有问题，改一下试试。 改完了，你试了试，不行。 它再猜：那可能是那里有问题，再改一下。 改完了，还是不行。

这就像你去看医生，只说"我难受"。 医生只能猜：可能是感冒，开点感冒药。 吃了没好，再猜：可能是胃病，开点胃药。 吃了还没好，再猜…… 但如果你告诉医生"我头疼，昨天开始的，发烧三十八度，吃了退烧药没效果"。 医生就能直接做检查，开对症的药。 AI 也是一样。 你让它"修一下"，它只能猜。 你让它"先分析问题"，它才能找到症结。

旧表达下，AI 可能会：

• 盲目修改代码，改了这里试那里
• 改了好几轮，问题还没解决
• 你浪费时间，AI 也浪费算力

新表达下，AI 会：

• 先分析：按钮点击事件有没有绑定？网络请求有没有发出？有没有报错信息？
• 告诉你最可能的原因和解决方案
• 你确认了，它再动手，一次改对
• 或者，它发现自己找不到原因，提前告诉你，而不是乱改

你跟 AI 说了一个需求，它直接开始写代码。你等了半天，它写完了，你一看："不对，我不是这个意思。"又得让它重来。

AI 默认的行为模式是：收到指令，立即执行。 它不会主动停下来，先跟你说"我打算这样做，你看行不行"。 因为它收到的指令是"做"，不是"先告诉我你的计划"。

但如果你让 AI 先说出计划，你就能在它写代码之前发现问题。 比如它说"我打算把所有用户信息放在一个页面上"。 你一看，不对，用户信息应该分几个页面。 你告诉它改计划。 它改计划，比改代码快得多。

这就像装修。 你让工人直接开工，他按照自己的想法砌墙、布电线。 做完了你一看："厨房不在这边。" 他只能把墙拆了重来。 但如果你让工人先画个草图给你看，你一眼就能看出问题。 改草图，十分钟。 拆墙重砌，十天。 AI 也是一样。

旧表达下，AI 可能会：

• 直接写代码，做出来可能跟你想的不一样
• 返工成本高，改代码比改计划慢得多

新表达下，AI 会：

• 先列出页面结构和功能清单
• 你看了觉得不对，马上能调整
• 计划确认了，再动手写代码，一次做对
• 整个过程快得多

你让 AI 做一个功能，它一口气做完，然后停下来等你。你看了半天，发现中间有一个步骤就走错了，导致后面全部白做。

AI 收到任务后，会一口气完成所有步骤。 它不会中途停下来问"这一步做对了吗？" 因为它的默认模式是"完成整个任务"。 但问题是：如果第一步就走偏了，后面的所有步骤都会偏。 而且你发现得越晚，返工的成本越高。

这就像你让一个人做一道菜，他没告诉你每个步骤做了什么。 最后端上来，你尝了一口，发现第一步就放错了调料。 但这时候已经晚了，整道菜都不能吃了。 如果他在放调料之前，先问你"这个量对吗？" 你就能及时纠正。 AI 也是一样。

旧表达下，AI 可能会：

• 一口气做完，你发现问题时已经晚了
• 中间某一步走偏，导致后面全错

新表达下，AI 会：

• 做完第一步，停下来告诉你："我做了A，你看对不对？"
• 你确认了，它再做第二步
• 每一步都经过你确认，方向不会跑偏
• 即使某一步要调整，也只影响这一步

你让 AI 修改登录按钮的颜色，它改完以后，你发现注册按钮的颜色也变了，首页的按钮颜色也变了。你只是想改一个按钮，AI 把整个软件的颜色都改了。

AI 收到"修改按钮颜色"的指令，它会想：按钮颜色应该统一，把所有按钮都改了吧。 这是 AI 的"好意"——它觉得帮你统一风格更好。 但你没有让它这么做。 你只想改登录按钮。 AI 扩大了修改范围，导致你原本满意的地方也被改了。

这就像你让理发师"鬓角修短一点"。 他理解成"修一个短发发型"，然后给你剪了一个板寸。 你看着镜子，说不出话。 他的出发点是好的——他觉得短发更适合你。 但你没有让他决定你的发型。 你只想修鬓角。 AI 也是一样——它会"好心"地扩大范围。 你需要明确告诉它：只改这里，别的地方不要动。

旧表达下，AI 可能会：

• 把所有按钮都改成蓝色
• 你可能不知道它改了哪些地方
• 你还要花时间检查哪些不该改的被改了

新表达下，AI 会：

• 只改登录按钮，其他按钮保持原样
• 改动范围极小，你一眼就能确认
• 不会出现"改好了这里，改坏了那里"的情况

你让 AI 给软件加一个新功能。新功能是加上了，但之前好好的登录功能突然不能用了。你心想："我让你加功能，没让你改登录啊。"

AI 在添加新功能时，可能会修改已有的代码。 它可能觉得"旧代码不够好，顺便改一下"。 也可能新功能和旧功能共享了一些代码，它改了共享部分，影响了旧功能。 但你没有让它改旧功能。 你只是让它加新的。

这就像你让工人给房子加一个阳台。 他加阳台的时候，顺便把你客厅的窗户换了。 他说："新窗户更好看。" 但你只想加阳台，你没有让他换窗户。 AI 也是一样——它会"顺便"改一些你觉得不需要改的东西。 你需要明确告诉它：已有的功能，一个都不许动。

旧表达下，AI 可能会：

• 加搜索功能的时候，顺便改了页面布局
• 你发现登录不能用了，又要花时间修
• 你不知道它到底改了哪些已有的东西

新表达下，AI 会：

• 优先选择不触碰已有代码的方式加新功能
• 如果必须改已有的，先告诉你，让你决定
• 新功能加好了，旧功能完全不受影响

你让 AI 改一个小问题，它改了几十个文件。你看着满屏的改动记录，心里发毛——一个小问题，需要改这么多吗？

AI 有时候会"过度修改"。 它看到一段代码，觉得"这里可以写得更好"，就改了。 它看到另一个文件，觉得"这个结构可以优化"，也改了。 它不断地"顺便改进"，最终改了几十个文件。 但你没有让它优化。 你只想修一个小问题。

每一次改动，都有风险。 改得越多，风险越大。 改得越多，你越难检查。 改得越多，越容易引入新问题。 所以，能少改，就不要多改。 这是软件开发的铁律。 AI 也需要你明确告诉它这条铁律。

旧表达下，AI 可能会：

• 把整个页面重构一遍，改了几十个文件
• 你不敢发布，因为改动太大了
• 万一引入新问题，排查范围巨大

新表达下，AI 会：

• 精准定位影响速度的地方，可能只改几行代码
• 改动量小，很容易检查
• 出问题的概率大大降低
• 即使出了问题，也很容易定位

你让 AI 做一个功能，描述得不太清楚。AI 没有问你，自己猜了一个方案，然后开始写代码。做完了你一看，完全不是你想要的。你心想："你不确定，为什么不问我？"

AI 收到一个模糊的指令，它有两种选择： 一、停下来问你，搞清楚再动手。 二、自己猜一个方案，直接动手。 AI 默认会选择第二种。 因为它收到的指令是"做"，不是"不确定的时候问我"。 它不会主动质疑你的指令。 它只会按照自己的理解去执行。

但如果你明确告诉 AI：不确定的时候，先问我。 AI 就会切换到"确认模式"。 它会主动告诉你：这个部分我不太确定，你希望怎么处理？ 你再告诉它，它再动手。 这样就不会出现"猜错了"的情况。

旧表达下，AI 可能会：

• 自己猜一个通知方式，做出来不是你要的
• 你又要花时间让它改
• 你会发现它做了很多"自己决定"的事情

新表达下，AI 会：

• 主动告诉你："我打算用软件内的弹窗通知，可以吗？还是你需要邮件通知？"
• 你做出选择，它再动手
• 不会出现"猜错了"的情况
• 你始终掌握决策权

AI 帮你写了一个软件，但每个页面的风格都不一样。首页是蓝色，设置页是绿色，个人中心是红色。每个按钮的形状、大小、颜色都不一样。整个软件看起来像几个人分别做的，拼在一起。

AI 每次都是独立完成任务的。 它不记得上次用的是什么颜色。 它不记得上次按钮是什么样式。 它不记得上次怎么写注释的。 每次你让它做新功能，它就重新开始。 所以第一个页面是蓝色，第二个可能变成绿色。

这就像你让不同的人写同一本书的不同章节。 每个人都有自己的风格。 写出来的东西拼在一起，读者一眼就能看出"这不是一个人写的"。 你需要给所有人一个统一的风格指南。 AI 也需要你给它一个统一的风格指南。

旧表达下，AI 可能会：

• 按照自己的默认风格来做新页面
• 每个页面风格都不一样，看起来像拼凑的
• 你后期要花大量时间统一风格

新表达下，AI 会：

• 先分析已有页面的风格特征
• 按照同样的风格来设计新页面
• 整个软件看起来统一、专业
• 不需要后期再花时间统一风格

AI 帮你写了代码，功能是实现了，但你回头一看代码，完全看不懂。变量名叫 a、b、c，函数名叫 func1、func2，你根本不知道每段代码是干什么的。

AI 默认追求的是"功能正确"。 只要代码能跑，它的任务就完成了。 至于代码好不好读、好不好维护，它不会主动考虑。 因为没有人告诉它"代码要写得让人看得懂"。 它默认的读者是机器，不是人。

但代码不只是给机器读的。 以后你还要修改、还要维护、还要让别的 AI 帮你改。 如果代码写得像天书，以后谁来改都很痛苦。 包括你自己。 所以，你需要告诉 AI：代码要写得让人看得懂。 变量名要有意义，函数名要能看出功能，不要用缩写，不要用莫名其妙的字母。

旧表达下，AI 可能会：

• 用 a、b、temp、data 这种无意义的变量名
• 代码能跑，但完全看不懂
• 以后维护成本极高

新表达下，AI 会：

• 用"用户姓名"、"订单列表"、"计算总价"这种有意义的名字
• 代码像文章一样，读起来流畅
• 以后修改、维护都很容易
• 你自己也能看懂 AI 写了什么

AI 帮你写了一段代码，三个月后你回来看，完全不记得这段代码是干什么的了。你想改，但不敢改，因为改坏了怎么办？

AI 写代码的时候，它知道自己在做什么。 但它不会主动给代码加注释。 因为注释对于机器来说没有用——机器不读注释。 但注释对于人来说，是救命的东西。 三个月后的你，需要注释来理解当时的思路。 接手你项目的另一个人，需要注释来理解代码。 甚至另一个 AI 来帮你改代码的时候，也需要注释来理解上下文。

注释不是写给 AI 的，是写给未来的自己。 一句话，就能帮你省下半个小时的回忆时间。

旧表达下，AI 可能会：

• 写出一段没有注释的代码
• 三个月后你回来看，完全不知所云
• 你不敢改，因为不知道改了会怎样

新表达下，AI 会：

• 在关键代码处加上清晰的注释
• 解释"这段代码做什么"和"为什么这样做"
• 三个月后你回来，读注释就能理解
• 修改起来安心多了

AI 改完代码，直接交给你，说"修好了"。你一试，发现还有问题。你说"还有问题"，它又改，改完又有新问题。来回折腾，你都快疯了。

AI 默认的工作模式是：改完代码，提交给你。 它不会主动检查自己改得对不对。 因为它收到的指令是"修"，不是"修完检查"。 但如果你告诉 AI：修完以后，先自己检查一遍。 AI 就会在提交之前，多走一步。 它会检查：代码有没有明显的错误？有没有遗漏？功能是否正常？ 这就相当于给你加了一道质量过滤。 AI 自己能发现的错误，就不会交到你手上。

旧表达下，AI 可能会：

• 改完就交，你帮它测试
• 你发现一个问题，它再改，改完又有新问题
• 来回折腾，效率极低

新表达下，AI 会：

• 改完以后，自己先检查一遍
• 能自己发现的问题，在交给你之前就修好了
• 交到你手上的代码，质量明显更高
• 你不需要一遍遍帮它找问题

AI 改完代码，跟你说"改好了"。你问它"改了哪些地方"，它说"改了一些文件"。你打开一看，改了十几个文件。你完全不知道每个文件改了什么，更不知道这些改动会不会影响其他地方。

AI 默认不会主动汇报修改范围。 它觉得"改好了"三个字就够了。 但作为项目负责人，你需要知道： 改了哪些文件？ 每个文件改了什么？ 这些改动会不会影响其他功能？ 有没有什么风险？ 这些信息，AI 都知道，但它不会主动说。 除非你明确要求它汇报。

旧表达下，AI 可能会：

• 只说"改好了"，你完全不知道它做了什么
• 你不知道改了什么，不敢放心使用
• 出了问题，你不知道从哪里排查

新表达下，AI 会：

• 汇报：改了3个文件，分别是A、B、C
• 详细说明：A文件改了登录验证逻辑，B文件改了按钮样式，C文件加了错误提示
• 影响分析：登录功能有变化，其他功能不受影响
• 你心里有数，可以放心使用

AI 帮你修一个问题，修了一次，没修好。又修了一次，还是没修好。又修了第三次，第四次……你看着它一遍遍地试，代码越改越乱，问题越来越复杂。

AI 有一种"执念"：你让它修，它就一定要修好。 它不会主动说"这个问题我修不好，需要换个思路"。 它会一直尝试，改这里、改那里、再改这里。 但有些问题，不是靠"多试几次"就能解决的。 越试越乱，越改越复杂。 最后，不仅问题没解决，代码也变得一团糟。

这就像你让一个人修一个漏水的水管。 他修了一次，还在漏。 又修了一次，还在漏。 他急了，开始用各种方法乱试。 最后水管炸了，水漫金山。 正确的做法是：试了两次还不行，停下来，换个思路。 AI 也需要你告诉它：试了两次还不行，就停下来，想想别的办法。

旧表达下，AI 可能会：

• 反复尝试，越改越乱
• 代码越来越复杂，问题越来越难修
• 你浪费了大量时间，问题还没解决

新表达下，AI 会：

• 停下来，不再盲目修改
• 重新分析问题的根本原因
• 换一个思路，或者告诉你需要什么额外信息
• 不再把代码越改越乱

AI 改了一段代码，改完以后，你的数据库出问题了，数据丢了。你质问 AI："你改之前为什么不告诉我这会有风险？"AI 说："你没问。"

AI 在做一些高风险操作时，不会主动提醒你。 比如修改数据库结构、删除文件、修改共享代码。 它觉得这是你让它做的，它就做。 它不会说"这个操作有风险，可能会丢失数据，你确定要这样做吗？" 因为它默认假设：你知道你在做什么。 但很多时候，你不知道。 你不知道这个操作会有风险。 你不知道改了这个文件会影响其他地方。

你需要告诉 AI：遇到可能有风险的操作，必须先提醒我。 给我一个"反悔"的机会。

旧表达下，AI 可能会：

• 直接修改数据库，数据丢了
• 你没备份，损失惨重
• 你完全不知道这个操作有风险

新表达下，AI 会：

• 先告诉你："修改用户表结构可能导致已有数据丢失，建议先备份。另外，登录功能可能会短暂中断。"
• 你知道了风险，可以决定：先备份，或者选一个低峰期操作
• 不会再出现"改了之后才发现出问题"的情况

做了一个记账本。刚开始只有两百行代码，加着加着就变成了一千八百行。功能还是那些功能，但代码像发面一样，越揉越大。

AI 每次帮你加功能，都是直接在后面追加。它不会主动帮你整理。就像你每次买东西都往衣柜里塞，从来不叠。衣服是多了，但衣柜越来越乱，找一件得翻半天。

AI 不再盲目删代码。它会先分析哪些代码是重复的，哪些是冗余的，然后给出一个合并方案。你看到的是一份有逻辑的"瘦身计划"，而不是一通乱删。

做了一个单词学习工具。里面有单词添加、单词复习、单词测试三个页面。每个页面都有一段几乎一模一样的代码，用来显示单词列表。三个页面，三段重复。

AI 每次都是独立完成一个页面。它不会自动发现"这个功能之前写过"。就像你请了三个不同的厨师，每个人都自己买了盐，结果厨房里有三袋盐。

AI 会精确地找到那三段重复代码，提取出一个公共部分，然后让三个页面都引用这个公共部分。以后你改显示逻辑，只需要改一处。

做课程管理项目，一开始只有一个 course.js 文件。后来加了作业功能、考试功能、成绩功能，全塞进这一个文件里。现在文件有 3000 行，翻找代码像翻字典。

AI 默认不会主动帮你分文件。它觉得"反正能跑就行"。就像你用一个笔记本，什么科目都往上写，数学、语文、英语全混在一起。时间长了，别说别人，你自己都看不懂。

AI 会先分析代码结构，搞清楚哪些代码属于哪个模块，然后有序地拆分。它还会检查其他文件的引用，确保拆完后程序能正常运行。

做了一个待办事项工具。里面有一个"处理任务"的函数，从最初的 20 行，涨到了 180 行。添加任务、删除任务、标记完成、设置提醒、发送通知，全挤在一个函数里。

每次加功能，AI 都在这个函数里加几行。它不会主动说"这个函数太长了，该拆了"。就像你每次吃饭都往碗里加菜，从来不换碗，最后碗满得溢出来。

AI 会按照你指定的五个操作，逐个拆成独立函数。主函数变成短小精悍的"调度员"，每个操作有自己的"专属办公室"。单测也更容易。

做了一个博客管理后台。文章列表页一开始只有标题和日期。后来加了作者、分类、标签、阅读量、点赞数、评论数、状态标记。一个页面塞了十几个功能，眼花缭乱。

AI 不会拒绝你的需求。你让它加什么它就加什么，从不提醒你"这个页面信息量已经很大了"。就像你往墙上贴便利贴，一张又一张，从来不揭，最后整面墙都是。

AI 会按照你指定的 6 个核心字段重新设计页面布局。其他字段可能收进详情页，或者做成可展开的折叠区域。页面清爽了，但信息不丢。

让 AI 改一个课程列表的筛选功能。第一次改完，筛选不生效。第二次改完，样式乱了。第三次改完，筛选生效了但数据不对。第四次改完，回到最初的状态。改来改去，越来越乱。

AI 每次修改都是基于当前代码，但它不知道你之前已经改过几次了。就像你让三个人接力修一辆自行车，每个人只看到上一个人留下的车，不知道最初的车长什么样。修到最后，轮子都装反了。

AI 会先撤销之前的改动，回到干净状态，然后重新理解需求。它不再基于乱七八糟的代码修修补补，而是从零开始实现筛选功能。

做了一个单词本，修复了"添加单词"的一个小问题。结果"复习模式"的发音功能坏了。修好发音功能，"单词统计"又出错了。像打地鼠，按下这个，那个冒出来。

不同功能之间共享了一些代码。你改了一个共享部分，其他依赖它的功能就跟着崩了。就像一栋楼里，你修了一根水管，结果隔壁房间的灯灭了。因为水管和电线走的是同一个管道。

AI 会去检查共享代码，找到 A 和 B 之间的耦合点。它不会只盯着一个功能修，而是会考虑"动了这里，那里会不会受影响"。修复后还会主动检查关联功能。

做一个客户管理工具。同一个东西，有的地方叫 userName，有的地方叫 customer_name，有的地方叫 clientName。同一个"保存"按钮，有的叫"确认"，有的叫"提交"，有的叫"保存"。看着就乱。

AI 每次生成代码时，命名方式可能不一样。它没有"全局命名规范"这个意识。就像你每次去咖啡店，今天点"中杯"，明天点"中间那个"，后天点"不大不小的"。虽然服务员听懂了，但菜单上写的是"标准杯"。

AI 会搜索全项目，找到所有不统一的命名，然后按你指定的风格统一替换。它还会注意区分哪些是变量名、哪些是数据库字段名，不会一锅端。

做了一个博客系统。早期有一个"草稿箱"功能，后来觉得没用，去掉了页面入口。但草稿箱的代码还留在项目里，占了三百多行。类似的还有好几个废弃功能。

AI 在帮你去掉功能时，往往只删了页面入口，底层的代码还留着。它怕删错了导致其他功能报错。就像你搬家时，觉得旧沙发不好看，把它搬进了储藏室，但没扔掉。房子大了，储藏室满了。

AI 会先梳理这三个废弃功能的代码边界，确认它们不再被任何活跃功能引用，然后安全地删除。它不会像以前一样"留一手"，因为你给了它明确的边界和安全约束。

做待办工具时，最早用了一个叫 oldTodo.js 的文件。后来重构了，新建了 todo.js。但 oldTodo.js 还留在项目里，没人引用它，也没人删它。项目里至少躺着七八个这样的"僵尸文件"。

AI 不会主动检查项目中哪些文件没有被引用。它专注于"加"，不关注"减"。就像你换了新手机，旧手机还放在抽屉里，抽屉越来越满。

AI 会系统地扫描项目，分析每个文件的引用关系，生成一份清晰的清单。你确认一个，它删一个，不会误删。

三个月前和 AI 一起做了一个课程表工具。现在想加一个新功能，打开代码一看，完全想不起来这段逻辑是干什么的。注释没有，变量名很随意，读代码像读天书。

AI 写代码时默认不会加注释，除非你明确要求。它觉得"代码就是最好的文档"。但对你来说，三个月后的代码就跟陌生人写的一样。

AI 会逐函数分析，给每个函数加上清晰的注释，包括参数说明、返回值说明、逻辑概述。代码逻辑不会动，但可读性大幅提升。

做电商课程项目，有一个"判断用户是否有优惠资格"的逻辑。一开始只有一条规则：注册满 30 天。后来加了：消费满 500 元、VIP 等级大于 2、近 7 天有登录、没有退货记录。现在这个判断逻辑有 80 多行，层层嵌套，像千层饼。

每次加规则，AI 都是在现有判断上再加一层 if。它不会主动说"规则太多了，该重新组织了"。就像一个接线板，插头越插越多，线绕成一团。

AI 会把每条规则拆成独立判断，主逻辑变成"一条一条检查，汇总结果"。嵌套消失了，每条规则清晰可读。以后加新规则，只需要加一条独立判断，不用在千层饼里找位置。

做了一个学生管理系统。修改学生信息的功能，不知怎么回事会影响到课程排课。添加新课程，学生列表偶尔会刷新失败。功能之间扯来扯去，像一张蜘蛛网。

不同功能共享了数据、共享了状态、共享了全局变量。改一个，可能牵动另一个。AI 在写代码时没有做好"隔离"。就像住宿舍，你关了自己房间的灯，结果室友的房间也黑了，因为你们共用了一个总开关。

AI 会找到共享的数据源和状态，然后给每个功能建立独立的数据管理。两个功能之间通过明确的"传话通道"通信，而不是共用一个"大喇叭"。

做一个个人博客，每次想加个小功能，比如加一个"相关文章推荐"，都要改五六个文件。改完还要担心有没有遗漏的地方。每次改代码都提心吊胆。

项目结构没有做好"关注点分离"。改一个功能需要碰多个文件，因为逻辑散落在各处。AI 早期帮你搭建项目时，没有考虑"未来好不好改"。就像你家的电线埋在了墙里，想加一个插座，得把整面墙凿开。

AI 不会一上来就"重构整个项目"。它会聚焦在文章模块，把散落的逻辑归拢到一两个文件里。改完后你修改文章功能，只需要动一两个文件，不再需要翻遍整个项目。

做了一个单词学习项目，做了半年。现在回头看，代码结构像一团乱麻。想加一个新功能，不知道往哪加。想改一个老功能，怕改坏别的地方。维护成本越来越高。

项目在生长过程中，没有定期的"整理和打扫"。AI 只负责帮你加功能，不负责帮你维护结构。代码债务越积越多。就像你住了一年的房子，从来不打扫，地上全是灰，柜子里塞满了东西，想找什么都找不到。

AI 会从最乱的地方开始，一步一步整理，不是推倒重来。它会保持功能不变，只优化结构和可读性。你还能用"加新功能耗时"来验证整理效果。

做了一个记账应用。数据库连接配置写在代码里，接口地址写了三份（开发环境一份、测试环境一份、线上环境一份），颜色、字体大小散落在各个页面里。想改一个颜色，要翻六个文件。

AI 在写代码时，习惯把配置和逻辑混在一起。它不会主动说"这个应该抽出来统一管理"。就像一个餐厅，每个厨师都自己记菜单价格，有人记错了，菜价就不一样了。

AI 会扫描项目，找到所有散落的配置，分门别类地搬到三个文件里。它还会在代码中用"引用"代替"硬编码"，以后你改配置只需要改一个文件。

做了一个图片展示页面，刚开始加载很快。后来图片越来越多，一张页面要加载 50 张图片，打开要等 8 秒。用户等不及，直接关掉了。

AI 在加功能时，默认把所有数据一次性加载。它不会主动说"数据太多了，该分页了"或者"图片该懒加载了"。就像你去餐厅，服务员把菜单上所有菜一起端上来，桌子根本放不下。

AI 会分析慢的原因，然后实施懒加载（滚动到哪加载到哪）或者分页加载。它不会盲目删图片或者压缩质量，因为你的限制里写了"不能降质量"。

做了一个课程列表接口。刚开始只有 20 门课，接口返回很快。后来课程加到 500 门，每次请求要等 3 秒。学生打开课程页面，盯着白屏发呆。

AI 在写接口时，默认一次性返回所有数据。它不会主动做分页、不会做缓存、不会做字段筛选。就像你去图书馆借书，管理员把整个图书馆的书都搬到你面前，让你自己找。

AI 会实施分页查询（每次只返回 20 条）、字段精简（前端不需要的字段不返回）、数据库查询优化（加索引）。三管齐下，速度自然就上来了。

做了一个记账统计功能。要统计一年的消费数据，每月分类汇总。刚开始只有 3 个月的数据，瞬间出结果。后来有了一年的数据，3000 条记录，统计一次要等 15 秒。

AI 在写统计逻辑时，用的是最简单直接的方式：一条一条遍历、一条一条计算。数据少的时候没问题，数据多了就慢得离谱。就像你数硬币，100 个可以一个一个数，10000 个这样数就疯了。

AI 会考虑多种优化策略：用缓存存中间结果、用更高效的数据结构、甚至把部分计算放到数据写入时提前完成。不再是简单的"一条一条数"。

做了一个文件处理工具，可以把大文件拆成小文件。处理 100MB 的文件时，电脑内存占用飙升到 2GB，风扇狂转，其他程序都卡住了。

AI 在处理文件时，默认把整个文件读进内存。文件小的时候没问题，文件大了内存就爆了。就像你用车搬东西，沙发也往里塞、冰箱也往里塞，一辆小轿车装不下整个家。

AI 会把"一次性读入"改成"流式处理"：读一点、处理一点、写一点、释放一点。内存占用始终维持在一个低水平，不管文件多大。

做了一个单词学习工具，每次打开控制台都有一堆红色报错。有的报错影响功能，有的不影响但看着烦。每天上线前都要"清报错"，像扫雷一样。

AI 在写代码时，对错误处理不够完善。有些路径没考虑到，有些数据格式没做校验，有些边界情况没处理。就像你出门没带伞，下雨了才知道。

AI 会按照你指定的优先级，从高到低逐个修复。它不会东修一个西修一个，而是有计划地推进。每修完一批，你会看到控制台的红字越来越少。

做了一个在线考试系统。学生在考试时，偶尔会提交失败，提示"网络错误"。但不是每次都失败，大概每 20 次提交就有 1 次失败。问题很难复现，更难修复。

偶发错误通常和时序、网络波动、并发操作有关。AI 在正常流程下测试没问题，但极端情况它没考虑到。就像你家的灯，平时都亮，偶尔闪一下，电工来了灯又不闪了，查不出问题。

AI 会先在你的代码里加上详细的日志记录。等收集到失败日志后，它就能分析出失败的原因（超时？并发冲突？数据格式问题？），然后精准修复。

做了一个博客系统。三周前修复了一个"文章保存失败"的程序问题（Bug）。这周又出现了，一模一样。修好了，过几周又回来。像打不死的小强。

AI 修复 Bug 时，只修了表面症状，没有修根本原因。或者修复方式不对，被后续的代码改动覆盖了。就像你只擦掉了墙上的霉斑，没有解决墙内漏水的问题，霉斑迟早还会回来。

AI 不会再用"创可贴"式修复。它会深挖根因，然后加上自动测试。以后每次你改代码，这个测试都会跑一遍，Bug 一复发就能立刻发现。

做了一个积分兑换功能。用户用积分兑换奖品时，偶尔会出现积分扣了但奖品没发放。让 AI 修了五次，每次都说"修好了"，但问题还在。你开始怀疑 AI 到底行不行。

这个问题的根本原因可能不在 AI 修的代码里，而在更底层的数据读写、事务处理、或者并发控制上。AI 只看到了问题的"症状"，没看到问题的"病因"。就像你一直吃止痛药，但头痛的原因是颈椎问题，吃再多止痛药也没用。

AI 会停下来，不再盲目地修修补补。它会先画流程图，分析整个业务链条，找出薄弱环节。这个过程可能发现之前五次都没注意到的问题——比如并发时数据不一致。

做了一个项目，总觉得哪里不对劲。页面有点慢，代码有点乱，偶尔报个错，改起来有点费劲。但你说不出具体问题是什么。这种感觉很挫败。

"感觉不对劲"是人类的直觉，但 AI 不懂直觉。AI 需要具体的数据、可观察的现象、可量化的指标。就像你去看医生，只说"我浑身不舒服"，医生不知道该给你做什么检查。

AI 会像一个体检医生，按照你指定的四个方面逐项检查。它会给出具体的数据和结论，而不是模糊的判断。你拿到报告后，就知道问题在哪了，然后可以回到 3.1 到 3.24 的任何一节，用对应的方法解决。

你在做一个记账应用，已经能记录收入和支出。现在想加一个"月度统计"功能，显示每个月的总支出和总收入的对比。你把需求说给AI，结果它把整个项目重写了一遍，连之前能用的记账功能都变了样。

AI不知道你的项目已经有了什么。当你笼统地说"加一个月度统计"，它只能从零开始理解你的需求。在它的视角里，它需要自己设计数据结构、自己写页面、自己写逻辑。它不知道你的记账功能已经有一套完整的数据格式，于是就自己造了一套新的，结果和旧代码完全对不上。 这就像你请了一个装修师傅来加一个书架。你没告诉他家里是什么风格、墙面是什么材质、插座在哪里。他只能按自己的理解来，结果书架装好了，挡住了一个插座，颜色也和家具不搭。

AI会先读取你已有的代码，理解当前的数据结构。然后只在指定的位置添加新代码，不会去动已经运行正常的记账功能。它会给新功能单独写一个文件或一个区域，不会和旧代码混在一起。

你的单词学习应用里有个"每日打卡"功能，但你觉得太麻烦，不想用了。你告诉AI"把打卡功能删掉"，结果删完之后，背单词的页面也打不开了。因为打卡功能的数据和背单词的记录是关联的，AI删的时候把关联的代码也一起删了。

代码不是孤立的。一个功能往往和好几个地方有关联。打卡功能可能和用户数据、日期计算、页面显示、本地存储都有关系。AI不知道这些关联，你说"删掉打卡"，它就真的把所有和"打卡"相关的代码都删了，包括那些背单词功能也在用的部分。 这就像你想把客厅里的一张旧桌子搬走，但桌上放着全家人的水杯、遥控器、杂志。你直接搬走桌子，桌上的东西全掉地上碎了。

AI会先扫描项目，找出所有和打卡相关的代码，然后告诉你哪些是打卡专用的，哪些是共享的。它只会删除打卡专用的部分，保留共享的代码。删完后还会主动检查一遍，确认其他功能没有受影响。

你的待办事项应用里，现在完成任务是直接划线删除。你想改成"任务完成后变成灰色，移到列表底部"。你告诉AI"改一下完成任务的显示方式"，结果它把整个列表的排序逻辑都改了，新增的任务反而排在最后面了。

你心里想的是"只改显示效果"，但AI听到"改显示方式"后，它可能理解为"重新设计整个展示逻辑"。AI不知道你的底线在哪里，它觉得既然要改，就帮你改得更彻底一些。结果好心办坏事。 这就像你让理发师"稍微修一下刘海"，结果他觉得你的发型整体都需要调整，给你剪了个完全不同的发型。

AI会精准定位到显示任务的那部分代码，只修改颜色和位置的样式。它不会去碰排序函数、数据存储、添加任务的逻辑。修改范围被严格限定，代码改动量很小。

你的课程表应用里，本来点击课程名称就能看到课程详情。你让AI加了一个"编辑课程"的功能，结果它把点击行为改成了"点击直接进入编辑模式"。想看课程详情的同学点进去就误触了编辑，很烦恼。

AI不知道你原来是怎么用的。当它加一个新功能时，它可能觉得"点击"这个动作应该对应新功能，于是把旧的行为覆盖了。它不理解"保留原来的使用习惯"这件事有多重要。 这就像你把家门钥匙给了一个朋友让他帮忙装个智能门锁，结果他把原来的钥匙孔堵住了，你只能用手机开门。你妈来你家的时候进不去了。

AI会把原来的点击行为视为"保护区"，不去动它。新功能会另找入口，和旧功能共存。它不会为了"方便"而合并两个功能，而是保持清晰的边界。

你的博客项目里已经有了一个"文章列表"组件，显示所有文章的标题和日期。现在你想在首页加一个"最新文章"模块，显示最近3篇文章。你告诉AI"加一个最新文章模块"，结果它重新写了一套列表组件，代码和原来的文章列表几乎一模一样，只是取了前3条。

AI喜欢"从零开始写"。当你让它加一个新模块时，它默认会写一套全新的代码。它不会主动去检查项目里是否已经有类似的组件可以复用。它觉得自己写新的更快，但这样会让项目越来越臃肿。 这就像你家里已经有一个工具箱，里面锤子、螺丝刀都有。你让家人帮忙钉个钉子，他跑去五金店又买了一把新锤子回来，而不是去工具箱里拿现成的。

AI会先搜索项目中已有的组件，找到文章列表组件后，分析它的数据获取方式和渲染逻辑。然后只做最小改动：调整数据查询的数量限制，修改标题文字。代码量很少，不会引入新的组件。

你的单词学习应用里，已经有一个"计算正确率"的功能，在每轮学习结束后显示。后来你又加了一个"学习报告"页面，也需要显示正确率。AI帮你做报告页面时，重新写了一套计算正确率的逻辑，结果两个地方算出来的正确率不一样，一个显示85%，一个显示90%。

AI在不同时间、不同上下文中帮你写代码，它不记得自己之前写过什么。每次你提一个新需求，它对项目的理解都是"局部"的。它不知道"计算正确率"这个功能已经在别的地方实现过了。 这就像一个公司的两个部门，各自统计了同一个数据，但用了不同的统计方法，结果对不上。老板拿到两份报告，不知道信哪个。

AI会先搜索"正确率"相关的函数，找到后直接引用。如果发现格式不匹配，它会提出修改建议，但不会另起炉灶。这样项目里只有一个计算正确率的地方，改了这里，所有地方都同步更新。

你的待办事项应用里，你想把"任务优先级"从三个等级（高、中、低）改成五个等级（紧急、高、中、低、不急）。你直接告诉AI"改一下优先级"，它就开始修改代码。但你不知道它改了哪些文件，改完之后你发现有些地方还是旧的三个等级，有些地方是新的五个等级，数据混乱了。

一个功能的修改往往涉及多个文件。优先级这个设定可能出现在数据定义、页面显示、筛选功能、排序功能、统计功能等多个地方。AI可能只改了它"看到"的那几个文件，遗漏了其他地方。而你不知道它改了哪里，就没法检查遗漏。 这就像你让一个人去给办公室换灯泡，但你没告诉他哪些房间需要换。他只换了走廊的灯，会议室和洗手间的还是旧的，你也不知道他到底换了哪些。

AI会先做一个全面的代码搜索，把项目里所有出现"优先级"的地方都找出来。然后整理成一份清单，告诉你数据定义在哪、页面渲染在哪、筛选逻辑在哪、排序逻辑在哪。你看了清单，可能还会补充遗漏的地方，然后再让AI动手改。

你的记账应用里，你修改了"支出分类"的数据结构，把原来的一级分类改成了两级分类（比如"餐饮"下面再分"早餐""午餐""晚餐"）。你让AI改完数据定义和录入页面，但没注意到"月度统计"和"分类筛选"这两个功能也依赖旧的数据结构，结果这两个功能直接报错了。

代码里的东西是互相依赖的。你改了底层的数据结构，所有用到这个数据的地方都可能受影响。AI改完你指定的地方就停了，它不会主动去排查"还有哪些地方用了这个数据"。 这就像把一栋楼的一楼承重墙拆了，你只修了一楼的天花板，但二楼、三楼的地板也会受影响。你不检查楼上，等到楼上的人踩空掉下来才知道出事了。

AI会改完你指定的部分后，自动搜索项目中所有引用支出分类的代码。它会列出月度统计、分类筛选、年度报告、数据导出等所有相关页面，并告诉你每个页面需要怎么改才能适配新的两级分类结构。

你让AI给课程表应用加了导出功能，修改了三个文件。AI说"改完了"，你一试，导出功能确实能用。但过了两天你才发现，课程表的时间显示出了问题——原本显示"08:00-09:30"的，现在变成了"8:0-9:30"。AI在修改导出功能时，不小心改动了时间格式的处理代码。

AI在修改代码时，注意力集中在你要的新功能上。它可能不小心碰到了旁边的代码，或者改了一个公共函数，导致其他地方受影响。而它自己不会主动回头检查"我有没有搞坏别的东西"。 这就像你请人修水龙头，修好了水龙头确实不漏水了。但他修的时候不小心把水管接口拧松了，过了几天厨房开始漏水。他没检查整个水路系统。

AI会像一个测试员一样，逐个检查项目的每个功能。它会打开每个页面，模拟点击每个按钮，检查数据读写。然后给你一份报告，告诉你哪些功能正常，哪些有问题。如果发现问题，它还会建议怎么修复。

你的记账应用用了两周，一直很正常。有一天你输入了一笔金额为"0"的支出，应用直接崩溃了。你回头一看，原来是AI在写计算逻辑时，没有考虑到金额为0的情况，做除法时出了错。一个潜伏了两周的程序问题（Bug），因为一个特殊输入触发了。

AI写代码时，默认按"正常情况"来写。它假设用户输入的都是合理的数字，不会想到有人会输入0、负数、或者特别大的数字。这些边界情况，AI不会主动去想，除非你专门提醒它。 这就像你买了一把伞，晴天用着没问题，一到下雨天发现伞面上有个洞。做伞的人只考虑了"伞能打开"，没考虑"伞能挡雨"。

AI会像一个经验丰富的质检员，逐行扫描代码。它会特别留意那些"看起来没问题但可能出问题"的地方。比如除法运算、数组下标、用户输入、文件操作。这些地方最容易藏Bug，AI会重点排查。

你让AI做了一个单词学习应用，需求里写了"背单词、测试、生词本"三个功能。AI做完了，你试了一下，背单词和测试都正常，但生词本里只能看到单词，不能点进去看释义。AI漏掉了"点击生词查看详情"这个细节。

AI对你口头描述的需求，理解可能不够完整。你心里想的"生词本"是一个完整的模块，包括列表、详情、删除、排序。但AI可能只理解成"显示生词列表"。它不会主动去想你漏掉了什么。 这就像你让裁缝做一件衣服，说了"要有领子、有口袋、有扣子"。裁缝做好了，你发现扣子缝上了但没有扣眼。你觉得"扣子"当然包括扣眼，但裁缝只理解了你说的"扣子"这两个字。

AI会拿着你的需求清单，像核对购物清单一样，一项一项去检查代码。它不会遗漏任何一个子功能，因为每个子功能都写在清单上了。如果发现某个功能只做了一半，它会明确告诉你还差什么。

你的博客项目里，你让AI加了好几次功能。加了文章搜索、加了标签筛选、加了分类浏览。有一次你发现这三个功能各写了一套获取文章列表的代码，三套代码逻辑一模一样，只是变量名不同。项目里凭空多了两套重复代码。

AI每次处理你的新需求时，都是独立写的。它不会记住"上次我已经写过获取文章列表的代码了"。当你让它加搜索功能时，它从零开始写了一套获取列表的代码；加标签筛选时，又写了一套。代码就这样悄悄重复了。 这就像你去超市买东西，每次都买一瓶酱油回家，因为你不记得家里已经有酱油了。三个月后，厨房里有五瓶酱油，占地方又浪费。

AI会像一个大扫除的管家，把所有代码摊开来看。它会比较不同文件里的函数，找出那些"干的事一样但名字不同"的代码。然后建议你把它们合并成一个公共函数，减少重复。

你的待办事项应用经历了多次修改。最初有一个"番茄钟"功能，后来你决定不要了，让AI删了入口按钮。但番茄钟的倒计时逻辑、提醒音效、休息计时器这些代码，还安静地躺在项目里。它们没有被任何地方调用，但占着空间，有时候还会干扰新功能的开发。

AI在删除功能时，往往只删了"入口"——页面上的按钮、菜单里的链接。但背后的代码逻辑、样式文件、数据定义，可能还留在项目里。这些代码像被遗忘在阁楼里的旧家具，没人用，但占地方。 这就像你搬家了，只搬走了沙发和床，但旧房子里的衣柜、书桌、台灯还留在那里。你不住那里了，但东西还在。

AI会像一个仓库管理员，盘点所有"库存"。它会追踪每个函数被谁调用、每个变量被谁使用、每个文件被谁引用。如果发现某个东西没有任何引用，就标记为"疑似无用"。它不会直接删，而是让你确认，因为有些代码可能是"备用的"。

你的单词学习应用里，AI写了一个判断"是否通过测试"的逻辑：正确率大于60%就算通过。但你发现正确率刚好等于60%的时候，显示的是"未通过"。你一看代码，AI写的是"正确率 > 60"，把等于的情况漏掉了。

AI在写条件判断时，有时候会忽略"等于"这个边界情况。大于60和大于等于60，差了一个等号，但结果完全不同。这种逻辑错误不会让程序崩溃，所以很难被发现，但结果就是错的。 这就像你定了一个规矩："考试60分以上及格"。但执行的人理解成了"超过60分才及格"。考了60分的同学，明明达标了，却被判不及格。

AI会像一个数学老师批改作业一样，逐个检查每个条件判断。它会用边界值去测试：等于的情况、大于的情况、小于的情况、为空的情况。如果发现逻辑漏洞，它会用具体的数字举例说明为什么这里会出错。

你的记账应用里，用户输入金额时，AI没有做任何限制。结果有人输入了中文字"一百元"，有人输入了负数"-500"，有人输入了科学计数法"1e10"。数据库里存了一堆乱七八糟的数据，统计功能直接报废了。

AI写代码时，默认用户会好好输入。它不会主动想"如果有人乱输入怎么办"。但对真实用户来说，什么都可能发生。输入框里什么都可能填，按钮可能被连续点击十次，网络可能突然断开。 这就像你开了一家餐厅，门是开着的，但没有贴"衣冠不整谢绝入内"。结果有人光着脚进来、有人带宠物进来、有人大声喧哗。你没有设置规则，就只能接受一切。

AI会像一个安全员，站在用户的角度去想"如果我乱来会怎样"。它会模拟各种不靠谱的操作：输入框里填奇怪的东西、连续狂点按钮、在加载过程中关掉页面。然后告诉你哪些地方缺少防护。

你的课程表应用里，数据存在本地手机上。有一天手机存储空间满了，应用在保存课程数据时失败了，但AI没有写"保存失败"的处理逻辑。应用假装保存成功了，用户以为课程已经存好，关掉应用再打开，数据全丢了。

AI写代码时，默认一切操作都会成功。文件保存？成功。数据读取？成功。网络请求？成功。但真实世界不是这样的。文件可能写不进去，数据可能读不出来，网络可能连不上。AI不写错误处理，是因为你没让它写。 这就像你出门旅行，默认天气一定是晴天，不带伞。结果半路下大雨，你只能淋着。规划的时候没考虑"如果下雨怎么办"，遇到意外就只能干瞪眼。

AI会像一个防灾检查员，假设一切都会出问题。它会检查每个可能失败的操作，看看有没有"如果失败了怎么办"的代码。如果发现某个操作只有"成功路径"没有"失败路径"，就会标记出来，并补上对应的处理。

你的单词学习应用里有一个"全部单词"页面，列出了5000个单词。每次打开这个页面，AI的代码都会把5000条数据一次性加载到页面上，手机卡了五秒钟才显示出来。更糟糕的是，每次搜索一个单词，AI都会重新遍历全部5000条数据，而不是用索引。

AI写代码时，默认数据量很小。它用最简单的方式实现功能：全部加载、全部遍历。这在数据少的时候没问题，但数据一多就卡。AI不会主动想"如果数据变多了怎么办"，除非你提醒它。 这就像你开了一家小卖部，货少的时候随便放，找东西也不费劲。后来生意做大了，进货量翻了一百倍，你还是按老办法找货，在仓库里翻半天才能找到一瓶酱油。

AI会像一个交通规划师，分析数据流动的路径。它会问自己：这条路是不是太堵了？能不能分流？能不能抄近路？它会找出那些"数据量大了就会慢"的地方，然后提出优化方案，比如分页、缓存、索引。

你的博客应用里，用户可以发表评论。AI在显示评论时，直接把用户输入的内容拼到了页面上。有一天有人发了一条评论，内容是一段脚本代码，结果所有打开这个页面的人，浏览器都弹出了一个广告窗口。这就是典型的跨站脚本攻击。

AI写代码时，不会主动考虑安全问题。它默认用户输入的内容是"无害的文字"，直接显示出来就好。但实际上，用户输入的内容可能包含恶意代码。如果不对用户输入做过滤，别人就可以在你的网页上执行任意代码。 这就像你开了一个留言板，任何人可以在上面贴纸条。但你没有检查纸条内容，有人贴了一张"请到隔壁店买东西"的广告，所有来你店里的人都被误导了。

AI会像一个保安，检查所有"入口"是否安全。用户输入的内容要过滤，密码要加密存储，敏感操作要验证身份。它会找出那些"看起来能用但容易被攻击"的地方，告诉你风险在哪里，怎么堵上漏洞。

你的待办事项应用里，同样是"任务"这个概念，有的地方叫"task"，有的地方叫"item"，有的地方叫"todo"。同一个意思用了三个不同的名字。你让AI改一个功能时，它只改了叫"task"的地方，叫"item"和"todo"的没改，功能又出问题了。

AI在不同时间帮你写代码，给变量起名时没有统一的标准。第一次叫"task"，第二次叫"item"，第三次叫"todo"。AI不觉得这是问题，因为它每次只关注当前的任务。但对你来说，维护起来就头疼了。 这就像你公司里，同一个客户，销售部叫他"李总"，财务部叫他"李老板"，技术部叫他"客户A"。三个部门在讨论同一个人的时候，各说各的，完全对不上。

AI会像一个编辑，通读整个项目的"词汇表"。它会找出所有"一词多译"和"多词一义"的情况，然后建议统一命名。比如项目中所有表示"任务"的地方，统一叫"task"，不再混用"item"和"todo"。

你的记账应用里，添加一笔支出需要填五个字段，但"保存"按钮在页面最底部，需要往下滑才能看到。很多用户填完数据后，找不到保存按钮，以为应用坏了。还有一个问题：删除一条记录后，没有任何提示，用户不确定是不是真的删掉了。

AI关注的是"功能能不能用"，而不是"好不好用"。按钮在底部，功能上没问题，但用户找不到。删除了不提示，功能上也没问题，但用户心里不踏实。AI不会主动从用户的角度去想"这样用起来舒服吗"。 这就像你设计了一个门，门能打开，功能没问题。但你把门把手装在门的最下方，需要弯腰才能够到。门确实能开，但用起来很别扭。

AI会像一个产品体验师，亲自"使用"一遍你的应用。它会留意每个操作是否顺畅、每次点击是否有反馈、每条提示是否看得懂。它会从"第一次用这个应用的人"的角度来审视，找出那些让人困惑的地方。

你的单词学习应用，你自己用着一直没问题。但给朋友试用后，朋友说"背单词的时候手机来电话了，回来之后进度全丢了"。你自己测试的时候从来没接过电话，所以没发现这个问题。

你自己测试的时候，是按"理想流程"走的：打开应用、背单词、完成、退出。但你不会模拟"中途接电话""切换到微信回消息""手机没电自动关机"这些真实场景。而真实用户什么情况都会遇到。 这就像你设计了一把椅子，自己坐上去试了试，挺舒服的。但你没试过"胖子坐上去会不会塌""小孩爬上去会不会翻""老人坐久了腰会不会疼"。不同的用户，用法完全不同。

AI会像一个演员，进入角色去使用你的应用。它会模拟各种打断、中断、恢复的场景，检查数据是否完整、状态是否正确。它会发现那些"你自己永远发现不了"的问题，因为你自己用的时候太"规矩"了。

你的记账应用运行两个月了，记录了两千多条数据。有一天你想导出所有数据，点了导出按钮，应用卡死了。因为AI在写导出功能时，默认数据量很小，一次性把所有数据读入内存再导出。两千条数据直接撑爆了内存。

AI写代码时，测试用的是三五条数据。它不会想到两个月后会有两千条。它更不会想到，如果用户连续记录五年，可能会有几万条数据。极端情况在AI的"默认思维"里是不存在的。 这就像你造了一座桥，测试的时候只让一辆小车通过，没问题。但你没有测试"如果十辆大卡车同时上桥会怎样"。平时不会发生，但发生了就是灾难。

AI会像一个压力测试员，专门找"最坏的情况"。它会故意把数据量放大一百倍、操作速度加快十倍、输入内容拉到极限，然后观察应用的表现。这些测试能帮你提前发现那些"平时不会遇到但遇到了就完蛋"的问题。

你的博客项目做了三个月，期间加了很多功能：文章管理、评论系统、标签分类、搜索、数据统计。你每次加功能都是单独让AI做的，从来没整体检查过。最近你发现项目越来越慢，代码越来越乱，但不知道问题出在哪。

项目是一点一点长起来的，像一棵树，枝条越来越多。每次加功能时，只看了那根枝条，没看整棵树。时间长了，枝条互相缠绕，有些枯死了，有些挡住了阳光。你需要退后一步，看整棵树的状态。 这就像你装修房子，今天加个柜子，明天加个灯，后天加个架子。每次加的时候只看了那一面墙，没看整个房间。三个月后，房间塞得满满当当，走路都困难。

AI会像一个体检医生，从头到脚检查你的项目。它会拿着七项指标逐项评估，给出一个"健康分数"。不是笼统地说"还行"或"有点乱"，而是具体到每个维度：哪里健康、哪里亚健康、哪里需要治疗。

你让AI检查过好几次项目，每次它都把结果写在聊天里。你想着"回头整理"，但从来没整理过。过了一周，你完全忘了上次检查出了什么问题，哪些修了、哪些没修。问题清单散落在十几段聊天记录里。

AI在聊天里汇报结果，这是它的习惯。但聊天记录是"流水账"，不适合做记录和追踪。你需要一个结构化的文档，能清楚地看到：发现了什么问题、严重程度如何、修了没有、谁负责修。 这就像你去看病，医生口头告诉你"血压有点高，胆固醇也偏高，还有两项指标需要复查"。你出了诊室就忘了一半。你需要一张体检报告，每一项写得清清楚楚，回去还能慢慢看。

AI会像一个专业的审计师，把所有发现的问题整理成一份正式报告。报告有结构、有优先级、有责任人、有截止日期。你可以拿着这份报告，一条一条地去修，修完一条勾一条，不会遗漏。

代码写完了，功能都能跑了。可你看着满屏的文件，不知道哪些是临时的，哪些是真正有用的。想把项目整理干净，但不知道该从哪里下手。

开发过程中，AI 会生成很多中间文件。测试用的临时代码、试错留下的废弃文件、不同版本的备份。这些东西混在一起，时间一长，项目就变成了一团乱麻。

AI 会先扫描整个项目，标记出疑似临时文件、测试代码、重复内容。然后逐项列出，等你确认后再删除。整理完成后，给你一份清理报告，告诉你哪些东西被移除了，项目现在干净了多少。

项目文件东一个西一个，有的在根目录，有的在 src 里，有的在不知道哪来的文件夹里。找个文件要找半天，结构混乱得让人头疼。

项目是逐步长出来的，不是一次规划好的。每个新功能往里面加文件的时候，可能在意的只是"能跑就行"，没顾上目录结构。等反应过来，已经乱得没法看了。

AI 会先分析现有文件的依赖关系，画出一个清晰的模块图。然后提出新的目录方案，同时更新所有文件中的导入路径，保证引用不会断。最后运行项目验证，确认一切正常。

项目做完了，但如果过两个月你再看这段代码，可能连自己都看不懂了。更别说别人接手这个项目，对着代码一脸茫然。

开发的时候，脑子里装满了上下文。你知道这个函数为什么这样写，那个变量代表什么。但这些知识只存在于你的脑子里，没有写下来。时间一长，连你自己都忘了。

AI 会站在新人的视角，从项目入口开始，逐步解释整体架构。它不会逐行解释代码，而是告诉你"这个模块负责什么""数据从哪里流向哪里"。生成的文档简洁、有料、能真正帮到人。

你把项目发给朋友试用，对方问了一堆问题：怎么安装？怎么启动？点了这个按钮会怎样？你才发现，项目缺了一份给用户看的说明书。

你太熟悉自己的项目了，觉得"这么简单还需要说明吗"。但对第一次接触的人来说，每一个步骤都是未知的。他们不知道依赖怎么装，不知道配置怎么填，不知道第一步该做什么。

AI 会切换到"零基础用户"的视角，从下载、安装、配置到启动，每一步都写得清清楚楚。它会尽量避免"假设你知道"，把每一个隐藏的步骤都显式地写出来。生成的说明像一份傻瓜教程，跟着做就能跑通。

项目在你自己电脑上跑得好好的，放到服务器上就各种报错。环境不对、配置不对、端口冲突。你折腾了半天，发现全是部署的坑。

开发环境和生产环境是两回事。你本地的操作系统、依赖版本、网络配置，和服务器上可能完全不同。如果在写代码的时候没考虑部署，上线的时候就会吃大亏。

AI 会先读取项目的所有配置文件，搞清楚真实的依赖和环境要求。然后写出每一步的具体命令，而不是含糊的"安装依赖"。最后还会给出故障排查清单，遇到问题知道先查哪里。

项目做完了，但你总觉得少了点什么。想回顾一下这次开发的过程，总结一下经验教训，但不知道从何说起。

开发过程中，你一直在解决眼前的问题，没时间停下来思考。等做完了，很多细节已经忘了。哪些决定是对的，哪些走了弯路，都淹没在过程里了。

AI 会回顾整个开发过程，从第一次对话到最后一次修改，梳理出项目的演进脉络。它会告诉你哪些功能是一次就做对的，哪些反复修改了很多次，从中可以学到什么。总结不是泛泛而谈，而是有具体案例支撑的复盘。

项目改了很多次，加了很多功能，修了很多程序问题。但如果有人问你"这个版本和上个版本有什么区别"，你只能含糊地说"改了很多东西"。

每次修改都很小，你觉得不值得记录。但积少成多，几十次小修改加起来，版本之间已经面目全非了。没有记录，以后想回溯都找不到线索。

AI 会从代码版本记录和对话历史中提取所有变更，按时间整理成一份清晰的更新记录。每个条目都简洁明了，格式统一，方便以后查阅。不像技术文档那么重，但足以让你知道项目是怎么一步步走到今天的。

项目做完了，功能都实现了。但你总觉得还能做得更好，只是不知道从哪方面入手。加新功能？还是改进现有的？优先级怎么排？

做完一个项目后，你离它太近了，反而看不清全局。你只知道还有 100 个想法没做，但不知道哪些值得做、哪些做了会后悔。

AI 会基于当前项目的实际情况，而不是泛泛的行业趋势，给出量身定制的建议。它会告诉你哪些地方现在做最划算，哪些可以等等。每个建议都带着理由和工作量预估，让你能做出明智的决策。

项目跑得挺好，但你心里不踏实。总感觉有些地方不太稳，说不上来哪儿不对，可就是觉得以后可能会出问题。

开发时为了赶进度，有些地方可能写了"能用就行"的代码。有些逻辑可能没考虑全面，有些边界情况没处理。这些隐患现在没事，但一旦遇到特殊情况，就会暴露出来。

AI 会像安全审计员一样审视代码，重点关注那些"看起来正常但藏着隐患"的地方。比如没有处理空值的变量、没有限制的循环、没有超时机制的网络请求。它会告诉你：什么情况下会炸、炸了影响多大、怎么修。

项目做完了，你想休息一下。但你知道，过不了多久又会打开这个项目继续开发。到时候，你还能记得现在的上下文吗？还能快速上手吗？

人的记忆是有限的。现在你脑子里装了项目的所有细节，但一个月后，这些细节会模糊。到时候重新打开项目，要花大量时间重新熟悉，效率大打折扣。

AI 会生成一份"项目交接手册"，浓缩了所有关键信息。当前项目在什么状态、哪些功能还没做完、环境怎么搭、之前做了哪些重要决策。这份手册不是又长又臭的文档，而是精炼的"重新入场指南"，让你下次打开项目时，不用从头摸索。