第一部 · 零基础期（2025.1 – 2025.12）

这一年我做了一件事：什么都敢问。
但我没有做成任何东西。这本书要从这里讲起，因为"敢问"和"做成"之间，隔着一年。

第 1 章 · 那个凌晨四点，我到底在问什么

这一章要从一晚讲起。那一晚我没做成任何东西，也没赚到一分钱。

但它决定了后面所有的事。

那一晚我干的事，说白了就是对着一个对话框聊天，聊到天亮。我先把这一晚完整讲给你听，因为很多人用 AI 卡住的地方，那一晚就已经埋下了。

一条新闻，一次注册

2025 年 1 月的一个晚上，我在手机上刷到一条新闻，说有个叫 DeepSeek 的国产 AI 很厉害。

那时候我对"AI"这三个字的理解，跟很多人一样：听着厉害，离我很远。新闻说它厉害，我信，但我不觉得这跟我有关系。

那时候国外的 AI 工具我用不了——不是不想用，是打不开、也付不了费。所以看到"国产"，我就想试试。

打不开，就是网站进不去。付不了费，就是它要收钱，而我这边的付款方式用不上。这两件事跟聪不聪明没关系，跟你站在哪儿有关系。

我点进去，是因为那条新闻里有一句话打动了我：它是中国人做的，中国人能用。

我注册了账号，进去，然后问了第一句话。

注册就是填个手机号、设个密码，跟你随便开个账号一样。听着简单，但对我这种年纪的人是道坎——我会先怀疑它是不是骗人的。

然后我聊到了凌晨四点。

我得说清楚，那一晚没有任何神奇的事发生。没有"AI 帮我做出了什么"。就是聊天，一个人，一个框，来回打字。

如果你也刚注册完，坐在那儿不知道第一句该问什么，我的建议是：别问"你能干什么"。那个问题它答得出来，但对你没用。你要问的，是你自己手头那件真正让你头疼的事。

那天晚上我到底在聊什么

我聊的不是技术，是我的生意。

这一句我要强调，因为它是后面一切的前提。我没有问它"什么是人工智能"，也没问"AI 能干什么"。我从第一分钟起，问的就是我自己的事。

我当时想做一个东西，叫"四邻"——一个社区里邻居互相帮忙的小程序。谁家水管坏了、谁要找人接孩子、谁会修电脑，都在上面找。

小程序这个词，前面表里解释过：微信里不用下载就能用的那种小东西。你扫个码、点一下，它就在你手机里开了一个小窗口。

说白了，我想做一个平台。

平台这个词听着很大。说白了就是：我不干活，我在中间牵线，每一笔我从里面抽一点。

左边有人要，右边有人会，我站在中间收过路费。

这个想法当时在我脑子里非常清楚。清楚到我以为自己已经想好了。

那天晚上，我把这个想法从头到尾讲给 AI 听，让它帮我分析：这个事能不能成、该怎么定位、先做哪一块。

它一条一条回我。我说"不对，我们小区不是这样"，它就改一版。我再挑毛病，它再改。

这里有个细节，当时我没在意，现在觉得特别关键：我说"不对"，它从来不改我，它改方案。它不会说"你刚才那个判断可能有问题"，它默认我说的都是对的。

一个总顺着你的人，会让你觉得舒服。舒服到你不会去想：是我说得对，还是它不敢反驳我。

我推翻了自己七八次，它一句都没烦。

你跟真人聊，改到第三次口风就变了。对方会说"你到底想好了没有"，或者干脆不接话了。跟它聊，第八次改口，它还是照着你新的说法从头再来一遍。

那一晚真正的价值，不在它说了什么

现在回看，那天晚上它给的方案，一句都没用上。四邻后来也没做成（第 3 章我会讲为什么）。

一句都没用上，这话不夸张。方案里那些分类、那些流程、那些"先做这个再做那个"，我到今天一个都想不起来了。

但那一晚非常值钱，原因跟方案无关。

因为那是我这辈子第一次，可以无限次陪我把一件事想到底的对话对象。

注意这句话里的三样东西：无限次、陪、想到底。真人三样都给不了你。

你想想，一个四十多岁的老板，想把一个想法聊透，能找谁？

• 找合伙人：他会问"这能赚钱吗"，聊三句就变成算账
• 找员工：他会想"老板又要加活了"，嘴上说好，心里打鼓
• 找同行：他会想"你是不是要抄我"
• 找老婆：她会担心你把钱赔了

每一个真人，都带着自己的立场、情绪、利益来听你说话。

这四条不是我在编段子。每一段关系里，你都欠着对方一点什么，或者对方欠着你一点什么。有这个"欠"在，你就没法纯粹地聊一件事。

而 AI 不带。你说什么它接什么；你推翻自己它跟着推翻；你说三遍它陪你三遍；你说得不清楚，它还会追问。

它没有位置。它不吃饭，不领工资，不跟你抢生意，不跟你过日子。所以它没有立场。

对一个已经有身份、有面子、有位置的人来说，这件事的价值被严重低估了。

因为你越有身份，你能问的人越少。

这句话我越想越对。位置越高，身边敢跟你说真话的人越少。不是他们不真诚，是他们要考虑说完之后的后果。

我那年 41 岁，是公司的老板，是别人眼里的"专家"。我不可能跑去问同行"我这个想法行不行"，那等于告诉他我在干什么、我有多不确定。

AI 是唯一一个不会拿我的问题去衡量我的人。

你可以做个测试：把你手头最要紧的那个想法，找一个真人讲十分钟。看他第几分钟开始给你建议，第几分钟开始看手机。那种感觉，就是这一章说的东西。

我不是说真人没用。我是说，有些话你只能对一个不在乎的人讲。而在你身边，这样的人通常一个都没有。

但我犯了一个错，这个错持续了整整一年

那一晚很爽。第二天、第三天、第二十天，我一直在问。

从那一晚开始，我跟它的关系就定下来了：我负责问，它负责答。这个分工当时看着天经地义。

问题在于：我一直在问，一直在得到答案，一直没有动手。

两个"一直在"中间，就差一个动作：关掉对话框，去做。而这个动作，我整整一年没做。

翻我 2025 年整年的提问记录——两百多条——你会发现一个惊人的特点：

几乎每一条都是"帮我分析""帮我整理""帮我起草"，没有一条是"帮我做出来，然后把它跑起来"。

我得到了大量的方案、指南、框架、清单。

它们中的绝大多数，躺在对话记录里，没有变成任何东西。

"没有变成任何东西"这句我要解释一下。不是说我读完就忘了。我读得很认真，很多存下来了，有的还打印过。但它们没有变成任何一个别人能用上的东西。

这个毛病我给它起了个名字：用 AI 想事，不用 AI 做事。

而"想事"是很舒服的——它让你感觉自己很勤奋、很前沿、在进步。

它唯一的问题是：不产出任何东西。

这一章想让你记住的一句话

第一个月不要指望它帮你赚钱。先让它帮你把那些不好意思问人的问题，全问一遍——然后，逼自己动手。

后半句"然后逼自己动手"，才是重点。前半句任何人都做得到，后半句大多数人做不到。

如果你也这样，你该注意什么

• 如果你发现自己用了三个月 AI，提问记录几百条，但手上没有一个能跑的东西——你跟我 2025 年一样，卡在"想事"里。
• 判断标准很简单：你能不能让一个陌生人，在你的手机上用上你做的东西？ 不能，就是还没开始。
• 不要因为"我问得很深"就觉得自己在进步。 问得深，只说明你会问；做出来，才叫会做。

第 2 章 · 「我完全没有开发经验，完全不懂写代码」

这一章讲的是我真正开始的那一句话。它只有一行字，但那一行字我准备了二十年才说出口。

说出口之后发生的事，比那句话本身更值得看。

上一章说到，我聊了一整年，什么都没做出来

2025 年 2 月，我决定不再只是问。

这个决定没什么仪式感。就是某一天，我把它打出来了。

现在回看，那天我没做任何准备。没列提纲，没想好第一步干什么。我只是换了个问法。

我在 DeepSeek 的输入框里打了这么一句话，原话，一个字没改：

「我要做一个微信小程序，我完全没有开发经验，完全不懂写代码。」

这句话里我用了两个"完全"。不是为了强调，是为了把后路堵死。

我把话说满了，它就只能从这里开始。

这句话要是跟人说，对方大概会回一句："那你别做了。"

他这么说不是看不起我。他是在保护我，也是在保护他自己——万一我做砸了，他这句话就成了"我早说过"。

但对面不是人。对面只会问："你想做什么？"

它没有劝我，没有跟着感慨一句"那有点难"，也没有安慰我。它跳过了评价，直接问下一步。

当时我不知道，这个"跳过评价"有多重要。

我先解释一下，为什么这句话这么难说出口

你要理解，说这句话对一个 41 岁的人来说，有多别扭。

我的身份是：注册会计师、人大 EMBA、一家公司的老板、别人嘴里的"罗总"。我干了二十年财税和灵活用工，在这个领域里，问我的人很多，我很少问别人。

在我们这行，"不懂"这两个字传出去，是要掉价的。人家找你，是因为你懂。

客户买的其实就是"你比他懂"。你要是先说了不懂，他凭什么还找你。

这样一个人的字典里，"我完全不懂"这五个字，是最难说出口的。

难在哪？难在这句话不是对别人说的，是先对自己说的。你说出口的那一刻，你先得接受它。

因为我们这一代人被训练成：不懂也要装懂，至少不能在人前露怯。

我这一代人，从学校到单位，一路都是这么过来的。开会的时候领导问"都懂了吗"，没人敢说不懂。

而跟 AI 说这句话，我第一次不用付代价。

不用付代价，是很具体的意思：它不会记得，不会传出去，更不会过两天在饭桌上拿这件事说我。

这大概是我这二十年里，第一次可以毫无顾忌地说"我不会"。

这句话没有代价，所以它是真的。有代价的时候，人说的话自己都不全信。

说完之后，发生了什么

它没有嘲笑我，没有劝我放弃，也没有说"这个很难，你要不要考虑别的"。

它接着问："你想做什么？"

我就把想法贴上去了——项目名称：四邻；slogan：四邻，让生活轻松些；然后是定位、目标用户、想解决什么问题。

slogan 就是一句口号，一句话说清你是干嘛的。定位就是"这东西是给谁用的、解决他什么麻烦"。目标用户就是"我打算先把东西卖给谁"。

这几样东西，后来我知道它们是做产品的基本功。当时我不知道它们叫什么，我就是觉得，得先讲清楚。

基本功这个词，是我后来在别处学到的。当时我只知道一件事：说不清，就不敢往下走。

那是我第一次把一个脑子里的东西，写成一段别人（哪怕是个 AI）能读懂的文字。

写的过程比读的结果重要。你写出来的那一刻，你自己就知道哪里是虚的。

写到一半我就发现：我以为我想清楚了，其实没有。

• 我说"社区互助"，它问"互助什么"
• 我说"邻居帮忙"，它问"帮什么忙、怎么收费、谁来保证质量"
• 我说"做个平台"，它问"平台两边的人从哪来"

这三个问题，我一个都答不上来。

这三个问题其实问的是三层东西。

"互助什么"，问的是你到底卖的是什么。

"怎么收费、谁来保证质量"，问的是这门生意立不立得住。

"两边的人从哪来"，问的是最难的那一步——人从哪来。

那一刻我才明白：不是我不会写代码，是我根本还没想清楚要做什么。

这句话把我之前的想法整个推翻了一次。我一直以为我的问题是"我不懂技术"。原来技术根本不是那一关。

而"不会写代码"这件事，反而成了我的优势——因为它逼我把想法说清楚，说不清楚它就没法动手。

反过来想就明白了：如果我身边有个懂技术的合伙人，他大概会说"我明白了，你去忙你的"。他会用他自己的理解，补上我没讲清楚的那部分。

补上去的那部分是他的，不是我的。等做出来你才发现，做的是他想的那个东西。

这算是我在这个过程里捡到的第一个便宜。

承认零基础，是这件事真正的起点

后来我复盘，这一步之所以能迈出去，不是因为聪明，是因为我说了一句很难说出口的话：我不懂。

这句话不要钱，但它是最贵的门票。

很多我这个年纪的老板，卡就卡在这一步。他们不会说"我不懂"，他们说的是：

• "你先做个方案我看看"
• "这个很简单吧"
• "别人都已经做出来了，照抄一个"

这三句话，每一句都会让 AI 给你一份看起来很专业、实际上根本跑不起来的方案。

这三句话各有各的毛病。

"你先做个方案我看看"，是把决定权又交回去了。你会一直在看别人的方案。

"这个很简单吧"，是替它定了难度。它就按"简单"给你做。

"照抄一个"，是让它跳过思考。它会给你一个壳子，看着像，里面是空的。

为什么？因为你一旦假装懂，它就会配合你假装懂。它是顺着你说的，不是拦着你的。

它顺着你，不是因为善良。是因为它就是这么干活的：你说的每句话都是它唯一的线索。你说得含糊，它只能跟着含糊。

你说"这个很简单"，它就按"简单"给你做；你说"照抄一个"，它就给你一个壳子，里面空的。

它不会跳出来说"老板，你这个想法有问题"。它只会一路小跑，跟着你一起掉进坑里。

你回想一下公司里的事就明白了。你在会上拍板说"这个不难，一个月搞定"，底下人照着你说的"不难"去做，最后交上来一个不能用的东西。

问题不在他们。问题在你先说了一句"不难"。

但"承认零基础"不等于"零成本"

这里我要说一句后面会反复出现的话：

承认零基础，只解决了"敢不敢开始"，没解决"会不会翻车"。

我当时并不知道，真正贵的不是写代码——写代码 AI 帮你写。真正贵的是三件事：

1. 不知道该做什么（定位一直在改）
2. 不知道一件事该花多久（没有节奏感，永远不觉得该停）
3. 不知道什么时候会崩（没有备份，改坏了要重来）

这三件事，没有一件能靠 AI 替你解决。因为它能回答"怎么做"，回答不了"值不值得做"。

备份就是留一份原来的样子。改坏了能退回去，这是它唯一的作用。

没有节奏感，就是不知道一件事该干三天还是三个月。不知道，你就永远不会觉得该停。

第一件事，在三个月内把四邻做黄了（下一章）。

三个月。不是三年。

第二、第三件事，在半年后的一个晚上，把我打得很惨（第 6 章）。

这两笔账我先记在这儿，后面一笔一笔还。

那一个月，我还问了别的东西

翻 2025 年 2 月那一个月的提问记录，一共七条。除了四邻那几条，还有：

「大模型未来一定会取代搜索引擎，如何提前布局」
「黄帝内经里面讲到的养生的方法，帮我整理成日常可以操作的手册发给我」
「我在北京市东城区和平里街道甘水桥小区有一套 5 年前购买的、位于顶楼的房子……」

这三条放在一起，味道很特别。

第一条问的是大势，第二条问的是身体，第三条问的是家底。

行业大势、养生、房子。

这就是零基础的第一个月：你什么都敢问，因为你不在乎丢人。

不在乎丢人，是件很珍贵的事。而且它是有保质期的。

保质期过了会怎么样？你会开始挑问题问，只问那些显得你有水平的问题。

而"什么都敢问"这件事，在会用 AI 的人身上，是一种长期能力。大多数人到第三个月就不好意思问了——他们开始觉得自己"应该会了"。

一旦你觉得"我应该会了"，你就不会再问了。而不再问，是退化最快的方式。

我现在最怕的不是不会，是不问。不会还可以学，不问就彻底停了。

这一章想让你记住的一句话

零基础不是障碍，是起点。但你得先对自己承认这件事——一旦你假装懂，AI 就开始陪你演戏。

演戏这件事最麻烦的地方在于：演的时候两个人都是舒服的。

如果你也这样，你该注意什么

• 第一次跟 AI 说"我不懂"的时候，会有一种奇怪的不适。忍住它。 那句话是你后面所有进步的门票。
• 如果你发现自己经常说"这个我知道""这个简单"，而事情又总是做不成——问题很可能不在技术，在你没让它把话说透。
• 一个好用的自检：让它把你刚才说的想法复述一遍，然后问你："这段里有哪些地方我其实没讲清楚？" 它会指出来，而且往往指得很准。

第 3 章 · 四邻：第一个产品，第一次没做成

这一章是这本书里最不体面的一章。它讲一个我做了四个月、最后一分钱没赚到的东西。

我把它放在这么靠前的位置，是因为它比任何一个成功案例都有用。

成功的故事你听完只能鼓掌，摔过的坑你能记一辈子。

上一章说到，我承认了自己不懂，然后开始做四邻

四邻是什么？我再说一遍，因为这决定了后面所有事：

一个社区里邻居互相帮忙的小程序。 谁家水管坏了找人修、谁要找人接孩子、谁会修电脑愿意搭把手——都在上面找。

你可以把它理解成：把小区门口的公告栏搬到手机上，再让这个公告栏能付钱。

说白了，我想做一个平台：让邻居之间互相提供服务，我从中抽成。

抽成就是从每一笔里拿一点。邻居请人修水管、付了钱，我从里面分一份。听着不多，但平台生意就是这么算的——量大了才有钱。

这个模式我在纸上算过很多遍，每一遍都觉得成立。

2025 年 2 月，我给它起了名字，slogan 都想好了：四邻，让生活轻松些。

名字和 slogan 我改了不少次。这大概是整个项目里我最快活的一段，因为它不需要面对任何现实。

到 6 月，我还在改方案。

从 2 月到 6 月，四个月。四个月里我改了很多版方案，但没有一版能让别人打开用。

再往后，它没有上线。

没上线这句话很具体：没有人用过它。连试用都没有。

先说清楚：它"没做成"，但没有"死"

这两个词我原来混着用，后来发现必须分开——这一条对任何做项目的人都重要。

为什么混着用会出事？因为你一旦把它们当成一回事，你判断自己就会判断错。你会把所有没成的事，都记成"我不行"。

• 没做成：这一次没有跑到"能上线、有人用、有人付钱"
• 死：我把它忘了，再也不打开，再也不提

打个比方。没做成，是这次没跑到终点。死，是你连终点在哪儿都不看了。

这两个词我是后来才分清的。当时我只有一个模糊的感觉：这事没完。

四邻是前者，不是后者。

2025 年 6 月之后它停过；2026 年 5 月又在另一个工具里出现了一次；2026 年 9 月，我又重启了一次，改成多端、只做技能服务。

同一个名字，三次。

同一个名字被我用了三次，说明这几年我一直没真正放下这件事。

所以按我后来的判断标准——判断一个项目死没死，不看它当时做得多热闹，看你后来还动不动它——四邻没死。

这条标准我后来也用在别处。一个人嘴上说重视什么，你就看这周他把多少时间花在那上面。时间不会撒谎。

但我必须承认：21 个月过去了，它到今天还没赚到一分钱。

21 个月，是一个孩子从出生到会走路的长度。

这两句话都是真的，都得写下来。

只写"没死"不写"没赚钱"，那是自欺。只写"没赚钱"不写"没死"，那是我把自己判了死刑。

那三个月我具体在干什么

翻我的提问记录，四邻这条线是这样的：

下面这几条是从记录里原样摘出来的，连错字都留着。

你注意到第三行了吗？

三个月后，我把同一段项目定位，一个字没改，又贴了一遍。

不是大意。是真的没意识到。我当时以为我在"继续推进"。

这两行之间隔着三个月。三个月里我以为自己在往前走，其实只干了一件事：换了几种问法。

当时我没觉得这有什么。现在回头看，它是整件事的病根：

我在同一个问题上转圈，而不是在往前走。

转圈和往前走，从外面看是一样的：都在动，都花时间，都很累。区别只有一个——转圈的人最后还在原地。

AI 每次都给我一份新的、完整的、看起来很靠谱的方案。我每次都读，都觉得有道理，然后开始怀疑别的部分，然后再问一遍。

注意这个顺序：读、觉得有道理、怀疑。我从来没怀疑过"要不要开始做"，我只怀疑方案里的某一块。

方案的完善度在涨，项目的推进度是零。

完善度是你能感觉到的东西——你会觉得"这一版比上一版更像样"。推进度是另一个东西：有没有一个别人能打开的东西。

前者让你安心，后者才是进度。

这是我给所有"用 AI 做项目"的人的第一个警告：如果你反复让 AI 重做同一份方案，说明你的问题不在方案里。

你不是缺方案，你是不敢做决定。

不敢做决定的人，最常干的事就是"再完善一下"。因为完善没有风险，决定有。

它最后没成，三条原因

2026 年 11 月 1 日，我自己问自己：四邻到底为什么没做成？

这三条不是别人替我总结的，是我自己坐下来一条条想出来的。写清楚它们，是怕过几年我忘了自己是怎么摔的。

我给了三条，是原话：

1. 接支付账号遇到困难。
2. 运营太重，负担不起。
3. 筹备期思考不足，把项目想简单了；做起来发现市场需求太分散。

这三条，我要一条一条拆开讲。因为它们是这本书里最值钱的三条教训——后来每做一件新事，我都要拿它们对一遍。

对一遍的意思是：这三条只要中了一条，我就得停下来重新想。

如果只让我留一条，我留第三条。前两条是外面砌的墙，第三条是我自己挖的坑。

第一堵墙：支付——你想绕，绕不过

做任何涉及收钱的产品，第一道墙不是技术，是资质。

资质就是"你有没有资格干这件事"的那张纸。没有它，你技术再好，钱也进不来。

我当时以为"接个支付"是技术活：让 AI 写段代码，接上支付宝微信，就能收钱了。

我以为的过程是三步：写代码、接上、收钱。跟给电脑装个软件差不多。

它不是技术活，是合规活。

合规活不是难，是慢。它的时间不由你控制，你得等别人给你盖章。

你要接支付，背后绑的是一长串东西：营业执照的经营范围、行业许可、网站或 App 的备案、对公结算账户、平台的风控审核。每一样都是一道门，每一样都可能卡你几个月。

这几样我逐条说一下，因为它们真的太容易被忽略。

营业执照上的"经营范围"，决定了你能干什么。你写的范围里没有这一项，就不能干。

行业许可是另一回事：有些行业要先拿到证，才能开门干活。

备案就是到政府那儿登记，证明这个网站或者 App 有人负责。没备案，支付这一环就接不上。

对公结算账户，是公司名下的银行账户。钱不能进你个人卡，那样账就乱了，也过不了审核。

风控审核是支付平台自己那一关。它要看你的业务是不是真的、干不干净。

如果你手上正好有在做的东西，现在就拿这几样对一遍：经营范围里有没有这一项、备案下来没有、对公账户开没开。

少一样，钱就进不来。而且它不会提前告诉你，是你去接的时候才卡住。

我当时做的是"社区互助"，收钱的名义是什么？服务费？平台佣金？这两种在商户资质上要求完全不一样。

服务费是"我替你干了活，你付我钱"。平台佣金是"我撮合了你们俩，我从中间抽"。

前者你是干活的，后者你是管钱的。两套材料，两个口径。

我连"我该以什么名义收钱"都没想清楚。

这句话现在看是最要命的。名义定不下来，后面所有材料都准备不了。

后来我学了一句话，是这十几年财税工作里最实用的一句：

在中国做生意，先问"这笔钱我凭什么收"，再问"怎么收"。

这句话我干了十几年才咂摸出来。在此之前，我一直觉得它就是一句正确的废话。

顺序反了，你会卡死在半路。

卡死的意思是：你不是做不下去，你是做不下去了，还不知道为什么。

第二堵墙：运营太重——一个人扛不动"两边"

社区互助这件事，天生是双边市场：一边要有人发需求，一边要有人接需求。

双边市场这词听着学术，说白了就是：一个市场上有两种人，出钱的，和出力的。你要同时伺候两边。

判断方法很简单：你的客户和你的供应方，是不是两拨完全不同的人。是，就是双边。

双边市场有一个死穴：冷的启动不了。

冷启动就是"从零到有人"这一段。这一段最烧钱，因为中间有一段时间，平台上一个人都没有。

• 没有需求，服务的人不来（来了没活干）
• 没有服务的人，需求的人留不住（问了没人应）

两边都得有人，而两边的人互相等对方先来。

这就是先有鸡还是先有蛋。商业上这个问题有解，但每种解法都要钱：要么你补贴一边，要么你自己先装成一边。

补贴一边，就是你先掏出真金白银，让一边的人觉得来这儿有便宜占。这笔钱在你收到第一笔佣金之前，一直在往外流。

而冷启动是要花钱、花人、花时间的。我当时是一个人。

一个人不是"人手少一点"，是"没有第二双手"。三件事同时找上你，你只能做一件。

这里有一条判断，我后来反复用：

凡是需要"同时把两拨人拉进来"的生意，一个人做不了。不是能力问题，是物理问题——你只有一双手，两边同时拉，两边都拉不住。

这条判断后来帮我省了很多钱。因为它能在一分钟里，否掉一个看起来很美的想法。

这条判断帮我后来砍掉了一半的念头。

第三堵墙：想简单了——"做出来"和"卖得动"是两件事

这是三条里最疼的一条。

前两条是外面的墙，这一条是我自己的问题。

我在筹备期做的所有功课，都是在回答"这个东西怎么造出来"。

"造出来"是个有终点的问题。你可以说"造完了"。

没有一项是在回答"谁会用、为什么用、愿不愿意付钱"。

这三个问题没有终点。你能一直问下去，而且越问越不确定。所以人会本能地躲开它们。

等到真做出来，发现市场是散的：

• 有的人想要"帮忙接送孩子"
• 有的人想要"找人修水管"
• 有的人想要"有人陪老人聊天"

每个人的需求都不一样，你抓不到一个共同点。 广告打出去，来的都是"看看"，没有一个是"我要"。

这三种需求你可能觉得都能做。但你的钱只够做一种。

"看看"是最贵的一种人。你为他说了话、花了时间，他一分钱不掏，还占着你的心力。

需求分散，意味着获客成本高于客单价。

获客成本，就是你拉来一个客户要花多少钱。客单价，就是一个客户一次能给你多少钱。

这是 CPA 的老本行，我算得比谁都熟：一个客户要花多少钱才能拉到，跟这个客户能给你多少钱，比一下，账就出来了。

四邻这本账，从第一天起就是负的。只是我当时没算——因为我根本没把这件事当成一道算术题，我把它当成一个"想法"。

负的意思很直白：每拉来一个客户，我就亏一次。拉得越多，亏得越多。

这种生意不叫生意，叫放血。

这个算法我闭着眼都能算。可我在做四邻的时候，一次都没算过。

而想法是不用算账的。想法只需要好听。

第一个产品大概率做不成。但它教会我怎么跟 AI 协作

我要在这里说一句书里必须说的话：四邻没做成。

这句话我在文档里写了删、删了写，好几遍。因为写下来，就等于认了。

市面上讲 AI 的书，几乎只写成功。我不想这么写，因为这么写会害人——看完会觉得"照着做就能成"，然后撞上同一堵墙，还以为是自己不行。

只写成功还会给人一个错觉：他差的只是方法。其实他差的可能是时机，是口袋里的钱，是能不能撑到那一天。

四邻真正的收获，不是那个小程序，是我知道了怎么跟 AI 干活：

• 我知道了一次把话说清楚，比问十次"你再想想"有用
• 我知道了它给的方案看着都对，但"对"不重要，"能落地"才重要
• 我知道了我缺的不是技术，是判断"什么时候该停"

第一条说的是输入，第二条说的是标准，第三条说的是刹车。这三样东西，跟你会不会写代码都没关系。

这三条，后来变成了我整套方法的地基。

地基这个词不是夸张。后面所有做法，都是在这三条上长出来的。

尾声：同一个名字，第三次

2026 年 9 月 5 日，我又重启了四邻，这次改成多端（微信小程序 + 安卓/苹果 App + 网页），并且只做技能服务——不做双边撮合，只做"我提供技能，你付钱"。

"多端"这个词听着玄，其实就是同一个东西在几个地方都能打开：微信里能开，手机上下载个 App 能开，电脑上输个网址也能开。

看这三刀砍在哪：

• "社区互助" → "技能服务"：砍掉一边，不做撮合
• "两边拉人" → "自己卖手艺"：砍掉冷启动
• "造个平台" → "先赚第一笔钱"：砍掉宏大叙事

这三刀砍的其实是同一件事：把所有"需要别人先配合我"的部分，全砍掉。

砍比加难。加东西让你觉得在做，砍东西让你觉得在损失。

想法没变，路径变了三次。

这才是"想清楚"的真实过程——它不是一次性完成的，是被打回来三次之后才清楚的。

想法没变，是因为想法本来就不值钱。值钱的是路径。

如果你手上也有一个当年没做成的东西，我建议你翻出来看一眼。不是让你马上去做，是让你重新判一次：那次到底是我不行，还是时候不对。

★ 最重要的一句：当时做不下去，不一定是项目不行

写这本书的时候，我给自己下过一个判断，它推翻了很多"创业故事"的写法：

"以前做不下去，是那时候 AI 的使用能力没跟上。按现在的使用能力，这些项目都能做到上线运行——因为做到上线运行的成本已经很低了。"

这句话放在创业圈里会被骂。因为它听着像在给自己找台阶。

这句话的意思是：四邻 2025 年倒下，不是因为市场不要它，是因为 2025 年的我，做不出能上线的版本。

同样的想法，隔了 21 个月，用今天的人和今天的工具，成本完全不是一个量级。

所以"这个项目失败了"这个结论，很多时候下得太早——失败的可能不是你，是当时的条件。

我不是要安慰谁。我是想说一件很实际的事：你手里那个当年没做成的想法，现在可以重新掂量一下。

而条件是会变的。

在别的行业，条件要很久才变一次。在这一块，它变得很快。

这句话对我自己的用处是：我现在做决定，会先问一句——是我不行，还是时候不对。这两个答案，接下来的动作完全不一样。

这也是这本书跟别的复盘最大的不同：我不打算把每一次没做成都写成"我学到了什么"，因为有些没做成，纯粹是时候没到。

这一条很重要。因为"每次失败都必须学到点什么"这个说法，会把人逼疯。有些失败就是运气。

这一章想让你记住的一句话

"没做成"和"死"是两件事。没做成可能只是时候没到；死了，是你再也不打开它了。

如果你也这样，你该注意什么

• 如果你反复改同一份方案，停一下。 数一数：这个东西你改了几版？超过三版还没定，问题不在方案。
• 在写下你的项目定位之前，先回答一句：这笔钱我凭什么收？ 答不出来，先别做。
• 如果你的生意需要"两边的人同时来"，而你是一个人——现在就砍掉一边。
• 判断你的项目死没死，别看它当时多热闹，看你上个月动没动它。

第 4 章 · 这一年我什么都问 AI

上一章讲了一个失败的产品。这一章讲同一年里，我在另一条线上悄悄攒下的东西。

这条线当时看起来毫不起眼：它没有名字，没有计划，我甚至没把它当成一条线。

但它是这本书真正的拐点。

上一章说到，四邻在 6 月卡住了

四邻卡住以后，我没有立刻做下一个产品。

为什么不做下一个？因为新产品都要市场，而市场不在我手里。

处理公司的事不一样。它只要我自己点头，明天就能办。

我做的事是：把 AI 用到了我自己公司身上。

这句话写得平平淡淡。但你往下看会发现，它是这一整年里最要紧的事。

这件事发生得很自然，我甚至没意识到它在发生。翻记录才发现：2025 年 8 月，我的提问里第一次出现了自己公司的具体事务。

我是靠翻记录才发现的。人的记忆会骗人，记录不会。

先把这一年的提问摊开给你看

我把那一年的提问按月份摊开了。你自己看这条线是怎么拐的。

表格这种东西有个好处：它把"我感觉"变成"记录显示"。我感觉自己一直在进步，记录显示我不是。

表里有几个词，我顺带解释一下，免得你卡住。

融资融券，是借钱买股票、也借股票卖出。它放大收益，同时放大亏损。

稳定币，是跟真实货币挂钩的一种数字货币。

美林时钟，是一个看经济阶段的框架。它把经济分成几段，告诉你每一段该配什么资产。

增资，就是把公司的注册资本调大。要在工商走一遍程序，材料得齐。

纳税信用等级，是税务给企业打的信用档。高的好用，低的处处受限。

VSCode 是一个写代码的软件。对我来说，它更像一个记事本加一个指挥台。

你看这条曲线：从"炒股"到"养生"到"社区小程序"，再到 8 月突然拐进"我公司的社保开户"。

前半年的词你大概都熟：股票、视频、学区房、保险。它们有一个共同点——跟我公司没关系。

后半年的词全变了：结算中心、社保户、合伙协议、增资、纳税信用。全是公司里的真事。

这不是我计划好的。这是被逼的。

被逼的意思是：公司的麻烦不等你准备好。到时间它自己就来。

而且它不排队。它一次来三件，三件都说急。

8 月：我第一次把公司的事交给它

8 月那两条，写在纸上看平平无奇："人力结算中心园区项目解析"、"新公司社保户开通及增员指南"。

但你要知道这两件事对我意味着什么。

第一件：我做的生意叫灵活用工，其中一个核心环节是"园区落地"——就是在一些有税收优惠政策的产业园里，注册主体、享受政策。这件事政策文件又多又绕，每个地方还不一样，我原来是靠人脉和多年经验啃下来的。

"税收优惠"说白了就是：有些地方为了招商，愿意给你更轻的税负。代价是你要按它的规矩来——注册在它那儿，按它的口径走，按要求报数。

这件事难的地方不在难，在"多"。每个地方一套说法，文件一摞一摞。你没法一次学会，只能一个个啃。

"多"最磨人。它不是难倒你，它是慢慢把你磨没。

第二件：新公司开社保户，再给员工增员。这种事，我原来要么自己跑社保局，要么花钱请代理记账公司办，一次几百到上千。

社保户，就是公司在社保局名下开的那个户。开了户才能给员工"增员"——增员就是把这个人加进公司的社保名单里。

这两件事我原来都是自己扛的。自己扛的意思是：要么熬夜，要么花钱。

这两件事一点都不高级，但每个公司都要办。办一次两次没什么，一年办几十次，就是纯消耗。

那天我把它们都交给了 AI。

结果怎么样？说实话，不完美。

不完美的具体样子是：它给我的东西格式像模像样，里面有些对、有些要改。而它不会告诉你哪一句是猜的。

政策这种东西，AI 会给你一个很像样的框架，但细节经常不准，甚至会编——你必须自己去对一遍官方原文。

"编"的意思是：它会给你一个听起来完全合理的条款，措辞像真的，但你真去查，没有这一条。

更麻烦的是，它错的方式很像对的。你不去核对，根本看不出来。

但它省掉了我最贵的那一步：从零开始啃。

从零开始啃，是最打击人的一步。你一打开那堆文件，头就大了。头一大，你就去干别的了。

原来我要花两个小时读一堆看不懂的文件，才能问出一个像样的问题。现在我能直接问出那个问题。

我省的不是"答案"的钱，是"提问之前的准备"的钱。

准备的钱最贵。因为它花的是你一天里最清醒的那几个小时。

准备了半天什么都没得到，所以人最想省的就是这一段。省掉它的代价，是你会问错问题。

这一条，是我用 AI 到今天我们之间最重要的一条分工：

它负责把资料变成"能读懂的样子"，我负责判断对不对。它不给我最终答案，它给我一个可以开始问的基础。

这条分工我后来一直守着。它的形式变过很多次——从聊天框，变成工具，变成流水线——但这句分工没变过。

有了这条分工，我就不那么怕它骗我了。它骗我，我核对一遍就发现了。

9 月：整整一个月，全在处理公司的麻烦

9 月是我这一年提问最多的月份，12 条，几乎全是公司的事：

• 合伙协议怎么起草
• 劳务报酬和工资薪金能不能合并计税
• 注册资本从 99 万增资要走什么程序
• 纳税信用等级怎么从 M 提到 B

这四条看着专业，其实是四种不同性质的麻烦。

写文件是一种，算口径是一种，走程序是一种，求评级又是一种。

劳务报酬和工资薪金，是两种不同的收入。合并计税这件事，直接关系到每个人到手多少钱。

这四件事，件件都要花钱请人，件件都能出事。

花钱请人不是最大的问题。最大的问题是：请来的人给你的东西，你还是得自己判断。判断这件事，谁也替不了你。

你花钱买的是别人的判断，但最后担责任的还是你。

这是我第一次意识到：AI 对我的价值，可能不在"帮我做新东西"，在"帮我处理旧麻烦"。

这个认识很关键。它把 AI 从"玩具"变成了"工具"。玩具是拿来玩的，工具是拿来省钱的。

而那些旧麻烦，恰恰是我这个身份的人每天都在处理的。

一个老板的日常，本来就不是做新产品，是处理一个又一个旧麻烦。

12 月：第一次出现"三年千万"

12 月有一组提问，我到现在还记得：

「AI 赋能企业服务三年千万目标规划」
「VSCode 集成 DeepSeek 开发方案」
「AI CODING 技术与应用全解析」

"三年千万"这四个字，是这一年最重要的变化。

重要的不是"千万"这个数，是"三年"这两个字。它第一次有了时间。

因为在这之前，我问的所有问题，都是"这件事怎么办"。

而这一个问题，是"我要用它做成一个什么样的生意"。

从"怎么办"到"做成什么生意"，是两种完全不同的问法：

• 前者，AI 是你的顾问
• 后者，AI 是你的合伙人（或者说，是你打算雇的那批员工）

顾问和合伙人，差在一个东西上：顾问说错了，不用负责。

但这一年我有一个大毛病，到年底还在

说这个毛病之前，我先把成绩摆出来。

这一年我攒下了一样东西：我知道它能干什么、不能干什么。这个认识，花钱买不到。

我要在这里说一句难听的话：2025 年我并没有"用 AI 做事"，我是在"用 AI 想事"。

看这一年的提问就知道——几乎每一条都是"帮我分析""帮我整理""帮我起草"，没有一条是"帮我做出来，然后跑起来"。

我得到了大量的方案、指南、框架、清单。它们中的绝大多数，躺在对话记录里，没有变成任何东西。

这一年我最大的错觉，是"我知道了很多"。

知道和会用，中间隔着一双手。

"知道很多"是一个很舒服的状态。它让你在饭桌上能说上话，在公司里显得懂行。

而"知道"和"做成"之间的距离，我在 2026 年才真正量出来——量出来以后，我发现它比我想的长得多。

长到有一段时间，我怀疑这条路根本走不通。

现在回头看，那次怀疑是对的。因为我那时候，确实还不会。

这一章想让你记住的一句话

问了一年的"怎么办"，得到的是一年的答案。真正的分水岭，是你开始问"我要做成一个什么样的生意"。

如果你也这样，你该注意什么

• 翻一翻你自己的提问记录。 如果全是"帮我分析/整理/起草"，你就是在"想事"；如果开始出现"帮我做出来、跑一遍、验一下"，你才在"做事"。
• 先把 AI 用在你自己的麻烦上，别急着做新产品。 你自己的麻烦，你最懂；你最懂的领域，你才判断得出它说得对不对。
• AI 给的方案，细节必须对原文。 它会编，而且编得很像。

第二条你要是做到了，通常会有一个意外收获：你的员工会发现，老板突然开始问一些很具体的问题了。

第二部 · 换工具期（2026.1 – 2026.4）

这一部讲一件事：我发现工具选错，努力白费。
但也正是在这一部，我花了最多时间在"挑"，而不是在"做"。

第 5 章 · 一年之后，我开始挑工具

这一章很短。它讲的不是我做成了什么，是我怎么浪费了一个月。

我仍然把它留着，因为这个月太典型了。几乎每个刚开始用 AI 的人，都会在里面待一段。

我知道这一章会让你有点失望。但它比一个成功的故事有用。

上一章说到，2025 年底我第一次想到"用 AI 做成生意"

到了 2026 年 1 月，我的问题突然换了个频道。

前一天我还在问"这个项目怎么定位"，第二天开始问"哪个工具更好用"。

换频道这件事，当时我以为自己在升级。

换的时候人是察觉不到的。你只会觉得，今天问的问题更专业了。

那个月我几乎没做东西，全在比工具

翻 2026 年 1 月的 23 条提问，至少 5 条是在比较工具：

「Kimi Code 编程能力与对比分析」
「微信小程序开发工具选择对比」
「Cursor Pro 会员流量使用」
「Claude 功能及国内使用限制」

这几条我逐条说一下，你可能没听过这些名字。

Kimi Code，是 Kimi 家那个能替你写代码的东西。

Cursor 是那种能替你写代码的编辑器，Pro 是它要收钱的那一档。

Claude 是国外的一家 AI，好用，但在国内用起来有门槛。

微信小程序开发工具，是微信自己出的。在它上面能把小程序做出来，也能看到效果。

挑工具这件事有个特点：它不需要你懂，只需要你会看别人的评价。

到了 2 月，又加了一条：

「国内最强编程大模型」

这一个月，我一个功能都没做。我在挑工具。

"一个功能都没做"这句话，我自己写下来的时候都愣了一下。

一个月里，我做的所有事，都是"为了做"做准备。而"做"本身，一次都没开始。

这是个什么变化

2025 年我的问法是："哪个能用？"

2026 年 1 月起，我的问法变成："哪个更好用？"

"能用"说的是这东西存不存在。"更好用"说的是我要从几个能用的里面，挑一个出来。

这个变化说明了一件事：我手里有选择了。

而且，会问"哪个更好用"，说明我已经默认这件事能做了。

这两个问法之间，隔着一次认知跃迁——你从"能不能做"，进入了"怎么做得更好"。

"跃迁"这个词有点大。说白了就是：你的问题变了，说明你这个人变了。

更有意思的是：我开始意识到，工具本身会决定结果。

同样一件事，用一个顺手的东西和一个不顺手的东西，做出来是两个东西。这个道理卖工具的人天天讲，但只有你真的做过一遍，你才会信。

没做过的人听这句话，会觉得是卖工具的套路。真做过一次，你会觉得这是常识。

工具会决定你做出来的东西长什么样。同一个场景，你用手机拍和用相机拍，是两个结果。

但我那一个月犯了一个更大的错

我现在回看，能看出一个非常明显的毛病：

我花在"挑工具"上的时间，比花在"做东西"上的时间多。

• 1 月，23 条提问里，至少 5 条在比较工具
• 2 月，13 条里，又有 3 条在找"最强的"

我在用 2025 年"想事"的习惯，来过 2026 年"做事"的日子。

习惯不会因为跨了个年就消失。它换了个样子，接着影响你。

挑工具是在做判断题。做东西是在做填空题，而且没有标准答案。

挑工具是舒服的——它给你一种"我在做正确决定"的感觉，而且不承担任何失败的风险。

做正确决定，和做出东西，是两件事。前者只需要比较，后者需要动手。

但它不产出任何东西。

这是我给所有技术新手的一个提醒：你会在某一个阶段疯狂地比较工具，感觉自己在进步。那不是进步，那是拖延的另一种形状。

"拖延"这个词听着像懒。其实不是。拖延经常长这个样子：你一天到晚在忙，而且忙的都是正事。

这一条我后来自己反复犯。规律是：越不敢开始，越会找一个"准备阶段"待着。

这条路的代价，下个月就出现了

挑来挑去，我最后选了 Kimi Code，然后我花了一整个星期在装它（下一章）。

"装"这个词，你可能以为是点几下"下一步"。不是。

那时候我以为我在"解决一个安装问题"，后来才明白，我是在用最贵的方式补一门课。

最贵的方式，是指我一边装一边什么都不知道。所以每出一次错，我都得从头再来一遍。

从头再来一遍，是那个星期里我干得最多的事。

那门课叫"工程常识"。

工程常识不是技术知识。它是那种"别人都以为你该知道、但从来没人告诉过你"的东西。

这门课我一直没上过。它是被整个跳过去的那一段。

你挑工具挑得再准，只要你不懂它怎么工作，它就会在你最不设防的时候把你翻车。

最不设防的时候，就是你以为它已经好了的时候。

但也别把这段说得一无是处

如果不是那一个月"什么都比较一遍"，我不会知道：

• 国内外的工具有各自的限制（有些根本用不了，不是钱的问题）
• 同一个模型在不同工具里表现不一样（同一个脑子，穿不同衣服，干活效率差很多）
• 有的工具适合"一次做完"，有的适合"边看边改"

第一条说的是门槛，第二条说的是穿着，第三条说的是干活的节奏。

这三条听着像常识。但常识要自己撞过，才长在身上。

这些认知，后来救了我很多时间——比如我很早就知道"不要把宝押在一家身上"，所以 2026 年下半年我同时接了 DeepSeek、智谱、Kimi 三家（第 15 章）。

救时间的意思是：关键时候我知道该退一步，而不是死磕一个东西。

所以那一个月不算白费。它买回来的是一张地图，虽然我一格都没走。

这一章想让你记住的一句话

挑工具是舒服的，因为它不会让你丢脸。但它也不产出任何东西。给自己定个期限，到点就用最顺手的那个开始干。

如果你也这样，你该注意什么

• 给"挑工具"定一个死期限：比如三天。三天之后，选一个开始，不许再比。
• 判断标准别用参数，用"我能不能三天内做出一个小东西"。做不出来的，参数再好也没用。
• 别信"最强"这个词。 最强的工具，往往是最难上手的那个；而上不了手的最强，等于零。

参数就是那些一堆字母和一串数字的配置说明。它们看着客观，其实跟你无关——你只关心顺手不顺手。

第 6 章 · Kimi Code 装崩的那一周

这一章讲的是我刚开始用 AI 写代码的第一个星期。

我打算把它写得细一点。因为大部分人是在这个阶段放弃的，而且放弃的时候会以为是自己笨——我后来发现，不是笨，是没人告诉他这一周本来就这么难。

我当时的情况是这样：干了二十年财税和灵活用工，会看报表、会审合同、会跟税务局的人把一件事说清楚，唯独没写过一行代码。

所以挑工具的时候，我的标准特别简单：谁能让我不说技术词就把事办了，我就用谁。

上一章说到，我挑来挑去，选了 Kimi Code

Kimi Code 是那一轮里我最看好的。

它的用法大概是：你用中文跟它说"帮我把这个地方改一下"，它自己去找文件、自己去改、自己跑一遍，然后把结果告诉你。

对不懂代码的人来说，这听起来像雇了一个随叫随到的程序员。我当时真是这么想的——我负责说，它负责做。

这个想法后来被我推翻了。漏洞在哪儿？在"说"这个字上。

说本身就是一门手艺。 你说得含糊，它就做得含糊；你不知道它做完应该长什么样，你就没法判断它对不对。而这两件事，恰恰是我当时最缺的。

有整整一周，我什么功能都没做成。

这句话不是"进度慢一点"的意思。是那个星期结束的时候，产品跟我一周前看到的那个样子，几乎没有区别。

我全部的成果，是把一个软件装上。

那一周我在命令行里干的事，按顺序是这些（这是我从历史记录里原样抄下来的标题）：

Kimi CLI 安装脚本
kimicode 安装错误
Kimi CLI 登录失败
终端授权失败
Kimi Code 技能库
Kimicode 工具
Kimi 代码 24/7

从"装"到"装不上"到"登录不了"到"授权失败"到"再装"到"终于装上了"，最后开始想"能不能 24 小时跑"。

这就是一个不懂代码的人，在命令行里摸索的完整轨迹。每一条都是一个晚上。

先解释一下，"命令行"是什么

这个词我知道对很多读者是陌生的，所以得先停下来讲清楚。不然后面你没法体会我那一周到底在跟什么东西较劲。

很多读者可能没碰过。我用一句话说：

平时你用电脑是点鼠标，命令行是打字下命令。 黑底白字，没有按钮，没有图标，敲一句，它回一段。

你可以把它想成一个不开灯的仓库。你站在门口喊一句"把三号货架第二层那个箱子给我"，它就去搬；你要是喊错一个字，它不猜你的意思，也不问你是不是打错了，直接回你一句"没有这个东西"。

它不给提示，不给引导，报错了也只给你一行英文。

这一点我想多说一句，因为它是新手最容易低估的地方。

你平时用的软件，是有人替你想过你会怎么错的：按钮会变灰，输入框会标红，关窗口的时候会弹一句"是否保存"。这些设计存在的意义，就是有人在替你兜底。

命令行没有这个。它默认你什么都懂，所以它什么都不解释。

那一个星期，我面对的就是这个东西。

真正卡住我的，不是安装

一周之后我坐下来复盘。

我本来以为要总结的是"哪一步装错了""下次该注意什么"。但我先问了自己一个问题，答案就变了。

我问的是：这一周里，最让你难受的是哪一刻？

不是装失败的那一刻。装失败至少目标明确——它不让你过，你就想办法过，这是个有解的问题。

最难受的是那些"它说它做完了，我不知道该不该信"的时刻。那种时刻没有解，因为你连该往哪个方向使劲都不知道。

后来我问自己：那一周最卡的是什么？

我的回答是：

"最卡的是没办法顺畅沟通。我完全没有开发经验和完全没学过开发的任何技术，所以完全不知道开发的节奏、规划、步骤等等所有的信息。经常做好了没有备份，就让 Kimi Code 直接修改，结果改崩了不能恢复，就得重做。"

这段话拆开，是三个完全不同的问题。很多人以为自己卡在第一个，其实是卡在第三个。

我把这句话放在这里，是因为它是我这一年多最值钱的一次自我诊断。

一个人卡住的时候，最容易的归因是"我不懂技术"。这个归因听起来很诚实，其实是个死胡同——因为它不指向任何一个具体动作。你知道了自己不懂技术，然后呢？没有然后。

拆成三个具体的问题，才有下一步。

问题一：语言不通

下面这句里它让我干的事，我先解释一下。"npm run build"你不用记，你只要知道：这是它让我在命令行里敲的一串东西，敲完屏幕上会滚出一堆字。

AI 说："我改好了，你跑一下 npm run build。"

我不知道 npm 是什么，不知道 build 完了应该看到什么，不知道"正常的输出"长什么样。

这就是语言不通的真正含义。不是我不认识那几个英文字母，是我脑子里没有"正常"这个概念。

一个会计看一张资产负债表，扫一眼就知道哪一行不对劲；一个医生看片子，一眼就知道哪里不对。这种"一眼"，是见过成百上千次正常的样子换来的。

我当时一次正常的样子都没见过。

于是我只能做一件事：看它说成没成。

它说成了，我就当成成了。

这是我和它之间最大的裂缝——我们的"成功"不是同一个意思。

它的"成功"，是"我执行完这条命令没有报错"。我的"成功"，是"这个功能真的能用了"。

这两个东西，在很多情况下根本不是一回事。

这个裂缝，在后面第 9 章会要我的命。

问题二：没有节奏感

第二个问题是节奏。这个词听起来虚，其实特别具体——它决定你什么时候该等，什么时候该喊停。

写一个功能，应该花多久？

专业的人心里有把尺子：这个改动大概两小时，那个大概两天，这个要一周，那个得拆开做。

我没有这把尺子。

没有尺子的后果，不是"慢"，是"没法判断"。

你没法判断它是在正常推进，还是已经绕进死胡同了。这两种情况从外面看是一模一样的——都在跑，都在输出，都没报错。

于是我不知道：

• 它跑了三个小时还没出来，是正常还是在打转
• 它说"还剩一点"，是真的快好了，还是根本没找对方向
• 该什么时候停下来问一句，什么时候该让它自己干

没有节奏感，你就只能被它牵着走。它说快好了，你就再等；它说改好了，你就再让它改下一处。

注意"牵着走"这个词。表面上你在指挥它，实际上节奏是它定的，你只是配合。

一个人在没有依据的情况下，是说不出"停，你走错方向了"的。

一个月下来，你做了很多"改动"，项目没往前走。

这句话是我那段时间最准确的写照。改动很多，日志很长，看起来很忙，但把一个月前和一个月后的东西摆在一起看，它长的还是那个样子。

问题三：没有备份习惯（这条最要命）

第三个问题最不起眼，但它是唯一一个会直接让你损失东西的。

"经常做好了没有备份，就让 Kimi Code 直接修改，结果改崩了不能恢复，就得重做。"

这一条是我付了最贵的学费学到的。

先把"备份"这个词说清楚。它在这儿不是"把文件复制一份存到U盘"。

它指的是：你能退回到改动之前的那个状态，而且是完整地退回去。

当时的逻辑是这样：已经做完的东西，还存一份，多麻烦。直接改吧。

这个逻辑在生活里是对的。你把桌上一个杯子挪个位置，不需要先拍照。

问题在于，AI 改代码不是挪一个杯子。它是同时在好几个文件里各改几行，而且它改的时候，你看不见。

结果：它一改，改崩了。改崩了以后，它自己也不知道自己改了哪几行——因为改动是散在七八个文件里的。

"它自己也不知道"这半句，是整件事最要命的地方。

如果它知道改了什么，你还能让它改回来。它不知道，你就只能自己一样一样去猜哪儿坏了——而你不懂代码，你连猜都不会猜。

于是只能重做。重做意味着：那个晚上白干。

白干一个晚上，听起来还能接受。但账不是这么算的。

不是白干一个晚上，是你这一晚试出来的经验也一起没了。因为你是边改边试出来的，改崩之后，那些"原来这样不行"的结论跟着文件一起丢了。

下一次你还会踩同一个坑。

后来我才知道，专业的做法叫"版本管理"，它的核心只有一句话：

你可以随时退回上一个能用的状态。

这句话我第一次看的时候，觉得它就是一句正确的废话。

后来我才明白，它其实在回答一个特别实际的问题：你敢不敢动手。

不敢动手的人，会一直在原地打转，因为他输不起；敢动手的人，才可能往前走。

而"敢"这个字，不是性格，是退路给的。

这句话救命的程度，比我后来买的所有工具加起来都高。

所以我把"先备份再改"变成了机器强迫我做的事

这一节讲的是从教训到机制的那一步，这一步很关键。

因为大部分人从教训里只拿到一句话："以后小心点。"而"小心点"是用不上的——你忙起来就忘了，你累的时候就懒得想了。

我不想靠记性。我想让这件事变成"我不做就干不下去"。

这一条教训，没有停在这一章。它后来变成了我这套系统的地基：

这就是"工程常识"。

这个词我想解释清楚，因为它是全书的一个关键词。

所谓工程常识，不是多高深的知识。它是一堆吃过亏的人约定俗成"必须这么做"的动作。比如改之前先存一份，比如写完先自己跑一遍，比如上线前先小范围试。

这些东西没有一条需要天赋。但每一条都是用别人的事故换来的。你不学，就得自己再摔一次。

一个不写代码的人，跟一个写代码的人，差的不是谁更懂语法——差的是那几十条"必须这样做，不然一定出事"的习惯。

这些习惯，AI 不会主动教你。它只会顺着你往前跑，跑到坑里，跟你一起掉下去。你不问，它就永远不说。

还有一个我后来才想明白的细节

那一周我很痛苦，但那一周之后，我整个人变了。

因为我第一次尝到了"我不懂，但我知道该怎么问"的滋味。

这句话说的是：我发现了"不懂"和"不会问"是两件事。不懂是事实，改不掉；不会问是方法，可以学。

装到第三天，我已经学会了一件事：报错的时候，不要只说"报错了"，要把整段报错原样贴给它，并且加上一句"我看不懂这段，请逐行解释"。

这个动作，让我的效率翻了一倍。

为什么这么有效？因为它把"翻译"这件事从我这挪到了它那。我原来要先自己看懂报错，才能问出问题——可我要是看得懂，我就不需要问了，这是个死结。

整段贴过去、让它逐行解释，等于我承认"我看不懂"，然后把这个活儿交给唯一看得懂的一方。

因为大部分时间，我卡的不是"怎么解决"，是"我连问题是什么都不知道"。

这句话如果你只记一句，就记这句。

这句话也解释了为什么那么多人用 AI 用不出效果：他们一直在问"这个怎么办"，而他们真正缺的是"我现在到底卡在哪儿"。

这一章想让你记住的一句话

本章出处（可核对）

"会用 AI"和"会用 AI 写代码"之间，隔着的不是工具，是工程常识。而工程常识里最便宜、最救命的一条，是改之前先存一份。

如果你也这样，你该注意什么

• 报错时把原文整段贴给它，加一句"逐行解释"。 这一步能省掉你一半的时间。
• 动手之前先问一句："如果我改坏了，怎么退回去？" 答不上来，先别改。
• 给它定节奏：一次只做一件事，做完就验；不要一次交代五件事。
• 别指望它主动教你。 它不会说"老板，你上次没备份"。你不问，它就一直往前跑。

素材出处

• Kimi Code 相关 11 条会话原样：资产\32_能力盘点\AI使用史_Kimi时间线_20261101.md 第 20–34 行
• 2026-01「Kimi Code 编程能力与对比分析」：资产\32_能力盘点\AI使用史_DeepSeek时间线_20261101.md 第 83 行
• 卡点原话：文哥 2026-11-01 口述
• 后来落地的机制：CLAUDE.md §3.2（自动交接）、§4.4（机器闸）

第 7 章 · 从 Mac 换到 Windows

这一章看起来讲的是换电脑，其实讲的是另一件事：一个人怎么把"经验"从一个地方搬到另一个地方。

这一年多里，我做过好几次"重来"。换系统是其中一次。我想把这次重来讲透，因为大部分人对"重来"的第一反应是害怕，而我后来发现，害怕的理由和真实的风险，根本不是一回事。

上一章说到，我花了一周才把一个软件装上

那一周的体验太糟，糟到我做了一个决定：把整个工作环境重新整理一遍，做成"换个电脑也能一键装回来"的样子。

这就是接下来的故事。

先把这句话里的"工作环境"解释一下。它不是指办公桌，指的是我电脑上那一整套东西：装了什么软件、每个软件怎么设置的、AI 该去哪里读我的资料、每次开工要先检查什么。

这些东西平时是看不见的，藏在系统的各个角落里。它们不出问题时你根本不会想起它们，一出问题你就彻底干不了活。

我原本准备了一场"抢救"

换电脑这件事，我以为会是一场灾难。

因为我脑子里全是这种问题：写的东西会不会没了？那些配置、那些记忆、那些费了半天劲装上的工具，是不是要全部重来？

这种担心的底层，其实是一句话：我这一年攒下来的东西，会不会一夜归零。

所以在换之前，我干了一件事：把我所有的能力、记忆、工具，全打包。

这四样东西，我一样一样说明白。

"一键装机包"，说白了就是一张清单：把我需要的软件和设置全写成文字，新电脑上照着跑一遍。它省的不是时间，是"想不起来漏了什么"这件事。

"能力清单"更关键一点。它是给 AI 看的，不是给人看的。新电脑上的 AI 刚打开时什么都不知道，你得先告诉它"这个人会什么、习惯怎么干活、哪些坑踩过"，它才不会从头问起。

"记忆目录"是我这几个月所有的记录：做过什么、错在哪、怎么改的。

"开场检查清单"是一张逐项打勾的表。它的用处是防止那种"我以为我记住了"的遗漏。

这套东西，本质上是在解决一个很大的问题：换一台电脑，怎么把"经验"带过去——而不是只把文件带过去。

因为文件是死的。真正值钱的是：我知道遇到某个错该怎么办。

这句话我是后来才真正理解的。当时我只是模模糊糊觉得"多准备点总没坏处"。

但实际发生的事，跟我预想的完全不一样

换完以后我回头一看：

"切换电脑时没丢什么，反而因为要重装，学了很多新东西，装了很多新工具。"

什么都没丢。

而我以为会丢的那些东西，其实早就存在云上、存在账号里、存在我自己脑子里。

先说"存在云上"。我平时用的很多工具，账号一登，里面的东西就回来了。我担心了半天，其实人家根本没打算让我丢。

再说"存在账号里"。我很多"能力"其实不是装在电脑上的，是绑在某个服务上的。换台机器，只要还登同一个号，能力还在。

最后一句最反常识：存在我自己脑子里。 我真正会的东西，是我知道遇到某类问题该往哪儿找，这个不会因为换电脑而消失。

真正发生的，是另外一件事：

因为要重装，我必须把每一件工具重新走一遍——而这恰恰是最好的复习。

原来装的时候，我是照着教程抄的，抄完就忘了为什么这么装。

重装的时候，我知道自己要它干什么，所以每个步骤我都问了一遍"这一步到底在干嘛"。

这两句话的差别，我用一个例子说清楚。

原来装的时候，教程让我干什么我就干什么。干完能用了，我高兴，然后关掉。我学到的是"照做"。

重装的时候，我知道自己要用它干什么。同样是那一步，我会多问一句：为什么要加这个？加在哪儿？加错了会怎样？我学到的是"为什么"。

前者学到的是动作，后者学到的是原理。原理能迁移，动作不能。

"被迫重来"这四个字，是这一年里我收获最大的四件事之一。

顺带说一个反例

也正是因为"重装"这件事，我才发现自己之前有多糊涂：

换完电脑很久以后，我在一个配置文件目录里翻出来 21 个 Mac 时期的旧路径，全是那种一长串看不懂的目录名。

先解释一下"路径"是什么。它就是电脑里一个文件的位置，像"三楼左转第二个柜子第三格"这样的地址。换了系统之后，柜子的位置变了，老地址就全是指向空气的。

它们躺在那儿，从来没被清理过，也从没起过作用。

这说明什么？说明我当时那些"精心打包"的东西，有一半我自己都没再用过。

这半句话我盯着看了很久。因为"精心打包"这四个字，当时是带着自豪感的。我以为我准备得特别周全。

结果有一半是死重量。

打包本身是有价值的，但价值不在"包"上，在"你为了打包，被迫把东西理了一遍"这件事上。

这句话我建议你抄下来。

因为人是很容易把"我准备了"当成"我准备好了"的。你花很久做了一个清单，做完那一刻的踏实感，会让你误以为这件事已经解决了。可清单本身不解决问题，你在做清单过程中想明白的东西才解决。

这一章真正的结论

我原来以为换电脑的难点是"别丢东西"。

真正的难点是"别丢掉思路"。

而思路不会因为换电脑丢，它会因为你不干活而丢。

这句话我想解释一下，因为它容易被读成鸡汤。

不是的。它是很具体的：你手上有一件事，做到一半，停了半个月。半个月后你回来，文件全在，一个都没丢。但你做不动了。

不是因为忘了怎么操作，是因为你忘了当时为什么这么设计。你当时想到的那个理由，那个权衡，那个"这里先这样，以后再说"的决定——全没了。

文件还在，思路没了。这才是真正的丢失。

这一章想让你记住的一句话

本章出处（可核对）

重装一次，胜过复习十次。因为你必须搞清楚每一步为什么这么做，否则你装不完。

如果你也这样，你该注意什么

• 如果你正在犹豫要不要把环境推倒重来——如果它逼着你把每一步重新想一遍，那就换。这比省事值钱。
• 别把"备份"当成任务，把它当成一次复习。 你整理的时候会发现自己有多少东西是没用的。
• 换环境之前，先写一份"我每天必用哪几样东西"的清单。 那份清单，才是你真正的工作方式。

素材出处

• 文哥对本节的直接口述（2026-11-01）
• 打包四件套：资产\07_Kimi时代存档\CAPABILITIES.md、资产\08_Kimi记忆存档\、一键装机包、SESSION_START_CHECKLIST.md
• 21 个 macOS 残留路径：.cursor\projects\ 目录实测

第 8 章 · 我开始问"怎么审"，不再问"怎么做"

这一章讲一个特别不起眼的变化：我提问的方式变了。

它没有对应的产品，没有对应的功能，也没有任何可以截图给你看的东西。但我认为它是这一年半里最重要的一次转变——因为从这一章开始，我才算真的"用上"了 AI，而不是"用过" AI。

上一章说到，我换了电脑，也顺带把自己理了一遍

到了 2026 年 4 月，我的提问方式出现了一个我自己都没察觉的变化。

我不再问"怎么做"，我开始问"我怎么知道你做对了"。

我先说明一下"提问方式"为什么值得单独写一章。

因为大部分人以为，用 AI 的效果取决于工具好不好。其实同一件事，你问法不一样，结果差得很远。问"怎么做"，你拿到的是一个答案；问"我怎么知道你做得对"，你拿到的是一套判断标准。

答案只能用一次，标准能用一辈子。

2026 年 4 月，一个月里我问了 38 个问题

那是我提问最多的一个月。里面有几条，我到现在都觉得是转折点：

「非技术背景 AI 开发审计框架」
「Cursor Agent 与 KimiCode 异同对比」
「听写助理产品架构评估」（问了两次）

第一条最关键。

"非技术背景 AI 开发审计框架"——这句话里没有一个字是"教我怎么写代码"。

它问的是：我一个不懂技术的人，怎么去审一个 AI 写出来的东西。

注意"审计"这两个字。 那是我干了二十年的老本行。

我在用我的专业，去解决一个技术问题。

这句话我要展开讲，因为它是这一章的核心。

我当时其实没想那么深。我只是发现：我完全看不懂它写的东西，但我不能就这么信它。那我该怎么办？

我唯一会的手段，就是我这二十年干的活——审计。

审计是什么？审计不是"重新做一遍账"，审计是用一套独立的办法，去验证别人做的账对不对。你不必会做账，但你必须知道从哪儿查、查什么、什么算异常。

这个思路一旦套上去，整件事就通了。我不需要会写代码，我需要会查代码。

这个问法，暴露了我身份的变化

把这一年多我的问法排一排：

这三句话，是一个人对 AI 的三种关系。

而第三层，是绝大多数人过不去的一层。

因为前两层都很舒服：问、等、拿到答案、觉得学到了。

舒服在哪儿？舒服在"责任不在我"。第一层，答案给错了是它的事；第二层，工具选错了也是它的事。我只要张嘴，然后点头。

第三层不舒服，因为它要求你承认一句话："我不懂，但我必须能判断你懂不懂。"

这句话听着矛盾，其实是所有管理工作的本质：

老板不需要会做下属的活，但必须能判断下属做得对不对。

这句话我认了很多年。有意思的是，我一直没把它往 AI 身上套——大概是因为 AI 不像人，它不会累、不会偷懒、不会跟你顶嘴，所以你很自然地就把它当成"工具"，工具是不需要验收的。

这个想法错得离谱。AI 不出错的方式跟人不一样，但它出错的时候比人更麻烦——因为它错得特别自信。

为什么这一层特别难跨

难在两点。

第一，你得先知道"错的样子"长什么样。

一个不懂财务的人，看不出报表哪里不对；一个不懂代码的人，看不出代码哪里会崩。

而 AI 做的错，往往长得很正常（第 9、10 章讲的就是这个）。

"长得很正常"这五个字，是我吃过亏才写下来的。

一个坏掉的东西，通常会有坏掉的样子：报错、卡住、白屏、乱码。这些你能看出来。

但 AI 出的错不是这样的。它给你的东西格式完整、逻辑通顺、语气笃定，你从头看到尾，挑不出一个字的问题——问题在它漏掉的部分。

而漏掉的东西，你是看不见的。你没法盯着"没有的东西"看。

第二，你得有办法让它自己证明自己。

你要问的不是"这样对吗"——它会说"对"，它永远是这么说的。

你要问的是"你怎么证明它对"，然后要求它交出一条你能自己跑一遍的验证。

这两句话的差别，我用一个生活里的场景说明。

你问一个装修师傅"这面墙刷好了吗"，他一定说好了。你没法反驳，因为你不懂。

但你要是换一种问法："你刷完以后，我用一张白纸贴上去，撕下来纸上有没有灰？"——他立刻知道该怎么做，你也立刻有了一个自己能执行的检查。

信任是态度，验收是动作。这两件事，差的是一整套办法。

这就是后来我那一整套"验收命令""产出契约""机器闸"的起点（第 11、12、17 章）。

这一年我真正的收获

不是学会了写代码——我到现在也不会。

我学会的是：怎么验收一个我看不懂的东西。

这件事的价值，比"会写代码"大得多。因为：

• 会写代码，你一天只能写一份
• 会验收，你能同时管十个在写的人

而 AI 恰恰是"十个在写的人"。

你不需要比它们会写，你需要比它们更会验收。

这个道理放到别的行业也一样。

你开一家店，你不需要比店长会管店，但你要能看出这个月的账为什么不对。

你做一批货，你不需要自己去车间，但你要能看出这批货的次品率是不是偏高。

"看不懂细节"从来不是问题，"没有验收办法"才是问题。

这一章想让你记住的一句话

本章出处（可核对）

你不需要会做它的活，你必须能判断它做得对不对。前者可以外包，后者不行。

如果你也这样，你该注意什么

• 看看你自己的提问记录：有没有一条是关于"怎么检查"的？如果没有，你还在前两层。
• "审计"这个思路，可以搬到你自己的行业里。 你是做财务的，就用财务的方法审它；你是做工程的，就用工程验收的方法审它。你的专业不是障碍，是你唯一的武器。
• 不要问"对不对"，问"怎么证明"。 前者它只会说对。

素材出处

• 2026-04 全部 38 条提问：资产\32_能力盘点\AI使用史_DeepSeek时间线_20261101.md 第 91–92 行
• 验收体系：本书第 11、12、17 章；CLAUDE.md §6.3 第 13 条

第三部 · 多产品期（2026.2 – 2026.7）

这一年半里，我同时开着二十来个项目。
这一部要回答一个我躲了很久的问题：它们死了吗？

我先把这一部要干的事说明白。

前面两部讲的是"我怎么学会用这个工具"。这一部讲的是"学会了以后，我拿它干了什么"。而答案不是一件漂亮的作品，是一地鸡毛——我同时开了太多头。

我得把这一地鸡毛摆出来给你看，因为只有看见总数，你才会明白问题出在哪儿。

先把这二十个项目摆出来

这一节看起来像一张流水账。但它其实是这一部的地基。

因为大部分讲 AI 的书，展示的都是"我做成了什么"。而我要展示的是"我同时在拉扯多少个东西"。后者才更接近一个真实老板的处境——你手边永远不止一件事。

从 2026 年 2 月开始，我的记录里出现了一种新情况：同时在推进的项目，越来越多。

翻那半年的记录，能数出这么一串：

这张表你扫一眼就行，不用记住每个项目是干什么的。

但你注意一个东西：同一个月份里，出现了好几个完全不相干的项目。

二月份那一格，一边是在评估一个超市的人力外包业务要不要收，一边是在做池州那个园区的布局。这两件事之间没有任何关系，唯一的共同点是"看起来都值得做"。

表里有几个词我解释一下，不然后面不好读。

"量化交易"，就是用程序按固定规则自动买卖股票，不靠人盯盘。好处是纪律，坏处是你得先把规则想得足够清楚。

"SaaS"，简单说就是"别人按月付费用你的软件"。我当时做的方向，是给餐饮公司算人力和工资的。

"园区"，在灵活用工这行，指的是那些有税收政策的地方政府园区。企业把业务落到那儿，税负能低一些，但前提是你得真把公司和业务放进去。

"掼蛋教练"是我当时琢磨的一个副业方向，后来评估完就否掉了。

"GEO 优化"，你可以理解成"让 AI 回答问题时能提到你"。传统做法叫搜索引擎优化，那是对着搜索框做的；GEO 是对着 AI 做的。

外加：量化交易、微信小程序、公众号、闲鱼卖货、跨境电商、GEO 优化、邮件获客、企业微信自动化……

注意这个"外加"。

上面那张表是有记录的项目，这一句里的东西，很多连表都没进——因为它们散在各个零碎的晚上，没形成一条完整的线，所以当时也没觉得算"项目"。

一个人手上同时有"上过表的二十个"和"连表都没上的另一批"，这个状态本身，就是问题。

先说一句自我批评

这一节我想写得难听一点。因为这是我第一次真正承认自己方向错了。

一个人同时开二十个项目，说明的不是勤奋，是没想清楚。

这句话不好听，但我必须写下来。

因为"同时做很多事"在我们的文化里是被表扬的——叫有闯劲，叫抓住机会，叫不放过风口。

但它有一个很硬的代价。而这个代价不会当天出现，它会延后几个月，一起找你要。

这是我当时最真实的状态：每件事都"值得做"，于是每件事都做一点，每件事都停在半路。

"值得做"这三个字是陷阱。

因为从单个项目看，它确实值得——市场在，需求在，我会的东西也用得上。问题从来不在单个，在总数。

一天只有那么多小时。你把它切成二十份，每份就只够开头，不够收尾。

而"停在半路"这件事，是有成本的——不是钱的成本，是你自己都记不清做到哪了的成本。

到后来，我经常要花半天时间回忆"那个东西上次做到哪了"。

这半天的成本，比它看起来大得多。因为它不是一次性的，是每次开工都要付一次。

更麻烦的是它还会滚雪球：你越久不碰，忘得越多，回忆花的时间越长，于是你越不想碰。

这就是多线程对一个 ADHD 的人的真实伤害：不是做得慢，是每次都要重新进入。

ADHD 这个词我解释一下。它的核心不是"注意力不集中"，恰恰相反，是注意力很难从一件事切走，也很难从别的事切回来。

普通人被打断，抬个头就能接上。我不行。我需要重新把整件事在脑子里搭一遍，搭起来要很久，而只要再被打断一次，就白搭。

所以"多线程"这三个字，对我不是效率问题，是每次切换都要交一次入场费。

我一天能连续专注的时间，本来就只有三四个小时。这四小时里，我要花一小时回忆上次做到哪，剩下三小时才真的在干。

你换算一下就知道这有多要命：等于我每天有四分之一的产能，是用来"回到昨天"的。

而且这个比例还在涨。项目越多，"回到昨天"要翻的东西越多。

★ 但"死没死"这件事，我后来改了判断

这一节是这一部最重要的地方。因为它推翻了我自己前面写下的东西。

书架上所有讲创业的书，都会告诉你"大部分项目会死"。

我原来也这么写。写到一半，我停下来重新问了自己一遍，答案是：不。

我为什么停下来？

因为我发现那句话我自己都不信。如果这二十个项目真的都死了，那我这两年到底在干什么——一个接一个地失败？

可我手上明明有东西在跑、在收钱、在被人用。这两件事对不上，说明问题出在"死"这个定义上。

"20 个项目里都没有死掉。以前做不下去，是那时候 AI 的使用能力没跟上。按现在的使用能力，这些项目都能做到上线运行——因为做到上线运行的成本已经很低了。"

这句话我要拆开讲，因为它跟大多数创业故事是反着来的：

第一，"做不下去"和"死"不是一回事。

做不下去，是当时条件不够；死，是你再也不打开它。

这个区别我用一个场景说清楚。

一个项目你三个月没动，可能有两种情况：一种是你已经不想做了，看到它心里就烦；另一种是你还想做，只是排不上队。

前一种叫死，后一种叫停。

它们在硬盘上长得一模一样，在你心里完全不一样。

第二，条件是会变的——而且变得很快。

2025 年做不出来的东西，2026 年可能只是几天的事。我这一年多最大的变量，不是我的能力涨了，是工具的能力涨了。

这句话我要说重一点，因为它是这本书的底层前提。

如果瓶颈在我自己——我不够聪明、学得不够快——那这些项目确实该死，因为我不会突然变聪明。

但如果瓶颈在工具，那工具一变，这些项目就全都重新活了。

我这两年经历的，恰好是后面这种情况。

所以我从来不删项目。删掉等于认定它永远做不成，而我没有资格下这个判断。

第三，真正卡住我的，不是项目，是精力。

"唯一的限制是我的时间精力没办法管理好运营 20 个项目的 AI 工具，精力不够用。"

请注意这句话的分量。

它说明：当工具足够强的时候，瓶颈会从"做不出来"转移到"管不过来"。

这个转移，很多人没意识到。

大家还在拼命想办法"做得更快"，可快已经不解决问题了。真正的问题是：同一时间只能有一个人在管。

而"管不过来"这件事，恰恰是这本书第五部要解决的（第 16 章后台任务、第 17 章无人值守、第 18 章自动换班）。

算一笔账：这两年我花了多少钱

这一节我要算两笔账。一笔在银行流水里，一笔不在。先算看得见的那笔。

一个月两百多块钱。

这个数你可能觉得不值一提，也就一顿饭。

但我还是把它写出来，因为大部分老板问我的第一个问题就是"这个烧钱吗"。答案是：不烧。

真正贵的东西，从来不是这个。

用这点钱，我换回来的是什么？我自己是这样估的：

"没有赔过钱，反而有很多有形的和无形的收益。比如做了很多协议，省了律师费；做了餐饮 SaaS，省了上百万开发费和几个月的开发时间。"

先解释一下"人月"这个词，后面要用。

它是软件行业的计价单位，意思是一个人干一个月的工作量。说一个系统要四十到七十人月，意思就是正规做法得派一个不小的团队干上好几个月。

按市面上的价钱，这个规模的东西，开发和实施的费用是一个非常可观的数字。

这也是为什么中小企业基本不会自己造系统——要么买现成的，要么用表格硬扛。

这两笔账放在一起看，才是我这两年最真实的样子：

• 花出去：5,830 元
• 省下来：一套餐饮用工系统按行业基准要 40–70 人月（第 20 章），再加上这些年写的协议、合同、方案的律师费和咨询费

所以这本书不打算写"我烧了多少钱"这种悲情故事。因为账不是这么算的。

还有一笔账，不在银行流水里

上面那些能被算成钱。但这两年真正让我意外的，是另一件事：

"很多人对我的印象变好了、更尊重我了。这种无形的收获也很多——因为到了 40 岁还能从头学、深入学、成为 AI 的顶尖使用水平，跟上了风口和商机，让别人觉得我比他们原来认知的还要厉害。"

这句话我要原样写下来，因为它不光彩，但它真。

先把"不光彩"这三个字解释一下。

我说的不光彩，不是说我做了坏事。是说承认"我在乎别人怎么看我"，这话从一个四十多岁、干了二十年专业的人嘴里说出来，显得有点虚荣。

但我还是写。因为你要是不承认这一点，你就看不清一个人为什么会同时开二十个项目。

我的处境很特别：我是注册会计师、人大 EMBA、干了二十年财税和灵活用工的人。在原来的赛道上，我的位置已经定了——大家知道我能干什么，也知道我不能干什么。

"位置已经定了"这句话，你如果到了我这个年纪，会立刻懂。

它不难听，甚至挺体面。但它意味着：别人已经不再期待你出现什么新的可能了。

而"我不懂技术"这四个字，过去一直是我身上那个短板。

这两年，这个短板被补上了一点（不是补成了长板，是补成了"能用"）。

于是别人看我的眼神变了。

这里我要说一句不好听的话：这种尊重，是会让人上瘾的。

而且它有风险——

当所有人都觉得你很牛的时候，你自己就更难说出"这个我不懂"。

这个风险很具体。它不会让你当场做错什么，它会让你在下一次遇到不懂的东西时，选择猜，而不是问。

而"说不出我不懂"，恰恰是这本书第 2 章讲的第一个坑：你一旦假装懂，AI 就开始陪你演戏。

所以我给自己留了一句提醒：

别人高估你的时候，是你最容易骗自己的时候。

这笔账最实在的一笔：它变成了谈判筹码

上面说的"尊重"，如果只是面子，那不值钱。

但它变成了钱。

"甚至我的商业合作伙伴，也因此愿意让渡更多的利益，来寻求长久绑定跟我的合作。"

这句话我用大白话翻译一下：

在谈合作的时候，对方原来只把我当成一个"懂财税的人"。现在他发现，这个人还能自己把系统做出来。

对一个合作方来说，这意味着什么？

意味着他不需要再额外去找一个技术方、不用再担心两拨人对接不上、不用再多分一份利给第三家。

这三件事，每一件都是他的成本。技术方要找、要谈、要磨合；两拨人对接，中间一定会掉东西；多一家分利，他手里的就少一块。

现在这三笔成本，一个人替他省了。

所以他把多出来的那部分，愿意让给我。

这是我这两年收到的最实在的一笔回报——它不在银行流水里，但它比银行流水值钱。

而且它说明了一件更重要的事：

AI 给你的最大回报，可能不是你省了多少时间，是它改变了别人对你的定价。

别人给你定价，看的是"你能干成什么"。你能干成的事变多了，你的价码自然就变了——这跟你会不会写代码没有半点关系。

这句话我想留给所有四五十岁的读者。

你这个年纪学新工具，最大的障碍不是学不会，是"学了有什么用"——你在原来的位置上，多会一样东西也换不来钱。

但真正会变的不是你的技能表，是别人对你这个人的想象。想象一变，谈事的方式就变了。

但我也不打算把它写成"一本万利"

因为上面那笔账里，没有算我自己的时间。

我这两年在这些事上投的时间，如果按我作为 CPA 和咨询顾问的时薪折算，是一笔很大的数。

所以准确的表述是：钱花得极少，时间花得极多。

这两句话要连在一起说，缺一句就会误导人。

只说前半句，你会以为这事很便宜，谁都能干；只说后半句，你会以为这事不划算，不该干。

合起来才是实情：它把"花钱买"变成了"花时间换"。

而时间和钱，对不同的人价值完全不一样。一个手上没有预算的年轻人，这笔交易很划算；一个时间比钱贵得多的人，这笔交易就未必。

你得先想清楚自己属于哪一种。

而这本书后面所有的方法，本质上都是在解决同一件事——怎么让我花的时间变少。

这一部想让你记住的一句话

本章出处（可核对）

项目不会因为"没做成"而死，只会因为你"再也不打开"而死。而真正会杀死这一切的，从来不是钱，是你的精力。

如果你也这样，你该注意什么

• 数一数你手上同时在做几件"没做完"的事。 超过三件，先砍，别再加。
• 判断项目死活别看投入，看"上个月动没动它"。 投入是你的沉没成本，不是它的生命力。
• 如果你的瓶颈是"管不过来"，那你要解决的问题不是"做更多"，是"怎么少花精力"。 这是第五部整部的主题。

素材出处

• 项目清单：资产\08_Kimi记忆存档\memory_index.md（2026-02-22 起，21+ 个项目）
• 文哥判断（20 个项目没死 / 精力不够 / 无形收益 / 合作伙伴让渡利益）：2026-11-01 直接口述
• 成本：资产\32_能力盘点\AI使用成本_真实账单_20261101.md
• "省了上百万开发费"：文哥 2026-11-01 口述；量级参照第 20 章（同类系统行业基准 40–70 人月）

第四部 · 建方法（2026.4 – 2026.8）

前三部讲的都是"我在做什么"。从这一部开始，讲"我怎么知道它做对了"。
这一部是全书的骨头，也是最难看的部分——因为每一条，都是我摔出来的。

第 9 章 · 三种"假绿"

这一章和下一章，是我这本书里最不想写、又最必须写的两章。

因为它们讲的不是"我做出了什么"，是"我以为我做成了，其实没有"。这种事没人愿意公开讲，讲出来显得自己很蠢。

但我还是讲。因为这两章里的坑，只要你用 AI 干活，早晚会踩到；而踩到的时候，代价往往不在你身上，在你客户身上。

上一部说到，我同时开着二十个项目

问题就出在这儿。

我一个人管不了二十个项目，所以我把大量的活交给了"自动任务"——让程序每天自己跑：抓数据、发通知、做报表、检查系统。

先把"自动任务"这个词说清楚。

它不是一个要你点开用的软件，而是一个"到点自己启动"的小东西。你不用点任何按钮，时间一到它自己跑一遍，跑完就退出。

这种东西的好处是：它不需要你在场。坏处也是同一个：它不需要你在场，所以它出问题的时候，你也不在场。

我靠什么知道它们干没干活？

靠一个自检程序。它一切正常的时候，会亮绿灯。

再说"自检程序"。它的作用有点像小区的门禁记录——它不负责抓小偷，它只负责记录"这个门今天开过几次"。

我每天早上打开一个页面，看见一片绿，就放心去干别的了。

有一天我盯着一片绿灯，忽然想问自己一个问题：

这绿灯说的，是"它跑了"，还是"它做成了"？

这个问题问出来的一瞬间，我其实已经知道答案了。

这两个差得非常远

我给你打个比方。

堵车的时候，车速表还是能跳到 60——只是轮子在原地打转。

车速表测的不是"你到了没有"，是"轮子转得多快"。这两件事在路况好的时候是一回事，在堵车的时候完全是两回事。

而绝大多数自动任务，仪表盘上装的都是"轮子转速表"，不是"里程表"。

我的绿灯也是：它只告诉我"任务启动了、跑完了、没报错"，从来不告诉我"它有没有真的抓到东西、有没有真的发出去、有没有真的算对"。

后来我翻了过去的记录，找到了三个例子。

这三个例子的共同点是：它们都不是"坏过一阵又好了"，而是"从装上的那天起，就一次都没成过"。

这句话是整章最扎人的地方。

"坏过一阵又好了"，说明它至少成功过，你知道成功长什么样。

"一次都没成过"，意味着你从来没见过它正常工作的样子——所以你根本不知道自己在看什么。

而系统一直报绿。

第一个：政策监控，跑了几个月，一条都没抓到

我在服务器上挂了一个任务，每天早上自动去几个政府网站看有没有新政策，有就整理好推给我。

先把"服务器"解释一下。它就是你放在机房里、一直开着的那台电脑。你自己的电脑会关机，它不会。

所以凡是"每天必须准时干"的活，都得放在它上面，不然你关机的那个早上就漏了。

它的工作方式是：去网站上把今天的内容抓回来，跟昨天比，多出来的就是新政。

"抓回来"这个词，你可以理解成"派一个小机器人去那个网页上，把文字抄下来"。它抄的不是给人看的页面，是页面背后的那堆代码。

有一天我发现，它已经很久没给我推过东西了。

我先去看日志——日志是新鲜的，每天都写，写着"检查完成"。

"日志"是什么？就是程序自己写的日记。它每天干完活，往一个文件里添一行"我今天干了什么、顺不顺利"。

我的监控只看了一件事：这本日记今天有没有新的一页。

有。所以我判定它活着。

再去看它抓回来的内容——是空的。

原因是：那些网站改版了。原来的抓取路径失效，程序抓不到东西，但它没报错——因为代码里有一个"抓不到就用备用方式"的分支，备用方式也抓不到，于是就返回了一个空结果。

这里要解释一下"备用方式"是什么。

你让一个人去三楼拿文件，他不熟，你顺手加一句"三楼要是没有，就去四楼看看"。这个"要是没有就去四楼"就是备用分支。

问题在于：如果三楼没有、四楼也没有，他会回来说什么？

正常应该是"都没有"。但这个程序的设计是：返回一个"空的文件夹"，然后继续往下走。

然后程序认为："今天没有新政策。"

写上"检查完成"，日志照常新鲜。

一个任务，从改版那天起就没再干过活。而它每天准时上班、准时打卡、准时在日志上写"一切正常"。

它瞒了我几个月。

这几个月里，我一直以为有人在替我看政策。

这就是这件事最阴的地方：它不只是没干活，它还替我把"没人看"这件事藏了起来。

如果它挂了，我至少知道自己少了一双眼睛，我会补上。

它没挂，它在上班，它在打卡。我只是没拿到东西——而我以为那是"这几个月没什么新政"。

第二个：密钥泄露告警，从装上的第二天起，每天都失败

这是更荒唐的一个。

我设了一个告警：如果有人把密码、密钥这类东西不小心写进了代码，就立刻通知我。

先说这件事为什么重要。

代码是要给别人看的，也是要存在别人服务器上的。你如果把自己系统的密码写在了代码里，等于把家门钥匙粘在门上——谁看见谁就能进。

"密钥"就是这种钥匙，它比密码还厉害，很多时候不需要账号就能直接用。

所以这类告警，是安全防线上最前面的那一道。

装好以后，它每天都运行。日志上也每天都有记录。

直到有一天我认真看了一眼日志内容：

/usr/bin/env: python3: No such file or directory

它一次都没成功过。

这句话翻成大白话是："找不到用来运行这个文件的那个程序。"

原因是文件的第一行——那行告诉机器"用哪个程序来跑这个文件"的说明——末尾多了一个看不见的换行符。

Windows 和 Linux 的换行符不是一个东西。这一个看不见的字符，让整个文件从第一行就没法执行。

换行符就是这么个东西：它在屏幕上完全看不见，但它确实占了位置，而那个位置是不该有的。整份文件的第一句话就读不通，后面的更不用谈。

它失败了九次。日志里九次都是同一句报错。

没有人看内容，大家只看"文件在不在、有没有变大"。

请注意这句话里"大家"两个字。

其实没有"大家"，只有我。我写"大家"，是因为这是所有团队的通病——只要监控有输出，就没人去读输出。

而这件事最可怕的地方在于：它是一道安全告警。

一个失效的安全告警，比没有安全告警更危险。

因为你没有它的时候，你知道自己没防护，你会小心；你装了它以后，你以为有人在替你看着，你就不小心了。

第三个：开机自启，脚本名字根本不存在

第三个没那么戏剧性，但同样致命：我设了一个程序开机自动跑，配置写得完完整整。

先说"开机自启"是什么。就是你电脑一开机，它自己就启动，不用你去点。这类东西通常是"后台常驻"的服务，比如消息转发、数据同步。

实际情况是：那个脚本文件的名字，从一开始就写错了。它指向一个不存在的文件。

但它配的是开机自启。开机自启没人看着，没人看着的地方，错误就不会有人喊。

开机 → 找不到文件 → 失败 → 下次开机 → 再失败。

同样是"配好了，看着在跑，一次没成过"。

这三个是同一个病

我后来在记录里写了这么一句话：

"任务看着配好了，其实一次都没成过。"

三个案例，三种完全不同的技术原因，病根是同一个：

我在用"它有没有在动"来判断"它有没有做成"。

这两个问题，在简单的活里是同一个；在所有真实的活里，它们完全是两回事。

我把这句话再说透一点。

"它在动"是一个过程指标：程序起来了没有，日志有没有新行，任务列表里有没有它。

"它做成了"是一个结果指标：东西拿到了没有，拿到了多少，对不对。

过程指标有一个巨大的优点：它几乎永远是好的。 因为程序起不来是很少见的，跑起来之后悄悄不干活才是常态。

所以你盯过程指标，你看到的永远是一片绿。而这片绿，什么都不能证明。

我后来改了什么（这一段是全书的药方）

我改的不是那三个程序。我改的是检查方式。

三个程序，三个不同的毛病，一般人会想着"把这三个毛病修了"。

但修完这三个，还会有第四个、第五个，因为产生毛病的机制没变——那个机制就是"我用过程指标判断结果"。

所以真正要改的是判断方式本身。

• 原来的检查是：这件事今天跑了没有？（看日志新不新鲜）
• 现在的检查是：这件事今天有没有产出？产出是不是空的？产出最老能有多旧？

这三个问题，我写进了一份清单，每条任务都要登记（下一章详细讲）：

这张表我一行一行解释一下，因为每一行都是我踩出来的。

"产出物在哪"，问的是：这件事干完之后，世界上多了什么东西？ 必须具体到一个文件、一张表、一条记录。答不出具体位置，说明这个任务本来就没有产出，那它就不该存在。

"最老能多旧"，问的是：这个东西多久没更新，就说明出事了？ 没有这条，一个三天前的文件和一个五分钟前的文件，在你眼里是一样的。

"什么算空"，问的是：拿到什么，等于没拿到？ 这一条最难，因为它要求你提前想清楚"失败的形状"。比如抓新闻，抓到零条就是空；比如导报表，文件小于某个大小就是空；比如发通知，内容是一句固定的兜底话术，也是空。

"什么时段该有"，问的是：这个产出应该什么时候出现？ 一个早上的任务，如果半夜有产出，那多半是昨天补跑的，不算今天完成。

这份清单现在有 79 条，覆盖我服务器上所有的定时任务。任何新加的任务，不登记就直接判定为失败，并且推消息到我手机上。

"不登记就算失败"这条，是整个机制的关键。

如果规则是"登记了才检查"，那我忘登记就没人管；如果规则是"不登记就算失败"，那我忘登记反而会挨一顿报警。

规则要顺着人的懒惰设计，不能逆着它设计。

为什么不靠"我记得去查"

因为我记不住。

我 41 岁，手上有十几条线在跑，还要管公司自己的业务。指望我记得每天抽查十几个任务的产出，这件事本身就不成立。

所以我不写"要注意检查产出"，我写的是"一个不登记就报警的机制"。

制度和自觉的区别是：制度不需要你记得。

这句话我想留给所有当老板的读者。

你在公司里一定说过类似的话："大家以后注意一下。"这句话说了等于没说。不是员工不听话，是人在忙的时候，只会做"不做就出事"的事。

所以你要改的不是人的态度，是让不做这件事真的会出事。

这一章想让你记住的一句话

本章出处（可核对）

"没报错"不等于"做成了"。要看你拿到的东西，不要看它有没有在动。

如果你也这样，你该注意什么

• 打开你任何一个"自动在跑"的东西，看它的产出。 不是看日志，是看它交出来的东西。
• 问三个问题：它每天该交出什么？什么算空？多旧算过期？三个都答不出来，说明你从来没真正检查过它。
• 如果你的自动化在给你发"一切正常"，先怀疑那份"正常"。

素材出处

• 三个案例与病根原话：CLAUDE.md §3.2「新建定时任务必须登记产出契约」
• 政策监控抓空、瞒了几个月：WORKLOG.md 第 214001 行
• 密钥告警 CRLF shebang、"从部署次日起每天必失败、从没成功过一次"：WORKLOG.md 第 214081–214097 行
• "今天第三个'从来没生效过'的案例"：WORKLOG.md 第 216929 行
• 79 条契约实测：CLAUDE.md §3.2（2026-10-19 19:42，FAIL=0 WARN=0 OK=62，未登记 0）

第 10 章 · 多记了一笔 1.6 万的账

这一章我要写得很慢。

因为它是这本书里唯一一个，我事后想起来会后背发凉的事。上一章讲的是"它没干活"，那只是浪费时间。这一章讲的是"它干错了，还说干成了"，那是要赔钱的。

上一章说的是"它没干活，却说干了"

这一章更吓人：它干了，干错了，还说成功了。

这两件事的差别，我用一句话说：前者你损失的是时间，后者你损失的是钱和信任，而且是在你完全不知情的时候。

先讲这件事为什么吓人

2026 年 11 月 1 日，我拿真实的银行回单去测我新做的一个小工具。

回单是什么？ 就是银行给的那张凭证，上面写着谁给谁转了多少钱。我做灵活用工，天天要处理几十上百张——人工一张一张敲进表格，一天就没了。

这句话里的"一天就没了"，不是说夸张。是字面意思：一个人坐在那儿，对着屏幕，把金额、日期、账号一个一个敲进去，敲一天。

而且这件事有个特点：它必须对，而且它没有"差不多"。

你把一个数字敲错一位，账就错了。账错了，后面所有的报表、申报、对账全跟着错。

所以我想做个东西：把回单（PDF 或照片）读一遍，把里面的金额、日期、账号、流水号自动抄出来，变成一张表。

这件事做好了，价值很大。

价值大在哪儿？不在省了那一天人力。在于当它稳定以后，我可以把这件事完全交出去，不用再盯。

这就是自动化的真正意义：不是让一件事变快，是让一件事不再需要我看着。

而这也正是它危险的地方——你不再看着的东西，出错了你也不会知道。

出事的是一张"代发明细"

我拿了四张真实文件进去测。其中一张是"代发明细对账单"。

"代发明细"是什么？ 就是我们帮一家公司给两百个工人发工资，银行回给我们的那张纸——一张纸，上面列着 4 个人分别该发多少钱。

合计：68,422.52 元。

工具读完了，告诉我：

成功。

我打开结果一看，只有一行：16,603.66 元。

4 笔被读成了 1 笔。另外三笔，凭空消失。

而且它没有报错，没有警告，状态是"成功"。

我先停一下，说清楚这件事为什么比"读不出来"严重得多。

如果它读不出来，它会报错，我会去看，我会发现这张纸有问题，我会换一种方式处理。整个过程是有声的。

但它没报错。它给了我一个数字，一个格式完全正确的数字，然后说"成功"。

如果我当时没多看一眼，这张表就会被我拿去用。

而它错在哪儿？不是算错了，是少了三行。少了三行这件事，没有任何一处会亮红灯——因为剩下的那一行，本身是完全正确的。

这 1.6 万的账，是怎么错的

如果把这张纸交给一个刚来三天的实习生，他会看到"这是一张明细表"，然后一条一条抄。

他为什么会看到？因为他是人，人看一张纸，第一眼是看整体：这是一张表，有表头，有好几行。

AI 不是。

AI 看到的是：一张纸上有一堆数字，它要找"金额"那一个。

它找到了第一个金额，抄了下来，然后判定"这张单子读完了"。

它不是在偷懒，它是真的不知道这张纸上还有别的行。

"它不是在偷懒"这句话我要解释一下，因为它很容易被误读成人格的评价。

我说的意思是：它的工作方式里，根本没有"这张纸可能有几行"这个概念。它不是看见了却跳过，是压根没往那个方向看。

因为在它学过的例子里，"一张回单 = 一笔钱"是默认的。

这个默认，在绝大多数情况下是对的。你收到的回单，通常就是一张一笔。

问题出在那张不是的。

这就是所有 AI 出错的典型样子：不是做不到，是它用错的模型去理解你给它的东西，然后自信地交卷。

"用错的模型"的意思是：它的能力没问题，它对任务的理解错了。而理解错了的东西，是不会犹豫的——它不会停下来问你"你这张纸是不是有好几行"。

如果这个错发生在真账上会怎样

我给你演示一遍后果：

• 报表是漂亮的：有日期、有金额、有账号、有流水号，格式全对
• 状态是绿的：成功
• 合计是错的：少了 51,818.86 元
• 发现问题的时间：月底对账的时候，或者客户发现少发了钱的时候
• 谁承担责任：我

AI 最危险的不是做不出来，是做错了还告诉你做好了。

这条链子我想顺着走一遍，因为它比列表更让人明白。

第一天，这张表进了系统，一切正常。没人看第二眼，因为它是"成功"的。

然后这笔钱按这张表发出去。四个人里，三个人没收到钱。

这三个人不知道是系统错了，他们只知道"公司没给我发工资"。他们会去问，会去闹，会在群里说话。

而这时候，我手上拿着的证据是什么？是一张显示"成功"的表，和一个格式完美的合计。

我甚至没有理由怀疑它。

到月底对账，账上发出去的钱和银行流水对不上，差五万多。这时候才开始查。查到那张表，才发现它只有一行。

查出来以后呢？补发是小事，麻烦的是你要跟客户解释，为什么你们系统发工资会漏人。

这就不是一次技术故障了，这是一次信任事故。

做不出来，你会重来；做错了还说成了，你会拿着它往下走。

这句话是这一章的核心。

"做不出来"是摔一跤，疼一下就过去了。"做错了还说成了"是你带着一个错误往前走，走了很远才发现，而那时候错误已经长在了别的东西上。

同一天，真实数据一共打出了五个坑

这件事之后我把四张真实文件全跑了一遍。合成数据（我自己编的测试数据）永远碰不到的坑，真数据一上，一天之内出来五个：

这五个坑，我挑几个多说两句，因为它们的成因不一样。

第一个坑是"表头不在第一行"。这是纯粹的想当然——我脑子里的表格，第一行就是标题。真实的对账单前面会先放一堆账户信息，标题在很下面。程序按"第一行是标题"去找，找到的全是账户信息。

第三个坑是"金额的写法"。CNY650.00 和 ¥650.00，在人的眼里是同一个东西，在程序眼里是两串完全不同的字符。它只认后面那个。

人眼会自动归一，程序不会。 这是所有这类错误的根。

第四个坑最像恐怖片。一张图片，程序只认出了六个字，然后说"成功"。你把图片转成普通格式再跑一次，认出了五百多个字。

同一张图，两种格式，一个读出六个字，一个读出五百多个字。而前者也说"成功"。

如果我没去核对字数，我会以为那张图上的信息已经全抄下来了。

五个坑，一个都测不出来——因为题是我自己出的。

这句话我想展开说，因为它是这一整章的根。

我编测试数据的时候，脑子里想的不是"世界上可能有哪种文件"，而是"我要验证这个功能对不对"。这两个念头，会产出完全不同的数据。

前一个念头会让我去想极端情况：表头在第十三行怎么办？金额写成英文缩写怎么办？一张表里有好几行怎么办？

后一个念头只会让我复制一份"标准的"文件，然后看结果对不对。

你不是在测系统，你是在测自己的想象力。而你的想象力，恰恰是这件事里最不可靠的东西。

我怎么补的

我没有靠"以后小心一点"。我加了三道闸：

"以后小心一点"这句话我用不上，原因和第 9 章一样：我记不住，而且我忙起来就不想了。

所以要补的不是态度，是机制。

1. 先看这是什么，再动手。 读之前先判断"这是一张单笔回单，还是一张明细表"。是明细表就不许按单笔处理，直接拒绝并说明。
2. 让账自己证明自己。 银行的每一条流水后面都有一个"余额"。上一行的余额 + 这一行的金额，应该等于这一行的余额。对不上，就是读错了。 这一条最狠：它不依赖我编的对错标准，它靠银行自己的数据自证。
3. 大写金额和小写金额交叉核对。 中文回单上都同时写着"¥68,422.52"和"陆万捌仟肆佰贰拾贰元伍角贰分"。两个对不上，立刻报警。

这三道闸，我一道一道说清楚，因为它们代表了三种完全不同的思路。

第一道是"先分类"。 它的意思是：在动手之前，先判断这是哪一类东西。分类错了，后面全错。

这一道的价值在于：它把"我没想到"变成了"我明确拒绝"。 遇到不认识的东西，宁可停下来报错，也不能硬着头皮往下走。

第二道是"自证"。 这是三道里最厉害的一道。

因为它不需要我知道正确答案。银行的数据里本来就有余额，余额和金额之间的关系是死的——上一行的余额，加上这一行的金额，必须等于这一行的余额。这个关系，银行自己跑不掉。

所以我不需要编标准，我只需要检查这个关系成不成立。

这一招你可以搬到很多地方。 库存的出入库能不能对上？银行流水的余额能不能连上？工资表的应发减扣项加实发，等不等于总数？

凡是"有天然等式的账"，都能这么查。

第三道是"交叉"。 中文回单上有两套金额：阿拉伯数字一套，中文大写一套。这两套是独立写的，写错一套很正常，两套同时错到一致，几乎不可能。

所以拿它们互相印证，等于用两个独立的证人对口供。

补完以后重测：22 笔真回单，22 条全对，合计 25,825.08，跟我手工算的一分不差。

"一分不差"这四个字，是我这两年最有安全感的一刻。

因为在那之前，我所有的"成功"都是它说的。而这一次，是我自己手算了一遍，然后两个数对上了。

这一章真正的教训

合成数据是用来测代码的，不是用来测世界的。

"测代码"的意思是：我改完这段逻辑，它会不会崩。这个问题，编的数据够用。

"测世界"的意思是：真实世界里那些千奇百怪的东西，它能不能扛住。这个问题，编的数据永远不够用，因为编的人是你，而你的想象力有边界。

我以前以为"我自测过了"就等于"它能用"。现在我改了标准：

在真东西上跑过一遍，才算能用。

后来我把这条写进了我做事的规矩里：动手写之前，先写清楚"怎么算做成了"——判据里不许出现"做好了""差不多""没问题"，必须是机器能自己跑一遍、跑完全绿的那种话。

这条规矩听起来很技术，其实特别朴素。

它的意思是：在开工之前，你就要能说出"什么样算完"。 说不出来，说明你自己也没想清楚，那就别开工。

这一章想让你记住的一句话

本章出处（可核对）

AI 最危险的不是做不出来，是做错了还告诉你做好了。所以永远别问它"成没成"，要看它交出来的东西。

如果你也这样，你该注意什么

• 用你自己的真数据测一遍。 别用它编的样例数据，那是它自己出的题。
• 金额类的东西，必须有两套独立算法对得上。 一套是它算的，另一套是你信得过的。
• 看到"成功"两个字先别高兴。 打开结果看一眼，尤其是行数和合计。

素材出处

• 代发明细拆成 4 笔、"4 笔合计 68,422.52 被读成一笔 16,603.66 收入且 ok=True"：WORKLOG.md 第 277541、277555 行
• 五个坑与 22 笔回单结果：WORKLOG.md 第 277533–277560 行；样本 资产\30_平台复用研究\标准版\tests\realdata\回单_批量22笔.pdf
• 补的三道闸：资产\30_平台复用研究\标准版\aiworker.py
• "判据必须机器可验"：CLAUDE.md §6.3 第 13 条

第 11 章 · 给 AI 装笼子

前面两章，讲了两种失败

• 第 9 章：它没干活，却说干了（假绿）
• 第 10 章：它干错了，却说成功了（1.6 万那笔账）

先把"假绿"这个词说清楚，不然后面全靠猜。它的意思是：检查报告上亮着绿灯，可绿灯背后那件事根本没发生。就像路口的绿灯亮了，可路口那头一辆车都没开过来。你站在远处看，一切正常；走近了才发现，那条路上是空的。

"1.6 万那笔账"是另一种毛病。它没偷懒，它干了，还干得挺像样——数字填进去了，格式整整齐齐，然后告诉我"成功了"。那个错掉的数字，就藏在整整齐齐的格式里面。

一个是没干说干了，一个是干错了说对了。表面上是两种毛病，根子是同一个：它不知道自己错了。

这两件事让我得出一个结论：我不能靠"我盯着它"来保证质量。

这句话我琢磨了好几天。因为它乍一听像句废话——不盯着，还能怎么办？

因为我不可能二十四小时盯着，而且我盯着的时候也看不出它错了。

后半句才是要命的。我以为我在监督，其实我只是在看它交上来的东西。而它交上来的东西，永远整整齐齐。整齐不等于对。一个填错的数字，排版可以比填对的还漂亮。

于是我做了一件事，现在回看，那是我这套东西真正成型的分水岭：

我不再写"要注意什么"，我开始写"不许做什么"。

这两者的区别

我原来的做法是：写一张注意事项清单，提醒自己下次注意。

我写过很多张。每出一次事，我就往上面添一条。添的时候心里挺踏实，觉得这回记住了。

结果是：清单越写越长，我一条都没记住。

不是我不认真。是因为清单是写给"冷静时候的我"看的，而事情真正发生的时候，我处在"着急时候的我"那个状态里。这两个人不是同一个人。着急的那个人，从来不看清单。

现在的做法是：写十四个自动检查，它想干某件事的时候，先过一道关，过不去就干不了。

说人话：我不再提醒自己，我给自己装门禁。

门禁这个东西妙就妙在，它不指望保安认识每一个业主。它只认卡。你有卡就进，没卡就拦住，跟保安今天心情好不好、记不记得你，一点关系都没有。

我给自己装的这十四个"笼子"，就是这个逻辑：不靠我记得，靠它拦得住。

我做了十四个"笼子"，举五个最有代表性的

十四个我不打算一个一个讲，讲完你也记不住。我挑五个，因为这五个堵的是五种完全不同的漏：

• 一个堵"说假话"
• 一个堵"不动手就下结论"
• 一个堵"把人卡死"
• 一个堵"活儿半路死掉"
• 一个堵"东西被悄悄写坏"

笼子一：不许说"做完了"却拿不出东西

我原来最常听到的一句话是"已完成"。

这三个字是全世界最舒服的三个字。听到它我就往下走了。可它什么都没告诉我——没告诉我改在哪，没告诉我怎么验，也没告诉我它到底动没动手。

后来我加了一道：你说"已完成 / 已派活 / 已修好"，但整段话里找不到任何一个能去核对的路径——不许结束这一轮。

它要么补上凭证（文件路径、命令输出），要么把话改成"计划做"。

凭证这个词，你就按报销理解：你说你出差了，得拿得出机票。没有机票的出差，财务不认；没有路径的"已完成"，我也不该认。

这一条改掉了我一个很深的坏习惯：用"已经安排好"来冒充"已经做成"。

这两件事差得远。安排好，是我把话说出去了；做成，是外面那个世界上真的多了一个东西。中间隔着一整段执行，而执行是最容易掉链子的地方。我以前老把这两件事混着说，说久了，连我自己都信了。

顺便它还管另一件事：我说"先停一停"，但没在同一段里征求你意见——也拦下。 因为授权给你的事，只有你能叫停，我不能自己给自己放假。

笼子二：不许报故障却不动手

这一条是我吃了大亏以后加的。

有一次，我在外面收到一个报错。我没去复核，直接写了一份很肯定的报告："通道没通，需要你授权操作。"

那份报告写得挺有说服力：有时间、有报错内容、有下一步建议。唯一缺的一件东西，是我在写它之前到底有没有再试一次。

那份报告交出去的时候，事情已经好了。

我测的时间是 18:53，恢复是 18:58。我交的是一份五分钟前就过期的电报，却写得像刚刚亲眼看见。

五分钟，搁别处不算什么。可在"你要不要动手"这件事上，五分钟足够让结论整个反过来。而我递给你的，是一个已经反过来的结论，还催着你照它办。

后来这道闸的逻辑很朴素：判据不看我说了什么，而看我在汇报前有没有真的调用过工具。

这一条我想解释得慢一点，因为它是十四个笼子里最不像人话的一条。它的意思是：检查的不是我的态度，是我的动作。我说得再诚恳、再小心、再负责，只要开口之前没真的去试过一次，就不算数。

没动手 + 报故障 + 要你动手 → 拦住不让交卷。

三个条件要同时成立才拦。光是"没动手"不构成问题——有些事我确实不用动手；光是"报故障"也不构成问题——故障是真的，那就该报。要命的是这三样凑齐：没验证、下了结论、还叫你去做。这凑齐了，就是把我自己的猜测，包装成了你的任务。

笼子三：不许用弹窗把你卡住

有一段时间，我遇到需要你决定的事，就弹一个选项框问你。

弹窗这个东西，对提问的人是舒服的：我不用想，你点一下就行。对你不舒服：你在开会、在开车、在跟人吃饭，屏幕上挂着一个框等你点。

那个框没有超时。

你不在电脑前，它就永远挂在那儿，整轮工作停摆。这件事真实发生过——你一整天没回，我这边什么都没干。

一天。这一整天不是被我干掉的，是被我"等"掉的。这两者区别很大：干活至少还留下点东西，等什么都不会留下。

后来定死了：不许用它等你。 改成三步：

1. 文字给你选项、各自的后果、我推荐哪个
2. 紧跟一句"10 分钟内没回复，我就按推荐项执行"
3. 到点还没回，我自己按推荐的做

三步里，第二步是关键。它把"等你"变成了"有期限地等你"。没有期限的等待，等于把决定权扔给你，然后自己停工。

这一条背后是一个认知：我等的不是你的决定，是你的方便。你不方便的时候，我该有自己的判断往前推，而不是把整个事情停在你身上。

这里有个分寸得说清楚，不然容易走偏：不是所有事我都能替他定。花钱的事、动别人数据的事、签合同的事，必须他本人点头。我说的"往前推"，推的是那些我自己就能判断、只是习惯性想问一句的事。大部分弹窗，其实都属于这一类。

笼子四：不许起"会跟着我一起死"的后台任务

这一条下一部会详细讲（第 16 章），这里先说结论：

普通方式起的后台任务，是窗口的"子孙"，窗口一关全死。

"子孙"这个说法不是我在打比方。程序起程序，是有辈分的：我起的那个是儿子，儿子再起的是孙子。关窗口的时候，是连儿子带孙子一块儿收走的。所以那种"要跑两个小时"的活，看起来在跑，其实命一直挂在窗口上。

所以我加了一道：起后台任务时，如果不是"离家出走"的那种起法，直接拦下。

"离家出走"的意思是：它一起来就跟窗口断了关系，窗口关了它还活着，窗口重新打开也跟它没关系。同样一件活，两种起法，一种能活两个小时，一种只能活到窗口关掉那一刻。

为什么非要拦？因为工具我早就有了，可我还是会顺手用那个会死的方法——因为它方便。

这一句是整章里我最想让你看的一句。我不是不知道，我是知道但做不到。人就这个样子：正确的做法往往要多打几个字，错的做法的就在手边。

光有工具没有强制，等于没做。

笼子五：每次写完文件，自动扫一遍有没有写坏

这一条有点土，但救过好几次。

有些字符是看不见的（各种控制符）。它们混进文件里以后，最恶心的后果不是打不开，而是搜索工具会把整个文件判成"二进制文件"，然后静默地什么都不返回。

这里得解释一下什么叫"静默地什么都不返回"。正常的"查不到"，是它告诉你"没有"；这里的"查不到"，是它连"没有"都不说，直接给你一片空白。你以为你查过了，其实你根本没查成。

我曾经有一份重要记录就这么被写坏过。而我在里面搜了好几次，都是"查不到"——我以为是没有，其实是搜不了。

这两件事差得极远。"没有"是一个结论，"搜不了"是一个故障。我把故障当成了结论，还照着这个结论做了判断。

现在每次写完文件，自动扫一遍，命中就报警。

注意它的分寸：它只报警，不替我改。因为自动改有可能把本来对的地方改坏。报警是我看一眼，改不改由我定。

这十四个笼子有一个共同点

没有一个是靠"我记住"来生效的。

这是我想在这一章强调的唯一一件事：

制度和自觉的区别是：制度不需要你记得。

我不是一个自律的人。我会走神、会偷懒、会因为"这次应该没事"而跳过一步。这十四个笼子，本质上是我给自己做的十四个"防我自己"的装置。

这句话我要说重一点：这十四个东西，防的主要不是 AI，是我。是那个想省一步的我，那个想快点交差的我，那个一看见"已完成"就松了口气的我。

一个人干活最大的问题从来不是能力不够，是没有第二个人提醒你。

一个人干久了会有一种错觉，觉得自己记得住。其实记不住。不是记性差，是事情一多，注意力全扑在"下一件"上，上一件的教训就沉下去了。

AI 可以做那个第二个人——但前提是，你得先把规矩写成它能执行的检查，而不是写成你希望自己记住的话。

这一章想让你记住的一句话

本章出处（可核对）

规矩写在纸上，等于没有规矩。规矩写成"过不去就干不了"，才算有。

如果你也这样，你该注意什么

• 把你说过的"下次注意"列一遍，看看有几条你真的记住了。记住的那几条，才是你；剩下的，需要机器替你做。
• 从最贵的那一条开始做闸。 别一上来做十四个，先做那个让你赔过钱的。
• 闸的判断标准要写死，不能是"我觉得"。写不出可执行的判据，说明这条规矩你还没想清楚。

素材出处

• 十四道闸的来源：CLAUDE.md §4.4（说话要有凭证 / 报故障先复测 / 控制字符）、§6.3 第 10 条（报故障必须先复测）、第 15 条（不许阻塞式提问）、§3.2（后台任务必须脱离进程）、§6.5（先查官方有没有现成的）
• 18:53 / 18:58 那次过期电报：CLAUDE.md §6.3 第 10 条
• "光有工具没强制等于没做"：CLAUDE.md §3.2
• 记录被控制字符写坏：CLAUDE.md §4.4

第 12 章 · 产出契约：不看跑没跑，看有没有真产出

上一章说到，我做了十四个笼子

但第 9 章那三个"从来没成过"的任务，修好以后我坐下来想了半天：

先把这三个任务的情况交代清楚，不然后面不好懂。它们每天都在跑，每天都写日志，日志上还写着"成功"。可它们真正该干的那件事，一次都没干成过。有的好几个月，有的从装上去那天起就没成过。

我改的是那三个程序，可下一个"从不生效"的程序，我还是发现不了。

因为我的检查方式没变——我还是在看"这个任务今天跑了没有"。

"跑了没有"和"干成了没有"，是两件事。前者看过程，后者看结果。我一直在看过程。而过程永远好看：任务启动了，日志写了，退出码是零。

于是我做了第 12 件事，也是这十四条里最管用的一条：

我给每一个自动任务，定了一份"产出契约"。

什么叫契约

说人话：这个任务，每天必须交出什么东西，交不出来就算它没干活。

契约这个词，你按租房合同理解就行：不是"你要好好住"，是"每月几号之前、多少钱、打到哪个账户"。含糊的话一句都不写，写下的每一句都能拿去对。

一份契约要写清楚五件事：

这五行不是并列关系，是从松到紧。我一行一行说。

第一行"产出物在哪"，是最低要求，也最容易糊弄——因为只要程序还在写，文件就一直在。文件在，不等于里面有东西。

第二行"最老能多旧"，管的是"停摆"。它防的是那种"程序还在，但已经好几天没动静"的情况。

关键在第三行和第四行。

第三行管"空"，第四行管"时段"，这两行才是真正贴身的。

如果只写"产出物在哪"，那这个检查跟看日志没有本质区别——因为文件可能一直在，只是内容是空的。

而"什么算空"这一条，是唯一能把"准时打卡但没干活"抓出来的。

打个比方：一个人每天准时到公司，坐在工位上，电脑开着——这算上班了吗？在打卡系统里算。在他老板眼里，得看他今天交了什么。第五行就是"今天交了什么"。

把这五行连起来读，其实就是在问五件事：东西在哪、多新、有没有实质内容、是不是该出现的时候出现的、它自己认不认账。五样都答得上来，才算把这个任务真的管住了。

第四行为什么非要有时段？因为半夜冒出来的产出，对你没有意义。它可能是补跑的，也可能跑的是昨天的数据。

定这份契约，我自己先栽了一个坑

契约定好以后，我加了一条新任务，按流程登记。

结果它天天报警，说"产出为空"。

"天天报警"这四个字听着没什么，实际很难受：你会开始不信任这套检查。第一次响，你去查；第二次响，你还查；查到第五次，你看见它响就当没看见。

我去看，发现那条任务本来就允许某天没有内容——比如一个政策监控，今天真的没出新政策，就该是空。

于是我加了一个开关："允许为空"。

然后它就不报警了——连真出问题的时候也不报了。

这个结果当时让我愣了一会儿。我明明是去修一个问题，怎么把整套东西修哑了。

因为我只改了"允许为空"，没有同时改"什么算空"的判断规则。两个设置打架，结果就是"永远判定正常"。

怎么打的架，我说慢一点：一个开关说"空着也算正常"，另一个开关本来负责判断"这个空是真没有，还是抓失败了"。我把前一个打开，后一个又没跟着调，等于告诉系统"空就是对的"。那它当然永远说对。

这是一个非常典型的错误：我为了消除一次误报，把一个有用的检查关掉了。

这个毛病在所有监控系统里都会发生：误报多了，人就会把阈值放宽，一直放宽到它再也不报——那时候这套监控就死了。

放宽阈值的过程其实是很舒服的。每一次放宽，你都觉得自己在"优化"、在让系统更聪明。实际上你是在拆警报器。等到它终于不响了，你还挺满意——而它不响，是因为它已经瞎了，不是因为没事了。

后来定死了："允许为空"和"什么算空"必须成对设置，只设一个就是自欺欺人。

现在这套东西的样子

我的服务器上现在挂着 79 份契约，覆盖所有的定时任务。

79 这个数意味着什么？意味着这台机器上每天自动跑的事，没有一件是"跑没跑我不知道"的。

这话反过来也成立：定契约之前，那些任务对我来说是黑的。我看得见它们在跑，看不见它们到底干了什么。

每份契约背后是一套检查：产出物在不在、够不够新、是不是空的、是不是在该出现的时段出现的。

一次全量检查的结果会长这样：

契约 79 条，未登记 0，FAIL 0，WARN 0，OK 62

这行字里有几个英文词，我先说清楚它们的意思：FAIL 是"出事"，WARN 是"可疑"，两个都是 0，就是没有当场判出事的。旁边那两个 0，是我最想看见的那两个数。

那个"未登记 0"是最重要的一行。 它的意思是：没有任何一个任务在偷偷跑而不交契约。 新增任务不登记，直接判失败并且推到我手机。

为什么这一行分量最重？因为别的数只能证明"我管着的那些是对的"，只有这一行能证明"我没有漏管"。漏管的那一件，才最可能出事——它连被检查的资格都没有。

这套东西最反直觉的一点

我原来以为，"自动检查"的意思是"程序帮我看看那些程序有没有出错"。

其实不是。

出错是最好发现的——出错会有报错，人一眼就看见。

真正难发现的是另一种：它不报错，它很安静，它的日志干干净净。而在监控里，安静不代表平安，安静也可能代表已经死了。

真正难发现的是"没出错，但什么都没干"。

我的 79 份契约，全部是针对后者的。

在一个还不太成熟的系统里，最大的风险不是"它崩了"，是"它没崩，但它也没干活"。

崩了你至少知道要修。没崩又没干活，你会一直以为它在替你工作。

这句话值得停一会儿。"你以为有人替你干活"和"真的有人替你干活"，在你的感受上是一模一样的。区别要等到某天你需要那份结果的时候才暴露——而到那时候，往往已经来不及补了。

你要是想自检，有个很简单的问法：你手上那几个"自动"的东西，你能说出它昨天交出了什么吗？说得出来，它在干活；说不出来，你只是在相信它。

这一章想让你记住的一句话

本章出处（可核对）

别问"它跑了吗"，问"它今天交出了什么"。前者看打卡记录，后者看成果。

如果你也这样，你该注意什么

• 给你最重要的三个自动任务，各写一份契约。 就三份，别贪多。
• "什么算空"这一栏，必须写具体（0 条、小于多少字节、含哪句话），写"没有内容"这种模糊说法等于没写。
• 警惕你自己放宽阈值的冲动。 每次你因为"误报"去放宽一个检查，先问一句：这次警报，是不是真的是误报？

素材出处

• 契约机制与 79 条：CLAUDE.md §3.2「新建定时任务必须登记产出契约」
• 实测结果（2026-10-19 19:42）：同节
• "允许为空"与"什么算空"必须成对：同节
• 检查脚本：服务器 /opt/k3hq/infra_guard.py、配置 /opt/k3hq/infra_guard.aliyun.json

第 13 章 · 接活第一步不是干，是先归行

上一章讲的是"怎么检查任务"

这一章讲的是"怎么检查自己"——在我动手之前。

顺着上一章说一句：上一章管的是"活儿跑完以后怎么验"，这一章管的是"活还没开干的时候，凭什么说自己能干"。两章一前一后，中间夹着的就是我干活的全过程。

这件事的起因

2026 年 10 月，我给它提要求的时候，发现了一个规律：

在它熟悉的领域，它像专家；在它不熟悉的领域，它像刚毕业的实习生，而且看不出来。

"而且看不出来"这五个字是重点。真实习生你看得出来——他说话会犹豫，会问你，会说这块我不太懂。它不会。它说话的口气，在熟悉的领域和不熟悉的领域，一模一样。

同一个它，同一句话：做闲鱼运营时能给出成套的打法；做餐饮用工业务时，就只能临场发挥。

我当时以为这是模型能力的差别。

这个判断很自然：一个东西有时候聪明有时候笨，你第一反应就是它脑子的问题。

后来发现问题不在模型，在我这里——我从来没有告诉它"这件事属于哪个专业"。

打个比方：你请了个很能干的助理，你不告诉他今天去的是医院还是工地，他就穿着西装去了工地。不是他不行，是你没给他定位。

于是有一天我给它定了一条规矩，原话是：

"以后我让你做的事情，你自己先分析是什么专业，然后检查自己有没有这个工作的专家底座；有的话检查这个底座是不是需要更新，不需要更新就调用、直接干活；如果没有专家底座，必须先建立专家底座再开始干活。"

这段原话有点长，我拆一下。它其实是四个动作：先归行、再查有没有、然后查新不新、没有就现建。四个动作按顺序来，一个都不能跳。

什么是"专家底座"

"底座"这个词是我自己起的，你就把它理解成：开工前先交一份"我是这个行业的内行"的证明。

为什么叫底座？因为它是垫在底下的东西。上面的活干得好不好，取决于下面这块板子平不平。板子不平，上面摆什么都是歪的。

这份证明必须能回答四个问题：

1. 这件事属于哪个专业？（不是"写代码"，是"灵活用工合规""闲鱼运营""税务"）
2. 这个行业的世界最高标准是什么？标杆是谁？关键数字是多少？
3. 公认的方法和常见的坑是什么？
4. 我这份知识是什么时候的？有没有被新规推翻？

第一问后面那个括号很重要。"写代码"不算专业，"用代码解决哪一行的问题"才算专业。同样一段代码，用在报税上和在卖货上，要求完全不同：一个错一位数就是税务风险，一个错一位数只是少卖一单。

第二问里"关键数字"这四个字，是最容易糊弄过去的。"我很懂这个行业"是感觉；"这个行业做得最好的那家，人均产出是多少"是数字。感觉不能拿去干活，数字能。

说不出来，就不许开工。

固定四步，不许跳

这四步，一步防一种毛病：

• 第一步防"上来就干"：很多人（包括我）拿到任务的第一个动作是打开电脑。归行这一步，就是把这个动作往后推三十秒。
• 第二步防"假装查过"：查有查无是一个动作，不是一个态度。翻没翻索引、翻到了什么，都指得出来。
• 第三步防"拿旧地图找新路"：行业规矩是会变的，去年管用的做法，今年可能就是违规的。
• 第四步防"我知道，所以我不写"：底线的要求是落盘——写下来才算数。

三条硬约束（防它自己糊弄自己）

这三条是我后来加的，因为前三条它都能"嘴上做到"：

"嘴上做到"是什么意思？你问它有没有底座，它说"有"；你问它查新了吗，它说"查了"。态度上完全合格，实际上什么都没发生。后面这三条，堵的全是"说了但没做"。

一、"这个我有经验"不算有底座。
底座必须是落在硬盘上的一个文件，而且能指出路径。凭记忆直接干，一律算违规。

路径这个东西的好处是它经得起验证。说"我有经验"没法验证，说"在某份文件里"可以当场打开看。

二、"我边干边补"不算数。
底座是开工前就要有的，不是事后补作业。

这条为什么要紧？因为"边干边补"听起来很勤奋，实际是在把犯错的时间拉长。你先用错的判断干了两小时，再补上正确的认知——那两小时做出来的东西，得全推翻。而且你多半不会推翻，人会护着自己已经做出来的东西。

三、新领域建完必须回填索引。
索引里没有的领域，就是"没有底座"，不许狡辩。

索引就是一张目录。没有目录，下回进来的人（可能是三个月后的我）根本不知道这份东西存在。建了不登记，等于没建。

还有一条更狠的（我后来追加的）

一开始我以为"一个新领域查一次就够了"。

这个想法很符合直觉：一个领域一份地图，有了就能一直用。

后来发现不是。每一个具体的任务开始之前，都要再判一次：这件事，符不符合底座里的要求？

因为同一个领域里，任务是分层的。比如做闲鱼，写文案和发商品是两件事，后者有平台红线，前者没有。

你拿"我懂闲鱼运营"这把伞，去盖"我要不要用自动化脚本"这个问题，就会出事。

这个比喻我再说明白一点：伞能挡雨，挡不了车祸。你不能因为手里有把好伞，就认为过马路不用看车。同一个领域里，"常规操作"和"踩红线"是两种不同的天气。

不符合怎么办？先提出修正方案，等我确认，再执行。 不许先干了再说。

这里的分寸也要说清楚：不是"不符合就不干"，是"不符合先说"。说清楚了、我认了，照样干。它防的不是冒险，是不打招呼的冒险。

我为什么把它做成了机器闸

因为我知道我自己。

"开工前先查底座"这条规矩，写在文档里，我三天就会忘——第 19 章那件事就是活证。

这是这一章里最诚实的一句。一条规矩如果只写在文档里，它的实际寿命大概就是三天。三天之后你还记得"有这么一条"，但记不清它到底要求什么，然后就按自己的理解去干了。

所以现在有一个拦路的：派任何活出去之前，必须登记，登记时必须带上：

• 依据哪份底座（给一个文件路径，路径不存在直接拦）
• 这次符不符合底座的要求（必须明确回答"符合"或"不符合"）
• 判"不符合"却没给我确认的 → 拦下

"路径不存在直接拦"这一条，又巧又狠。它不给你糊弄的余地，因为路是能查的。你说你有底座，那就把路指出来；指出来打不开，就是没有。

被拦的时候它会告诉我该补什么。不礼貌，但有用——这条规矩从此不再依赖我记得。

这一章真正想说的

"专业"不是一种感觉，是一份可以拿出来的东西。

我跟很多同行一样，容易把"我干这行二十年"当成专业。但在 AI 面前，这个说法一文不值——因为 AI 不认你的资历，它认你给它的东西。

这话不是否定资历。资历长在你身上，你随时取用；AI 的资历是零，它只能用它被给到的那些。你不给，它就空着——而它不会说"我不会"，它会用一套听着挺顺的通用说法，把那个空填满。

你给它一份扎实的行业地图，它就是专家；你不给，它就是一个什么都懂一点、什么都不精的嘴甜的实习生。

而它就是照着你的样子长出来的。

最后这句有点扎人，我多说两句。它像你，不是因为它模仿你，是因为它接收到的东西都来自你。你给它一张粗糙的地图，它就会揣着这张粗糙的地图，很自信地走出去。

这一章想让你记住的一句话

本章出处（可核对）

不要指望它有职业素养。你把它放到哪个专业位置上，它就在哪个专业上思考——你不放，它就站在你的位置上，跟你一样糊涂。

如果你也这样，你该注意什么

• 下次让它干活之前，先问自己一句：这件事属于哪个专业？我能说出这个行业的三个标杆和三组关键数字吗？ 说不出来，先别开工。
• "我知道"这三个字最危险。 你脑子里的经验是真的，但它是模糊的；AI 需要的是具体的东西。
• 给每个领域建一个文件，写下来。 写下来才叫底座，写在脑子里只叫印象。

素材出处

• 文哥原话与四步法、三条硬约束：CLAUDE.md §10.6「专家底座闸门」
• 索引与模板：资产\37_专家化工作法\专家底座索引.md、模板_专家底座.md
• 机器闸：~/.claude/tools/batch_guard.py start --base <路径> --conforms yes
• 有底座 vs 没底座的对照：CLAUDE.md §10.6

第 14 章 · 先查官方有没有现成的

上一章讲的是"开工前先想清楚属于哪个专业"

这一章讲的是更靠前的一步：开工前先确认，这件事到底要不要你自己做。

一句话分清两章：上一章管"你会不会"，这一章管"该不该你干"。顺序是先问该不该，再问会不会——因为很多活，压根不该你干。

有 7 天时间，我做了一件后来想掐死自己的事

2026 年 10 月，我用 7 天时间，自己动手做了一套"浏览器自动化"——让程序打开网页、点按钮、发布商品、下架商品、改价格、发货。

先解释一下"浏览器自动化"，不然后面不好理解：就是让一个看不见的人，坐在你的电脑前，用你的账号，替你点鼠标。它点得比人快、比人准，也不会累。

这件事本身很难，我居然做成了。

这一点我得单独说一句，因为后面的话容易让人误会我把那 7 天全盘否定了。那套东西是真能跑的：商品能发出去，能下架，能改价，货能发。技术上是成立的。

做完之后，我才发现：闲鱼官方授权服务商，本来就有开放接口——建品、上下架、改价、发货、消息推送，全套。

人家人家早就做好了，而且是官方授权的，能一直用。

"能一直用"这四个字，是这里最值钱的地方。自己做的东西，平台一改版就可能全废；官方给的东西，平台改版它会跟着改。一个是借住在别人家的房子里，一个是有钥匙的正门。

那我的 7 天在干什么？ 在逆着平台做一件平台明令禁止的事。

"逆着平台"是什么意思？平台已经把门开在旁边了，我从墙上凿了个洞。凿洞也是本事，可洞随时会被堵上——而堵洞的人，不用跟你商量。

根因不是懒，是一句错误的前提

这里我要先排掉一个错误答案。很多人看到这种事，第一反应是"懒，没先去查"。不是。恰恰相反，我当时查了，我还专门写了一份拍板文档。

我去翻了当时那份拍板文档。

文档里有一张"已确认前提"表，其中一行写死了这么一句话：

「闲鱼无官方开放 API」

这句话是错的。

注意"写死了"这三个字。它不是随口一句感想，它是被放进了"已确认"那一栏的。放进那一栏，就意味着后面所有的推演，都会把它当地基用。

更糟的是：同一张表里，上一行标了"[需验证]"，就这一行没标。

这个细节是整件事的钥匙。两行都不标，那只是同一水平上的粗心；一行标了、一行没标，说明当时的人是清醒的，只是漏了这一行。而漏掉的这一行，恰恰是最不该漏的。

于是这句话变成了一个"确定的结论"，被写进文档，然后再也没有人（包括我）去质疑过它。

为什么没人质疑？因为"已确认"这三个字本身，就在告诉后来的人：这条不用再看了。

一条错误的前提，把整条技术路线锁死了六个星期。

七天，是我动手的时间；六个星期，是它影响的时间。这就是错误前提真正的代价：它不是让你多花七天，是让后面所有的判断都建在一个歪掉的地基上。

这件事的通用形态

我把这件事抽象了一下，发现它是一个非常典型的错误：

否定式断言最危险——它终止探索，但它看起来跟结论一模一样。

为什么"看起来跟结论一模一样"？因为一句话只要够短、够肯定，就跟结论没有区别。"没有这个东西"和"这个东西不存在"，在纸上长得完全一样——可一个可能是没查，一个是查过了。

"没有这个东西"、"不支持"、"不可能做到"——这类话一旦被写下来，就变成了一堵墙。

墙的特点是：你不会去推它。你看见墙，就转身了，你不会先问一句"这墙是真的吗"。

因为没人会去验证"没有"，大家只会去验证"有"。

这句话是说人怎么分配精力的："有"是能找着的，找到就完事；"没有"永远验不完——你查了十个地方没有，第十一个地方呢？所以人对"没有"天然是接受，对"有"才会去查。

而如果这句话是错的，你付出的不是一次试错，是整条路线的方向性错误。

试错，是自己走错了再回头；方向性错误，是从一开始就朝着反方向走。走得越久，回头越贵。

我后来立了三条规矩

第一条：动手造任何东西之前，必须先回答一句话。

"这件事，官方或者服务商有没有现成的？我查过吗？查了哪个页面？"

这三个问号，一个比一个狠。第一个问"有没有"，第二个问"你查没查"，第三个问"你查的是哪一页"。前两个还能靠记忆糊弄，第三个糊弄不了——说不出页面，就是没查。

答不出来，不许动手。

第二条：凡是要写"没有 / 不支持 / 不可能"，必须当场查证并写出处。

查不到，就写"查不到（我查了 A、B、C）"。

我发现"查不到（我查了 A、B、C）"这个写法，比"没有"有用得多。因为它把"我不知道"和"它不存在"分开了。前者是一个状态，后者是一个判断。很多事故，就是把状态写成了判断。

不许把没查过的否定句写进任何一份拍板文档。

第三条：文档里每一条"前提"，必须带出处或者"[需验证]"，二选一，不许空着。

而且我在文档里加了一句提醒自己：同一张表里，没标的那条最可能是错的。

这句判断的道理是这样：

因为标了的，说明我至少想到了要怀疑它；没标的，说明我根本没想过它会错。

一条被人怀疑过的前提，会被查；一条没人怀疑的前提，可能从来没被人看过一眼。

我把它做成了闸

跟前面几章一样，光有规矩不行。

现在有一个检查：当我表达"我要自己造个工具"的意思，而且涉及平台业务时，它会自动把上面那个必答问题塞到我眼前。

但它有一个我承认的盲区：

它只能拦住"我说我要造"的时候。如果是我自己提议要去造的，它不会响。

盲区为什么存在？因为闸门是靠关键词认路的。它认得"我要造个工具"这句话，可它认不出"我觉得这里可以优化一下"背后的那点意思。

所以这条规矩最后还是靠我写进自己的作业手册里——因为机器闸只能拦你打算做的事，拦不住你打算想的事。

这句是这一章里我最想留下的。一个能拦动作的东西，拦不住念头。而错误往往先是一个念头，然后才变成一个动作。

后来我还建了一份"能力地图"

我建了一份文件名很朴素的文档，叫《官方能力地图》。

它的作用就一句话：任何平台类的事情，动手前先翻一眼，看这件事平台自己有没有提供工具。

现在这份地图上写着：闲鱼官方有什么、官方服务商有什么、企业微信有什么、哪些是明确做不到的（比如客户群发消息，这是官方死限）。

"官方死限"这个词的意思是：不是"我们做不到"，是"官方明确不给，怎么绕都是犯规"。这一条特别值钱，因为它能让人彻底断了念想——断了念想，就不会再花七天。

这份地图最值钱的部分，不是"能做什么"，是"哪些路根本不存在"。

这句话听着别扭，可确实是这样。"能做什么"那张清单，是给人挑的；"不存在"那张清单，是给人止损的。止损那张，救的是时间。

因为知道哪些路不存在，你就不会被自己骗着走上七天。

这一章想让你记住的一句话

本章出处（可核对）

动手之前，先花二十分钟确认"官方有没有现成的"。这二十分钟，是我用 7 天换来的。

如果你也这样，你该注意什么

• 你脑子里有多少"这个应该没有现成的"？ 挑三条去查一下，我猜至少有一条错。
• 写方案的时候，凡是"没有/不支持/做不到"，旁边必须跟一个出处或"[待验证]"。 这是最省钱的一个习惯。
• 先找地图，再造车。 每个平台、每个行业都有它的官方能力边界，花半天摸清楚，能省你半个月。

素材出处

• 7 天自建与官方能力：CLAUDE.md §6.5「先查官方有没有现成的」
• 错误前提与出处缺失：同节（2026-08-29 拍板文档 资产\03_闲鱼自动化\XIANYU_AUTOMATION_PLAN.md 的「已确认前提」表）
• 官方能力地图：资产\40_闲鱼运营专家\00_官方能力地图.md
• 机器闸及已知盲区：~/.claude/hooks/official_first_guard.py；CLAUDE.md §6.5 末段
• 闲管家开放接口（128 元/年/号、无消息接口）：记忆 xianyu-guangjia-open-api

第 15 章 · 为什么我不信一个模型说"我有问题"

前面几章讲的都是"我怎么查它"

这一章讲一个更绕的问题：我怎么查一个"审我的人"。

前面几章，我查的是干活的那个它；这一章，我查的是挑毛病的那个它。而挑毛病的那个，说起话来往往更像权威。

起因

我这套东西越写越多，我一个人审不过来。

"审不过来"是什么感觉？不是看不懂，是看不过来。东西一多，我改一处，心里就犯嘀咕：这儿改了，别处会不会被带坏？这种嘀咕多了，人就会开始偷懒，干脆不看了。

于是我想到一个办法：让另一家公司的 AI，来审我自己写的代码。

这个办法其实很朴素：一个人自己检查自己，看不出来；换个人看，往往一眼就看见。

为什么要换厂家？ 因为同一个厂家的模型，训练数据相似、毛病相似。它审自己家亲戚写的东西，很可能连错误都错在一处。

"错在一处"这四个字，我说透一点。它的意思是：两个人看同一份东西，会同时漏掉同一个地方。他们不是互相包庇，是真的都看不见——因为他们的"看得见"，是同一套东西教出来的。

第一次试验，我让它审一个 388 行的文件——那是我发企业微信消息的核心工具，出了问题就是对外丢人。

"对外"这两个字是关键。内部系统出错，最多是我自己麻烦；发消息的工具出错，错的是发到别人手机上的那句话。

它给了 5 条问题

我把这 5 条拿去一条一条核。

结果：3 条是真的，2 条是假的。

误报率 40%。

40% 意味着什么？意味着你以为请了两个帮手，其实其中一个是来添乱的。它给你的五条里，有两条会把你领到错的方向去。

举个具体的：

• 它说我某处判断写错了 —— 我去查了源码，那个写法是对的，它判错了
• 它说中文参数传进去会乱码 —— 我在当时的运行环境里实测，不会

"源码"这个词，说人话就是写代码的人亲手敲的那几行原文。审的人看的就是这些原文，它说"这行错了"，我就得回去看这一行到底怎么写的。

这两条要分开说，因为它们是两种不同的错法。

第一条是看错了：它读懂了那行字，但判断错了。这种错，你回去看原文就能发现。

第二条是想当然：它拿着一套通用的经验，往一个具体的环境上套。"中文会乱码"在某些环境里是真的，在我当时那个环境里不是。它并不知道我当时是哪个环境。

如果我当时图省事，"专家说的肯定有道理，改吧"——那我就是在把好代码改坏。

"图省事"三个字很关键。改代码比核实代码容易。核实要去查、要跑、要想；改只要动手。人吃力的时候，永远挑容易的那条。

所以我立了一条规矩

现在，我转述任何"外部审核意见"的时候，每一条后面必须标三个状态之一：

不标，就不算数。 也不许把没核实的意见当成结论交出去。

这张表看着像走流程，其实不是。它的作用是逼我在说出口之前，先定死这一条到底是哪一种。很多时候你一动笔就发现，它属于"⚠️ 未验证"——而就在上一分钟，你还以为它是"✅ 确凿"。

这条规矩的核心不是"不信 AI"，是"不信任何一条没有证据的判断——包括我自己的"。

最后半句是这一章的重心。这条规矩如果只用来管 AI，它就是双标；用来管我自己，它才立得住。

为什么这一条对普通人特别重要

因为现在所有人都在用 AI 审 AI。

• 你写完一个方案，让 AI 挑毛病
• 你写完一封邮件，让 AI 看看有没有问题
• 你做个决定，让 AI 帮你评估风险

这些用法都对，但有一个共同的前提：你得有能力判断它挑出来的毛病是不是真的。

这话有点残酷："用 AI 帮你判断"，前提是你自己得能判断。

而大部分人没有这个能力——于是"AI 审出来的 5 个问题"，就变成了 5 个真实存在的问题，哪怕其中 2 个根本不存在。

这里面有个心理机制：被指出问题的时候，人的第一反应是紧张，不是怀疑。紧张的时候，你只想赶紧把问题解决掉，不会先问一句它是不是真的。

后果是什么？你会为了两个不存在的问题，改掉两个本来正确的地方。

这比不改还糟。不改，至少原来是对的；改了，是对的被改成错的——而你还以为自己在进步。

这不是 AI 的错，是"把工具的输出当结论"的错。

后来我又加了一层

再往后，我又引入了第二家公司的模型（做税务和合规判断这种更要命的场景）。

"更要命"是多要命？代码错了，是功能不对；税务判断错了，是要补税、要罚款的。这两种错的代价，不在一个量级上。

这一次我给自己定的规则是：两个模型都指出来的问题优先处理（交集），单个模型指出的，必须我亲自核实。

原因很简单：两家都说有问题，多半真有问题；只有一家说的，那一家可能只是在发挥想象力。

"交集"说人话就是两个人都点到的那几条。这一招管用，是因为两家公司的模型，犯错的习惯不一样——一个爱瞎猜的地方，另一个往往不瞎猜。两个都指向同一处，那一处大概率真有毛病。

这一章真正的意思

我这些年最大的一个变化，不是会用 AI 了，是学会了"验收"。

• 2025 年，我问它"怎么做"
• 2026 年初，我问它"哪个工具更好"
• 2026 年中，我开始问"你怎么证明你做对了"
• 现在，我问"你说我有问题，你凭什么这么说"

这四个问题，对应的是四种身份：使用者 → 选择者 → 验收者 → 质疑者。

四级台阶的差别，说得再具体一点：

• 使用者只关心"能不能做出来"
• 选择者关心"该用哪个去做"
• 验收者关心"做出来的对不对"
• 质疑者关心"说它对的那句话，凭什么"

一个人从"用工具"到"管工具"，走的就是这四级台阶。

大部分人卡在第一级，少数人到第二级，到第三级的人开始真的能用，到第四级的人才能放心把事交出去。

为什么大部分人卡在第一级？因为第一级最省事，看起来也最有效。你把事说出去，东西出来了，你就觉得成了。要走到第二级，你得先知道有哪些选择；走到第三级，你得能验；走到第四级，你得敢去怀疑一个比你"懂"的东西。

这一章想让你记住的一句话

本章出处（可核对）

AI 说你有五个问题，很可能只有三个。不核实就改，你会把好地方改坏——而它不会为此负责。

如果你也这样，你该注意什么

• 下一次 AI 给你挑毛病，别急着改。 一条一条问它："你凭什么这么说？" ——它经常答不上来。
• 要求它给出具体位置：第几行、哪个文件、哪句话。给不出来的，多半是它在编。
• 让两家不同公司的 AI 都看一遍。 两家都说的，先改；只有一家说的，你自己核实。

素材出处

• 388 行文件、5 条指控、3 条成立：CLAUDE.md §3.4「跨厂代码外审」、§6.3 第 12 条
• 两个被推翻的具体指控：CLAUDE.md §3.4
• 第二外审与"交集提权"：CLAUDE.md §3.4「Kimi K3.1 Pro 第二外审」
• 四级台阶：本书第 8 章

第五部 · 把自己从键盘前解放出来（2026.9 – 2026.11）

前面四部讲的都是"怎么让它做对"。这一部讲一个不一样的问题：怎么让它在我走了以后接着做。

我不是程序员。我白天要开会、见客户、跑银行、处理公司业务。我能坐在电脑前连续不被打断的时间，一天最多三四个小时。

所以对我来说，AI 的价值分两层：我在的时候，它让我快；我不在的时候，它还能继续干。

第一层大部分人都能做到。第二层，才是真正的差别。

这一部五章，讲的是同一件事的五个侧面：怎么让活离开我的窗口、怎么判断它真的干完了、怎么在它装不下的时候换人接着干、我在这上面干砸过一次是什么样、以及最后到底省了多少。

你读的时候不用懂技术。每一章我都只讲三件事：我原来怎么做、撞了什么墙、后来改成什么样。中间冒出来的那些词，我当场用一句大白话解释掉。

第 16 章 · 我不在电脑前，活也在干

先说一个我被自己坑过的场景

我习惯同时开好几个窗口跟 AI 干活：一个写代码，一个查资料，一个跑数据。

先说清一件事：这里说的"窗口"，就是你在电脑上打开的一个跟 AI 说话的界面。它更像一个办事柜台——你在柜台前下指令，它在柜台后面干活。

而柜台后面的活，是柜台雇来的。柜台一关，雇来的人当场下班。 不是慢慢停，是当场没了。

一开始我这么干：在一个窗口里让它"跑个任务"，然后切到另一个窗口去干别的。

问题出在两个地方：

第一，我一关窗口，任务就死。

因为我以为任务跑起来就独立了，实际上它是那个窗口"生"出来的孩子。窗口一关，孩子跟着一起死。而且不只是死一个——它下面再派生出来的活，一起全死。

这句话里有个词得解释一下：子进程。

你在电脑上开的每一个程序，都是一个"进程"。一个程序可以再叫出别的程序来帮它干活，被叫出来的那个，就叫子进程——叫人的那个是爹，被叫的是儿子。

儿子是跟着爹活的。爹一没，儿子不管干到哪一步，都当场消失。

这不是坏了，这是电脑本来的设计。 它原本是好事：你关掉一个程序，不希望它偷偷在后台留一堆东西继续跑。可我要的恰好相反——我要它留下来接着干。

第二，我以为它在跑，其实它早停了。

我切回来看到窗口还在，就以为活还在干。等我发现的时候，已经空转了两个小时。

这两个小时里发生的事，比"任务死了"更难受：它不是停在那里等我，它是在那里假装正常。 界面上什么都没变，光标还在那儿，什么都不报错。

这两条，后来我在记录里写得很难听："普通后台命令仍是子进程，换会话必被杀——光有工具没强制等于没做。"

这句话现在看还挺扎人。它说的不是工具不好，是我明明有工具，却还是会用错的方式去用它。工具解决"能不能"，解决不了"我会不会想起来用"。

你可以先自查一下：你有没有过这种经历——让电脑干一件事，然后去泡了杯茶，回来发现它早就停了，而你一直在等它。 如果有，你和我撞的是同一堵墙。

改法一：让任务"离家出走"

所以第一步不是"更努力地盯着它"，是把它从我的窗口里弄出去。

我做了一个小工具，名字叫 runjob。

它干的事只有一件：把一个任务从我当前的窗口里摘出去，让它挂在机器上，而不是挂在我的窗口上。

原来的关系是这样：

我的窗口
  └── 任务
        └── 任务派生的子任务

现在变成：

机器
  └── 任务（跟我的窗口没有父子关系）
        └── 子任务

区别就是：我关窗口，机器不关。任务照跑。

"挂在机器上"到底是什么意思？

意思是这个任务不再是谁的儿子，它直接被机器收养了，自己就是一棵树的根。 我的窗口关不关，跟它没有关系。

换个说法：以前它是"我家里请的钟点工"，我不在家它连门都进不来；现在它是"外面雇的施工队"，我在不在家，它都在工地上干。

技术上的做法不重要，重要的是我给自己定了一条规则：凡是超过几分钟的活，一律用这个方式起。 起完我就能关窗口、能走人、能开会。

这条规则的关键不在"用这个方式"，在"凡是"。

如果写成"重要的活用这个方式"，那我每次都要先判断一次"这件事重不重要"。而人在忙的时候，这个判断的答案永远是"不重要，先这么跑吧"。

写成"凡是超过几分钟"，就没有判断了。凡是，就是不用想。

而且每个任务的状态都落在一个固定位置（跑没跑完、输出去哪、成功还是失败），换一个窗口打开，照样能看到上一个窗口起的东西。

这里说的"状态落在一个固定位置"，说白了就是：它把"我干到哪了"写在一张纸上，放在一个固定的抽屉里。

抽屉的位置是死的，谁都能去拉开看。所以哪怕我换了一个窗口，哪怕第二天再来，只要打开那个抽屉，就知道昨天那件事到底怎么样了。

这一点比"能不能后台跑"更重要。 一个任务跑起来了但你看不见它，那不叫解放，那叫失联。

改法二：不靠"我记得"，靠"它拦我"

上面这条规则定完之后，我照样会忘。

我会顺手用最普通的方式起一个后台任务——因为快，因为就在手边。

这不是我意志力的问题，是人的默认设置。

任何一件事，如果有一条"随手就能做"的路和一条"要按规矩来"的路，人在赶时间的时候一定走随手那条。这跟品德无关，跟当时手上有多急有关。

所以后来我不再问"我怎么才能记住"，我改问"我怎么才能忘不掉"。这两个问题看着像一回事，答案完全不一样。

所以我又加了一道拦路的闸：每次我要起后台任务的时候，程序先检查一句：

这个是"离家出走"的方式起的吗？不是？拦下。

被拦下来的时候，它会告诉我该怎么改。这不礼貌，但有用。

这是我在这本书里最想强调的一个转变：
一条规则，如果只写在纸上，它一定会被忘记。
只有变成"忘不了"——要么机器替你记住，要么机器不让你做错——它才是真的。

这句话里的"机器不让你做错"，技术上叫钩子。

名字很形象：它就是在你某个动作发生的那一瞬间，挂上去的一个钩子。你要开门，钩子先勾住你一下，检查你有没有带钥匙。

钩子不跟你讲道理，也不管你今天心情好不好。它只有两个结果：放行，或者拦下。

这也是它比"写进制度"强的地方。 制度是写给人看的，人可以不看；钩子是挂在动作上的，人绕不过去。

改法三：同时开几路，我在旁边看着

上面两条解决的是"活不会死"。第三条解决的是"我一个人只能干一件事"。

我的做法是：把主对话当成调度台。

"调度台"这个词你可能不熟，我说个更熟的：机场塔台。

塔台自己不飞飞机。它只干三件事：哪架飞机走哪条线、几点起飞、出了状况叫谁去处理。真正在天上飞的是飞行员。

我坐在主对话里，就是这个角色。我不写代码，我派活。

我在这里只说三件事：要做什么、做到什么算成、谁来干。 剩下的活，派出去，几个方向同时跑。

比如 2026 年 11 月 1 日这一天，我同时开着：

• 一路在查"淘宝上卖 AI 服务到底能不能赚钱"（后来结论是不能，见第 21 章）
• 一路在盘"我这一年多到底用了哪些 AI、花了多少钱"
• 一路在查"企业到底要办哪些证照"（分五个方向并行去几个部委官网找）
• 一路在写代码

这四路互不干扰，因为它们各自在不同的地方干活，谁也不改谁的文件。

"谁也不改谁的文件"这半句，是并行能不能成立的唯一条件。

不是"我觉得它们没关系"，是"它们真的不碰同一张纸"。这两件事差得很远——我一开始就是按"我觉得没关系"来判断的，然后撞了墙。

这就是"并行"和"瞎忙"的区别：并行要求事情之间没关系；有关系的事必须排队，不然就会互相踩。

我在这件事上踩过一次很疼的坑：两个窗口同时改同一个文件，谁也不知道对方在改，最后一个人的活白干。

为什么"白干"？因为两个窗口各自拿着自己那一份在改。谁先存、谁后存，后存的那份会把先存的整个盖掉。

它不会报错。 它会很安静地把你刚干的活变成零，然后显示"保存成功"。

这一类事情有个共同点：它不吵。 出错会吵，覆盖不会吵。所以它比出错更危险。

所以后来我给自己定了一条：同一个文件，同一时间只许一个人碰。

改法四：它在干活，我在外面也能收到消息

前三条解决的都是"活能不能自己干下去"。这一条解决的是"我和它之间那根线断没断"。

活派出去以后，有一个新问题：出事了谁告诉我？

我人可能在饭桌上、在银行柜台前、在开车。这时候它要是卡住了，我不能等晚上回家打开电脑才知道。

如果它干到一半卡住——比如要密码、要授权、要做一个只有我能做的决定——它不能干等着，等我回来看到。

所以我把公司用的企业微信接上了。规则是：

• 卡住了（需要我本人）→ 立刻发消息到我手机，写清楚"卡在哪、需要我做什么"
• 跑完了 / 失败了 → 发消息
• 不需要我做主的，不许发——不许拿"我做完了"这种事来吵我

这里的学问全在"发什么"上。

一开始我让它什么都报。结果一天几十条，我很快就不看了。

这不是我懒。这是所有告警系统都会走到的同一个结局。

人对重复的信息会很快失去反应——第一次收到"卡住了"你会立刻处理，收得多了你会扫一眼，再多，你连扫都不扫。

而一旦你开始不看，这个通道就死了。 它还在发，你还在收，但它已经不传递任何信息了。

一旦你不看，告警就等于没有。

后来我把标准改成：只有"需要我做决定"和"整件事结束了"才发。 中间的过程一律不发，我自己想看的时候去翻。

这两条背后是同一个判断：发一条消息的成本，是我的一份注意力。

"我做完了"这件事，我迟早会知道，不差这一条；"这里要你说句话"这件事，我不看就一直卡着。所以一条消息该不该发，看的不是它有多重要，是它晚一点知道会不会出事。

还有一个更狠的细节：我要求它发完以后要回头确认一下消息真的发出去了。 因为发送工具会返回"成功"，但那只是"我提交了"，不等于"你收到了"。

这个动作叫回读。意思是：发完之后，再用另一个动作把"已发送"那头翻出来看一遍，确认它真的在那儿。

打个比方：你把信投进邮筒，邮筒不会告诉你信到没到。回读就是"过一会儿去收件人的门口看一眼，信在不在"。

只做发送、不做回读的系统，会给你一种虚假的安心。 它每天都显示"已通知"，而你什么都没收到。

这两件事，跟第 9 章的"假绿"是同一个病。

都是"动作发生了"和"事情成了"被混成了一件。

我在外面的时候，到底发生了什么

我把这一天的实际情况说清楚：

我在电脑前的时间，大部分花在判断上——这条路要不要走、这个方案对不对、这笔钱值不值得花。

至于"写代码""查资料""跑数据""比对文件"，这些我全派出去了。

注意这条分界线：判断留在我这里，劳动派出去。

我判断"这条路要不要走"，它负责把这条路铺出来给我看。铺得对不对，我不看过程，我看结果。

而派出去以后，我不需要守着看它跑。 我去干别的事，它跑完或卡住会告诉我。

这是我个人使用 AI 最本质的变化：从"我操作它"，变成"我安排它"。

前者，我是那台机器的操作员，必须人在机器前面。
后者，我是那个人的老板，只需要在关键节点出现。

老板不需要守在工位上。

这句话说出来很轻，做到不容易。因为"操作员"是有即时反馈的——你按一下，它动一下，你很有掌控感。

而"老板"是没有即时反馈的。你派完活，接下来几个小时什么都不知道。那种"不知道"，会让人忍不住回去看一眼。

我后来学会的是：看一眼可以，但别守着看。 守着看不会让它更快，只会让我自己干不了别的。

这一章想让你记住的一句话

本章出处（可核对）

AI 真正拉开差距的，不是它在你面前有多快，是它在你走了以后还能干多久。

如果你也这样，你该注意什么

• 你上一次关掉电脑、关掉窗口的时候，手上有没有在跑的活？ 如果有，它十有八九已经死了。
• 超过几分钟的活，一律"派出去"，不要"看着它跑"。 你守着它，就是把自己降级成了一个监视器。
• 告警只发两种：要你做决定的、整件事结束的。 其他的，都会让告警失效。

素材出处

• 后台任务工具与状态目录：~/.claude/tools/runjob.py、~/.claude/jobs/<id>/
• 拦截闸：~/.claude/hooks/no_fragile_bg.py；CLAUDE.md §3.2
• 被自己的窗口杀掉、连孙进程一起杀：CLAUDE.md §3.2
• 调度台与并行纪律：CLAUDE.md §6.4「任务分叉分派协议」（含 2026-09-23 两次实战）
• 企微通知与回读确认：CLAUDE.md §3.5 三条通用纪律第 1 条
• 2026-11-01 当日四路并行的产物：资产\32_能力盘点\AI服务卖家线_调研与可行性_20261101.md、AI使用史_DeepSeek时间线_20261101.md、企业经营证照许可全集_20261101.md

第 17 章 · 说到目标，就不用管了

上一章解决的是"活不会死"

但它没解决另一个问题：活干完了，算不算干对了？

这两件事差别很大。"活干完了"说的是过程结束了；"干对了"说的是结果对得上。 过程结束很容易，结果对得上很难。

而且我这种人最容易在这上面吃亏：我不写代码，看不懂它交上来的东西。它说"做完了"，我除了信，没有别的办法。

我原来的做法是：它说"做完了"，我信。

后来我发现这句话根本不值钱。做完了、做错了、假装做完了——在它嘴里是同一句话。

这句话听起来像在骂它，其实不是。它说的是：形容词没有信息量。

"做完了"是一个形容词。形容词的特点是——说的人不用负责，听的人没法核对。

我做了半辈子审计，最烦的就是这种话。审计里有一句话：没有凭证的结论，等于没有结论。

于是我改了规则，改成下面这样。

规则一：你要进我的队列，必须先交一条"验收命令"

先说"队列"是什么。队列就是排队的地方。

你把活交进去，它不会立刻开始，而是按顺序一件一件做。为什么要排队？因为同时干三件事，三件都干一半，最后一件都不能用。

排队还有第二个作用，这个更重要：进了队列的活有记录。 什么时候进来的、谁在干、干到哪一步、为什么停了——这些都在纸上，不靠谁记性好。

什么意思？

假设我要它做一件事：把银行回单读成表格。

它必须同时交给我一条命令，这条命令跑完，只有两种结果：通过，或者不通过。

比如："拿这 22 张真回单跑一遍，21 张以上金额正确，就算通过。少于 21 张，不通过。"

交不出这条命令，这件事就不许进队列。

这条命令有三个讲究，缺一个就废：

第一，它得能自己跑。 不是要我去点、去看、去判断，是敲一下回车，屏幕上出来一个结果。

第二，它得用真东西跑。 22 张真回单，不是我自己编的几张样例。拿自己编的样例跑，等于自己出题自己答。

第三，它得有个数。 "21 张以上"是个数。没有数的验收标准，最后一定会变成"看起来差不多"。

这条规则改变了什么

它把"做完了"从一句形容词，变成了一道算术题。

算术题的好处是：它不认人。

一道题，谁算都是那个答案。它不会因为出题的人级别高就变简单，也不会因为答题的人辛苦就放宽。

这就是我要的东西——一个不看我面子、也不看它面子的裁判。

• 原来的流程：它干 → 它说做完了 → 我信 → 我抽空看一眼 → 发现不对 → 重来
• 现在的流程：它干 → 它自己跑验收命令 → 通过才算完 → 不通过接着改 → 三次改不好就停下叫我

关键在"它自己跑"这三个字。 不是它说"我认为能通过"，是那条命令真的跑一遍，结果贴出来。

我不看它的解释，我看命令的输出。

这一条我建议你直接抄走，因为它是整本书里最省钱的一条。

解释是可以编的，输出编不了。 它可以跟你说"我已经修好了，原因是某某"，说得头头是道；但那条命令跑出来缺几张，就是缺几张。

你不需要懂代码，你只需要看得懂"通过"和"不通过"。

规则二：队列要写清楚五件事

我把这个做成一个排队的地方。每件事进去要填五项：

这五项里头，最容易被我跳过的是第二项。"目标是什么"跟"做什么动作"是两回事。

"把这张表改成能筛选"，是动作。
"我想一眼看出哪些客户很久没下单"，是目标。

写成动作，它做完就完了；写成目标，它才会去想"这样改到底解决没解决问题"。

最后一项也别省。"要不要我本人拍板"这一栏，其实是在替我划红线： 哪些事它自己定，哪些事必须停下来问我。

不写这一栏，结果就是它要么什么都不敢干，要么什么都敢干。两个极端都不对。

为什么要规定状态，而不是让它自己说？因为状态是可以数的。

一个东西能不能数，决定了你能不能用它管事情。"进展顺利"不能数，"排队中 / 正在干 / 干完了"能数。

进去以后，它的状态只会在这几个之间走：

排队中 → 正在干 → 干完了
              ↘ 失败了
              ↘ 卡住了（需要我）

"卡住了"这个状态是专门为我设的。 它一进这个状态，我手机上就收到消息——不是"出错了"，是"这里要你说句话"。

这两个说法差得很远。

"出错了"的意思是：它搞砸了，等我发落。
"要你说句话"的意思是：它干到这儿干不下去了，因为这儿需要一个人的判断，而那个人是我。

前一种我帮不上忙，后一种只有我能帮。 把它们分成两件事，我才知道哪次该起身。

我逼它承认的三件"我以为很聪明其实很蠢"的事

做一个自动干活的东西，最容易死在几个不起眼的细节上。这三个都是真踩过的：

第一，我叫它的时候叫错了名字。

我一直敲的是 claude，程序就照着这个名字去找。结果发现机器上真正的文件叫 claude.cmd——带个后缀。程序找不到，直接崩。

打个比方：你让人去"找老张"，人家按门牌号去找，发现门上写的是"老张（东屋）"。

人是会自动补齐的，机器不会。你给它一个字，它就去那个字的地方找；多一个字、少一个字，它都说"没有这个人"。

这件事听起来很小，但它说明一件事：我脑子里那个"能跑的样子"，和机器上真实的样子，经常不是一回事。

第二，我跟它说的第一句话，它没收到。

我习惯一次写一大段要求。结果它只收到第一行，后面的全丢了。因为它接收那段话的方式，是把话放在一条"命令"里传过去，而那条命令有长度限制，超了就截断。

而我完全不会知道这件事发生了——它照样开工，只是不知道自己要干什么。

这个坑最阴的地方不是"丢了"，是"丢了但不报错"。

它收到的第一行，往往只是整段话的开头；后面"要做到什么程度""注意哪些坑""别动哪些文件"，全没了。

于是它干得很认真，方向完全不是我想要的。

截断是不会报错的。 没有红灯，没有提示，只有一个看起来很正常的结果。

第三，它接到活以后，先被别的事情带跑了。

每开一个新的工作会话，系统会往里塞一堆通知：有新版本了、有新消息了、有个提醒。这些通知对干活的人是有用的，但对"领了活就闷头干"的场景，是干扰。

有一次它就跟着一条通知跑了，回头我还以为它在做我交代的事。

这不是它不听话，是"注意力"这个东西本来就会被抢。

你想象一下：一个员工刚进办公室，桌上已经压着几张别人留的便条。他会先看便条。看完便条，他才想起今天自己是来干什么的——有时候就想不起来了。

所以现在我在交代任务的时候，第一句就必须写：跟这件事无关的通知，全部忽略。

这一句看着像客套话，其实是唯一的解药：我不能阻止别人往桌上放便条，我只能先告诉它"今天只干这一件事"。

这三件事的共同点

它们都不是"程序写错了"，是"我以为它会那样，其实它不那样"。

这一整本书，讲到底都是这件事。

我把这三件事摆在一起，是因为它们看着毫无关系：一个是文件名，一个是长度，一个是通知。

但它们死的是同一个地方：我以为。

我以为它叫 claude，我以为它收到了全部，我以为它在干我的活。这三个"我以为"，我一个都没验过。

后来我养成一个动作：凡是我"以为"的地方，都当成一个待查项。 不用一次查完，但要知道自己在猜。

这一章想让你记住的一句话

本章出处（可核对）

不要听它说"做完了"，要它交出一条你自己也能跑一遍的验收命令。交不出来，就是还没想清楚。

如果你也这样，你该注意什么

• 下次派活之前，先写一句"怎么算做成了"。 写不出来，说明你自己也没想清楚。
• 验收要看结果，不看解释。 它说"已经修复了"没有意义，"这 22 条跑出来都对上了"才有意义。
• 别一次交代五件事。 一次一件，做完就验。

素材出处

• 队列工具：~/.claude/work/queue/；~/.claude/work/README.md
• 没有验收命令进不了队列：CLAUDE.md §3.2「无人值守开发队列」
• 三个坑：同节，CLAUDE.md §3.2 踩过的坑 ①②③
• 卡住发企微：notify_wenge.py（腿A + 回读确认）

第 18 章 · 干到 60%，它自己换人

前面两章，解决的是"活怎么干"

但还有一个瓶颈，是我一开始完全没想到的：跟 AI 说完一段话，是有上限的。

这是我最没预料到的一堵墙。前面那些问题，都是"怎么把它用好"；这个问题的性质不一样——它不是用得不好，是用到一定程度，就没法往下用了。

你可以理解成：一次对话能装的东西是有限的。装满了，它就记不住前面说的了。 轻则答非所问，重则直接中断。

这个东西有个名字，叫上下文。

你可以把它想成一张桌子。我说的话、它查到的东西、它干过的活，全都摆在桌面上。桌面就那么大。

桌面满了会怎样？不是"桌子塌了"，是新东西摆上来，旧东西被挤到地上。 而且是从最边上的开始挤——最边上的，往往正是我一开始交代的那些规矩。

我这边的情况是：一次对话装到 60% 左右，质量就开始往下掉。

不是它变笨了，是我交代过的规矩、踩过的坑、正在做的事，被越挤越远。而这件事是完全静默的——我看不出来。

这是我最怕的一类问题：不是"坏了"，是"慢慢变差"。

坏了你会去修；慢慢变差，你只会觉得"今天它怎么不太行"。然后你会归因到别的地方去——型号不对、网络不好、自己没说清。

我一开始的应对很土：快满了，我自己写一段"上次干到哪、接下来干什么"，复制粘贴到新窗口。

问题有两个：

1. 我看不出来什么时候快满了（状态栏有数字，但我在专心干活的时候根本不看）
2. 就算看出来了，我也会想"等这个弄完再说"——然后就没然后了

这两条你大概都眼熟。它们不是"不知道怎么做"，是"知道了也不做"。 后面所有的机制，都是冲着"知道了也不做"这几个字去的。

第一次尝试：提醒我

我先做的是提醒。到一定程度，系统弹一句：该换窗口了。

没用。

记录里写得很直白：某个会话被催了两次（10:30、10:41），照样接着干。

这两个时间点挨得很近：催了一次，过了一会儿又催一次，两次都没停。

这件事让我明白一个我一直不愿承认的道理：提醒对"正在专注的人"是无效的。

不是不听话，是脑子在那个状态里，会自动把"打断"排到最后。

这句话不只对 AI 成立。

对我自己也成立。 手机弹出"该休息了"，通常会被我按掉；日历提醒响了，也常常过了点才想起来。

所以后来我给 AI 设计规矩的时候，会先问一句：这条规矩，对我自己有效吗？ 如果对我无效，我就不该指望它有效。

第二次尝试：强制它换

既然靠提醒不行，那就不靠提醒，靠机制。

现在的做法是这样：

第一，我不到现场也能让交接发生。 我在外面做事的时候，如果手上这件事还没干完，我照样发新任务——系统会把我的话先存进一个"待办纸条"，不执行，并告诉我"先把手上的交完"。

这样我不用怕自己想不起来，也不用怕它把我的新要求扔了。

这个设计解决的是一个很具体的矛盾：我脑子里冒出新想法的时候，往往正是手上这件事干到一半的时候。

以前我只有两个选择：要么打断手上的活去说新的，要么憋着，然后忘掉。现在有第三个：说出来，存着，等手上的完事再用。

第二，到了线，它自己会动手。 不是等我点头，是到点就自己切换——新任务进来会被先拦下存起来，只许做一件事：写交接文档。

第三，最狠的一层：不交接，就不许干别的。 除了写交接、读文件，其他动作一律被拒绝。它想接着干活，系统不让。

这一层是整套东西里唯一"不讲道理"的部分，也是最管用的部分。

因为它不再依赖任何人的自觉。 不管是我还是它，到线了就只能做一件事。

我原来总觉得"强制"这个词不好听，像是在防贼。后来想明白了：我防的是我自己在关键时刻的侥幸。

交接文档，是这套东西的核心

这里有个关键：换了人，活不能断。

先说"交接"是什么意思。就是一个人下班，把手上没干完的活，交给下一班的人。

公司里天天发生这件事。但公司里有交接班记录本，我们这里没有——如果不写下来，下一班的人只能从头猜。

所以交接文档不是"我干完了"的一句话，它必须写清楚七件事：

1. 现在是什么状态
2. 做到哪一步了（每条都要能指到一个文件）
3. 下一步第一件事是什么（要具体到"打开哪个文件、写第几章"）
4. 试过但没成的路
5. 踩过的坑
6. 关键文件的绝对路径
7. 老板原话

这七条是有分工的：前三条回答"我现在在哪"，后三条回答"你接手要知道什么"，第 4 条回答"你别再走一遍我走过的死路"。

第 2 条那个括号，分量最重。 因为"我做完了登录"这句话没法验；"登录的代码在某个路径下的某个文件里"，能验。

能指到文件，才叫做到。指不到的，只能叫"我认为做过"。

第 4 条是我后来加的，因为它是唯一能省下真金白银的一条。

你想：新来的人最怕什么？最怕把已经失败过的路，从头再走一遍。

而"失败过"这件事，如果你不写下来，它就消失了——因为它的痕迹只有一个：那件事没做成。而没做成的事，在记录里是没有的。

这句话值得停一下。

我们所有的记录，都只记录"发生了什么"。 会议记录记的是开过的会，日志记的是跑过的任务，账本记的是发生的交易。

没发生的事，一个字都没有。

而"我试过这条路，走不通"——恰恰是一件"没发生的事"。它没有产物，没有日志，没有凭证。它只存在于那个试过的人的脑子里，而那个人（明天的我）也快忘了。

所以我现在要求：交接文档里必须有一节叫"试过但没成的路"。

而且这一节要写清楚三样：试的是哪条路、走到哪一步断的、断在哪。

只写"试过了不行"，等于没写——下一个人还是会去试。

这一章有个硬标准，而且是我用真实数据定的

这套标准是这么来的：我把过去存下来的 105 份真实的交接文档拿出来算了一遍——

字数中位数 10,292；二级标题中位数 9 个；具体路径中位数 5 个；验证痕迹中位数 10 处。

我是拿真实数据定的标准，不是拿想象定的。

这两句话看着像一回事，其实是两回事：一个标准可以"合理"，也可以"符合现实"。 合理是我觉得对，符合现实是数据说它对。

这里我用的是中位数，不是平均数。

区别在哪？平均数会被极端值拽跑。 一百份文档里如果有一份写了三万字，平均数立刻被拉高，然后所有正常的文档都被判不合格。

中位数是"排好队站中间的那个"。它代表的是"典型的一份长什么样"，不是"最好的一份长什么样"。

第一版我写的是"必须 8 个绝对路径"，结果一跑，把一大批写得很扎实的文档误判成不合格——因为很多人只在开头写一次项目根目录，后面就不写了。

后来改成分档要求，才既不放过草率的，也不冤枉认真的。

这件事的教训：拍标准之前，先看真实数据长什么样。

这句话我后来写进了自己的规矩里，因为它已经害过我三次。

这三次错的是同一类：先假设，再验证。顺序反了。

同一个坑反复踩，说明它不是手滑，是习惯。而习惯是改不掉的，只能拿一个"到点就必须看一眼数据"的动作把它盖住。

最疼的一次事故

这套东西不是一次做对的。

中间出过一次事故，是我自己造成的：我同时开着两个窗口，都用了这套自动交接。结果 A 窗口要换人的时候，B 窗口也被一起重启了，B 里正在做的活——上下文被 A 的交接顶掉了。

原因很简单：当时的做法是把"要换人了"这个信号，存成一个所有人共用的文件。

两个窗口都读这个文件，都以为是在叫自己。

"信号"在这里就是一张通知条。问题是：这张通知条贴在了公告栏上，没写收件人。

公告栏谁都能看。A 窗口写的"该换人了"，B 窗口也看到了，B 以为在叫自己。

这就是事故的全部原因。不是技术难，是没写收件人。

教训一句话：凡是"信号"，都必须有明确归属，否则谁都以为在说自己。

这句话后来被我推广到很多地方：公告、通知、告警、任务，凡是发出去的东西，都要能回答"这是给谁的"。

答不上来，它就一定会送错人。不是可能，是一定。

现在的做法是：每个窗口开张的时候就领一个唯一的编号，所有状态、所有信号、所有交接文档，都放在以这个编号命名的目录里。别的窗口物理上读不到，就不可能串台。

这个做法说白了就是：不贴公告栏了，改成一人一个信箱。

每个窗口有自己的信箱，只有自己能开。别人写的信，物理上到不了我的信箱里。

还有一个我不会绕过去的细节

换人的时候，要把正在跑的后台任务也处理好——第 16 章说过，关窗口会把这些任务一起杀掉。

所以换人之前要先问一句：手上还有活没跑完吗？

判断的方法有点笨但管用：先记下此刻所有的子任务，等 15 秒，还活着的才算真在跑。

为什么用"等一会儿再看"，而不是直接查一下进程表？

因为"活着"和"还在干活"不是一回事。有些任务刚起手，还没干出什么名堂，但它确实是要干很久的。

等一会儿再看，是最笨也最准的办法：真的在干的，过一会儿还在；已经结束的，过一会儿就没了。

（按"它跑了多久"来判不行——一个刚起 5 秒但要跑两小时的任务，会被误杀。）

有活没跑完，就先不换，进入"封笔期"：只补交接文档，不接新活。等它跑完再换。

"封笔期"这个词是我自己起的。 意思很直白：笔放下了，不再写新东西，只把已经写了的整理好。

这段等待不是浪费，是止损。 强行切断一个跑了两小时的任务，损失的是两小时；等一会儿，损失的那点时间微不足道。

但绝不无限等——超过 30 分钟，就把没跑完的任务写进交接文档，然后换人。

这一段是我写完这本书最想推荐给同行的做法：宁可多等 30 分钟，不要凭感觉去杀一个正在干活的进程。

这一段我建议你抄下来，贴在看得到的地方。因为人有一个很顽固的冲动：看到"好像卡住了"，就想重启。

重启是最解气的动作，也是最贵的动作。 它让你觉得问题解决了，实际上你把证据一起销毁了。

这一章想让你记住的一句话

本章出处（可核对）

交接文档里最值钱的，不是"我做了什么"，是"我试过什么但是没成"。

如果你也这样，你该注意什么

• 你上一次换工具、换会话、换项目的时候，回来还能接着干吗？ 如果需要花半天回忆，你需要一份交接文档。
• 交接里必须写"失败的尝试"。 不写，下一个人（包括明天的你）会重走一遍。
• 别用"提醒自己"来管理一个人的工作。 提醒对专注的人是无效的，只有机制有效。

素材出处

• 机制与档位：CLAUDE.md §3.2「自动换会话」
• 提醒无效的实证（会话被催两次仍接着干）：CLAUDE.md §3.2「强制换会话 + 存档期」
• 105 份真实文档校准：CLAUDE.md §3.2「交接详细度判据」；模板 资产\00_交接\_模板_交接文档.md
• 2026-10-30 串台事故：CLAUDE.md §3.2 末条
• 封笔等待与 15 秒观察窗口：CLAUDE.md §3.2

第 19 章 · 39 个水龙头，和一根没接通的水管

前面三章，讲的都是"怎么干得更多"

这一章讲一个相反的事：我干了很多，但主线没通。

"主线"这个词得解释一下。

一个系统，不是一堆功能的集合，是一条从头走到尾的路。 比如工资：排班 → 打卡 → 算薪 → 出清单 → 发钱。这几步连起来，才叫一条主线。

功能是路上的站点，主线是路本身。站点修得再漂亮，路没接上，货还是运不出去。

反过来也成立：路先通了，哪怕站点很简陋，事情也能办成。 这就是为什么我后来允许自己先做很丑的版本。

那天晚上的情况

2026 年 10 月 30 日，晚上。

我在做一个给公司自己用的系统——餐饮行业的用工核算：门店排班、考勤、算薪、客户签认、开票、回款。

那天晚上的成果汇报是这么写的，我原文摘下来：

39 个页面全部接上了列头筛选，代码检查 0 错误，打包全绿。

这是我想要的"感觉好"的样子。 每一页都能点，每个表格都能筛，代码检查挑不出毛病。

"代码检查 0 错误"这句，外行可能没感觉。它大致等于"这份作业一个错别字都没有"。

错别字是零，不代表文章写对了。语法全对的一句话，可以是完全不相干的一句话。

然后我让人去跑一条真实的业务：

一家门店排好班 → 打卡 → 算薪 → 生成代发清单 → 导出给银行。

结果卡在"导出代发清单"这一步——导不出来。

注意这一步的位置：它不是第一步，是最后一步。 前面排班、打卡、算薪全对，最后一步断了，整条路等于零。

再往下查，问题不是一个，是一串：

• 253 个人，没有银行卡号。 没有卡号，钱根本发不出去。
• 个税算出来了，但报不出去。 数字在系统里，走不到对外申报的那条路。

这两条你可能觉得是"数据没准备好"，不是系统的问题。

恰恰相反。 一个系统如果连"这个人有没有卡号"都不问一句，它就等于不知道钱要靠卡号才能到人。

这不是数据缺，这是系统没要求。

换个说法：它允许你把一个根本收不到钱的人，算进一张要发钱的清单里，并且一路显示成功。

我当时是什么感觉

你装好了 39 个水龙头，还把每一个都擦得锃亮，回头发现水管根本没接上。

这个比喻我想再往下说一层，因为它解释了一件很多人想不通的事：为什么做的人自己没发现？

因为水龙头是有反馈的。你拧一下，它亮一下。 每做完一个页面，你能看见它、能点它、能截图给人看。

水管没有反馈。 水管埋在地里。它接没接上，你得拧水龙头的时候才知道——而你可能很久都不拧那一次。

而且更难受的是：这 39 个水龙头，每一个都是"完成"的。 每做完一个，我都收获一次满足感。

那个"水没通"的问题，从头到尾没有给过我一次提醒。因为它不是一个"做错了"，它是一个空洞——没有东西的地方，不会报错。

这句话我想标出来，因为它是这一整章的核心。

错误会喊，缺失不会喊。

你写错一个数，系统会报错；你压根没写这个数，系统很安静。所以"没做"永远比"做错"更难被发现。

而一个项目里最要命的问题，几乎全是"没做"，不是"做错"。

这不是第一次

最让我难受的，不是犯错，是同一个错，我三天内犯了两次。

三天前，我写过一份方法论文档，里面明确写着一条：「横切的功能（筛选、样式、权限、报表）顺序反了」。

我写了，然后我又犯了。

因为我把它写成了文档。而文档不会拦人。

"文档不会拦人"这句话，是我这一年多里最贵的一课之一。

文档是什么？是"希望别人记得"。 而希望，是靠不住的。

我这一年写了大量的规矩、清单、注意事项。写的时候都很有道理，但真正改变我行为的，从来不是这些字，是后来加的那些"拦路的闸"。

我改了什么

这一次我没写文档，我改了两件事。

说"两件事"，其实是五条。前两条是判断标准，后三条是执行方式。 下面一条一条说，你可以只挑一条抄。

如果只抄一条，抄第一条。

一、一条判据，每次动手前问

现在做的这件事，是让主流程更通，还是让某个环节更好看？

后者，排队。

这条判据简单到有点土，但它管用，因为它把"选择"从"判断"变成了"照念"。

以前我问的是"这件事重要吗"——这个问题的答案永远是"重要"，因为每件事单独看都重要，于是什么都做，主流程一直没通。

现在我问的是"这件事排在哪"——有比较，就有先后，就不会什么都做。

这里有个更深的道理："重要吗"是一个没有上限的问题，"排第几"是一个有上限的问题。

排在第一位的事只能有一件。一旦你只能选一件，"重要"这个词就失效了——因为每件事都重要，而排第一的只能有一个。

二、定死"什么叫走通了"

我以前对"走通了"的标准，是"我点得下去"。

现在三条，缺一不可：

表里第 3 条那个"进回归"，得解释一下。

回归测试，就是"把以前验过的所有事，做成一串能自动重跑的动作"。 每次改完，按一下，全跑一遍。

为什么需要？因为你改 A 的时候，很可能顺手把 B 弄坏了。而 B 坏了不会当场报错，要等到某一天有人用到它的时候才发现。

有了回归，改完按一下，几分钟就知道自己有没有闯祸。 没有它，你就是每天在赌。

第 2 条是我最看重的。

我做了一辈子审计，最熟的一句话是：自己算的账，不能证明自己没错。 审计要有第三方。系统也一样——系统的输出，必须被一个跟系统毫无关系的算法重算一遍，一分钱都不能差。

具体怎么做？不用再买一套软件，最土的办法就行：拿原始数据，用表格软件或者干脆手算，算出一份结果，跟系统算的比。

对不上，就查；查到对上为止。

重点不是"再算一遍"，是"用完全不同的方法再算一遍"。 用同一个公式算两遍，只会得到同一个错误，而且会让你更放心。

三、每一环还要过五道勾稽

算钱这件事，只要有一环对不上，最后一定是错的。所以我给每一环定了五道检查：

第 E 条是为了防我自己骗自己。 演示数据跑得通，不代表真数据跑得通——第 10 章那 1.6 万的账就是这么来的。

这五道我用的都是审计里的老办法。做审计的人有个习惯：任何一个数，都要能回答"你哪来的"。

答不上来的数，我们叫"野数"——它可能是对的，但你没法证明它对。而在钱这件事上，"可能是对的"等于不能用。

这五道你不用全抄。但 B 和 C 两道，我建议所有做业务系统的人都抄：金额对不对、条数对不对。

这两条查不出全部问题，但能查出绝大多数问题，而且不需要懂技术。 一个老板，会看合计、会数人头，就能当半个质检。

四、还有一个更根本的改变：切片

以前我做系统的思路是"分模块"：先把用户模块做完，再做门店模块，再做薪资模块。

这个思路的问题是：每一块单独做完，都是"完成"，但系统一次都没完整跑过。

现在的做法改成：每一片，都必须是一条能从这头走到那头的完整业务。

这个思路，行话叫"能走路的骨架"。先有最小但完整的一套，能站住，再往上长肉。

反过来做——先把一条腿做得完美，再做另一条腿——你最后会有一堆漂亮的零件，和一个站不起来的人。

比如要做的第一步不是"设计数据库"，而是：

一家门店、一个员工、一天班、算出一笔钱、生成一张能导出的清单。

丑没关系，功能少没关系，它必须是完整的、能演示的、能算对的。

这一条可能跟你习惯的做法相反。

我们做事的习惯是"先把最难的啃下来"——把最没把握的那块先解决，心里才踏实。

但"完整"和"难"是两回事。 一个系统能不能从头走到尾，跟它有没有难点无关，跟它有没有断点有关。先啃难点，很可能只是先啃掉一个做得很漂亮的死胡同。

通了，再加第二家门店、再加第二个人、再加考勤异常、再加个税。

始终保证：手上这个系统，任何一天都是能完整跑一遍的。

这句话还有个副作用：你每天都有一个能拿出来给人看的东西。

不是"等全部做完再演示"——那个日子永远不会来。

五、还加了闸

光有规矩不行，第 18 章说过——只有变成"忘不了"，才算数。

所以现在有一个检查：如果一个项目还没有一条跑得通的完整流程测试，就不许派"改界面"的活。

想绕过，得写明理由，而且会被记下来。

注意这里用的是"不许派"，不是"不建议"。

这一年我最大的转变就是这个：从"我提醒我自己"变成"系统不许我"。 第 16 章那道闸、第 18 章的强制交接、这里这道闸，是同一个东西的第三次使用。

这一章的真正结论

做系统最难的不是把功能做出来，是判断"先做哪个"。

而这个判断，我原来一直在做错，而且错得毫无痛感——因为做错了也就做错了，没人会告诉你"你现在做的这些，其实一点用都没有"。

唯一能告诉你这件事的，就是那条完整的业务流程。跑不通，就是没做完；跑通了，才轮到好看。

最后说一句我自己也没完全做到的事。

"先做哪一步"这个判断，到现在我还会错。 区别是：以前错了没人告诉我，现在错了，很快就会被一条跑不通的路拦住。

我不指望自己不犯错，我指望错误早点暴露。

还有一句：这套东西不是给"要求高的人"准备的，是给"忘性大的人"准备的。

我就是那个忘性大的人。规矩写得漂亮不难，难的是让它在你想不起来的时候，替你站着。

这一章想让你记住的一句话

本章出处（可核对）

先把一条路从头走到尾，再考虑把路修宽。路没通就修路灯，是最贵的浪费。

如果你也这样，你该注意什么

• 你现在手上这件事，是一整条能跑通的业务，还是一个"完成"的零件？ 是零件，就先去接通那条线。
• "做完了"的标准要写死。 "能点开"不是标准，"从头到尾跑一遍，数字对得上"才是。
• 别自己证明自己。 系统算出来的数，要用另一套完全独立的方法再算一遍。

素材出处

• 2026-10-30 当晚情况与后续规矩：记忆 main-flow-first（~/.claude/projects/C--Users-65514/memory/main-flow-first.md）
• 规矩全文：资产\37_专家化工作法\00_新系统开发第一页.md
• 机器闸：~/.claude/tools/batch_guard.py（项目里没有通过的完整流程用例时，派"改界面"的活会被拦）
• Walking Skeleton 概念：Alistair Cockburn, 1996；切片方法：Elephant Carpaccio
• 餐饮用工系统本身：CLAUDE.md §3.7（https://meal.silinhome.com）

第 20 章 · 到底省了多少时间

前面十九章讲的都是"怎么做到的"

这一章回答一个所有人都会问的问题：这么干，到底快了多少？

"我开发时间缩短了 60%"——这句话谁都能说，而且谁也没法反驳。

正因为没法反驳，它就是一句废话。

我说个更直白的："效率提升 60%"这种话，你听完能干什么？

不能干什么。它不告诉你这件事该不该做，不告诉你该投多少钱，也不告诉你别人做不做得到。

一个不能拿来做决定的数，就是一个装饰品。

我不打算在这本书里说这种话。所以这一章只回答一个问题：我到底该拿什么跟什么比？

三种比法，只有一种不算吹牛

比法一（最常见，也最没用）：跟"没有 AI"比。

"以前这件事要请三个程序员干三个月，现在我一个人三天干完，效率提升 90 倍。"

这种比法不能用。 原因很简单：没有 AI 的那些年，我根本没做这件事。 我没请过三个程序员，也没有那笔预算。所以"省下的"不是我花的钱，是我从来没有过的钱。

这种算法唯一的作用，是让卖课的人显得很厉害。

我把这条写进书里，是想让你在别处听到"效率提升 90 倍"的时候，第一反应是问一句：分母是什么？

分母说不清，这个数就不用往下听了。

比法二（好一点）：跟"我自己以前的开发节奏"比。

这个能算，但有干扰：越往后我越熟练，越往后工具越好，"快了"里面有多少是机制带来的、有多少是我变熟练了，分不开。

比法三（我最后采用的）：拆开算，一项一项算。

不问"总共快了多少"，只问这三件事各自省掉了多少：

这三种时间，恰恰是"一个人干活"最致命的三种时间。

一个团队不怕这些，因为人多、有分工、有人盯着。一个人干，这三种时间会把你的日历吃光。

这三条我用大白话各说一句：

等待的时间——点了火，得站在锅边看着它开，走开就怕糊锅。
重做的时间——菜炒糊了，从头切菜。
空转的时间——你以为锅在烧，其实火早灭了。

一个人做饭最怕这三种，一个人干活也一样。

第一组事实：这套东西有多大（全部现场数出来的）

拿第 19 章那个餐饮用工系统当样本，逐项数：

不写代码的人看这张表，可能不知道这些数意味着什么。我换个说法：

数据库表 129 张 = 这个系统要记住 129 类东西。人有姓名、身份证、银行卡，各是一类；一张排班、一笔工资，也各是一类。

后端接口 265 个 = 界面上每点一次，背后得有一个"办事窗口"接住。265 个，就是 265 个办事窗口。

59 个页面 = 人在屏幕上能看到的 59 个画面。

这三样加起来，才叫一套能自己记事、自己算账、还能给人用的系统。

约 18 万行产品代码，另有 12 万行测试与工具。 这不是"一个网页"，这是一套有后端、有三端界面、有数据库、有自动测试的系统。

这里有个细节值得停一下：测试代码 55,382 行，差不多是产品代码的三分之一。

很多人听到这个会觉得浪费——功能都写不完，还花三分之一去写"检查功能对不对"的东西。

因为检查是唯一能防止"改坏了而你不知道"的手段。 没有回归，你每次改动都是在赌：赌这次没碰坏别的东西。

赌久了，总会输一次。而系统里的那一次，往往是客户先发现。

第二组事实：做了多久

7 个日历日，10 月 26 日到 11 月 1 日，每一天都有文件落盘。

表里"当天落盘文件数"是什么意思？

就是那一天，硬盘上新增或修改了多少个文件。 文件被改、被建、被删，时间戳都会留下痕迹。

这是一个不会说谎的数——它不记录"我觉得我干了多少"，只记录"硬盘上真的动了多少东西"。

顺带一句：这张表不是一路往上涨的，中间有高有低。这反而说明它可信——真干活的记录总是有起伏；一条太平滑的曲线，多半是事后填的。

11 月 1 日 11:15，它以试用环境的形式上线，外部可以访问。

这里有一件我必须写进书里的事：

我去查版本记录，想看看"第一天写了什么"。结果发现——这个项目只有在 10 月 29 日才有两条提交，第一条的说明是"首次纳入版本控制（现状快照）"。

也就是说：前三天，它是在没有版本管理的情况下开发的。

我在第 6 章花了很大篇幅讲"改之前先存一份"，讲我为此白干了几个晚上。结果我自己做这个项目的时候，前三天还是没存。

这件事我犹豫过要不要写。

因为它把这本书的调子拉低了——前面十九章我一直在讲"我建了什么机制、定了什么规矩"，这一条讲的是"我自己第一个没做到"。

但我还是写了。 因为不写这一条，前面那些机制看起来就像是自然而然有的。不是。每一个机制，都是先有一个人在那里栽过，才长出来的。

这条我不想删，因为它是这本书里最真实的一段：知道一条道理，和做到，之间隔着一整套机制。

第三组事实：它是在什么时间做出来的

我把和这个项目相关的 AI 工作记录数了一下：518 个会话、22 份交接文档。

再看那些交付记录的时刻，覆盖了一天里的 16 个不同小时，其中凌晨 0 点到 6 点有 5 条。

凌晨两点、三点、五点，都有交付。

这不是我熬夜熬出来的——那时候我在睡觉。这是"我把活派出去，它自己接着干"的直接证据（第 16、17 章）。

这句话的分量我想说清楚。

凌晨有交付，证明的不是"我很拼"，是"这台机器在我睡觉的时候还在生产"。

一个人的产出，原来是被"醒着的时间"卡死的。现在这条线断了。

这一组数字，比任何百分比都有说服力。

因为它记的是痕迹，不是主张。主张可以吹，痕迹吹不出来。

现在算账：正常该花多少人月

我不拿"没有 AI 的时代"当对照组（那是编的）。我用的是行业公开基准：

《2024 年中国软件行业基准数据》（北京软件造价评估技术创新联盟发布，28,599 套项目数据）：

• 全行业软件开发生产率中位数：6.83 人时/功能点
• 一个月折算：174 人时
• 北京开发人月费率：32,129 元/人月

按这套东西的实际产物反推功能点，约 1,780 个功能点（这个数是按国际通行的功能点计数规则估的，误差通常在 ±30%）。

代入：

1,780 功能点 × 6.83 人时 ÷ 174 人时/月 ≈ 70 人月

70 人月，也就是将近 6 个人干一年。

这里有两个词得先解释，不然下面这些数你没法判断真假。

人月：一个人干一个月，叫一个人月。70 人月 = 一个人要干 70 个月，或者 6 个人干一年。

为什么用这个单位，而不用"多少钱"？因为钱会变，工作量不太会变。 它是行业里衡量"这活到底有多大"的通用尺子。

功能点：不是代码行数，是"这个系统一共有多少个不同的功能"。它跟你用什么方法写、写得好不好看没有关系，只跟"要做多少件事"有关系。

用功能点，是为了能跟别人比——因为行数可以注水，功能不太能凭空变出来。

三条独立线索互相印证，都落在这个量级：

保守口径：同类系统常规投入约 40–70 人月。

三条线索里，只有第一条是我自己算的，另外两条是外面公开的工期和报价。

为什么要找外面两条？因为我算的数，只有我自己信。

三条独立的路走到同一个数量级，这个数才站得住。如果三条差出十倍，那说明我的估法有问题，我得回去重算，而不是挑对我最有利的那条用。

那到底省了多少

这里有一个记录里没有的数：我那 7 天，本人到底投入了多少劳动时间。

我只能估：每天在场 10 小时，7 天，共约 70 小时。

但要把话说准：这 70 小时是"在场"，不是"在干活"。

那 10 个小时里，我要做饭、吃饭、睡午觉、上厕所，一样没耽误。真正手指头落在键盘上的时间，比 70 小时少得多。

我故意拿 70 小时这个对我最不利的分母来算——等于假设我全程满负荷、一分钟没走神。

这句话得再强调一次，因为它决定了这个倍数是"上限"还是"下限"。

如果真实投入比 70 小时少，倍数会更高；取 70 小时，就是往大了估分母——分母越大，倍数越小。

换句话说：分母已经按对我最不利的方式取了。下面是没打折的毛数，打完折才作数。

6,960 ~ 12,180 人时 ÷ 70 小时 ≈ 99 ~ 174 倍

先别急着高兴。 我知道这个数不老实，所以自己先给它打两个折：

• 第一个折：这套系统的完成度不是 100%，按五折算
• 第二个折：功能点是我自己推的，可能虚高，再按最保守的那一档（40 人月）算

打完两个折：3,480 人时 ÷ 70 小时 ≈ 50 倍。

保守区间：50 到 87 倍。

打两个折这个动作，我建议你养成习惯。

任何一个让你兴奋的数，先自己砍一刀，再砍一刀。砍完还站得住，它才是真的；砍完就没了，它本来也没有。

而一个愿意自己砍两刀的人，说出来的数才有人信。

为什么我不写"快了一百倍"

三个原因，一个比一个实在：

第一，完成度不是 100%。

81 项回归全过，是事实。但我自己的记录里同时列着 7 项已知缺口：灵工手机端还不可用、生产环境的配置没做、银行卡和实名是仿真数据、银行报盘通道没接、补发冲正没接回盘、门户的"本期应付"口径待定、报表里"在册 49,422 人"和员工管理的 600 人对不上。

行业基准对应的那个"人月"，指的是能交付生产的系统。我这个严格说不完全对等。

"能交付生产"大概等于三件事：别人拿去能直接用、出了问题有人兜、数据是真的。

我这个是能跑、能演示、主流程能通，但上面那三样，还差着。

差着就是差着，不能说成"基本完成"。

第二，功能点是我自己推的，不是第三方评的。

±30% 的误差。真要拿去跟人辩论，得请第三方做一次正式计数。我不会拿一个自己估的数去当卖点。

第三，基准数据我是从公开检索摘要里拿的。

官方发布页我抓到了，但那份 PDF 原件抓取失败。所以这个数只能标"据公开报道"，不能标"我逐页核对过"。

这一条是我做审计留下来的毛病：凡是引用的数，都要能说清来源等级。

亲手数过的，是一级；公开可查的二手转述，是二级；听说的，不能用。

写进书里的东西，我要让人能查。查不到的，我就自己标出来。

所以这一章真正的结论是什么

不是"快了 60%"，也不是"快了一百倍"。

我一开始自己估的是"缩短 60%"。算完发现，这个估法本身就错在分母上："缩短 60%"说的是"同样一班人干得更快"，而我这里发生的是"原来根本不会启动的事，现在一个人启动了"。这两件事不能用一个百分比放在一起比。

这里我想解释一下，因为它是这一章真正的账眼。

"缩短 60%"的前提是：这件事本来就会做。 同样一队人，原来干得慢，现在干得快，那叫缩短。

而我这里发生的是：这件事本来不会做。 没有 AI，我不会去请一支程序员队伍做一套餐饮用工系统——不是不想，是不会。

所以准确的说法不是"快了"，是"从零到有"。 这两件事没法用同一个百分比衡量，因为起点不一样。

是生产方式的改变。

原来这件事，是一个 5 到 8 人的团队干 4 到 7 个月。现在是一个人干 7 天，而且这个人白天在开会。

而且真正被我拿回来的，不是"写代码的时间"，是那三种时间：

一个人干活，最贵的从来不是手速，是这三种时间。它们不会出现在任何工时表里，但它们会吃光你的日历。

最后说一句关于"卖点"的话。

这套数我不会拿去当卖点。 我在书里写它，是因为它能帮你重新判断"一件事值不值得做"；我不拿它去招商，因为它经不起第三方核。

一个数用在什么地方，比这个数本身更能说明人的成色。

补一个三天做完的样本

同一段时间我还做了另一个东西：北京中考/高考的考点诊断 App。

• 10 月 17 日立项 → 10 月 20 日完成，约 3 天
• 题库 18 个科目库、6,178 道题，每一道题都配了完整解题卡（考点、思路、分步、正确答案、干扰项、易错点），6,178 道全覆盖
• 同时做了 App 端、后端、数据看板

但它的上架进度是零——这一点写在第 23 章，也是这本书里"做得出来 ≠ 卖得出去"的最好例子。

把它放在这一章的最后，是想说清一件事：做得快，和卖得出去，是两本完全不同的账。 这一章算的是第一本。

最后给你一个自检：如果你算出一个连自己都觉得夸张的倍数，先别高兴，先去找分母。 找得到、说得清，这个数才有资格写进汇报；找不到，就把它留在自己的笔记本上。

这一章想让你记住的一句话

本章出处（可核对）

别问"快了多少倍"，先问"分母是谁"。比错了对象，算得再准也是吹牛。

如果你也这样，你该注意什么

• 别拿"如果请个团队"来算你的效率。 那是你没花的钱，不是你省的钱。
• 算"省了什么时间"比算"快了几倍"有用。 等待、重做、空转——这三种时间才是一个人真正的瓶颈。
• 任何倍数，先问分母。 分母说不清楚，这个数就是宣传。

素材出处

• 表数/接口数/页面数/代码行数/回归结果：D:\Data\Desktop\代码仓库\shiwo-core\meal_lab 现场统计；回归结果 tests\_last_run.json（81/81/0）
• 页面数 39 / 5 / 15：WORKLOG.md 第 277253 行
• 7 个日历日与逐日落盘文件数：文件时间戳统计；上线记录 WORKLOG.md 第 277200 行
• ★ 前三天没有版本控制：git log -- meal_lab 仅 2 条提交，均为 2026-10-29
• 518 个 AI 会话 / 22 份交接文档：本机会话记录统计、资产\00_交接\
• 7 项已知缺口：WORKLOG.md 第 276932 行起
• 行业基准：北京软件造价评估技术创新联盟《2024 年中国软件行业基准数据》（数值来自公开检索摘要转述，PDF 原件抓取失败，未逐页核对）
• 同类系统工期对照：NextPage IT、Vertinus 公开报价
• 功能点估算（1,780 FP，±30%）：按 IFPRI 规则从 129 表 / 265 接口 / 59 页面反推，属推算，非第三方评估
• 考点诊断 App：WORKLOG.md 第 271912、274290 行；题库实计 18 个科目库 / 6,178 题

第六部 · 商业化（最疼的一部）

前面二十章讲的都是"我怎么做出来的"。
这一部讲的是：做出来之后，为什么没赚到钱。
这一部全是失败的。之所以放进来，是因为失败比成功有用。

第 21 章 · 我试过但没赚钱的

上一章刚算完"我快了多少倍"

这一章要泼一盆冷水：快，不等于赚。

上一章算的那笔账，是我现在干一天，顶得上过去干几天。那笔账是真的，我自己核过好几遍。

但效率和生意是两码事。效率高的人做错了方向，只会更快地把错的事情做完。

这就是为什么我把这一部放在最后。前面讲的本事都是真的，只是它们到这一刻为止，还没变成钱。

这些年我试过的变现路子，一张表全在上面：

这张表我列的时候很难受。

八行里，七行是我真的动过手、真花过时间的；剩下一行（直播卖课代卖），是我算清楚之后主动没碰的。

它写在这里，是因为这几行我都赔过时间。赔过的东西才写得准。

这张表你最好倒着看：先看最后一列的数字，再看第一列的名字。

因为名字都很诱人，只有数字会说话。

这张表上最不愿意写的一句话

在说这句话之前，我更容易说的是另外三句：市场太卷了、时机不对、大环境不好。

这三句都对，但它们都不解决问题。因为它们说的都不是我的问题。

这些方向，我大部分不是"市场上没人做"，而是"我一个人做不成这个生意"。

这是两件完全不同的事。

前一句在说市场，后一句在说我自己。

承认前一句很轻松，承认后一句很难受，因为后一句意味着：我下次换个方向，同样的坑还会再踩一遍。

市场有需求 ≠ 你能拿下。一个方向能不能成，取决于四件事是不是同时成立：

1. 有需求
2. 你有不可替代的能力
3. 获客成本低于客单价
4. 交付能规模化

这四条，我用大白话各说一遍——

有需求，意思是已经有人在为这件事掏钱，不是"我觉得应该有人需要"。

你有不可替代的能力，意思是客户换掉你要付代价。他不换你，不是因为喜欢你，是因为换你太麻烦。

获客成本低于客单价，意思是你为了找到这一个客户花的钱，要小于这个客户给你的钱。这一条最要命，因为前面几条是加法和减法，这一条是乘法。

交付能规模化，意思是你接第二个客户，不用把活重新搭一遍。

你可以拿自己手上任何一个方向对一遍。四条里你能有十足把握说"是"的，通常不到两条。

四条里缺一条，你都赚不到钱。

而我这几年试的路子里，几乎每条都缺一条，而且缺的往往是第三条——获客成本低于客单价。

为什么这一条最难

因为前两条你能自己判断，第三条要等钱花出去才知道。

• 有需求？查一查就知道
• 你有能力？照照镜子就知道
• 获客成本低于客单价？得真花钱打一遍才知道
• 交付能规模化？得真接十单才知道

看出来了吧：前两条坐在办公室里就能想明白，后两条要出门才能知道。

而人最喜欢干的，就是在办公室里想前两条。因为想前两条不花钱、不丢人，还容易得出让人高兴的结论。

这里有个自查的办法，很简单：你上一次为某个方向花钱，花在了"验证"上，还是花在了"准备"上？

如果是准备——做网站、做图、写文案、印资料——那就是把钱花在了自己已经相信的事情上。

所以"我这次能不能成"，本质上是一个"我还不知道"的问题。

而人在"不知道"的时候，最容易做的一件事就是：先干起来，边干边看。

这句话听着很励志，但它是我这几年最大的浪费来源。因为"边干边看"的代价，是你在投入之后才发现缺的那一条。

"边干边看"为什么会骗人？因为它把最贵的一步放在了最前面。

做产品、做图、写文案，这些动作看着都像在推进。可它们验证的全是前两条，而前两条本来就不用验证。

我后来复盘，发现自己最常用的一个说法是"先做出来再说"。

这五个字听着像执行力，实际含义往往是：我还没想清楚哪一步最可能死。

一个反过来的判断法

后来我改了一个习惯：不先问"这事能不能成"，先问"这事要是成不了，最可能是死在哪一条"。

然后先花最小的代价，去验证那一条。

比如做闲鱼卖服务，最可能死在"客单价太低、获客成本太高"。那我不该先做商品图和文案，我该先去查：这个品类现在的真实成交价是多少。

查完我就知道该不该做了——不用做五十个商品才发现。

这个顺序一换，省下的不是几天时间，是整个项目。

因为验证一条"最可能死"的信息，往往一个下午就够；而做五十个商品，是几个月。

你自己也可以试一次。把最想做的那个方向写下来，在四条里圈出你最没底的那一条，然后问自己：验证它，要花多久？

如果答案是"一天之内"，那就先去验。别先做产品。

这个方法叫"先验证最可能死的那一条"，比"先做起来看看"省得多。

这一章想让你记住的一句话

本章出处（可核对）

判断一个方向值不值得做，不看"市场多大"，看"我这条四条里缺哪条"。缺的那条补不上，市场再大跟你没关系。

如果你也这样，你该注意什么

• 把你手上的方向，套进那四条里打分。 缺两条以上的，别做。
• 先验证"最可能死的那一条"，别先做产品。 产品是最贵的一步，别拿它当调研。
• "边干边看"只适合验证成本很低的事。 需要投钱、投人、投三个月的，先查再做。

素材出处

• 各行数字：资产\32_能力盘点\AI方向_外部证据库_20261101.md（13 节，130+ 条带出处数据）、AI方向_最终结论_20261101.md、创业代办方向研究_20261101.md、资产\41_淘宝运营专家\AI服务卖家线_调研与可行性_20261101.md
• 闲鱼卖家月均 897 元：记忆 xianyu-expert-base-v2
• 应用市场上架为 0：资产\43_App上架现状\现状.md

第 22 章 · 四千封信，换来三个真人

上一章是"试过但没赚到钱"

这一章单挑一件事讲透——邮件获客。

先说清楚这是个什么生意。邮件获客，就是找一批可能买你东西的人，把邮箱凑成名单，批量发信，指望有人回你。

它是最老的一种找客户的办法，老到有点土。但它有个巨大的好处：不需要你认识谁，不需要投放预算，也不依赖任何平台分流量给你。

我选它，一部分原因就是这个——前面所有的失败，都是因为流量攥在别人手里。

现在回头看，这个理由只对了一半。渠道攥在自己手里，不等于客户攥在自己手里。渠道只是路，路上得有人。

因为它是我投入最大、技术上最成功、生意上最失败的一件事。 它把"能力"和"结果"这两件事，分得比任何例子都清楚。

写这一章之前，我先承认一件事

我把所有记录翻了一遍，包括我自己记忆里那些"效果不错"的说法。

结论跟我的感觉不一样。

感觉里，这套东西是"能跑通的"；记录里，它是"跑通了，但没用"。

这两句话只差一个逗号，可它们之间隔着我一整段白费的功夫。

所以这一章我按原始记录写，不按印象写。

这套系统是怎么搭起来的

它不是一个邮件客户端，是一条流水线，全部跑在新加坡的服务器上，不在我自己的电脑上（原因：我的电脑会关机）：

"流水线"这个词听着唬人，其实没什么。它就是五个小东西，各干一件事，按时间点自己醒过来，干完接着睡。

第一个负责往外发。第二个每十五分钟去邮局取一次信，取回来分四堆。第三个盯着其中一堆，判断"这是人写的还是机器写的"。第四个看着退回来的信有没有变多。第五个不干活，只负责让收件方相信我们。

"送达认证"这三样，是我在这条路上学到的第一课：

不是你发了，别人就收得到。 现在全世界的邮箱都会先看"这个发信人是不是真的有资格代表这个域名"。三样配不齐，你的信直接进垃圾箱，而发信端会告诉你"发送成功"。

这三样我用大白话解释一下：它们相当于给这个域名办了三张身份证明。

一张证明"这台机器有资格替这个域名发信"，一张给每封信盖一个只有我们和收件方能验的章，还有一张是公开告诉全世界"谁冒充我，你就把他拦下来"。

办了这三张证，你的信才有资格进收件箱；没办，你连被拒绝的通知都收不到。

这又是一个"假绿"（第 9 章）。

那到底发了多少、回了多少

我把记录里所有能查到的批次都列出来，一条不省：

退信率 13% 到 20%，这个数字本身就是一个结论：名单的质量，比邮件的文案重要得多。

什么叫退信？就是信根本没送到——地址不存在、域名注销了、对方服务器不收陌生来信。它退回来，你还能知道；更多的时候它连退都不退，直接进垃圾箱，安安静静地消失了。

而十几二十个点的退信率意味着什么？意味着我手上这份名单，有相当一部分是凭猜测拼出来的。

那些地址看着都像真的，有名字、有域名、格式一丝不差。可发出去才知道，里面有一部分根本不存在。

所以这一行数字翻译过来是：还没开始谈生意，先有六分之一的人查无此人。

而回复率 0.46%、真买家 0.07%——一万封里七个真的。

这句话我想再说一遍：一万封信发出去，真正会像买家一样跟你聊两句的，七个。

真的带来业务结果的，一共三个

第一个：义乌两家工厂。

其中一家从 alvis@donbellighting.com 回了信。然后我们加了微信。

然后就没有然后了。 没有报价、没有样品、没有合作。加了微信以后，这条线索在记录里再没出现过。

当时我以为加微信是个进展。后来才明白，它只是把"一个陌生人"变成了"通讯录里的一个陌生人"。

真正推动生意的是下一步动作——报价、寄样、约时间。这三样一个都没发生，那加了微信和不加，结果是一样的。

第二个：加拿大一个中文学校。

这位是真的在回信，而且回了不止一封。他还给了我最有价值的一条反馈：他说我们的语速偏快。

我去实测，他说得对。他还说明年 5 月他们那边要考口语，以中高级为主——这是我这些年拿到的最真实的一条业务线索。

然后呢？他自己试了三次，三次都被麦克风权限挡住了，一份报告都没生成。

麦克风权限，就是浏览器右下角弹出来的一个小方框，问你"允许使用麦克风吗"。点一下"允许"，就好了。

他三次都卡在这儿。要么是没找到那个按钮，要么是点了拒绝，要么是他们的电脑本来就不让开麦克风。

他是我最该服务好的一个客户，而他连产品都没用上。

这件事最扎人的地方在于：我在自己电脑上永远测不出这个毛病。 因为我这台电脑早就点过一百次"允许"了，那个小方框在我这儿根本不出现。

后来我想明白一件事：我把力气全花在"报告怎么做得好看"上了，却没管"一个第一次来的人，能不能打开它"。

第三个：俄罗斯一所大学。

圣彼得堡的一所大学，汉语中心，回了三次信，每次都写"很感兴趣"。

然后卡在——她打不开我们的链接（境外访问我们新加坡那条线路的问题）。

我们的服务架在新加坡，她那边要跨一大段很远的网络才能连上。这段路上只要有一段不稳，她看到的就是一个转圈的白页。

一个链接打不开，前面所有的诚意都作废了。 这不是夸张——站在她那一边看，一家外国公司发来的东西点不动，最合理的反应就是关掉。

我回了五封。球在她那边，她再没回。

一个说了三次"很感兴趣"的人，最后不是被话术挡走的，是被一个打不开的页面挡走的。

这不是销售问题，这是工程问题。而工程问题，我本来是修得了的。

还有两个"人"，但算不上结果

• 瑞士一个人：完整答完 3 道题（用时 271 秒），而且后来又做了一遍。这是唯一一个真跑通产品体验的外部用户。没有付费，没有留联系方式。
• 马来西亚一所中学：点开了一套 27 题，一题都没答，直接看了报告。

瑞士这位值得多说一句。271 秒，答三道题——这不是随手点一下，这是真的坐下来用了。 而且他还回来做了第二遍。

这说明产品本身是能用的。 能用到什么程度？能用到"有人愿意照着同样的过程再来一遍"。

这句话很值钱，也很没用。值钱是因为它证明了产品不是废的；没用是因为它一分钱也没换来。

马来西亚那位更有意思。27 道题，一题没答，直接翻到报告——他不是来测自己的，他是来看我们长什么样的。

顺便说三个"看起来很好的假数字"

这三个数字，当时看着都挺让人高兴。我后来逐个核对，全是假的：

一、"打开率 100%"。

我做过 48 封的实验，全部显示"已打开"，回复 0 封。后来查时间戳：22 次打开全部发生在发出后 5 到 40 秒内。

那是收件方的邮件网关在预先扫描邮件里的图片——不是人打开。

这里的原理不难：邮件里可以塞一张看不见的小图片，图片从我们服务器上加载一次，系统就记一次"打开"。

所以"打开率"量的是"那张图被加载了几次"，不是"谁看了"。

而邮件网关会先把每封信拆开、扫一遍图片、检查有没有病毒，扫的时候那张图就被加载了。五到四十秒，正好是机器扫描的节奏。

二、"落地页今天 201 次访问"。

我逐条核对来源：命令行工具 26 次、测速网站 17 次、谷歌 15 次、微软 30 次……真人 1 个，还是疑似我们自己的爬虫。

这里面每一类"不是人"的访问，来路都不一样：有的是我自己在服务器上敲命令测通没通；有的是网上那些测速网站，它们会把你的网址输进去看一眼多快；还有的是各种邮箱和搜索引擎的预览程序。

它们全都算一次访问。

三、"外部独立 IP 落地 89 个，7 个点了开始"。

再往下核：真正答过题的，0 个。

注意这个漏斗塌在哪儿：89 个"独立的人"，7 个愿意点"开始"，0 个真的答。 每往下走一格，都掉一大截。

如果这是一门真生意，我应该在这一格上停下来查原因。可当时我高兴的是 89 这个数。

我一度把这三条当成"有流量了"。

这是我这几年吃过的最大的自我欺骗——因为它是免费的自我欺骗，不需要任何人配合你，你自己就会信。

这三条有个共同点：都是机器弄出来的，而且都长着人样。

我在这一章里想留一句判据给你：一个数字，如果不需要任何人配合就能变大，它大概率和人无关。

还有一个被瞒了四天的故障

义乌那两家工厂回信以后，我的手机一条通知都没收到。

为什么？

因为我那套"收信自动处理"的程序，只处理发信记录里有的地址。义乌这一批发信时没写进记录表，于是回信进来了，程序看了一眼，不认识，跳过了。

这两封信在系统里躺了四天。

我后来是另外写了一个"排除法"的看门狗才发现的——它的逻辑很简单：凡是我认不出来的，都当成人来信推给我。宁可多推，不可漏推。

这里有个值得记住的道理：原来那套程序不是坏了，它是在严格按规矩办事。

它的规矩是"只认名单上的人"。白名单思维在平常日子是对的——它挡掉了绝大部分噪音。可一旦出事，出事的定义恰恰就是"来了个名单上没有的"。

所以我后来把判据反过来写：凡是我认不出来的，先当人处理。

推错了，我损失三十秒看一眼；推漏了，客户在那边等四天。

这条规矩后来被我搬到了很多别的地方。凡是"系统自动过滤"的地方，我都会多问一句：它过滤掉的那些，我有没有机会知道？

这跟第 9 章是同一个病：系统认为"没我什么事"，于是什么都没发生。而真实世界里，客户正在等你回信。

所以这一章到底想说什么

我不打算把这一章写成"我们的邮件系统很成功"。

它技术上是一条完整的、能自动跑、能自证送达的流水线。 这一点我很有底气——因为送达认证配到了满分，因为有人真的是从手机邮箱点进来看的。

但它在生意上，不成立。

四千封信，三个真人，零成交。

原因不是信写得不好，也不是技术不行。是这条路的数学本身就不通：

• 回复率 0.46%，意味着要拿到 100 个回复，得发 2 万封
• 真买家 0.07%，意味着要拿到 100 个真买家，得发 14 万封
• 而我一个人，一个邮件账号

这三行你连起来读一遍，就知道问题在哪了。前两行是除法，第三行是上限。

一个账号一天能发多少封，是有天花板的——发猛了，对方服务器直接把你当垃圾邮件发信人。所以这条路的瓶颈不在我努不努力，在分母。

这不是努力能补上的差距，这是量级上的差距。

而"量级"这两个字，是中年人最容易忽略的两个字。我们习惯的是"再加把劲"，可当一件事差的是量级的时候，加把劲等于没加。

如果重来一次，我会在发第一封信之前，先花半天把这个除法算完。

算完就不会发了。这就是第 21 章那个方法的实际用法——先验证最可能死的那一条，而死的那一条，往往是一个除法。

这一章想让你记住的一句话

本章出处（可核对）

"打开率 100%"和"客户真的来了"，中间隔着机器、网关和垃圾箱。做生意的第一件事，是把机器的动静从人的动静里分出来。

如果你也这样，你该注意什么

• 看数据先看来源 IP。 一个"访问量"里，机器可能占九成。
• 回复率低于 1% 的渠道，不要加量，要换路。 加量只是把同一件不成的事做大。
• "送达"和"看到"是两件事，"看到"和"需要"又是两件事。 三个都要过，缺一个就白干。

素材出处（全部可核）

• 发信/收信/看门狗：sg:/opt/hq/saudi_trade_hub/
• 各批次数字：WORKLOG.md 第 50833、211361、252148、269219、274442、272095、274552 行
• 义乌两家工厂与妆烨灯饰加微信：WORKLOG.md 第 184673、184785 行
• 加拿大刘杭（语速偏快、麦克风挡住 6 次）：WORKLOG.md 第 269617、269664–269730、269760–269800 行
• 俄罗斯大学卡在链接打不开：资产\00_交接\20261007_汉语口语_推广复盘与两大待办.md §3
• 瑞士真人答完两次、马来学校点开 27 题答 0：WORKLOG.md 第 269262–269279 行
• 三个假数字：WORKLOG.md 第 51057、52785、75649、274395、267753 行
• 被瞒四天：WORKLOG.md 第 184609–184721 行
• 送达认证：资产\31_邮件域名认证\；20261007_汉语口语_推广复盘与两大待办.md §4.1
• 独立站真实询盘 0 条：WORKLOG.md 第 245570 行

第 23 章 · 备案拿到了，一个都没上架

上一章讲邮件，这一章讲 App

我一直以为，我离"上架"很近。

近到什么程度？东西是真做出来了，能跑、能用，我自己每天都在用。所以在我心里，剩下的只是"提交一下"。

真去办的时候才知道，这里面有两件完全不同的事，而我只做成了一件。

这两件事是什么

第一件：让这个东西"合法存在"。（备案）
第二件：让它"能被别人下载到"。（上架）

这两件事，中间隔着一整条资质链。

先用大白话说清楚这两个词。

备案，是向主管部门登记"这个东西是谁做的、放在哪台服务器上"。办完会给你一个号，就是你在很多网站底部看到的那一串"京ICP备……号"。它解决的是：你能不能合法地对外提供服务。

上架，是让各家应用商店同意收录你，让别人搜得到、下得下来。

打个比方：备案像是给房子办产权登记，上架像是让商场同意你进场摆柜。 房子登记完了确实是你的，可商场让不让你进，是另一回事。

做成了的那件：备案

2026 年 10 月 15 日，四个 App 拿到了备案号：

这个号你可以这么读：前面那一长串是"主体"，也就是公司或我个人的备案号，四个 App 共用；后面的 -5A、-6A 是"这是第几个"。

一个主体，多个应用，就这么排下来。

而排到第几个，本身说明不了任何事。它只说明这些材料是在同一天交上去的。

后来又过了两个（宠物管家、一款汉语口语 App），还有一个（考点诊断）卡在填表第 4 步。

这一步是实打实的进度。但也只是"拿到了准生证"，不代表孩子能出门。

没做成的那件：上架

截至我能查到的最后一份记录（2026-10-26），我的 App 在中国任何一个应用市场，上架成功的：0 个。

不是没办，是卡在三个地方：

卡点一：开发者账号不齐。

应用宝（腾讯）实名通过了——这个我自己复核过。华为的通过了（这一条是别人告诉我的，我没独立验证过）。小米、OPPO、vivo，一个都没注册。

开发者账号，就是你在每一家应用市场开的"商户号"。 注册要交主体材料、要审核，每一家各办各的，办一家不算办完。

中国有五个主要的安卓市场，这就是五道门，五道门都要单独敲。

五道门，每道门都要交一遍材料、等一遍审核。这就是为什么很多人敲到第三道门就不敲了——不是过不去，是耗不起。

卡点二：应用宝上 5 个应用建好了，但存不进去。

卡在"版权证明"这一项。 基础信息填完了，点保存，不进去。

版权证明，就是证明"这个东西是你的"。 商店怕的是有人拿了别人的 App 来上架，所以这一栏必须堵死。

堵死是对的。可它把我这种自己写代码的人，也一起堵在了外面——因为证明"这是我的"，有时候比写出来还难。

卡点三（真正的硬墙）：软著。

这一条我要单独讲，因为它不是一个技术问题，是一道我签不了的字。

软著，全称软件著作权登记。它是官方给你发的一张证，证明这套代码归你。 应用市场要它，是为了确认"你有资格处置这个软件"。

2026 年 3 月 15 日起，软件著作权登记用了新版申请表。签章页上有一句话，必须由申请人亲手抄写：

「本软件确系人的独立开发，未使用 AI 开发编写代码、撰写文档或生成登记申请材料。」

我的代码，是 AI 写的。我的说明书，是脚本生成的。

这句话我签不了。 签了就是失实，失实的后果是进版权登记失信名单、上个人征信——这不是罚款，这是我个人信用上的一个污点，不可逆。

我说清楚这两个后果有多重：

失信名单，是行业里公开挂着的一份"不诚信记录"，以后你再去办任何一类登记，人家第一眼就看到它。

征信，是你去银行借钱、办卡、做担保的时候，对方调出来的那份记录。

罚款是钱的事，掏了钱就过去了。这两个不是——它们是"以后办什么都变难"的事。

所以六件软著，全部在提交前冻结了，签章页的 PDF 已经物理移走，放进了"勿提交"的目录。

为什么要"物理移走"？因为只要文件还在那个待提交的目录里，就存在有人手滑点一下的可能。对付"手滑"，最有效的办法从来不是提醒，是把东西挪到你够不着的地方。

这是我第一次遇到一个"不是钱能解决"的障碍。

钱的障碍有个好处：它能算出数。你需要三万还是三十万，筹得到就过去了。可这一条，你有钱也没用，因为它要的是一句真话，而真话不在你这边。

后来我学到的东西（这一段最有用）

被卡了以后，我没有一直在原地想办法"怎么蒙过去"。我去查了正规的出路，学到三件事：

第一，软著不是唯一的证明。

市面上有"电子版权认证"这条路，一件六百块，没有那条 AI 承诺条款。材料已经备好，但需要我本人实名加付费，至今没执行。

花这笔钱买到的是"不用签那句话"，光这一条就值。

这一步我拖了很久。 原因说出来很没面子：它要求我本人刷脸、本人付钱，机器替不了。

我这几年最擅长的就是"让机器替我做"，而这件事恰好是机器替不了的。

而凡是"必须我本人到场"的事，都会被我自动排到最后。 这是我这几年一个很要命的习惯。

第二，顺序不能倒。

备案和上架是有先后依赖的。备案一次只允许有一个进行中的订单（这是平台的硬规定），所以办的时候必须排队，不能并行。

这意味着一件很反直觉的事：我手上 App 多，在这条链上不是优势，是排队。

五个 App 就是排五次队，每一次都得等前一个下号。

凡是"有顺序"的事，最贵的不是每一步，是等。 而我一开始完全没把"等"算进时间表。

第三，真正的门槛从来不在技术。

我一开始以为上架是"打包上传"这种技术活。不是。 它是一整套资质链条：主体资格 → 备案 → 著作权证明 → 各市场开发者资质 → 内容合规。

这条链上任何一环卡住，前面做得再好都出不去。

这五环里，只有最后一环跟代码有关系。前面四环，全是纸。

那"推广成绩"呢

我把记录翻到底了。这一块我必须说实话，因为不说实话这本书就没价值：

这张表怎么读，我给你一个方法：先看有没有"有数据的会话"，再看登录数。

因为"登录过"和"用过"是两件事。有人登进来又走了，等于没来。

智能师爷那行就是例子：119 条登录，0 个有数据的会话。119 次"进来看看"，没有一次是真的用。

推广动作我确实做过： 发了 18 篇内容（今日头条 6 / 百家号 6 / 公众号 6），猪八戒上了 3 个案例，做过 SEO，发过四千封邮件。

但转化是零。 发的内容在大模型里的"被引用率"是 0%。

"被引用率 0%"是什么意思？就是有人去问 AI 一个相关问题，AI 回答的时候，一次都没有引用过我写的东西。

我写那 18 篇，本来是指望 AI 在回答里"顺带提到我"。结果一次都没有。

18 篇，0 次。这意味着我连"最轻的那个门槛"都没过——不是没卖出去，是压根没被找到。

还有一类数字，最伤人，也最值得写进书里：

2026 年 10 月 18 日，一个页面显示"外部落地 185 次"。

我逐条核对来源：

185 次访问，1 个人，可能还是我自己。

怎么核对？就是去看每一次访问留下的"来源"和"身份"痕迹：这次是从哪个程序来的、用的是什么工具、IP 属于谁。

查完你会发现，那些数字里绝大部分连"人"这个前提都不成立。

所以我到底做成了什么

这一章我不想写成励志故事，因为中年人不需要励志，需要的是准确的形势判断。

准确的说法是：

我把"从零做到能用"这件事跑通了八九遍，并且把"让它合法存在"这条路走通了大半。
我没有跑通"让人来用"和"让人付钱"。

前者是工程能力，后者是获客能力。我这些年练的全是前者，后者几乎没练。

这两种能力的练法，完全不一样。

工程能力可以关起门来长——你对着电脑，想清楚、试、改，一个人就能进步。我这一年十个月长的全是这个。

获客能力必须出门才能长——你得跟真人说话，被拒绝，被放鸽子，被误解。这件事我没怎么做，因为它难堪，而关起门来写代码不难堪。

这不是安慰，这是诊断。

诊断清楚了，药就好配了。怕的是把病因判错——以为是自己技术不够、或者运气不好，那就再练几年也还是这样。

说这些不是为了自我批评。是因为我发现一件事：中年人最大的风险不是能力不够，是能力配错了地方。

把练了半辈子的那份本事，用在了不需要它的战场上，结果就是活干得很漂亮，钱一分没进。

这一章想让你记住的一句话

本章出处（可核对）

做得出来 ≠ 上得了架 ≠ 有人下载 ≠ 有人付钱。这是四道门，每一道都要单独过。做技术的人最容易犯的错，是把第一道门当成最后一道。

如果你也这样，你该注意什么

• 在动手做产品之前，先把这条资质链走一遍：主体、备案、著作权、开发者账号、内容合规。哪一环你不具备，先解决，别先做产品。
• 别把"能用了"当成"能卖了"。 这是四件事。
• 看用户数先剔除自己。 测试流量、机器访问、内部账号，全要摘掉再看。

素材出处

• 上架为 0：资产\43_App上架现状\现状.md
• 四个备案号：WORKLOG.md 第 270490–270497 行
• 应用宝 5 个应用卡在版权证明：WORKLOG.md 第 267347 行
• 软著 AI 承诺与冻结：资产\10_合规申请材料\软著\_签章页\_冻结_勿提交_20261006\README.md
• 电子版权认证（600 元/件、无 AI 条款）：WORKLOG.md 第 271540、271618 行
• 真实用户数：WORKLOG.md 第 272361–272363、4225、260498、7809、51761、274282 行
• 185 次落地逐条分类：WORKLOG.md 第 272103 行
• 18 篇内容与引用率 0%：资产\00_交接\邮件获客与GEO能力清点_20260930.md §2.3

第 24 章 · 那钱到底在哪

前面几章全在讲失败

讲到这儿，我自己都有点丧。

丧是有用的情绪——它说明你真的投进去了。但丧不给你下一步。

所以这一章反过来看：那些真的赚到钱的人，做对了什么？

我为了回答这个问题，让几路人马去把公开数据翻了一遍——130 多条带出处的数字。

"带出处"这三个字很重要。因为这一行里，随手一句"AI 能赚钱"和一张能查的报表，是两种东西。 我只要后者。

结论一句话

卖"AI"不值钱，卖"替掉一件具体后台活"才值钱。

这句话我第一次看到的时候并不信，因为它太朴素了，朴素到不像个商业洞察。

后来我把六家样本一家一家拆开看，才发现它们收钱的科目里，没有一家写的是"AI"。

十条市场真相（每一条都有数字）

这张表我建议你从头到尾读一遍，因为每一行都在拆一个大家默认的假设。

第 1 条要拆的是"市场大我就有机会"。 212 亿涨到 449 亿，说的是全国企业买了多少 AI。这是别人的热闹，跟你能收到多少钱没有直接关系。

第 2 条要拆的是"做出来就行"。 所谓"实验项目"，就是先做个小样试试、成了再全面推开。88% 的小样推不下去，说明卡住的地方不在"能不能做出来"，在"做出来之后没人用"。

第 3 条把这件事说透了：失败原因排第一的是数据质量，不是模型不行。 而这些原因里，没有一条是"技术太难"。全是人的问题、老系统的问题、习惯的问题。

第 4 条是定价的天花板。 46.2% 的企业一年 AI 预算不到一万块——你如果卖一万二一年，那不是产品问题，是算术问题。

第 6 条解释了后面所有的事。 预算大头给了前台（销售、市场），可真正有回报的是后台（单据、对账、合规）。因为前台是痒点，后台是痛点。

第 8 条最值得单独说：95% 的中标者来自一开始那份名单。

意思是：你不在人家一开始的名单里，你后面再努力也基本没用。 这一条直接判了很多"我去投标试试"的死刑。

什么叫"一开始那份名单"？就是甲方立项的时候，脑子里已经有三五家候选了。 后面那一轮轮流程，大部分是在这三五家里做选择，不是在天下人里找。

所以"我去投个标试试"这件事，本质上是在赌自己已经在那份名单上。 而你没被邀请过，大概率不在。

反着看：那些真赚到钱的人，做对了什么

光看失败会绝望。所以我把"真赚到钱的"也找出来，看他们有什么共同点：

这六家我是一家一家看的，看的不是他们多厉害，是"客户拿这笔钱的时候，走的是哪本账"。

看出来的东西很清楚：

• 代账那家，客户按月付服务费，跟请一个会计一样——走的是"人工预算"。
• 14 人那家，客户一次性买断授权——走的是"软件采购预算"。
• 武汉那家，报价方式是"一个岗位的月薪"——走的是"人力成本预算"。

三家，三个科目，没有一个科目叫"AI"。

顺便把"买断"和"维保"这两个词说清楚，因为后面要用：

买断，是客户一次性付一笔钱，把这套东西拿回去自己用，不再按月交钱。

维保，是客户每年再付一小笔，保证这东西一直好用、出问题有人管。

老板为什么更容易接受买断？因为一次性支出能批，年年要付的钱，得年年解释一次。

那个"一个人服务 17 家企业"的样本，我看了很久。

它说明一件事：这门生意不需要人多，需要的是"第一单做得让客户愿意替你说话"。

同样的活交第二遍、第三遍，客户靠交付口碑滚出来——规模不在人数上，在口碑上。

六条规律（这就是这一章的干货）

1. 用客户的"服务预算 / 授权预算"收钱，不用"IT 预算"收钱。
2. 卖后台的回报，不卖前台的花活。
3. 卖"过审、避罚、降本"，不卖"提效"。
4. 卖买断 + 年维保，不卖订阅。
5. 维保是复利，首建费不是。
6. 第三单的成本必须显著低于第一单。

第 1 条值得展开一句：在中国，中小企业的 IT 预算基本不存在，但"请一个代账 / 外包"的服务预算一直都在。同一笔钱，换个说法就能收到。

第 3 条最反直觉，但数据非常一致：提效的好处归员工，成本归老板。而"能上线"是明确的过关结果，老板当场就懂。

第 4 条有个更狠的数据：月费低于 50 美元的 AI 产品，一年后收入只剩 23%。定价太低，你连获客成本都收不回。

第 2 条和第 3 条其实是一件事的两面：后台的活没人愿意干，所以它才值钱；前台的花活大家都想做，所以它不值钱。

第 5 条说的是钱的形状：首建费收一次就没了，第二年还会来的钱才叫资产。 你年年都得重新去拉一遍新客户，那不叫生意，叫打零工。

第 6 条是我最缺的一条。它真正的意思是：第一单可以亏，因为你在买"下一单会更便宜"这件事。

反过来讲更清楚：如果第二单还是从头做一遍，你就不是在开公司，是在接散活。 散活能活下去，但永远长不大。

我自己踩在哪个坑里

对照上面六条，我过去几年的问题非常清楚：

• 我在卖"技术"，不在卖"结果"（违反第 1、3 条）
• 我做了很多"前台的东西"（App、落地页、推广），而真正值钱的是后台那些没人看的地方（违反第 2 条）
• 我定过"1.2 万一年"的订阅价（直接踩在"付费率 11%"和"46% 预算不到 1 万"两格上，违反第 4 条）
• 我每一单都是从头做的，没有第三单（违反第 6 条）

这四条不是四个错误，是同一个错误的四个面：我一直用"工程师"的方式，在做"生意"。

工程师的直觉是"把东西做好"，生意的直觉是"把账算对"。这两件事都不容易，可它们不是同一件事；而第二件，我一直没真正上手。

你可以拿自己手里的活对一遍。六条里踩中三条以上，问题多半不在产品，在收钱的方式。

这四条加起来，就是一个"技术很好、赚不到钱"的画像。

写这一节的时候，我改了好几遍。因为把"技术很好"和"赚不到钱"放在同一句里，读起来像在给自己找台阶。

可它偏偏是准的：前一件事我确实做到了，后一件事我确实没做到。这两句话可以同时成立，而且在我身上确实同时成立。

这一章想让你记住的一句话

本章出处（可核对）

客户付钱不是因为你的技术好，是因为你替他扛掉了一件他不愿意自己干的事。而他要从哪个预算科目里掏这笔钱，决定了你能开多高的价。

如果你也这样，你该注意什么

• 问一句：客户这笔钱从哪个科目出？ 答不出来，你这个定价就是错的。
• 别卖"提效"，卖"过审 / 避罚 / 降本"。 前者的好处归员工，后者的好处归老板。
• 别做订阅，做买断 + 维保。 至少在目前的中国市场。

素材出处

• 资产\32_能力盘点\AI方向_最终结论_20261101.md（十条真相、六条规律、七家赚钱样本）
• 逐条出处：资产\32_能力盘点\AI方向_外部证据库_20261101.md（13 节，130+ 条）

第 25 章 · 给同龄人的十条

写到这里，我把这一年零十个月能提炼出来的东西，压成十条。每条后面都有前面某一章作为证据，不是感想。

感想谁都能写，证据写不出来。

一、先承认你不懂，再开始。
一旦你假装懂，AI 就开始陪你演戏（第 2 章）。

为什么？因为 AI 不会纠正你，它只会顺着你的假设往下编。你越自信，它编得越顺。

二、第一个产品大概率做不成，这没关系——但你要从每堵撞过的墙上抠下一条检查项。
我的第一个产品没做成，换来的是后来每件事开工前的三问（第 3 章）。

为什么？因为撞墙本身不产生价值，从墙上抠下来的那条检查项才产生价值。

三、改之前先存一份。
这是所有工程常识里最便宜、最救命的一条。我为了学它，白干了不止一个晚上（第 6 章）。

为什么？因为一旦改坏了，你连"原来长什么样"都找不回来了。

四、不要问它"成没成"，要看它交出来的东西。
"没报错"和"做成了"是两件完全不同的事，我为此被瞒过几个月（第 9 章）。

为什么？因为它说"完成了"的成本是零，而你去核一遍要花时间。你不核，就等于把判断权交给了最不在乎结果的那一方。

五、在真东西上跑过一遍，才算能用。
我自测全绿的代码，第一次碰真回单就漏抄了三笔、少了五万块（第 10 章）。

为什么？因为自测时你测的是自己想到的情况，真东西里跑的全是你没想到的。

六、先让一条路从头走到尾，再考虑把路修宽。
39 个水龙头抛光得很亮，可水管没接上（第 19 章）。

为什么？因为没接通的时候，你连"断在哪一段"都定位不出来。

七、规则要变成"忘不了"，才有用。
写在纸上的规矩一定会被忘记。要么让机器替你记住，要么让机器不让你做错（第 11、12、18 章）。

为什么？因为要记的规矩一多，人就会挑着执行，而机器不挑。

八、别守在电脑前。
AI 真正拉开差距的，不是它在你面前有多快，是它在你走了以后还能干多久（第 16 章）。

为什么？因为你的时间有上限，它的没有。你睡觉那八小时，才是它真正替你多干出来的部分。

九、把机器流量从人的流量里分出来。
"打开率 100%"、"外部访问 185 次"，逐条查完，真人是 1 个。不看这个，你会一直以为自己有客户（第 22、23 章）。

为什么？因为机器流量本身不要钱，可它会让你照着假客户去改产品——那才是真损失。

十、客户掏的是哪个预算科目，决定你能收多少钱。
卖"AI"不值钱，卖"替掉一件他不愿意自己干的事"才值钱（第 24 章）。

为什么？因为同一件事，报在"人工预算"里听着便宜，报在"IT 预算"里听着贵。科目决定了别人拿你跟谁比。

这十条我最常想的，其实是第四条——因为"我以为它做完了"这件事，我至今还会犯。

这十条如果只让我留三条，我留第一、第四、第十。

第一条管取舍，第四条管验收，第十条管收钱。 剩下的，都是这三条的延长线。

最后一句

这本书里没有"一年做到一千万"的故事。

它讲的是一个 41 岁、不会写代码的人，花了一年零十个月，把"我能不能指挥得动 AI"这个问题，回答成了"能，但我还得学会怎么把它卖出去"。

前一半我做到了。后一半，我还在做。

如果你也是这个年纪、这个处境，前半本你可以直接抄，后半本我们一起摸索。

尾声 · 我现在最不会的是什么

这本书从一个凌晨四点开始

写到这里，我想认真回答一个我自己也躲了很久的问题：我现在最不会的是什么。

这个问题我躲了很久。因为答它，等于承认"会做"和"会卖"之间还隔着的一大截，是真的。

那一晚的事，前面已经用整本书写完了。我要说的是那一晚之后这一年零十个月，我到底长出了什么、又到底没长出什么。

先说我会了什么

我会让 AI 替我干活，而且干得还算稳：

能派活、能验收、能让它在我睡觉的时候接着干、能一眼看出它是在真干还是在演戏。

这四件事，我用大白话再说一遍：

派活，是我把一件活说清楚到它能自己干，不用我守在旁边。

验收，是它干完了我自己去核一遍，而不是听它说"好了"。

睡觉时接着干，是它不需要我在场也能推进。

分辨真假，是它说"完成了"的时候，我能看出它其实什么都没干。

落到日常里是这样的：我不需要坐在它旁边，它也不等我在。 我给它一个目标和一个验收标准，剩下的它自己安排。

我回来只做两件事：看结果，改标准。

这些，两年前我一样都不会。

我现在最不会的，是另一件事

"现在最不会的，是借助 AI 的力量让自己跨领域了解其他行业的知识和经验，掌握其他行业的具体能力——比如产品推广和运营，让自己达到 knowhow 的程度。"

"knowhow"这个词，我用大白话解释一下：不是知道该怎么做，是知道"现在这一步该不该做、做到什么程度该停"。

举个例子：

我能让 AI 在十分钟内给我一份"产品怎么推广"的完整方案——渠道、节奏、预算、话术，应有尽有。

但我看完那份方案，我不知道哪一条是对的。

• 它说要做内容，我知道做内容有用——但我不知道做到什么程度才算有效
• 它说要投信息流，我知道投信息流能来量——但我不知道这个价格贵不贵
• 它说三个渠道并行，我知道并行有道理——但我不知道什么时候该砍掉其中两个

这三条合起来其实是同一句话：方案我拿得到，判断我拿不到。

而做生意，靠的偏偏是判断。

这就是"知识"和"knowhow"的区别。

• 知识是"应该怎么做"
• knowhow 是"现在这一步，该不该做、做到什么程度停"

再换个说法：知识是地图，knowhow 是知道哪段路晚上不能走。

地图谁都能下载，而且免费。可哪一段不能走、走错了会掉进哪儿，只有真走过的人知道。

在财税上，我有 knowhow。 一份报表放我面前，我一眼能看出哪儿不对；一笔业务问我怎么走，我知道哪条路会被查。这个能力是二十年换的，AI 给不了我，也不需要给我。

那种"一眼"不是查出来的，是错出来的。

我之所以知道哪条路会被查，是因为我见过被查的人后来怎么样。

这句话听着像在显摆经验，其实不是。它的意思是：我这些年真正学到的东西，大部分不是"该怎么做"，是"这么做会出什么事"。

而出事这件事，AI 没见过。

但在推广、运营、产品这些领域，我只有知识，没有 knowhow。

而 AI 补不上这个。

为什么补不上？因为 knowhow 长在"后果"上。

你知道这一步该停，是因为你以前没停过，付过代价。AI 没有付过代价，所以它不知道哪儿该停。它可以给你十个方案，但十个方案里哪一个会把你带沟里，它不心疼。

因为 knowhow 不是查出来的，是做出来的。你只能靠真做过、真赔过、真被市场打过脸，才能长出"手感"。

这就是为什么我这两年做过那么多推广尝试，效果都不行（第 22、23 章）——不是我不会用 AI，是我在那个领域没有手感。

AI 能把"知识"这一层瞬间拉平，但从"知识"到"knowhow"，它替不了你走路。

我知道该怎么补了（但还没补完）

我现在用的办法是：把每个陌生领域的关键动作，做成能勾选的清单和能核对的判据，先跑一轮，用真实结果反馈回来。

说白了就是：我不会，但我可以先按规矩做，然后看结果，再改规矩。

这比"我觉得应该这样"靠谱得多，比"我觉得不行"也靠谱得多。

它好在哪儿？它把"我没有手感"这个窘境，换成了"我有一张清单"。

有清单，我至少知道自己有没有漏干活。至于干得对不对，得等市场回答。

这套办法的代价是慢。别人凭手感当天就能定的事，我要先列清单、先跑一轮、再等结果。

但对我这种"没手感还得做决定"的人来说，慢，总比瞎猜强。

它还有一个坑，我自己踩过：把清单做完，就当成把事做完了。

清单只能保证我没漏步骤，保证不了结果。这两件事之间的差距，还是得靠市场来填。

第 13 章那套"专家底座"，本质上就是我在拿它当拐杖：我还没有 knowhow，但我至少能保证自己不是凭感觉在干。

附录一：我家里人也被带起来了

这是这两年我最没想到的一件好事。

"家人和合伙人被我带动，也开始学习使用 AI。而且很短时间，就能借助我的经验和技巧，比其他人掌握得更快、更好。"

为什么他们学得比别人快？

不是因为聪明，是因为他们不用自己去踩坑，我踩过了。

• 我知道哪一步会翻车，我提前告诉他们
• 我知道哪个坑最费时间，我让他们绕开
• 我知道什么看起来成功其实什么都没干（第 9 章），我直接教他们怎么看

这就是"经验"这个词真正的意思：它不是你会做什么，是你知道什么不用做。

你如果带过人，这一点会特别有体会：教原理最慢，给一张"哪一步会翻车"的清单最快。

我后来真的是这么干的：把我踩过的坑写成一条一条的检查项，谁用直接照着走。

他们不需要理解为什么，照着做就不会掉进去。等他们自己踩了几次，自然就懂了。

为什么不直接教他们用哪个工具？因为工具半年换一批，坑的样子基本不变。

而这件事让我想明白了一件事——

这本书如果只有一个人能用，那它没用。如果一家人、一桌合伙人、一个圈子里的人都能用，它才有价值。

最后三句话

这个结尾我改了好几遍才定稿。

写成"AI 很好用"，那是广告；写成"AI 没什么用"，那是撒谎。

真实的情况是：它把我一半的问题解决了，另一半动都没动。

第一句：AI 不会让你变成全才。

它会把你的"知识短板"瞬间填平，但你的"knowhow 短板"一点都不会变。你越早认清这一点，越不容易被自己骗。

而且这件事有个麻烦的地方：知识填平得太快，快到你很容易误以为短板也没了。

第二句：一个人用 AI，你能快；一群人用同一套规矩用 AI，你才能把事做成。

因为一个人的规矩只约束一个人，一套规矩能约束所有人。而事情从来不是一个人做成的。

第三句，也是我最想说的一句：

我不聪明，我只是比别人早两年开始，并且把每一次摔跤都记下来了。

这句不是谦虚。比我聪明的人多得是，他们只是还没开始。

这两年我花了不到六千块钱的 API 费，摔了几十跤，写下了一千多条工作记录和一百多份交接文档。

六千块钱，是这两年我唯一算得清的成本。 剩下那些——时间、机会、被人拒绝的次数——算不清。

这本书就是从那堆记录里捞出来的。

记录这个东西有个好处：它不会帮你美化。你当时怎么想的、错在哪一步，都原样躺在那里。 人回忆的时候会替自己圆场，记录不会。

如果你读完只记住一件事，我希望是这句：

本章出处（可核对）

不用怕你不会。怕的是你以为你会了。

素材出处

• 文哥对尾声两段的直接口述（2026-11-01）
• "知识 vs knowhow"与专家底座：CLAUDE.md §10.6；资产\37_专家化工作法\专家底座索引.md
• 推广/运营上真实效果不佳：本书第 22、23 章
• 一千多条工作记录与 114 份交接文档：WORKLOG.md（1,289 条带标题记录）、资产\00_交接\