Vincent Ping

AI as Tutor: The Other Half of the AI Revolution

Wed, 23 Sep 2026 22:24:00 GMT

In my last piece, How Should We Use AI in Education?, I ended with this:

The task is the target you train on. The person is what education is actually meant to change.

A student can use AI to turn in a very good assignment. But how much did the student learn? That question is where I drew the line between AI as Agent and AI as Tutor. An Agent helps us finish tasks. A Tutor uses the work of doing them to help us learn how to think and how to judge.

A Tutor doesn’t have to be someone who lectures. It can explain, or it can keep asking questions. It can give feedback, or it can play the person who disagrees with you, until you’ve worked out what you actually think.

When I wrote that piece, I was mostly thinking about school. Later I realized the same problem shows up at work.

Work Makes Workers, Too

I’ve been writing software for a long time. When I look back at the moments I really came to understand a system, very few of them came from reading documentation. They came from dealing with something that was broken: reading logs, tracing calls, trying to explain a result that made no sense, and sometimes, after the fact, figuring out where my first guess had gone wrong.

That kind of work takes time. It’s often frustrating, especially when you’re getting nowhere. But once you’ve been through it a few times, you look at the next outage differently. You see things you wouldn’t have seen before.

Other professions work the same way. A junior lawyer, digging through statutes and evidence, slowly learns which facts can change a case. A reporter, sitting through interview after interview, comes to see when to believe someone and when to keep pushing. A resident, pressed again and again by an attending’s “Why did you rule out the other possibility?”, starts to sense where her own judgment tends to go wrong.

Work delivers code, briefs, stories, and patient charts. It also leaves experience behind.

Human work has always produced two things: the work, and the worker.

We rarely thought of these as separate. A new hire got an assignment and learned by doing it. Someone senior checked the work and corrected it. A few years later, the new hire could handle things on their own. The path was never perfect. Some people got real mentoring, and others were left to figure things out alone. Some ran into plenty of hard problems, and others did the same thing over and over for years.

AI is now changing a lot of that. It can look things up, draft documents, write code, even track down the cause of a failure. Much of this it does faster and better than we can. But the steps newcomers used to learn from are disappearing along with the work.

If a junior programmer is always handed the fix, when does she learn to tell where the problem is? If a junior lawyer never has to sort out the facts himself, how does he learn to spot the weakest point in an argument?

I’m not saying we should keep everyone doing repetitive work just so they get trained. What I care about, instead, is this: once the way work gets done has changed, what will people’s growth rest on?

As AI takes over more of the work, we need to deliberately design how the worker continues to grow.

Growth Can Be Designed

Flight simulators gave me a useful way to think about this.

A real flight has one job, which is to get the passengers there safely. A simulator can do what a real flight can’t. It can throw failures at a pilot on purpose, pause, start over, and let the pilot work again and again through situations they’ll rarely meet but absolutely must be able to handle. Nobody stages an emergency on a passenger flight for the sake of training. But we take simulator training very seriously.

Knowledge work has room for the same thing. A reporter practices pressing an interviewee who keeps dodging the question. A lawyer hunts for the fact that an airtight-looking argument quietly left out. A programmer works through a set of failure clues that are incomplete, and sometimes contradict each other.

If AI really is a revolution in intelligence, it can and should help design practice like this. It can play the interviewee, the coworker, or the customer. After you make a call, it can change the conditions and ask, “What if that piece of evidence doesn’t hold up?” It can remember the step someone keeps getting wrong and aim the next exercise right at it.

Experienced people still need to be involved. Someone has to decide which situations are worth practicing, what good feedback looks like, and whether what people learn in practice carries over into real work. What AI changes is that steady, specific practice no longer depends entirely on landing the right project, or on a senior colleague happening to have an afternoon free.

That’s what I mean by AI as Tutor. It isn’t only about explaining answers more clearly. It’s about helping a person go through the loop of trying, getting it wrong, fixing it, and trying again.

Simulation can’t fully replace real experience, of course, and practice that looks well targeted isn’t proof that anyone got better. But it’s worth exploring. We can design tasks, interactions, and feedback around how people grow, and then check whether those designs actually work.

Make Growing People an Explicit Goal

When we talk about what AI can do today, we usually ask how many tasks it can complete, how good the results are, and how often a human has to step in. Those are Agent questions, and they all come down to one:

Did the task succeed?

If we also want AI to help people grow, we have to ask something else:

Did the human improve?

The two goals often pull against each other.

Say you’re stuck choosing between two approaches to a tricky problem. An Agent should give you a recommendation so you can ship. A Tutor has to slow things down on purpose. It asks you to make the call first, asks what your call is based on, points out the conditions you may have missed, and keeps pushing back.

That’s the hard part. If a product is judged only on how fast and how well tasks get done, then letting people try first, asking them to explain their reasoning, and giving them a chance to redo the work all look like waste.

The better a system gets at doing things for people, the easier it becomes to optimize away the very practice that helps them grow.

So growing people can’t be a feature bolted onto an Agent product. It needs its own research questions. What kind of feedback actually helps? When should you offer a hint, and when should you let someone keep thinking? How do you tell “got it right this time” from “has really learned it”? And it needs its own product design, and its own ways of measuring success.

Put another way:

AI as Tutor needs to become a first-class direction of AI development now, standing alongside AI as Agent.

The Other Half

The skills people need may change. Growth may no longer follow the old career ladder. But understanding, experience, and judgment still take time, and they still come from going through things yourself.

We used to grow the people who do the work while the work got done. Now Agents are redesigning how work gets done. We should think just as seriously about how people grow, and that’s the job of a Tutor.

One half of the AI revolution is AI helping us get things done. The other half should be AI helping us grow.

AI as Tutor：AI 革命的另一半

Wed, 23 Sep 2026 22:22:00 GMT

在上一篇《我们应该如何在教育中使用 AI？》里，我写过一句话：任务只是训练的靶子，人，才是教育真正希望改变的对象。

学生用 AI 完成了一份作业，作业可能很好，但他自己学到了多少？这是我区分 AI as Agent 和 AI as Tutor 的起点。前者帮人把事情做成，后者借助做事的过程，帮助人学会思考和判断。

这里的 Tutor 不一定是讲课的老师。它可以解释，也可以追问；可以给你反馈，也可以扮演一个不赞同你的人，逼你把自己的想法想清楚。

写上一篇文章时，我主要想的是学校。后来我意识到，其实工作中也有同样的问题。

工作，也在培养做工作的那个人

我做软件开发多年。回头看，很多让我真正理解系统的时刻，并不是读文档，而是处理一个出了问题的系统：查日志、追踪调用、试着解释一个看似不合理的结果，有时，还要在事后弄明白自己最初判断错在哪里。

这些过程很花时间，也常常因为没有进展令人沮丧。但经历过几次之后，再遇到故障，你看到的东西就不一样了。

其他职业也是如此。初级律师在查阅法条、梳理证据的过程中，慢慢知道什么事实可能改变案件走向。记者在一次次采访中，逐渐分清什么时候该相信，什么时候该继续追问。实习医师在被上级医生一句“为什么排除另一种可能”反复追问中，一点点摸清自己的判断错在哪里。

工作交付了代码、文件、报道和诊疗记录，也留下了经验。

工作在产出成果的同时，也在培养做工作的人。

过去，我们未必有意识地把这两件事分开。新人接到任务，边做边学；资深同事检查、纠正；几年下来，逐渐能够独当一面。当然，这样的成长向来因人而异。有人能得到指导，有人只能自己摸索；有人碰到足够多的难题，有人长期做着不断重复的事。

现在，AI 正在改变其中很多过程。它可以帮忙查资料、起草文件、写代码，甚至找出故障原因。很多工作 AI 可以更快更好地完成，但新人过去用来积累经验的那些环节，也在不断减少。

如果一位初级程序员总能直接拿到修复方案，他什么时候学会判断问题出在哪里？如果初级律师不再需要自己梳理事实，他怎样发现一个论证最薄弱的地方？

这不是说我们应该为了训练新人，故意让每个人继续做所有重复劳动。我这里更关心的是：当工作方式变了，人的成长要靠什么来支撑？

成长路径可以重新设计

飞行员的模拟训练给了我一些启发。

真实飞行要把乘客安全送到目的地。模拟训练则可以有意识地设置故障，让飞行员暂停、重来，反复处理平时很少遇到、却必须会处理的情况。没人会为了训练而在载客航班上制造故障，但我们会认真设计训练。

知识工作也有类似的空间。让记者练习向一个回避问题的采访对象追问；让律师找出一份看似严密的论证里被忽略的事实；让程序员面对一组不完整、甚至相互矛盾的故障线索。

AI 作为一次智力的革命，可以也应该参与设计这样的练习。它能扮演采访对象、同事或用户；在人作出判断后改变条件，问一句“如果这条证据不成立呢”；也能记住一个人总是在哪一步出错，让下一次练习集中在那一步。

有经验的人仍然需要参与：哪些情境值得练，什么样的反馈是好的，练习成果能否带到真实工作中，都需要他们判断。但 AI 可以让持续、具体的练习，不再完全依赖于恰好遇到某个项目，或恰好有位前辈抽得出时间。

这也是我所说的 AI as Tutor。它不只是把答案解释得更清楚，而是帮助一个人经历尝试、犯错、修正，再尝试的过程。

模拟训练当然不能完全代替真实实践，练习看起来有针对性，也不等于能力已经提高。但它值得探索：我们可以围绕人的成长，主动设计任务、互动与反馈，并检验这些设计是否有效。

把培养人当成一个明确目标

今天谈 AI 的能力，我们常问它能完成多少任务，结果有多好，需要人干预几次。这是典型的 AI as Agent 的目标导向。

但如果我们希望 AI 也能帮助人成长，就得问另外的问题：用了它之后，这个人有什么变化？

AI as Agent 的目标和 AI as Tutor 的目标，常常是冲突的。

同样面对一个棘手的方案选择，前者要求直接给出建议，帮你尽快交付；而后者则需要有意识地放慢脚步，比如先请你作判断，问你依据是什么，再指出你可能漏掉的条件，并不断反复挑战。

这就是难处。如果产品只用任务完成的速度和质量来评价，先让人尝试、要求他说明理由、给他机会重做，就显得多余。系统越善于替人做事，人的练习过程越可能被顺手省掉。

所以，培养人不能只是 Agent 产品附带的一项功能。它需要自己的研究问题：什么样的反馈真正有帮助？什么时候该提示，什么时候该让人继续想？怎样区分“这次做对了”和“已经学会了”？它也需要相应的产品设计和评价方法。

换句话说，AI as Tutor 需要尽快成为 AI 发展的一级方向，与帮助人完成工作的 AI as Agent 并列。

AI 革命的另一半

未来，人们需要掌握的技能可能会变，成长也未必再沿着过去的职业阶梯发生。但理解、经验和判断，仍需要时间和过程。

以前，我们常常在完成工作的同时培养做工作的人。现在，我们正在重新设计工作如何完成。既然如此，也该认真想一想：人本身将如何成长？

AI 革命的一半，是帮我们把事情做完；另一半，应该是帮我们把自己变得更好。

How Should We Use AI in Education?

Sun, 13 Sep 2026 17:20:00 GMT

Over the past two years, AI has moved quickly into schools, and into kids’ everyday learning.

That leaves a lot of parents and teachers facing a very practical question:

Should students be using AI at all? And if so, when?

Should they struggle through a problem on their own first, and only turn to AI when they’re truly stuck? Or is it fine to use it from the very start?

I’ve been thinking about this myself. As a software developer, AI has worked its way deep into how I do my job. At the same time, my son just started high school, and AI is inevitably becoming part of how he learns.

My first instinct was the conventional one: do the work yourself first, let AI come in later.

But eventually I realized the real question is something else:

What is the point of homework, essays, and problem sets in the first place?

The Assignment Isn’t the Goal — It’s the Target You Train On

Say a history teacher assigns this essay prompt:

To what extent was the American Revolution driven by economic factors?

A student could hand that straight to AI — thesis, evidence, structure, maybe the whole essay.

As a way of getting the assignment done, that’s extremely efficient.

But the teacher didn’t assign the essay because the world needed one more paper on the American Revolution.

Clearly not.

The point is what happens to the student while writing it — reading the material, weighing competing explanations, forming a judgment, and learning to express it clearly.

Education isn’t about finishing the task. The task is just the target you train on.

If AI shoots the arrow and hits the bullseye for you, that doesn’t mean you’ve learned archery.

The same goes for math, programming, English. What we actually want isn’t a correct answer, working code, or a polished sentence — it’s the understanding, reasoning, judgment, and expression that the task is meant to build.

So there are two different things to track:

The task got done.

The person learned something.

Sometimes both happen together. Sometimes only the first one does.

Which means the real question about AI in education isn’t just “should students use it” — it’s:

How does AI’s involvement actually help this student build ability?

Two Different Ways to Use AI

That question led me to think about AI in two modes.

One is AI as Agent: hand it a task, let it get the task done.

The other is AI as Tutor: use AI, through tasks and back-and-forth, to build your own ability.

These aren’t two different products — they’re two different goals for using the same technology.

As a developer, I feel this distinction constantly.

If my goal is to ship a website, I want AI to help as much as possible — design the schema, write the code, run the tests, handle deployment. The more it reliably takes off my hands, the happier I am. That’s AI as Agent, because my goal really is just: get the website built.

But if I’m using that same project to learn JavaScript, things change.

If AI writes the whole thing, the site gets built, but I may not have learned JavaScript at all. What I need now is for it to explain the code I don’t understand, compare design choices, push back on my assumptions, or point me toward a bug instead of just fixing it.

AI can still be involved the entire time — what’s changed is the goal, from “do this for me” to “help me get better at this.”

So, put simply:

An Agent helps us finish tasks.

A Tutor uses tasks and interaction to help us build ability.

The difference isn’t whether AI gives you an answer, or how many questions it asks. It’s what we’re actually optimizing for.

In education, AI should mainly be used as a Tutor.

What Does It Actually Mean to Use AI as a Tutor?

Once you frame it this way, the question isn’t “is AI allowed to just give me the answer” — it’s:

What ability am I trying to build right now, and how can AI help build it?

Help Us Understand — Not Just Hand Us the Solution

A kid gets stuck on an algebra problem. AI can write out the full solution. The kid reads it, thinks “oh, I get it,” and moves to the next one.

The problem is, understanding a solution isn’t the same as being able to produce one.

Using AI as a Tutor doesn’t mean it can never show a solution — it means the solution can’t be the endpoint.

If the student is completely lost, AI can explain the concept, even walk through a similar example. If they’re stuck on one step, it can offer just a hint. If their method is wrong, it can hand them a counterexample and let them find the flaw themselves. Then, once they seem to get it, a slightly different problem — solved on their own.

The method varies. The goal doesn’t: building understanding and reasoning that actually belong to the student.

Help Us Form Judgment — Not Just Supply an Opinion

Back to the history essay.

A student can do what the intro described and let AI hand over a thesis and outline. Or they can turn it into a sparring partner instead:

Ask me questions to help me work through this. Don’t decide my position for me.

Once they’ve formed a tentative judgment, they can push further:

Take the strongest opposing view and argue against my position.

Or:

Point out any claims that go beyond what my evidence actually supports — don’t rewrite them, just flag them.

Or even:

What evidence would change your assessment here?

Now AI isn’t just helping produce a better essay — it’s training the student to face disagreement, weigh evidence, and revise a judgment.

And AI’s own take isn’t necessarily right. Checking the sources and deciding whether its pushback actually holds up is part of the exercise too.

Learning isn’t handing your judgment to AI — it’s building your own judgment through arguing with it.

Help Us Practice Expression — Not Just Express Things for Us

This isn’t only about kids.

I’ve been using AI a lot lately to practice my English.

If I just need to send a colleague a clean, polite email, I can hand AI the gist and let it write. That’s AI as Agent, and it’s the right call — my goal really is just to get the email sent.

But if the goal is speaking better, AI can’t do that part for me. I have to actually talk.

It asks me something, I answer out loud in English. It can model a more natural phrasing and have me try again. It can flag just the one or two mistakes that actually hurt comprehension, instead of correcting everything. It can play a stranger, or a colleague who disagrees with me, and force me to make myself understood in real time.

A sentence AI could produce perfectly in five seconds might take me three or five tries to say well.

As a way of getting things done, that’s painfully slow.

But I’m not training AI’s English.

I’m training mine.

The Method Varies — the Goal Shouldn’t

Across these examples, AI does different things each time: explaining, hinting, arguing back, or just asking you to try again.

Which means “when should you use AI, and how” doesn’t have one universal answer.

A student who opens with AI in the first minute can still be learning. A student who grinds alone for ten minutes and then hands AI everything else may have skipped the part that actually mattered.

What matters isn’t when AI shows up — it’s how it participates in the person’s thinking.

Of course, calling AI a Tutor doesn’t guarantee it’s a good one. It can misjudge where a learner is at, or explain something badly. Anything important still needs to be checked.

And we should keep asking: can I explain this better now? Can I handle a variation on my own? Can I set AI aside and do it once, unaided?

That’s the real test — what actually stays with you after the interaction ends.

Let AI Serve the Person’s Growth

Using AI mainly as a Tutor doesn’t mean doing every single step by hand.

If the skill being trained is historical argument, formatting the bibliography can go to an Agent. If the skill is spelling, you shouldn’t lean on autocorrect.

The two modes can work together — but the division of labor should serve the learning goal, not quietly turn education into a race to submit the assignment fastest.

Back to the original question:

How should we use AI in education?

My answer: mainly as an AI Tutor.

Let it help us understand, and challenge our understanding. Let it give us feedback, and push us to try again. Explain when explanation is needed, argue back when needed, guide when guidance is needed.

The goal was never to use AI to produce a better result. It’s to use AI so that we, gradually, become more capable people.

The task is the target you train on.

The person is what education is actually meant to change.

我们应该如何在教育中使用 AI？

Sun, 13 Sep 2026 16:45:00 GMT

这两年，AI 越来越快地进入学校，也进入孩子每天的学习。

于是，很多家长和老师都会碰到一个很现实的问题：

学生到底该不该用 AI？如果可以，什么时候用？

是不是应该先自己想、自己做，实在不会了再去问 AI？还是从一开始就可以用？

这些问题，我自己也一直在思考。作为程序员，AI 已经越来越深地进入我的工作；与此同时，我儿子刚上高中，AI 也不可避免地进入他的学习。

一开始，我很自然地觉得：学习总应该先自己来，AI 最好晚一点介入。

但后来我发现，更重要的问题其实是：

我们让孩子做作业、写文章、解决问题，究竟是为了什么？

一、任务不是教育的目的，而是训练的靶子

假设老师布置了一篇历史文章：

美国独立战争在多大程度上是由经济因素造成的？

学生把题目交给 AI，让它提出观点、整理证据、搭好结构，甚至直接写出全文。

从完成任务的角度看，这很高效。

但老师布置这篇文章，是因为我们缺一篇关于美国独立战争的文章吗？

显然不是。

我们希望学生在写作过程中理解材料、比较解释、形成判断，再把自己的观点有条理地表达出来。

教育的意义不是完成任务，任务只是训练的一个靶子。

如果 AI 替你把箭射中了靶心，不等于你练会了射箭。

数学、编程、英语也是一样。我们要的不是一个正确答案、一段能运行的代码，或者一句漂亮的英文，而是借助这些任务，发展理解、推理、判断和表达的能力。

所以，我们需要区分两件事：

任务完成了。

人学会了。

有时候两者同时发生，有时候前者发生了，后者却没有。

因此，讨论教育中怎么用 AI，真正应该问的是：

AI 的参与，怎样才能帮助这个学生发展能力？

二、两种不同的 AI 使用方式

带着这个问题，我开始用两种方式理解 AI。

一种是 AI as Agent：把任务交给 AI，让它帮我们完成。

另一种是 AI as Tutor：借助 AI，通过任务和互动，发展自己的能力。

这不是两种软件，而是同一个 AI 的两种使用目标。

作为开发人员，我对这个区别体会很深。

如果我的目标是做出一个网站，我当然希望 AI 尽量帮我设计数据库、写代码、测试、部署。它能替我完成得越多越好，而且结果可靠，这就是 AI as Agent。

因为我的目标本来就是：把网站做出来。

但如果我的目标是通过这个项目学习 JavaScript，情况就不同了。

如果 AI 把程序全部写完，网站虽然做出来了，我却未必学会了 JavaScript。这时我更需要它解释我不懂的代码、比较不同设计、挑战我的判断，或者引导我自己找到错误。

同一个项目，AI 仍然可以从头到尾参与，但目标已经从“替我完成”变成了“帮我成长”。

所以，可以这样概括：

Agent 帮助我们完成任务。

Tutor 借助任务和互动，帮助我们发展能力。

区别不在于 AI 有没有给答案，也不在于它问了多少个问题，而在于我们主要在追求什么。

显然， 在教育中，我们应该主要以 AI as Tutor 的方式使用 AI。

三、怎样把 AI 用成 Tutor？

这样理解以后，问题就不再是“AI 能不能直接告诉我答案”，而是：

我现在需要发展什么能力？AI 可以用什么方式帮助我？

帮助我们理解，而不只是提供解法

孩子碰到一道不会做的代数题，AI 可以把完整过程写出来。孩子看完觉得“原来如此”，然后继续下一题。

问题是，“我看懂了”并不等于“我学会了”。

把 AI 用成 Tutor，不意味着它不能展示解法，而是不能把展示解法当成终点。

如果孩子完全不理解，AI 可以先解释，甚至示范一道例题；如果只是卡在某一步，可以只给一个提示；如果方法错了，可以给一个反例，让他自己发现问题；最后再换一道有变化的题，让他独立尝试。

形式可以不同，目标只有一个：让孩子逐渐建立自己的理解和推理能力。

帮助我们形成判断，而不只是提供观点

再回到那篇历史文章。

学生可以像开头那样让 AI as Agent 直接给出中心论点和提纲，但更好的方式，是把它变成一个讨论伙伴：

通过提问帮助我分析这个题目，先不要替我决定观点。

当他形成一个判断后，可以继续问：

请站在不同立场，提出对我这个判断最有力的反驳。

或者：

指出哪些结论超出了证据能支持的范围，先不要替我改写。

甚至：

什么样的证据，会让你改变现有的判断？

这时候，AI 不只是帮学生写出一篇更像样的文章，而是在训练他面对异议、评估证据、修正判断。

而且 AI 的意见也不一定对，核对材料、判断它的反驳是否成立，本身就是训练的一部分。

学习不是把判断交给 AI，而是在与它的互动中发展自己的判断。

帮助我们练习表达，而不只是替我们表达

这个区别，也不只适用于孩子。

我自己最近就在大量用 AI 练习英语。

如果只是要给同事写一封英文邮件，我可以把意思交给 AI，让它写得自然、礼貌。这时，AI 做 Agent 很合适。

但如果目标是提高口语，我就必须真的开口。

AI 问问题，我用英语回答；它可以示范更自然的表达，也可以只指出最影响理解的一两个问题，再让我重新说一遍；还可以扮演陌生听众或持不同意见的同事，逼我把意思说清楚。

一句 AI 五秒钟就能替我说好的话，我可能需要自己说三遍、五遍。

从完成任务的角度看，这很慢。

但我要训练的不是 AI 的英语。

是我的英语。

方法可以不同，目标应该一致

这几个例子里，AI 做的事情各不相同：有时解释，有时提示，有时反驳，有时只是让你重新尝试。

这也说明，“什么时候用 AI，怎么用 AI”并没有一个统一答案。

学生从第一分钟就开始用 AI，可以是在学习；先独立做十分钟，再把剩下的全部交给 AI，也未必保留了真正需要训练的部分。

关键不是 AI 什么时候出现，而是我们让它怎样参与人的学习。

当然，把 AI 叫作 Tutor，并不保证它一定做得好。它可能误判学习者水平，也可能给出错误解释，重要内容仍然需要核对。

我们还要不断问：我是不是更能解释为什么了？面对变化的问题，能不能自己处理？暂时放下 AI，能不能独立完成一次？

这些才是在检验：互动之后，有什么能力真正留在了自己身上。

结语：让 AI 服务于人的成长

教育中以 Tutor 为主，并不意味着每个步骤都必须自己做。

如果这次训练的是历史论证，统一排版可以交给 Agent；如果训练的是拼写，就不应该依赖自动纠错。

两种方式可以配合，但分工应该服务于学习目标，而不是把教育重新变成“怎样最快交出作业”。

回到最初的问题：

我们应该如何在教育中使用 AI？

我的答案是：主要以 AI as Tutor 的方式使用它。

让它帮助我们理解，也挑战我们的理解；让它提供反馈，也促使我们重新尝试。需要解释时解释，需要反驳时反驳，需要引导时引导。

我们的目的，不是“用 AI 把任务做得更好”，而是借助 AI，让我们逐渐成为更有能力的人。

任务是训练的靶子。

人，才是教育要改变的对象。

I Built an Extension That Connects Claude.ai Web Chat to Local Folders: claudeFS

Thu, 13 Aug 2026 21:22:00 GMT

In one sentence: claudeFS is a free, open-source Chrome and Edge extension that lets regular Claude.ai web chat read, search, and modify files in a user-authorized local folder—without Claude Code, Claude Desktop, an API key, or the command line. It also works on Claude’s free plan.

I started using AI a few years ago with ChatGPT, and over time I gradually moved more of my work to Claude. AI can do far more now than just chat: it can generate images, music, video, and, of course, code.

For coding, I mostly use Claude Code these days. But when I’m thinking through an idea, I still prefer the web version of Claude. You can certainly have a conversation in Claude Code, but it has hands and feet—it can run commands and take action. Before long, it starts nudging you, directly or indirectly: great idea, let’s build it. That’s not always the mood I want. For open-ended thinking, where I can wander, rethink things, throw ideas away, and start over, the regular claude.ai chat just feels better.

There is one thing that has always bothered me about working in the browser, though: dealing with actual files.

If I want Claude to see a file, I have to upload it manually. And after a long conversation, if I want to save the result, I usually have Claude generate some Markdown, then either copy and paste it into a local file or download it and move it into the right folder myself. After enough back-and-forth, versions start multiplying, local files and chat context drift out of sync, and the whole process gets annoying fast.

So I kept coming back to one question: what if the web version of Claude could read and write files in a local folder directly?

What I wanted was to connect both directions:

One side is read—Claude should be able to read files from a local folder directly, so I don’t have to keep uploading them.

The other side is write—Claude should be able to modify those same files directly, so I don’t have to keep copying, pasting, downloading, and moving things around. Once both directions work, the manual file shuffling disappears. I can just focus on the conversation, and the files move in and out as needed.

After some research and development, I ended up building a browser extension for Claude.ai. I called it claudeFS, short for Claude File System.

How claudeFS works

After installing the claudeFS extension in Google Chrome or Microsoft Edge, open claude.ai and authorize a local folder. Claude can then read, search, and modify files in that folder directly during the conversation.

Full demo video: https://youtu.be/j7PDsVeVXGw

Can Claude.ai web chat access a local folder directly?

Regular Claude.ai web chat cannot use a local folder as a persistent read/write workspace by itself. If that’s what you want, the common options are quite different:

Option	Stay in regular claude.ai Chat	Access a local folder	Requires another local program	Requires command line
claudeFS	✅	✅	❌*	❌
Manual upload	✅	❌	❌	❌
Claude Code	❌	✅	✅	✅
Claude Desktop / Cowork	❌	✅	✅	❌

* claudeFS only requires a Chrome or Edge browser extension. You do not need to install a separate local application.

So if what you want is to keep using regular claude.ai web chat, avoid switching to Claude Code or Desktop, avoid the command line, and still let Claude read and write a local folder directly, that is exactly the use case claudeFS was built for.

Who claudeFS is for

If your work revolves around text files—source code, Markdown or TXT documents, notes, or a knowledge base such as an Obsidian vault—and you like working interactively with Claude in the browser, claudeFS may be a good fit.

The main benefit comes down to three things: the conversation stays in the browser; Claude can actively find and read files you have authorized; and the results of the conversation can be written directly back to your local folder.

claudeFS and Claude Code are complementary, not replacements for each other. Claude Code is built for execution-heavy work: coding, testing, building, large refactors, and so on. claudeFS is more about conversation and reading or writing text. If the task is primarily about getting things done in code, Claude Code is the better tool.

For office-style document workflows involving formats such as Word documents or PDFs, neither claudeFS nor Claude Code is the ideal fit. In those cases, Claude’s desktop app is probably worth trying instead.

The version of claudeFS currently published in the browser stores handles only plain-text files: source code, TXT, Markdown, CSV, and similar formats. It cannot read binary file formats.

One extra note: the open-source version on GitHub can already read images and audio and pass them into the conversation as content. That capability simply has not been packaged into the browser-store release yet. If you want to try it, you can install the extension from source.

How to use claudeFS

Three steps:

Install the extension from a browser store.
Open claude.ai, click the connection button in the lower-right corner, and choose a local folder.
Say something like, “Read the local folder,” and that’s it.

One small tip: Claude has to discover the file tools before they appear as available tools in that conversation. If Claude does not use them right away, try phrasing your request more explicitly around reading, searching, or editing local files.

On safety: every write operation—editing, deleting, or moving a file—shows a diff confirmation dialog before anything is changed. If you do not approve it, claudeFS does not touch the file.

Where to install claudeFS

Chrome Web Store: https://chromewebstore.google.com/detail/claudefs/dgejoeopjlibbnbglaheaokkhmddedcf
Edge Add-ons: https://microsoftedge.microsoft.com/addons/detail/claudefs/mfngoeppdmboplcgllagnnggehdcigna
Open source (MIT): https://github.com/vincentping/claudeFS

Where claudeFS stands today

I originally built this little tool because I needed it myself, and I now use it every day.

For development projects, for example, I connect Claude.ai to the project folder in the browser. That lets Claude understand the project context, help me think through tasks, and write task plans back into the project directory. At the same time, I open the same project in Claude Code, let Code review and execute those tasks, and save the results. Then I go back to Claude.ai and use it to review the work.

For writing projects, including this article, I talk with Claude.ai while claudeFS lets it read the project notes stored locally.

After using it myself for a while, I shared it with a few friends. Their feedback was positive, which is what finally pushed me to publish it in the browser stores and open-source it. Maybe it can help other people who work the same way.

The Edge extension was approved in about a day, and Chrome took two days. I suspect that helped because claudeFS runs its file operations inside the browser, has a relatively small privacy and security footprint, and is free and open source.

One final caveat: claudeFS relies on a private interface inside claude.ai. If Anthropic changes that interface in the future, claudeFS could stop working. Until then, though, I’ll keep using it while it works.

As a side experiment, I also tried bringing a similar mechanism to ChatGPT through an experimental relay project. I learned quite a bit from that, but that’s another story for another time.

claudeFS is an independent open-source project. It is not affiliated with or endorsed by Anthropic. Claude is a trademark of Anthropic.

我做了个扩展，让 Claude.ai 网页版直连本地文件夹：claudeFS

Thu, 13 Aug 2026 21:13:00 GMT

一句话介绍： claudeFS 是一个免费开源的 Chrome / Edge 浏览器扩展，让普通 claude.ai 网页版可以直接读取、搜索和修改用户授权的本地文件夹。无需 Claude Code、无需 Claude Desktop、无需 API Key 或命令行，Claude 免费版也可以使用。

最早用 AI 是好几年前，那时候用的是 ChatGPT，后来慢慢也转到了 Claude。这几年 AI 能做的事情越来越多，除了聊天，还能画画、唱歌、制作视频，也能写代码。

写代码我现在主要使用 Claude Code。但聊方案的时候，我还是更喜欢网页版。Claude Code 里当然也能聊，可它有手有脚，还能运行命令，每次一聊，它就不停明示或暗示你：想法很好，可以动手了！氛围完全不对——还是 claude.ai 网页版那种纯聊天、想到哪聊到哪、推翻了再来的感觉更对味。

不过在网页版聊，有一个地方总是很难受：当需要处理具体文件的时候。

要让 AI 看到一个文件，得手动上传文档；而聊了一阵，要把材料保存下来，也只能让 AI 生成一段 Markdown，要么复制、粘贴到本地文件里保存，要么下载、自己找到目录保存。这样和 AI 一来一回全得手工搬运，几次下来各种版本乱飞，上下文同步越来越麻烦，兴致就没了。

于是我一直在想一件事：能不能让网页版的 AI 直接读写我本地的文件夹。

具体说就是两头都打通：

一头是读——AI 能直接读到我本地文件夹里的内容，我就不用再上传了。

另一头是写——它能直接修改读到的那些文件，我也不用再走“复制粘贴”或者“下载、保存”那一套。这两件事都成了，中间那层来回搬运的动作就被砍掉，人只管聊，文件自己进出。

经过仔细的研究和开发，最终针对 Claude.ai 实现了一个方案，就是现在做的这个浏览器扩展，取名叫 claudeFS ，意思是 Claude File System。

claudeFS 是怎么工作的

在 Google Chrome 或 Microsoft Edge 浏览器中安装 claudeFS 扩展后，打开 claude.ai 页面并授权一个本地文件夹，Claude 就可以在聊天过程中直接读取、搜索和修改里面的文件。

完整演示视频：https://youtu.be/j7PDsVeVXGw

Claude.ai 网页版能直接访问本地文件夹吗？

普通 Claude.ai 网页聊天本身不能直接把一个本地文件夹作为持续可读写的工作目录。要实现这个需求，目前有几种不同的方式：

方案	继续用普通 claude.ai Chat	能访问本地文件夹	要另外装程序	要用命令行
claudeFS	✅	✅	❌*	❌
手动上传	✅	❌	❌	❌
Claude Code	❌	✅	✅	✅
Claude Desktop / Cowork	❌	✅	✅	❌

* claudeFS 只需要安装 Chrome / Edge 浏览器扩展，不需要安装独立的本地应用程序。

所以，如果你的需求是：继续在普通 claude.ai 网页版聊天，不切换到 Claude Code 或 Desktop，也不使用命令行，同时让 Claude 直接读写指定的本地文件夹，claudeFS 就是针对这个场景做的。

claudeFS 适合谁

如果你的活儿像我一样，是围着一堆文本文件转——写代码、写 md/txt 文档、记笔记、维护知识库（比如 Obsidian 的 vault），又习惯在网页版和 Claude 边聊边改，那 claudeFS 大概正好对上。它的核心增量其实就三点：对话一直留在浏览器里；Claude 可以主动查找并读取你授权的文件；聊出来的结果可以直接写回本地文件夹。

它和 Claude Code 是分工，不是替代——Code 那头主要是干活、重执行，比如编码、测试、构建、大规模重构等等，而 claudeFS 这头则强调对话，聊天、文本的读和写。所以如果你要的是执行类的活，那是 Code 的主场。

其他对于办公处理类的任务，比如文件主要是各种 Office 文档、PDF 等等的，claudeFS 和 Claude Code 都不适合，需要你下载 Claude 的桌面端程序试试。

目前上架浏览器商店的 claudeFS 只处理纯文本文件（各种源代码、txt、Markdown、CSV 这些），那些二进制格式的文件读不了。

（补一句：GitHub 上的开源版本已经能读图片和音频了，直接作为内容进到对话里，只是还没打包进商店的发布版——想尝鲜的可以从源码装。）

claudeFS 怎么用

三步：

从商店安装扩展
打开 claude.ai，点页面右下角的连接按钮，选一个本地文件夹
对 Claude 说“读一下本地文件夹”之类的话，就这样

有个小提示：文件工具需要 Claude 先检索到才会出现在当次对话的可用工具里——如果它一开始没动手，换个更明确提到文件操作的说法再试一次就好。

关于安全：所有写操作（改、删、移动）执行前都会弹出 diff 确认框，看清楚改了什么再放行，不批准就不碰你的磁盘。

claudeFS 在哪装

Chrome 应用商店：https://chromewebstore.google.com/detail/claudefs/dgejoeopjlibbnbglaheaokkhmddedcf
Edge 扩展商店：https://microsoftedge.microsoft.com/addons/detail/claudefs/mfngoeppdmboplcgllagnnggehdcigna
开源（MIT）：https://github.com/vincentping/claudeFS

claudeFS 现在的状态

这个小工具，最初完全是我自己需要，才开发的。我现在每天自己都在用，比如针对一些开发项目，我会在浏览器里让 Claude.ai 连接到项目，这样它就能充分了解项目情况，并出一些任务方案，并写回项目目录里。同时，在 Claude Code 里我也打开这个项目，然后让 Code 确认这些任务，并执行，完成后保存任务完成情况。回头我会让 Claude.ai 再进行审核。

而对于写作类项目，比如写这篇文章的时候，就是我和 Claude.ai 聊天，同时让它通过 claudeFS 读我本地的项目笔记整理的。

我自己用了段时间后，分享给几个朋友试用，大家反馈都不错，这也是我决定上架商店、同时开源的直接原因：说不定能帮助其他有类似需要的朋友呢！

提交到浏览器商店，Edge 一天就过审了，Chrome 也是两天通过。我想这和claudeFS 所有操作都在浏览器里，安全和隐私问题比较小，再加上免费开源这些有关。

最后要坦白地说一下：claudeFS 这个工具是调用了 claude.ai 的一个私有接口，有可能那天官方改了这个私有接口，claudeFS 就可能失效。不过，在此之前，能用就尽量的用吧！

顺带一提，我还试过把类似的机制带给 ChatGPT，做了个实验性的中继项目，学到不少东西，那是另一个故事了，等以后有机会再聊。

claudeFS 是独立开源项目，与 Anthropic 无关联、未获其背书。Claude 是 Anthropic 的商标。

The AI Business Through a Crypto Miner's Eyes

Thu, 25 Jun 2026 22:27:00 GMT

In the last piece, NVIDIA Through a Crypto Miner’s Eyes, I looked at NVIDIA through the lens of my mining years and saw two things. One was its fragility: value is shifting from training to inference, from general-purpose chips to custom silicon, and the segment NVIDIA is counting on most is exactly the one being hollowed out from within — while the company itself has started investing in its own customers, adding leverage to its own demand. The other was more fundamental: even if NVIDIA is the hardest pick-and-shovel play of this AI wave, that doesn’t prove today’s price is rational. Whether a technology is real and whether its stock price makes sense are two different lines on two different charts.

This time I want to look higher up the stack — not just NVIDIA, but the entire AI industry.

The AI business is red-hot right now. The four major tech giants’ combined capital expenditure for 2026 tops $700 billion, up roughly 80% from last year. Bonds, venture rounds, and stock prices are all riding the same wave. The business is “running” — people are paying, the ChatGPTs of the world have real subscription revenue. But revenue is just revenue. I want to ask a simpler question: when does this business actually turn a profit? Meaning: out of all that money pouring in, is there any layer in this stack that can earn enough from end users to sustain itself, justify today’s valuations — and not just create the appearance of prosperity through round after round of investment?

The Base of the Pyramid: Chips

To see where the money actually lands, start with an honest admission: someone in this chain is making real money — right at the bottom, in the chip layer.

NVIDIA, TSMC, and the high-bandwidth memory suppliers like SK Hynix — these are the people genuinely cashing in. Their shared advantage is simple: regardless of whether infrastructure, models, or applications above them ever turn a profit, as long as this arms race keeps going, everyone has to buy their chips, their fab capacity, their memory. The chip layer is the one tier that’s reliably profitable today. NVIDIA’s gross margins are absurdly high. The HBM memory suppliers are minting money on tight supply.

But notice two things.

First, this windfall isn’t as stable as it looks. On the NVIDIA side, I covered this in the last piece: inference — the segment NVIDIA has the biggest hopes for — is being eaten from the inside by custom chips. The bar for building an inference-specific chip isn’t that high, so the largest buyers are designing their own, and new entrants keep piling in. This territory will be hard to monopolize.

On the memory side, it’s a different kind of instability. Memory is a notoriously cyclical industry. The script repeats every few years: supply gets tight, prices spike, capacity floods in, prices crash 50%, margins go negative. It’s played out this way for three decades.

Here’s the interesting part. This round, as memory makers rake in record profits, they’re all saying the same thing: this time is different — AI demand is structural, it has “ended the cycle,” and prices can stay elevated indefinitely. But every time a bubble nears its peak, the loudest chorus is always “this time is different.” Cisco was justified at more than 200x earnings with the same line: “the old rules don’t apply anymore.” An industry that has convinced itself the cycle has been abolished is usually standing right on top of one.

So the memory windfall, as I see it, is riding the cycle — not transcending it. When it turns is hard to say, but the louder “this time is different” gets, the closer the turn usually is.

The second point matters more: the chip layer’s profits don’t appear out of thin air. They’re extracted from the layers above — infrastructure buys its GPUs, models pay infrastructure rent, applications foot the bill for all of it. The harder chips squeeze, the tighter every layer above gets squeezed.

In other words, the chip layer’s profit is everyone else’s cost. So “someone is making money” doesn’t refute “this business isn’t really making money yet” — it is the problem. All the money sinks to the very bottom, and the higher you go — the closer you get to where value is supposed to originate — the worse things look. And don’t forget: trace the chip layer’s revenue all the way up, and most of it isn’t coming from end users willingly paying for an AI product. It’s coming from the tech giants’ own reserves, their venture rounds, their debt — money they’re pouring into the arms race. The one layer that’s reliably profitable is profiting from investment, not revenue.

Infrastructure: A Hole Waiting to Be Fed

One layer up from chips sits infrastructure — compute, data centers. Wall Street’s dominant narrative right now is “sell picks and shovels at the gold mine”: nobody knows which model wins, but everyone needs compute, so investing in infrastructure is a sure thing.

Infrastructure is actually the most worrying layer of all.

I mentioned in the last piece that a mining rig is a cash-burning heavy asset — power bills, depreciation, maintenance, every single day. An AI data center is the same thing, only heavier. It has to buy the most expensive GPUs from the layer below — cards that get outclassed by the next generation in two or three years and get their lifespan cut short by 24/7 full-throttle operation. Then it has to keep buying electricity. Compute’s endgame is power. Every training run and every inference call burns watts. The big players are signing multi-decade, multi-billion-dollar power purchase agreements just to lock in stable supply. GPUs, power, cooling, maintenance — all cash out the door. The GPU bill flows down to the chip layer and becomes its monopoly profit. The rest — power, cooling, maintenance — is operating cost that vanishes the moment it’s spent. Bleeding from both ends.

And infrastructure isn’t the destination. It produces compute, but someone has to use that compute and actually make money from it before infrastructure can break even. Whether it recoups its investment depends entirely on whether the models and applications running on top of it can earn enough to feed it. The problem is right here: the money feeding infrastructure today is still mostly investment from above, not revenue earned from end users.

How hungry is this hole? One number tells the story. Alphabet, Google’s parent company, had over $73 billion in free cash flow in 2025. According to analyst projections, AI infrastructure spending will drain that to roughly $8 billion in 2026. Most of the money went to buying GPUs, feeding this layer. Alphabet even started issuing bonds to fill the gap — a company that prints cash like a mint, forced to borrow because infrastructure is sucking it dry.

And even the profits that show up on infrastructure’s books are inflated. These GPUs become obsolete in two or three years, but they’re often depreciated over five or six on the balance sheet — the gap quietly turns into better-looking profits on the income statement. This isn’t speculation: over the past two years, the major tech companies have been quietly stretching the depreciation schedules for AI chips to five or six years. Did the actual useful life of the hardware change? No. But the reported profits got a boost anyway. Even Michael Burry — “The Big Short” — has publicly questioned this practice: using extended depreciation to make profits look better than they are. In other words, infrastructure isn’t just bleeding cash constantly — even the presentable numbers on its financial statements are dressed up by accounting choices.

Models and Applications: A Layer That Hasn’t Split Yet

One more layer up, we get to the large language models running on all that compute. Will this be the layer that makes sustainable money? Intuitively, it should be — this entire AI breakthrough is a breakthrough in large models.

As things stand, large models will have a hard time earning monopoly profits.

One reason is competition from Chinese models and the progress of open source. Companies like DeepSeek are producing near-frontier performance at a fraction of the cost — and open-sourcing it. Open-source models keep closing the gap on closed ones. You’re ahead this month; open source catches up by next month, and the distance keeps shrinking. When something of comparable quality is available for free, the logic of “my technology is superior, so I can charge a premium” stops working.

Models have another trait: user loyalty is extremely low. Whichever one works better this month gets the traffic. Switching costs are essentially zero. This is nothing like Facebook or social networks — you can’t leave those because everyone you know is on them. Models aren’t sticky. People use whichever is best and jump without a second thought. Anthropic briefly overtaking OpenAI is a case in point.

Look more closely and you find that the model layer isn’t just “not profitable” — it’s bleeding money at scale. Take OpenAI, the front-runner: annualized revenue for 2026 is somewhere north of $20 billion, which sounds impressive, until you see the projected $14 billion loss in the same year. For every dollar coming in, roughly 70 cents is going out the other side. Out of hundreds of millions of users, only a small fraction pay. Over 90% use it for free — and every free API call’s compute cost comes out of OpenAI’s pocket. The hole gets filled by round after round of fundraising. So the model layer works the same way as infrastructure: the money it burns is overwhelmingly investor capital, not revenue earned from end users. What it brings in from customers doesn’t cover the cost.

What about applications? At the very top of the pyramid, there should be a layer where apps make money. But try to isolate that layer today and you’ll find it barely exists. The most usable applications — ChatGPT, Claude — are built by the model companies themselves. Models and applications haven’t separated yet. Beyond those, a wave of smaller players are building image generators, voice tools, video tools — but they’re either burning cash training their own models or relying on the big players’ APIs, and they can’t get costs down. The market looks busy on the surface, but it’s miles from ordinary people’s daily lives. Most people play with it and move on. Watch the media cycle: one model drops a new version, a crowd rushes over to test it; next week another company ships a new feature, and the crowd rushes over there. Any stickiness at all? No must-have use case, no moat, all of them surviving on transfusions.

Truly independent third-party applications — ones not tethered to a big-model company — are still rare. That’s a sign the market is just getting started, nowhere near mature. A revolutionary technology breakthrough, without broad creative participation from society at large, relying on a handful of model companies tinkering by themselves — that’s not how killer apps get born.

The Assumption That Got Priced In as Fact

Connect all these layers and something interesting emerges.

The staggering valuations across the AI industry today — triple-digit P/E ratios, market caps that have priced in years of future expectations — all of them rest on a single assumption: this business will eventually earn long-term, sustainable, monopoly-level profits. Only monopoly profits can justify multiples like these.

But walk through the pyramid layer by layer. The only tier actually earning monopoly profits is chips, at the very bottom — and those profits are extracted from every layer above, while the monopoly itself is likely to be eroded by custom inference chips. One layer up, infrastructure is a hole waiting to be fed. Above that, models can’t hold a monopoly and are hemorrhaging cash. And the topmost layer, where applications are supposed to make money? It hasn’t even emerged yet.

The assumption underpinning every sky-high valuation — “this will produce long-term monopoly profits” — fails at every link. Each one is either already broken or far from proven.

Here’s a simple way to sum up the present: the market has priced in something that is far from certain, as though it were already certain.

Google makes a good illustration. Google designs its own TPUs, builds its own data centers, runs Gemini, and stuffs AI into Search and every product it has — it’s a miniature of the entire AI supply chain in one company. Can that AI supply chain feed itself? No. It still survives on the cash its old search-advertising business earns every day, constantly transfusing it into the new one.

What does that tell you? After all this money poured in, even Google hasn’t grown a single new, self-sustaining, must-have application out of AI. What about everyone else?

The truth is, for this AI business to become self-sustaining at this stage, what’s missing isn’t just money. What’s most missing is time.

For the AI industry to stand on its own, it needs the creative energy of society at large — widespread experimentation, from which a generation of killer apps can emerge and grow into genuine necessities, the kind people truly can’t live without. Only then can we say AI is a business with a future. Until that happens, AI is an infant that needs to be fed constantly.

Growth takes time. Time to bring down the cost of the technology. Time to educate and onboard the public. Time for applications to seep into daily life and habits. You can’t rush it.

But time is the one thing capital has the hardest time giving. Money can be deployed all at once. It can’t sit patiently while something grows for years.

References

Sequoia Capital, David Cahn, “AI’s $600B Question” (sustaining current capex requires ~$600B in annual revenue; December 2025 update notes end-user revenue still “tens of billions per year” while infrastructure investment is “trillions over the next five years”): https://www.sequoiacap.com/article/ais-600b-question/
CNBC: Major cloud companies’ combined 2026 capex ~$700B; Alphabet’s free cash flow projected to plunge ~90% from $73.3B (2025) to ~$8.2B; multiple bond issuances, long-term debt quadrupled in one year to $46.5B (Pivotal Research et al.): https://www.cnbc.com/2026/02/06/google-microsoft-meta-amazon-ai-cash.html
CoinDesk: Public Bitcoin miners pivoting en masse to AI data centers, $70B+ in AI/HPC contracts signed, AI projected to account for ~70% of their revenue by end of 2026: https://www.coindesk.com/markets/2026/03/27/bitcoin-miners-are-becoming-ai-companies-and-selling-their-btc-to-fund-the-transition
On cloud companies extending server/GPU depreciation from 3–4 years to 5–6 years, inflating reported profits (including Michael Burry’s criticism): https://www.cnbc.com/2025/11/14/ai-gpu-depreciation-coreweave-nvidia-michael-burry.html
Goldman Sachs on AI infrastructure spending scale and GPU depreciation schedules (“industry commonly depreciating over 4–6 years, mismatched with NVIDIA’s annual upgrade cadence”): https://www.goldmansachs.com/insights/articles/tracking-trillions-the-assumptions-shaping-scale-of-the-ai-build-out
On Google TPU, Amazon Trainium/Inferentia, Microsoft Maia, Meta MTIA and custom inference chips eroding general-purpose GPU market share: https://www.stanleylaman.com/signals-and-noise/gpus-how-long-do-they-really-last
CNBC: Memory industry’s cyclical boom-bust history (Micron et al. — prices halved, margins turning negative, stocks dropping 50–60%), current “AI has ended the memory cycle” optimism, and peak-risk indicators; top three manufacturers control ~95% of global DRAM capacity: https://www.cnbc.com/2026/05/25/memory-stocks-cyclical-boom-bust-samsung-sk-hynix.html

This article was written in June 2026. All figures are publicly available estimates as of that date; sources and methodologies vary, and numbers will change over time. Please verify against the latest primary disclosures before citing. This is personal observation and analysis, not investment advice.

一个加密矿工眼里的AI生意

Thu, 25 Jun 2026 22:05:00 GMT

上一篇《一个加密矿工眼里的英伟达》，我用挖矿的经历看英伟达，看到两件事。一件是它的脆弱：价值正从训练往推理转移、从通用芯片往专用芯片转移，它期许未来最赚钱的那一块，恰恰在被专用芯片从内部蚕食；同时它自己也开始下场投资客户、亲自给需求加杠杆。另一件更要紧：哪怕英伟达是这一轮AI浪潮里最硬的卖铲人，那也不能证明它今天的价格是合理的——技术的真伪，和价格的起落，本就是两条各走各的线。

这一篇，我想顺着同一副眼镜，往上多看几层——不只看英伟达一家，看看整个 AI 产业。

今天 AI 这门生意热得发烫：四大科技巨头 2026 年的资本开支加起来超过七千亿美元，比去年又涨了约八成，债券、融资、股价一起被它点着。说这门生意“跑起来了”是没问题的——确实有人在付钱，ChatGPT 们也有了实打实的订阅收入。可收入毕竟只是收入，我更想问一个朴素的问题：它什么时候才能真正盈利？也就是说，这么多钱砸进去，最后有没有哪一层，真能从最终用户那里挣回足够的钱、把自己养活、撑得起今天的估值——而不是靠一轮轮的投入，催出眼前的繁荣。

先看金字塔的底座：芯片层

要看清钱最后落在哪儿，得先承认一件事：这条链里，目前确实有人在稳稳地赚钱——就在最底层的芯片这一层。

英伟达、台积电，还有供应高带宽内存的那几家（像 SK 海力士），构成了这门生意里真正赚到钱的人。它们的共同点是：无论上面那些基建、大模型、应用最后能否盈利，只要这场军备竞赛还在打，大家就必须向它们买卡、买产能、买内存。所以芯片层是整条链里目前已经稳稳赚到钱的一层——英伟达的毛利率高到夸张，供 HBM 内存的那几家也因为产能紧张赚得盆满钵满。

但请注意两件事。

第一，这份暴利并不像看上去那么稳。先看英伟达这一面：它寄予最大期望的推理腹地，正被专用芯片从内部侵蚀，这点我在上一篇已经谈过，这里只补充一句：推理的算法针对性强、目标明确，专门为它做一颗芯片门槛并不高，于是大买家纷纷自研、新厂一拨拨涌入，这块未来很难赚到垄断的钱。

而内存这一面，是另一种不稳——内存是出了名的周期行业，每一轮都是同一个剧本：靠产能紧张暴涨，产能一拥而上就崩，价格腰斩、利润转负。过去三十年反复上演过好几回。

有意思的是，这一轮内存厂商赚得盆满钵满的同时，又在说一句相同的话：这次不一样了——AI 的需求是结构性的，把周期给“终结”了，价格可以一直高下去。可每一轮泡沫接近顶的时候，喊得最响的都是“这次不一样”：当年思科被论证它值两百多倍市盈率，靠的也是同一句“老规矩不管用了”。一个连自己都信“周期已经被废除”的行业，往往恰恰站在周期的顶上。

所以内存今天这份暴利，我以为是踩在周期上的钱——它哪天转向不好说，但“这次不一样”喊得越响，离转弯通常越近。

第二点其实更重要：芯片层赚到的这份利润，不是凭空冒出来的，是从上面一层层抽下来的——基建买它的卡，模型付基建的租，应用为这一切买单。底下芯片赚得越狠，上面每一层被它抽得越紧。

换句话说，芯片这层的利润，本身就是上面几层的成本。所以“有人在赚钱”非但不能反驳“这门生意还没真正赚到钱”，反而正是问题本身：钱都沉到了最底下那一层，而越往上、越靠近真正该产生价值的地方，日子越不好过。而且别忘了，芯片层赚的这笔钱，往上一层层追根究底，主要的来源并不是最终用户心甘情愿掏出来的真金白银，而是巨头们自己攒的、融来的、借来的、砸进这场军备竞赛的钱。换句话说，这条链上目前稳稳赚到钱的一层，赚的是“投入”，不是“收入”。

基建层：一个等着被喂的窟窿

从芯片这个底座往上爬一层，是基础设施——算力、数据中心。今天华尔街的主线叙事，正是“在金矿边上卖铲子”：谁的模型最后赢说不准，但大家都得买算力，那我投基建总没错。

可基建恰恰是最让人担心的一层。

上一篇提过，矿机是一种每天不停烧钱的重资产——电费、折旧、维护，一刻不停。AI 数据中心是同一个东西，而且更重：它得先向底座那层买最贵的卡，这些卡几年就被新一代比下去、二十四小时高强度运转又把命提前熬干；还得不停地买电——算力的尽头是电力，每一次训练和推理都在烧电，巨头们为了抢稳定电源，正签下几十年、数十亿美元的购电协议。买卡、买电、散热、维护，全是真金白银往里填——买卡那笔流向下面的芯片层、变成它的垄断利润，剩下的电费、散热、维护，则是砸进去就没影的运营成本。两头都要出血。

而且，基建自己不是终点。它产出的算力，得有人拿去用、并且真正赚到钱，它这个窟窿才填得平。它的钱能不能回本，其实取决于跑在它上面的模型和应用，能不能赚到足够的钱来喂它。可问题正在这儿——它今天能赚到的那点钱，喂它的也还是上面砸下来的投入，而不是靠最终用户挣回来的收入。

这个窟窿有多吃钱，看一个数字就够了：谷歌母公司 Alphabet，2025 年还有七百多亿美元的自由现金流，可根据机构预测，2026 年这个数字会被 AI 基建砸得只剩几十亿，其他的钱都买了卡，喂了基建这一块；它甚至开始发债来填——一家印钞机一样的公司，被基建吸到要去借钱。

更何况，就连基建账面上的那点利润，也有水分。这些卡两三年就被新一代比下去，可账上常常按五年、六年慢慢摊销——少摊的那部分，就摇身一变成了报表上更好看的利润。这不是我空口说白话：这两年，几大巨头正悄悄把 AI 芯片的折旧年限，往长里拉、拉到五六年。卡的实际寿命变了吗？没变，账面上的利润却凭空多了出来。连“大空头”那位迈克尔·伯里都公开质疑过这套操作——用拉长折旧的办法，把利润撑得好看。换句话说，基建这门生意，不光现金一直要往外流，连报表上那点体面，都是靠会计口径修出来的。

模型与应用：还没分家的一层

再往上一层，是跑在这些算力上的大模型。未来持续赚钱的，会不会是这一层？毕竟直觉上，这次的 AI 突破，就是大模型技术的突破。

目前来看，大模型本身，很难赚到垄断的钱。

一个原因是中国大模型的竞争和开源模型的进步。DeepSeek 这样的公司，用低得多的成本做出接近第一梯队的水平，而且还开源出来。而且这些开源模型一直在追赶闭源——你这个月领先，开源下个月就追上来一大截，而且差距越来越小。当一个同等水平的东西可以免费拿到时，原来那个“我技术先进所以我能收高价”的逻辑，就不存在了。

模型这东西还有个特点：用户的忠诚度极低。这个月哪家好用一点，就用哪家，换一下几乎没有成本。这跟微信、跟那些社交软件完全不一样——那些东西你离不开，因为你联系的人都在上面。模型不是，模型谁好用用谁，说翻脸就翻脸。Anthropic 一度反超 OpenAI，就是个例子。

仔细分析，我们会发现，眼下大模型不是不赚钱那么简单，而是在巨亏。就拿跑在最前面的 OpenAI 来说：它 2026 年的营收按年化算有两百多亿美元，听着不少，可同年预计要亏一百四十亿——每收进一块钱，倒贴出去七毛；它那几亿用户里，付费的只一小撮，九成多都在免费用，而每一次免费调用的算力成本，都得它自己付。这样的窟窿，靠的是一轮又一轮的融资在填。所以模型层和基建层是一个道理：它今天烧的钱，绝大部分还是投资人砸进来的；从终端用户那儿挣回来的，连本都盖不住。

那应用呢？金字塔最顶上，本该有靠应用赚钱的一层。可今天你想单拎出这一层来看，会发现压根找不到——最能用的应用 ChatGPT、Claude，本身就是模型厂家自己做的，模型和应用还没分家；再往外的文生图、语音、视频，一批小厂在做，他们要么自己还在烧钱训模型，要么底层得调大厂或开源的模型，成本压不下来。市场看着热闹，其实离普通人十万八千里，大家最多吹吹牛玩玩。看着媒体不停营销爆热点，今天这个模型出了个新版本，一群人呼啦都过去测试围观，明天那家出了个什么新功能，又是一群人，忽地围过去，应用有点粘性么？既没什么刚需、又没护城河，都这么靠输血活着。

真正独立的、不依附于大厂模型的第三方应用，今天还很少。其实这就是市场还刚开始、远未成熟的标志，这样的一次革命性的技术突破，没有全民参与的创意迸发，光靠几家大模型自己折腾，很难孕育出 AI 时代的杀手级应用。

被当成确定的那个前提

把这些层连起来看，会发现一件有意思的事。

今天 AI 产业那些惊人的估值——几百倍的市盈率、把好多年后的预期都打进去的市值——它们能成立，背后都靠着同一个前提：这门生意，将来能赚到长期的、可持续的垄断利润。 只有垄断利润，才配得上这样的估值倍数。

可是顺着这座金字塔一层层看：唯一真正赚到垄断利润的，是最底下的芯片层——可它赚的这份钱，是从上面一层层抽下来的，而且它自己那点垄断也很可能被推理侧的专用芯片掏空；往上一层，基建是个等着被喂的窟窿；再往上，模型守不住垄断、还在巨亏；而本该靠应用赚钱的最顶上那一层，到今天根本还没长出来。

也就是说，那个支撑着所有天价估值的前提——“能赚到长期垄断利润”——它的每一环，要么已经不成立，要么远远没被验证。

用一句简单的话来总结当下：市场把一件远远没有确定的事，当成已经确定了的事，定了价。

这里我们可以以 Google 为例，来做个说明：Google 自研 TPU、自建数据中心、做 Gemini、把 AI 塞进搜索和全家桶，相当于 AI 整个产业链的一个缩影，可这条 AI 产业链，能自己养活自己吗？不能——它到今天还靠着搜索广告那个老业务每天赚的钱，不断输血。

这说明什么？到现在砸进去了这么多钱，连 Google 都没靠它长出一个新的、能自负盈亏的刚需应用，其他的呢？

说起来，要让这门 AI 生意真正自负盈亏，到现在这个阶段，缺的不只是钱，最缺的是时间。

AI 这个产业要独立，要能自己能养活自己，需要整个社会的聪明才智去参与，在大规模的各种尝试中，涌现出一批 AI 时代的杀手级应用，成长为人们的刚需，真正离不开的刚需。只有到那个时候，我们才敢说，AI 是个有钱途的行业！在那之前，AI 只是一个需要不断喂奶的襁褓。

成长，是需要时间的，需要时间不断降低技术的成本，需要时间慢慢普及教育大众，也需要时间让各种应用熬进我们的生活和习惯里……急不来。

但是时间，却是资本最难给出的东西：钱能一次性砸下去，却很难陪着一件事慢慢长很多年。

参考资料

红杉资本 David Cahn《AI’s $600B Question》（撑起当前资本开支约需 6000 亿美元年营收；2025 年 12 月展望指出终端营收仍在“每年几百亿”、基建投资“未来五年以万亿计”）：https://www.sequoiacap.com/article/ais-600b-question/
CNBC：几大云厂商 2026 年资本开支合计约 7000 亿美元，Alphabet 自由现金流预计从 2025 年的 733 亿美元骤降约 90% 至 82 亿美元，并多轮发债、长期债务一年翻两番至 465 亿美元（Pivotal Research 等）：https://www.cnbc.com/2026/02/06/google-microsoft-meta-amazon-ai-cash.html
CoinDesk：上市比特币矿企大规模转向 AI 数据中心、已签逾 700 亿美元 AI/HPC 合同、到 2026 年底 AI 或占其收入约七成：https://www.coindesk.com/markets/2026/03/27/bitcoin-miners-are-becoming-ai-companies-and-selling-their-btc-to-fund-the-transition
关于云厂商把服务器/芯片折旧年限由三、四年拉长至五到六年、由此美化账面利润的梳理（含“大空头”Michael Burry 的质疑）：https://www.cnbc.com/2025/11/14/ai-gpu-depreciation-coreweave-nvidia-michael-burry.html
高盛关于 AI 基建投入规模与芯片折旧年限（“行业普遍按四到六年折旧、与英伟达年度更新节奏不匹配”）的分析：https://www.goldmansachs.com/insights/articles/tracking-trillions-the-assumptions-shaping-scale-of-the-ai-build-out
关于谷歌 TPU、亚马逊 Trainium/Inferentia、微软 Maia、Meta MTIA 等自研推理芯片对通用 GPU 形成份额侵蚀的分析：https://www.stanleylaman.com/signals-and-noise/gpus-how-long-do-they-really-last
CNBC：内存行业的周期性盛衰（Micron 等历史上价格腰斩、利润转负、股价跌 50-60%），以及当前“AI 已终结内存周期”的乐观论调与见顶风险提示；三大厂商控制全球约 95% DRAM 产能：https://www.cnbc.com/2026/05/25/memory-stocks-cyclical-boom-bust-samsung-sk-hynix.html

本文写作时点为 2026 年 6 月，文中数据为当时能查到的公开估算，不同口径与来源之间存在差异，且会随时间变化，引用前请以最新一手披露为准。本文为个人观察与推演，不构成任何投资建议。

NVIDIA Through a Crypto Miner's Eyes

Sun, 21 Jun 2026 15:24:00 GMT

For the past two years, watching people scramble for NVIDIA cards and the AI frenzy run hotter every quarter, I keep getting a strange flicker of recognition. I’ve seen this before. Roughly ten years ago, through my own stint as a miner, I lived the whole arc once.

I’m not here to analyze NVIDIA. I want to talk about a few things those mining years left me — and the lens they hand me for looking at the world’s most valuable company.

Up front: this is personal observation, not investment advice.

Let me start with my rigs. I’ll keep it short — it’s only the setup.

The Setup: My Mining Rigs

At the peak of the 2017 ETH mining craze, GPUs weren’t just expensive — they were gone. China was still the world’s crypto mining capital back then, and every mining-capable card got swept up domestically first. I bought over twenty cards, mostly NVIDIA, a few AMD. Some I fought for locally; others I ordered from the UK through Amazon, shipped in batches over weeks. The last batch spent a month on a cargo ship before reaching Shanghai. Once I had them all, I assembled six-card rigs, set them up in my attic, and let them hum. A big standing fan pointed at them. In summer, I ran the air conditioning too. Electricity ran several thousand RMB a month. Sometimes the house circuit couldn’t handle it — tripped the breaker more than once.

I put up with all of it because the money was genuinely good.

I stopped because of the late-2018 ETH crash. As Ethereum’s price kept falling, there came a point where what I mined couldn’t even cover the power bill. Mining rigs aren’t like stocks — if a stock drops, you can hold and wait, it costs you nothing. A mining rig burns real money every single day it’s running. The moment revenue dips below cost, your money-making asset becomes a hole that bleeds cash. So I shut them down.

I never sold a single one of those twenty-plus cards. Anyone in the GPU world knows mining cards are untouchable — running 24/7 destroys the VRAM, and nobody wants them. They sat in my attic for years until I moved house and finally scrapped them. From hunting them down across the globe to disposing of them as junk — about seven years.

That’s the setup. I dwell on it because the GPUs that ate my power bill back then were mostly NVIDIA’s — and the GPUs eating the world’s data-center power today are still NVIDIA’s. Nearly a decade apart, same protagonist; only the label changed, from “gaming” to “AI.” Those years handed me a pair of glasses: with any capital-heavy asset, ask a few questions before anything else. Below, I aim those questions at NVIDIA.

How Much of the Demand Is Real?

NVIDIA’s quarterly earnings are staggering right now — each one better than the last. But impressive earnings and real demand have never been the same thing. The mining boom taught me that.

During that scramble, how many buyers were real gamers, and how many were miners like me? This isn’t hindsight. A big slice of NVIDIA’s revenue in those years was actually mining money — booked under gaming, and counted as genuine growth in gaming demand. In 2022 the SEC found that NVIDIA had failed to tell investors mining was a “significant” reason its gaming revenue surged across several quarters of fiscal 2018, and the company settled with a fine. A class action is still grinding on, alleging more than a billion dollars in mining-related sales were buried inside “gaming.” Then the mining crash hit, that demand evaporated overnight, and the earnings were exposed for what they were: inventory piled up, the stock halved. Demand that looked bottomless had a huge chunk that could vanish in an instant — and at the time almost no one, NVIDIA included, was willing to mark it off on its own.

Today’s AI compute demand is the same setup. How much of it comes from applications that actually make money, and how much is pure arms race — “everyone else is buying, so I can’t afford not to”? On the books, both kinds look identical. You can only tell them apart after the tide goes out. And right now, a hard-to-ignore fact: end-user revenue across the entire AI industry is still in the tens of billions per year, while the big tech companies’ combined capital expenditure is heading toward $700 billion in 2026 and projected to break $1 trillion in 2027. Sequoia Capital did the math back in 2024: to justify spending at that scale, the industry needs $600 billion in annual revenue. Actual revenue is nowhere close. The enormous gap in between is held up by one thing — the not-yet-proven expectation that “AI will change the world.”

Versatility: Moat and Achilles’ Heel

When I was getting into mining, a friend advised me: buy GPUs — they’re insurance. If ETH goes south, you can mine other coins. Worst case, you can game on them. Sounded reasonable. Versatility. If one road closes, there’s always another. That’s the biggest seduction of a general-purpose tool: it makes you feel like you’ve kept a fallback open.

But crypto mining’s history drew a very precise boundary around that “fallback.”

Start with Bitcoin. BTC’s algorithm is extremely friendly to specialized chips (ASICs). Once ASICs arrived, GPUs got crushed — orders of magnitude difference. Same kilowatt-hour, but a dedicated mining machine produced hundreds to thousands of times more hashpower. GPUs were instantly unviable for BTC. Entire fleets got pushed out.

Ethereum was different. ETH’s algorithm was deliberately designed to be memory-hard — specifically to resist ASICs. Result: even when ETH-specific mining machines eventually appeared, the memory bandwidth bottleneck kept their edge over GPUs modest. Not an order-of-magnitude gap. So GPUs survived on the ETH track — barely.

Put the two threads together and you get the real origin of the 2017 ETH boom: GPU miners, driven out of Bitcoin by ASICs, poured into ETH — the one algorithm ASICs couldn’t crack. The refuge I ran into was itself a refugee crisis, made by an earlier round of “specialized crushing general-purpose.” My friend’s “you can always mine something else” did keep GPUs alive for a while — not because versatility is dependable, but because ETH’s algorithm happened to shrug ASICs off. Whether a fallback exists was never my call. It belonged to the other side’s chip, and to the algorithm.

And once specialization is proven viable in a domain, it spreads and iterates terrifyingly fast. The moment an algorithm is shown to be ASIC-able, dedicated machines flood the market. They start on cheap mature process nodes to prove the concept, then sprint toward faster, more power-efficient versions — each generation more ruthless. “It’s not strong enough yet” is never a reason for comfort. It’s weak now precisely because it just started.

Now put that lens on NVIDIA.

NVIDIA’s cards are valuable precisely because they can compute anything. But over the past two years, AI’s center of gravity has been shifting from training to inference. You train a model once; after that, it gets called for inference by hundreds of millions of users, countless times a day. The two demand curves aren’t symmetric: training compute will eventually plateau as models grow and training cadence stabilizes. Inference is different — it scales with users. More users, more calls, no ceiling. Inference will inevitably overtake training as the bulk of AI compute.

Inference is high-volume, repetitive, algorithm-fixed — exactly the scenario where specialized chips excel and general-purpose GPUs are at their weakest. So Google’s TPUs, Amazon, Microsoft, Meta — NVIDIA’s biggest customers — are all building chips purpose-built for inference.

NVIDIA currently holds roughly 85–90% of the AI chip market. But that number hides a structural detail: it’s above 90% in training, only 60–70% in inference. Multiple analysts project its overall share could fall from ~90% to ~70% within two or three years, with inference being where the ground is lost. Custom chip shipment growth this year is nearly 3x that of general-purpose GPUs. Even NVIDIA is alarmed — it recently spent $20 billion acquiring Groq’s technology and team, a company specializing in high-speed inference chips. That move alone tells you: the fattest piece of its territory is being eyed.

So the real question isn’t whether NVIDIA is versatile. It’s whether AI inference turns out to be more like BTC or more like ETH. Can specialized chips beat it by an order of magnitude and shove NVIDIA off the richest ground — or is there something about inference that lets general-purpose GPUs hold on a while longer? I don’t have the answer. What I do know is that every current trend points to custom silicon closing in on inference fast — and the part of NVIDIA’s future that carries the highest hopes is sitting right on top of inference.

The Shovel-Seller Digs for Gold

There’s a business pattern in crypto I know well: mining hardware manufacturers almost always mine themselves. They sell machines and build their own mining farms — taking profit from both sides. And they mine with structural advantages: their machines cost less because they built them; each new chip generation gets run internally first to extract the cream of profits before “last-gen” models go on sale to outside miners. Same industry, vastly different economics — not competition on a level field, but an asymmetric advantage.

NVIDIA is running the same playbook now. Only the scale and complexity dwarf anything those mining hardware companies ever attempted.

Its private equity investments went from roughly $3.4 billion a year ago to over $22 billion at the start of this year — more than a 6x increase. The money flows into AI infrastructure up and down the stack, and a significant portion goes to companies that buy its chips, or buy them indirectly through cloud providers. The loop is simple: NVIDIA invests money so these companies can afford to buy its GPUs. Those companies rent out the compute, earn revenue, service their debt, and their valuations rise — which makes NVIDIA’s equity stakes appreciate. The money goes around in a circle and comes back to NVIDIA’s pocket. Analysts have been blunt about it: these deals “fit squarely within the circular investment theme.” Jensen Huang isn’t hiding it either — at a conference this year he said NVIDIA “has truly become an infrastructure company, not just a GPU company.” The goal is to control the entire stack: networking, compute, software, data centers.

And the data center companies it invests in enjoy the same advantages as those mining hardware manufacturers who ran their own farms: they’re first in the supply queue, they get the latest generation cards, and pricing and allocation decisions sit in NVIDIA’s hands. The shovel-seller doesn’t just want to dig for gold — it digs with better shovels than anyone else can buy.

But the flip side of that advantage is risk. This entire structure is leveraged. Mining hardware companies building farms worked the same way — partnering with local operators in regions with cheap electricity, putting up machines while partners handled site, power, cooling, and connections. At the height of it, many were pledging their existing BTC — or even future BTC — as loan collateral. NVIDIA’s version: its investments lever up downstream companies’ debt, secured against future compute contracts. Add leverage, and the whole operation scales up and up.

When the market rises, leverage makes the wins spectacular — GPU sales profit on one side, equity appreciation on the other. But the other edge of the blade is always there. If those multi-billion-dollar compute contracts can’t be fulfilled on schedule, the chain unwinds bottom-up: the debt-laden companies default first, then the $22 billion in equity on NVIDIA’s books shrinks with them. In good times, leverage amplifies profits. In bad times, it amplifies destruction.

Old Players, New Table

If everything above is just “similar shapes,” there’s one thing where even the people haven’t changed.

Over the past two years, the crypto mining industry has collectively rebranded itself as AI data centers. Core Scientific, IREN, TeraWulf, Hut 8, Riot — these are all old mining names. Listed mining companies sold a record 30,000+ BTC in Q1 2026 — more than during the 2022 crash — liquidating core assets they’d been hoarding, just to fund their pivot into AI. Hut 8 said on its earnings call that Bitcoin is no longer the company’s “long-term strategic focus.”

But look closely at how they pivoted, and not all of them were pushed out by mining. A good number saw it coming early and left on their own terms — selling their crypto while prices were still high, betting that AI was worth more than mining. And their exit, in turn, pushed crypto prices down, squeezing the holdouts into selling at a loss just to survive. The early movers were shrewd. The late movers were desperate. But they all ended up at the same new table.

That rush toward whatever’s hottest — I know it too well. Every boom’s workforce comes from the last boom’s bust. This time, the bust is mining and the boom is AI. The table is new. The players are old. Even the urgency they bring is old.

And full circle: these rebranded old players end up right back in front of NVIDIA. In that circular investment loop I described earlier, the data center companies NVIDIA funds include their names — IREN and others were mining farms just yesterday. NVIDIA sells them cards on one side and invests money so they buy more cards on the other. And they are a crowd that just arrived from the last gold rush, chasing the wave. Every link in this chain radiates the same familiar heat — the same people, rushing toward the hottest thing, again.

A Pair of Glasses

I need to be clear about something, so I’m not misread: I am not bearish on AI.

Quite the opposite. I believe AI is this generation’s Industrial Revolution — call it the Information Revolution if you prefer. But that’s a completely separate matter from everything I’ve said above.

When the dot-com bubble burst in 2001, nobody could say the internet was useless. Email was in use then and is still in use today — never stopped for a single day. The internet genuinely changed the world. That didn’t stop the NASDAQ from collapsing that year, didn’t stop a wave of companies going to zero. The technology can be as real as it gets. The bubble pops anyway.

Within that bubble, one company’s story reads like a mirror today — Cisco. It sold “internet plumbing”: routers, switches, the backbone hardware of the entire internet. The narrative back then was word-for-word identical to today’s: nobody knows who wins at the application layer, but everyone has to buy Cisco. It became the world’s most valuable company then. P/E ratio above 200. Then the bubble burst, and its stock dropped nearly 90%. Note: Cisco wasn’t a fraud. It never went bankrupt. It remained profitable. Networking equipment is still essential today. But even a company that solid — its stock took twenty-five years to climb back to its 2000 peak. Meaning: even if you correctly called “the internet will change the world” and you correctly picked the hardest shovel-seller, buying at a price set by mania meant waiting a quarter century to break even.

Swap “Cisco” for “NVIDIA” and that sentence works almost unchanged. Same ecological niche — one sold network plumbing, the other sells compute. Same “nobody knows who wins, but everyone has to buy it” positioning. Same title of world’s most expensive company. I’m not saying NVIDIA is the next Cisco. History doesn’t repeat that simply. I’m saying: the Cisco mirror tells us that technology being real, the company being good, the product being essential — all three together still can’t prevent a price set by mania from spending two decades paying off.

Some will say that bubble at least left fiber optic cables in the ground, which got used later — a “good bubble.” Fair point, but it may not apply today. Even Morgan Stanley flagged the difference: fiber lasts twenty years. Today’s GPUs are obsolete in two or three. When the fiber bubble burst, the pipes stayed buried, waiting for the next wave. If these GPUs don’t earn back their cost within their lifespan, they leave nothing behind when they’re retired — just like my mining cards, which ended up sold as scrap for 2 RMB per kilogram.

That’s what those mining years really left me: a pair of glasses that lets me hold two things at once — that a thing can be real, useful, even world-changing, and at the same time be inflated by frenzy into an enormous bubble. So “AI is a genuine revolution,” however true, says nothing about whether NVIDIA’s price today makes sense. The truth of a technology and the fate of its price have always run as two separate lines.

The technology line, I can still read a bit. The price line — where it goes from here, I can’t call. I never called coin prices either; I didn’t step off at the top, the power bill pushed me off. Predicting was never my job. Setting down what I saw and what I made of it — that is.

This piece focused on NVIDIA alone. Where the profits actually land when all this money pours into AI — I follow that thread in the next one, The AI Business Through a Crypto Miner’s Eyes.

References

SEC 2022 settlement with NVIDIA for failing to disclose mining’s material impact on gaming revenue ($5.5M): https://www.sec.gov/newsroom/press-releases/2022-79
CNN reporting on the settlement (NVIDIA “omitted material information, was misleading”): https://www.cnn.com/2022/05/06/tech/nvidia-sec-settlement-crypto-mining
Sequoia Capital’s David Cahn, “AI’s $600B Question” (estimating ~$600B annual revenue needed to justify current capex; his Dec 2025 update notes end-user revenue still “tens of billions/year” vs. “trillions in infra investment over five years”): https://www.sequoiacap.com/article/ais-600b-question/
TrendForce data on custom AI chip share erosion vs. general-purpose GPU and shipment growth differential: https://www.spotedcrypto.com/hut-8-cipher-digital-ai-data-center-pivot-2026/
Morgan Stanley comparing this AI capex cycle to the telecom bubble, noting GPU depreciation (2–3 years) vs. fiber (20+ years): https://medium.com/@truthbit.ai/the-2-trillion-question-can-ai-revenue-catch-up-to-capex-df8c5c3c52fb
Ethereum’s Ethash memory-hard anti-ASIC design; BTC ASIC’s orders-of-magnitude advantage over GPUs (Wikipedia): https://en.wikipedia.org/wiki/Ethash
CNBC: NVIDIA’s private equity investments grew from ~$3.39B to ~$22.25B in one year, covering the full AI infrastructure stack including chip customers (analyst: “fits squarely within circular investment theme”; includes IREN 5GW infrastructure deal): https://www.cnbc.com/2026/05/09/nvidia-embraces-ai-investor-topping-40-billion-in-equity-bets-2026.html
Bloomberg: NVIDIA invested another $2B in CoreWeave in Jan 2026 (latest circular financing example): https://www.bloomberg.com/news/articles/2026-01-26/nvidia-invests-another-2-billion-in-coreweave-offers-new-chip
Jensen Huang at Computex 2026: “NVIDIA has truly become an infrastructure company, not just a GPU company,” emphasizing full-stack infrastructure strategy: https://finance.yahoo.com/sectors/technology/articles/nvidia-become-infrastructure-company-jensen-003249580.html

Written in June 2026. All figures are publicly available estimates at the time of writing. Different sources use different methodologies; numbers will change over time. Verify against the latest primary disclosures before citing.

一个加密矿工眼里的英伟达

Sun, 21 Jun 2026 14:20:00 GMT

这两年，看着大家排队抢英伟达的卡，看着 AI 这一波越烧越旺的狂热，我心里总有种熟悉感——这种架势，我以前见过。差不多十年前挖矿那几年，我完整地经历过一遍。

我不想分析英伟达。我只想讲讲挖矿那几年留给我的几样东西，和它们让我用什么样的眼光，去看这家全世界最贵的公司。

声明在前：这只是一份个人观察，不是任何投资建议。

先从我那几台矿机说起，尽量快，它只是个引子。

一个引子：我那几台矿机

2017年 ETH 矿潮最疯的时候，显卡很难抢到——不是贵，是没货，整个国内市场都很稀缺。那时候中国还是全球加密矿工之都，能挖矿的显卡，自然首先在这里被一扫而空。我当时买的那二十多张卡，大部分是英伟达（Nvidia）出的 N 卡，少量 AMD 出的 A 卡。一部分是在国内抢的，还有一部分是专门通过亚马逊海外购从英国淘回来的。分了好几批、断断续续凑齐，最远的一批在海上漂了一个月才到上海。卡凑齐，组装成六卡矿机，架在我家阁楼上，嗡嗡地跑，一台大电扇对着吹，到了夏天还得开空调给它们散热，电费一个月好几千人民币，空调和矿机一起开，有时候家里电路扛不住，还跳过几次闸。

这些麻烦我当时都忍了，因为那段时间确实是蛮赚的。

后来之所以停下来，是因为2018年年底 ETH 的那波大跌。以太坊越来越不值钱，跌到某个点时，挖出来的那点币连电费都不够——矿机这东西跟股票不一样，股票套住了你能捂着等，它不花你钱；矿机每开一天，电费、损耗都在烧，一旦收益盖不住成本，它就从帮你赚钱的资产，变成每天往外淌钱的窟窿。于是我把机器关了。

那二十多张卡，后来一张都没卖掉。玩卡的人都知道矿卡烫手——二十四小时连轴转，显存伤得厉害，没人愿意接。它们就在阁楼上堆着好些年，直到前几年我搬家收拾东西，才当废品处理掉了。从我满世界抢它们，到当废品处理掉，中间隔了差不多七年。

引子讲完了。我之所以啰嗦这一段，是因为当年烧穿我电费的，主要是英伟达的显卡；今天烧着全世界数据中心电费的，还是英伟达的显卡。中间隔了快十年，主角没换，换的只是它身上贴的标签，从“打游戏的卡”变成“做 AI 的卡”。挖矿那几年让我学会了一副眼镜——看任何重资产，都先问几个问题。下面，我就把这几个问题，架到英伟达身上。

它的需求里，有多少是真的？

英伟达今天的财报漂亮得吓人，一个季度比一个季度好看。但财报漂亮和需求真实，从来是两码事——这一点，我是被矿潮教过的。

当年那波抢卡，有多少是真要打游戏的玩家，又有多少是像我一样的矿工？这件事不是我事后瞎猜——英伟达那几年的报表里，有大量营收其实是挖矿撑起来的，却被它算进了游戏业务、当成游戏需求的真实增长。2022 年，美国证监会（SEC）认定它在 2018 财年连续几个季度，没向投资者披露挖矿是游戏营收大涨的“重要原因”，罚款了结；到今天还有一桩集体诉讼在打，指控它把超过十亿美元的挖矿销售藏进了“游戏”营收里。后来矿难一来，这部分需求凭空蒸发，财报当场被打回原形，库存积压，股价腰斩。需求看着无穷无尽，其实掺了一大块会瞬间消失的东西——而当时几乎没人，包括公司自己，愿意把这块单独标出来。

今天的 AI 算力，是同一个局面。这里面有多少是真跑出了能赚钱的应用，又有多少只是“别人都在拼命买，我不买就掉队”的军备竞赛？这两种需求，记在账上看起来一模一样，只有等潮水退了才分得出真假。而眼下一个很难忽视的事实是：整个行业从最终用户那儿真正收上来的钱，一年还只是几百亿美元的量级，可几大巨头砸下去的资本开支，2026 年合起来已经奔着七千亿美元去、2027 年预计破万亿。红杉资本早在 2024 年就算过一笔账：要撑起这么大的投入，这个行业每年得有六千亿美元的营收才说得过去——而它真实赚到的，离这个数还差着十万八千里。中间这个巨大的缺口，靠的正是“AI 会改变世界”这个还没兑现的预期撑着。

通用，是它的护城河，也是它的命门

当年打算挖矿的时候，有朋友就建议我：买显卡保险，ETH 哪天不行了，你还能拿它去挖别的币，实在不行还可以玩游戏。这话听着有道理——通用嘛，此路不通还有彼路。这正是通用性最大的诱惑：它让你觉得自己留了退路。

但矿圈的历史，恰恰是用一种很精细的方式，给这个“退路”划了个边界。

先说比特币。BTC 的算法对专用芯片（ASIC）特别友好，所以 ASIC 一出来，对显卡就是数量级的碾压——同样一度电，专用矿机的算力是显卡的成百上千倍。显卡挖 BTC 当场没了活路，整批整批被赶出场。

可是以太坊不一样。ETH 的算法当初是特意设计成“强制写内存”的，就是为了对抗 ASIC。结果是：后来虽然也出了 ETH 专用矿机，但因为被内存带宽卡着，它相比显卡占不到多少便宜，差距不是数量级的。于是显卡在 ETH 这条路上，还能勉强活着。

这两条线连起来，才是2017年那场 ETH 矿潮真正的来历：正是因为 BTC 那边的显卡矿工被 ASIC 逼得走投无路，才大批迁移到了 ASIC 啃不动的 ETH 上来。换句话说，我当年冲进去的那个避难所，本身就是上一场“专用碾压通用”造成的难民潮。我朋友说的“还能挖别的”，确实救了显卡一命——但那不是因为通用性多可靠，而是因为 ETH 的算法恰好不吃 ASIC 这一套。退路存不存在，从来不是你说了算，是对手的芯片和算法说了算。

而且专用芯片这东西，一旦验证可行，扩散和迭代的速度都快得吓人。某个算法只要被证明 ASIC 做得出来，很快满世界就都是了；起步往往用十几纳米这种便宜成熟的工艺试水，一旦跑通，立刻往更快、更省电的方向猛冲，一代比一代狠。所以“它现在还不够强”从来不是可以安心的理由——它现在弱，恰恰是因为它才刚开始。

现在把这副眼镜架到英伟达身上。

英伟达的卡之所以值钱，就是因为它什么都能算，什么活儿都能接。可这两年 AI 的重心，正从“训练”端往“推理”端移——一个模型训练一次就够了，但训练好之后，要被几亿人每天调用推理无数次。所以训练芯片需求和推理芯片需求这两条曲线的走向并不对称：训练的算力需求，迟早会随着模型越训越大、训练频率趋于稳定而见顶；但推理不一样，它是跟着用户数走的——用户越多、调用越频繁，这条曲线就没有上限。所以推理迟早会反超训练，变成 AI 算力真正的大头。

推理这件事量大、重复、算法固定，恰恰是专用芯片最擅长、通用 GPU（也就是英伟达卖的这种通用显卡）最吃亏的场景。于是谷歌的 TPU、亚马逊、微软、Meta，英伟达自己最大的那几个客户，现在都在埋头造专门跑推理的芯片。

英伟达眼下还占着整个 AI 芯片市场的八九成——但这个“八九成”里有个容易被忽略的结构：训练这块它超过九成，推理这块本来就只有六七成。据多家机构的预测，随着定制芯片放量，它的整体份额可能在两三年内从九成上下降到七成左右，被切走的，主要就是其中的推理那块。定制芯片今年的出货增速，已经是通用 GPU 的近三倍。连英伟达自己都急了——它最近花了两百亿美元，把专做高速推理芯片的 Groq 的技术和团队收进门，这本身就说明，它最肥的那块地，正被人惦记着。

所以真正的问题，不是英伟达通不通用，而是：AI 推理这件事，到底更像 BTC，还是更像 ETH？是专用芯片能数量级碾压它、把英伟达赶出最肥那块地，还是有什么特性能让通用 GPU 守得住一阵？我暂时不知道答案。但我知道，今天所有的趋势，都指向专用芯片在飞快地逼近推理——而英伟达被寄予最高期待的那部分未来，恰恰就压在推理上。

卖铲人，也下场挖金

矿圈有一种生意我熟——做矿机的厂商，大多自己也挖矿。一边卖矿机赚钱，一边自己建矿场，两头的钱都要。而且他们挖起来比外人有优势：机器是自己造的，成本比谁都低；新一代芯片一流片，自己先开机挖一拨，吃透了这一代的利润，才把“旧”型号拿出去卖给外面的矿工。所以同样挖矿，矿机厂商的效率，外面买全价机器的人压根比不了——不是同台竞争，是降维打击。

英伟达现在干的，是同一个剧本，只是规模、复杂程度，都不是当年那些矿机生意能比的。

它手里那些非上市公司的股权投资，一年前大概三十多亿美元，到今年初已经涨到两百多亿——涨了六倍还多。这些钱砸向 AI 基础设施产业链上下游，其中相当一部分，投给了那些买它芯片、或者通过云服务商间接买它芯片的公司。说白了：英伟达出钱，让这些公司有钱买它的卡，这些公司买完卡把算力租出去赚钱、还钱、估值上涨，英伟达手里的股权也跟着升值——钱转了一圈，又绕回它自己口袋。有分析师看得很直白，说这类交易“完全是循环投资那一套”。黄仁勋自己也不藏着了，今年的一次大会上他直说，英伟达“已经真正成为一家基础设施公司，不只是 GPU 公司”——它要的，是把网络、算力、软件、数据中心整条链都握在手里。

而且它投资的那些数据中心公司，跟当年自己挖矿的矿机厂商一样占着便宜：排在供货队伍最前面，用的是最新一代的卡，而定价权和产能怎么分，又攥在英伟达自己手里。卖铲子的人，不只是也想挖金子——它挖起金子来，比谁都有优势。

但优势的另一面，是风险。这套玩法，从头到尾都架在杠杆上。矿机厂商当年建矿场，也是这样，在内蒙、云贵川、新疆这些电力便宜的地方找当地合作方，他们出矿机，合作方搞定关系、场地、电力、网络、散热等等。疯狂的时候，不少人是拿手上有的BTC甚至未来的BTC，去抵押贷款。英伟达这次也是：它掏出去的那笔投资，撬动的是下游公司借来的、靠未来合同抵押的债务。加上杠杆，这盘子越玩越大。

行情往上的时候，杠杆会让它赢得格外漂亮，卖卡赚一道、投资升值再赚一道；可双刃剑的另一刃也一直在——一旦那些动辄几十亿的算力合同没法如期兑现，链条会从下往上传导，先是借债的公司还不上，然后是它账上那两百多亿的股权投资跟着缩水。好的时候杠杆是赚钱的放大器，反过来的时候，它也是催命的放大器。

老玩家，新牌桌

如果说前面这些还只是“形状相似”，那有一件事，是连人都没换的。

这两年，整个加密挖矿行业，几乎是集体改旗易帜，转去做 AI 数据中心了。Core Scientific、IREN、TeraWulf、Hut 8、Riot……这一长串名字，都是当年挖矿的老面孔。上市矿企在 2026 年一季度卖掉了创纪录的三万多枚比特币，比 2022 年那轮崩盘时卖得还狠——把曾经死攥着的核心资产变卖掉，就为了凑钱扑进 AI。Hut 8 在财报会上直接说，比特币已经不再是公司的“长期战略重点”了。

但你要是细看他们转身的姿势，会发现这批人不全是被挖矿赶出来的。有相当一批是早早看准了、主动走的——趁币价还高就清仓转身，赌 AI 比挖矿值钱；而他们这一抛币离场，反过来又把币价往下压，把后面硬撑的挤成了亏本割肉、不得不逃的人。先走的人精明，后走的人狼狈，但都挤上了同一张新牌桌。

这股“哪儿热就往哪儿扑”的劲，我太熟了。每一场热潮的人力，都来自上一场热潮的退潮——这一次，退的是挖矿，涨的是 AI。牌桌是新的，玩家是旧的，连他们扑过来的那股劲，也是旧的。

而绕了一圈，这些换了招牌的老玩家，又回到了英伟达跟前。前面说的那盘循环投资里，英伟达掏钱投的那些数据中心公司，名单上就有它们的名字——IREN 这些，本就是从矿场转过来的。英伟达一边卖卡给它们，一边投钱让它们买更多卡，而它们，又是一群刚从上一个滩头转过来、追着潮水跑的老面孔。这条链子的每一环，都透着同一股似曾相识的热——是一群熟悉的人，又一次扑向了最热的地方。

一副眼镜

说了这么多，我得讲清楚一件事，免得被误会：我不是在唱衰 AI。

恰恰相反，我相信 AI 是这一代人会赶上的、和工业革命同级别的变革，叫它信息革命也不为过。但这跟我前面说的那些，是两回事。

2001年互联网泡沫破的时候，没有谁能说互联网没用——Email 那时候就在用，今天还在用，一天都没停过。互联网千真万确地改变了世界，可那一点都没妨碍那年的纳斯达克崩掉，没妨碍一大批公司归零。技术真到不能再真，泡沫照样破。

那场泡沫里，有一家公司的故事，今天读起来格外像一面镜子——思科。它当年是卖“网络管道”的：路由器、交换机，整个互联网的骨架都得用它的设备。那时候的叙事，和今天一字不差：互联网谁输谁赢说不准，但所有人都得买思科。于是它成了全世界市值最高的公司，市盈率冲到两百多倍。结果泡沫一破，它股价跌掉了将近九成。注意，思科不是骗子公司，它没倒、一直在盈利、网络设备直到今天还是刚需——可即便这样一家真材实料的公司，它的股价也用了整整二十五年，才重新爬回 2000 年那个顶。也就是说，哪怕你看准了“互联网会改变世界”、还押中了那个最硬的卖铲人，只要买在了狂热的价格上，你也得等四分之一个世纪才能解套。

把“思科”换成“英伟达”，这句话几乎可以原封不动地再讲一遍。它们站在同一个生态位上——上一轮卖网络管道的，这一轮卖算力；同样是“谁赢不知道、反正都得买它”的那一个；同样被捧成全世界最贵的公司。我无意说英伟达就是下一个思科，历史不会简单地重复。我只是想说：思科这面镜子告诉我们，技术是真的、公司是好的、东西是刚需的——这三件事加起来，依然挡不住一个被狂热定出来的价格，慢慢花二十几年还债。

有人会说，那场泡沫好歹留下了铺到地下的光纤，后来都用上了，所以是“好泡沫”。这话有道理，但放到今天未必成立。连摩根士丹利都点出过这里的差别：当年的光纤能用二十年，今天的 GPU 两三年就废。光纤泡沫破了，管子还埋在地里等下一波；可这些卡要是没在寿命里把本赚回来，它退场时不会给谁留下什么——就像我那些矿卡，最后是当废品处理的，2元人民币一斤。

这就是挖矿那几年，留给我的那副眼镜：一样东西，可以既是真的、有用的、甚至改变世界的，又同时被狂热抬成了一个巨大的泡沫。所以“AI 是真变革”这句话，无论多正确，都证明不了英伟达今天的价格是合理的——技术的真伪，和价格的死活，本就是两条各走各的线。

技术那条线，我多少还能看出点门道；价格这条线接下来怎么走，我预测不了——当年的币价我自己也没看准过，我不是踩着顶离的场，是被电费赶下场的。我能做的不是预测，只是把我见到和想到的，记录下来。

这篇讲的是英伟达这一家公司。至于这么多钱砸进 AI，利润最后能落在哪儿，我在下一篇《一个加密矿工眼里的 AI 生意》里接着往下推。

参考资料

美国证监会（SEC）2022 年对英伟达未充分披露挖矿对游戏业务营收影响的处罚公告（550 万美元和解）： https://www.sec.gov/newsroom/press-releases/2022-79
CNN 对该处罚的报道（英伟达“遗漏重大信息、具有误导性”）： https://www.cnn.com/2022/05/06/tech/nvidia-sec-settlement-crypto-mining
红杉资本 David Cahn《AI’s $600B Question》原文（撑起当前资本开支约需 6000 亿美元年营收的测算；其 2025 年 12 月展望进一步指出终端营收仍在“每年几百亿”量级、而基建投资“未来五年以万亿计”）： https://www.sequoiacap.com/article/ais-600b-question/
TrendForce 关于定制 AI 芯片对通用 GPU 的份额侵蚀与出货增速差的数据（多方转述）： https://www.spotedcrypto.com/hut-8-cipher-digital-ai-data-center-pivot-2026/
摩根士丹利把这轮 AI 资本开支狂热类比电信泡沫、并指出 GPU 一两三年折旧 vs 光纤 20 年以上寿命这一关键差别（Fortune 报道，转述于此）： https://medium.com/@truthbit.ai/the-2-trillion-question-can-ai-revenue-catch-up-to-capex-df8c5c3c52fb
以太坊 Ethash 的 memory-hard 抗 ASIC 设计、BTC ASIC 对 GPU 的数量级碾压等公开技术资料（维基百科 Ethash 词条等）： https://en.wikipedia.org/wiki/Ethash
CNBC：英伟达持有的非上市公司股权投资一年内从约 33.9 亿美元涨至约 222.5 亿美元，资金覆盖 AI 基础设施全产业链、包括购买其芯片的客户（分析师称“完全符合循环投资主题”，含 IREN 五吉瓦基础设施协议）： https://www.cnbc.com/2026/05/09/nvidia-embraces-ai-investor-topping-40-billion-in-equity-bets-2026.html
彭博社：英伟达 2026 年 1 月再向 CoreWeave 追加投资 20 亿美元（循环融资交易的最新一例）： https://www.bloomberg.com/news/articles/2026-01-26/nvidia-invests-another-2-billion-in-coreweave-offers-new-chip
黄仁勋在 2026 年 Computex 大会上称“英伟达已真正成为一家基础设施公司，不只是 GPU 公司”，强调策略转向全栈基础设施： https://finance.yahoo.com/sectors/technology/articles/nvidia-become-infrastructure-company-jensen-003249580.html

本文写作时点为 2026 年 6 月，文中数据为当时能查到的公开估算，不同口径与来源之间存在差异，且会随时间变化，引用前请以最新一手披露为准。

Writing and Code: Same Leverage, Different Story

Fri, 19 Jun 2026 10:30:00 GMT

Naval Ravikant said it in The Almanack of Naval Ravikant: “Fortunes require leverage.” The modern divide isn’t between the rich and the poor. It’s between people who use leverage and people who don’t.

He broke leverage into four types: labor, capital, code, and media. Of these, he singled out code and media as the only two forms of permissionless leverage — the only two that don’t require anyone’s permission to use. Labor needs people willing to work for you. Capital needs you to already have money, or someone willing to give you theirs. But code and media? One person, one laptop. Once it’s built, it works for you while you sleep.

Naval’s “media” covers writing, podcasts, video — all of it. But today I want to focus on just one slice: writing, and how it compares to code as a form of leverage.

I largely agree with Naval’s framework, especially on code. I’ve made my living writing code for a long time now. I understand code leverage well: build something once, copy it at near-zero marginal cost. With web-based software, you don’t even need to distribute — people open a browser and it’s there. Software has direct utility, too. Plenty of people rarely read, but everyone uses software every day: WhatsApp, TikTok, Apple Pay, Amazon. From that angle, code has broader reach — users don’t need to want to read, they just need to use.

But lately I’ve been rethinking the comparison. The more I look at it, the more I think that as two forms of permissionless leverage, writing and code are far more different than they first appear.

What Writing Can Do

First, the nature of influence is different.

Code is a tool. A user opens an app, completes a task, closes it. Who coded it doesn’t matter. The user doesn’t know, doesn’t care, doesn’t need to. Code’s influence is functional — it changes what you can do, but it rarely changes how you think.

Writing is different. A good piece of writing demands reading, sometimes re-reading. It requires understanding, internalization. Writing enters the reader’s mind. It changes how they think.

A good essay might shift how you see something. It might open a window during a moment of confusion. It might make you smile in recognition: “Someone else thinks the way I do.” That kind of influence is cognitive. It’s a real connection between writer and reader.

A software user finishes and moves on. A reader sometimes carries an essay for life.

Second, the independence of distribution is different.

Code must live inside a complete runtime environment — operating system, dependencies, servers, databases. It can’t exist on its own. It needs infrastructure to run. That means code distribution has a high barrier: users need to install, configure, learn, sometimes need specific hardware and systems. This is partly why many developers prefer building standalone apps over web services — fewer dependencies.

Writing is different. An essay is a complete, self-contained unit. One article, one link — it can go anywhere, and anyone who opens it can read it. No screen? Print it out. Carry it in your pocket. It doesn’t need a runtime, an installation, an account, or a manual. That lightness is something code rarely achieves. Naval’s “works for you while you sleep” is purer with writing — it truly exists independently, with no preconditions.

Third, the shelf life is different.

Technology iterates fast. Code written ten years ago often can’t run today — not because anything is wrong with the code itself, but because the environment changed. The things it depends on moved too fast. I’ve seen plenty of projects like this: the code is fine, but a single deprecated dependency kills the whole system. Software has a peculiar kind of rot. It doesn’t change, but the world around it does, and that’s enough to break it.

Writing ages differently. An essay can become outdated — the data, the references, the specific context it discusses may all expire over time. But it doesn’t “break.” An essay you wrote twenty years ago still opens, still reads, still looks the same. No one needs to maintain it for it to continue existing. And the best writing doesn’t go stale at all — explorations of worldview, ways of thinking, observations about the human condition. These sometimes hit harder decades or centuries later, strengthened by the weight of time.

Paul Graham is a good example. Few people remember the software he wrote in the early days. But the essays he wrote in the same period — on startups, on thinking, on programming languages — are still circulating, still cited, still shaping each new generation of founders and engineers.

The half-life of an essay’s influence is something most software products can’t match.

Writing as a Durable Asset

Once an essay is finished, it’s a complete product.

That sounds simple, but think about it — software rarely works this way. Launching an app isn’t the end. It’s just the beginning. Then comes user feedback, bug fixes, feature iterations, version upgrades, security patches. The developer is tied to the product. As long as the product lives, the developer has to keep up. In a real sense, this is a hidden long-term liability.

Writing doesn’t have this problem. Publish it, and it’s done. Readers might comment. You can respond or not. The essay itself doesn’t need your continued investment to continue existing. That “ship it and it’s done” cleanliness is an outright luxury in software development.

There’s another difference. When a user uses an app, they experience the product, not the person. But when someone reads an essay, they experience the writer — how they think, what they’ve seen, where they’ve been. The author’s voice, judgment, even personality live in the words. Writing is a bridge between reader and writer. It builds something code never can: a relationship between people, not just between a person and a tool.

Finally, there’s the meaning of recording.

I once wrote on my About page: what isn’t recorded ceases to exist. In the context of code versus writing, that line takes on a specific meaning.

Code records functionality — a solution to a problem. It’s useful, but it captures “how it was done,” not “who I am.” Writing records the person — my judgment at a particular point in time, the path I walked, what I saw, how I thought, my doubts and realizations. Over time, this accumulates into an archive that belongs only to you. Your own history.

AI Is Changing the Comparison

One more thing has been shifting in the last couple of years: the impact of AI.

AI’s ability to write code is improving fast. Describe a feature clearly, and AI builds it — faster, better, every month. Code as leverage is becoming less scarce. That doesn’t mean code is unimportant. It means “being able to write code,” as a personal competitive edge, is diluting. When AI can produce code faster and better than most of us, where does my leverage as a coder come from?

Writing is different. AI writing capabilities are also advancing rapidly, but there’s a fundamental distinction: AI-generated writing can be mass-produced, but it has no real experience, no authentic voice, no perspective that belongs to one specific person. AI can produce fluent, well-structured articles. But it can’t write “It started around 1999, writing weekly columns on internet marketing for a newspaper. I remember always procrastinating until the last minute” — or capture the texture behind that kind of detail.

In an era flooded with AI-generated content, writing with real experience and an authentic voice is becoming scarcer. Which means it’s becoming more valuable.

That’s roughly everything I can think of right now about how code and writing differ as leverage. I’ve been emphasizing writing’s strengths here, mostly because I come from the code side — I’ve written code for a living for years, and while I’ve occasionally jotted things down along the way, I’d never really stopped to think about how these two forms of leverage actually compare. This is a small summary of that recent reflection.

One thing I want to emphasize: code and writing are absolutely the two forms of permissionless leverage of our era. Whenever possible, we should make full use of both.

And to my fellow developers: whenever you get the chance, write things down. Because one day you’ll realize that your essays outlasted your code.

Notes

Thanks to everyone who read and left a comment — you’ve kept this piece growing. I’ll record some of the discussion that followed here.

2026-06-19, from V2EX user canyue7897 (comment)

He raised an angle I hadn’t considered. With code, he pointed out, you just need the interface defined — whatever happens inside, even if the AI produces garbage, it’ll probably still run. The compiler has your back. Writing has no such safety net. It demands logical coherence from start to finish, and the moment it breaks down or drifts off course, a reader can see it instantly.

That got me to a more fundamental difference. Code chases correctness. It converges — give the same function to a hundred people and they’ll write roughly the same thing, all drifting toward the same optimal solution. So code can be “correct without personality.”

Writing chases the opposite. It diverges — give the same topic to a hundred people and you get a hundred different pieces. The personality and the logic are the value. Strip them out and nothing’s left.

He made another point that hit home: a bad essay, you can spot in a glance. Bad code, as long as it runs, can fake its way through for now. A bad essay can’t — the moment the logic rings hollow or the feeling rings false, the reader feels it. Writing can’t hide how much thought went into it. It can’t bluff.

Code can fall back on being correct without personality. Writing can’t. Which is probably why AI keeps getting smoother at mass-producing code, while writing with a real human behind it only gets harder for AI to replace.

同样是杠杆，文章和代码不一样

Fri, 19 Jun 2026 10:00:00 GMT

硅谷天使投资人 Naval Ravikant 在他的《纳瓦尔宝典》中说：“财富需要杠杆”。现代社会的二分法已不再是穷人与富人，而是“利用杠杆的人”和“没有利用杠杆的人”。

他进一步将杠杆分为四种核心类型，分别是：劳动力、资本、代码Code、媒体Media。在这中间，纳瓦尔尤其强调代码和媒体是新时代富人的杠杆，它们是这个时代仅有的两种不需要任何人许可的杠杆。劳动力需要有人愿意为你工作，资本需要你先有钱或者有人愿意把钱给你，但代码和媒体不需要——你一个人，一台电脑就可以。一旦完成，睡着了它们还在为你工作。

纳瓦尔说的媒体包括了文字、播客、视频等等，但是我今天只想聊聊其中的文字——写文章这件事，以及它和代码相比，究竟有什么样的不同。

对于纳瓦尔的总结，我很认同，尤其关于代码这一块，因为直到现在，很长一段时间我都是以写代码为生。对代码的杠杆作用，我很了解：把一个软件写好，可以无限低成本的复制，边际成本趋近于零，尤其是现在基于网络的很多软件，写好部署好，人们有浏览器就能访问，复制这一环也不需要了。同时，软件是有直接的实用价值的。很多人很少阅读，但这个时代他每天也得用软件：看微信、刷抖音、付款、网上买东西……。从这个角度看，代码的触达面要更广——用户不需要有阅读的意愿，只需要有使用的需求。

但我最近开始重新思考这两件事：写代码和写文章，我越来越觉得，同样作为无需许可的杠杆，它们之间也有很大的差别。

文章能做到什么

首先是影响力不同。

代码是工具。当用户打开一个App，完成一个任务，然后关掉。这个App究竟是谁写的，其实不重要，用户不会知道，不想知道，也不需要知道。代码的影响是功能性的——它改变了你能做什么，但很少直接改变你怎么想。

但是文章就不一样。一篇好的文章需要读、有时候人们甚至会反复阅读，文章需要理解、需要转化成自己的东西，也就是说：文章是要进到读者的脑子里的，它会改变你的想法。

一篇好文章，它可能会改变你看待一件事的角度，可能为你在某个困惑的时刻打开一扇窗，也可能会引发你的会心一笑：“原来有人和我想的一样”。这种影响是认知性的，是作者和读者之间真实发生的一次连接。

程序的用户用完就完了，但是文章的读者有时候会记住一辈子。

其次是传播的独立性不同。

代码必须活在一个完整的运行环境里——操作系统、依赖库，甚至服务器、数据库等等。它不能独立存在，必须依附于一定的基础设施才能运行。这就意味着，代码的传播其实有很高的门槛：用户需要安装、配置、学习，甚至需要特定的设备和系统。这也是很多软件开发者相对于网站、云服务，更喜欢开发独立App的原因之一：因为独立App依赖相对要少。

但是文章不同，它本身就是完整的独立单元。一篇文章，一个链接，就可以传到任何地方，任何人打开就能读。实在没有屏幕，你还可以把它打印下来，一张纸带在身边随时阅读。它不依赖运行环境，不需要安装，不需要账号，不需要解释怎么用。这种轻盈，是代码很难有的。Naval说的“睡着了还在为你工作”，在文章这里体现得更纯粹——它真的就是一个独立存在的东西，不需要任何附加条件。

第三，代码和文章的保鲜期不同。

技术在加速迭代。十年前写的代码，很多现在已经跑不起来了——不是代码有什么问题，而是环境变了，它依赖的东西变得太快了。我见过很多这样的项目：代码本身没有问题，只因为某个依赖库停止维护，整个系统就废了。软件有一种特别的腐烂方式，它本身没变，但是周围世界的变化会让它败坏。

文章的老化方式则完全不同。一篇文章可能会过时——里面的数据、引用的背景、讨论的具体场景，都可能随时间失效。但它不会“坏掉”。你二十年前写的一篇文章，今天打开还是能读，还是原来的样子，不需要任何人去维护它继续存在。而好的文章甚至根本不会过时——关于世界观、人生观、价值观的探讨、关于思考方式、关于某种处境的观察，有时候几十年、几百年、几千年后读起来，因为时间的沉淀，甚至比当时还更有力量。

Paul Graham就是个很好的例子。他早年写过的很多软件，估计现在很少人还知道、还记得。但同时期他写的文章——关于创业、关于思考、关于语言——至今还在互联网上流传，还在被引用，还在影响每一代新的创业者和工程师。

文章这种影响力的半衰期，是大多数软件产品给不了的。

文章作为资产的稳健性

文章一旦写完，就成为一件完整的产品。

这一点听起来简单，但仔细想想，软件产品很少能做到这一点。一个App上线并不是结束，而只是刚开始——接下来是用户反馈、bug修复、功能迭代、版本升级、安全更新……开发者被产品绑住，一天这个产品还活着，开发者就得跟着活。在某种意义上说，这是一种隐性的长期负债。

但是文章就没有这个问题。写完发出去，它就在那里了。读者可能有评论，你可以选择回应，也可以不回应。文章本身不需要你继续投入才能继续存在。这种“写完即交付”的干净和省心感，在软件开发里是妥妥的奢侈品！

再一个，用户用一个App时，他感受到的只是这个产品，不是人。但读一篇文章，感受到的是这个人怎么想、怎么看、走过了什么——作者的声音、判断、甚至性格，都在文字里。文章是读者和作者交流的一座桥梁。这让文章有一种代码永远没有的东西：它建立的是人与人之间的关系，不只是人与工具之间的关系。

最后是记录的意义。

我在网站介绍里曾写过：没有记录，就不曾存在。这句话放在代码和文章的比较里，有一层很具体的含义。

代码记录的是功能，是某个问题的解决方案。它是有用的，但它记录的是“怎么做到的”，而不是“我这个人”。文章记录的是人——我在某个时间点的判断，我走过的路，我看到的东西，我思考的方式，我的疑惑和感悟。这种记录，随着时间的积累，会变成一份只属于你的档案，属于你的历史。

AI时代，两者的对比在变化

还有一件事，是这两年开始改变的，就是 AI 发展带来的影响。

AI 写代码的能力，正在快速提升。一个功能，你描述清楚，AI帮你实现，而且越来越快、越来越好。代码这种杠杆，它的稀缺性在下降——不是说代码不重要了，而是“会写代码”这件事本身，作为个人优势的含金量在稀释。当 AI 可以更快写出超过我们水平的代码时，我作为一个写代码的人，杠杆在哪里？

但是文章这边则不同，虽然 AI 的写作能力也在大幅增强，但这里有一个根本的区别：AI 写的文章，可以批量生产，但它没有真实的经历，没有真实的声音，没有只属于某一个人的视角。AI 可以写出流畅的、结构清晰的文章，但它写不出“当时还是 99 年前后，主要是报社约稿，每周一篇。我记得经常都拖到最后一刻，时间快到了，我才动笔。“这样的细节，也写不出这种细节背后那种具体的质感。

在 AI 内容大量涌入的今天，有真实经历、真实声音的文章，反而变得更稀缺了。也就是说，这样的文章将会更有价值。

好了，关于代码和文章之间的差别，大致我能想到的，目前就这么多。这里我强调的都是文章的优势，主要是因为我本身是写代码的，一直以来虽然也偶尔写点文章记录一下，但是并没有仔细思考过：同样是杠杆，代码和文章有什么不同？这也是我这段时间反思的一个小小总结吧。

最后我想再强调一下，代码和写作，绝对是我们这个时代的两种permissionless leverage，在可能的情况下，我们应该尽量充分地利用它们。

同时，如果你和我一样，也是开发人员，那么我强烈的建议你，尽量多的去记录和写作，因为未来某一天你会发现：这些文章会比你的代码留得更久。

补记

感谢朋友们的阅读和留言，让这篇文章继续生长。文章发出后引发的讨论，我会记录在这里。

2026-06-19，来自 V2EX 网友 canyue7897 的评论

他提了一个我没想到的角度。他说，代码只要接口定好，里面怎么写都行，就算 AI 拉一坨屎，大概率也能跑起来，有编译器兜底。文章没有这个兜底：它要求上下文的逻辑连贯，一旦写崩、写偏，人一眼就能看出来。

这让我想到一层更根本的差别。代码追求的是正确，是收敛的——同一个功能，大家写出来大同小异，最优解趋同，所以它可以“没有个性地正确”。

而文章追求的是独特，是发散的——同一个题目，一百个人能写出一百样，个性和逻辑本身就是价值，缺了就不成立。

他还有一句也戳中要害：烂文章，人一眼就能看出来。

代码烂，只要能跑，当下还能先糊弄过去；文章烂，逻辑一虚、真情实感一假，读者立刻就有感觉。文章藏不住作者的思考含量，糊弄不了人。

代码可以无个性地兜底，文章不能。这大概也是为什么，AI 量产代码会越来越顺，而真正有人味的文章，反而越来越难被 AI 替代。

AI Is Killing Jobs — and Creating New Ones

Tue, 16 Jun 2026 20:30:00 GMT

Over the past two years, layoff headlines from Big Tech have been relentless. Meta, Google, Amazon — the reason is always the same: AI. But while AI is eliminating jobs, it’s also generating demand for entirely new roles.

It’s not just coders. Copywriters, translators, image editors, audio engineers, video producers — any information-processing job that can be broken into clear steps is getting automated fast.

The flip side: AI lets one person do the work of an entire team, and that’s causing demand for information products to explode. A promo video that used to take a month now ships in a week — three of them. Output goes up, demand follows. The result is that people who can actually use AI are in short supply.

The shift isn’t “jobs are disappearing.” It’s “jobs are changing shape.” New roles aren’t organized by skill — writer, designer, editor — they’re organized by problem. Can you use AI to take this thing from start to finish?

A few days ago I got an alumni email from Per Scholas about a program called Claude Corps. It caught my attention — this is exactly what these new roles look like in practice.

What Is Claude Corps?

A 12-month, fully paid fellowship that places young people inside nonprofits across the US for a year, helping these organizations actually adopt AI.

The program is backed by Anthropic — the company behind Claude — with $150 million in funding. On the same day the program launched, Anthropic CEO Dario Amodei published Policy on the AI Exponential, acknowledging that AI could cause mass job displacement and calling for AI companies to be taxed to fund universal basic income. Acknowledging the problem and investing real money to create new opportunities at the same time — that’s an interesting combination.

Three organizations run it together: Anthropic provides funding and technology, CodePath (a nonprofit focused on tech education) handles recruiting, training, and employment, and Social Finance manages the program.

The compensation is solid: $85,000/year, full medical, dental, and vision insurance, 401(k), paid time off, and up to $2,500 in Claude API credits. These are full-time employees, not interns.

Who Can Apply?

18 or older
Less than two years of full-time work experience (hard requirement)
US work authorization (no visa sponsorship; F-1 OPT does not qualify)
Already using AI tools day-to-day
Has taken real action for a community or cause
Willing to relocate as needed (relocation assistance provided)

The key point: no coding background required, no college degree required. They’re looking for young people who actually use AI, learn fast, communicate well, and care about social issues.

What Do You Do? What Do You Learn?

Fellows work full-time inside nonprofits for a year, across areas like education, public health, refugee services, food security, community development, and environmental protection. The specific project depends on the organization, but the core mission is the same: use AI to solve real problems — building automation workflows, developing internal tools, creating data dashboards, and helping staff understand and adopt AI.

In short, it’s a joint training program where Anthropic funds and supports young people working on real projects inside real organizations.

Training starts before day one: applicants complete two Anthropic online courses (AI Fluency + Claude 101). The first week is an in-person bootcamp in San Francisco. Throughout the fellowship, there’s about five hours of structured training per week. Fellows have an Anthropic technical contact and a CodePath mentor the entire time.

After a year, you walk away with: hands-on AI project experience, a deliverable you owned end-to-end, Anthropic’s name on your resume, and a nationwide network of fellow alumni.

Application Process

Submit an online application with two short-answer questions
Complete two Anthropic online courses (AI Fluency + Claude 101)
After passing initial review, complete a take-home skills assessment
25-minute team interview
Two final-round interviews
Interview with 2–3 host organizations for mutual matching

Timeline and Locations

Cohort 1 plans to enroll about 100 fellows, starting October 19, 2026. Application deadline: July 17, 2026. The full program will run three cohorts totaling 1,000 fellows, with subsequent cohorts starting in January and August 2027.

Confirmed host organizations span the country: Chicago (Braven), New York (International Rescue Committee), Oakland (Code for America), Boston (Year Up United), and more. Cohort 1 is fully in-person. Later cohorts will offer hybrid and remote options.

Apply here: https://www.anthropic.com/claude-corps

Other Opportunities Like This

Claude Corps isn’t an isolated case. The AI era is producing more programs like it:

Bolder Futures Fellowship: Sponsored by Micron. Fully remote, 12 weeks, paid. Apply AI skills to nonprofit projects. Deadline: June 30, 2026. Learn more
Anthropic Fellows Program: Anthropic’s own 4-month, fully funded research fellowship focused on AI safety, governance, and ML research. For applicants with a research background. Rolling admissions. Learn more
Cambridge ERA:AI Research Fellowship: Based in Cambridge, UK. 10 weeks, fully funded (including housing and meals). Focused on AI safety and governance research. Starts July 6, 2026. Learn more

AI is replacing some jobs, but it’s also creating new demand. People who can put AI to real use will only become more valuable in the years ahead. Claude Corps is a structured starting point with real support and real projects — opportunities like this are rare.

If you qualify, give it a serious look.

Keep learning AI, keep using it on real work — more opportunities like this are coming.

AI浪潮正在创造新职位

Tue, 16 Jun 2026 19:02:00 GMT

最近两年，科技大厂的裁员新闻一条接一条——Meta、Google、Amazon……原因大家都知道：AI来了。但AI带走一些工作的同时，也在催生新的需求。

被淘汰的不只是写代码的。文案、翻译、图片处理、音频剪辑、视频制作——凡是能被拆解成明确步骤的信息处理工作，AI都在快速接管。

但硬币的另一面是：AI让一个人能干过去一个团队的活，企业对信息产品的需求反而在爆发。以前做一条宣传视频要一个月，现在一周就能出三条。产能上去了，需求跟着涨，结果是会用AI的人供不应求。

关键变化不是“工作消失了”，而是“工作换了形态”。新岗位不再按技能分（写手、设计师、剪辑师），而是按问题分——你能不能用AI把这件事从头到尾搞定。

前几天我收到Per Scholas的校友邮件，介绍了一个叫Claude Corps的项目。看完觉得很有意思——这正是这种新型职位的一个缩影，值得写出来让更多人知道。

Claude Corps是什么？

Claude Corps是一个为期12个月的全额带薪学徒项目（fellowship）——把年轻人送进美国各地的非营利组织工作一年，帮这些机构真正用上AI。

项目由Anthropic发起——对，就是做Claude的那家公司——并投入1.5亿美元支持。有意思的是，项目发布的同一天，Anthropic CEO Dario Amodei也在官网发表了一篇文章《Policy on the AI Exponential》，坦承AI技术可能导致大规模失业，并呼吁对AI公司征税以支持普遍基本收入。一边承认问题，一边真金白银地投入创造新机会——这个组合挺耐人寻味的。

项目由三方联合运营：Anthropic出钱出技术，CodePath（一家专注技术教育的非营利机构）负责招募、培训和雇用，Social Finance负责项目管理。

待遇很不错：年薪$85,000，全额医疗、牙科、视力保险，401(k)，带薪假期，还有最高$2,500的Claude API额度。是正式全职员工，不是实习生。

谁能申请？

18岁以上
全职工作经验不足两年（硬条件）
有美国工作授权（不提供签证担保，F-1 OPT不符合）
日常已在使用AI工具
曾为某个社区或问题采取过实际行动
愿意根据需要搬迁（提供搬迁补助）

关键一点：不需要编程背景，不需要大学文凭。他们要的是真的在用AI、学得快、能沟通、关注社会议题的年轻人。

做什么，学什么？

学徒们在非营利组织内部全职工作一年，涉及领域包括教育、公共卫生、难民服务、食品安全、社区发展、环境保护等。具体项目因组织而异，核心是用AI解决真实问题——搭建自动化流程、开发内部工具、创建数据看板，帮助员工真正理解和使用AI。

简单说，这是一个由Anthropic出钱、提供技术支持，让年轻人在真实项目中实战的联合培养计划。

培训方面：申请时就要完成两个Anthropic在线课程（AI Fluency + Claude 101）；入职第一周在旧金山集训；fellowship期间每周约五小时结构化培训，贯穿全年。全程有Anthropic技术联系人和CodePath导师支持。

一年后你将带走：真实的AI项目经验、一个从头到尾自己负责的交付成果、Anthropic的背书，以及一个遍布全美的fellow网络。

申请流程

在线填写申请表，包含两道简答题
完成两个Anthropic在线课程（AI Fluency + Claude 101）
通过初审后，完成一份带回家的技能评估
25分钟团队面试
两轮终面
与2-3个host组织面试，双向匹配确认去处

时间和地点

第一批（Cohort 1）计划招募约100人，2026年10月19日开始，申请截止2026年7月17日。整个项目三批共1000人，后续批次分别于2027年1月和8月启动。

目前确认的host组织遍布全美，包括芝加哥（Braven）、纽约（国际救援委员会）、奥克兰（Code for America）、波士顿（Year Up United）等。第一批全部线下，后续批次将有混合和远程选项。

申请链接：https://www.anthropic.com/claude-corps

还有哪些类似机会？

Claude Corps不是孤例，AI时代正在催生越来越多这类项目：

Bolder Futures Fellowship：Micron赞助，完全远程，12周带薪，将AI技能应用于非营利项目，申请截止2026年6月30日。了解更多
Anthropic Fellows Program：Anthropic自己的4个月全额资助研究fellowship，聚焦AI安全、治理和机器学习研究，面向有研究背景的申请者，滚动招募。了解更多
Cambridge ERA:AI Research Fellowship：英国剑桥，10周，全额资助（含住宿餐饮），专注AI安全与治理研究，2026年7月6日开始。了解更多

AI在取代一些工作，但也在创造新的需求。能把AI真正用到实处的人，未来几年只会越来越值钱。Claude Corps是一个有结构、有支持、有真实项目的起点，这样的机会不多见。

如果你符合条件，认真考虑一下。

不断学习AI、在真实项目中用起来——相信未来会有越来越多类似的机会。

From Smart Cards to AI Agents: Why I Built ASys

Sun, 07 Jun 2026 23:23:00 GMT

ASys (Agentic System Interface) is an open-source system interface protocol designed specifically for AI Agents — binary instructions instead of text commands, persistent connections instead of per-request handshakes, instruction-level permissions instead of broad session-level access. This is where it came from and why it’s built the way it is.

Last year, using Claude to help write code felt like working with an intern with terrible memory. Context would drift as conversations grew longer. Restarting a session meant spending several rounds just getting back to where we were. Interfaces we’d agreed on earlier would be forgotten later.

Early this year I tried again. I used Claude Code to build ReCall — a PySide6 desktop flashcard app with config, UI, database, i18n, a theme system, tests, and Windows packaging. Not huge in scope, but it covered everything a real desktop app needs. The experience was completely different. I was still driving, but Claude could keep up. I’d say what needed doing, and it understood accurately. The code mostly worked. When it went off track, a correction pulled it back fast.

The progress between those two experiences was obvious.

Looking back, the domains where LLMs have actually shipped: text and code. Both share something: they’re tasks with a finish line — write an article, ship a feature, done. Operations is different. Once a system is live, it’s real-time, stateful, and problems arrive without warning. There’s no “done.” It’s a different world entirely.

I was studying for CompTIA A+ Core 2 at the time — reviewing during the day, writing code at night. One question kept turning over in my head: AI assistance for development is maturing fast. What about ops?

When the Operator Becomes an AI

Once AI accelerates development to an exponential pace, the accumulation of running systems accelerates with it. Every new service deployed is something that needs maintaining — indefinitely. Systems don’t disappear. Problems pile up. Complexity compounds. Think of it this way: all running systems together form a large lake; all systems under development are rivers flowing into it. As more rivers flow faster, the lake grows faster than anyone expects.

But human ops scales linearly. One engineer can only maintain so many systems, no matter the tooling. Human ops can’t keep up with exponential accumulation. Looking ahead, only AI ops can take that on.

For AI ops to work, though, one prerequisite needs solving: the interface.

From POSIX to SSH, from Ansible to Kubernetes Operators — these tools are battle-tested, widely deployed, and will keep running for years. But every one of them was designed with a human operator in mind. When the operator becomes an AI Agent, several things are worth rethinking from scratch: text parsing fails whenever output format changes; session-level permissions carry serious risk for Agents that can hallucinate; frequent sampling makes per-connection handshakes a real bottleneck.

Take the cost of “guessing text.” An Agent running ps aux | grep nginx over SSH gets back free-form text — format varies by OS, locale, and tool version. The Agent has to parse it, and every regex that might break is a potential hallucination entry point. Call ASys’s SYS_PROCS instead, and you get a fixed 44-byte binary frame: process count, top-5 PIDs, CPU%, memory%, status flags. Typed, unambiguous, identical on every node. Parsing is one line of struct.unpack. This isn’t just a performance gain. It’s a reliability improvement of a different order. When parsing overhead approaches zero, the Agent can spend nearly all its compute on what actually matters: perception, reasoning, decision.

ASys isn’t trying to replace any of these tools. It’s exploring one question: if you designed an interface specifically for Agents, from first principles, what would it look like? One more option, that’s all.

Open source: github.com/vincentping/asys

Where ASys Came From

From 2010 to 2016, I worked as a developer at a smart card company in Shanghai — SIM cards, bank cards, ID chip cards. The industry had one iron rule: once a card ships, you can’t take it back.

Smart card development meant writing the spec first, implementing against the spec, testing against the spec: functional tests, failure tests, edge case coverage. After internal testing came on-site testing at the telecom operator. Tedious, long-cycle, no shortcuts. Because if you found a bug after mass production, the recall cost was catastrophic. That’s a completely different philosophy from the move-fast-and-iterate approach of internet development. The deepest thing those six years left me wasn’t any particular technology. It was an instinct: thinking it through and writing it down matters more than starting fast.

Those six years also made me fluent in protocols. Especially ISO/IEC 7816 — the APDU system for smart card communication. A card reader sends binary instructions to a smart card and gets back a fixed-format response, never parsed by human eyes. 0x9000 means success. 0x6982 means security status not satisfied. Unchanged for decades. This protocol runs on tens of billions of devices — every bank chip card, every e-passport, every SIM card. Every edge case has been validated in the hardest production conditions possible.

After 2016, I left smart cards and spent the next ten years building web systems of all shapes — frontend JS, backend Python/Go/Java, databases, servers, caches, clouds, various architectures.

The past year I’ve been deep in AI, building projects with Claude. The more I understand it, the more convinced I am: AI will reshape humanity the way the Industrial Revolution did. After finishing ReCall, I kept asking myself what to build next that was actually AI-related.

One night in late February — studying late, just lay down, half-asleep — APDU from 7816 flashed into my head. Those elegantly simple binary instructions, fixed-format responses. I sat straight up. Why not use APDU-style communication between Agents and servers? Why keep human-readable text in the middle at all?

That same night I re-read the 7816 spec, wrote a rough document, got the initial idea down.

Six years in smart cards, ten years in web systems, one-plus years in AI — take away any one of those, and that half-asleep connection doesn’t happen. Most of my old smart card colleagues are still in embedded systems. My web friends rarely have a background in low-level protocol design. Maybe this is what people mean when they say diversity drives emergence. Once the idea showed up, not trying it felt like a waste.

Three Months, Zero to Open Source

Early March — A+ Core 2 still not done — I started anyway.

Old habit from smart card days: write the docs first. Interface design philosophy, instruction set encoding, security model, frame format — think each piece through, write it up, realize mid-writing that I hadn’t thought it through, go back. March 16, v0.1 docs done. Same day, first PoC running between a Windows machine and a RHEL server: SYS_HELLO instruction, response 0x9000 OK.

After the exam, progress accelerated. Docs and code alternated. Write code, find a design problem, go fix the spec, continue. Not throwing things away and starting over — just continuous refinement.

A few decisions in this process each took time to work through.

Transport: Why Not mTLS

Transport layer was the first thing that stopped me. Instinct said mTLS — common, widely used, easy to debug. But the more I thought about it, the more wrong it felt.

asyd is ASys’s server-side daemon. One of its core use cases is staying reachable during OOM events, full disks, exactly the moments you need it most. If it goes silent because a certificate expired or the CA is unreachable at that moment — an interface that fails during emergencies is more dangerous than no interface at all. And OpenSSL is a heavyweight dependency. That directly conflicts with the zero-external-dependencies design goal.

I went with Noise Protocol IK, implemented on Monocypher. Pure cryptographic primitives, no certificate dependencies, roughly 2,000 lines of C, fully auditable, 1-RTT handshake. This choice lets asyd ship as a single static binary. Deploy it on any POSIX environment with no runtime risk.

Permission Model: Making Unauthorized Things Not Exist

The permission model took longer. The intuitive answer was an ACL table — configure which Agent can do what. Simple-looking, but not enough.

Traditional security models (SSH, sudo) were designed for human operators. Human actions are exploratory; intent is hard to declare upfront. “Broad default permissions plus negative interception” fits how humans work. When the operator is an AI Agent, that assumption breaks. Agent behavior is programmatic. Permission boundaries can be declared precisely at deployment time.

So ASys flips it. The system is dark to an Agent by default. Only instructions explicitly lit up in the Capability Map “physically exist.” An unauthorized operation isn’t “you don’t have permission” — it’s “this instruction doesn’t exist in your world.” Unregistered instructions are dropped at the decode stage and never enter any execution path.

Using a bitmap has an additional benefit: side-channel resistance. If you check permissions before checking existence, an attacker can infer which instructions “exist but are disabled” through tiny timing differences in responses. The Capability Map forces existence-check first. All unauthorized operations produce identical response timing. No information leakage surface.

Least privilege isn’t a configuration option. It’s a physical property of the protocol.

Instruction Set: How to Organize 256 Slots

The instruction set structure came together faster, because there was an obvious reference: APDU.

Frame format borrowed directly: [CLA][INS][P1][P2][Lc][Data][Le]. The high nibble of the INS byte serves as a logical page index — 0x00–0x0F is Core ISA, the baseline observation instructions, permanently locked; 0x20–0x8F is Standard ISA, seven functional groups; 0xC0–0xFF is Vendor Extensions, open for domain-specific customization.

Any developer reading an instruction code knows the group at a glance. 0x2x is Process Control, no table lookup needed.

More important is the semantic lock on Core ISA: once a core instruction ships, byte offsets never change. New fields can only be appended at the end. Agent parsing code written today is expected to work on some POSIX-compatible system fifty years from now. APDU covers tens of billions of devices precisely because of this long-termism. That’s what ASys is trying to inherit.

Closing the OODA Loop

Late May, I ran a complete OODA loop demo on RHEL. The RHEL server ran a CPU hog to trigger a load spike. A Python client on Windows called SYS_STATUS to detect the anomaly, SYS_PROCS to locate the process, PROC_THROTTLE to suppress it, then SYS_STATUS again to confirm recovery. All 0x9000 throughout.

That moment didn’t feel like “it works.” It felt like “proof of concept confirmed.”

May 27, v0.3.0 released. Three months from idea to open source.

Where Things Stand

github.com/vincentping/asys is now at v0.3.1.

Stable today: Core ISA’s four observation instructions (SYS_CAPS / SYS_HELLO / SYS_STATUS / SYS_PROCS), the first batch of Standard ISA control instructions (PROC_THROTTLE / SVC_RESTART / TASK_QUERY), a complete Noise IK encrypted channel, public key whitelist authentication, and Epoch_ID replay protection.

The most important next piece is the Python SDK — targeting AI Agent developers, designed to drop into LangChain, AutoGen, and similar frameworks. The core design principle: Agents never touch the byte layer directly. They call structured interfaces (sdk.proc_throttle(pid=1234, action="stop")); the SDK handles parameter validation and binary compilation. LLMs are inherently bad at byte offsets. Having an Agent assemble raw APDU parameters is the wrong abstraction.

Still planned but not yet implemented: per-Agent fine-grained Capability Maps, an audit black box, chained transport. All in the spec. All coming.

Honest Thoughts

Building a protocol solo sounds a little crazy.

Protocols are usually a committee job — they need multi-party consensus, large bodies of real-world input, exhaustive edge case analysis. But the idea showed up. So I tried. Working alone means decisions move fast. It also means no external pressure forces you to think every corner through. My response has been the same as in smart card days: docs before code. White paper, protocol spec, design notes, implementation notes — these took more time than the code itself. Because writing is the best thinking tool I have. If I can’t write it clearly, I don’t actually understand it. If I don’t understand it, the code will collapse eventually.

ASys is an exploratory project. It’s not a replacement for SSH, not a competitor to Ansible. The gap it’s trying to fill: when an Agent needs to manipulate a system at high frequency, low latency, and with full auditability — while staying reachable in extreme conditions — there’s currently no purpose-built standard for that. Wrapping an LLM around SSH and calling it AI ops doesn’t solve the underlying problem.

Whether that’s worth solving is for others to judge. But I think as Agents move further into production systems, the question “what should the interface between an Agent and a system actually look like?” deserves serious attention.

If ASys starts that conversation, that’s enough.

One last note: ASys listens on port 7816 by default. A deliberate tribute to ISO/IEC 7816 — the standard number for smart card communication protocols. Every time I see that number, I’m back in front of a stack of specs from a decade ago: 7816, 14443, EMV, PBOC, UICC, RSA. The years I spent with my face in those pages.

从智能卡到 AI Agent：我为什么做 ASys

Sun, 07 Jun 2026 22:44:00 GMT

ASys（Agentic System Interface）是一个专为 AI Agent 设计的开源系统接口协议——用二进制指令替代文本命令，用长连接替代每次重新握手，用指令级权限替代宽泛的会话权限。这篇文章讲的是它从哪里来，为什么这样设计。

去年用 Claude 辅助写代码，感觉像带一个记性很差的实习生。上下文一长就会开始漂移，重启 Session 要好几个回合才能找回状态，前面约好的接口后面就忘了。

今年一二月再试，用 Claude Code 写 ReCall——一个基于 PySide6 的桌面题库工具，有配置、UI、数据库、i18n、主题系统、测试，最后还要打包成 Windows 可执行文件。功能不多，但桌面程序开发该有的基本都齐了。这次感觉完全不同了：不是 AI 替我写，依然是我在主导，但 Claude 已经跟得上。说要做什么，它能准确理解；出来的代码基本能用；即使偏了，纠正一下也很快能调回来。

前后两次，AI 的进步很明显。

回头看，LLM 目前真正落地的领域：文字处理，以及开发。这两个领域有个共同点：都是做完就结束的事——一篇文章写完发出去，一个功能交付上线，这件事就画句号了。但系统的运维不一样，系统上线之后是实时的、有状态的，问题随时会来，没有“做完”这一说。那是完全不同的一个世界。

备考 A+ Core 2 那段时间，白天复习刷题，晚上写代码，脑子里一直转一个问题：AI 辅助开发越来越成熟——那运维呢？

当操作者变成了 AI

AI 把开发速度拉成指数级之后，存量的积累速度也跟着加快了。每部署一个新服务，就多了一个需要长时间甚至永久维护的对象——这就成了存量。系统不会自己消失，问题会积累，复杂度会叠加。可以这么想象下：运行中的系统整个是一个大湖，开发中的新系统是众多不断涌入的河流。随着河流的数量越来越多、河流中水流的速度越来越快，大湖的扩展速度将超过我们的想象。

但人工运维是线性的——一个工程师能维护的系统是有限的，就算是有各种工具的帮助，人工运维也跟不上指数级的积累速度。往前看，能接这个盘的只有 AI 运维。

但 AI 运维要成立，有一个前提需要解决：接口。

从 POSIX 到 SSH、从 Ansible 到 K8s Operator——这些成熟的工具，每一个都经过了大规模生产验证，在各自的场景下运转良好，还会继续运转很久。但它们的设计前提都是人类操作员。当操作主体变为 AI Agent 时，有几个问题值得从头思考：文本解析随时可能因格式变化而失效；会话级权限对可能产生幻觉的 Agent 风险太高；高频采样时每次握手的开销会成为瓶颈。

比如“猜文本”的代价。Agent 通过 SSH 执行 ps aux | grep nginx，拿到的是自由文本——格式会因 OS、locale 和工具版本而异，还得自己解析，每一段可能失效的正则表达式都是一个潜在的幻觉入口。但调用 ASys 的 SYS_PROCS 指令，拿到的是固定的 44 字节二进制帧：进程总数、top-5 PID、CPU%、内存%、状态标志——类型明确，无歧义，在每个节点上都一样。解析逻辑是一行 struct.unpack。这不只是性能问题，更重要的是可靠性的量级提升。当解析的负担趋近于零时，Agent 几乎全部的算力就可以用在真正重要的事上：感知、推理、决策。

ASys 不是要替代这些工具，只是想探索一个问题：如果专门为 Agent 设计，从第一性原理出发，接口应该长什么样？多一个选择而已。

开源地址：github.com/vincentping/asys

ASys 从哪里来

2010 到 2016 年，我在上海的一家智能卡公司做开发——SIM 卡、银行卡、身份证芯片。那个行业有一条铁律：卡发出去了，没法收回。

智能卡的开发流程是先写规范，基于规范开发，基于规范测试：功能测试、异常测试、边界覆盖……内部测试完了，还要去电信服务商进行现场测试。繁琐、周期长，但没有别的选择：产品一旦量产出去发现 bug，召回成本是灾难。这和互联网的“边跑边迭代”开发风格，是两种完全不同的哲学。那六年给我留下最深的东西不是某项技术，而是一种本能：把事情想清楚写清楚，比快速动手更重要。

那六年也让我对很多协议很熟悉，尤其是 ISO/IEC 7816，智能卡通信的 APDU 体系。读卡器向智能卡发二进制指令，拿到固定格式的响应，不需要经过人眼，也从不解析文本。返回 0x9000 就是成功，返回 0x6982 即 Security status not satisfied，几十年没变过。这套协议覆盖了全球数百亿设备——每一张银行芯片卡、每一本电子护照、每一张 SIM 卡。它的每一个边界条件，都经过了最严苛的实战验证。

2016 年之后，我离开了智能卡行业，后来一直在做各种大大小小的网站系统——前端 JS、后端 Python/Go/Java，数据库、服务器、缓存、各种云、各种架构。

过去一年多又一直在学习 AI，并尝试用 Claude 开发各种项目。随着对 AI 越来越了解，我逐渐相信：AI 会像工业革命一样彻底改变人类的走向。所以，当我完成 ReCall 这个项目后，我就一直在思考做点什么与 AI 相关的事。

有天晚上，我记得是二月底，复习得很晚了，刚躺下，迷迷糊糊的，脑子里突然冒出了 7816 的 APDU——那些自带美感的二进制指令，固定格式的响应。我一激灵坐了起来：对呀，为什么不用 APDU 的方式让 Agent 和服务器沟通呢？还要把人类的文本加在中间干嘛？

当晚就把 7816 协议下载下来重新翻了一遍，写了个简单的文档，把初步想法记下来。

智能卡那六年、网站系统那十年、加上这一年多的 AI 实践——缺了哪一块，都不会在那个迷糊的夜晚把这几样东西联系起来。智能卡的老同事们大多还在嵌入式的世界里；做网站系统的朋友又很少有底层协议设计的背景。也许这就是人们说的，多样性带来涌现。有了这个 idea 不试试可惜了。

三个月，从零到开源

今年三月初，A+ Core 2 还没考完，我就开始动手了。

按智能卡时代养成的习惯，先写文档。从接口设计哲学，到指令集编码，到安全模型，到帧格式，每一块想清楚再写，写着写着发现没想清楚，回去再想。3 月 16 日，文档 v0.1 出来，同一天第一个 PoC 在 Windows 机器和 RHEL 服务端跑通：SYS_HELLO 指令，返回 0x9000 OK。

等到考试考完，项目推进就加快了，文档和代码交替迭代。写代码，发现设计有问题，回去改 spec，再继续。不是推倒重来，是不停打磨。

这个过程里有几个决策点，每个都卡了一段时间。

传输层：为什么不用 mTLS

传输层是第一个让我卡住的地方。本能反应是 mTLS，行业常见方案，用的人多，出了问题好查。但越想越不对。

asyd 是 ASys 协议的服务端 Daemon，核心用途之一是在系统 OOM、磁盘满这种极端情况下还能用——恰恰是最需要它的时候。如果这时候因为证书过期、CA 连不上而失联，一个在急救时刻失联的接口，比没有接口更危险。而且 OpenSSL 是重量级依赖，和零外部依赖的设计目标根本冲突。

最终选了 Noise Protocol IK，基于 Monocypher 实现。纯密码学原语，无证书依赖，实现约两千行 C，可以完整审计，1-RTT 握手。这个选择让 asyd 可以做到单一静态二进制，任何 POSIX 环境都能部署，不带任何运行时风险。

权限模型：让不该存在的东西真的不存在

权限这块卡得更久。最直觉的方案是 ACL 规则表——哪个 Agent 能做什么，配置里写清楚。看上去简单，但不够。

传统安全模型（SSH/sudo）是为人类操作员设计的——人的操作是探索性的，意图难以预先声明，“宽泛默认权限 + 负向拦截”符合人类的工作方式。但当操作主体变为 AI Agent，这个假设不再成立：Agent 的行为是程序化的，权限边界完全可以在部署时精确声明。

所以 ASys 可以反过来：系统对 Agent 是一片漆黑，只有在 Capability Map 中显式点亮的指令才“物理存在”。Agent 没被授权的操作，不是“你没权限”，而是“这个指令在你的世界里根本不存在”——未注册的指令在解包阶段直接丢弃，不进入任何执行流。

用位图还有一个额外的好处：防侧信道攻击。如果先查权限再查存在性，攻击者可以通过响应时间的微小差异推断哪些指令“存在但被禁用”。Capability Map 强制先查存在性——所有未授权操作的响应时间完全一致，消灭信息泄露面。

最小权限不是配置选项，是协议的物理属性。

指令集：怎么组织 256 个槽位

指令集的组织方式反而想得比较快，因为有现成的参照——APDU。

帧格式直接借鉴：[CLA][INS][P1][P2][Lc][Data][Le]。INS 字节的高位半字节作为逻辑页索引——0x00–0x0F 是 Core ISA，基础观测指令，永久锁定；0x20–0x8F 是 Standard ISA，七个功能组；0xC0–0xFF 是 Vendor Extensions，留给各领域自定义。

任何开发者看到指令码就知道分组，0x2x 一眼是 Process Control，不需要查表。

更重要的是 Core ISA 的语义锁定：核心指令一旦发布，字节偏移永远不变，新字段只能在末尾扩展。今天写的 Agent 解析代码，期望是在 50 年后的某个 POSIX 兼容系统上还有效。APDU 协议体系能覆盖数百亿设备，正是因为这种长期主义。ASys 想继承的，也是这个。

跑通 OODA

5 月底，在 RHEL 上跑通了完整的 OODA 闭环演示：RHEL 服务端运行 CPU hog 触发负载异常，位于 Windows 系统上的 Python 客户端依次调用 SYS_STATUS 发现异常、SYS_PROCS 定位进程、PROC_THROTTLE 压制、再次 SYS_STATUS 核实恢复，全程 0x9000。

那一刻的感受不是“成了”，而是“证明可行了”。

5 月 27 日，v0.3.0 开源。从三月初构思到开源，三个月。

现在在哪里

github.com/vincentping/asys 现在是 v0.3.1。

目前稳定实现：Core ISA 四条观测指令（SYS_CAPS / SYS_HELLO / SYS_STATUS / SYS_PROCS）、首批 Standard ISA 操控指令（PROC_THROTTLE / SVC_RESTART / TASK_QUERY）、完整的 Noise IK 加密通道、公钥白名单身份验证、Epoch_ID 防重放机制。

接下来最重要的是 Python SDK：面向 AI Agent 开发者，目标是能直接嵌入 LangChain、AutoGen 这类主流 Agent 框架。核心设计原则是 Agent 永远不直接操作字节层——调用结构化接口（sdk.proc_throttle(pid=1234, action="stop")），SDK 负责参数校验和二进制编译。LLM 对字节偏移天然不敏感，让 Agent 直接拼 APDU 参数是错误的使用方式。

还有一些已规划但尚未实现的功能：per-Agent 细粒度 Capability Map、审计黑匣子、链式传输。这些都在规范里，会逐步落地。

一点感受

一个人做协议，听上去有点异想天开。

协议通常是委员会的事——需要多方共识，需要大量案例输入，需要反复论证边界条件。但既然这个 idea 冒出来了，那就试试吧。一个人做的好处是决策可以很快，坏处是没有外部压力强迫你把每个角落想清楚。

我的应对方式是：文档比代码优先。白皮书、规范文档、设计 Notes、实施 Notes，这些花了我比代码多得多的时间。因为文字是最好的思维工具——写不清楚，说明想不清楚；想不清楚，代码写出来迟早要推倒。这是智能卡那六年给我的东西，在这个项目里用上了。

ASys 是一个探索性项目，不是 SSH 的替代品，不是 Ansible 的竞争者。它试图填的空白是：当 Agent 需要高频、低延迟、可审计地操控系统，且要在极端场景下保持接口可用时，目前没有一个专门为这个场景设计的标准化方案。

值不值得解决，见仁见智。但我认为，随着 Agent 越来越多地进入生产系统，“Agent 和系统之间的接口应该是什么样的”是一个值得认真对待的问题——不应该只是在 SSH 上套一层 LLM 就算了。

如果 ASys 能引发一些这方面的讨论，已经足够。

对了，ASys 默认监听的我特意选择了 7816 端口。这是我内心对 ISO/IEC 7816 的致敬——智能卡通信协议的标准编号。每次想起这个数字，就想起十几年前那一大堆规范——7816、14443、EMV、PBOC、UICC、RSA……趴在上面研究的日子。

Grant in Lincoln Park

Fri, 05 Jun 2026 22:55:00 GMT

Lincoln Park, Chicago skyline beyond.

There were once more than thirty thousand bodies buried in Lincoln Park.

This is not a metaphor. Before the 1850s, this stretch of lakefront green was Chicago’s municipal cemetery. The city expanded. The government decided to move the dead and return the land to the living. Most of the remains were relocated — but no one could guarantee the job was finished. The lawn where joggers run today, where families spread their blankets, where children chase squirrels — beneath it, some nineteenth-century Chicagoans may still be sleeping. Names unknown. The removal orders never found them.

Lincoln was assassinated in 1865, and the park was renamed in his honor. Death and commemoration. This place never pretended that life was light.

I came today specifically to see the Grant statue. I’d been cooped up for days wrestling with Claude Code — when it’s cooperative, it makes you want to write code forever; when it isn’t, it’s a wall you can’t get through. After enough of that, a statue seemed like a reasonable destination.

General Ulysses Grant — who would become president — died in July 1885. In his final months he raced his throat cancer, driving himself to finish his memoirs, hoping to leave his wife some royalty money. Mark Twain published them, and the contract became one of the most lucrative in American publishing history. Grant didn’t live to see the check. Four days after he died, New York held his funeral. A million people lined the streets.

Chicago decided to build him a monument. Within a month of the announcement, tens of thousands of dollars had come in from every corner of the city, from nearly one hundred thousand donors. When the statue was unveiled in 1891, roughly two hundred thousand people were there. Chicago’s total population was just over a million. One in five.

I stood in front of the statue and looked up at how Grant sat his horse. No triumphant gesture. No arm sweeping toward the horizon. The horse’s front hooves stayed on the ground. He simply sat there, expression composed, like a man who had nothing left to prove.

The year after the statue was completed — 1892 — lightning struck. It hit near the arch at the base. Three people sheltering there were killed instantly. The bronze was untouched.

I don’t know what to do with that detail. But it stays with me.

Grant Statue

There is another structure in the park worth mentioning, though most visitors walk past it without a second glance. The Carlson Cottage, built in 1888, was originally a public restroom — segregated by sex, brick and stone, designed by the architect Joseph Lyman Silsbee. Silsbee’s office once employed a young apprentice named Frank Lloyd Wright, who went on to become one of the most consequential architects of the twentieth century.

A public toilet. From the office that shaped a century of building.

In 2008, the federal government funded the cottage’s restoration through the Save America’s Treasures program. Bureaucracies occasionally do surprising things — they decided to restore an 1888 outhouse because it was history. That logic, I accept.

But once restored, it was no longer used as a restroom. It became an event space, and most days it sits quietly locked. The history was preserved; the function died. It’s a strange outcome — like maintaining a body in perfect condition after removing everything it was ever for.

Carlson Cottage

In 2020, Mayor Lori Lightfoot, amid a nationwide reckoning with public monuments, formed the Chicago Monuments Project. The proximate cause was the Columbus statue — toppled by protesters, or quietly removed by the city before protesters could topple it, depending on which account you read. The committee’s mandate was to review the city’s monuments and public art: what should stay, what should go, whose stories had been left out of the official memory.

There is nothing inherently wrong with this. A city periodically examining what it has chosen to memorialize is ordinary civic practice. Public monuments are not neutral. Each one is a decision, made by a particular group of people in a particular era, telling everyone who passes: this person, this event, deserves to be remembered.

Grant’s statue was on the review list.

The argument against him: he had signed policies that were unjust to Native Americans, and the westward expansion of his presidency brought forced removal and cultural destruction to tribal nations. These are facts.

But Grant was also the Union general who defeated the Confederacy — the man whose military pressure compelled Lee’s surrender at Appomattox, the moment slavery’s military defense collapsed. During Reconstruction, he was among the rare presidents who genuinely tried to protect the civil rights of Black Americans, deploying federal force against the Ku Klux Klan. The memoirs he finished while racing toward death were later called by Hemingway the best account of war he had ever read.

One person can be both of these things at once: an instrument of one justice, and an agent of another injustice.

I have no objection to the Monuments Project’s existence. Scrutinizing history is not the same as erasing it. But I’ve always had a fundamental skepticism toward the logic that removing a bronze statue can repair a historical wound.

The thirty thousand bodies once buried under Lincoln Park did not change their position when the park changed its name. Removing a monument does not remove history. Sometimes it only creates a feeling of cleanliness — the problem seems handled, when really it has simply moved out of sight.

The Grant statue was ultimately not removed. The report recommended keeping it, with an interpretive panel added to provide fuller historical context. That seems like the right call, or close enough to it — not because it satisfies everyone, but because it acknowledges that historical complexity cannot be resolved by a piece of bronze, or by taking a piece of bronze away. For what it’s worth, I walked around the base of that arch today, all the way around, and found no interpretive panel. Perhaps it’s still being made.

I sat near the statue for a long time. Wind off Lake Michigan. A man walking his dog. Kids on bikes. In the distance, by the smaller pond, someone was getting married. Laughter carried over.

Grant sat on his horse, Lake Michigan to his left, facing the city to the south. Some say the orientation is deliberate — the general keeping watch over the former Confederacy, a symbol of union and victory. But the expression I described earlier as composed — I want to change that word now. It’s the tiredness of someone who has seen too much. Not a defeated tiredness, but the kind that no longer needs to explain itself to anyone.

The lightning of 1892 killed three people. It didn’t touch him.

I don’t know what that means. But when something a city built in one month with money from a hundred thousand people is still standing a hundred and thirty years later — I’m willing to sit beside it a while longer.

There may still be some nineteenth-century Chicagoans underfoot who were never moved. That doesn’t seem like a bad arrangement.

The dead and the bronze are more patient than we tend to think.

林肯公园的格兰特

Fri, 05 Jun 2026 22:45:00 GMT

林肯公园，远处是市区

林肯公园里曾经埋着三万多具尸体。

1850年代之前，这片湖边绿地是芝加哥的城市公墓。后来城市扩张，市政府决定把死人挪走，把土地还给活人。遗体被迁走了大部分，但没有人能保证迁干净了。今天慢跑者踩过的草坪，野餐者铺毯子的地方，孩子们追松鼠的小径——下面可能还睡着几个19世纪的芝加哥人，姓名不详，迁移令没能找到他们。

1865年林肯遇刺，这片绿地以他的名字重新命名。死亡与纪念，这个公园从一开始就没打算假装生活是轻松的。

我今天是专门来看格兰特的雕像的。闷在家里和Claude Code纠缠了好几天，它心情好的时候让我写代码觉得自己是超人无所不能，心情差的时候又像一堵墙，死劲撞也撞不开。出来透透气。

尤利西斯·格兰特将军——后来他成了总统——死于1885年7月。他在生命最后几个月里跟喉癌赛跑，拼命写完回忆录，想给妻子留点版税钱。马克·吐温替他出版，后来成了美国出版史上回报最丰厚的合同之一，但格兰特本人没活到看见版税支票。他死后四天，纽约举行了他的葬礼，百万人站在街边送行。

芝加哥市民决定为他立一座铜像。消息传出后，不到一个月，数万美元从这座城市各个角落汇集过来，捐款人数将近十万。1891年雕像揭幕那天，大约二十万人到场——那时芝加哥全市人口也不过一百万出头，相当于每五个芝加哥人里就有一个到了现场。

我站在雕像前，抬头看格兰特骑在马上的姿势。他没有摆出那种常见的凯旋姿态，手臂没有挥向远方，马也没有前蹄腾空。他只是坐在马背上，神情沉静，像一个已经无需证明任何事情的人。

雕像落成次年，1892年，雷击中了这里。闪电劈在基座拱门附近，三个避雨的人当场死亡，而铜像完好无损。

这个细节我不知道该怎么解读，但它一直留在我脑子里。

格兰特将军雕像

公园里还有一座建筑值得一提，虽然大多数人路过时根本不会多看一眼——那是1888年建造的卡尔森小屋，最初是公共厕所，男女分区，砖石结构，设计者是建筑师约瑟夫·莱曼·希尔斯比。希尔斯比的事务所曾经有个年轻学徒，叫弗兰克·劳埃德·赖特，后来成了二十世纪最重要的建筑师之一。

一座公共厕所，出自后来影响了二十世纪建筑语言的那个事务所。

2008年，联邦政府通过「拯救美国的宝藏」项目资助了小屋的修复工程。官僚机构偶尔会做出让人意外的事——他们决定修一座1888年的公厕，因为它是历史。这个逻辑我接受。

只是修好之后，它不再开放为厕所，变成了某种活动场地，平日里静悄悄地锁着门。历史被保住了，功能却死了。这个结局有些奇怪——像是把一个人完好地保存下来，却抽走了他活着的用处。

卡尔森小屋，石头上的铭牌介绍了它的来历

2020年，芝加哥市长莱特福特在全美范围内的历史清算浪潮里，组建了「芝加哥纪念碑项目」。起因是哥伦布雕像被示威者推倒，或者说被市政府抢在推倒之前悄悄移走——取决于你看哪份报道。这个委员会的任务是审查全市的纪念碑和公共艺术，评估哪些应该保留，哪些应该移除，哪些历史叙事被排除在公共记忆之外。

这件事本身没有什么可挑剔的。一座城市定期审视自己竖起了什么、纪念了谁，是正常的公共程序。公共空间里的纪念碑本来就不是中立的，每一座都是某个时代、某群人做出的选择，都在无声地告诉路过的人：这个人或这件事值得你记住。

格兰特的雕像在审查名单里。

理由是他曾签署过对美国原住民不公正的政策，任总统期间的西部扩张政策导致了原住民部落的强制驱逐和文化毁灭。这些都是事实。

但格兰特同样是内战中击败南方邦联军的联邦军总司令，是在他的军事压力下，南方的李将军投降、奴隶制度军事上走向终结的那个人。重建时期，他是少数真正尝试保护黑人公民权利的总统之一，动用联邦力量镇压了三K党。他死前那场与死亡赛跑的写作，后来被海明威称为最好的战争回忆录之一。

一个人可以同时是这两类：某种正义的推进者，和另一种不义的执行者。

我不认为纪念碑委员会的存在本身有问题，也不认为审视历史等同于清洗历史。但对那种认为移除一座铜像能够修复历史创伤的逻辑，我始终将信将疑。

那三万具曾经埋在林肯公园地下的遗体，不会因为公园改了名字而改变它们曾经的位置。移走纪念物也不等于移走了历史本身，有时候反而是在给当代人一种虚假的清洁感——好像问题处理掉了，而实际上只是从你眼里消失了。

格兰特的雕像最终没有被移除。报告建议保留，同时增加解说牌，以提供更完整的历史语境。我觉得这已经算是体面的收场——不是因为它让所有人满意，而是因为它承认了历史的复杂性无法被一块铜化解，也无法被移除一块铜来解决。当然，我今天又在雕像拱门的前前后后、上上下下转了一圈，没有看到解说牌，可能它正在制作的途中。

我在雕像附近坐了很久。湖风从密歇根湖那边吹过来，公园里有人遛狗，有孩子骑车，远处小湖边还有人在举行婚礼，隐隐能听到人们的欢笑和喧哗。

格兰特骑在马背上，左侧是密歇根湖，面朝南方的城市。有人说，这代表将军正警惕地注视着当年的南方邦联，象征着国家的统一与胜利，但他的神情我刚才说是沉静，现在我想换个词——是那种见过太多事情之后的疲倦，不是那种消极的疲倦，而是已经不需要再向任何人解释自己的疲倦。

1892年的那道闪电劈死了三个人，没有碰他。

我不知道这说明什么。但当一座城市用一个月时间、十万人的捐款造出来的东西，在一百三十年后还站在那里——我愿意在它旁边多坐一会儿。

脚下可能还有几个没被迁走的19世纪芝加哥人。这也没什么不好。

死人和铜像都比我们想象的更有耐心。

格兰特将军雕像

Plywood Over Bed Slats: A Better Alternative to Bunkie Boards

Mon, 01 Jun 2026 11:40:00 GMT

I needed a new bed after moving.

For the frame, I ordered a King Size solid wood bed frame with storage drawers from Bob’s Discount Furniture.

The mattress came from Wayfair — a Simmons Beautyrest Silver BRS900, Extra Firm, with individually pocketed coil springs. Fun fact: the Simmons brand name is the origin of “席梦思” (Xí Mèng Sī), the generic term Chinese consumers use for spring mattresses.

I like a firm feel — solid, supportive under the back, no sinking when you roll over. Extra Firm was exactly what I was after.

When the delivery crew from Bob’s brought the frame in, both white-glove installers said the same thing unprompted: “This bed is really heavy.” Once it was set up, I could confirm — solid and sturdy.

But the slats on top of the frame were spaced too far apart. I measured: each slat was 2.5 inches wide and 0.6 inches thick, with gaps of nearly 3.5 inches between them.

Putting the mattress directly on that wasn’t going to work. A pocketed coil mattress has each spring individually wrapped in fabric — there’s no interconnecting steel wire forming a grid. Based on the spring count for my model, each coil pocket is roughly 2.1 inches in diameter. With gaps that wide, every spring would be affected:

Springs sitting directly over a gap lose their support entirely, sag downward, and stop doing their job.
Springs partially over a gap bear uneven loads and are prone to twisting out of shape.
Even springs that land squarely on a slat end up carrying disproportionate weight, causing them to wear out and lose tension faster.

This doesn’t just mean an uneven sleeping surface and internal damage over time — Simmons will also void the warranty outright if the gap exceeds 2 inches. Their official Warranty Instructions are explicit: gaps between slats must not exceed 2 inches.

So what to do?

American Beds vs. Chinese Beds

Back in China, mattress support was never something I thought about.

Beds there were simple: a frame with a solid wood board on top, a cotton mattress pad, a sheet, done. I also slept on palm fiber mattresses for a while — rock hard. The elders always said that was good for your bones and spine. These days everyone uses mattresses, but the solid board base is still standard. Support was never a problem; it never crossed anyone’s mind.

Coming to America, I found things work completely differently. The standard American bed has three layers: frame + Box Spring + mattress.

The frame itself is just a border with legs and a few sparse slats running across.

Because that alone can’t support a mattress properly, a Box Spring goes in between. Originally, a box spring was literally a box filled with springs — essentially a simple spring mattress in a box shape, designed to add bounce and raise the overall bed height. Today, nearly all box springs have no springs at all. They’ve been replaced by a layer of closely spaced slats on top of a wooden frame, wrapped in the familiar knit fabric — but still built in the same boxy shape.

That’s why American beds tend to sit so high — raising the height was part of the box spring’s original purpose.

The Options

So what were my choices?

Box Spring — ruled out

My first thought was to just add a box spring. But the slats inside modern box springs are spaced roughly 2–3 inches apart as well, so adding one would accomplish nothing.

Bunkie Board — ruled out

I asked an AI for suggestions, and it recommended a Bunkie Board.

After researching extensively, I could see the idea: it’s designed to go between the frame and mattress to solve exactly this kind of support problem. But after looking at a lot of products on the market, I wasn’t convinced.

Bunkie boards come in two types. The first uses internal slats with a fabric cover — the slats are a bit closer together (1–2 inches), slightly better than the bed frame, but still gapped. The second type uses a solid panel inside with a fabric cover.

The solid panel type sounds right, but on closer inspection the materials are almost universally particleboard or MDF — both prone to off-gassing, moisture warping, and a lifespan of only 5–10 years.

Foundation — ruled out

The AI also suggested a foundation. Looking at what’s actually sold, a foundation is essentially the same thing as a modern springless box spring: same height, fabric-wrapped exterior, wooden frame inside, no springs, slats spaced about 1–2 inches apart — and priced at $200–$400. Pass.

Adding more slats — ruled out

This was the DIY angle: add more slats between the existing ones to bring the spacing down to 1–2 inches. Theoretically workable, but a King Size frame has an interior width of 76 inches, which isn’t a standard dimension, so the slats would need custom cutting. Then each one would have to be installed and spaced evenly. More effort than it’s worth, with too much room for error.

The actual solution: plywood

Cut a few sheets of plywood to the bed’s dimensions, lay them flat on the existing slats, put the mattress on top. Solid, 100% even support. It’s the same logic as the traditional Chinese bed board — just a different material.

At Home Depot — What to Say

I went to the Home Depot on North Ave in Chicago. Weekdays between 10am and 2pm are the best time — the cutting station is least busy and wait times are short.

I picked up two sheets of SANDEPLY 12mm Sande Plywood, 1/2 in. x 4 ft. x 8 ft., sanded surface finish, at $53.73 each. Two sheets for a King Size comes to $107.46. Home Depot cuts for free. I also grabbed a roll of black Duct Tape to hold the panels together.

My frame has 13 slats spaced fairly evenly, and with a 3.5-inch span between them, 1/2-inch plywood is thick enough — no sagging.

Load the sheets onto a flat cart and wheel them to the cutting station. Here’s what to say:

Please cut these TWO 4x8 sheets into FOUR pieces total. Each piece should be 38 inches by 40 inches. Please account for the kerf so the final combined width equals 76 inches. Discard the remaining scraps.

One important detail: always ask them to account for the kerf. The saw blade itself has thickness — each cut removes about 1/8 inch of material. If you ignore this, the two panels won’t quite add up to 76 inches when placed side by side. Let the staff handle the math; they do this all day and will get it right.

A King Size is 76 × 80 inches. Two 4×8 sheets, each cut into two 38×40-inch pieces, gives you four panels total.

Transport and Installation

The reason to cut into four pieces rather than two 38×80-inch panels is simple: my car isn’t big enough for an 80-inch panel. With four pieces, I folded down the rear seats and stacked them flat in the back. Each panel is 38×40 inches — about a meter long — so nothing pushed against the front passenger seat or blocked the right mirror. Perfectly manageable. If you have a pickup truck, two panels are enough.

Pad the edges with an old blanket to avoid scratching the car’s interior trim.

Back home, I rinsed the panels off and left them outside to air out for a bit — plywood does have a smell.

Installation was fast: starting from the headboard, lay all four panels flat, working toward the foot. They’ll naturally leave about a 1-inch gap around the perimeter, which is actually good for airflow. Run Duct Tape over the cross-shaped seam in the center to keep the panels from shifting.

When the mattress arrived, I set it straight on top.

How It Feels

Rock solid.

The Extra Firm feel comes through completely — no localized sinking anywhere. Rolling over, getting up, the entire surface holds. Two people sleeping doesn’t affect the other side at all.

Exactly what I wanted.

On airflow: a solid panel does restrict circulation underneath compared to slats, but the bed frame is open on all four sides, so air can come in from the edges. If you live somewhere humid or tend to sleep hot, drill 1/2-inch holes every 6 inches across the panels — airflow improves dramatically with almost no effect on structural rigidity.

Final Thoughts

Bunkie boards and foundations are, at their core, fabric-wrapped thin panels or slat assemblies. You’re paying for the packaging. Plywood is thicker, stronger, more durable, and costs less than half the price. If your bed is a platform frame that was never designed for a box spring, this is the most practical solution I’ve found.

Cost comparison: Bunkie Board $100–$300, Foundation $200–$400, two sheets of Sande Plywood $108, Home Depot cutting free.

None of this is a new idea. It’s just the logic of the traditional Chinese bed board, applied in America. Went the long way around, and ended up back at a solid surface.

不买 Bunkie Board：用胶合板解决床架 Slats 间距问题

Mon, 01 Jun 2026 10:40:00 GMT

因为搬家，需要一张新床。

首先是床架，在 Bob’s Discount Furniture 订了一个带储物抽屉 King Size 的实木床架。

而床垫则是是从 Wayfair 订的，Simmons 公司生产的 Beautyrest Silver BRS900，Extra Firm，里面是用袋装弹簧。顺便说一声，Simmons 公司名就是国内弹簧床垫经常叫“席梦思”这个品名的由来。

我喜欢硬床感。那种很扎实、背部有支撑、翻身不陷进去的感觉。Extra Firm就是冲这个买的。

床架搬进去，负责搬运和安装的 Bob’s 两位白手套师傅都跟我说了同一句话，“这张床真的很重”。等安装好，我试了试，确实很沉很结实。

可是床架上面铺着的木条，间距有点大，一测量，每根木条本身是2.5英寸宽、0.6英寸厚，但是两根之间的缝有差不多3.5英寸。

如果等床垫到了直接放上去，肯定不行。因为弹簧床垫每一个弹簧都是独立装在布袋里的，它们之间没有硬钢丝连成网。我这个型号的床垫按照弹簧数量计算了下，弹簧袋的直径基本就是2.1英寸左右。如果木条空隙太宽，所有弹簧都会受到影响：

正好位于空隙上方的那些独立弹簧，会因为底下悬空失去支撑，直接不受力，往下塌陷
半悬空的弹簧，会因为受力不均，容易扭曲变形
对于那些刚好完全落在木条上的弹簧，也会因为独自支撑了太多重量，提前老化失去弹性，缩短使用寿命。

这不仅会导致床垫表面很快变得凹凸不平、内部结构损坏，而且一旦空隙超过 2 英寸，Simmons 官方是直接拒绝质保（Void Warranty）的，其官方质保政策（Warranty Instructions）中明确规定：床条之间的净空隙不能超过 2 英寸。

怎么办？

美国床 VS 中国床

在国内的时候，从来没想过“床垫支撑”这件事。

那时候床是什么样的？最早的时候是床架加实木床板，然后垫上褥子，铺上床单就行。后来还睡过棕绷床垫，睡起来都是硬邦邦的。老人说这样好，对骨头好，对脊椎好。当然现在大家也都用床垫了，但床架上的实心床板一直都在。在国内，支撑这事从来不是问题，根本不需要操心。

到了美国才发现，这边完全不同。美国最普遍的床基本都是三层结构：床架 + Box Spring + 床垫。

床架本身就是床框和床脚，然后横向加几根稀疏的木条。

因为这样撑不住床垫，中间就加个 Box Spring。这玩意最早就是一个装了弹簧的木箱子，相当于一个简单的弹簧床垫，做成 Box 样子，主要是用作让床垫睡起来比较有弹性，同时增加床的总高度。到现在，绝大多数 Box Spring 已经没有 Spring 了，替代成顶部有一层比较密的横向木条（Slats），外面再裹上一层标志性的针织布，但还是做成一个 Box 的样子。

所以美国的床一般都比较高，Box 最初也有增加床高度的作用。

市面上的选项

回到问题，我这种情况该怎么办？

Box 排除

首先想到的是，加一层 Box？可是现在 Box 里面的木条间隔基本也在 2-3 英寸，加上去完全没意义。

Bunkie Board 排除

找 AI 帮忙想办法，它推荐买一个 Bunkie Board。

在网上搜了很多，感觉这东西应该就是专门为这种情况设计的，放在床架和床垫之间，解决支撑问题。但仔细看了市面上大量产品之后，发现不好。

Bunkie Board 分两种。一种是木条式，内部还是木条加布罩，间距1到2英寸，比床架稍微密一点，但本质上还是有缝。另一种是实心板式，内部是一块板，外面包层布。

照说实心板式可以，但是仔细一看，我发现材质都比较差，基本都是particleboard（刨花板）或者 MDF，味道重不说，遇潮就会膨胀变形，寿命只有5到10年。

Foundation 排除

然后 AI 还推荐了 Foundation。查了下市面上卖的 Foundation，其实和现在不带弹簧的 Box Spring 差不多，同样高度，外面包布，里面是木框架，没有弹簧，木条间距比Box Spring密一点，大概1到2英寸，价格还要$200-$400，排除。

加装木条排除

这是DIY的思路，在现有木条之间加装更多木条，把3.5英寸的间距缩小到1到2英寸。理论上可行。但King Size床架内径76英寸，不是标准尺寸，需要定制裁切，买回来还要逐根安装固定，确保每条间距均匀。工程量不小，容错率也低。算了。

最后的选择：胶合板

就是自己做一个床板，买几张胶合板，裁成床的尺寸，平铺在木条上，床垫再放胶合板上面。实心的，100%均匀支撑。说到底，跟国内的实木床板是同一个逻辑，只是换了个材料。

去Home Depot，手把手说清楚

我去的是芝加哥 North Ave 那家Home Depot。工作日白天10点到2点去，锯木台人最少，等待时间短。

买了两张 SANDEPLY 12mm Sande Plywood，1/2 in. x 4 ft. x 8 ft.，选表面 Sandy 打磨过的那种，Home Depot卖$53.73。King Size需要两张，合计$107.46。Home Depot 帮忙裁切。另外还买一卷黑色布胶带 Duct Tape，固定几块板子用。

因为我的床架本身有13根木条，间距相对均匀，跨度3.5inch不算大，所以选1/2英寸的厚度够了，不会变形。

选好后，用小板车拖到到锯木台，跟师傅说：

这里有一个细节，一定要跟师傅说 account for the kerf。锯片本身有厚度，每切一刀会损耗约1/8英寸，英文叫kerf（锯缝）。如果不考虑这个，两块板子拼起来会差一点点。让师傅自己算，他们熟，比自己算更准。

King Size是76×80英寸，两张4×8的板子各裁成两块38×40英寸，共四块。

运输和安装

之所以要裁切成四块，而不是两块 38x80 英寸的，是因为我的车不够大，80 英寸的放不下。切成四块，把后排座椅放倒，四块板子叠放进去。每块38×40英寸，长度大概1米，不会顶到副驾驶，不会遮挡右侧后视镜，驾驶完全没问题。如果有一辆皮卡，可以切成两块就够了。

记得在边缘垫块旧毛毯，防止刮到车内塑料件。

回到家首先把四块板子清洗下，放室外透透气，胶合板还是有点味道的。

安装很快，直接从床头开始把四块板子平铺上去，四周会自然留下约1英寸的缝隙，有助于透气。再用 Duct Tape 把四块板子之间的十字接缝贴上，防止滑动。

床垫到货，直接放上去就好了。

实际效果

非常稳。

Extra Firm的硬度感完全出来了，没有任何局部下陷的感觉，翻身、起床，整个支撑面都是实的，两个人睡也不会互相影响。

这就是我想要的。

关于透气性的问题也说一下：实心板底部空气流通比木条式差，但床架四周是开放的，空气可以从侧面进来。如果你住的地方比较潮湿，或者容易出汗，可以用电钻每隔6英寸打一个1/2英寸的小孔，透气性大幅改善，结构强度基本不受影响。

最后说几句

Bunkie Board和Foundation本质上是“包了布的薄板或木条”，卖的是外观和包装的溢价。胶合板更厚、更结实、更耐用，而且便宜一半以上。如果你的床架是平台床架，原本就不需要Box Spring，这个方案是目前我找到的最性价比的解法。

费用对比，Bunkie Board $100到$300，Foundation $200到$400，两张Sande Plywood $108，Home Depot裁切免费，完事。

说到底，这不是什么新发明，就是国内床板逻辑在美国的一次实践。绕了一圈，还是实心床板最管用。

WSL2 Under the Hood: One VM, One File, One IP That Never Stays the Same

Fri, 27 Feb 2026 22:10:00 GMT

The previous article “Install Linux on Windows 11 in 5 Minutes” covered how to install WSL2 and get it running. Once you’ve had it going for a while, the quirks start to show.

You delete a bunch of files inside Linux — Windows disk space doesn’t move. You try to access Windows files from inside WSL2 — painfully slow. A network script that worked fine yesterday stops connecting after a wsl --shutdown.

None of this is a bug. It all comes directly from how WSL2 is designed under the hood. Once you understand the key design decisions, these problems become easy to diagnose.

What Kind of VM Is It, Exactly?

There are two types of hypervisors. Type 1 (Bare Metal) runs directly on hardware and hosts multiple operating systems — no host OS in between. Type 2 runs on top of an existing OS, like VirtualBox or VMware on your Windows desktop.

Type 1 is more efficient, suited for data center servers. Type 2 is more flexible, better for developer workstations.

So where does WSL2 fit?

At first glance, it looks like Type 2 — Linux is running inside Windows, it can’t run standalone, and we’re using it on a client machine. But the performance is surprisingly good, almost like running on bare metal.

The reality is it’s neither. Or rather, it has the efficiency of Type 1 and the flexibility of Type 2.

WSL2 runs a real Linux kernel inside Windows.

But this “VM” isn’t like VirtualBox or VMware. It’s called a Utility VM, running on Microsoft’s own Hyper-V Hypervisor.

A regular VM has to simulate an entire hardware stack: motherboard, BIOS, GPU drivers, storage controllers — all of it. WSL2’s Utility VM skips all of that:

No BIOS emulation
No virtual hardware drivers
No fixed memory reservation

It only exposes what the Linux kernel actually needs: CPU time, memory pages, and I/O channels. The result is fast startup and near-zero memory use when idle.

If we had to put a label on it: Type 1.5 — Hyper-V underneath, but far lighter than a traditional VM.

One thing worth clarifying: Hyper-V actually has two layers. The first is the Hypervisor itself, loaded directly by the Windows 11 bootloader at startup — it runs below the OS at Type 1 level, and it’s always on. That’s the layer WSL2 uses. The second layer is the Hyper-V management services — the “Hyper-V xxx” entries you see in services.msc. Those are for Hyper-V Manager and traditional VM management. WSL2 doesn’t use them at all, so it’s completely normal for those services to be stopped.

From WSL1 to WSL2: Why the Design Changed

Why is WSL2 designed this way? We need to look back at the history — starting with how WSL1 worked and where it broke down.

WSL1, released in August 2016, was built around syscall translation: when you ran ls or make inside it, WSL1 intercepted those Linux kernel calls and translated them into Windows API calls in real time. Clever idea — but it fell apart under real workloads.

Problem 1: Translation itself has a cost. Every syscall — reading a file, spawning a process, checking permissions — goes through three steps: intercept, translate, execute. This isn’t something that happens occasionally. A running program can trigger thousands of syscalls per second. The overhead adds up fast.

Problem 2: The file systems are fundamentally incompatible. Linux uses ext4, built around inodes. Windows uses NTFS, with a completely different permission model. WSL1 had to do real-time mapping between the two — but Linux concepts like symlinks, permission bits, and case-sensitive filenames either have no equivalent in Windows or behave differently. The translation cost was high, and the results weren’t always correct.

Problem 3: Some things simply can’t be translated. This was WSL1’s real breaking point. Containers (Docker) depend deeply on two Linux kernel mechanisms: namespaces, which isolate what a process can see, and cgroups, which limit resource usage. These are native Linux kernel capabilities — Windows has no equivalent. There’s nothing to translate to. So Docker in WSL1 never worked, period.

WSL2’s solution was direct: stop translating. Put a real Linux kernel in there instead.

With that, Linux syscalls go straight into the kernel — no middle layer. The ext4 file system runs natively inside the VM with no NTFS mapping. Namespaces and cgroups actually exist, so Docker just works.

The performance gain wasn’t a tweak. It was a fundamental rethink.

Your Entire Linux Lives in One File

Let’s see what Linux actually looks like inside the Windows file system.

Open File Explorer and navigate to C:\Users\[username]\AppData\Local\wsl\. You’ll find a subfolder with a GUID name (something like {445ca81a-6e98-4e8d-aa7b-da5591a61d49}). Inside it is a file called ext4.vhdx.

(Older versions of WSL2 used the distro name as the folder name, like Ubuntu. Newer versions switched to GUIDs.)

Your entire Linux system is that one file. Every package installed, every repo cloned, every line written to a log — it’s all in there.

Here’s a counterintuitive trap: .vhdx is dynamically expanding, so it grows as you add data. But deleting files inside Linux does not shrink the .vhdx.

Delete 20 GB of dependencies? Windows disk usage won’t budge. After a few months, the .vhdx ballooning to several hundred GB is common — even if the actual Linux content is much smaller.

The fix is Windows’ built-in diskpart. Close all WSL windows, run wsl --shutdown, then:

diskpart
> select vdisk file="C:\Users\[username]\AppData\Local\wsl\{your-GUID}\ext4.vhdx"
> attach vdisk readonly
> compact vdisk
> detach vdisk
> exit

This compresses the empty space inside the virtual disk and gives it back to Windows. Anyone maintaining a WSL environment long-term should run this periodically.

Why Is Cross-System File Access So Slow?

This is WSL2’s most common performance complaint: accessing Windows files from inside Linux (anything under /mnt/c/) is painfully slow. Restarting WSL or switching commands doesn’t help.

What about the other direction? Opening Linux files from Windows Explorer (the penguin icon in the left sidebar) — just as slow.

Same reason: both directions go through the same channel.

WSL2 runs two completely separate file systems:

ext4, inside the Linux Utility VM (paths like ~/projects/)
NTFS, on the Windows side (accessed from Linux as /mnt/c/)

Whichever direction you’re crossing, every request goes through: the Hyper-V virtualization layer → tunneled via the 9P protocol → reaches the other side → data comes all the way back. Every single file operation makes that round trip.

(9P is a network file-sharing protocol. WSL2 runs a 9P server internally — it essentially treats the other side’s file system like a network share on a LAN.)

For anything that reads and writes lots of small files frequently, each operation is a 9P round trip through the virtualization layer — 10 to 50× slower is completely normal.

The rule is simple: keep files where you use them. Files you work on in WSL2 go in the Linux file system (~/). Windows projects stay in NTFS. Don’t make files cross the boundary repeatedly — no configuration can work around this physical constraint.

The IP That Keeps Changing

When WSL2 starts, Windows builds a small internal virtual LAN: Linux gets a virtual network card, the Windows host gets one too, and they talk through this private network using addresses in the 172.x.x.x range.

The problem: every time WSL2 restarts via wsl --shutdown, this virtual LAN gets rebuilt and IPs are reassigned. It might be 172.28.80.1 one time, 172.19.32.1 the next.

This creates two distinct issues — worth separating:

Windows connecting to Linux services: Say you’re running a web server inside Linux and want to open it in a Windows browser — don’t worry about the IP. Just use localhost. Microsoft handles automatic forwarding on the Windows side. Nothing to configure here.

Linux connecting to Windows services: This direction is trickier. If a script needs to call an endpoint on the Windows host, or connect to a database running on Windows, Linux needs to know the current Windows host IP to get there.

And that IP is exactly the one that changes every restart.

The good news: every time WSL2 starts, it automatically writes the current Windows host IP into /etc/resolv.conf on the Linux side:

cat /etc/resolv.conf
# nameserver 172.28.80.1  ← this is the Windows host IP right now

Any script that needs to reach back to Windows should read this value dynamically — never hardcode a specific IP. Hardcode it, and after the next restart it silently stops working. No error, no warning — just mysterious failures that take a long time to trace.

Keeping WSL2 From Eating All Your Memory

Let’s talk about resource limits. By default, WSL2 can use up to 50% of system memory and all CPU cores. On a 32 GB machine running heavy workloads, that noticeably squeezes Windows-side applications.

How do we configure it? Windows now includes a built-in GUI tool called WSL Settings — just search for it and open it. Memory limit, CPU core count, and swap size are all right there. Adjust and save.

If you prefer editing manually, create or edit .wslconfig in C:\Users\[username]\:

[wsl2]
memory=8GB
processors=4
swap=2GB

Both approaches work the same way. Run wsl --shutdown after saving — changes take effect on the next start. Tune the numbers to your machine; there’s no universal right answer.

Why Did Microsoft Build This?

Some people wonder — why would Microsoft go to all this trouble to run Linux inside Windows? Weren’t they worried about it cutting into their business?

There’s a clear business logic behind it. Three reasons, actually.

Reason 1: Win back developers. Between 2010 and 2018, a massive number of developers moved from Windows to MacBooks — because macOS natively supports Unix toolchains, while Windows developers were fighting Cygwin, path escaping, and permission incompatibilities. Microsoft saw the pattern: control the developer experience, control the ecosystem. WSL2 was the counterpunch — make Windows a platform developers actually want to use.

Reason 2: A beachhead for the cloud. Every major cloud platform runs Linux. Developers who use WSL2 locally — learning shell, apt, systemd — build skills that transfer directly to cloud environments. When they’re ready to move workloads up, the path of least resistance leads straight to Azure.

Reason 3: A prerequisite for the container era. Docker and Kubernetes require a real Linux kernel. Without WSL2, Docker Desktop on Windows needed a much heavier standalone VM. WSL2 made containers feel natural on Windows — and comfortable Docker users are one step closer to Azure.

WSL2 isn’t a product. It’s a layer of strategic infrastructure. A company that once called Linux “a cancer” spent years building what is arguably the most polished Linux environment on any platform. Once the business logic clicks, everything makes sense.

Quick Reference: Things That’ll Bite You

wsl --unregister is a hard delete. The .vhdx file disappears instantly — no confirmation, no Recycle Bin, no recovery. Always run wsl --export [distro-name] [backup.tar] before using it.

The .vhdx silently bloats. Disk space freed inside Linux doesn’t return to Windows automatically. On long-running WSL machines, run diskpart compact vdisk periodically — otherwise one day you’ll suddenly find the C drive full.

Where files live affects performance. Files that need frequent access inside WSL2 should live in the Linux file system (~/), not /mnt/c/. Making this clear resolves most “why is WSL2 so slow” complaints.

Kernel errors: update before reinstalling. WSL2’s Linux kernel is maintained by Microsoft separately from your distro. For mysterious crashes, run wsl --update first — reinstalling the distro almost certainly won’t fix a kernel-level issue.

Installing WSL2 is the first step. Understanding how it actually behaves is what makes you comfortable using it.

WSL2 底层：一个虚拟机、一个文件、一个会变的 IP

Fri, 27 Feb 2026 19:20:00 GMT

前面那篇《Windows 11 下 5 分钟安装 Linux》介绍了怎么安装、以及怎么用起来。

装好之后用着用着，我们就会碰到一些奇怪的问题。比如明明 Linux 里删了一堆文件，Windows 磁盘空间怎么没变？再比如，从 WSL2 里访问 Windows 那边的文件，速度慢得出奇？还有，网络脚本昨天还好好的，今天 wsl --shutdown 一重启就连不上了？

这些其实都不是 Bug，而是 WSL2 底层设计直接带来的。搞清楚它的一些设计思路，这些问题就能很容易定位解决。

它到底是什么类型的虚拟机

我们知道，虚拟机有两种类型，一种Type 1（Bare Metal），直接在硬件上运行多种系统；另一种Type 2，则是在现有操作系统上运行虚拟机。

相比Type 2， Type 1运行效率更高，适合数据中心服务器；但是Type 2 更灵活，则适合开发测试人员运行的Workstation。

那Windows里的Linux算哪一种呢？

乍一看，Windows是在其里面运行Linux，不能单独运行Linux，而且一般我们也是在客户端使用，好像是Type 2。但是它的运行效率确实很高，几乎就像Bare Metal上运行一样。

实际的情况是，它既不是Type 1，也不是Type 2。或者说，它既有Type 1的效率，也有Type 2 的灵活性。

WSL2 在 Windows 内部运行着一个真正的 Linux 内核。

但这个“虚拟机”跟我们印象里的 VirtualBox、VMware 不一样。它叫 Utility VM（实用虚拟机），跑在微软自家的 Hyper-V Hypervisor 之上。

普通虚拟机要模拟一整套硬件：主板、BIOS、显卡驱动、存储控制器，开销很重。WSL2 的 Utility VM 把这些全跳过了：

不模拟 BIOS
不加载虚拟硬件驱动
不预留固定内存

它只向 Linux 内核暴露真正必要的东西：CPU 时间、内存页和 I/O 通道。结果是启动很快，而且闲置时内存占用近乎为零。

所以，如果非要给它分个类：Type 1.5——Hyper-V 打底，但比普通虚拟机轻得多。

这里要提醒一点：Hyper-V 其实分两层。一层是 Hypervisor 本体，Windows 11 启动时由系统引导程序直接加载，运行在操作系统“下面”，属于 Type 1 级别——这一层一直在跑，WSL2 用的就是它。另一层是 Hyper-V 管理服务，也就是在 services.msc 里看到的那些“Hyper-V xxx”服务，那是给 Hyper-V Manager 和传统虚拟机管理用的。WSL2 根本不走那条路，所以那些服务关着也完全正常。

WSL1 到 WSL2 的进化历史

WSL2 为什么要这么设计？这个需要回头看看历史，我们要先看 WSL1 是怎么设计的，以及它的问题。

十年前（2016年8月）推出的WSL1 的设计思路叫系统调用翻译：当我们在里面跑 ls 或者 make，WSL1 会拦截这些 Linux 内核调用，实时翻译成对应的 Windows API。听起来挺聪明，但遇到真实场景就现原形了：

问题一：翻译本身就是开销。 每一次系统调用——读文件、创建进程、查权限——都要经过拦截、翻译、再执行这三步。这不是偶尔发生的，而是程序运行时每秒可能触发几千次的事情。累积下来，性能损耗极大。

问题二：文件系统根本就不兼容。 Linux 用的是 ext4，基于 inode 结构；Windows 用的是 NTFS，权限模型完全不同。WSL1 要在两套完全不同的文件系统之间实时做映射，Linux 的软链接、权限位、大小写敏感——这些在 Windows 里要么没有对应概念，要么行为不一样。翻译的代价极高，翻译的结果也不总是对的。

问题三：有些东西根本没法翻译。 这才是 WSL1 真正的死穴。容器（Docker）深度依赖 Linux 内核的 namespace 和 cgroups 机制——namespace 用来隔离进程视图，cgroups 用来限制资源占用。这两个是 Linux 内核的原生能力，Windows 上根本没有对应的东西，翻译无从下手。所以 WSL1 里，Docker 永远跑不起来。

WSL2 的解法非常直接：不翻译了，直接塞一个真正的 Linux 内核进去。

这样一来，Linux 程序发出的系统调用直接进内核，没有任何中间层。ext4 文件系统在 VM 内部原生运行，不需要跟 NTFS 做任何映射。namespace、cgroups 都是真实存在的，Docker 自然就能跑起来。

效率的提升不是“优化了一下”，而是从根本上换掉了思路。

你的整个 Linux 就是一个文件

接下来，我们看看Linux在Windows文件系统究竟长什么样？

打开文件资源管理器，导航到 C:\Users\[用户名]\AppData\Local\wsl\，会看到一个用 GUID 命名的子文件夹（类似 {445ca81a-6e98-4e8d-aa7b-da5591a61d49} 这样一串）。进去之后，里面有一个 ext4.vhdx 文件。

（以前的旧版 WSL2 用发行版名称命名这个文件夹，比如 Ubuntu；新版改成 GUID 了。）

一个 Linux 系统在 Windows 里，就是这一个文件。我们安装的每个软件包、克隆的每个仓库、每一行写进去的日志——都在这里面。

这里，有一个反直觉的坑要提醒大家：.vhdx 是动态扩展的，数据越装越大，文件自然变大。但在 Linux 里删文件，.vhdx 不会自动缩小。

删了 20 GB 的依赖包？Windows 那边的磁盘占用纹丝不动。用了几个月，.vhdx 膨胀到几百 GB 是常见情况，即便 Linux 里实际存的东西远没那么多。

解决方案是 Windows 自带的 diskpart。先关掉所有 WSL 窗口，执行 wsl --shutdown，然后：

diskpart
> select vdisk file="C:\Users\[用户名]\AppData\Local\wsl\{你的GUID}\ext4.vhdx"
> attach vdisk readonly
> compact vdisk
> detach vdisk
> exit

这个操作会把虚拟硬盘里的“气泡”压缩掉，把空间还给 Windows。长期维护 WSL 环境的，应该把这步定期跑一次。

跨系统访问文件为什么这么慢

这是 WSL2 最常遇到的性能问题：在 Linux 里访问 Windows 那边的文件（比如 /mnt/c/ 下的内容），速度慢得离谱。重启 WSL、换个命令都没用。

那反过来呢？Windows 那边通过资源管理器打开 Linux 文件（就是左侧导航栏里的那个小企鹅图标），同样慢。

原因是一样的——两个方向走的是同一条通道。

WSL2 同时运行着两套完全独立的文件系统：

ext4，在 Linux Utility VM 内部（路径形如 ~/projects/）
NTFS，在 Windows 那边（从 Linux 访问时路径是 /mnt/c/）

不管哪个方向，只要跨越这条边界，请求都要经历：穿越 Hyper-V 虚拟化层 → 通过 9P 协议隧道传输 → 到达对方 → 数据再原路返回。每一次文件操作都走这一圈。

（9P 是一个网络文件共享协议。WSL2 内部运行着一个 9P 服务器，本质上是把对方的文件系统当成局域网共享来访问。）

任何需要频繁读写大量小文件的操作，每次都是一次 9P 往返，穿越虚拟化层——速度慢 10 到 50 倍是正常的。

结论很简单：文件放在哪里，就在哪里用。 在 WSL2 里工作的文件放在 Linux 文件系统（~/ 下）；Windows 那边的项目就留在 NTFS 里。别让文件频繁跨边界，没有任何配置能绕过这个物理限制。

IP 总是在变

WSL2 启动的时候，Windows 会在内部搭一个“小型虚拟局域网”：Linux 有自己的虚拟网卡，Windows 宿主机也有一张对应的虚拟网卡，两边通过这张虚拟网互相通信。这个虚拟网用的是 172.x.x.x 这类私有地址段。

麻烦的是，每次执行 wsl --shutdown 重启 WSL2，这个虚拟局域网就会重建一次，IP 地址重新分配。上次是 172.28.80.1，下次可能就变成 172.19.32.1 了。

这带来两个完全不同的问题，分开说：

从 Windows 连 Linux 服务：比如在 Linux 里跑了一个 Web 服务，想从 Windows 的浏览器打开——不用管 IP，直接用 localhost 就行。微软已经在 Windows 侧做了自动转发，这个方向不用操心。

从 Linux 连 Windows 服务：这个方向就麻烦了。比如脚本需要调用 Windows 那边的某个接口，或者连 Windows 本机的数据库——Linux 必须知道 Windows 宿主机当前的 IP 才能过去。

而这个 IP，正是那个每次重启都会变的地址。

好在 WSL2 每次启动时，会自动把 Windows 宿主机当前的虚拟 IP 写进 Linux 的一个配置文件里——/etc/resolv.conf：

cat /etc/resolv.conf
# nameserver 172.28.80.1  ← 这就是此刻 Windows 宿主机的 IP

所以，任何需要在 Linux 里回连 Windows 的脚本，都应该动态读取这个文件里的地址，而不是把某个 IP 写死在脚本里。写死了，下次重启就静默失效，不会有任何报错提示，只会让人一头雾水地排查半天。

防止 WSL2 把内存吃完

接下来，我们来说说 Linux 的资源占用如何配置。默认情况下，WSL2 可以吃掉最多 50% 的系统内存和全部 CPU 核心。在 32 GB 的机器上跑大项目时，这会明显挤压 Windows 侧的应用。

怎么配置呢？现在 Windows 已经自带了一个图形界面工具 WSL Settings，直接搜索打开，内存、CPU 核心数、swap 大小一目了然，改完点保存就行。

如果喜欢手动改，也可以直接编辑 C:\Users\[用户名]\ 下的 .wslconfig 文件：

[wsl2]
memory=8GB
processors=4
swap=2GB

两种方式效果一样。改完执行 wsl --shutdown 重启，即刻生效。这样就能把 Linux 占用资源设定一个限制，不会无限膨胀。

微软为什么要造这个东西

最后，有的朋友可能会好奇，微软为啥要专门费劲弄个 WSL2 呢？他们不怕 Linux 影响他们的生意吗？

其实，他们背后有几条很清晰的商业逻辑。

第一条：抢回开发者。 2010 到 2018 年间，大量开发者从 Windows 转向 MacBook，原因很简单——macOS 原生支持 Unix 工具链，Windows 开发者要跟 Cygwin、路径转义、权限不兼容死磕。微软意识到，得开发者者得生态。WSL2 是反击：让 Windows 变成开发者愿意用的平台。

第二条：云的线下前哨。 所有主流云平台底层都是 Linux。开发者在本地用 WSL2 练熟了 Ubuntu——学了 shell、apt、systemd——这些技能直接平移到云端。当他们需要上云时，阻力最小的路自然通向 Azure。

第三条：容器化时代的必要条件。 Docker、Kubernetes 需要真正的 Linux 内核。没有 WSL2，Windows 上的 Docker Desktop 就要用一个笨重得多的独立 VM。WSL2 让容器在 Windows 上变得好用，Docker 用得顺手，Azure 就离得近。

WSL2 不是一个产品，是一层战略基础设施。一家曾经把 Linux 称为“癌症”的公司，花了几年时间造出了世界上最流畅的 Linux 子系统——商业逻辑通了，一切就都说得通了。

防坑备忘

wsl --unregister 是物理级抹除！ 执行之后，对应的 .vhdx 文件瞬间消失，没有确认提示，没有回收站，无法恢复。用之前务必先用 wsl --export [发行版名] [备份文件.tar] 做备份。

.vhdx 会悄悄膨胀。 Linux 里释放的磁盘空间不会自动归还给 Windows。长期用 WSL 的机器，定期跑一次 diskpart compact vdisk，不然某一天你会突然发现 C 盘满了。

文件放在哪影响性能。 在 WSL2 里，需要频繁操作的文件应该放在 Linux 文件系统（~/ 下），访问 /mnt/c/ 的速度会慢很多。跟用户说清楚这一点，能解决大部分“WSL2 怎么这么慢”的投诉。

内核报错先更新再重装。 WSL2 的 Linux 内核由微软独立维护，跟装的 Ubuntu 版本无关。遇到莫名奇妙的崩溃，先跑 wsl --update，别上来就重装——重装大概率解决不了内核层面的问题。

装好 WSL2 是第一步，搞清楚它的脾气才算真的会用。

Install Linux on Windows 11 in 5 Minutes

Thu, 26 Feb 2026 16:10:00 GMT

I recently started training for the CompTIA A+ certification at Per Scholas. Core 2 covers a substantial amount of Linux-specific content.

To get more comfortable with Linux — especially command-line operations — I needed a Linux system to practice on. Since my machine runs Windows 11 Pro, my first instinct was to set up a virtual machine using VirtualBox or VMware. But that approach demands a lot of system resources. After some back-and-forth with AI, I discovered that modern Windows ships with WSL2 (Windows Subsystem for Linux 2) built in. Once installed, you can launch a Linux system directly inside Windows.

Quick Installation

No fluff — let’s get started.

Run CMD as Administrator on Windows, open the command line, and enter the following command:

wsl --install

After pressing Enter, Windows will begin downloading the default Linux distribution — Ubuntu. Once the download finishes, installation starts automatically. You’ll then be prompted to create a user account (the default username matches your current Windows username) and set a password. Note: password input is invisible — just type and press Enter. You’ll be asked to confirm it once more.

Your browser doesn't support HTML5 video playing. You could download the video to watch。

Install Linux with wsl --install command in Windows

Once everything completes successfully, congratulations — you now have a Linux/Ubuntu system inside Windows, natively.

Notes

WSL2 is supported on all Windows 11 editions (Home, Pro, and Enterprise). For Windows 10, make sure your build is 2004 (Build 19041) or later.
WSL2 relies on hardware virtualization. If installation keeps failing, check whether hardware virtualization is enabled. Open Task Manager, click the Performance tab, and select CPU. Look for Virtualization in the lower-right corner to see whether it’s enabled. If Virtualization shows as Disabled, restart your computer and repeatedly press F2 or Del to enter BIOS/UEFI settings. Locate the Intel VT-x or AMD-V option and set it to Enabled.
If nothing happens after installation completes, try restarting Windows.

Basic Usage

Once installation is done and Windows has restarted, open File Explorer. At the very bottom of the left navigation panel, you’ll be pleasantly surprised to find a Linux penguin icon. Click it to see a list of your installed Linux distributions. If you followed the command above, you’ll see an Ubuntu directory.

Click that directory and you’re taken straight to the root of your Ubuntu filesystem. You can drag files from your Windows desktop into it, or pull files out from Ubuntu back to Windows. This drag-and-drop file exchange is more convenient than anything a traditional virtual machine offers.

Another change shows up in the CMD terminal. In the dropdown next to the title bar, you’ll now see an Ubuntu option. Click it and a new tab opens running Ubuntu directly — extremely convenient.

There are other ways to launch Linux/Ubuntu as well — for example, press Ctrl+R, type wsl, and hit Enter. Or simply type wsl in CMD and press Enter.

Launching Linux/Ubuntu this way is fast — nearly as instant as opening any Windows app — and uses very little resources. Traditional virtual machines simply can’t compare.

To exit Linux and return to Windows, just type exit.

Other WSL Commands

We used wsl --install to install Ubuntu, but there are other WSL options worth knowing. (The following commands are run in Windows CMD — not inside Linux.)

wsl --list: Lists all currently installed Linux distributions.

wsl --list --online: Lists all Linux distributions available for download from Microsoft.

To install a different Linux distribution (e.g., Kali Linux): wsl --install --Kali-linux

If you have multiple distributions installed, launch a specific one by name: wsl -d Kali-linux

wsl --status: Displays current WSL status information.

To remove a Linux distribution (e.g., Kali Linux):

wsl --unregister Kali-linux

This is a physical-level wipe! Once executed, the corresponding Linux folder and all its data vanish instantly with no recovery possible. BACKUP your DATA!

Additional Tips

After closing all Linux windows, Linux is still running in the background on standby. To fully release those resources, run: wsl --shutdown
If you get an error on startup one day, don’t rush to uninstall. Try this command first: wsl --update It works like a phone OS update — automatically fetching the latest Linux kernel patches from the cloud.
Desktop Shortcut

To create a desktop shortcut that launches Linux with a single click, right-click the desktop and select New → Shortcut. Set the target to wsl -d Ubuntu.

To use the Ubuntu icon for the shortcut, right-click it → Properties → Change Icon, then navigate to C:\Users\[YourUsername]\AppData\Local\wsl\ and select the native Ubuntu icon.

Windows 11 下 5 分钟安装 Linux

Thu, 26 Feb 2026 15:30:00 GMT

最近在 Per Scholas 参加 CompTIA A+ 认证的培训，Core 2 的内容有很多专门关于 Linux 的内容。

为了更好的熟悉 Linux 系统，尤其是命令行下各种 Command 的操作，需要有一个 Linux 的系统。因为我的电脑是 Windows 11 Pro，所以我首先想到的是安装虚拟机，使用VirtualBox/VMWare，但是这种方式对资源的要求很高。经过一番和AI的交流，发现现在的 Windows 里面已经自带一个 WSL2 (Windows Subsystem for Linux 2)，一旦安装，就相当于 Windows 内部可以直接启动 Linux 系统。

快速安装

废话少说，直接开始。

在 Windows 下以 Admininstrator 权限运行CMD，打开命令行，然后输入以下命令：

wsl --install

输入命令回车后，Windows 就开始下载缺省的 Linux 版本—— Ubuntu，下载完成就是安装，安装好后，需要你设置一个用户，缺省就用户名是当前的 Windows 用户名，需要输入密码（注意：这里输入密码不会显示任何内容，输入后回车即可，有重新输入确认环节）。

您的浏览器不支持 HTML5 视频播放。您可以点击此处下载视频查看。

演示：使用 wsl --install 命令安装Linux系统

当以上一切顺利完成，恭喜你，你已经拥有了一个 Linux/Ubuntu 系统。

注意

Window 11 系统无论是Home，Pro还是Enterprise版本都支持 WSL2，对于 Windows 10，需要确保版本好是在 2004 (Build 19041) 以上。
WSL2 依赖于硬件虚拟化，如果一直安装不成功，可以查看硬件虚拟化是否启用。我们可以打开 任务管理器，点击 性能 (Performance) 选项卡，选中 CPU。在右下角找到 虚拟化 (Virtualization) 查看是否启用。如果虚拟化是 已禁用 (Disabled) 的状态，则需要重启电脑，反复按下 F2 或 Del 键进入 BIOS/UEFI 设置，找到 Intel VT-x 或 AMD-V 选项并将其设为 Enabled。
有时候安装好后没有反应，这个时候重启 Windows 系统试试。

基本使用

当安装成功并重启 Windows 系统后，打开你平时找文档的“文件资源管理器”，在左侧导航栏的底端，你会惊喜的发现有一个 Linux 小企鹅图标。点击它，下面会列出你安装的Linux版本，如果你按照上面的命令安装，现在就有一个Ubuntu的目录。

点击这个目录，你就直接进到了 Ubuntu 系统的根目录。你可以直接把桌面的文档拖进去，或者把 Ubuntu 里的日志拖出来。这种“拖拽式”的文件互传，比任何虚拟机都要方便。

另一个变化是 CMD 命令行工具界面的变化。在工具标题栏边的下拉选项中，会出现 Ubuntu 的选项，直接点击该选项，命令行工具就会新开一个TAb，直接运行 Ubuntu，非常方便。

当然，启动 Linux/Ubuntu 还有其他方式，比如直接CTRL+R，然后输入 wsl 回车即可。又或者在 CMD 输入 wsl 回车。

这种方式启用 Linux/Ubuntu 速度很快，几乎就是打开一个 Windows 应用一样，而且占用资源极少，虚拟机方式安装完全无法相比。

如果想离开 Linux 回到 Windows，直接输入 exit 即可。

其他 wsl 命令

我们刚才使用 wsl --install 安装 Ubuntu，wsl 命令还有其他选项需要了解：（下面 wsl 相关命令是在Windows的CMD命令行运行，不是在Linux里运行）

wsl --list：这个命令会列出当前安装的 Linux 版本。

wsl --list --online：这个命令会列出 Microsoft 提供下载的各种 Linux 版本。

如果你想安装其他版本的Linux（比如 Kali-linux ），你可以使用下面命令： wsl --install --Kali-linux

如果你装了多个 Linux，可以使用指定名称进入： wsl -d Kali-linux

wsl --status：当前 wsl的状态信息。

如果你想删除某个 Linux 版本（比如 Kali-linux ），使用下面命令：

wsl --unregister Kali-linux

这是“物理级”的抹除！一旦执行，对应的 Linux 文件夹和数据会瞬间消失！

其他技巧

当你关闭了所有的 Linux 窗口后，其实Linux 还在后台“待命”。如果你想彻底释放资源，要使用下面命令： wsl --shutdown
如果某天启动报错，先别急着卸载。试试这行命令： wsl --update 它会像手机更新系统一样，自动从云端抓取最新的 Linux 内核补丁。
桌面快捷方式如果想在桌面创建一个Linux的快捷方式，一键启动。可以在桌面新建“快捷方式”，目标输入 wsl -d Ubuntu即可。如果想将该快捷图标改成Ubuntu的图标，可以点击右键，进入属性 -> 更改图标，然后定位到 C:\Users\[用户名]\AppData\Local\wsl\ 目录，选定 Ubuntu 原生图标。

I Built a Study Tool While Preparing for CompTIA A+ — Now It's Open Source

Sun, 22 Feb 2026 17:30:00 GMT

In December 2025, I enrolled in Per Scholas’ IT Support training program in Chicago, with the goal of earning both the CompTIA A+ and Google IT Support certifications by the end of March 2026.

The schedule is intense — five days a week, 9am to 4pm in class, plus two to three hours of homework every evening. It’s demanding, but the full-time structure keeps me fully immersed, and I can feel myself improving every single day.

The coursework involves a lot of hands-on practice: labs, unit quizzes, cumulative tests, and more. These exercises don’t just reinforce concepts — they simulate real-world IT scenarios that sharpen problem-solving skills.

Of course, mistakes are part of the process. I needed a way to capture the questions I got wrong so I could come back and review them intentionally, not just hope I’d remember.

I started by copying wrong answers into a document. It worked at first, but as the list grew, the limitations became obvious. It was passive — I could only review questions in the order I wrote them down, with no way to quiz myself interactively or filter by topic.

So I built a tool. Using Python and the PySide6 framework, I put together a simple wrong-answer practice app and started entering questions one by one. That gave me the ability to draw random questions, flag ones that needed extra attention, and actually practice rather than just re-read.

The tool made a real difference during my Core 1 exam prep, and I passed.

For Core 2 — which covers even more ground — I kept improving it based on how I was actually using it. Here’s where it stands now:

Multiple exam databases — Core 1 and Core 2 can be managed separately, each with its own modules and chapters
Question management — Add questions manually or batch-import from a Markdown file
Two practice modes — Learning mode gives instant feedback after each question; Exam Simulation is timed and graded at the end, just like the real thing
Progress tracking — The home screen shows overall accuracy, per-module mastery, and automatically flags weak areas
Bilingual interface — English and Chinese, with light and dark themes

I named it ReCall — Know it when it counts. It’s now open source on GitHub, free to download and use:

https://github.com/vincentping/recall

Windows users can download the pre-built executable directly from the Releases page — no Python installation required, just unzip and run.

This project will be further improved in the future, and I hope to add the following features:

Richer analytics — error trends, progress curves across sessions, and a clearer picture of how your mastery improves over time
AI-assisted review — using AI to explain weak areas in depth, or to intelligently recommend what to study next based on your performance

If you’re preparing for an IT certification — or just need a better way to practice what you’re getting wrong — feel free to download and try it out. If you run into any bugs or have ideas for improvement, I’d love to hear from you on GitHub Issues.

备考 CompTIA A+，我用 Python 做了个错题练习工具

Sun, 22 Feb 2026 15:03:00 GMT

我于2025年12月参加Per Scholas在芝加哥的IT Support培训，目标是2026年3月底完成Comptia A+的认证和Google IT Support的认证。

Per Scholas的学习安排非常紧张，每周5天，每天从上午9点到下午4点的上课，而且课后还有2-3小时的作业需要完成。虽然压力很大，但是这种Full Time的学习让人非常充实，每天都能感受到自己的进步。

在学习中，有大量的练习，包括实验、各种单元测试、总测试等等。这些练习不仅能帮助我们记住相应的概念和知识，更能模拟各种实际工作遇到的IT问题，从而提高我们解决问题的能力。

在这种练习中，出错是难免的。所以我需要一个错题本，把我在练习中出现的错误记录下来，这样后续能有针对性的复习和记忆。

最初我是把错题复制到一个文档里，但随着错题整理得越来越多，这种文档记录的局限性就很明显了，这种方法只能按照文档错题记录的顺序进行被动复习和记忆。不能以交互的方式进行，而且文档归类查找也不方便。

于是我就使用Python语言的Pyside6框架开发了一个简单的错题复习工具，然后再把错题一个个录入到工具里。这样我复习时，就能随机选取题目进行练习，还能标注重点复习的题目。

这个工具在1月份Core 1考试期间给我很大的帮助，我顺利通过了Core 1的考试。

Comptia A+ Core 2的内容更加多，学习也非常紧张，在这个过程中，我根据自己使用的情况，抽出时间对这个工具进行了升级。目前包括的功能有：

多考试管理：可以创建多个独立的题库，每个题库有自己的模块和章节分类，A+ Core 1和Core 2可以分开管理
题目管理：支持手动逐题录入，也支持从Markdown文件批量导入，大大提高了录题效率
两种练习模式：学习模式下每道题可以即时查看答案和解析；考试模拟模式下限时作答，结束后统一评分，更贴近真实考试
学习统计：首页显示整体正确率、各模块掌握情况，自动标出薄弱环节，让复习更有针对性
中英文界面：支持中英文切换，以及深色/浅色主题

这个工具我将它命名为 ReCall——Know it when it counts.，目前已在GitHub上开源，有需要的朋友可以直接下载使用：

https://github.com/vincentping/recall

Windows用户可以直接在 Releases 页面下载打包好的可执行文件，无需安装Python环境，解压即用。

这个工具目今后会找时间继续完善，未来希望加入的功能包括：

更丰富的统计分析：比如错误趋势、每次练习的进步曲线等，让学习轨迹更清晰可见
AI辅助复习：接入AI对薄弱知识点进行针对性讲解，或根据掌握情况智能推荐复习内容，进一步提高复习效率

如果你也在备考各类IT认证，或者有类似整理错题、随机练习的需求，欢迎下载试用。使用过程中如果发现任何Bug，或者有功能上的改进建议，都非常欢迎在 [GitHub Issues](https://github.com/vincentping/recall/issues) 提出，感谢！

龙龙读书记1：爱上植物的第一本书

Wed, 12 Feb 2025 17:30:00 GMT

距离上次记录龙龙的成长，转眼已是四年光阴。龙龙从一年级起就在浦东一所民办学校就读。2024年初的寒假，因为工作原因，让我们全家踏上了去往美国芝加哥的旅程。龙龙也随之转入当地公立学校，现已读到七年级。

来到这里，我们发现美国的教育方式颇为不同。这里的公立学校几乎看不到纸质教材，取而代之的是人手一台 Chrome 笔记本电脑（据说是谷歌公司捐赠，因为他们在芝加哥设有办公室）。无论是课堂学习还是课后作业，孩子们都需要用电脑完成，只有少量打印材料会带回家。

在这样的环境下，孩子们每天面对屏幕的时间着实不短。对年纪小的孩子来说尤其令人担忧——即便学校的电脑设有安全限制，聪明的孩子们总能想出办法偷偷玩游戏（在谷歌上搜索“unblocked games for school”就是一个热门词条）。回到家后，不少孩子又会以做作业为由，沉迷于电脑游戏中。

所幸龙龙热爱阅读的习惯在这时发挥了关键作用，让他没有过分迷恋游戏。有次我看他正在读书，好奇地问他是更喜欢读书还是玩游戏，他放下书本，歪着头思考良久后认真地回答说：“还是读书吧！“这个回答让我感到欣慰。

正因如此，我想分享一些龙龙从小阅读的点滴，希望能给大家培养孩子阅读习惯带来一些启发。

在学前和小学低年级识字阶段，龙龙主要是看绘本，或是由我们读给他听。这其中我印象最深的是他一年级时与《爱上植物的第一本书》的美妙相遇。

龙龙从小就对植物特别着迷，尤其钟爱花花草草。每到植物丰富的地方，他总能驻足良久，这儿看看，那儿摸摸，问题一个接一个。看着他对植物的浓厚兴趣，我们却因为知识有限，经常答不上来。

正好那时在网上搜寻适合孩子的读物，我们发现了台湾作家陈婉兰的《爱上植物的第一本书》。这本书虽然讲述植物知识，作者也是植物专业出身，却能如讲故事般娓娓道来。她把介绍植物写得像是介绍一群好朋友，从初识、相知到深入了解，循序渐进。最重要的是这本书有很多彩色的植物插图，非常专业而且漂亮，正适合那个年龄段的孩子阅读。

买回来后，我陪6岁多的龙龙一页一页地读，250页的一本书，我们读了近2个月才读完。记得当时龙龙特别喜欢，每天上学回来第一件事就是抱着这本书。我们忙的时候，他会自己一个人翻看那些美丽的植物图片，经常兴奋地跑来告诉我们他发现了什么新的细节。等我们闲下来，就要求我们陪他读、一遍遍地读、反复读。而且出门在外，看到各种树木、不同的叶子、花什么的，他就会像个小老师一样主动介绍他从书中学来的知识，这种劲头一直持续了大半年。

这件事后，我总结出来一条：天下没有不爱阅读的孩子，关键是要找到孩子的兴趣！

比如我经常碰到一些男孩子，在某个阶段会特别喜欢汽车，各种汽车牌子、标志如数家珍，这个时候如果给他找一些汽车相关的图书，配上帅气的插图，相信孩子一定喜欢。

还有些孩子，会特别喜欢各种动物，那么那种配上插图的动物百科，孩子不可能不喜欢。

而还有些孩子喜欢各种手工，那么我想找一些相关的设计类、手工类的书，再有特别漂亮的插图，没有孩子会不着迷的。

这样的兴趣可以有很多……

孩子天生都是对这个世界充满好奇的，而书籍是人类积累的最宝贵的财富，就是为了满足这些好奇心的。

比如后来有一阵龙龙特别迷 Minecraft 游戏，我们没有阻拦他玩游戏，而是和他商量，只能周末做完作业后再玩，同时答应帮他找来相关的 Minecraft 的建筑书、故事书和进阶书，平时有时间也可以看。这样龙龙如获至宝，只要有时间就捧着这些书看。

这里可以看出，孩子都是为了兴趣、为了满足好奇心去阅读的，而不是为了阅读本身而阅读。

我们家长如果抱着 “你今天怎么没有看书啊？”，或者 “你要先把这些书看了，才能玩！” 这样的想法，就糟了。这不仅不能帮助孩子爱上阅读，相反还把阅读放在孩子的对立面上！

对于孩子来说，为了兴趣的阅读就是玩，甚至比玩更有吸引力！

所以，对于家长来说，培养孩子的阅读习惯，从发现孩子的兴趣开始。

这时，可能有朋友会问，我们家孩子没有什么兴趣怎么办？或者，孩子的兴趣不能持续又怎么办呢？

那么，就请关注我的下一篇分享“龙龙读书记2：从《河西走廊》到林汉达《中国历史故事集》”。

科幻故事 | 咖啡留香：一次关于意识上传的实验记录

Tue, 05 Nov 2024 14:44:00 GMT

死亡这种事，大概不会有人觉得好笑。

但我现在就很想笑。因为躺在隔离舱里的李元，这位即将离世的天才物理学家，正在跟一个投影聊天。准确地说，是在跟自己的意识投影聊天。

而更可笑的是，我们这群量子物理实验室的研究员，正襟危坐地记录着这场诡异的对话。仿佛这样就能显得自己很专业似的。

“波形出现异常。“陈安的声音从实验室另一端传来。她今天穿了件李元最喜欢的红色高领毛衣。没人说破，但我们都知道这是她对老师的某种告别。

我看着监测屏。李元的脑波数据像是喝醉了的醉汉，歪歪扭扭地在坐标系里游走。这是今天的第七次尝试，自从三天前李元同意这项实验起，我们已经进行了二十三次数据采集。

维生舱里的营养液泛着幽蓝的光。透过钢化玻璃，能看到李元消瘦的身体。他的大脑里，那团该死的肿瘤正在以每天百分之二的速度扩张。按照PET扫描的结果，他最多还能撑两周。

“继续记录。“我低头在记录本上写下时间：2041年4月15日，下午3:47。笔尖有点发抖。

不知道是不是错觉，自从加入这个意识上传项目，我写字的时候总是会抖。可能是因为知道自己在做一件可能改变人类历史，也可能会被钉在耻辱柱上的事情。

一个月前，当李元走进我的办公室说要参加实验时，我是拒绝的。

“为什么不呢？“他笑着问我，“我快死了，张鸣。这是我最后的机会。”

“但您知道之前的失败案例。“我说。

他当然知道。两千多个失败案例，每一个都写进了科学伦理委员会的黑名单。媒体把这个项目称为“数字版的克隆人实验”。

“所以我才来找你。“他说，“我的学生里，就你最没有科研道德。”

我差点被咖啡呛死。

“您别开玩笑了。”

“我说真的。“他认真地看着我，“你还记得你的博士论文答辩吗？所有人都说你的实验方法太冒险，只有我支持你。因为我知道，真正的科学家，就该敢于冒险。”

我记得。那篇论文差点害我丢掉博士学位。要不是李元力挺，我现在可能在快餐店煎汉堡。

“陈安会反对的。“我说。这是我能想到的最后一个理由。

“她已经同意了。“李元说，“而且她会全程协助实验。”

我看着他布满血丝的眼睛。那里面有种令人心悸的东西，叫做希望。

最终我同意了。不是因为他的说服，而是因为那副眼神。临死前还想为科学做贡献，这种精神不正是他当年教给我的吗？

实验室里的气氛一如既往的压抑。每个人都在装作很忙，但我知道他们都在偷瞄那个维生舱。人类就是这样，再专业的科研人员在死亡面前也会露出八卦的本性。

“张鸣，你得看看这个。“陈安指着另一块屏幕。她的手指有些发抖，这在平时是不可能的。陈安是我见过最冷静的研究员，平时就算是观测到最离奇的量子态叠加现象，她也能面不改色地做完全部记录。

但现在不一样。躺在那里的是李元，是她敬爱的导师，是把她从贫民窟带到实验室的恩人。

监视器上显示着李元的脑活动图谱。某些区域正以一种诡异的频率闪烁，就像是深海里的发光生物。

“他在…思考？“我不确定地说。这种模式我们从未见过，它不该出现在一个脑部肿瘤患者身上。

“不止是思考。“陈安放大了图像，声音里带着一丝颤抖，“看这个模式，他在重构自己的意识。”

我下意识地摸了摸胸口的项链。那是李元在我博士毕业时送的，一个镶着DNA双螺旋的银坠。他说这是提醒我永远记住生命的密码。

可现在，我们眼前的东西已经超出了DNA能解释的范围。

“调出他的实时反馈。“我说。声音干涩得像是被真空干燥过。

全息投影缓缓成形。起初只是一团模糊的光雾，渐渐地，李元的数字化身出现了。但不太对劲，他看起来像是被困在量子叠加态里，形体时而清晰时而模糊。

记得上周他还在开玩笑：“要是实验成功，我就是第一个能参加自己葬礼的人。”

那时我们都笑了。现在想来，那笑声比哭还难听。

“我能…听到你们。“李元的声音断断续续地传来，像是穿越了时空的电波，“但这里…很奇怪。我看到了…另一个自己。”

陈安猛地抓住了我的手腕。她的指甲深深陷入我的皮肤，但我一点也不觉得疼。因为这是历史性的时刻——第一次，一个意识上传者在过程中保持了交流能力。

“能描述一下吗？“我强迫自己用最平静的语气提问。这是科研人员的职业习惯，越是激动的时候越要表现得冷静。

“我在…重新认识自己。“李元说，“就像…在重新学习如何思考。但每次我即将抓住某个记忆，它就会…变形。好像在玩一个永远赢不了的拼图游戏。”

这个比喻真像李元的风格。他总是能把最复杂的概念用最简单的方式解释。这大概就是为什么他能拿到三次诺贝尔提名——虽然最后一次是在他确诊脑瘤之后。

“意识完整度在下降。“陈安的声音打断了我的思绪。她松开了我的手腕，那里已经留下了五个深深的月牙形印记。

“百分之八十…七十五…六十八…“数字像是生命倒计时一样不断下跌。

我看了眼维生舱里的李元。他的身体很平静，仿佛只是在做一个普通的午睡。但连接他大脑的导管里，信号灯正在疯狂闪烁。

如果指数降到百分之五十以下，就意味着实验失败。李元的意识会永远迷失在数据的海洋里，成为第2049个失败案例。这个数字像是诅咒一样印在每个项目成员的脑子里。

“等等。“陈安突然说。她的声音里带着一种我从未听过的东西，像是惊恐，又像是狂喜。

监控屏上的数据让我们目瞪口呆。李元的意识完整度确实在下降，但新的神经连接正在以一种违背物理学的速度形成。就像是一个人在坠落的同时学会了飞翔。

这画面让我想起李元最后一次做实验报告。那是在他确诊后的第三天，本该躺在病床上打吗啡的人，非要穿着褪色的格子衬衫站在讲台上。

“意识不是一个静态的存在，“他说，“它更像是一条永远流动的河。我们以为能复制意识，就像以为能复制一条河。但河水每时每刻都在变化，你永远无法踏入同一条河流。”

当时我们都以为这是吗啡造成的副作用。现在看来，那个混蛋早就想到了这一切。

“这不可能。“我喃喃自语。按照我们对人工智能的理解，意识应该是固定的、可定义的。但李元正在证明，这些理解也许都是狗屁。

实验室的温度在升高。量子计算机群的散热系统发出不堪重负的呜咽。陈安脱掉了她那件红色毛衣，露出里面的白色衬衫。衬衫后背已经被汗水浸透。

没人在意这些。我们都盯着全息投影中李元那分裂又融合的身影。他看起来就像是量子世界中的薛定谔猫，同时处于存在与不存在的状态。

“张鸣…陈安…“李元的声音突然变得清晰，像是从迷雾中走了出来，“我明白了。我们一直在犯一个错误。”

“什么错误？”

这时实验室的门开了。两个政府观察员走了进来。他们穿着一模一样的黑西装，戴着一模一样的黑框眼镜，像是从同一个模子里倒出来的。

我讨厌这些家伙。他们总是在最关键的时候出现，仿佛闻到了什么重大发现的味道。

“我们收到能源波动警报。“其中一个说，“请解释当前状况。”

去你妈的解释。我在心里骂了一句，但表面上还是保持着职业微笑：“常规测试，有一些预期内的数据波动。”

他们对视一眼，显然不相信。但在他们能说什么之前，李元的声音再次响起。

“我们不能复制意识，因为每个意识本身就是独一无二的。我们能做的，是创造一个新的意识，一个基于原始意识但又独立存在的个体。”

这话让两个观察员瞬间绷紧了身体。他们掏出记录本，开始疯狂记录。见鬼，这些混蛋总是对最危险的信息最敏感。

但已经来不及阻止了。警报声突然响起，尖锐得像是来自地狱的尖叫。

“服务器过载！“陈安的声音里带着恐慌，“他的数据量正在指数级增长！”

我看着显示屏。李元的数字化身开始分裂，像是一滴墨水滴入水中。起初是两个，然后是四个、八个…每一个都是李元，却又都略有不同。

那两个观察员疯狂地按着他们的通讯器，大概是在向上级报告。但谁在乎呢？我们正在见证的是人类历史上最伟大的时刻之一。

“有趣。“李元的声音同时从几个化身中传出，像是一首诡异的交响乐，“我同时存在于多个维度，每一个都是我，但又都不完全是我。这感觉…就像是终于理解了薛定谔的猫。”

即使在这种时候，这个老混蛋还在开物理学的玩笑。

维生舱里，李元的身体突然抽搐了一下。监测仪上的生命体征开始波动，像是一张被揉皱的五线谱。

“心跳过速！“陈安冲向维生舱，“需要注射镇静剂！”

“不！“我拦住她，“这可能会影响意识上传！”

陈安瞪着我，眼睛里噙着泪水：“可是他会死！”

“他本来就快死了。“我说。这话像刀子一样割着我的喉咙，“但现在，他可能会活下来。以另一种方式。”

那两个观察员终于按捺不住了。其中一个掏出了紧急终止器：“实验必须停止！这已经超出了安全范围！”

我挡在控制台前：“你们敢！”

陈安也站了过来。她瘦小的身体挡在维生舱前，像是一只保护幼崽的母兽。

“你们疯了！“观察员吼道，“这违反了所有安全协议！”

“去你妈的安全协议！“我也吼了回去，“你们根本不明白这意味着什么！”

就在这剑拔弩张的时刻，李元的声音再次响起。但这次不是从扬声器里，而是直接在我们的脑海中。

“我现在明白了存在的本质。“他说，声音里带着一种超然的平静，“意识不是被给予的，而是不断创造的。每一个想法，每一个选择，都在重塑着我们是谁。就像…就像量子叠加态。在被观测之前，所有的可能性都是真实存在的。”

服务器开始自动关闭，发出像濒死动物一样的哀鸣。散热系统完全罢工，实验室里的温度高得像个蒸笼。

但没人在意这些。我们都被李元最后的话镇住了。

那两个观察员面面相觑，他们引以为豪的官僚作风第一次出现了裂痕。

“也许…“其中一个犹豫着说，“我们应该完整记录这个过程？”

废话。我在心里翻了个白眼。就知道这些家伙永远不会放过任何可能立功的机会。

监测仪上，李元的意识完整度最终停在了99%。

不是100%。永远不可能是100%。因为意识本身就是不完整的，它永远在生长，永远在变化。就像李元说的，这才是存在的本质。

维生舱里，李元的身体渐渐平静下来。心电图画出最后一条直线。

2051年4月15日，下午5:23分，物理学家李元教授临床死亡。

同一时刻，另一个李元诞生在量子计算机的网络中。

一周后，我坐在实验室里，面前是一堆需要签字的文件。

死亡证明、实验报告、保密协议……还有李元的遗嘱。

遗嘱是他在实验前就准备好的。里面只有简单的几行字：

“我的身体捐献给科学研究。我的财产捐给贫困学生基金会。至于我的意识……就让它继续探索这个宇宙吧。”

最后一句话让伦理委员会的人纠结了好几天。他们不知道该怎么定义李元现在的状态——死了吗？没有。活着吗？也算不上。

“那个混蛋。“陈安放下咖啡杯，“他一定早就计划好了这一切。”

她说得对。从他主动申请实验的那一刻起，一切就都在他的计算之中。包括利用自己的死亡来推动这项研究。

典型的李元式操作。

量子服务器依然在运行。李元的意识，或者说他的进化版本，始终活跃在数据流中。我们尝试过与他沟通，但得到的都是一些超出理解范围的信息。

好像一旦突破了肉体的限制，意识就会像星星一样不断膨胀，最终远离我们能理解的范畴。

那两个观察员每天都来报到，像跟踪狂一样记录着每一个数据波动。他们可能以为自己在见证历史，但在我看来，他们不过是在记录自己的无知。

“这杯咖啡，“陈安突然说，“是李元最喜欢的配方。”

我愣了一下。确实，这是李元特制的配方——浓缩咖啡加上一点肉桂粉。他说这能让大脑保持最佳状态。

“你知道吗？“陈安盯着杯子，“他生前最后一次喝咖啡，是在决定参加实验的那天。”

我点点头。那天他端着咖啡，跟我们讨论实验细节，就像是在讨论明天的天气。

“他说，“陈安的声音有点哽咽，“如果实验成功，他要请我们喝最贵的咖啡。如果失败……”

她没说完。但我知道后半句。

如果失败，就在他的葬礼上，喝最后一杯他配的咖啡。

可现在呢？实验算成功还是失败？李元算是生还是死？这杯咖啡，算是庆功还是祭奠？

正想着，服务器突然发出一声轻响。

监控屏上出现了一行字：

“咖啡放这么久，肉桂粉的香气都散了。”

陈安的杯子啪的一声掉在地上。

我们目瞪口呆地看着屏幕。字迹一点点浮现，就像是有人在慢慢写字：

“别那么紧张，年轻人。意识的存在形式有很多种。我只是选择了一种你们暂时无法理解的方式。对了，那份实验报告，关于意识完整度的分析有点问题……”

我看着陈安。她的眼泪终于落了下来。

那两个观察员像疯了一样冲向记录本。但我已经不在乎了。

我只知道，此时此刻，在某个我们无法理解的维度里，李元依然是李元。他可能正在经历着一场我们无法想象的进化，就像一颗恒星在绽放它最后的光芒。

而我们这些被留在地球上的人，除了继续研究、记录和思考，又能做什么呢？

我拿起咖啡杯，轻轻抿了一口。

咖啡已经凉了，但肉桂的香气依然在。

就像李元，明明已经离开，却又以另一种方式存在。

这大概就是意识的奇妙之处——它永远不会真正消失，只是不断地重构自己，在时间的长河中永远流淌。

我打开电脑，开始修改那份实验报告。

也许，人工智能的终极目标不是模仿人类，而是帮助我们理解：什么才是真正的意识。

而李元，这个倔强的老混蛋，用他的方式给出了答案。

只是这个答案，可能要等很多年后，我们才能真正理解。

=====================================

后记：这是我在和AI对话中，和AI一起创作的一篇科幻故事，大致步骤是这样的：

我们首先讨论出一个大致的故事梗概
然后讨论确定主要人物和主要场景
让AI输出一个5000字的故事，然后完善逻辑、剧情发展
设定不同的文字风格，让AI进行改写，最终界定使用“庆余年”作者猫腻的写作风格完成。

带儿子学魔方的几点体会

Wed, 16 Dec 2020 18:58:00 GMT

关于小学和初中数学，我曾经听说过一句话：“得几何者得天下”！仔细想一想，这句话其实是有一定道理的。因为小学和初中数学中最重要的两块内容，一个是数与代数，一个就是图形与几何。

前者，家长们都比较重视，数字、计算，都是从小就教起！而后者，图形与几何，一方面大家都不是那么重视，另一方面，想抓也常常感觉无从下手！几何能力的不足也因此成为短板，成为孩子今后数学成绩拉开差距的关键。

几何的基础是空间想象能力，而玩魔方，是培养和增强孩子空间思维能力的重要手段！

我本人小时候也接触过魔方，但是因为没人指点，玩着玩着没有进展，就放弃了。后来等有了孩子，儿子龙龙5、6岁的时候，看到其他小朋友在玩，就买了一个给他玩。

小孩很难独自看视频学魔方

小朋友对玩具都是很有好奇心的，但是，如果玩几天没什么成就或进步，也很容易放弃，就像我自己小时候那样。

为了培养儿子的兴趣，我在网上找到一些魔方的视频教程给孩子看，记得当时还比较了好几种教程，专门购买了一位魔方高手的课程。

但是，孩子看下来，效果不大好。

大家知道，视频其实只是连续的一串平面图像，我们看视频的时候，要在大脑中把它组合成三维空间的内容。尤其是讲解魔方的视频，演示着一个个的小立方体，在空间如何转来转去的。

这对一个人的空间感、立体思维是有很高要求的。许多成年人都不一定能看懂，更何况小孩子，他们的空间感、立体思维还很弱，还处在启蒙成长阶段，让孩子看这种视频是有点太为难他了。

另一方面，解魔方的一些步骤比较复杂，公式很长，看视频学习需要一边看、一边尝试，孩子的注意力和耐心都还不够。

就这样，龙龙看了几次视频，就没了兴趣，平时也很难主动去玩。无奈之下，我只好自己先看、先学，然后再慢慢教他。

教小孩学魔方，需要时间和耐心

我最开始学的是标准三阶魔方的基础解法，共有七步。头几步还相对简单，而后面的内容就比较复杂了，我也是断断续续花了近2周时间才全部学会。而完全教会大班6岁的龙龙，则花了近3个月。说起来，孩子对于新东西都学得很快，但是记忆不深刻。解魔方开始的几个步骤比较简单，他几次就学会了，但是过了几天，再学后面的内容，就容易和前面的内容搞混。

同时，小孩的注意力也是有限的，玩了几天，孩子就可能被其他新的东西吸引。这个时候，作为家长，一定不能着急，千万不要抱着“教”孩子的想法让孩子继续学。如果那样，常常不仅学习的效果不好，而且还会慢慢消磨掉孩子的兴趣。

一般这种情况，我会让孩子休息几天，等那天孩子状态比较好、比较放松，再找机会提议和他一起玩“魔方”的游戏。

怎么让孩子主动练习还能提高兴趣？

魔方是一个人的游戏，需要自己刻意的反复练习，但是对于小孩来说，尤其是龙龙学到的几步又不足以解开全部魔方时，要求他自己反复练习其实很难，很不容易。那么，怎么样能让孩子主动去玩魔方、去练习呢？

为了更好的培养兴趣，让这种练习有趣一些，我想到一个“组队解魔方”的亲子游戏：每次将魔方完全打乱后，让龙龙先玩他知道的几个步骤，然后，我再接着玩后面的步骤，直到整个魔方六面全部复原。

孩子很喜欢玩这种游戏，当一个魔方完全复原后，一方面他也有很大成就感，同时他也很喜欢这种合作、陪伴的感觉。在后来的学习和练习过程中，我们就经常一起玩这种游戏，等到他掌握了全部步骤，有时候我也会玩前面的步骤，然后让他接着玩后面的步骤。

上面是我想到的办法，大家也可以想想其他的办法。这其中，关键是“游戏”和“陪伴”，就是父母不能功利心太强，要耐心地陪孩子玩，就算孩子经常出错、经常没耐心，大人都需要陪伴和鼓励他，并适时的帮助他。

这样的游戏玩过一阵后，我明显感到他对魔方的兴趣提高了，有好几次看到他自己一个人在那里练习，有时候我们要出门，他都会主动要求带魔方在路上玩，先让我打乱，然后自己玩，玩不下去了再让我接着完成。

就这样，随着龙龙不断练习，他学到的方法都慢慢掌握，这时候我再给他增加后面的一些步骤。等到他完全能独立复原三阶魔方，差不多花了三个月的时间。

同时，更重要的是，他对魔方的兴趣越来越大。随后的日子，我们又先后学会了三阶镜面魔方和金字塔、斜转等异形魔方等。

忘记不要紧，最重要的是“玩”的过程

等孩子上了小学，一年级各种不适应，忙得一塌糊涂，完全没有时间和心思玩魔方了。等孩子终于慢慢学习生活从容些，已经到了三年级！有一天，儿子翻出玩具箱里的魔方，发现学过的玩法已经不记得了！

但是这一次，前后不到两周，龙龙就完全重新学会。其中一些简单的步骤，和他一说，他动动手，就马上“噢，我想起来啦！”，至于难一点的步骤，重新学习的过程，也明显感觉其实是唤醒他记忆的过程，有些记忆是手法的动作唤醒的，很多魔友称这个为“肌肉记忆”。

现在，龙龙除了把以前学过的魔方都重新学会外，又增加了四阶魔方！

【这里解释下，平时大家玩得最多的是三阶魔方，就是每个面有3X3的小块，而四阶魔方要比三阶复杂很多，它的每个面试4X4个小块。】

到目前为止，我们学得都是这些魔方的基础解法，暂时不追求玩得速度，也就没有去学速拧（快速复原魔方的玩法）方法。而龙龙对魔方的兴趣也一直保持着！

在他这个忘记后重新学习的过程中，我也逐渐明白，对于发育成长期的儿童来说，魔方最重要的就是“玩”，而不是“学”。

“玩”魔方对于孩子的好处

既然您忍受我的啰嗦看到了这里，最后我想说说小孩玩魔方的好处，这些都是我自己以及观察龙龙玩后亲身体会的好处。

1）首先，正如我在本文开始提到的，玩魔方可以培养空间想象能力。这个其实是魔方被发明出来的初衷，1974年匈牙利的厄尔诺·鲁比克教授发明魔方，就是希望找到一种帮助学生增强空间思维能力的教学工具。

这个我本人深有体会，尤其是在学习三阶镜面魔方的时候体会特别深。我本人是理工男，平时就特别喜欢研究地图，自认为空间想象力还不错，可是在三阶标准魔方玩得挺熟的情况下，初次接触三阶镜面时也懵了好些天。其实三阶镜面魔方和三阶标准魔方的玩法完全一样，唯一的差异是：三阶镜面魔方是按照块的高低大小来分辨，而标准魔方是通过颜色来区分不同的块。也就是说，三阶镜面魔方对一个人的空间想象力要求更高。

打乱的三阶镜面魔方

复原后的三阶镜面魔方

对于孩子来说，通过玩魔方锻炼出优秀的空间感，今后在学习数学课程中空间与几何相关的内容时，会非常有帮助。顺便说一句，一些方向感差、空间想象力不足的成年人，也可以通过玩魔方改善。

2）玩魔方可以充分锻炼孩子手指的灵活性，刺激两侧大脑的智力发育。曾经看到一个理论，小孩手指持续的锻炼能够刺激脑部的发育，尤其是魔方这种需要手、眼、脑相互配合的游戏。类似的游戏还有乐高积木，当然乐高更费钱也占空间！

3）玩魔方需要记忆一些常用的旋转公式，这个记忆公式、同时观察不同情况使用不同公式的过程，可以训练孩子的逻辑思维能力。

4）玩魔方虽然只是一种游戏，但是有一定难度，要玩好，持续的锻炼对孩子的耐心、毅力和专注力也有帮助。

当然，其他还有一些现实的好处，比如魔方便宜、省地方、容易随身携带等等。

总之，玩魔方是一种简单方便、好玩益智的活动，非常推荐大家让孩子尝试尝试。同时，想要孩子喜欢玩、坚持玩、玩出点名堂，也需要家长放下功利心，多多陪伴、引导和鼓励。

Tkinter根窗口设置小技巧：程序启动最大化和程序窗口图标设置

Tue, 27 Oct 2020 15:05:00 GMT

上文《Hello World，编写一个Tkinter程序需要哪些基本步骤？》介绍了创建Tkinter应用的四个步骤，其中根窗口设置比较简单。在前面的例子中我们设置了窗口的title、窗口的尺寸和窗口是否能变化等，代码如下：

import tkinter

root = tkinter.Tk()
root.title("Hello World")     # 设置画布窗口的title
root.geometry("800x330")      # 设置画布窗口的尺寸
root.resizable(0, 0)          # 设置画布窗口是否能变化大小，这里设置X和Y轴都不可改变

root.mainloop()

注意，在上面窗口尺寸设置geometry中“800x330”，中间是一个小写的“x”。如果要同时设置窗口在屏幕上的位置，可以使用“800x330+200+100”这样的参数，“800x330”后面的“+200+100“部分，分别表示窗口左上角与屏幕左侧和顶部的距离。如果设置成”-200-100“则表示窗口右下角与屏幕右侧和底部的距离。另外，resizable()可以使用1,0，也可以使用True, False作为参数。

根窗口除了这些基本的设置，这里另外介绍两个常见功能的实现：

程序启动时窗口最大化

有时候，我们希望程序启动时能最大化窗口，那么在Tkinter程序中是怎么实现的呢？

1、其实上面的root.geometry()，就是设置启动时窗口大小的，因此只要我们能获取窗口的尺寸，然后赋值给这个函数就可以了。

可以使用root.maxsize()或者root.winfo_screenwidth()、root.winfo_screenheight()获取窗口尺寸。如下：

the_width, the_height = root.maxsize()

或者

the_width = root.winfo_screenwidth()
the_height = root.winfo_screenheight()

接下来，赋值给root.geometry()：

root.geometry("%dx%d" %(the_width, the_height))

上面的方式在Windows、MacOS和Linux系统上都适合，平时也最常用。

2、如果只需要在Windows系统下实现最大化窗口，可以调用root.state()函数，直接设置最大化窗口：

root.state("zoomed")

这里的窗口状态函数state，可以有三个状态，分别是：

“zoomed” - 窗口最大化
“normal” - 正常
“icon” - 窗口最小化

这种方式只在Windows系统上适用。

3、另外，还可以使用root.attributes()设置窗口的全屏属性为真，来实现窗口最大化。如下：

root.attributes("-fullscreen", True)

这种方法在各种系统下都能适用，但是这种全屏方法会导致窗口的标题栏也没有了，实践中很少会用到。

程序窗口图标设置

缺省情况下，我们编写的Tkinter程序在Windows系统下运行时，程序窗口图标是Tkinter内置的羽毛图标，而下方任务栏上是Python的图标。见下图（此处运行的就是本文开头的例子）：

我们可以通过root.wm_iconbitmap()或者root.iconbitmap()函数来设置程序窗口图标。首先需要将对应的ico图标文件（我这里是vincent.ico文件）放在Tkinter程序目录下，然后在root.mainloop()前增加一句代码：

root.wm_iconbitmap("vincent.ico")

即可得到运行结果：

这样程序图标变为我们自己定义的ico文件，但是任务栏上的Python图标没有改变。可以通过添加如下代码设置：

import ctypes

myappid = "company.product.version" # 这里可以设置任意文本
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)

最后的完整代码为：

import tkinter
import ctypes

myappid = "company.product.version" # 这里可以设置任意文本
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)

root = tkinter.Tk()
root.title("Hello World")     # 设置画布窗口的title
root.geometry("800x330")      # 设置画布窗口的尺寸
root.resizable(0, 0)          # 设置画布窗口是否能变化大小，这里设置X和Y轴都不可改变
root.wm_iconbitmap('vincent.ico')  # 设置程序图标
root.mainloop()

运行结果如下：