从专利高墙到指令世界：CPU、终端、PLC与游戏指令的底层逻辑

2005年，电脑还是Pentium 4的天下，我窝在一个电子DIY论坛里，看到一条让我记了快二十年的回复。有人问“怎么才能设计自己的CPU指令集”，楼下一位老哥贴出一长串专利号，然后冷冷地说：“你随便定义一条指令，都可能踩到别人早就圈好的地。想绕开这堵墙，先学十年法律。”那天下午我顺着专利网站一个个点进去，越看越窝火。我想要的不过是一个自己的加法指令，凭什么要被一堵看不见的高墙挡住？

这个愤懑成了我做“指令之心”系列的第一块基石。这个系列没有别的使命，就是把“指令”这件事讲透：从CPU底层的机器指令，到终端里敲的Linux命令、Windows的CMD命令，再到ESP8266上的AT指令、西门子博图里的PLC指令，甚至游戏聊天栏里的Minecraft指令。这些东西各有语法，各有脾气，但底层逻辑非常像，都是人向某个系统发出一句结构化的话，要求它执行动作。2024年的搜索热榜上还满是“豆包清理电脑指令”“MC指令大全”“Linux系统排查指令大全”这类词，说明大家一直在找指令，却常常找不到能把它们串起来的逻辑。所以第一集，我们回到2005年那堵专利高墙下面，先讲清楚为什么一个简单的“指令”会让人感到愤懑。

1. 一个2005年的下午：当专利墙挡在代码面前

1.1 那个让我翻了一下午专利库的提问

当年那个帖子问的是“能不能开发一种新的CPU指令集”。对于一个整天抱着奔腾4跑模拟器的爱好者来说，这问题天真又热血。指令集就是CPU的母语，你懂得越多，越觉得应该有自由去定义新的说话方式。可楼下的回复把温度一下降到冰点：光是“每条指令的二进制编码、译码方式、执行单元的组织方法”这些维度，就可能分别被不同的专利覆盖。你想实现一个ADD，前人在1990年用一条宽泛的权利要求把所有“两数相加并写回目的寄存器”的方法圈住了，那你就要换编码、换执行路径、换数据流结构，最后换出来的东西很可能已经不是你想要的“简单指令”了。

那一下午我翻了几十份公开专利文本，最大的感受不是“哪个公司坏”，而是规则本身就把门槛抬得太高。一个只读过几本编程书的人，连专利的权利要求书都未必能读通，更不要说去设计绕开方案。高墙不是某个人盖起来的，是整个行业用二十年的时间慢慢垒起来的。回过头看，那股愤懑其实并不是针对某个具体的企业，而是针对一种“明明道理我都懂，可就是不能自由去做”的制度环境。

1.2 指令的真正身份：芯片与程序之间的母语

要理解那堵墙为什么存在，得先说清楚“指令”在计算机里到底处在什么位置。程序是人类想法的一长串转述，机器没法直接理解，所以编译器会把代码翻译成一串数，这串数就是机器指令。每个指令由一个操作码和一些操作数组成，CPU按照固定套路去取指令、译码、执行。比如x86里，8B C3这个两个字节的机器码，翻译成人话就是“把EBX寄存器的值移动到EAX寄存器”。同样的动作，在ARM或者RISC-V上可能用不同编码表达，这就是指令集差异。

指令集就是一颗CPU对外公开的契约：你按这个格式给我指令，我就按那个约定执行。它决定了芯片能干什么、程序怎么编译、编译器怎么优化。2005年的时候，x86已经统治了PC，ARM正在统治移动设备，它们的指令集都背负着几十年的历史包袱。如果你想去优化这些已经被验证过的指令编码，那不是在写代码，是在和几十年的专利布局硬碰硬。

1.3 高墙的真实含义：编码权和实现方式都被锁死

专利高墙不是说你不能写一个叫ADD的助记符。助记符本身是文字，不构成侵权。真正麻烦的是二进制编码和实现方式。CPU拿到的是一串二进制位，它必须知道这串位代表哪个操作、操作数放在哪、结果写到哪里。你对二进制编码的任何新的安排，都可能和已有专利里的权利要求撞车。更麻烦的是，即使你绕开了编码，执行这条指令时用到的译码器结构、加法器复用方式、流水线状态机，每一层也都有专利。这就像院子里还有院墙，院墙里还有屋子，你不知道哪一间进去会碰到法律的红外线。

我给你举个简化例子。假设我只想定义一条指令：从内存地址0x1000读取一个32位整数，加1，写到0x2000。这个动作至少涉及三个维度：指令编码（操作码怎么选）、寻址模式（地址怎么表达）、执行单元（谁来做加法）。如果A公司已经申请了“一种以特定前缀区分访存操作与算术操作的方法”，B公司申请了“一种用立即数扩展实现任意内存地址访问的方法”，那我的新指令在第一关就出局了。你说我全用软件模拟，不走硬件实现，那也许能绕开硬件电路专利，但指令编码如果与已有专利重叠，软件模拟也可能被认定构成仿冒。这就是愤懑的核心：一个看似自由的可以开拓的领域，实际上布满了看不见的红线。

2. 指令到底有多少种：从Minecraft到PLC再到Linux终端

2.1 同一句话，完全不同的话语体系

“指令”这个词在2024年的搜索热榜上出现了几十种完全不同的场景。有人在找Linux指令大全，有人在查mc1.8.8指令，有人问博图AT指令怎么用，还有人搜豆包优化电脑的指令。表面上看它们毫不相干，实际上它们都符合同一个模型：一个用户（人或者脚本）向一个解释器（shell、CPU、PLC扫描器、游戏引擎）发送一条结构化消息，解释器解析后执行动作，然后返回结果。所谓指令，就是“一句话让系统干活”的标准化表达。

但不同系统的表达方式差异极大。CPU指令是最底层的二进制，Linux终端命令是文本，PLC指令既可以是梯形图里的线圈也可以是STL语句表，Minecraft指令是聊天栏里以/开头的一段话。理解它们共通的“输入-解析-执行-反馈”模型，会让你学习任何新指令都快得多。我每次接触新指令系统，都先画一条很窄的流水线：谁接收、谁解析、执行后返回什么。把这三件事搞清楚，剩下的语法只是时间问题。

2.2 CPU指令集：最硬核的底层契约

CPU指令是二进制的，但开发者通常用汇编助记符。比如x86的MOV EAX, 1、ARM的MOV R0, #1、RISC-V的addi x1, x0, 1，语义都是“把立即数1放进寄存器”。学习这些指令，实际上是在学一台机器怎么思考。用objdump -d反汇编一个可执行文件，你就能看到源代码变成的一串指令；用gdb断在某个函数入口，也能看到每一步执行的是哪条指令。

CPU指令和终端指令最大区别在于，终端命令是给人用的，有的解释器能自动补全、给你提示，而CPU指令是给机器吃的，错一个位就行为异常。也因为这个原因，CPU指令集被专利高墙围得最严实。你想加一条新指令，不是像加一个Linux别名那样容易，而是要动处理器本身的设计，这自然会碰到一大堆已有专利。

2.3 终端和Shell指令：人机之间的快捷通道

终端指令是普通人最容易接触的一类。Windows的dir、ping、ipconfig，Linux的ls、cd、grep、systemctl，都属于这个类别。它们的共性格式是：命令名字 + 选项（option）+ 参数（argument）。例如ls -l /etc，ls是要执行的程序，-l是长列表输出选项，/etc是目标路径。你不需要理解内核怎么解析，只要记住这个语法模式，就能很快套用到新的命令上。

我在实际排查服务器问题时，最喜欢的一组是top看负载、free -h看内存、df -h看磁盘、journalctl -xe看日志。热词里的“Linux系统排查指令大全”其实就是把这些命令按场景整理成速查表。这类指令的心智负担很低，只要你掌握“用man或--help查帮助文档”的习惯，就会滚雪球。Windows用户也别觉得没法学，ipconfig /all、netstat -ano、tasklist | findstr这三条配合起来，能应付一大半日常网络排查。

2.4 设备控制指令：AT与SCPI的请求-响应世界

AT指令是另一个高频搜索词。它起源于调制解调器时代，现在大量用在Wi-Fi模块、蓝牙模块、4G模块上。比如ESP8266的AT+CWMODE=1设置Wi-Fi Station模式，AT+CIPSTART="TCP","192.168.1.1",8080建立TCP连接。你通过串口把这行文本发给模块，模块执行后返回OK或ERROR。这种“请求-响应”模式非常简洁，很多物联网开发者入门就是从这些AT指令开始的。

SCPI指令则用于测试测量仪器，比如*IDN?查询仪器身份、MEAS:VOLT:DC?读取直流电压。热词里专门有“力科示波器SCPI指令”，说明工程师在自动化测试里常被它卡住。SCPI的共同点是都有严格的语法树，按标准格式写，仪器就照做；语法错了，仪器会返回错误队列。学习AT和SCPI，其实就是在学习怎么和一台“不能理解你意图”的设备清清楚楚地对话。

2.5 工控PLC指令：把继电器逻辑搬进扫描循环

PLC的指令体系和前面完全不同。西门子博图（TIA Portal）里常见梯形图和语句表，梯形图里的置位（S）、复位（R）、TON定时器、计数器，都是在模拟传统继电器电路。热词里有“一键启停程序两个线圈互锁用了置位与复位指令作用于一个线圈另一个还是置位怎么实现了常开常闭的不冲突”，这其实是在问一个经典的双线圈互锁问题。PLC的扫描机制是“从上到下、从左到右”周期扫描，如果你在一个程序段里对同一个输出线圈既置位又复位，执行顺序会直接决定最终状态，所以很多初学者会在这里踩坑。

学PLC指令，重点不是背语法，而是理解扫描周期和存储区划分（I区、Q区、M区、DB块）。你会写置位复位、会用定时器、再懂互锁，就已经能解决大部分基础电机控制问题。别被那些掉书袋的论坛帖子吓到，本质上PLC指令就是在回答一个很简单的问题：这一秒钟里，哪些继电器应该吸合。

2.6 游戏和应用内指令：轻量级的交互协议

游戏指令是很多人第一次接触“指令系统”的地方。Minecraft是典型代表：在聊天栏输入/gamemode creative进入创造模式，/give @p minecraft:diamond_sword 1给予物品。这类指令有权限系统、参数校验、错误提示，本质上就是一个小型命令行解释器。还有《原神》《星穹铁道》，玩家口中说的“抽卡记录指令”，往往是指用工具导出记录时填写的参数或脚本命令，虽然和真正的控制台指令不同，但也遵循同样的“输入-解析-输出”模型。

我把它们整理成一张表，方便对照：

这张表足够用了。以后你在任何新环境里遇到“指令”，先问三个问题：它由谁解析？它接受什么参数？它返回什么结果？把这三个问题答出来，你就已经入门了一半。很多人学指令慢，不是因为记忆力差，而是从来没有从这几百种表面不同的指令背后，找到那条相同的逻辑线。

3. 2005年的高墙是怎么砌起来的：指令集专利的三十年

3.1 指令集不只是技术，还是商业版图

为什么标题要强调2005年？因为那一年正是指令集专利体系最胶着的时间点。1970年代，处理器指令集更像一份技术说明书，大家都在探索怎么让计算机做更多事。但到了1980年代，芯片公司突然意识到，指令集一旦被开发者接受，就会形成生态，后来者为了兼容就必须使用同一套指令集。于是“指令集”从技术变成了商业壁垒，专利申请也成了一种军备竞赛。

那段时间里，今天有人申请“指令预取方法”，明天有人申请“分支预测装置”，后天有人申请“立即数扩展电路”。每一个专利看起来都很具体，但堆在一起就是一面墙。到1990年代末，你要设计一款新CPU，几乎不可能不碰到别人已经申请过专利的微观结构。更讽刺的是，RISC（精简指令集）本来是为了简化指令数量，结果连“如何简化”都被大量专利包围，想精简反而要先解决法律问题。

3.2 2005年：专利池、交叉许可和开发者挤不进去的窄门

到了2005年，PC市场已经是x86的天下，移动市场开始被ARM渗透。这两大阵营内部都有着庞大的专利组合与交叉许可协议。新玩家如果要做兼容CPU，必须拿到授权；如果要做不兼容的新指令集，则要绕开海量专利。很多程序员都听过“x86授权”“ARM授权”这类说法，授权费背后其实就是那堵墙。更让人愤懑的是，专利文本往往故意写得极其晦涩，一个简单的“把一个寄存器里的数送到另一个寄存器”，可以用几十个词绕成一页纸。

2005年的我读了一下午专利库，唯一记住的是“权利要求1-12，均被引用”。这种晦涩本身就是一种威慑，让绝大多数技术爱好者知难而退。所以“专利高墙下的愤懑”，不仅是恨墙高，还恨墙不透明。普通人不是不愿意绕开专利，而是根本看不懂专利画出来的边界在哪里。这种无力感，才是愤懑的核心。

我还记得身边一个朋友的遭遇。他当时想基于MIPS公开论文做一套教学用的8位单片机仿真器，不敢碰x86，也不想碰ARM授权，结果第一版设计刚落地，就被提醒“你的指令编码和某公司1994年的专利撞了”。他只好把操作码重新排布，又增加两位扩展位，才勉强绕开。这事听起来像段子，但真实世界就是这样：你正常想一个设计，也可能莫名其妙撞上别人几十年前画下的圈。

3.3 高墙之内的空隙与反抗火种

当然，专利墙不可能密不透风。2000年前后已经有了OpenRISC这类开源指令集架构，只是生态极度弱小：没有成熟的工具链、没有便宜的开发板、也没有GNU编译器默认支持，普通玩家根本不会去碰。直到2010年RISC-V在伯克利诞生，开放指令集才有了真正意义上的破墙者。但那是后话。站在2005年的视角，RISC-V连影子都没有，那些被高墙挡住的人，只能用软件模拟器过干瘾。

这一段的重点是：技术生态的变革通常源于愤懑，而愤懑必须转化成系统的学习，才可能参与破墙。当年那些只知道在论坛里抱怨的网友，和后来成为开源芯片社区骨干的人，差的不是智力，而是有没有把那股愤懑变成深入研究指令集的动力。回到2005年，真正让我获益的不是愤怒本身，而是愤怒之后我开始读体系结构教材、写模拟器、学汇编，一点一点把那堵墙的轮廓摸清楚。

4. 从愤懑到破墙：给普通人的指令学习路线

4.1 先把常用终端指令学好，建立指令感

无论你以后走多深，终端指令是最容易获得正反馈的入口。Windows用户先掌握dir、cd、ipconfig、ping、netstat；Linux用户掌握ls、cd、cp、mv、rm、grep、awk、sed、systemctl。不用一次记很多，真正常用的就三四十条。遇到不认识的命令，用man 命令名查帮助，一两周就能形成肌肉记忆。热词里的“cmd指令大全指令”“linux打开终端指令”，本质上都是在问这个。

我的建议是不要死背速查表，而是背“场景-命令”的对联：查进程用ps aux，杀进程用kill，看端口用netstat -tunlp，定位系统问题用journalctl -xe。有了场景，命令自然记住。还有一个技巧：不要直接搜“全部指令”，去搜“排查CPU占用命令”“查看端口占用命令”，搜到的都是可以直接套用的场景组合，比背一本手册高效得多。

4.2 往底层走一步：用反汇编看指令长什么样

终端指令属于应用层，再往下是系统调用和机器指令。想理解指令集，最快的方法是把一段C代码编译成汇编。在Linux上：

cat > test.c <<EOF int add(int a, int b) { return a + b; } EOF gcc -O2 -S test.c cat test.s

你会看到类似addl %edi, %esi的汇编行。进一步用objdump -d test.o查看机器码，能直接看到指令的二进制表示。这个过程能让你理解：源代码里的一个加号，底层对应某条指令编码；不同优化等级，编译器会选不同的指令组合。对“指令”的理解，就是要从这里开始。别觉得汇编难，你不需要会写完整汇编程序，只要能认出常用的几十条指令，就足够建立起“指令感”。

4.3 在嵌入式世界接触AT指令和SCPI，体会设备对话

如果你喜欢硬件，花几十块钱买一块ESP8266或ESP32模块，用USB转串口工具接上，打开串口终端，输AT回车，模块回OK，你就已经完成了一次设备指令交互。接着试AT+CWMODE=1、AT+CWJAP="SSID","Password"，最后用AT+CIPSTART建立连接。这个过程会让你理解什么叫“协议状态机”：不是你想发就发，模块在某些状态下会拒绝某些指令并返回ERROR。

SCPI指令更建议在有示波器、万用表的实验室里玩。*IDN?是经典的自查指令，很多自动化测试程序靠它判断仪器是否在线。只要记住“仪器是哑终端，你说什么它执行什么，语法错了就报错”，SCPI就不难。这比读一百页手册有效得多，因为你会发现所有SCPI指令都遵循同一种树状语法，学一条能推十条。

4.4 工控PLC指令：从置位复位悟出扫描逻辑

PLC的学习门槛主要在思维转换。在博图软件里，你写的程序不是在“一行行执行”，而是在描述一个周期性反复扫描的电路网络。置位指令S Q0.0会让输出线圈保持接通，复位指令R Q0.0让它断开。如果你同时对同一个线圈写了置位和复位，谁在程序中靠后，谁就决定最终状态。搜索热词里的“双线圈互锁问题”，其实就是没搞懂这个顺序。当你使用置位和复位指令时，还要注意它们对同一个线圈的抢占顺序，否则会出现电机一启动就被停掉的诡异现场。

建议在博图里搭一个起保停电路：启动按钮I0.0置位Q0.0，停止按钮I0.1复位Q0.0，再用Q0.0的常开触点做自保持。把这个逻辑跑通，你对PLC指令的感觉就建立起来了。至于TON、TOF、计数器，都是在基本逻辑之上的延展，有了扫描周期的思维，这些都不难理解。

4.5 用游戏指令培养条件反射

别小看Minecraft指令。/gamemode creative这类命令虽然简单，却包含完整的“命令+参数”结构，而且有权限系统和错误提示。在服务器上试着用/give @p minecraft:diamond_sword 1给物品，你会遇到参数解析错误，这就是指令系统的基本校验。学会输入/help查看命令帮助，你会发现游戏模拟了一个标准命令解释器。这种环境几乎没有风险，适合新手练手。

同样的道理也适用于其他游戏工具。比如热词里的“星穹铁道抽卡记录指令”“原神指令”，本质上是用一小段脚本命令把大数据导出来。你不需要精通编程，只要能看懂“命令+URL+参数”的结构，就能完成一次真实的数据交互。游戏里的“指令感”，会迁移到终端和嵌入式开发里，不要觉得那是浪费时间。

5. 一次实战模拟：在2005年被专利高墙挡住的自定义指令

5.1 定义一个只有四条指令的玩具CPU

先别去碰真实芯片。我们用Python写一个最小模拟器，用来体验“自定义指令撞墙”的过程。假设这个CPU支持四条指令：0x01LOAD从指定内存地址取值存入寄存器，0x02STORE把寄存器值写入指定内存地址，0x03ADD把两个寄存器相加，0x04JMP跳转到指定地址。代码很短，但已经能模拟一个最简单的取指-执行循环。

class ToyCPU: def __init__(self, memory, program): self.regs = [0] * 4 self.pc = 0 self.memory = memory self.program = program def step(self): op = self.program[self.pc] if op == 0x01: # LOAD addr = self.program[self.pc + 1] reg = self.program[self.pc + 2] self.regs[reg] = self.memory[addr] self.pc += 3 elif op == 0x02: # STORE addr = self.program[self.pc + 1] reg = self.program[self.pc + 2] self.memory[addr] = self.regs[reg] self.pc += 3 elif op == 0x03: # ADD r1 = self.program[self.pc + 1] r2 = self.program[self.pc + 2] r3 = self.program[self.pc + 3] self.regs[r3] = self.regs[r1] + self.regs[r2] self.pc += 4 elif op == 0x04: # JMP self.pc = self.program[self.pc + 1] else: raise ValueError(f"unknown opcode 0x{op:02x}") def run(self): while self.pc < len(self.program): self.step()

先别急着研究代码细节，注意一个关键点：0x03这个操作码被用来表示“三个寄存器相加并写回第三个寄存器”。这个编码加操作数序列，在真实世界里是可能撞上专利的，但在模拟环境里暂时没人管。

5.2 加载程序并执行

我们写一段小程序：把内存地址100和101的两个数分别取到寄存器0和寄存器1，相加后写到寄存器2。然后停止，用一个不存在的操作码0x7F触发异常来终止运行。

program = [ 0x01, 100, 0, # LOAD addr=100 -> reg0 0x01, 101, 1, # LOAD addr=101 -> reg1 0x03, 0, 1, 2, # ADD reg0 + reg1 -> reg2 0x7F # 触发停止 ] memory = [0] * 200 memory[100] = 35 memory[101] = 7 cpu = ToyCPU(memory, program) cpu.run() print(cpu.regs[2]) # 期望输出42

运行后输出42，程序正常。这个玩具CPU本身没有任何专利问题，因为它只是用Python写的解释器，而且没有任何实用价值。但请注意，“没有任何实用价值”不等于“不会侵权”，专利侵权的判定从来不看你有没有商业价值，而看你是否落入了权利要求的范围。

5.3 模拟专利检查：你的编码撞墙了

现在模拟2005年的情况。假设某专利持有人已经把0x03定义为：“在指令流中指定三个寄存器并执行加法的方法”，权利要求覆盖了“使用一个字节作为操作码、后随三个寄存器编号、结果为第三寄存器”。这时，我们的ADD指令正好完全命中权利要求。我用一个简单函数模拟检查：

PATENTED_ADD = [(0x03, 3)] # 专利覆盖的操作码和操作数个数 def check_patent(opcode, operand_count): for pat_op, pat_cnt in PATENTED_ADD: if opcode == pat_op and operand_count == pat_cnt: return True return False if check_patent(0x03, 3): print("侵权警告：ADD指令的编码与专利权利要求重叠") # 现实中的后果是诉讼风险，而不是打印一行警告

当你看到屏幕上跳出“侵权警告”时，就能体会2005年那些DIY爱好者的处境：代码明明是对的，只是因为一个字节的编码撞上了法律文书，你就不能继续用。更讽刺的是，专利里写的往往不是某个具体指令，而是一大类“方法”，让后来者想绕也绕不开。

5.4 你能做的反制：换编码、换语义、换实现

在真实世界，遇到专利重叠通常有三条路。第一，调整操作码分配，把ADD从0x03改成0x05，同时改变操作数排列顺序。第二，修改指令语义，比如让ADD变成“把第一个寄存器复制到第二个寄存器后再做加法”，但这样会改变程序语义，增加编译器的负担。第三，绕过硬件实现，改用微代码或软件解释器，避开“特定硬件电路实现”这一类的权利要求。当然，现实中这些方案还要考虑其他专利、兼容性和性能，远比我这个玩具复杂。

我把代码里的0x03改成0x05，并把操作数顺序调整为“目标寄存器在前”，再跑一次，模拟专利就绕开了。这时你会明白，为什么真实处理器里的指令编码看起来总是不够“漂亮”：那不是技术最优解，而是在无数专利缝隙里挤出来的可行解。那些你以为的“随意编码”，其实都隐含着几十年的妥协痕迹。

6. 高墙没有被拆掉，但门多开了几扇

6.1 RISC-V：开放规范，但专利风险依然存在

2005年时，开放指令集几乎是冷门话题。2010年代初，RISC-V从伯克利大学走出来，把指令集架构做成开放标准，任何人无需授权费就可以实现自己的RISC-V处理器。这确实是一道新门。但必须清醒：RISC-V的ISA规范开放，并不代表某一种具体实现里没有专利。你免费使用规范，不能把别人在具体电路、流水线、缓存策略上的专利也随便复制。开放降低的是第一层高墙，而不是彻底拆掉了所有围墙。

这就像开源软件里的许可证和专利条款的关系：开放源代码不等于放弃专利权利。所以遇到RISC-V项目时，多花十分钟读一下许可证和专利声明，是一个好习惯。没有人会因为你的谨慎而骂你，反而会因为踩坑而感激你。

6.2 愤懑没有白费：懂指令的人越来越值钱

我见过不少因为“指令”而产生愤懑情绪的人，最后都成了很好的工程师。有人去啃ARM手册，做嵌入式驱动，天天和AT指令、SCPI指令打交道；有人专攻Linux指令优化，把服务器排查做到肌肉记忆；还有人沉迷PLC置位复位逻辑，成了产线自动化调参高手。愤懑只是起点，重要的是它有没有推动你去把指令的底层逻辑吃透。二十年前那个下午，我在专利库里看到的每一页晦涩文字，后来都成了理解知识产权布局的养料。

如果你此刻也在被某个指令系统卡住，不妨把情绪放一放，先问自己：这条指令由谁解析？它接受什么参数？它会返回什么结果？沿着这三个问题走，你会发现自己比想象中更快进入状态。指令的世界确实有很多墙，但墙与墙之间的通道，往往就藏在这种朴素的追问里。

6.3 指令之心的下一集会聊什么

这个系列的第一集，我们从2005年的专利愤懑讲起，把不同领域的指令类型和一条可行的学习路线串了一遍。下一集我想聊一聊“为什么两条看起来一样的指令，在不同系统上执行效率差这么多”，或者“从AT指令到AI提示词：本质还是一条指令”。方向还没完全定，但可以确定的是，会继续用“从问题到原理再到实操”的方式来写。如果你也有和指令有关的坑，或者当年在专利墙前碰过壁，欢迎在留言区说说，我会挑素材写进后面的故事里。