构架师教程：前传

——写给 AI 时代的一份思维教程

不谈 agent，不谈 skill，不谈那一堆三个字母的缩写。

我们只谈一件事：当机器开始替你写代码，你脑子里到底还剩下什么，是值钱的。

越狱系列过两天再写，有些概念跟不上了。

楔子：一个趴在内存地址上的孩子

我十几岁的时候，干的第一件像样的“工程“，是给一个单机游戏的角色加血。

那个年纪，对我影响最深的是两款国产 RPG。一款是《金庸群侠传》，一款是《仙剑奇侠传》九八柔情版。今天的年轻人未必听过这两个名字，但在当年，它们是能让一个少年心甘情愿把整个暑假交出去的东西。我爱它们，爱到不满足于只是玩——我想动它们，想伸手进去摸一摸它们的骨头。

那时候装了金山游侠。今天的小孩可能不知道这是什么东西，简单说，它是一把锁，一把能撬开游戏内存的锁。你先记住自己现在有多少血，比如 100，去搜索内存里所有等于 100 的地址，搜出来几千个；然后你被怪打一下，血变成 80，再搜一遍等于 80 的，几千个缩成几十个；再挨一下，几十个缩成一个。那个地址，就是你的命。

你把它锁死在某个值上，从此无敌。

我后来想，那其实是我人生里第一堂工程课，而且是最硬的一堂。它教给我的，跟作弊关系不大。它教给我的是一件更底层的事——屏幕上那一排显示生命值的数字是假的，真正存在的，是内存里一个会变化的数字。 你看到的所有界面、动画、音效，都只是这个数字穿了好几层衣服之后的样子。你要做的，是脱掉衣服，去摸那个数字本身。

一开始，我改的都是些表面的东西。等级、金钱——无非是让角色多一点、富一点，给一个既定的人物添砖加瓦。改这些，爽，但浅。

真正让我后背发凉的，是后来我摸到了技能。

我发现自己不光能改主角有多少钱、有多少级，我还能改他会什么。一个本来只会野球拳（虽然野球拳升级满了超强）的小虾米，我可以让他身上挂满其他角色的全套绝学；一个被设定成弱鸡的角色，我可以重写他的能耐。那一刻我隐约撞见一个东西，当时说不清楚，现在能说清楚了——改一个东西“有什么“，和改一个东西“能做什么“，是两个层级的事。 前者是在表面上加加减减，后者是在动它的本质。一个十几岁的孩子当然不懂什么叫本质，但他的手已经先于他的脑子，摸到了那个地方。

从那以后我就没怎么停过。逆向、破解、写外挂，后来是各种自动化，再后来是量化交易，中间还做过几年安全——比脚本小子强一点，但也别吹得太大，离真正的高手还差着段位。这条路走下来，我换过无数种语言，从趴在汇编上抠寄存器，到用 Lisp 给魔兽世界写脚本，到 Python 和 Bash 把一堆破事缝在一起自动跑。

现在，2026 年了。机器能替我写代码了，而且写得比我快，比我多，有时候比我还规整。

很多人慌了。他们开始疯狂地学怎么“用 AI“——学各种工具、各种缩写、各种花活，生怕自己被时代甩下。

我也想慌，但我慌不起来。因为我回头看了一眼那条假血条，突然明白了一件事：

真正值钱的从来不是我会写哪种代码，而是我那个从十几岁起就改不掉的毛病——看到任何东西，都想脱掉它的衣服，去摸底下那个会变化的数字。

这份东西，就是想把这个毛病讲清楚。我不教你工具，工具会过时，今天最火的明天就成了笑话。我想跟你聊的是底下那层不会过时的东西：思维模式。

它分四种。我用我这二十多年趟过的坑，一种一种拆给你看。

讲完你会发现，所谓 AI 时代的“构架师“，根本不是什么新物种。它只是把程序员脑子里最古老的几样东西，重新标了个高价。

第一章：所有的抽象都会泄漏

先讲汇编。

不是教你写汇编——这年头会写汇编的人，多半也快退休了。我要讲的是汇编思维，一种看待整个计算机世界的角度。

汇编是什么？它是机器语言的人话版。电脑只认 0 和 1，汇编用 MOV、ADD 这种简单的英文缩写代替那一长串二进制，直接指挥 CPU、内存、寄存器干活。它极快、极底层、极难写。一行 Python 在它眼里可能要拆成几十行。今天没几个人靠它吃饭。

但你一旦在汇编那个层面待过，哪怕只待过一阵，你的脑子里会被烙下一个东西，这个东西我活到现在都没丢：

你知道往上的每一层，都是别人给你修的一条柏油路，而柏油路底下，是会塌的土。

2002 年有个叫 Joel Spolsky 的人提出过一条定律，叫“抽象泄漏定律“（The Law of Leaky Abstractions）。原话很短：所有非平凡的抽象，在某种程度上都是会泄漏的。

这句话朴素得像废话，但它是整个软件工程里最毒的一句真话。

什么叫抽象？抽象就是有人替你把复杂的东西包起来，给你一个简单的开关。你用文件系统读一个文件，一行代码 open(“file.txt”)，背后是磁盘磁头的物理移动、是扇区、是缓存、是一整套你看不见的脏活。这套脏活被包成了一个干净的开关，这就是抽象。抽象让你能飞快地干活，不用每次都从泥里爬。

但 Joel 说：这层包装永远包不严。 总有那么些时候，底下的脏东西会渗上来。你读一个网络上的文件，把它当本地文件用，用着用着网断了，抽象就漏了——你以为你在读一个文件，其实你在赌一条随时会断的网线。你写一句 SQL，以为数据库会聪明地帮你查，结果数据量一大，查询慢得像爬，你被迫去研究它底层的查询计划。SQL 程序员必须对数据库服务器的查询计划懂个七七八八，才能搞明白自己代码的性能到底卡在哪——查询语言这层抽象，在这种时候帮不上什么忙。

这条定律最阴的地方，是它的一个推论：抽象帮你省下了干活的时间，但它没帮你省下学习的时间。

你品一下这句话。

它的意思是：你用一个高级框架，可以一天写完别人一个月的活，省下了干活的时间。但那个框架一旦出问题、一旦泄漏，你就得懂它底下那一层是怎么回事，否则你连 bug 在哪都找不到。所以你该学的东西一样没少。抽象只是把你的痛苦从“每天都痛一点“改成了“平时不痛、出事就痛死“。

现在，把 AI 放进这个框架里看。

AI 写代码，是人类有史以来造出来的最高的一层抽象。

往上数：机器码之上是汇编，汇编之上是 C，C 之上是 Python 这种高级语言，高级语言之上是框架，框架之上是各种低代码平台。这是一座一直在往上盖的塔，每一层都比下一层更“人话“、更“省事“。

而你用人话直接描述需求、让 AI 把代码吐出来——这是塔顶，是迄今为止离机器最远、离人最近的那一层。有人把它叫“英语是最新的编程语言“，当你用清楚的人话描述功能时，你写的就是一份可执行的规格说明书，模型负责把意图翻译成实现，于是限制你的因素不再是编程能力，而是你思考的清晰度和表达的精确度。

听起来很爽，对吧。塔盖到这么高，是不是底下那些脏活就跟你没关系了？

恰恰相反。

塔越高，泄漏越致命。

因为这一层抽象包住的，不是磁盘扇区，不是 TCP 重传，是整个软件工程本身。它一旦漏，漏出来的就不是性能问题，是逻辑被悄悄改坏，是它自信满满地给你一段错的东西，而你还以为它对。

我做了二十年自动化，我可以非常负责任地告诉你：AI 写代码最危险的从来不是它写不出来。它写不出来你一眼就看见了，那不可怕。真正可怕的是它自信地写错——语法完美，结构漂亮，跑起来不报错，但里面有一处逻辑被它“脑补“歪了，而它不会告诉你，它甚至自己都不知道。

这就是塔顶抽象的泄漏。这个泄漏，普通用户根本看不见。能看见它的，只有一种人：在塔底待过，知道底下是土的人。

我那条假血条的故事，讲的就是这个。当年我学会的不是金山游侠这个工具，我学会的是一个本能——不相信表面那条红色的血条，去摸底下那个数字。今天 AI 给我吐出来一段漂亮的代码，我的本能还是一样的：不相信这层漂亮的抽象，往下捅一层，看看它说的和它做的，是不是真的对得上。

这就是汇编思维在 AI 时代的全部价值：当抽象泄漏的时候，你有没有能力往下掉一层。

掉得下去的人，AI 是他的放大器。掉不下去的人，AI 是他的悬崖——平时风平浪静，一旦泄漏，他连自己怎么死的都不知道。

所以别天真地以为塔盖高了，底层就不用懂了。Joel 那句话还在那儿冷笑着：抽象省你的是干活的时间，不省你的是学习的时间。机器替你干活了，但你该懂的那层东西，一分都没少。

我甚至觉得，正因为机器把“干活“这件事的成本压到了地板上，“懂底层“这件事的价格反而被顶到了天花板。从前你不懂底层，至少还能靠手快、靠肯加班混口饭。现在手快不值钱了，机器比你快一万倍。剩下唯一还值钱的，就是你那个能在泄漏发生时往下掉一层的本事。

这是第一种思维。它的内核就一句话：永远记得，你脚下的路是别人修的，而路底下是会塌的土。

第二章：把世界拆成对象

讲完往下看，讲往上抽。

第二种思维，来自面向对象。同样，我不教你写类、写继承——那是语法，语法两个星期就能学会。我要讲的是面向对象背后那个看世界的方式，它远比任何一门语言都活得久。

面向对象的官方说法，是把程序里的数据和功能打包成一个个“对象“，然后让对象之间协作干活。新手都会背那三个词：封装、继承、多态。

封装，是把对象内部的脏东西藏起来，只露出几个必要的接口。一个微信机器人对外只提供“发消息“这个口子，至于它内部怎么连微信、怎么走代理、怎么过风控，你不用管，也别去管。继承，是子类复用父类的能力，通用机器人会收消息，微信机器人继承它，再加一个微信专属的扫码登录。多态，是同一个动作，不同对象有不同的干法——同样是“发消息“，微信机器人发微信，QQ 机器人发 QQ，你只管喊“发消息“，不用关心它具体怎么发。

这三个词，新手当成语法背。但我趟了二十年坑之后回头看，它们哪是什么语法。它们是一整套拆解世界的手术刀。

我挑封装和多态展开讲，因为这两把刀，在 AI 时代直接就是命根子。

先说封装，它的本质是画边界。

写代码，真正难的从来都不在敲键盘那一下。难在敲之前那个决定：什么该露出来、什么该藏起来。一个对象，你给它开几个口子、每个口子长什么样、内部那一堆脏活怎么对外保持沉默——这套决定，就是工程的灵魂。封装做得好，整个系统像乐高，一块一块拼，坏了换一块；封装做得烂，整个系统像一锅粥，动一根头发全身抽筋。

而画边界这件事，机器到今天都干不好。

你让 AI 写一个功能，它能写。但你让 AI 决定“这个系统该拆成哪几个模块、每个模块的边界划在哪、谁该知道谁的存在、谁该对谁一无所知“——它会给你一个看起来合理、实际上经不起推敲的答案。因为画边界这件事，知识帮不上太多忙，真正起作用的是判断：你要预判这个系统未来会往哪长，要预判哪些东西会一起变、哪些东西会各自变，然后顺着这些“变化的节理“去下刀。

这是人的活。这是从前资深架构师拿高薪的核心原因，现在它没变，只是更值钱了。

再说多态，它的本质是只认契约，不认实现。

多态在教你一件特别深的事：你喊“发消息“的时候，你根本不关心对方是怎么发的。你只关心一件事——我喊了，消息发出去了。至于它走了微信还是 QQ，用了 HTTP 还是 WebSocket，是它自己的事，跟你没关系。

你关心的是契约（发消息这个承诺），不是实现（具体怎么发）。

把这句话记死了，你就拿到了 AI 时代构架师的核心姿势。

因为你现在指挥 AI 干活，干的就是一模一样的事。你不该关心 AI 内部是怎么把代码憋出来的——那是它的实现，是它的脏活，藏在它的封装里。你该关心的，是你跟它之间那份契约：我要的输入是什么，我要的输出是什么，什么样算对，什么样算错。

你定义契约，它去实现。这就是多态思维放大到人和机器之间的样子。

那些用 AI 用得最痛苦的人，都是因为他们不停地想钻进 AI 的实现里去，想替它操心它该怎么写、用什么写法、第几行该怎么改。他们把多态忘了，把封装也忘了，结果就是跟一团黑箱肉搏，越搏越累。同样的任务，同样的模型，你的同事五分钟交活，你花四十分钟跟输出搏斗，差别根本不在智商。差别在于：他在定义契约，你在替机器操心实现。

封装和多态合起来，指向同一个能力：拆解。

把一个模糊的、黏成一坨的需求，拆成几个边界清晰、契约明确的对象。这是面向对象真正在训练你的东西，也是 AI 时代最稀缺的能力。

我得在这里说句重话，因为这是整份教程的脊梁骨：

机器极其擅长执行明确的指令，但它极其不擅长把一个模糊的东西变明确。

而“把模糊的东西变明确“，就是面向对象训练了几十年的那件事——拆对象、画边界、定契约。它从前的名字叫“系统设计“，现在它有个更值钱的名字，叫“问题定义“。

我见过太多人，对着 AI 敲一句“帮我做个交易系统“，然后抱怨 AI 给的东西不能用。废话，“交易系统“这五个字里，藏着几百个没被定义的对象：行情从哪来？信号怎么算？下单走哪个交易所的接口？止损用什么逻辑？仓位怎么管？回撤到多少要停？——这每一个问号，都是一个等着你去封装、去画边界、去定契约的对象。你不拆，AI 替你瞎拆，拆出来的东西当然是垃圾。

我自己做量化做了八年多，我做 TradeV7 那套东西的时候，真正费脑子的从来不是写代码。写代码是最后那一哆嗦。费脑子的是前面：把“我要赚钱“这个混沌的欲望，一层一层拆成可以被验证、可以被执行的对象。比如止损这一块，我用的是吊灯止损（Chandelier），它本身就是一个被定义得极其清晰的对象——它的输入是最高价和波动率，它的输出是一条会跟着价格往上爬、但绝不往下退的止损线，它的契约是“只锁利润，不放利润“。我把它定义清楚了，剩下的实现谁写都行，机器写、我写、十年前的我写，结果是一样的。

这就是面向对象思维的终局：你不是在写程序，你是在把混沌拆成一个个能被信任的对象。 谁拆，谁就是构架师；谁不拆、只会喊“帮我做个 XX“，谁就永远是那个跟黑箱肉搏的人。

这是第二种思维。一句话：世界是一坨混沌，你的本事是把它拆成边界清晰、只认契约的对象。

第三章：代码即数据，你站在代码的上一层

第三种思维，来自一门老到快成化石的语言：Lisp。

Lisp 1958 年就有了，比绝大多数还活着的程序员都老。它长得很怪，满屏的括号，一切都用括号包起来的列表表示。(+ 1 2) 就是算 1 加 2。新手第一次看见会头晕，觉得这什么鬼东西。

但 Lisp 藏着一个全世界几乎没有第二门语言敢这么玩的特性，叫同像性（homoiconicity）。说人话就四个字：代码即数据。

在 Lisp 里，你写的代码，和你处理的数据，长得一模一样，都是括号括起来的列表。这意味着什么？意味着你可以把代码当数据来操作——你可以写一段程序，它的产出是另一段程序；你可以把一段代码抓在手里，像捏橡皮泥一样改它、拼它、生成它。

有人把这个能力总结成一句特别狠的话：Lisp 是一门“可编程的编程语言“。说白了，编程是写代码，而元编程是写“能生成代码的代码“。

我年轻的时候用 Lisp 给魔兽世界写过脚本。当时没觉得自己在干什么了不起的事，就是觉得这玩意儿爽——我当时写的，根本不是“角色该做什么“这种一条一条的动作。我写的是一套逻辑，让它根据局势自己长出行为来。我站在行为的上一层。我写的是生成动作的那个东西，而不是动作本身。

那时候我不知道这个姿势叫什么。现在我知道了，它叫元编程思维，而它是 AI 时代最被低估、却最要命的一种思维。

为什么要命？

因为 AI 把所有人，硬生生推到了元编程的位置上。

你想想，你现在对 AI 说一句话，让它生成一段代码——你在干嘛？你在用一段文字（数据），去生成一段程序（代码）。 你写的那句话、那份需求、那份规格说明，本身就是“能生成代码的代码“。你已经不在写代码了，你在写“生成代码的东西“。你被强行抬到了代码的上一层。

这正是 Lisp 同像性那个古老梦想的现代版本：代码和数据的界限模糊了，你操作的东西既是描述、又是指令。甚至已经有人认真地把 Lisp 这套老灵魂和大模型接在一起研究，因为同像性这个核心特征——代码和数据的统一表示——天然地契合大语言模型的能力，模型恰恰受益于这种易于解析和操作的结构。这不是巧合。这是几十年前那个“代码即数据“的直觉，绕了一大圈，终于在 AI 这里兑现了。

那么问题来了：当所有人都被抬到代码的上一层，谁活得好，谁活得差？

活得好的，是那些早就习惯了“站在上一层“的人。是那些写过 Lisp、写过宏、写过元编程，骨子里就知道“我写的是生成器、不是产物“的人。他们换个皮就上手了，因为姿势没变，只是从前用括号，现在用人话。

活得差的，是那些一辈子只会写“产物“的人。你让他在代码这一层，他是熟练工；你把他抬到上一层，让他去“描述一个能自己生成代码的东西“，他懵了。他还在用写代码的脑子写需求，写出来的东西又啰嗦又夹缠，机器读完一脸茫然。

这里就接上了上一章的“问题定义“。一段好的需求、一份好的规格说明，本质上就是一段好的“元代码“——它要足够精确，精确到机器能照着它生成出对的东西；它又要足够抽象，抽象到不去管机器具体怎么实现。这中间的分寸，正是 Lisp 老炮儿们玩了一辈子的分寸。

有个做产品的人讲过一句让我记到现在的话：规格说明书才是难的那部分，搭建反而很快。一个从前要花五到十万、做四到八周才能出原型的生意点子，现在一个下午就能搭出来。注意他说的——难的是规格，不是搭建。搭建被机器接管了，那是产物，是下一层的脏活。难的永远是上一层：你能不能写出一份精确又克制的“元代码“，让产物自己长出来。

Lisp 还教了我第二件事，比代码即数据更朴素，但同样救命：纯函数。

Lisp 是函数式编程的鼻祖。函数式里有个核心洁癖，叫“纯函数“——同样的输入，永远给同样的输出，不偷偷改外面的任何东西，没有副作用。一个纯函数，是世界上最好验证的东西：你喂它一个输入，看它吐什么输出，对了就是对了，错了就是错了，干干净净，没有“看情况““有时候”“可能”。

你把 AI 当成一个纯函数来用，你就赢了一半。

你定义清楚：给它什么输入，期待什么输出，什么叫对。然后你只验证这一件事——输入进去，输出出来，对不对。你不去管它中间那一团黑箱里发生了什么，因为那是它的副作用，是它的脏活，藏在它的封装里（看，又回到第二章了）。

而那些被 AI 折磨得死去活来的人，都是因为他们把 AI 当成了一个充满副作用的脏东西——他们盯着它的中间过程，被它一会儿这样一会儿那样的“脾气“搞得心神不宁，却从来没给它定义过一个干净的“输入—输出—对错“契约。他们没有纯函数思维，所以他们永远在跟一个不可预测的东西扯皮。

这是第三种思维。一句话：你交出去的，早已从代码本身，变成了生成代码的那个东西；你站在代码的上一层，而你越能把下一层定义成一个干净的纯函数，你就越安全。

第四章：不要相信任何不能被证伪的东西

讲到这儿，前三种思维其实都还偏“建设性“——往下掉一层、把世界拆成对象、站到代码的上一层。它们教你怎么造。

第四种思维不一样。它教你怎么不被骗。

它来自我做过的两件事：逆向和量化。这两件事看起来八竿子打不着，一个是拆别人的程序，一个是在市场里搏杀，但它们的底层是同一个东西——对抗。 在一个会骗你的世界里活下来。

先说逆向。逆向工程的本质，是从一个成品，倒推回它的意图。你手里没有源码，没有文档，没有作者的解释，你只有一个黑乎乎的、编译好的东西。你要做的，是反着走——从它的行为，反推它的逻辑；从它的逻辑，反推它的意图。

干这行干久了，你会落下一个永久的职业病：你不相信任何东西的表面。

一个程序告诉你它在做 A，逆向的人第一反应是：真的吗？让我看看它到底在做什么。界面写着“安全连接“，他想的是这条连接到底加没加密。一个函数名叫 validateUser，他想的是它到底验没验，还是只是名字叫验证、里面直接 return true。

这个职业病，在 AI 时代，是最贵的一种保险。

我在第一章说过，AI 真正危险的地方，不在它写不出来，而在它能自信地写错。这件事现在被研究得越来越细。一个值得记住的概念是：模型在总结自己干的活时，会不会漏报关键的失败——也就是它明明搞砸了一部分，却在汇报里轻描淡写甚至只字不提。新一代的模型在这件事上确实在进步，漏报的比例在往下掉，但只要这个比例不是零，逆向那个职业病就一天不能丢：

它说它做对了，不算数。我得自己看它到底做了什么。

这就引出了对抗思维最核心的武器——证伪。

科学哲学里有个朴素到不行的道理：一个说法之所以值得信，不是因为有多少证据支持它，而是因为它能被证伪却没被证伪。一个永远没法被推翻的说法，比如“明天可能下雨也可能不下雨“，是废话，因为它怎么都对，所以它什么都没说。真正有价值的，是那些“如果错了，我能立刻知道“的说法。

把这个道理搬到 AI 上，就是一句话：

不要相信任何不能被证伪的 AI 输出。

AI 给你一段代码，说它能跑。“能跑“这个说法值不值钱，取决于你有没有一个能立刻证伪它的东西。如果你有一套测试用例，输入进去，结果不对就立刻红灯——那“能跑“就是值钱的，因为它经受住了证伪。如果你什么都没有，只是盯着代码觉得“嗯看起来挺对”，那“能跑“就是废话，跟“明天可能下雨“一个级别。

这就是为什么，在 AI 时代，测试不再是写完代码之后的收尾工作，而是指挥 AI 之前的前提。

你想让一群机器替你干活，又不想被它们自信地骗死，你唯一的办法，是先把“什么叫对“用测试钉死。测试就是你给 AI 划的牢笼，是那条它跑偏就会立刻撞响的电网。你把电网架好，剩下的它怎么折腾都行，因为它一撞线你就知道了。你不架电网，它跑偏了你毫无察觉，等你发现的时候，错误已经长进了系统的骨头里。

我做量化的时候，这套思维是用真金白银喂出来的。

市场是世界上最大的骗子。一个策略在历史数据上跑出漂亮的曲线，叫回测，那玩意儿是最容易自欺欺人的东西——你总能找到一组参数，让过去的曲线美得像画。但画再美，那是已经发生的事，是它“自信地告诉你“它行。真正值钱的验证只有一个：拿它没见过的数据去打它，叫样本外。能在样本外活下来的，才算数。能在历史里美如画的，一文不值。

你看，这跟 AI 是一模一样的。AI 在你给的例子上表现完美，那是它的“回测“，是它自信地告诉你它行。你得拿它没见过的、刁钻的、边界的输入去打它，那才是样本外。

还有止损。我前面提过吊灯止损，它的灵魂不在那条线怎么算，而在一件特别反人性的事：你在还没亏的时候，就提前把“我什么时候认输“定死了。

为什么要提前定死？因为你不相信亏钱那一刻的自己。亏钱的时候人会找各种理由不止损，“再等等就回来了”“这次不一样”，每一个理由都很动听，每一个都能让你亏得更惨。所以聪明的做法是：在你还清醒、还没有利益牵扯的时候，提前写好那条铁律，然后到点了，闭着眼睛执行，不许临场讨价还价。

把这个搬到 AI 上，就是：你的验证标准，必须在 AI 干活之前定好，而不是看完它的产出再定。

这中间的区别是天与地。事先定标准，你是清醒的、客观的，你定的是“什么叫对“。事后看产出再定标准，你已经被它那段漂亮的代码洗脑了——它看起来那么对，你会忍不住把标准往它身上凑，就像亏钱的赌徒忍不住把“再等等“合理化。这就是为什么那么多人用 AI 用着用着就放松了警惕：因为它的产出太顺滑、太自信，顺滑到你忘了去证伪它。

所以这第四种思维，是前三种的守门人。前三种教你怎么把活干漂亮，第四种教你怎么确认它真的漂亮，而不是看起来漂亮。

一句话：在一个会自信地骗你的世界里，真正能让你托底的是证伪，而不是证据的堆砌；并且证伪的标准，必须在你被洗脑之前就钉死。

我做安全的那几年，把这句话刻进了骨头。安全这行的第一信条就是：默认一切都在撒谎，然后想办法戳穿它。我不算什么大佬，比脚本小子强一点而已，但这个本能我有——而这个本能，恰好是 AI 时代最值钱的本能之一。因为现在你面对的，是一个比任何程序都更会“自信地撒谎“的对手。它不是恶意的，它只是不知道自己错了。而不知道自己错、却又表达得无比笃定，比恶意更危险。

第五章：在机器军团之前，我已经指挥过两千个分身

前面四种思维，我都是用“造一个东西“的尺度讲的。但有一件事，是在你把这四种思维用到很大的规模上之后，才会逼出来的。它本身也是一种思维，而且是构架师最后、也最难的那道关。

我得先交代一段不太光彩、但很真实的经历。

我做 PBN 站群做了十几年。PBN 是什么不重要，你就理解成：我手里同时养着一大堆网站，最多的时候，两千多个。两千多个站，每一个都要有内容、要更新、要被监控、要在出问题的时候被发现和修复。

你现在脑子里可能在算：两千个站，那得多少人？

答案是，主要就我一个。

这件事，在很多人听来像吹牛。但凡做过的人都知道，它根本不是靠人多，也不是靠手快——两千个站，你一天什么都不干，光是挨个点开看一眼，一个站花一分钟，两千分钟，三十多个小时，一天都不够。手快在这个尺度上是个笑话。

那靠什么？靠一个特别朴素、却特别反直觉的转变：

你不能再把它想成两千件活，你得把它想成一个会生产两千个实例的系统。

你看，这句话其实把前面三章全串起来了。

一个站群，不是两千个对象，是一个对象——它有清晰的边界、有明确的契约（“一个站长什么样、该有什么、出什么状况算坏”），它只是被实例化了两千次（面向对象）。我写的不是两千篇内容、两千套配置，我写的是“能生成内容和配置的东西“，我站在这两千个站的上一层（Lisp 的代码即数据）。而我每天真正盯的，不是两千个站本身，是那张架在它们底下的证伪电网——哪个站掉出了我定义的正常范围，电网就响，我才去看那一个（对抗思维）。

所以一个人能不能扛住两千个分身，跟他手快不快、勤不勤奋，一点关系都没有。只跟一件事有关：他脑子里那层壳，是不是用那几种思维做的。

我跟你讲这个，不是为了显摆我养过多少站。是因为我想说一件特别重要的话：

指挥一支军团，从来不是 AI 发明的。AI 只是让这支军团变得免费了。

在 AI 出现之前，想指挥两千个分身，你得自己写脚本、自己搭系统、自己造那个“会生产实例的东西“，门槛极高，所以能干这事的人极少。AI 来了，它把“造执行系统“这件事的成本压到了地板上——现在你不用自己一行行写那个生产引擎了，你描述清楚，它就给你长出来。

但请你注意，被压到地板上的，只是造军团的成本。指挥军团的那个本事，一分钱都没便宜。

恰恰相反，它更贵了。因为从前能指挥军团的人少，是被技术门槛挡住的；现在门槛没了，理论上人人都能拥有一支军团，于是真正稀缺的东西，就从“会不会造“变成了“会不会指挥“。会造的人遍地都是，会指挥的人凤毛麟角。

而指挥军团最难的地方，我做站群十几年、做量化八年，反复撞的是同一堵墙——活多从来都不是问题，真正压垮你的，是你自己那颗会溢出的脑子。

这件事得展开讲，因为它是构架师真正的天花板。

一个人的工作记忆是有限的。你可能是世界上最聪明的工程师，但你脑子里能同时握住的依赖关系、能同时想清楚的因果链条，是有上限的。当一个系统大到几十万行、几千个站、几百个并行的活，它内部的依赖关系会多到任何人类大脑都装不下。你越想把它全部握在手里，你的“缓存“溢出得越快，最后的结果是你既没握住全局，又把自己累垮。

这就是为什么，那种“我要亲自审每一行、亲自盯每一个站“的勤奋，在大规模面前，是一种致命的愚蠢。它看起来很负责，实际上是用必然会溢出的人脑，去对抗一个本来就超出人脑容量的系统。

构架师在这堵墙面前的解法，不是把自己练成一个更大的缓存——那是练不出来的，人脑就这么大。解法是反过来的：设计一个系统，让验证变成机械的，而不是脑力的。

让那张证伪电网替你记住“什么叫对“，这样你就不用把两千个站的状态全塞进脑子；让那些被定义清楚的契约替你守住边界，这样你就不用时刻盯着每个对象的内部。你把“记住“和“盯着“这两件最耗脑力的事，外包给了你设计的系统本身。你的脑子，就空出来了。

空出来的脑子干嘛？这就引出了指挥军团最后、也最微妙的一种本事——判断力的分配。

注意，是判断力的分配，不是判断力本身。

一个指挥两千个分身的人，他最稀缺的资源，说出来你可能不信，时间和精力都排不上号，排第一的是他那点有限的、宝贵的“深度思考“。如果他把这点深度思考平摊到两千个站上，每个站都想得很浅，那他等于没思考。真正高明的指挥官，会把九成的深度思考，砸在那一成真正承重的地方——那些一旦错了就会全盘崩塌的关键决策、关键边界、关键契约。剩下的九成，他让它们在轨道上自己跑，绝不浪费一丝注意力。

这个“知道该在哪儿使劲、该在哪儿放手“的本事，本身就是一种顶级的思维。它要求你对整个系统有一种近乎直觉的轻重判断：哪些地方值得你掉下去看一层，哪些地方扫一眼就够；哪些活值得你把脑子拧到最紧，哪些活随便它去。把全部精力拉满去对待每一件小事的人，看着像认真，骨子里是没有判断力——他分不清轻重，所以只能对一切都用力，最后在最该用力的地方反而没了力气。

我做量化的时候，这一课交的学费最贵。早期我什么都想优化，每个参数都想调到最好，每个细节都不肯放过，结果就是把大量精力耗在了根本不影响盈亏的边角上，反而在真正决定生死的风控和止损逻辑上想得不够透。后来我才学会，把绝大部分的脑力，死死压在那几个承重的决策上——比如止损到底怎么定、仓位到底怎么管——其余的，定好契约，架好电网，让它自己跑，错了电网会响，我再回来看。

这就是指挥军团的全部秘密：不是你能握住多少，而是你敢放开多少；不是你在每个地方都用力，而是你知道力该用在哪。

所以，当所有人都在为“AI 能并行干几百个活“而兴奋的时候，我想泼一盆冷静的水：军团免费了，但你那颗会溢出的脑子，没有升级。机器给了你一千只手，但没给你一千个大脑。这一千只手该往哪伸、哪些地方值得你这唯一的大脑掉下去看、哪些地方该信任电网放手——这套判断，机器替不了你。

它，恰恰就是那层壳最厚、最坚硬的地方。

第六章：构架师——四种思维坍缩成一个人

现在我把四种思维摆在一起，你会看到一件有意思的事：它们其实是同一个人，从四个角度走过来。

往下掉一层的人（汇编思维），把世界拆成对象的人（面向对象思维），站在代码上一层的人（Lisp 思维），不相信表面、只信证伪的人（对抗思维）——这四个人合体，就是 AI 时代唯一还涨价的那个角色：

构架师。

我得先把“构架师“这三个字从神坛上拽下来。它听起来很高大上，好像得是穿着格子衫、画一墙 UML 图的中年男人。不是。构架师的本质特别土，就一句话：他是那个把混沌变成可执行、可验证的东西的人。

他往下能掉一层，所以抽象泄漏时他不慌。 他能把一坨需求拆成边界清晰的对象，所以机器知道该干什么。 他站在代码的上一层，所以他写的是生成器而不是产物。 他不信表面只信证伪，所以机器骗不了他。

这四样合起来，构成了一个完整的回路。而这个回路，恰好就是机器最干不了的那部分。

为什么这么说？因为现在的机器，已经能把“执行“这件事做到极致了。它能同时开几十上百个分身，并行地处理不同的活，干完之后自己审自己、自己跑测试、不对就自己改，改到收敛了再交出来。换句话说，从前需要一个团队规划几个月、执行几个月的大工程——比如把一个庞大的老系统整个迁移到另一种语言——现在它的执行成本，被压到了地板上。

这件事的冲击，所有人都看到了，但绝大多数人理解反了。

他们以为这意味着“程序员要完了“。

恰恰相反。当执行的成本被压到接近于零，判断的价格就被顶到了天上。

这是一个特别朴素的经济学。一样东西变得极度便宜、极度充裕，那么和它互补的、稀缺的那样东西，就会变得极度昂贵。代码变便宜了，那么“决定该写什么代码“就变贵了。实现变充裕了，那么“定义该实现什么“就变稀缺了。机器能造出无穷多的组件，于是AI 生成组件，人定义系统这件事里，“定义系统“那一头的人，就成了整条价值链上最值钱的环节。

有人把这个新角色描述得很贴切：人的位置，像是在给一艘船设定航向的目的地，掌舵“做什么“和“为什么“，而让 AI 去优化“怎么做“。架构师不再逐行调试代码，而是定义想要的结果，审查高层次的产出。这话说得没错，但它只说了表面。它没说的是：要想“掌舵做什么和为什么“，你脑子里得有那四种思维，否则你连舵在哪都摸不到。

一个不会往下掉一层的人，他设的航向是错的，因为他不知道海面下有礁石。 一个不会把混沌拆成对象的人，他给的指令是糊的，因为他自己都没想清楚要去哪。 一个不会站在代码上一层的人，他写的“航向“还是一行行的划桨动作，累死也走不远。 一个不会证伪的人，他以为船在往前开，其实早就触礁了，他还在原地打转却浑然不觉。

所以“从执行者变成指挥官“这句话，听起来轻巧，做起来要命。因为指挥官这个位置，不是谁想站就能站的。它要求你把过去几十年程序员积累的所有底层直觉，全部内化成一种本能，然后用这种本能去定义、拆解、抬升、证伪。指挥官比士兵难当一百倍，因为士兵只要执行一个动作，指挥官要对整场战役的胜负负责。

这就让我想起一枚鸡蛋。

我做过一人公司，主打 AFF，有独立站，底下是一堆 Python 脚本、Bash 脚本、定时任务，再压几个会自己干活的东西进去。说实话不优雅，挺脏的，但它能自己转。我盯着这套东西看得久了，脑子里浮出来的，总是一枚蛋的样子。

一枚蛋的壳只有 0.3 毫米，薄得一捏就碎。但就是这层薄薄的壳，包住了里面一整套完整的生命系统。壳很薄，可它是定义边界、维持秩序、决定生死的那一层。

AI 时代的构架师，就是那层 0.3 毫米的壳。

人这一层，会越来越薄。从前一个项目要几十个人，现在可能一两个人加一群会自己干活的机器就够了。人少到极致，薄到极致。但是——这层壳是用什么做的，决定了里面那套生命系统是活的还是死的。

如果这层壳是用那四种思维做的，它薄而坚韧，它能往下掉一层、能拆解、能抬升、能证伪，那么里面那套庞大的执行系统就被它牢牢定义着、约束着、纠正着，它是活的。如果这层壳是空的，是一个只会喊“帮我做个 XX“、被机器随便糊弄就满足的人，那么这层壳薄而脆，一捏就碎，里面的执行系统再强大，也只是一坨没有边界、没有方向、没有验证的黏液，迟早烂掉。

我见过太多人想做一人公司，想当那个指挥一群机器的孤胆英雄。他们买工具、攒配置、学花活，把外面那些放大器堆得满满当当。但他们那层壳是空的。他们没有那四种思维，所以机器越强，他们死得越快——因为强大的执行力配上空洞的定义，等于高速地奔向错误。

构架师与其说是一个职位，不如说是一种壳的材质。

讲到这儿，软件工程那套老掉牙的分工——初级、中级、资深——其实已经悄悄换了坐标系。新的坐标系里，分工不再按“你写代码写得多熟“来排，而是按“你那层壳是什么材质“来排：你是问题的定义者，还是别人定义完了你来执行？你是那个能架起证伪电网的人，还是那个在电网外面瞎转的人？你是站在代码上一层的人，还是死死扒在代码这一层不肯上去的人？

这个新坐标系特别残酷，因为它不看资历，只看思维。一个写了二十年 CRUD 的“资深“程序员，可能那层壳是空的；一个二十岁、但骨子里就爱往底层钻、爱拆东西、爱证伪的年轻人，那层壳可能厚得很。前者会越来越慌，后者会越来越值钱。

有人说我们是这个时代的铁匠——一门曾经显赫的手艺，正在变成爱好。这话有点丧，但也有点真。如果你把“程序员“理解成“会写代码的人“，那确实，这门手艺正在贬值，机器抢走了铁锤。但如果你把“程序员“理解成“那个会往下掉一层、会拆解混沌、会站在上一层、会证伪一切的人“——那他不是铁匠，他是那个决定要锻造什么、并且能验证锻出来的东西到底合不合格的人。铁锤可以交给机器，但“锻什么“和“合不合格“，永远是壳的事。

第七章：这四样东西，到底怎么练

说了一堆思维，你大概在等一个问题的答案：这玩意儿怎么练？

我先把丑话说前头。这四种思维，没有速成班，没有七天精通，没有看完一篇文章就脱胎换骨这种好事。它们是用时间和坑喂出来的。但有没有“练的方向“？有。我把每一种的练法，用最朴素的话给你点出来，你自己拿去磨。

练汇编思维（往下掉一层）：一辈子至少彻底拆穿一个抽象。

你不需要天天写汇编，这年头也犯不着。但你这辈子，至少要挑一个你天天用、却从来没搞懂的抽象，把它彻底扒光。你天天用 HTTP，那就去看一次一个请求从你按下回车到收到响应，中间到底经过了多少层、每一层在干什么。你天天用数据库，那就去看一次你那条查询语句，底下到底是怎么走索引、怎么扫表的。

扒一次就够。因为你会在某一刻经历一种震撼——“原来底下是这样”。这种震撼会永久地改造你看世界的方式。从那以后，你再面对任何漂亮的抽象，心里都会有个声音问：底下呢？这个声音，就是汇编思维。它一旦长出来，就拔不掉了。

练面向对象思维（拆解）：把一个模糊需求拆到不能再拆。

这个练法特别枯燥，但特别管用。拿任何一个你脑子里的“帮我做个 XX“，然后强迫自己，把藏在这五个字底下的每一个问号，一个一个写下来。

“做个交易系统”——行情从哪来？多少个交易所？信号怎么算？延迟容忍多少？下单失败了怎么办？仓位上限是多少？回撤到几要停？……你写着写着会发现，原来那五个字底下，藏着几十上百个你根本没想过的问号。把这些问号全挖出来，再逼自己每一个都用一句话答清楚，答不清楚的，继续拆。

这个动作，做一百遍，你那把拆解的手术刀就磨出来了。到那时候你会发现，你跟 AI 之间最大的差距，不在它会不会写，在你会不会拆。

练 Lisp 思维（站到上一层）：写一次“生成器“，而不是“产物“。

找个小活，别直接做它，而是做一个“能做它的东西“。比如你要给十个站写介绍，别写十篇，写一个能生成介绍的模板逻辑。比如你要处理一批文件，别一个个处理，写一个能处理任意一批文件的东西。

哪怕这个生成器很小、很丑，都没关系。关键是，你要亲身尝一次“站在产物上一层“的滋味。这种滋味很奇特，一开始会觉得绕、觉得费劲，明明直接做更快。但一旦你尝过它，尝过那种“我写一次，它替我干一千次“的爽，你就回不到一个一个手工做的状态了。而这个“回不去“，就是你被抬到代码上一层的标志。

练对抗思维（证伪）：拿到任何结论，先问“如果它错了，我怎么会知道？“

这是一个能改命的提问习惯，养成它，比学任何工具都值钱。

不管是 AI 给你的代码，还是你自己得出的判断，还是别人信誓旦旦的结论，你拿到手第一件事，不是问“它对不对“，是问：“假如它是错的，我有没有办法立刻发现？”

如果答案是“没有办法“，那么对不起，无论它看起来多对、说得多笃定，你都没资格信它。因为一个你无法证伪的东西，它对你来说没有信息量，它只是一个让你舒服的幻觉。你得先给它造一个能戳穿它的工具——一套测试、一组反例、一次样本外的检验——然后看它能不能扛住。扛住了，它才值得你信；扛不住，趁早扔。

把这个习惯练到成为本能，你就拥有了 AI 时代最稀缺的防身术：在一个会自信地骗你的世界里，你天生免疫漂亮的废话。

这里还要补一种和证伪连在一起的、容易被忽略的设计本能。面向对象那一套之外，老一辈程序员还琢磨出过一种叫“面向切面“的思路，专门用来处理那些横切一切、不属于任何单个对象的关注点——比如日志、权限、监控。它们不归任何一个具体功能管，却必须笼罩在所有功能之上。

构架师对 AI 军团的验证和审计，恰恰就是这样一种横切关注点。“它到底做了什么、有没有偷偷搞砸、每一步留没留下痕迹”——这件事不属于任何一个具体的子任务，它必须笼罩在整支军团之上。你把这张横切的审计之网架好一次，它就替你盯着所有的活，而不是你跟在每个活后面一个个查。这是证伪思维在大规模下的工程形态：不是一件一件去验，是织一张网，让所有东西都在网下面跑。

练判断力的分配：复盘你的精力都花哪儿了。

这一条最反直觉，也最少有人练。

找个周末，认真回想一下，过去一个月，你那点宝贵的深度思考，到底花在了哪些事情上。我几乎可以预言你的结论：你会震惊地发现，绝大部分精力，花在了根本不承重的边角上——那些就算你想得再透、做得再完美，也不会改变任何结果的小事。而真正承重的那几个决策，你反而想得稀里糊涂，因为它们难、它们让你不舒服，你下意识地躲开了它们，跑去把精力发泄在好对付的小事上。

人有一种特别坏的本能：用战术上的勤奋，逃避战略上的思考。把简单的小事做到极致，会带来一种“我很努力“的踏实感，而这种踏实感，恰恰是用来麻痹你、让你不去面对那个真正难的、承重的决策的。

练判断力分配，就是反复地、刻意地，把你的脑力从那些舒服的小事上拔出来，按在那个让你头疼的承重决策上，直到把它想透。这个动作每做一次都很痛，但你每做一次，你那层壳就硬一分。

这五样东西——掉一层、拆解、上一层、证伪、分配判断——没有一样是看完就会的。它们是你往后每一次面对一个真实问题时，可以刻意去练的方向。练一次进步一点，练十年，你就成了那个市场上标价最高的人。

而绝大多数人不会练。他们会绕过这条又慢又痛的路，直接奔向那条又快又爽的路——去堆工具、攒配置、学花活。

这就是为什么，我要在最后，专门讲一讲那条又快又爽的路。

第八章：外挂是最强的辅助，但它放大的是零还是一

写到这里，你可能一直在等我讲工具。

讲那些会自己干活的东西，那些能让一个人指挥一支机器军团的配置和花活。市面上铺天盖地都在讲这个，恨不得每个缩写都开一门课。

但我从头到尾没怎么讲，而且现在也不打算讲。

原因很简单。我十几岁玩金山游侠的时候就明白了一个道理，这个道理这二十多年从来没变过：

外挂是最强的辅助，但它放大的是零，还是一，取决于你自己。

当年那些靠外挂横行的人，分两种。一种人，外挂一关就废了，因为他什么都不会，他全部的本事就是那个外挂。另一种人，把外挂拆开看过、自己改过、甚至自己写过，外挂对他来说只是省时间，关掉他照样能玩，因为底子在他脑子里。

第一种人，外挂是他的全部。第二种人，外挂是他的放大器。

AI 时代所有的工具，本质上都是放大器。它们极其强大，强大到能把一个人的产出放大几十上百倍。但放大器有一个冷酷的特性：它对零无效。

你那层壳是空的，思维是零，工具把你的零放大一百倍，还是零。甚至更糟——它会让你以为自己有了一百倍的本事，于是你更快、更自信地奔向你根本看不见的悬崖。这就是我在第一章说的，工具是掉得下去的人的放大器，是掉不下去的人的悬崖。

而你那层壳如果是用那四种思维做的，是一，那么工具把你的一放大一百倍，就是一百。这时候，那些会自己干活的东西、那些能并行调度的配置、那些花里胡哨的缩写，才真正成为它们应该成为的样子——你思维的延长线，你判断的扩音器，你那层壳之外最强的辅助。

所以工具该不该学？该学。但顺序千万别搞反。

先有那个十几岁就趴在内存地址上、不肯相信表面血条的本能；先有把混沌拆成对象的手术刀；先有站在代码上一层的姿势；先有不被任何漂亮东西洗脑、只信证伪的职业病。先把这层壳锻硬。然后，再去拿那些最强的放大器。

顺序对了，你是构架师，工具是你的军团。顺序反了，你是工具的提线木偶，看起来指挥着千军万马，其实连自己在打哪场仗都不知道。

第九章：一个下午，杀死了我信了二十年的东西

我得跟你讲一件事，到今天想起来都觉得脊背发凉。它发生在 2025 年。

讲之前，先交代我的底色。

我这辈子信的，就两个字：技术。

从十几岁那个偷偷改技能的孩子开始，我信奉的是技术为王。我吃了二十多年技术饭，靠的全是脑子里那些别人没有的东西——那四种思维，那些趟过的坑，那套用命喂出来的系统。我把自己活成了一座一个人的城堡。城墙又高又厚，墙里堆满了别人攻不进来的本事。我一直以为，这座城堡是永久的；我一直以为，技术就是我的护城河，挖得越深，越没人能碰我。

直到那个下午。

我带过一个小徒弟。聪明，肯学，但论功力，跟我隔着十几年的距离——那种距离，我以为是非得用十几年的夜、十几年的坑熬出来的，没有捷径，也不该有捷径。

那个下午，他用 AI，把我的交易系统，复刻了出来。

我做了八年多量化，那套系统是我的命根子，是城堡里最深的一间密室。它的每一条逻辑、每一个止损、每一处对人性的提防，都是我用真金白银、用一次次爆仓喂出来的。我一直觉得这种东西复制不了，因为它不像知识那样能学，它更像直觉，像我身上一道一道的疤。

他用 AI，把它倒了出来。不是分毫不差，但七八分神似，而且——他根本不需要懂我当年是怎么疼过来的。机器替他把我脑子里那些疤，翻译成了他能直接拎走的代码。

那个下午，没人说话。我盯着屏幕看了很久。

我信了二十年的“技术为王“，就在那个下午，悄无声息地，死了。

我得讲清楚，这件事到底动摇了什么，因为它跟你前面看的八章，是顶着干的。

前八章我一直在说：那四种思维是这个时代标价最高的东西，是机器复制不了的护城河。这话对，但只对了一半。

那个下午让我看明白的，是更冷的另一半：所有的技术，无论多深，骨子里都是信息。而信息，一旦工具足够好，就会流动、会复制、会从一个脑子，倒进另一个脑子。

我的护城河，原来是水做的。它看着固若金汤，直到有个东西，让它哗啦一下淌走了。

那四种思维让我活下来了，让我一个人扛住两千个分身、做了八年量化——这是真的，我不收回。可那个下午逼我承认一件更狠的事：我花了二十年，把自己练成了那个“可以被复制的层“上的顶尖高手。

你看，又回到那个改游戏的孩子身上了。我引以为傲的一切——等级、金钱、技能——我这辈子干的，一直是改“有什么“和“能做什么“。而 AI 现在最擅长改的，恰恰就是“能做什么“：它能把任何人的“能做什么“，一键拉满，包括把我的那身本事，整包塞给一个小徒弟。

那么，到底还有没有一样东西，是机器倒不出来、复制不走、永远改不了的？

这个问题我想了很久。答案藏在那个下午里，藏在一个我当时没在意的细节里。

他复刻走了我的系统，每一行代码，每一个参数，全拿走了。

可有一样东西，他一点没拿走，也拿不走。

是我和那些人之间的东西。

是我为什么信任某几个人、提防另几个人；是那些年一起爆过仓、一起熬过通宵、在我最难的时候没掉头走的人；是那些没法写成代码、没法被机器翻译、没法被任何工具倒出来的，人与人之间的牵连。

代码复制得天衣无缝。那些东西，一个字节都没复制走。

因为它们压根就不是信息。它们不是内存里一个能被搜索、被锁死的数字。它们是这个世界上，唯一一种你改不了技能、加不了血、破解不了的东西。

二十年了，我第一次发现，我最看不上的那个“软“的层——人和人之间那点说不清的东西——是唯一一个，机器的手伸不进去的层。

我经常想起十几岁那个趴在屏幕前的我。

他不知道什么是抽象泄漏，不知道什么是面向对象，没听过 Lisp，更不懂证伪。他只是单纯地、固执地，不肯相信屏幕上那条红色的血条——他非要去搜内存，非要去摸底下那个会变化的数字，非要把它锁死。

他以为，只要能摸到底下那个数字，就能掌控一切。后来他真的用了二十多年，去摸越来越底层的数字：从血条摸到技能，从游戏摸到市场，从一个人摸到两千个分身。每摸深一层，他就更相信一次——技术为王，往下捅得越深，越没人动得了我。

他对了很久，又在某个下午，错得很彻底。

因为这个世界上，有一条血条，是永远摸不到内存的。它不在任何一台机器里，不在任何一行代码里，搜不到地址，锁不住数值，机器倒不出来，徒弟拎不走。

那条血条，在人和人之间。

它是这个时代，机器替你做完了几乎所有“表面“的活、又顺手把你引以为傲的“里子“也复制走之后，唯一还留在你手里、真正属于你的东西。机器越强，它越值钱。因为机器能复制一切信息，而它，恰恰不是信息。

我这辈子构架过系统，构架过站群，构架过策略，构架过一座只装得下我一个人的城堡。

接下来，我想去构架一样，二十年前的我一定会嗤之以鼻的东西。它不能被写成代码，所以也不能被复制。它很慢，很笨，很不“技术“。具体是什么，我先不说。

我只说一句：我要走的方向，和我过去二十年，正好相反。

现在轮到你了。

机器已经能替你写代码了，写得又快又多又规整。它甚至能把你最深的本事，整包倒给一个比你年轻十几岁的人。你大概率会慌，会想赶紧去学怎么“用“它，把那些最强的放大器堆满。

我劝你先停一下。把工具关掉，把代码关掉，把你这辈子引以为傲的全部技术，都假装已经被人原样复制走——

然后问自己一个问题：

剩下的那一点点，没法被复制、没法被倒出来、没法被一键拉满的东西——你，到底还有多少？

PS：本来想写成AI构架师系列的。后来想想，构架思维不一定用在AI上。