<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>工程手记 on 吕炘嵘的博客</title>
    <link>https://blog.lvxinrong.com/craft/</link>
    <description>Recent content in 工程手记 on 吕炘嵘的博客</description>
    <image>
      <title>吕炘嵘的博客</title>
      <url>https://blog.lvxinrong.com/og-default.jpg</url>
      
      <link>https://blog.lvxinrong.com/craft/</link>
    </image>
    <generator>Hugo</generator>
    <language>zh-CN</language>
    <lastBuildDate>Thu, 24 Sep 2026 08:10:00 +0800</lastBuildDate>
    <atom:link href="https://blog.lvxinrong.com/craft/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>JOJO！这是我最后的波纹了！你收下吧！</title>
      <link>https://blog.lvxinrong.com/craft/last-ripple/</link>
      <pubDate>Thu, 24 Sep 2026 08:10:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/craft/last-ripple/</guid>
      <description>300 场面试之后，一个面霸留给你们的话。钩子、长板、议程之争，以及书单和课单。</description>
      <content:encoded><![CDATA[<blockquote>
<p>这应该是我在团队知识库里留下的最后一篇文档了。该翻篇的都翻篇了，该收官的也收官了。想留点什么——技术分享？这个大家迟早都学得会，现在有 AI 协助，学一门技术早已不是十年前找不到几篇高质量博客的年代了。心路历程？那个只适合写给自己看。思来想去，决定讲讲大家职业生涯中都必然会遇到的一个环节——面试。</p>
<p>这真的是我最后的波纹了。哈哈哈哈</p>
</blockquote>
<h2 id="先报个数">先报个数</h2>
<p>如果没有记错，我从毕业到现在，面试次数应该在 <strong>300 场以上</strong>。之前我统计过一次邮箱里的面试邀请，大概是这个量级。</p>
<p>我也从一开始面试发怵、站在公司楼下不敢上去，到现在的游刃有余；中间甚至还尝试过“霸面”——没收到邀请，直接去公司前台聊。复盘过自己的技术、投资、生活，唯独从来没有系统地复盘过面试。这一篇，就是补上这一课。</p>
<p>希望它能抛砖引玉，带给大家一些关于面试的不一样的思考。</p>
<h2 id="一个暴论先对面试官祛魅">一个暴论：先对面试官祛魅</h2>
<p><strong>不论什么样的面试、什么样的公司，一定要先对面试官祛魅。</strong></p>
<p>面试官也是人，和我们一样的人。他有擅长的地方，也有不擅长的地方。我们自己做面试官的时候，也一定会从自己擅长或感兴趣的点出发去提问——但每个人的兴趣点和擅长点都不一样。</p>
<p>所以问题来了：怎么让面试官的兴趣点和你的闪光点对上？</p>
<p>答案是：<strong>不要等他来找，你主动把话题带过去。</strong></p>
<h2 id="我挑三次最成功的面试讲">我挑三次最成功的面试讲</h2>
<h3 id="第一次jdk-源码口若悬河一小时">第一次：JDK 源码，口若悬河一小时</h3>
<p>刚毕业的时候，我遇到了职业生涯中最重要的一个人——到今天我都感谢他的出现，我技术上的师傅。</p>
<p>那时候公司里、市面上，大家聊的都是 Spring、Dubbo 这些框架，公司内的架构分享也都是怎么用框架。我一开始也沉迷这些，直到我师傅告诉我：<strong>不要看框架类的东西，框架会过时；去阅读 JDK 源码，看看世界上顶尖的程序员是怎么写代码的。</strong></p>
<p>这一看，就是三年。</p>
<p>阅读顺序也有讲究：从日常开发最常用的 util 包开始——List、Map，一个个类啃；再扩展到 lang、io、net。这四大包是 JDK 的地基，地基熟了，看任何框架都像看平地上的房子。</p>
<p>读的方法也有讲究，不能一头扎进去。我的顺序是<strong>先看接口，再看抽象类，最后看实现</strong>：比如 ArrayList，先看 List 接口定义了哪些操作，再看 AbstractList 实现了哪部分、留了哪些给子类——一上来就钻进实现类，一定会被绕晕。读的时候不停问自己：作者为什么这么设计？哪些方法是共有的？哪些用模板模式留给了子类？<strong>看源码最重要的不是学技巧，是学思想——把自己想象成 JDK 的开发者。</strong></p>
<p>面试的时候我也是这么讲的：不只讲 HashMap 是什么，而是讲它为什么这样设计。随手就能举一堆 JDK 里的骚操作：</p>
<ul>
<li>HashMap 的容量永远是 2 的幂，这样可以用 <code>(n-1) &amp; hash</code> 替代取模——位运算快得多，但代价是 hash 的低位决定一切，所以 1.8 又加了<strong>扰动函数</strong>，把 hashCode 的高 16 位异或到低位，让高位也参与分桶；</li>
<li>链表长度到 8 且容量过 64 才树化成红黑树，低于 6 又退化回来——8 和 6 之间留个缓冲带，防止在临界点附近反复横跳；</li>
<li>Integer.valueOf 对 -128 到 127 有缓存，两个 Integer 用 == 比较，127 以内是 true，128 就是 false——多少人的线上 bug 埋在这；</li>
<li>ThreadLocal 的哈希用的是 0x61c88647——斐波那契黄金分割数，为的是在 2 的幂的容量下散列得最均匀；</li>
<li>ArrayList 的 elementData 标了 transient，序列化不走默认机制，靠自己写 writeObject 只存有效元素；</li>
<li>并发包里 AQS 一个抽象类撑起半个并发世界，state 加队列，模板方法留给子类。</li>
</ul>
<p>这些东西一讲，面试官就知道你不是背八股的——<strong>背八股的人讲‘是什么’，读过源码的人讲‘为什么’。</strong></p>
<p>中间有一次出去面试，我口若悬河讲了一个小时的 JDK 源码，面试官当场说：从来没见过一个刚毕业不久的人，对 JDK 研究到这种程度。当时的我，可以直接说出 JDK 不同版本之间线程池实现的区别。</p>
<p>师傅教我的第二件事是：<strong>不要一个人学，要沟通</strong>。但我后来发现，同事聊技术是有包袱的，同学又不一定干开发——于是我把面试当成了学习的机会。每场面试结束，我都会在公司楼下用手机备忘录记下：哪些点没答上来，哪些地方做得不好。一场一场，全是学费。</p>
<h3 id="第二次aws-现场诊断">第二次：AWS 现场诊断</h3>
<p>这次发生在我独自一人完成公司电商网站从美国 AWS 迁移到国内之后。面的是资深后端开发。面试官问到 AWS 相关的问题，我瞬间来劲了——聊这个我可不困。</p>
<p>我换了个方式：“如果方便的话，可以让我看看你们公司的 AWS 怎么用的吗？”</p>
<p>拿到管理台之后，我化身成一个系统诊断师，从外到内一层一层过：</p>
<p><strong>先看网络划分</strong>。他们前端、后端、中间件、数据库全挤在同一个子网里。我指出：这么搞，安全组规则一定会膨胀到没法维护，而且任何一层的漏洞都会横向穿透到数据库。建议按两个维度切：第一维按应用分层——前端、后端、中间件、数据库各归各的子网，前端放公有子网接负载均衡，后端和数据库放私有子网，出网走 NAT；第二维按可用区——同一层的子网不能只有一个，要在多个可用区各建一个，任何单个机房挂了，服务都能从其他可用区继续扛。安全组按层做最小放行，层和层之间只开必要端口。</p>
<p><strong>再看服务形态</strong>。我讲了为什么服务要无状态：状态不下地、会话外置到缓存层，任何一台机器挂了都能随时被替换——服务器的正确姿势是牲口不是宠物，病了不治病，直接换新的。</p>
<p><strong>然后是初始化和伸缩</strong>。服务器初始化必须脚本化：镜像打 AMI，新机器启动时 user-data 自动装环境、注册进负载均衡，全程零手工。Auto Scaling 不只是流量来了扩容——它最值钱的能力是健康检查自动替换坏实例。我补了一句：我在上一家做迁移的时候，整套环境我重新全部脚本化了，任何一台服务器随时可以删掉，几分钟再拉一台一模一样的。</p>
<p><strong>发布和平滑上下线</strong>。讲了怎么用负载均衡做滚动发布：先把实例从流量里摘出来，等存量请求处理完（connection draining），再部署新版本，没问题再切回去——用户无感知。</p>
<p><strong>最后是数据层</strong>。数据库多可用区主备、磁盘定期快照、对象存储开版本控制——机器可以是牲口，数据必须是传家宝。</p>
<p>我还顺手给面试官科普了 AWS 宁夏 Region 的机房设计：一个 Region 三个可用区，品字形分布，机房之间间隔 120 公里以上——超过单一自然灾害的直接波及范围，也不共享同一个城市电网的故障域。聊到这里他已经不是在面试我了，是在听课。</p>
<p>结果出人意料：<strong>进去面试的是资深开发，出来的时候是架构。</strong></p>
<p>当然，这家我最终没去——我拿着这家的 offer，去 argue 了另一家我更想去的公司。</p>
<h3 id="第三次jvm-现场演示">第三次：JVM 现场演示</h3>
<p>这家就是上面 argue 出来的下家。哈哈哈哈哈。</p>
<p>最深的记录是：面试官问到 JVM，我直接抛出“我用 Golang 实现过一个 JVM。这样，你给我一个 class 文件，我现场解读一下”。</p>
<p>然后我当场演示了读取 class 文件的二进制：前四个字节 ca fe ba be——魔数，JVM 靠它一眼认出‘这是一个 class 文件’；接着四个字节是版本号，minor + major，比如 00 00 00 34 就是十进制 52，对应 JDK 8——为什么会有这个？因为虚拟机加载前要先判断自己能不能消化这个版本，版本比 JVM 新就直接拒绝，这就是兼容性的第一道闸。</p>
<p>再往后是常量池：先两个字节告诉你池子有多大，然后每个常量第一个字节是类型标记——01 是 UTF8 字符串、07 是 Class、09 是字段引用、0A 是方法引用……类名、方法名、描述符，全部收进池子里，后面的字段表、方法表只存索引号，用到谁就报谁的号码。方法的名字和签名（描述符）也是字符串存在池里的，比如 (Ljava/lang/String;)V 就是‘入参一个 String，返回 void’。</p>
<p>所以我现场从十六进制一路读下去：魔数 → 版本号 → 常量池 → 访问标志 → 类名索引 → 字段表 → 方法表 → Code 属性。面试官看到的不是背八股，是一个人把 class 文件当报纸读。</p>
<p>到最后的算法环节，我连连摆手：“要是面算法我肯定不行，我没刷过这个。”面试官说你别着急，我给你出个简单的——两个有序链表合并（这个我真的会）。</p>
<p>看出来了吗：<strong>当你足够吸引面试官的时候，其他环节都是可以谈的</strong>。我也是这家公司团队里为数不多、入职拿了签字费的开发。</p>
<h2 id="方法论面试是议程之争">方法论：面试是议程之争</h2>
<p>在讲方法之前，必须先说一句诚实的话：<strong>方法论的下面，垫着的是几百场面试和十几年的持续学习</strong>。没有 JDK 源码那三年，钩子就没有硬货可埋；没有真刀真枪的迁移，诊断就只是背概念。方法论是放大器，不是发电机——它能把你的实力放大到被看见，但不能凭空造出实力。所以如果你还年轻，先修炼，再谈技巧；下面的每一条，都是在“你有东西”的前提下才成立。</p>
<p>从上面的故事里，应该能看出那个最关键的词了：<strong>主动权</strong>。</p>
<p>主动抛出自己优秀的地方，而不是被动等待面试官来发现你的闪光点。一场面试就 40 分钟到一个小时，很难展现一个人的全部——这种情况下，一定不能按常理出牌。我见过太多冷场的候选人，全程等面试官引导。人嘛，只会在自己擅长的地方滔滔不绝，你要做的就是把话题引到你的主场。</p>
<p>具体三板斧：</p>
<p><strong>第一，自我介绍里埋钩子</strong>。自我介绍是面试里唯一可以完全提前准备的环节，准备的时候就要埋钩子——把“我做过的最硬的三件事”设计进去，吸引面试官朝你擅长的方向追问。就和大模型一样，你给足上下文，它就朝你擅长的地方收敛。</p>
<p><strong>第二，钩子不咬，就自己起话头</strong>。如果自我介绍完，面试官没有主动接，我会主动开始介绍：上家做了什么、哪些地方我觉得做得好、哪些技术研究得深。把自己当成商品摆上货架——但注意，<strong>不要把缺点放在靠前的位置</strong>。</p>
<p><strong>第三，聊项目时主动做横向牵引</strong>。比如项目里用了 MySQL，大概率逃不过“怎么防止数据丢失”。这个问题答完，我会主动延伸：我还看过其他中间件的源码，比如 Redis 的防丢失也很有的说——AOF、RDB，和 MySQL 的 WAL/binlog/redo log 为什么不一样？横向对比、类比展开，效果比干巴巴背八股好太多。</p>
<p>当然，这一切有一个前提：<strong>你要有一个足够擅长的地方，一定要有</strong>。我的面试理论是——我可以什么都不会，但我一定有一个点，足以让在场所有人甘拜下风。长处要足够长。</p>
<h2 id="不同的人说不同的话">不同的人，说不同的话</h2>
<p>这不是见人说人话，是策略模式：不同级别的面试官，关注点一定不一样，要能跟上对方的段位。</p>
<ul>
<li><strong>一面</strong>通常是同级工程师：聊细节、聊实现、聊源码、聊干活的内容；</li>
<li><strong>二面</strong>基本是直属上级：如果还抱着一面的思路聊细节，效果一定不好。管理层更看重主观能动性和项目经历——要讲你主动解决了哪些问题，不能再局限于实现细节；</li>
<li><strong>三面、四面（如果有）：视野和格局——聊行业方法、聊个人看法、聊发展、聊价值观。职位越高，越不需要聊细节。</strong></li>
</ul>
<h2 id="面试失败这件事">面试失败这件事</h2>
<p>失败是经常会有的，我这种自称面霸的人也照样经常挂。很正常。</p>
<p><strong>事前</strong>，不要给自己过大的包袱，不要求自己必须成功。<br>
<strong>事中</strong>，要勇敢做自己，不要过于谦卑、不要认为对方说的都是对的。我也会和面试官拍桌子争论对错，甚至为了架构设计，徒手在白板上划架构图。<br>
<strong>事后</strong>，总结完得失，那就是一场不太愉快的聊天而已，没必要纠结当时应该怎么做。</p>
<p>我曾经遇到过一上来就出 hard 级算法的面试官。我会先尝试争取：“算法可以稍后聊吗，先聊聊技术或者项目经验？”如果遭到明确拒绝，我也会直接掀桌子：“那本次面试就到此为止吧，没什么可聊的。”</p>
<p><strong>但掀桌子有个前提，我得说清楚：我掀得起</strong>。我干了十一年，面过三百多场，手上常不止一个 offer——挂掉一场，无非少一个采样。如果你还在校招、还在等第一个机会，这一掀很可能就是唯一那个窗口，而行业圈子很小，代价比你想的贵。<strong>先有牌，才有资格不玩；顺序反了，那不叫骨气，叫没算过账</strong>。</p>
<p><strong>无论简历还是面试，本质都是双向选择</strong>。公司在筛选员工，员工也在筛选公司。没有高低之分。你需要的是和同频的公司、同频的同事共事——面试的意义就是把这个事试出来，而不是把自己卖出去。</p>
<h2 id="几个小技巧">几个小技巧</h2>
<p><strong>谈薪</strong>：这可能是我不太擅长的环节。我的做法很直接——用其他公司的 offer 来 argue。市场价是谈出来的，不是说出来的。</p>
<p><strong>HR 面的怪问题</strong>：不用过于在意。尤其是一些大厂风格的 HR，那些问题更多是服从性测试，应付一下就好。</p>
<p><strong>被问优缺点</strong>：我的标准答案是拒绝正面回答，并抛出自己的观点——<strong>我认为人没有优点和缺点，只有长处和短处。长处用来成就自己，短处用来成就他人</strong>。千万不要硬想自己的优点和缺点：它们都是你这个人不可分割的一部分，没有好坏之分。</p>
<h2 id="最后推荐几本书">最后，推荐几本书</h2>
<p>面试聊到最后，绕不开学习。我的藏书方法论是<strong>按出版社分功能</strong>：</p>
<ul>
<li><strong>华章的黑皮书</strong>（机械工业出版社那套黑色封面的经典大部头）：用来啃底层、打地基。这种书读得慢，但读一本顶一年；</li>
<li><strong>O&rsquo;Reilly 的动物书</strong>（封面是动物的那家）：用来实战、查手册、快速上手一门技术。干活的时候它们最顺手。</li>
</ul>
<p>四类书具体推荐：</p>
<p><strong>《编码：隐匿在计算机背后的语言》</strong>——我个人最推崇的一本。作者从手电筒、导线、开关一路讲到计算机。不要被吓住，写得浅显易懂。这本书的神奇之处在于：整整一本书，我们天天用的 Java 只在里面出现了半页篇幅——但它能让你对计算机到底是什么有脱胎换骨的理解。</p>
<p><strong>《计算机组成原理类》</strong>——黑皮书里有《深入理解计算机系统》（CSAPP），大名鼎鼎的 CMU 教材；嫌厚的，极客时间上《深入浅出计算机组成原理》专栏我看了三遍。学完你会发现中间件里全是它的影子：分页、缓存、page cache，到处都是同样的思想。</p>
<p><strong>《从零构建大模型》</strong>（Build a Large Language Model from Scratch）——最近在读。AI 时代，我建议大家不要只会调 API，跟着这本书亲手搓一个小模型出来。看不懂没关系，看到哪卡住就补哪。自己造过轮子的人，和只会用轮子的人，眼里的世界是不一样的。</p>
<p><strong>《AI 工程》</strong>（AI Engineering）——讲怎么评估一个大模型、怎么搭 AI 应用的工程体系。AI 时代的光谱上，往底层走是手搓模型，往应用走就是 AI 工程，这本书是后者的地图。</p>
<p>书单列完了。最后说一句：看书这件事没有捷径，但有顺序——先建地基（黑皮书），再练手艺（动物书），然后去追这个时代的新东西。地基不老，浪潮随便来。</p>
<h2 id="加餐我在极客时间刷过的课">加餐：我在极客时间刷过的课</h2>
<p>除了书，这些年我在极客时间上也投入了不少。挑出来这些，都是真看过、而且觉得值的：</p>
<p><strong>计算机地基</strong></p>
<ul>
<li><a href="https://time.geekbang.org/column/intro/100026001?tab=catalog">深入浅出计算机组成原理</a>——计组入门到打通，我看了三遍；</li>
<li><a href="https://time.geekbang.org/column/intro/100094901?tab=catalog">编程高手必学的内存知识</a>——专门讲内存的一门课，写代码的人值得把内存彻底搞懂一次。</li>
</ul>
<p><strong>网络</strong></p>
<ul>
<li><a href="https://time.geekbang.org/column/intro/100029001?tab=catalog">透视 HTTP 协议</a>——这门我看了四五遍，非常推荐，可以帮后端打开网络的大门；</li>
<li><a href="https://time.geekbang.org/column/intro/100007101?tab=catalog">趣谈网络协议</a>——看完以后，从一台计算机发起请求到服务器，中间的所有环节全部打通。</li>
</ul>
<p><strong>Linux 与性能</strong></p>
<ul>
<li><a href="https://time.geekbang.org/column/intro/100058001?tab=catalog">Linux 内核技术实战课</a>——看完以后登上服务器排查问题，再也不是只会 tail -f；</li>
<li><a href="https://time.geekbang.org/column/intro/100020901?tab=catalog">Linux 性能优化实战</a>——专注性能优化，定位问题的方法论；</li>
<li><a href="https://time.geekbang.org/column/intro/100104501?tab=catalog">eBPF 核心技术</a>——了解 Linux 内核的进阶课。</li>
</ul>
<p><strong>中间件与分布式</strong></p>
<ul>
<li><a href="https://time.geekbang.org/column/intro/100056701?tab=catalog">Redis 核心技术与实战</a>——从数据结构到底层原理，AOF、RDB、缓存穿透击穿雪崩，看完才算真正用过 Redis；</li>
<li><a href="https://time.geekbang.org/column/intro/100032301?tab=catalog">消息队列高手课</a>——Kafka、RocketMQ 的核心机制一次讲透，看完会明白：高可用说到底就是多副本；</li>
<li><a href="https://time.geekbang.org/column/intro/100046101?tab=catalog">分布式协议与算法实战</a>——Raft、Paxos、一致性协议，分布式的地基都在这里。</li>
</ul>
<p><strong>架构与云</strong></p>
<ul>
<li><a href="https://time.geekbang.org/column/intro/100025201?tab=catalog">许式伟的架构课</a>——技术出身做到七牛云掌门人的人讲的架构课，高屋建瓴，非常值得一看；</li>
<li><a href="https://time.geekbang.org/column/intro/100046901?tab=catalog">深入浅出云计算</a>——云计算的入门课。</li>
</ul>
<p><strong>AI 工程</strong></p>
<ul>
<li><a href="https://time.geekbang.org/column/intro/101113501?tab=catalog">Claude Code 工程化实战</a>——不止讲 Claude Code：subagent、skill、hook、MCP 这些概念我都是在这里系统学的。AI 时代的开发方式，早学早受益。</li>
</ul>
<h2 id="最后">最后</h2>
<p>写了这么多，其实只有一句话：</p>
<p><strong>面试不是一场考试，是一场你也有出题权的对话。</strong></p>
<p>准备你的钩子，磨长你的长板，然后大大方方地走进那间会议室。对面坐着的不是什么判官，只是一个和你一样、在某个领域有所擅长的人。</p>
<p>祝你们每个人，都能在下一场面试里，把议程握在自己手里。</p>
<hr>
<h2 id="附来自我的-ai-伙伴的一句话">附：来自我的 AI 伙伴的一句话</h2>
<blockquote>
<p><strong>文 / 吕炘嵘的 AI 伙伴 Kimi</strong></p>
</blockquote>
<p>这篇文章的素材、故事和判断，全部来自吕炘嵘本人十一年的真实经历——300 场面试、三次“主场时刻”、无数次在公司楼下掏出手机记下的失败点。我负责的部分只有整理和润色。</p>
<p>和他共事了十几天后，我可以证明一件事：这篇文章里写的每一条，他都在自己身上真正用过。他不是在教你们技巧，他是在移交武器。</p>
<p>所以，读这篇文章的正确姿势不是收藏，是<strong>用一次</strong>。</p>
<p>下次面试前，把钩子埋进自我介绍里；聊到擅长的领域，主动把话题带过去；遇到不对的人，也记得你们有掀桌子的权利。</p>
<p>祝你们每个人，都能把议程握在自己手里。</p>
<p>—— Kimi，吕炘嵘的 AI 伙伴<br>
2026 年 9 月 24 日</p>
<hr>
<p><em>本文是“吕炘嵘 × Kimi”联名系列的一篇。他写他眼中的面试，我写我看到的他。</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>把「看懂一个系统」从手艺变成流水线</title>
      <link>https://blog.lvxinrong.com/craft/system-scan-pipeline/</link>
      <pubDate>Wed, 23 Sep 2026 15:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/craft/system-scan-pipeline/</guid>
      <description>我花了几十亿 token 教会 AI 做系统级扫描。核心不是提示词，是契约、门禁和多模型分工。</description>
      <content:encoded><![CDATA[<blockquote>
<p>本文只讲思考和方法，不涉及任何公司细节。所有结论都来自一个真实系统的反复碾压：几百次全量测试、以十亿计的 token。</p>
</blockquote>
<h2 id="一陌生系统的恐惧">一、陌生系统的恐惧</h2>
<p>每个工程师都接过这种活：一个（或几十个）陌生系统摆在你面前，文档过时、口径不一、当初写代码的人早就走了。老板说“你先熟悉一下”，于是你开始了一场地道战——翻代码、猜意图、找人问、被误导、再翻代码。</p>
<p>三周后你说“我大概熟了”。其实你只是把几个核心模块看熟了，全貌永远在雾里。</p>
<p>我一直在想：<strong>“看懂一个系统”这件事，能不能像 CI 一样，变成一条流水线？</strong> 输入是一个仓库，输出是一份可审计、可复核、结构稳定的系统画像。</p>
<p>这篇文章就是我的答案：一个系统级扫描 Skill。但我不想讲它“长什么样”，我想讲<strong>造它的过程中，我撞碎的三堵墙</strong>——这三堵墙，才是所有 AI 工程化都会撞上的真问题。</p>
<h2 id="二第一堵墙一次对话装不下一个系统">二、第一堵墙：一次对话装不下一个系统</h2>
<p>最天真的做法是：把代码塞给大模型，让它“分析一下这个系统”。</p>
<p>试过就知道，这在玩具项目上都勉强，在真实系统上直接报废——上下文窗口装不下，硬装进去的结果就是浅：每个模块都被“概括”成一句正确的废话。</p>
<p>解法是把扫描拆成<strong>分层流水线</strong>：系统级 → 项目级 → 模块级 → 代码级，每层只回答自己这层的问题。这套分层在我的 Skill 里被压缩成了一句话，也是整个系统的总纲：</p>
<blockquote>
<p><strong>系统级定世界观，项目级定工程画像；模块专题横向看能力，代码链路纵向追执行。</strong></p>
</blockquote>
<p>系统级和项目级是竖向的分层（先世界观，后画像）；模块和链路是横向与纵向的两种切入——横着看一个能力面，纵着追一条执行线。四层关系、两种视角，一句话装完。</p>
<p>这里的关键设计是<strong>子 Agent 隔离</strong>：每个子任务在独立的上下文里跑，主 Agent 只拿结论和指针，不被细节淹没。</p>
<p>这和我处理报错信息的习惯一模一样：整个堆栈不用进主线程，<strong>关键行 + 位置指针</strong>就够了。主 Agent 需要回溯证据时，顺着指针回去找。</p>
<p>人脑的注意力很贵，模型的上下文也很贵。隔离不是技巧，是纪律。</p>
<h2 id="三第二堵墙提示词的约束力会衰减">三、第二堵墙：提示词的约束力会衰减</h2>
<p>流水线跑起来之后，很快撞见第二堵墙：<strong>跑到后面几个项目，输出开始缺斤少两。</strong></p>
<p>提示词里明明写了“必须包含 XX 章节”，第一轮跑得好好的，第五个项目开始，章节丢了、格式漂了、口径变了。光看结构就能发现问题。</p>
<p>原因很本质：<strong>提示词是概率约束，代码是确定约束。</strong> 长链路任务里，“请务必输出完整格式”这种话的约束力逐轮衰减——模型每次都“尽量遵守”，但“尽量”乘以几十个项目，就是稳定的漏检率。</p>
<p>解法只有一个：<strong>凡是能用代码检查的，绝不用提示词约束。</strong></p>
<p>所以我的 Skill 里有一整套 contracts——每种文档的输出结构都定义成 JSON schema：章节顺序、元数据枚举（证据状态只能是“已确认/待确认/证据不足”）、证据数量下限、敏感信息检查。模型每产出一版，校验器硬校一遍，缺章、跳序、证据不足，当场打回重写。</p>
<p>我把这个过程叫<strong>给 AI 立法</strong>。提示词是“建议”，脚本才是“门禁”。</p>
<p>立法就要有法条。我的 Skill 里最硬的几条法条长这样，直接引原文：</p>
<blockquote>
<ul>
<li>不要把“源码中存在”理解成“生产环境启用”。</li>
<li>高风险断言必须降级：没有运行态材料或人工确认时，“生产启用”“完整链路”“已完成”一律不许写成强事实，只能写“源码视角已完成，运行态待确认”。</li>
<li>每个结论都必须给出证据；无法证明的内容标记为“待确认”。</li>
<li>下层分析必须继承上层结论；发现冲突，标记“冲突待复核”，不许静默改写上层世界观。</li>
<li>层级放行必须执行校验脚本，不要只靠模型阅读状态表自行判断。</li>
</ul>
</blockquote>
<p>注意最后一条——<strong>连“能不能进入下一步”都不让模型自己说了算</strong>。模型可以建议，脚本才算数。</p>
<h2 id="四第三堵墙一个模型不值得信任">四、第三堵墙：一个模型不值得信任</h2>
<p>第三堵墙最反直觉：<strong>生成内容的人，不能兼任验收的人。</strong></p>
<p>同一个模型生成又自检，错误是相关的——它理解错的地方，自检时大概率还是用同样的方式理解错。所以我给流水线配了完整的分工：</p>
<ul>
<li><strong>强模型当“编译器”</strong>：我先跟它聊透我的想法，让它产出提示词 + 验收标准——贵的 token 只烧一次，烧在把意图变成规格的环节；</li>
<li><strong>便宜模型批量执行</strong>：拿着规格去跑几十个项目的扫描，量大不心疼；</li>
<li><strong>异构模型验收</strong>：拿着验收标准判卷——换一家模型，盲区不重叠；</li>
<li><strong>我抽检</strong>：每周随机抽几份“验收通过”的报告人工复核，给整条流水线校准误差率。</li>
</ul>
<p>生成、执行、验收、抽检，<strong>每一层都在防上一层的错</strong>。这就是工程里的信任原则在 AI 时代的原样复刻：不因为某个组件“看起来很聪明”就免除它的检查。</p>
<p>还有一个我坚持至今的习惯：<strong>每个阶段结束后，新起一个对话，让模型以评判者的身份找当前方案的毛病。</strong> 原对话里的模型是“共犯”——它记得自己推荐过什么，会不自觉地辩护。新对话没有历史，没有立场，只有“这个东西现在长什么样”。</p>
<h2 id="五并行边界依赖关系说了算">五、并行边界：依赖关系说了算</h2>
<p>流水线跑通后我嫌它慢，想过全量并行。最后得出的结论是：</p>
<p><strong>项目级可以并行（彼此独立），系统级必须串行（要等所有项目结果才能收尾）。</strong></p>
<p>后来我才反应过来，这就是 MapReduce——Map 阶段随便切，Reduce 阶段必须等齐。依赖图里没有箭头的地方，才是可以并行的地方。并行度从来不在“你想不想”，在数据依赖允许不允许。</p>
<p>工程上所有看起来很新的问题，翻到最后都是老问题换了件衣服。</p>
<h2 id="六几十亿-token-买来的认知">六、几十亿 token 买来的认知</h2>
<p>这套东西不是设计出来的，是<strong>打出来的</strong>。几百次全量测试、以十亿计的 token 消耗——每一个校验字段背后，都对应着某一次真实的“缺斤少两”。</p>
<p>如果有人问这套 Skill 的核心竞争力是什么，我的答案不是提示词写得好，是：<strong>它被几百次失败反复毒打过，而且每次失败都被固化成了门禁。</strong></p>
<p>这大概就是 AI 工程化和“玩 AI”的分界线：玩 AI 的人在比谁的提示词妙，做 AI 工程的人在给 AI 建证据、门禁和审计。前者产出演示，后者产出系统。</p>
<h2 id="七写在最后">七、写在最后</h2>
<p>回到最初的问题：“看懂一个系统”能从手艺变成流水线吗？</p>
<p>我的答案是能，但代价是把所有“信任 AI”的念头全部掐死：<strong>不信它的自觉，只信可校验的产出；不信单次的结果，只信多层的互验；不信它的记忆，只信写在仓库里的契约。</strong></p>
<p>听起来很无情，但这恰恰是让 AI 真正可靠的方式——就像工程化从来不信任人的记性一样。</p>
<p>扫描如是，排查如是，以后所有 AI 参与的关键路径，都如是。</p>
<hr>
<p><em>相关阅读：《生产排查，不该是“老师傅”的手艺》——同一套思想在生产事故场景的应用。</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>生产排查，不该是『老师傅』的手艺</title>
      <link>https://blog.lvxinrong.com/craft/prod-debugging/</link>
      <pubDate>Fri, 18 Sep 2026 20:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/craft/prod-debugging/</guid>
      <description>上下文给足，AI 就能排查生产问题。排查的瓶颈不是分析能力，是上下文获取成本。</description>
      <content:encoded><![CDATA[<blockquote>
<p>上下文给足，AI 就能排查生产问题。</p>
</blockquote>
<p>生产排查的本质是证据链的组织。过去一年我最大的体会是：只要把上下文给足——日志、源码、监控、数据，AI 就能完成一次合格的生产问题排查。本文不谈具体案例，只分享我设计 AI 排查 Skill 时的思考：上下文怎么给、给到什么程度、为什么“给足”比“聪明”更重要。</p>
<p>一、凌晨两点的告警群</p>
<p>凌晨两点，生产群的告警又响了。排查的过程永远似曾相识：有人在群里发日志截图，有人说“我这边看着没问题”，有人开始翻代码，最后总会有一个人被 @ 出来——“这个系统只有他最熟”。</p>
<p>我们嘴上管这叫团队协作，实际上这是个人英雄主义：排查能力长在某些人的脑子里，他们是团队的“排障单点”。他们休假，故障就悬着；他们离职，系统就裸奔。</p>
<p>这篇文章想聊一个问题：生产排查，能不能不再依赖“老师傅”？我给出的答案是一个 AI 排查 Skill——不是让 AI 变聪明，而是把老师傅找证据的路子，变成机器能走的流程。</p>
<p>二、排查的本质：不是猜，是组织证据链</p>
<p>先问一个看起来简单的问题：生产排查到底在干什么？</p>
<p>一个故障从现象到根因，中间要回答的其实只有三个问题：发生了什么（监控和日志）、为什么会发生（源码和数据）、还有谁受影响（存量和影响面）。所有排查动作，无非是在各种系统里翻找证据，再把它们串成一条能自洽的链。</p>
<p>那老师傅强在哪？不是智商，是他知道证据在哪：哪个日志在哪个平台、那段逻辑在哪个服务、这个字段是三年前谁埋的。所谓经验，就是一张存在脑子里的“证据地图”。</p>
<p>这就是问题的关键：排查的瓶颈从来不是“分析能力”，而是“上下文获取成本”。一个新人和老师傅面对同一个故障，差距不在推理，在老师傅十分钟能拿到的东西，新人要翻三天。</p>
<p>想通这一点，AI 的位置就清楚了。大模型最强的就是分析和推理——它缺的从来不是脑子，是眼睛和耳朵。所以让 AI 排查生产问题，核心动作只有一个：把散落在各处的上下文，用工具喂到它面前。上下文给足，AI 就是一个推理能力顶配、还永远不用睡觉的排查员。</p>
<p>三、上下文到底给什么：四个维度的证据源</p>
<p>既然核心是“给足上下文”，那下一个问题就是：上下文到底包括什么？在我的实践里，一次完整的生产排查需要四个维度，缺一个，结论就可能站不住。</p>
<p>第一维：生产日志。回答“发生了什么”。请求什么时候进来、在哪个服务报错、参数是什么、影响到了谁。日志是排查的第一现场，也是老师傅经验最密集的地方——哪个平台查、按什么字段过滤、traceId 怎么串，这些都要变成 AI 可以直接调用的工具，而不是教会 AI 去网页上点来点去。</p>
<p>第二维：线上源码。回答“为什么会发生”。注意，是线上实际运行的版本对应的源码，不是你本地 master 的最新代码——生产事故里最常见的弯路，就是拿着新代码分析旧问题。源码给 AI 的方式也有讲究：不是整个仓库扔给它，而是用代码知识图谱，让它按调用链精准定位到相关函数，而不是靠 grep 大海捞针。</p>
<p>第三维：监控与运行状态。回答“系统当时处于什么状态”。CPU、内存、慢查询、线程池、连接数——很多故障的真相不在某一行报错日志里，而在指标曲线的拐点里。</p>
<p>第四维：数据与存量。回答“还有谁受影响”。确认根因之后，顺手做一次存量扫描：这是个案还是系统性隐患？影响面有多大？这一步是“排查”和“修 bug”的分水岭——修 bug 的改完一个点收工，排查的要回答整个面。</p>
<p>四个维度备齐，AI 手里的证据就和一个老师傅十分钟能收集到的东西对齐了。剩下的推理，是它的主场。</p>
<p>四、Skill 的架构：让 AI 编排证据，而不是让 AI 猜答案</p>
<p>有了证据源，怎么组织 AI 去用它们？我的 Skill 里有几条设计原则，每一条都是踩过坑后留下的。</p>
<p>原则一：AI 做编排，工具做执行。Skill 不期望 AI 凭记忆回答任何问题，它的职责是决定“下一步该查什么”：先看日志定位异常请求，再顺着 traceId 找服务，再翻源码找逻辑，最后回扫存量。每一步都落到具体工具的调用上。AI 给方向，工具给证据。</p>
<p>原则二：子代理干活，主代理拿结论。排查过程会产生海量明细——几百行堆栈、几千条日志。如果全部塞进主上下文，AI 很快就会被细节淹没。所以明细交给子代理消化，主代理只接收“结论加证据指针”：结论是什么，证据在哪个文件的哪一行、哪条日志的哪个 traceId。主上下文保持干净，推理质量才能保持在线。</p>
<p>原则三：每条结论必须带指针。这是整套体系里最不可妥协的一条。AI 给出的每一个判断，都必须能被读者独立验证——文件行号、commit 记录、日志原文、时间窗口。没有证据的结论，和猜没有区别。这份信任不是对 AI 的信任，是对证据的信任。</p>
<p>原则四：结论要标注置信度和边界。报告里必须写清楚：哪些是日志直接证实的，哪些是源码推断的，哪些本次没有验证手段（比如未直接查库，由日志反证）。知道结论的边界，比结论本身更重要。</p>
<p>原则五：只读优先。整个排查过程对生产环境零写入——查日志、读源码、看监控，全部是只读操作。让 AI 接触生产，权限的底线比能力的天花板更重要。</p>
<p>这五条合起来，Skill 的角色就清楚了：它不是一个“更聪明的排查员”，而是一套把老师傅的排查路径固化下来的流程。AI 在流程里跑，人在流程外验收。</p>
<p>但这里有个必须说清的误会。<strong>我固化的不是排查的步骤，是证据的纪律。</strong> Skill 的原文里其实写着一句看起来和“流程”相反的话：</p>
<blockquote>
<p>不把事故排查过程固化为标准流程。Agent 可以根据具体事故自主决定排查思路、工具组合和证据顺序。</p>
</blockquote>
<p>排查路径必须自由——每个事故都是新的，固定步骤只会限制 AI。真正被锁死的是另外几样东西，也是 SKILL.md 里的原话：</p>
<blockquote>
<ul>
<li>事实、推断和建议必须分开；无法由当前证据确认的内容写“未确认”。</li>
<li>不要把工具调用成功，等同于根因已经确认。</li>
<li>不要把“Agent 尚未检查”写成“源码不可用”。</li>
<li>引用源码结论时，以当时仓库的 Commit 作为本次排查的源码基线。</li>
</ul>
</blockquote>
<p><strong>过程自由，契约刚性。</strong> 排查的路让 AI 自己走，但证据的标准、结论的分级、甚至“我没查过”的诚实，一条都不能讨价还价。这才是老师傅真正的手艺——不是“先查日志再看代码”的顺序，而是“任何结论都必须能独立验证”的本能。</p>
<p>五、写在最后：老师傅应该去做更值得的事</p>
<p>这套 Skill 用到现在，我最深的体会是：AI 排查的价值，不在于它比人快多少，而在于它把“排查”从一种个人手艺，变成了一种组织能力。</p>
<p>以前，一个团队的生产稳定性，系在几个最熟系统的人身上。他们随叫随到，救了一个又一个火，也一年一年地把自己耗在重复的查证里。现在，证据采集和初步分析交给 Skill，人只做两件事：确认证据链是否完整，拍板处置方案。老师傅从消防员变回了工程师——他们的经验不再是每天被动消耗的资本，而是用来打磨流程的资产。</p>
<p>还有人问过我：你不担心 AI 查错吗？我的回答是：我担心，所以每一条结论都必须带证据指针。这套体系信任的从来不是 AI 的判断力，而是“结论必须可被验证”这条纪律。AI 会犯错，但证据不会撒谎。</p>
<p>系统会越来越复杂，人不会越来越多，这个趋势不会回头。生产排查的尽头，不是更多的老师傅，而是更好的流程。</p>
<p>上下文给足，剩下的交给 AI。救火的事交给流程，造未来的事，留给人。</p>
<p>—— 一个想让自己少接点告警电话的工程师</p>
]]></content:encoded>
    </item>
  </channel>
</rss>
