在 slop 的世界里造 Pi

Building pi in a World of Slop — AI Engineer Europe 2026 keynote, London, April 10, 2026. Hello, I'm Mario. I built pi in a world of slop, and this is a strategy, a tragedy in three acts.

《在 slop 的世界里造 Pi》——AI Engineer Europe 2026 主题演讲，伦敦，2026 年 4 月 10 日。大家好，我是 Mario。我在一个满是 slop 的世界里造了 Pi，这是一个策略，一场三幕的悲剧。

Just to talk about this real quick, a bunch of people on the internet gave me money for ad space on my torso, and all of that goes to a charity. So act one: building pi. In the beginning, there was Claude Code and it was good, right? We all got basically cat-nipped by that thing and stopped sleeping. Claude Code was the one thing that kinda clicked with me the most. And to preface all of this, I love the Claude team. They're brilliant people, talented, super high velocity. They also created the entire game. So this is not a roast, this is just me, an old man, telling you why I stopped using Claude Code and built my own thing.

先岔开说一句：一群网友给我的躯干广告位付了钱，收入全部捐给慈善机构。那么第一幕：造 Pi。起初，有了 Claude Code，它是好的——我们基本都被那东西猫薄荷了，集体失眠。Claude Code 是最合我手的那一个。先说清楚：我爱 Claude 团队。他们是聪明人，有才华，速度飞快，而且整个游戏就是他们开创的。所以这不是吐槽大会，只是一个老头告诉你，我为什么停用 Claude Code、自己造了一个。

In 2025, I started using Claude Code in about April, thanks to Peter, because he told us the agents are working now. And back then it was simple and predictable and fit my workflow. But eventually, the token madness got hold of them, and the team got bigger, and they started dogfooding that stuff and built a lot of features. A lot of features I don't need. Which is fine, I can just ignore them. But with velocity and more features come more bugs. And that's bad, because I used to work at construction sites, and if my hammer breaks every day, I'm getting really mad. And if my development tools break every day, I'm also getting mad.

2025 年，大约四月我开始用 Claude Code，多亏 Peter——他告诉我们 agent 能用了。那时它简单、可预期、贴合我的工作流。但后来 token 狂热抓住了他们，团队变大，他们开始吃自己的狗粮、堆了很多功能。很多我用不上的功能。没关系，我可以无视。但速度和功能带来更多 bug。这就糟了——我以前在工地干活，锤子天天坏我会真生气；开发工具天天坏，我也一样生气。

But that's just a symptom.

但那只是症状。

The real problem is that my context wasn't my context. Claude Code is the thing that controls my context. And behind my back, Claude Code does things to the context. You have the system prompt, which changes on every release, including the tool definitions. They would remove tools, modify tools. It's not good. They would insert system reminders in the most inopportune place in your context, telling the model, "Here's some information. It may or may not be relevant to what you're doing." It actually says it may or may not be relevant. And that kind of confused the model, and that kind of broke my workflows.

真正的问题是：我的上下文不是我的上下文。Claude Code 是控制我上下文的东西。而它在我背后对上下文动手脚。系统提示词每次发布都变，工具定义也一样——他们会删工具、改工具。这不好。他们还会把 system reminders 插进你上下文里最不合适的地方，对模型说：「这里有些信息，可能跟你在做的事有关，也可能无关。」它真的是这么写的——「可能有关可能无关」。这就把模型搞困惑了，也把我的工作流搞坏了。

On top of all that, there's zero observability, because that's how the tool is constructed, and I like knowing what my agents are doing. There's zero model choice, which is obvious — it's the native Anthropic harness, so it makes sense for them to want you to use Claude. And there's almost zero extensibility. Some of you might have written some hooks for Claude Code, but the number of hooks and the depth of those hooks is very shallow. Every time a hook triggers, what actually happens is a new process gets spawned — basically, the command you specified for the hook. I don't find that specifically efficient.

除此之外，可观测性是零——工具就是这么造的，而我喜欢知道我的 agent 在干什么。模型选择是零，这显而易见：它是 Anthropic 亲生的 harness，他们想让你用 Claude 天经地义。扩展性几乎也是零。你们可能写过一些 Claude Code 的 hooks，但钩子的数量和深度都非常浅。每次钩子触发，实际发生的是一个新进程被 spawn——就是你给钩子指定的那条命令。我不觉得这有多高效。

So I took a step back and looked around for alternatives, and I'd like to especially call out Amp and Factory Droid, the Porsche and Lamborghini of coding agent harnesses. If you can afford them, please use them. They're at the frontier. And I have history in OSS, so naturally I gravitated towards OpenCode. Brilliant team, super high execution velocity, and they don't sell you hype. They sell you tools that work for the most part. I started looking under the hood of OpenCode with respect to context handling, because that's the most important part for me.

于是我退一步找了找替代品。特别要点名 Amp 和 Factory Droid——coding agent harness 里的保时捷和兰博基尼。买得起就用，它们在前沿。我有开源情结，所以自然滑向了 OpenCode。团队出色，执行速度飞快，不卖你玄学，卖你的工具大体能用。我开始掀开 OpenCode 的引擎盖，专门看上下文处理——因为那是我最在乎的部分。

And I found a bunch of things. Given some conditions, OpenCode would just prune tool output after a specific minimum amount of tokens. And that basically lobotomizes the model. There's also LSP server support, which means every time your model calls the edit tool, OpenCode goes to the LSP server, asks "Are there any errors?", and if so, injects that as part of the edit tool result. Which is bad, because think about how you edit code: you're not writing a line of code, checking the errors, writing the next line, checking the errors. You don't do that. You finish your work, and then you check the errors. This confuses the model. And it's not great if by default a server spins up — CORS headers are set in such a way that any website you open in your browser can now access your OpenCode server.

我发现了一堆东西。某些条件下，OpenCode 会把超过某个 token 下限的工具输出直接剪掉——这基本上是给模型做脑叶切除。还有 LSP 集成：模型每次调 edit 工具，OpenCode 就去问 LSP 服务器「有没有报错」，有就注进 edit 结果里。这很糟——想想你自己怎么改代码的：你不会写一行查一次错、再写一行再查一次。你干完了再查。这会把模型搞糊涂。还有：默认起一个 server，CORS 头设置成你浏览器里打开的任何网站都能访问你的 OpenCode server。这……嗯。

Entirely unrelated to all of this, I started looking into benchmarks for coding agent harnesses and found Terminal-Bench, which is a pretty good benchmark, all things considered. And the funny part about it is that the best-performing thing is the most minimal kind of thing you can think of. All it gives the model is a tool to send keystrokes to a tmux session and read the output of that tmux session. There's no file tools, no sub-agents, none of that stuff. And it's one of the best performing harnesses in the leaderboard. Here's the leaderboard from December 2025: irrespective of model family, Terminus scores higher — even higher than the native harness of that model.

跟这一切完全不相关地，我开始研究 coding agent harness 的基准，发现了 Terminal-Bench——总体而言相当不错。最好笑的是：榜单上表现最好的，是你能想到的最极简的东西。它给模型的全部，就是一个往 tmux 会话发按键、再读 tmux 输出的工具。没有文件工具、没有 sub-agents，什么都没有。但它是榜单上表现最好的 harness 之一。这是 2025 年 12 月的榜单：不管哪家模型，Terminus 得分都更高——甚至高过那个模型的亲生的 harness。

So what does that tell us? I form two theses. We are in the fuck around and find out phase of coding agents, and their current form is not their final form. And the second thesis: we need better ways to fuck around. For me, that means self-modifying, malleable agents — things that the agent itself can modify and I can modify depending on my workflow. So I stripped away all the things, built a minimal core, but made it super extensible and made it so that the agent can modify itself.

这告诉我们什么？我立两个论断。第一：我们正处在 coding agent 的「先乱来再看结果」阶段，它们的当前形态不是最终形态。第二：我们需要更好的乱来方式。对我而言，这意味着 self-modifying、可捏塑的 agent——agent 自己能改、我也能按我的工作流改的东西。于是我把所有东西剥掉，造了一个极简内核，但让它超级可扩展，并且让 agent 能修改它自己。

It comes with four packages: an AI package that's basically just an abstraction across providers and context handoff between providers; an agent core, which is just a while loop and the tool calling; a bespoke TUI framework — I come out of game development, so I built a thing that actually doesn't flicker too much; and the coding agent itself. Here's pi's system prompt. That's it. Eventually, the industry created a new standard called Skills, which is basically just markdown files. So we added that as well, and that needs to go into the system prompt. So, begrudgingly, we had to add a couple more lines.

它有四个包：pi-ai——跨 provider 的抽象和上下文交接；agent core——一个 while 循环加工具调用；自研的 TUI 框架——我出身游戏开发，造了个真不怎么闪屏的东西；以及 coding agent 本体。这是 Pi 的系统提示词。就这些。后来行业搞了个叫 Skills 的新标准——基本上就是 markdown 文件——所以我们也加了，那得进系统提示词。于是不情不愿地，我们多加了几行。

And finally, here's the magic that makes pi able to modify itself: we ship the documentation, which was handcrafted by me and an agent, and code examples of extensions. All we need to do for the agent to modify itself is tell it, "Here's the documentation. Here's some code that shows you how to modify yourself by writing extensions." It comes with four tools. That's all it has: read, write, edit, bash. Here's the tool definitions. Don't read the text, just look at the size.

最后，是让 Pi 能修改自己的魔法：我们随包发文档——我和一个 agent 合手写的——还有扩展的示例代码。让 agent 修改自己所需要的全部，就是告诉它：「这是文档。这是一些代码，教你通过写扩展来修改你自己。」它带四个工具。全部家当：read、write、edit、bash。这是工具定义。别读文字，看体量。

That's it. Here's what happens when you start a new session in one of these tools. The thing is, the models are actually reinforcement trained up the wazoo, so they know what a coding agent is, because the coding agent harness is basically what they're being trained when they are post-trained. You don't need ten thousand tokens to tell them you're a coding agent. They know because they are coding agents now.

就这些。这是你在其中一个工具里开新会话时发生的事。关键是：模型被强化学习训得透透的，它们知道 coding agent 是什么——因为它们后训练时泡的就是 coding agent harness。你不需要一万 token 去告诉它们「你是一个 coding agent」。它们知道，因为它们现在就是 coding agent。

Pi is also YOLO by default, because my security needs are different than yours, and I don't think a little dialogue that pops up every time you call bash asking you to approve is a smart security mechanism. So instead, I give you so much rope that you can build anything that's fit for your specific security needs. There's also stuff that's not built in. If you don't like that, then you just ask pi to build you sub-agent support or plan mode or MCP support, whatever you need.

Pi 默认也是 YOLO。因为我的安全需求和你的不一样，而我不认为每次调 bash 都弹个「请批准」的小对话框是什么聪明的安全机制。所以我给你足够长的绳子，让你能造任何适合你具体安全需求的东西。也有些东西不内置。你不喜欢？那就让 Pi 给你造 sub-agent 支持、plan mode、MCP 支持——要什么造什么。

Extensibility comes with a bunch of table stakes, and then with the extensions themselves. Extensions in pi are just TypeScript modules. In the simplest case, a TypeScript file on disk. You point pi at that, and you get an extension API that lets you hook into everything and define stuff for the harness to expose to the model. That includes tools, slash command shortcuts. You can listen in on any kind of event and react, and then save state in the session that's optionally provided to the agent as well, or stored there for tools that analyze sessions as part of your organizational workflows. You can do custom compaction, custom providers, and you have full control over the tool, so you can modify everything in pi. And you can then bundle all of that up and put it on npm or on GitHub, because I think we don't need to reinvent another bunch of silos called marketplaces. We already have package managers. And all of that hot reloads — if you develop an extension for pi, you do so in the session, hot reload the changes, and see the effects immediately, which is a game development thing.

扩展性有一堆基本盘，然后才是扩展本身。Pi 的扩展就是 TypeScript 模块。最简情形：磁盘上的一个 TS 文件。把 Pi 指过去，你就拿到一个扩展 API：钩进一切、定义要暴露给模型的东西。包括工具、斜杠命令快捷键；你可以监听任何事件并响应；把状态存进会话——可以选择性地喂给 agent，或存在那里给「分析会话」的组织工作流工具用。自定义压缩、自定义 provider、对工具的完全控制——Pi 里一切皆可改。然后你可以把这一切打包发上 npm 或 GitHub——因为我觉得我们不需要再发明一批叫「marketplace」的孤岛。我们已经有了包管理器。而且全部热重载：你开发 Pi 扩展就在会话里开发，热重载改动、立刻看效果——这又是游戏开发的老手艺。

A couple of examples. Anthropic ships the /btw, which lets you talk to the agent while it goes on its main quest. I posted this little prompt on Twitter jokingly, and somebody built it in five minutes — with more features. And they didn't have to fork or clone pi. They just let the agent write the extension based on the prompt. Here's Nico, one of the most prolific extension writers. I don't know what the fuck is going on here. It's a chat room for all of his pi agents, and they talk with each other. I would never use this, but all of this is custom, including the UI. Or you can play NES games, or you can play Doom. So how do you build a pi extension? You don't. You tell pi to build it for you based on your specifications, and then you just iterate with it on that and hot reload during a session.

几个例子。Anthropic 出了 /btw——agent 干主线任务时让你插嘴聊天。我把这个小 prompt 开玩笑地发上 Twitter，有人五分钟就造出来了——功能还更多。而且不用 fork 不用 clone Pi：让 agent 按 prompt 自己写扩展。这是 Nico，最高产的扩展作者之一。我不知道这里在搞什么鬼——这是一个给他所有 Pi agent 用的聊天室，它们互相聊天。我永远不会用这个，但这一切都是自定义的，包括 UI。你还能玩 NES 游戏，或者玩 Doom。那 Pi 扩展怎么开发？你不用开发。你告诉 Pi 按你的规格造一个，然后跟它迭代、会话里热重载。

And if you don't like building things yourself — and I hope you do like building things yourself — you can look on npm, or our little search interface on top of npm, to find packages for sub agents, MCP, and so on. So does it actually work? Here's the Terminal-Bench leaderboard from October, before pi had compaction. I added that for Peter's Claw thingy. It scored sixth place.

如果你不喜欢自己造——我希望你喜欢——你可以上 npm，或者我们架在 npm 上的小搜索界面，找 sub-agent、MCP 之类的包。那它到底行不行？这是 10 月的 Terminal-Bench 榜单，Pi 还没有压缩功能的时候——压缩是我为 Peter 的 Claw 那玩意加的。它排第六。

But none of this is actually about pi. I basically want you to retake control of your tools and workflows, so build your own. And then eventually Peter happened. He put pi inside of OpenClaw as its agentic core, which meant my open source project became the target of a lot of OpenClaw instances, unbeknownst to their users.

但这一切其实都不是为了 Pi。我真正想要的是你夺回对自己工具和工作流的控制权——所以，造你自己的。然后，Peter 事发生了。他把 Pi 塞进了 OpenClaw 当它的 agent 内核——于是我的开源项目成了无数 OpenClaw 实例的靶子，而那些用户自己都不知情。

So this is act two: OSS in the age of clankers. Clankers are destroying OSS. Here's tldraw — they closed down the issue and pull request tracker. Here's OpenClaw's trackers. Here's mine: half of that is OpenClaw instances who post garbage. So I started to rage against the clankers. If you send a pull request, it gets auto-closed with a comment that asks you to please write a nice issue in your human voice, no longer than a screen worth of text. And if I see that, I write "Looks good to me," and your account name gets put in a file in the repository, and the next time you send a pull request, it's let through. Clankers don't read that comment. They don't go back once they posted a pull request. So that's a perfect filter.

这是第二幕：clanker 时代的开源。clanker 正在摧毁开源。tldraw——他们把 issue 和 PR tracker 关了。这是 OpenClaw 的 tracker。这是我的一半是 OpenClaw 实例在发垃圾。于是我开始向 clanker 宣战。你发 PR，它被自动关闭，附一条评论：请用你的人话写一个不超过一屏的 issue。我看到了，回一句「Looks good to me」，你的账号名就进了仓库里的一个文件，下次发 PR 直接放行。clanker 不读那条评论——发了 PR 就头也不回。所以这是个完美的过滤器。

I also labeled them: if you had interactions with OpenClaw, your issues get deprioritized. I also built tools where I embed issues and pull request texts into 3D space, so I see clusters of issues. And I invented OSS vacation: I just close the tracker whenever I want, so I have my life back. So does this work? Yes, sort of.

我还给他们打标：跟 OpenClaw 有过互动的，issue 降权。我还造了个工具，把 issue 和 PR 文本嵌进 3D 空间，看 issue 的聚类。我还发明了 OSS vacation：想关 tracker 就关，把生活拿回来。这套管用吗？管用，算是吧。

Which leads me to act three: slow the fuck down. Everything's broken. And then there's people that say, "Our product's been 100% built by agents." Yes, we know. It fucking sucks now. Congratulations. And I'm hearing this from my peers, and this is entirely unhealthy. Here's how we should not work with agents, and why.

于是到了第三幕：慢下来。一切都坏着。还有人说什么「我们的产品 100% 由 agent 构建」。是，我们知道。现在它烂透了。恭喜。我从同行那里也一直在听说这种事，这非常不健康。下面是我们不该怎么跟 agent 干活，以及为什么。

We are having armies of agents, and you don't know that it's basically uninstallable malware. Anthropic built a C compiler — it kind of works, but actually doesn't, and we're hoping the next generation of models will fix it. Someone is building a browser, and that's also super broken — but the next generation will fix it. And SaaS is dead, software solved in six months, and my grandma just built herself a Spotify with her OpenClaw. Come on, people.

我们养着 agent 军团，而你不知道那玩意基本上是卸不掉的恶意软件。Anthropic 造了个 C 编译器——好像能用，其实不能用，我们盼着下一代模型修好它。有人在造浏览器——也烂得飞起，但下一代模型会修好的。还有「SaaS 已死、六个月解决软件」、我奶奶用她的 OpenClaw 给自己造了个 Spotify。清醒一点，各位。

Agents are actually compounding boo-boos — my word for errors — with zero learning, no bottlenecks, and delayed pain. The delayed pain is for you. Here's your codebase with a human, with one agent, and with ten agents. How much of the agent code can you review? Here's the same codebase expressed in boo-boos per day. How much of those boo-boos do you think you'll find? Then you say, "But I have a review agent." Let me introduce you to the wonderful world of the Ouroboros. Doesn't work. It catches some issues.

agent 实际上在复利 boo-boo——我对「错误」的称呼——零学习、无瓶颈、痛感延迟。延迟的痛是给你的。这是你的代码库：配一个人类、配一个 agent、配十个 agent。agent 代码你能审多少？同一个代码库按每天 boo-boo 数表达。这些 boo-boo 你觉得能发现几成？然后你说「可是我有审查 agent」。让我给你介绍衔尾蛇的美好世界。没用。它能抓到一些问题。

The problem is that agents are merchants of learned complexity. Where did they learn that complexity from? From the Internet. What's on the Internet? All our old garbage code. There are some pearls on the Internet — really well-designed systems — but 90% of code on the Internet is our old garbage, and that's what the models learn from. And every decision of an agent is local, especially if the codebase is so big that it doesn't fit into its context. And if you let it go wild, it adds abstractions everywhere that are intertwined. So that leads to lots of abstractions and duplication and backwards compatibility. Who has seen that in the output of their agent? Or defense in depth. So you get enterprise-grade complexity within two weeks, with just two humans and ten agents. Congratulations.

问题是：agent 是习得复杂性的贩子。复杂性从哪学来的？从互联网。互联网上有什么？全是我们过去的垃圾代码。网上确实有珍珠——设计得真正好的系统——但互联网上 90% 的代码是我们的旧垃圾，而模型就是从那里学的。而且 agent 的每个决策都是局部的——当代码库大到装不进它的上下文时尤其如此。你放它撒欢，它就到处加互相纠缠的抽象。于是就是一堆抽象、重复、向后兼容。谁在自己 agent 的产出里见过这些？还有「纵深防御」。于是：两个人类加十个 agent，两周拿到企业级复杂度。恭喜。

And then you say, "But my detailed spec." Yes, sure. You know what we call a sufficiently detailed spec? It's a program. So if you leave blanks in your spec, what happens? How does the model fill in the blanks, and with what? It fills it in with the garbage that it learned on the Internet from our old code. And then you say, "But humans also [make garbage]." Yes, humans are horrible, fallible beings, but they can learn. And there are bottlenecks — there's only so many boo-boos they can add to your codebase on a daily basis. And humans feel pain, which is a very interesting property, because humans hate pain. Once there's too much pain, the human has options: quit the job, blame somebody else and make them fix it, or everybody bands together and starts refactoring the hell out of the garbage codebase. Agents will happily keep shitting into your codebase.

然后你说：「可是我有详细的 spec。」行，你知道一个足够详细的 spec 叫什么吗？它叫程序。那你的 spec 里留了空白会怎样？模型怎么填空白、拿什么填？它用它从互联网的旧代码里学来的垃圾填。然后你说「可是人类也这样」。是的，人类是糟糕的、会犯错的生物，但人类能学习。而且人类有瓶颈——每天能往代码库加的 boo-boo 就那么多。人类还会痛，这是个非常有意思的属性，因为人类怕痛。痛多了，人有选项：辞职、甩锅给别人修，或者大家伙儿一起动手把垃圾代码库重构个底朝天。而 agent 会开开心心地继续往你代码库里拉屎。

And no, your AGENTS.md and super-complex memory systems will not save you. Agents don't learn the way we learn. Then there's my most beloved people: "I don't even read the code anymore." Congratulations. Something is broken and your users are screaming — who you gonna call? Not yourself, because you haven't read the code. So you're relying on your agents, but they are now also overwhelmed, because the codebase is so humongous that there's absolutely zero chance they can get all the context they need to fix the issues. And long context windows are a hack, as most of you will find out this year as everybody's switching to million-token context windows. And agentic search is also failing. So the agent patches locally and fucks shit up globally. If you see this in your codebase, you're finished. You cannot trust your codebase anymore, and also not your tests — because your agent wrote your tests. Good game.

不，你的 AGENTS.md 和超级复杂的记忆系统救不了你。agent 不像我们这样学习。还有我最爱的那类人：「我都不读代码了。」恭喜。出了故障、用户在尖叫——你打电话找谁？不找你自己，因为你没读过代码。于是你依赖 agent，但它们现在也过载了——代码库大到它们绝对拿不全修问题所需的上下文。而长上下文窗口是个 hack，今年大家全在切百万 token 窗口时你们就会明白。agentic 检索也在失效。于是 agent 局部打补丁、全局搞砸。你的代码库里出现这个，你就完了。你不再能信任你的代码库，也信任不了你的测试——因为测试是你的 agent 写的。好局。

So here's how I think we should work. There's a bunch of properties for good agent tasks. Scope: if you can scope it in such a way that the agent is guaranteed to find all the things it needs to find to do a good job, you're done. That means modularize your codebase. If you can give it a function to evaluate how well it did the job, even better — hill climbing, auto research. Anything non-mission-critical, let it vibe. Boring stuff, let it vibe. Reproduction cases for user issues, which usually only have partial information — perfect. I don't spend any mornings anymore doing that. Or if you don't have a human near you, rubber duck. So lots of tasks you can use them for and save time. At the end of that, you evaluate. You take what's reasonable — most of it isn't — and then finalize.

下面是我认为我们该怎么干活。好的 agent 任务有一组性质。范围：如果你能把任务框到「保证 agent 找得到干好这件事需要找的所有东西」，就成了——这意味模块化你的代码库。如果你还能给它一个评估干得好不好的函数，更好——爬坡、自动研究。一切非命脉的活，让它 vibe。无聊的活，让它 vibe。给用户 issue 写复现用例——信息通常只有半截——完美。我再也不为这个花早晨了。身边没人的时候，让它当橡皮鸭。很多活都能这么省时间。收尾时你来评估：留下说得过去的——大部分说不过去——然后定稿。

My final slide, more or less: slow the fuck down. Think about what you're building and why, and don't just build because your agent can do it now. That's stupid. Learn to say no — this is your most valuable capability at the moment. Fewer features, but the ones that matter. And then use your agents to polish the hell out of that. Enlighten your users, not your token-maxing desires. Cap the amount of generated code that you need to review. And non-critical code — sure, vibe slop ahead. Critical code: read every fucking line.

我的最后一张幻灯片，差不多就是：慢下来。想想你在造什么、为什么造，别只因为「你的 agent 现在能造」就造。那是蠢的。学会说不——这是你眼下最值钱的能力。更少的功能，但都是要紧的。然后用你的 agent 把它们打磨到发光。启发你的用户，而不是喂饱你刷 token 的欲望。给需要你审的生成代码设上限。非关键代码——行，一路 vibe slop。关键代码：每一行都他妈亲自读。

So how do you know what's critical? Any guesses? Well, you read the fucking code. If you do anything important, write it by hand. You can use a clanker to help you with that, but don't let it make the decisions for you, because we've learned all the decisions it makes are learned from the Internet. And that friction is the thing that builds the understanding of the system in your head, which is important — and it's also where you learn new things. And all of this requires discipline and agency, and all of this still requires humans. Thank you.

那你怎么知道什么算关键？猜猜看？——你他妈去读代码啊。真要紧的东西，手写。可以用 clanker 帮忙，但别让它替你做决定，因为我们已经知道它做的每个决定都是从互联网学来的。而那个摩擦，正是在你脑子里建立系统理解的东西——这很重要，也是你学到新东西的地方。这一切需要纪律和能动性，这一切仍然需要人类。谢谢。