# A Field Guide for Computational Thinking
**作者**: Will Chen
**日期**: 2026-07-24T20:14:47.000Z
**来源**: [https://x.com/stablechen/status/2080748550728912919](https://x.com/stablechen/status/2080748550728912919)
---
Mental models you can run from statistical mechanics, computer science, information theory, and game theory.
“Think from first principles” is a phrase, not a process. The expert who says it runs an actual procedure they can’t see anymore, and you get the slogan. This manual is the procedure part: a set of models for thinking about yourself, your work, and your systems as computation. The difference between these and most advice is that these compute. “Rest gives energy” describes; a model with costs and states lets you predict, and a model you can’t run isn’t a model, it’s a vibe.
You don’t need to read this in order. Each entry stands alone: the situation it’s for, the model, the move it buys you, and the way it misleads. Bookmark it, and come back to the entry you need when you need it.
## 1. Your hardware
Every model below prices things in the same two currencies, so meet the currencies first.
Working memory. You can hold about seven things in mind at once, and no amount of effort expands that. So when a task fills you with fog and dread, count what it’s asking you to hold. Usually it wants twenty things compared against each other, in a seven-slot head. The fog isn’t weakness; it’s the correct error message for an impossible request. Next time something feels unstartable, write every piece onto a page (the page is extra slots) and watch the dread shrink to the size of the actual next step.
Willpower. Treat it as a stamina bar with an exchange rate. Every act of resistance (not checking the phone that’s right there, not opening the tab, staying in the chair) costs 2 to 3 units, and it costs that every time the temptation fires. Changing the situation so the temptation never fires costs about 1, once. This one exchange rate explains most of what gets called discipline: the people who look disciplined aren’t paying the resistance tax over and over; they’ve stopped incurring it. Environment design is the whole trade.
Context switching. Switching tasks isn’t free. Every switch dumps the context you’d loaded and starts a cold boot, which is why the same task feels easy at 10am inside a routine and impossible at 4pm between errands. A fixed daily slot for the same kind of work is a warm cache: by the time you sit down, the context is already loaded.
## 2. Reading the situation
Diagnosis before action. The same buttons produce different results on different days, and these models say why.
State. Behavior doesn’t come from your character; it comes from your state. The urge that owns you in your bedroom at midnight has no pull on a trail at 7am. You didn’t improve overnight; the script that runs in the bedroom doesn’t load on the trail. Behavior turns out to be state-dependent, which changes what you try to fix. Ask what state you’re in before asking what’s wrong with you.
Macrostate and microstate. The load-bearing model of the whole manual, from statistical mechanics. When you boil water, you set a temperature. You don’t care which molecule moves at which speed; billions of arrangements all count as boiling, and any of them cooks the noodles. Temperature is a macrostate: a condition satisfied by countless specific arrangements, the microstates. Every goal exists at both levels, and most planning pain comes from gripping the wrong one. Zoomed in, you’re choosing between arrangements: which task first, which words exactly. Zoomed out, you’re stating what must be true when you’re done: shipped by Friday, under $500, doesn’t read like a robot wrote it. You can feel the wrong zoom physically, as heat in your head while you juggle arrangements that all might work. That heat is the signal to go up a level: state the conditions and let any arrangement that satisfies them win. This is also the master move for working with AI. People get poor results by dictating microstates (edit this word, move that line) when the model is a search engine over arrangements. Hand it the macrostate; let it search. One warning: “make it good” isn’t a macrostate, because it rules nothing out. A real macrostate is specific about what must be true and silent about how.
Algorithmic complexity. Mental work comes in price tiers, and you can read the tier before paying. Recalling something you know: O(1), pennies. Going through a list once (a braindump, a checklist): O(n), cheap, scales with length. Comparing everything against everything (an apartment choice across twelve criteria, untangling which projects feed which goals): O(n²), expensive, because the price grows with the square of the item count. Open-ended pondering with no stopping rule, like “what should I do with my life”: exponential, no listed price, the question will take everything you bring. The move: when work feels crushing, name its tier. Square-tier work isn’t done by grinding but by changing the tier: sort, group, build an index. And exponential questions aren’t answered; they’re replaced with priced ones. “What should I do with my life” has no bottom. “Which of these three options do I kill this month” costs an afternoon.
Hidden state. When the same input produces different outputs, something you can’t see is loaded. An AI agent that nails a task Monday and botches it Wednesday. A collaborator whose output swings on dimensions you never asked them to change. You, sailing after one kind of evening and drowning after another. The probe: change exactly one thing and run it again. If the output shifts only where you changed it, the system is clean. If it shifts where you didn’t touch, it has hidden state (mood, fatigue, an open loop, a stale context), and the hunt is for the hidden variable, not the visible ones.
Incentive gradients. Game theory’s gift to diagnosis: you can’t see anyone’s microstates, their thoughts and plans, but you can see the incentive gradient they stand on, and where a gradient exists, someone will walk down it. That’s why you can predict that a thing will happen without knowing which actor or mechanism will make it happen. It works on yourself too: your own future behavior follows the gradients in your environment more reliably than it follows your intentions. Don’t ask what people (including you) intend. Ask what the terrain rewards, and expect the terrain to win.
Compression. Information theory’s definition of understanding: you understand something when you can compress it, predicting a lot from a little. That’s the test that separates knowing a word from having a model. “Form determines function” compresses a thousand cases into four words, which makes it useful for communication and dangerous for understanding, because the handle makes you feel you understand when you’ve only named. Explaining something simply is compression running in public; if you can’t compress it without losing the mechanism, you don’t have it yet. And it’s why vocabulary matters more than it seems: words are the data structure your thinking runs on, and lossy words (lazy, blocked, broken) throw away exactly the mechanism you needed.
## 3. Making things cheap
The caching chapter. One theme four ways: pay once, reuse forever.
Caching. Any answer you generate more than once is a computation you should have saved. The explanation of your project you rebuild in every conversation, slightly differently, with sweat. The morning routine re-decided every morning. Generation is expensive and comes out different each time; retrieval is nearly free and comes out the same. Pay full price once, while you’re sharp and the context is loaded, and store the artifact where future-you will trip over it: the one-sentence answer, the checklist, the template, the saved prompt. The tell that a cache is missing: the feeling of having solved this before.
Prefetching. The expensive part of starting isn’t the work; it’s loading the context. So load it when it’s cheap. Five minutes tonight deciding tomorrow’s first task, while today’s context is still warm, means morning-you wakes to instructions instead of decisions. A braindump before deep work pre-loads the slots so the session starts warm. Same work, different price, because the loading moved to when the assets were already in memory.
Activation energy. From chemistry, and the reason environment design beats resolve. Every behavior has a startup cost, and behavior flows toward whatever’s cheapest to start. The phone on the desk is a low barrier you must actively not cross, all day; the phone in a drawer in another room is a high barrier you stop noticing. Same person, same phone, different energy landscape, different behavior, and no willpower spent. Lower the barriers into what you want (shoes by the door, the document already open) and raise them out of what you don’t. Anyone can look disciplined on a landscape they’ve shaped.
Cache invalidation. Every best practice you inherit is a cached answer to a cost question somebody asked long ago, under old priors. Then the priors change and the recipe quietly goes wrong. AI just repriced hundreds of them at once: drafts are no longer expensive, translation is no longer scarce, and “measure twice, cut once” assumed cutting was costly; when cutting is free, you cut five times and keep the best. Audit your inherited practices: find the cost assumption inside each one and check whether it survived.
## 4. Searching well
Most of life is search — for answers, options, products, routes. Search has actual theory, and it’s learnable.
Testable targets. A search needs a win condition you can check. “Figure out the business” wanders forever because no state of the world counts as done. Write the macrostate: three paying customers, by March, without hiring. Now every day either moved a condition or didn’t, and “am I making progress?” stops being a mood and becomes a measurement.
Binary search. When the space is big (where the bug lives, what’s wrong with the system, which segment wants this) don’t check possibilities one by one. Ask the question that eliminates half of them however it’s answered. “Does the problem still happen when I disable this?” kills half the map either way. Twenty honest yes/no questions can locate one answer among a million possibilities; two to the twentieth is a million. It only works if you ask questions that can genuinely come back no.
Explore vs exploit. Two different activities, fatal when confused. Exploiting is extracting from a spot you’ve already found: efficient, repeatable, blind. Exploring is searching for better spots: wasteful-looking, unrepeatable, and the only source of anything new. The failure isn’t preferring one; it’s doing one while believing you’re doing the other. The veteran farming a shrinking niche who won’t move because every direction looks like a step down? That’s someone whose exploration went to zero without a decision ever being made. Declare which mode you’re in, and what would switch you.
Simulated annealing. At the start of anything new, thrashing is correct. Wild swings, dropped approaches, contradictions: that’s search at high temperature, and to spectators it looks like failure because they can’t see the algorithm. The skill is cooling on schedule: each pass, commit to more and vary less, until the thing sets. People fail in both directions: freezing on the first idea (never hot), or reheating forever and calling it iteration (never cooled). Ask which phase you’re in; the phases have different rules.
Random restarts and ergodicity. Sometimes flawless execution inside your routine still produces nothing, because the routine only ever samples three states of an enormous space. The cravings, the block, the staleness are properties of the states you keep standing in, and you’ve been standing in the same ones for months. Pushing harder in the same state costs 2 to 3 per fight, forever. Jumping states costs about 1: a different city, different hours, one long walk clear across town with no phone. People who try this report something that sounds impossible: compulsions that ruled them at home simply don’t fire elsewhere, because the pull was never in the character. It was in the state. Physicists would say a life that never leaves its region isn’t ergodic: it samples too little of the space to know what’s true of the whole.
Boundary conditions. Some things aren’t goals to optimize or rules to obey. They’re constraints any acceptable solution must satisfy, and they say nothing about the solution itself. “The work shouldn’t feel like suffering” isn’t a goal; it’s a boundary condition, and declaring it as one redirects all your effort from enduring what violates it to redesigning the setup so it holds. Boundary conditions are liberating for exactly that reason: once the walls are set, everything inside them is fair game, and guilt about anything they permit is wasted stamina.
Intelligence. Here’s the fresh take this chapter has been building to: intelligence isn’t a substance, it’s a search structure. Two factors do the work: branching (how many candidate moves get generated) and convergence (whether the process closes in on something and stops). Branching without convergence is a brainstorm that never ships; convergence without branching is a rut executing efficiently. An intelligent process, human or machine, is one that generates real alternatives and then reliably collapses them against a testable target. That’s why the models in this chapter compound: targets give convergence something to converge on, binary search prunes the branches, annealing schedules the ratio between the two. When someone (or something) seems smart, look for the branching and the convergence. When you’re stuck, check which of the two you’re missing.
## 5. Systems that run without you
Everything above happens in real time. This chapter is what keeps working while you’re not looking, and it’s also what separates an AI setup that compounds from one that resets every session.
State machines. Reliable systems fail at transitions, not states. You don’t fail at “working”; you fail at the transition from dinner to working, and the transition from couch to anything. So design the transitions. An undefined hour is an unguarded transition, and the lowest-cost script wins it by default; the couch routine needs an entry point to run, and entry points can be removed. The same model kills day-ruination logic: a day is a chain of transitions, and the current state determines what’s available next, not the morning’s history. Nothing about a bad 9am locks the 2pm door except your belief that the run is ruined. (The no-history property has a name: Markov.)
Idempotence. An operation is idempotent when doing it twice is harmless, and you should engineer for it, because it deletes an entire category of work: the checking. The pill organizer that shows today’s dose already happened. The checklist that doesn’t mind a re-check. The task that can be re-run over yesterday’s half-finished attempt without breaking anything. Once repetition is safe, “did I already?” stops being a question you carry. This bar matters double for anything you hand to an AI agent, because agents retry, and a retry that double-sends the email is how people learn this word.
Invariants. For anything you maintain, write a check that returns true or false, not a feeling that returns “seems okay I guess.” Every invoice is in exactly one folder. Any note findable in under a minute. The account never dips below one month of costs. Run the checks on a schedule. The difference between a system and a pile is that a system can tell you when it’s broken. Invariants are also how you verify machine work without redoing it: you don’t read every line; you run the checks.
Interfaces. Wherever work crosses a seam (you to an agent, an agent to an agent, this week’s you to next month’s you) the seam is where quality leaks. Two stages that are each 99% reliable can compose into garbage if the handoff is vague, because each one’s small errors become the other’s confusing inputs. The fix is unglamorous and total: specify what crosses. What exactly arrives, what exactly leaves, what counts as done. Tight contracts are the reason strangers’ code can build one system, and vague handoffs are where drift gets in.
Degrees of freedom. When something fails the same way twice, the standard patch is a sign: a reminder, a rule, a note to self. Signs cost willpower to obey and get ignored under load. The stronger patch removes the degree of freedom the failure uses. If the wrong thing can be selected, it eventually will be, so make it unselectable: the account that can’t exceed its cap, the template that can’t render the broken layout, the subscription cancelled instead of resisted. A removed degree of freedom is a failure that no longer needs your vigilance, which is the only kind of fix that survives your bad days. It costs optionality, and that’s the deal: reliability is bought with freedom, deliberately, at the joints you choose.
## 6. Making progress stick
The difference between activity and progress is whether you can keep what you’ve won.
Convergence. Anything you repeatedly pour effort into (a diet, a codebase, an agent on a long task, an essay under revision) deserves four questions. Is something measurably getting closer? Is there stability between attempts, or does each one re-roll the world? Is there a floor you can’t fall below? Is anything guaranteed never to regress? Four noes means you’re not progressing, you’re oscillating: burning effort to move sideways. From inside, oscillation feels exactly like working hard. The four questions are how you tell the difference, and they run on anything with a loop in it.
Ratchets. When part of the work passes, freeze it. Actually freeze it, not “keep it in mind.” The section that finally reads right gets locked and is never rewritten in later passes. The routine that works gets written down and defended. Progress that can be silently lost will be silently lost, and you’ll re-fight fights you already won, indefinitely, without noticing that’s where the effort goes. A ratchet converts effort from circular to cumulative, which makes it the highest-leverage structure in this manual: not doing more — making done stay done.
Recursion. The same patterns repeat at every scale: folders hold folders, teams coordinate like teams-of-teams, an agent that delegates to agents uses the design one level down. So you don’t design a new system for every size; you find the pattern that contains itself, build it once, and let it nest. The deeper payoff is permission to think small: because the large system is built from the same repeating part as the toy version, understanding the toy is understanding the tower. When something’s too big to reason about, zoom down until it’s toy-sized, solve it there, and ride the pattern back up. Recursion is the license to hop between resolutions freely.
## 相关链接
- [Will Chen](https://x.com/stablechen)
- [@stablechen](https://x.com/stablechen)
- [1.5K](https://x.com/stablechen/status/2080748550728912919/analytics)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [4:14 AM · Jul 25, 2026](https://x.com/stablechen/status/2080748550728912919)
- [1,536 Views](https://x.com/stablechen/status/2080748550728912919/analytics)
---
*导出时间: 2026/7/25 10:43:49*
---
## 中文翻译
# 计算思维实地指南
**作者**: Will Chen
**日期**: 2026-07-24T20:14:47.000Z
**来源**: [https://x.com/stablechen/status/2080748550728912919](https://x.com/stablechen/status/2080748550728912919)
---
你可以运行的源自统计力学、计算机科学、信息论和博弈论的心智模型。
“从第一性原理思考”是一句口号，而非过程。说出这句话的专家实际上运行着一套他们自己都看不见的程序，而你得到的只是这句标语。这本手册就是那个过程部分：一套将你自己、你的工作和你的系统视为计算来思考的模型。这些模型与大多数建议的区别在于，它们是可以计算的。“休息能带来能量”只是描述；一个包含成本和状态的模型能让你进行预测，而一个无法运行的模型根本不是模型，只是一种氛围。
你不需要按顺序阅读此文。每个条目都是独立的：适用场景、模型、它为你带来的操作，以及它误导你的方式。将其加入书签，在需要时回到你需要的条目即可。
## 1. 你的硬件
下文中的每个模型都用同样的两种货币来为事物定价，所以先来认识这两种货币。
工作记忆。你一次只能在大脑中保持大约七样东西，再多的努力也无法扩展这个数量。因此，当一项任务让你感到迷茫和恐惧时，数数它要求你保持多少东西。通常，它要求在一个只有七个插槽的大脑里对二十样东西进行比较。这种迷茫不是软弱；它是对一个不可能请求的正确错误提示。下次当你觉得某事无从下手时，把每一个部分写在一页纸上（这页纸就是额外的插槽），然后看着恐惧缩减到实际下一步操作的大小。
意志力。把它当作一个带有汇率的生命值条。每一次抵抗行为（不去看就在手边的手机、不打开那个标签页、留在椅子上）都要消耗 2 到 3 个单位，而且每次诱惑触发时都会消耗。改变环境以使诱惑根本不触发，成本大约是 1，且只需一次。这一汇率解释了大多数被称为“自律”的情况：那些看起来自律的人并不是在反复支付抵抗税；他们早已停止了这种消耗。环境设计就是这场交易的全部。
上下文切换。切换任务不是免费的。每一次切换都会倾倒你已加载的上下文并开始冷启动，这就是为什么同一项任务在上午 10 点的例行程序中感觉很容易，而在下午 4 点差事之间却感觉不可能完成。为同类工作留出固定的每日时间段就是一个温热的缓存：当你坐下时，上下文已经加载完毕。
## 2. 解读情境
先诊断，后行动。同样的按钮在不同的一天会产生不同的结果，而这些模型解释了原因。
状态。行为不源自你的性格，它源自你的状态。那种在午夜卧室里吞噬你的冲动，在早上 7 点的小径上没有任何拉力。你没有一夜之间变得更好；只是在卧室里运行的脚本在小径上加载不起来。结果证明，行为是依赖于状态的，这改变了你试图修复的方向。在问“你有什么毛病”之前，先问问你处于什么状态。
宏观态与微观态。这是整本手册中承重的模型，源自统计力学。当你烧水时，你设定了一个温度。你不在乎哪个分子以哪个速度运动；数十亿种排列组合都算作沸腾，其中任何一种都能煮好面条。温度是一个宏观态：由无数特定排列（即微观态）满足的条件。每个目标都存在于这两个层面，大多数规划痛苦都源于抓错了层面。拉近看，你在排列之间做选择：先做哪个任务，具体用哪些词。拉远看，你在陈述完成时必须为真的条件：周五前发布，500 美元以下，读起来不像机器人写的。你可以身体力行地感觉到错误的缩放级别，当你在大脑中摆弄那些可能都行得通的排列时感到的燥热。这种燥热就是信号，提示你要上升一个层级：陈述条件，让任何满足条件的排列胜出。这也是与 AI 协作的终极操作。人们通过规定微观态（改这个词，挪那行）得到糟糕的结果，而该模型本质上是在排列组合上的搜索引擎。把宏观态交给它；让它去搜索。一个警告：“把它做好”不是宏观态，因为它没有排除任何东西。真正的宏观态对必须为真的东西很具体，而对如何实现保持沉默。
算法复杂度。脑力劳动按价格分层，你可以在买单前识别层级。回忆你知道的事情：O(1)，几便士。遍历一次列表（一次大脑倾倒、一份清单）：O(n)，便宜，随长度缩放。将所有东西互相比较（基于十二条标准的公寓选择、理清哪些项目服务于哪些目标）：O(n²)，昂贵，因为价格随项目数量的平方增长。没有停止规则的开式思考，比如“我这辈子该做什么”：指数级，没有标价，这个问题会拿走你投入的一切。操作：当工作感觉压得人喘不过气时，说出它的层级。平方层级的工作不是靠死磕完成的，而是靠改变层级：排序、分组、建立索引。而指数级的问题不是被回答的，而是被替换为有价问题的。“我这辈子该做什么”没有底。“这三个选项我这个月砍掉哪一个”花一个下午。
隐藏状态。当同样的输入产生不同的输出时，意味着加载了你看不见的东西。一个周一搞定任务、周三搞砸任务的 AI 代理。一个产出在你从未要求改变的维度上摇摆的协作者。你自己，在一种夜晚过后顺风顺水，而在另一种夜晚过后却溺水挣扎。探测法：只改变一样东西并再次运行。如果输出只在你改变的地方变动，系统是干净的。如果在你没碰的地方也变了，那它就有隐藏状态（情绪、疲劳、未闭环的任务、过期的上下文），你要寻找的是隐藏变量，而不是可见变量。
激励梯度。博弈论给诊断带来的礼物：你看不到任何人的微观态，他们的思想和计划，但你能看到他们所处的激励梯度，而只要梯度存在，就会有人顺势走下来。这就是为什么你可以在不知道是哪个行为者或机制的情况下，预测某事将会发生。这对你自己也适用：你未来的行为遵循环境中的梯度，比遵循你的意图更可靠。不要问人们（包括你自己）打算做什么。问问地形奖励什么，并期待地形获胜。
压缩。信息论对理解的定义：当你能压缩它时，你就理解了它，即从少量信息中预测大量信息。这就是将“知道一个词”与“拥有一个模型”区分开来的测试。“形式决定功能”将一千个案例压缩成四个词，这使得它有利于交流，却不利于理解，因为这个把手让你觉得你理解了，其实你只是给它起了个名字。简单地解释某事就是公开运行的压缩；如果你不能在不丢失机制的情况下压缩它，那你就还没有真正掌握它。这也是为什么词汇比看起来更重要：词汇是你的思维所运行的数据结构，而有损的词汇（懒惰、受阻、坏了）恰恰丢弃了你需要的机制。
## 3. 降低成本
缓存章节。一个主题，四种方式：支付一次，永远复用。
缓存。任何你生成过不止一次的答案，都是你应该保存下来的计算结果。你在每次对话中重新构建的项目解释，略带不同，还冒着汗。每天早上重新决定的晨间例程。生成是昂贵的，且每次结果都不同；检索几乎是免费的，且结果一致。在你头脑清醒、上下文已加载时支付全价一次，并将产物存储在未来你肯定会绊倒的地方：那一句式的回答、那份清单、那个模板、那个保存的提示词。缺少缓存的线索：感觉以前解决过这个问题。
预取。开始工作的昂贵部分不是工作本身，而是加载上下文。所以在便宜的时候加载它。今晚花五分钟决定明天的第一个任务，趁今天的上下文还温热，这意味着早上的你醒来面对的是指令，而不是决策。在深度工作之前进行大脑倾倒可以预加载插槽，使会话开始时就处于热身状态。同样的工作，不同的价格，因为加载转移到了资产已经在内存中的时候。
活化能。源自化学，也是为什么环境设计胜过决心的原因。每个行为都有启动成本，行为流向最容易开始的事物。桌上的手机是一个你必须整天主动不跨越的低门槛；在另一个房间抽屉里的手机是一个你不再注意的高门槛。同样的人，同样的手机，不同的能量景观，不同的行为，且没有消耗意志力。降低进入你想做的事情的门槛（门口放鞋，文档已经打开），提高离开你不想做的事情的门槛。在他们自己塑造的景观上，任何人都可以看起来很自律。
缓存失效。你继承的每一个最佳实践，都是有人在旧的先验概率下很久以前提出的成本问题的缓存答案。然后先验变了，配方悄悄地出了错。AI 一下子重新给数百个实践定了价：草稿不再昂贵，翻译不再稀缺，而“三思而后行”假设的是剪切是昂贵的；当剪切免费时，你切五次并保留最好的。审计你继承的实践：找出每一个内部隐含的成本假设，并检查它是否存活了下来。
## 4. 有效搜索
生活中大部分时间都是搜索——搜索答案、选项、产品、路线。搜索有真正的理论，而且是可习得的。
可测试的目标。搜索需要一个你可以检查的获胜条件。“搞懂生意”永远在游荡，因为没有哪种世界状态算作完成。写出宏观态：三个付费客户，在三月前，不雇佣。现在每一天要么移动了某个条件，要么没有，而“我在进步吗？”不再是一种情绪，而变成了一种度量。
二分查找。当空间很大时（bug 在哪里、系统有什么问题、哪个细分群体想要这个），不要逐一检查可能性。问一个无论怎么回答都能消除一半可能性的问题。“如果我禁用这个，问题还会发生吗？”无论答案是肯定还是否定，都能消灭一半的地图。二十个诚实的“是/否”问题可以在一百万种可能性中定位到一个答案；2 的 20 次方是一百万。这只有在你问那些真能返回“否”的问题时才有效。
探索与利用。两种不同的活动，混淆时致命。利用是从你已经发现的地方提取：高效、可重复、盲目。探索是寻找更好的地方：看起来浪费、不可重复，并且是任何新事物的唯一来源。失败不在于偏好其中一种；而在于做了一种却以为自己在做另一种。那个正在耕作萎缩的利基市场而不愿搬家的老兵，因为每个方向看起来都像是走下坡路？这就是那个探索归零却从未做出决定的人。声明你处于哪种模式，以及什么会让你切换模式。
模拟退火。在任何新事物的开始，挣扎是正确的。大幅摇摆、放弃的方法、矛盾：这是高温下的搜索，而在旁观者看来这像失败，因为他们看不见算法。技能在于按计划冷却：每一轮，增加承诺，减少变化，直到事物定型。人们在这两个方向上都会失败：在第一个想法上冻结（从未热过），或者永远重新加热并称之为迭代（从未冷却）。问问你在哪个阶段；阶段有不同规则。
随机重启与遍历性。有时在你的例行程序中完美执行却依然一无所获，因为该例行程序只能在一个巨大空间中采样到三种状态。那些渴望、阻碍和陈腐感是你一直所处的状态属性，而你已经站在同样的状态里好几个月了。在同样的状态里更用力地推进，每次战斗都要消耗 2 到 3，永无止境。跳转状态大约消耗 1：一座不同的城市、不同的时间、不带手机穿过大城的长途步行。尝试过的人报告了一些听起来不可能的事情：在家里主宰他们的强迫症在别处根本不触发，因为拉力从来不在性格里。它在状态里。物理学家会说，一个从未离开其区域的生活不是遍历的：它对空间的采样太少，无法知道整体的真实情况。
边界条件。有些事情不是要优化的目标，也不是要遵守的规则。它们是任何可接受的解决方案都必须满足的约束，它们对解决方案本身只字未提。“工作不应该感觉像受苦”不是一个目标；它是一个边界条件，将其声明为此会将你所有的精力从忍受违反它的事情，重新导向重新设计设置以使其成立。边界条件正是因为这个原因而令人解脱：一旦墙壁设定好，里面的一切都是公平游戏，对任何它们允许的事情感到内疚是浪费精力。
智能。这一章一直在构建的新颖观点是：智能不是一种物质，它是一种搜索结构。两个因素在起作用：分支（生成了多少候选步骤）和收敛（过程是否聚集在某样东西上并停止）。没有收敛的分支是永远无法交付的头脑风暴；没有分支的收敛是高效执行的车辙。一个智能的过程，无论是人类还是机器，是产生真正的替代方案，然后可靠地针对一个可测试的目标将其坍缩。这就是为什么本章中的模型会复合：目标给收敛提供了收敛的对象，二分查找修剪分支，退火安排两者的比例。当某人（或某物）看起来很聪明时，寻找分支和收敛。当你卡住时，检查你缺少了哪一个。
## 5. 无需你运行的系统
以上所有事情都发生在实时。这一章是当你不在看时仍在继续工作的部分，它也是区分一个能够复合的 AI 设置和一个每次都会重置的 AI 设置的关键。
状态机。可靠的系统在转换处失败，而不是在状态处。你不会在“工作”这个状态失败；你在从晚餐到工作的转换失败，在从沙发到任何事情的转换失败。所以要设计转换。一个未定义的小时是一个无人看守的转换，成本最低的脚本会默认获胜；沙发例程需要一个入口点来运行，而入口点是可以被移除的。同一个模型也摧毁了毁掉一天的逻辑：一天是一连串的转换，当前的状态决定了下一步什么可用，而不是早上的历史。除了你的信念认为这一天已经毁了之外，糟糕的上午 9 点并没有锁死下午 2 点的门。（这种无历史属性有一个名字：马尔可夫。）
幂等性。当一个操作做两次是无害的，它就是幂等的，你应该为此进行工程设计，因为它删除了一整类工作：检查。显示今天的剂量已经吃过的药盒。不介意重查的清单。可以在昨天未完成的尝试上重新运行而不会弄坏任何东西的任务。一旦重复是安全的，“我已经做了吗？”就不再是你背负的问题。这个标准对于你交给 AI 代理的任何事情都加倍重要，因为代理会重试，而一次重试导致重复发送邮件就是人们学会这个词的方式。
不变量。对于你维护的任何东西，写一个返回真或假的检查，而不是一个返回“感觉还可以吧”的感觉。每张发票都正好在一个文件夹里。任何笔记都能在一分钟内找到。账户余额从未低于一个月的成本。按计划运行检查。系统和一堆东西的区别在于，系统能告诉你它什么时候坏了。不变量也是你在不重做的情况下验证机器工作的方法：你不读每一行；你运行检查。
接口。无论工作在哪里跨越接缝（你到代理，代理到代理，本周的你到下个月的你），接缝就是质量泄漏的地方。两个各自 99% 可靠的阶段，如果交接模糊，可能会组合成垃圾，因为每一个的小错误都会成为另一个的混乱输入。修复方法并不光鲜但需要彻底：指定跨越的内容。什么确切地到达，什么确切地离开，什么算作完成。严格的契约是陌生人的代码能构建一个系统的原因，而模糊的交接是漂移渗入的地方。
自由度。当某事以同样的方式失败两次时，标准的补丁是一个标志：一个提醒、一条规则、一张给自己便条。标志消耗意志力去遵守，并在负载下被忽略。更强的补丁是移除失败所利用的那个自由度。如果错误的东西可以被选中，它最终就会被选中，所以让它变得不可选：不能超限的账户、无法渲染错误布局的模板、被取消而不是被抵抗的订阅。一个被移除的自由度就是一个不再需要你警惕的失败，这是唯一能在你的糟糕日子里幸存下来的修复。它消耗了可选择性，这就是交易：可靠性是用自由买来的，有意识地，在你选择的关节处。
## 6. 让进步持续
活动和进步的区别在于，你能否保住你赢得的东西。
收敛。任何你反复投入精力的事情（一种节食、一个代码库、一个处理长任务的代理、一篇正在修改的文章）都值得四个问题。有什么东西在可衡量地接近吗？尝试之间有稳定性吗，还是每一次都重掷了世界？有一个你不能掉下去的底线吗？有什么东西保证永远不会倒退吗？四个“否”意味着你不是在进步，你是在震荡：燃烧精力横向移动。从内部看，震荡感觉就像在努力工作。这四个问题是你如何区分它们的方法，它们可以运行在任何有循环的东西上。
棘轮。当工作的一部分通过后，将其冻结。真的冻结，不是“记在心里”。那段终于读得对的章节被锁定，在后续轮次中永远不会被重写。那个起作用的例程被写下来并加以维护。可以被无声失去的进步将会被无声失去，并且你会无限次地重新打你已经打赢的仗，而没有意识到精力流向了哪里。棘轮将精力从循环转化为累积，这使它成为本手册中杠杆率最高的结构：不是做更多——而是让“完成”保持完成。
递归。同样的模式在每个尺度上重复：文件夹里套文件夹，团队像团队之团队一样协调，一个委托给代理的代理使用下一层级的设计。所以你不要为每个规模设计新系统；你找到包含自身的模式，构建一次，然后让它嵌套。更深层的回报是允许想得小：因为大系统是由与玩具版本相同的重复部分构建的，理解玩具就是理解高塔。当某个东西太大而无法推理时，缩小直到它变成玩具大小，在那里解决它，然后顺着模式骑回来。递归是自由跳跃于不同分辨率之间的许可证。
## 相关链接
- [Will Chen](https://x.com/stablechen)
- [@stablechen](https://x.com/stablechen)
- [1.5K](https://x.com/stablechen/status/2080748550728912919/analytics)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [4:14 AM · Jul 25, 2026](https://x.com/stablechen/status/2080748550728912919)
- [1,536 Views](https://x.com/stablechen/status/2080748550728912919/analytics)
---
*导出时间: 2026/7/25 10:43:49*