别再为你的 Agent 打造“富士康工厂”了

好的，请看以下翻译。翻译严格遵循了您提供的术语表、CJK排版规则以及所有格式要求。

原文 (English)	译文 (简体中文)
540,000 Lines of Code I Didn't Need	我不需要的 54 万行代码

January I got back into coding and I built Garry's List. Over five hundred thousand lines of Rails and the tests to police it.

I was proud of it. I shouldn't have been. The thing worth being proud of wasn't the app. It was the setup that came out of building it. GStack, the way I code with agents, grew out of the work of building Garry's List, and I gave it away. It's one of the hundred most-starred open source projects in GitHub history, about 105,000 stars in under three months. The half-million lines were the product. The setup was the byproduct. The byproduct is the part that mattered.

Here is what 540,000 lines of code wrapped around an LLM actually is.

一月份我重新开始编程，构建了 Garry's List。超过五十万行的 Rails 代码以及用于监管它的测试。

我曾为此感到自豪。但我本不该如此。真正值得自豪的不是那个应用本身，而是构建它过程中产生的那套体系。GStack，我与 Agent 一起编程的方式，正是从构建 Garry's List 的工作中演化而来，并且我把它开源了。它是 GitHub 历史上最受星标的 100 个项目之一，不到三个月就获得了约 105,000 颗星。那五十万行代码是产品。那套体系是副产品。而副产品才是真正重要的部分。

以下就是包裹着 LLM 的 54 万行代码的真实面目。

It is a Foxconn factory. Built for an hyper-intelligent AI worker who doesn't need hyper-vigilance. We built it anyway.

Little booties at the door. Up at 6am. Calisthenics. A life so hard you have to erect netting around high floors of every building, because... well, it's not a life you want to live. The same line of the assembly belt forever. Every test, every guardrail, every retry loop, an inch of cage bolted onto a worker who can already do the job and a thousand things you didn't ask for.

Humans and agents both contain multitudes but Foxconn factories are built to squeeze intelligence and work out of beautiful beings that could do all that work and 1000x more if we let them.

I built the factory. Everyone builds these today. I'm telling you not to.

它是一座富士康工厂。 为一个不需要高度警惕的超智能 AI 工人而建。但我们还是建了。

门口的小鞋套。早上 6 点起床。晨练。一种艰苦到不得不在每栋高楼的高层架设防护网的生活，因为……好吧，这不是你想过的生活。永远是同一条流水线。每一个测试、每一道护栏、每一个重试循环，都是给一个本已胜任工作、甚至能完成你未曾要求的上千件事的工人，又锁上的一寸牢笼。

人类和 Agent 都蕴含着无穷潜力，但富士康工厂是为了从这些美丽的生灵身上榨取智力和劳动力而建，而如果我们放手，他们本可以完成所有这些工作，甚至多出 1000 倍。

我建造了这座工厂。如今每个人都在建造这样的工厂。我告诉你们，不要建。

The time traveler

What I actually did with my 539k LOC written was prove I could perfectly impersonate a time traveler. A 2013 Web 2.0 engineer (me, the last time I was a true software engineer) dropped into 2026 with modern tools, building the only way he knew how. More code. Always more code. The tools had changed. My instincts hadn't.

The 2013 engineer believes one thing in his bones: capability equals lines of code. That belief was correct for decades, until now. Hand me Codex or Claude Code and I'll do the work of 100 to 1000 engineers. Same map, faster engine, fastest possible route to the what is now the wrong place.

This is where almost everyone building with AI is right now. They upgraded the tool and kept the 2013 mental model. The trap doesn't feel like a trap, because the code works. Garry's List shipped. It felt like the most productive month of my life.

It was productivity in the service of an obsolete idea.

时间旅行者

我写下的 539k 行代码，实际上证明了我能完美地扮演一个时间旅行者。一个 2013 年的 Web 2.0 工程师（我，上一次作为一名真正的软件工程师的我），带着现代工具空降到 2026 年，用他唯一知道的方式构建东西。更多的代码。总是更多的代码。工具变了，但我的本能没有变。

2013 年的工程师骨子里坚信一件事：能力等于代码行数。这个信念持续了数十年，直到现在。把 Codex 或 Claude Code 交给我，我能做 100 到 1000 个工程师的工作。同样的地图，更快的引擎，以最快的路线奔向——如今看来——错误的地方。

这就是现在几乎所有用 AI 构建的人所处的阶段。他们升级了工具，却保留了 2013 年的思维模式。这个陷阱感觉不像陷阱，因为代码确实运行了。Garry's List 成功上线了。那感觉像是我人生中效率最高的一个月。

但那只是为一个已经过时的想法而服务的效率。

LLMs were expensive so we had to harness them

The old economics for many years through 2025: LLM calls were expensive and code was cheap. So you wrote code to ration the model, to harness it, to call it carefully and sparingly. The architecture was lots of software wrapped protectively around a few precious model calls.

Both halves of that equation have flipped.

The model is now becoming cheap and getting cheaper every quarter, and it's so smart that the value-cost ratio flipped. And the model can write usable code. So you stop writing code to babysit the model. You can now instruct the model in plain language, and you let it write the minimal code actually needed.

This is just-in-time-software, and we're entering the golden age of it.

The artifact changes shape entirely. The Rails app was 540,000 lines I wrote and own, code plus the tests built to police it. The replacement is an agent built on markdown and code, a fraction of that. Same capability. Easier to read. Easier to maintain. Far more flexible, because the behavior lives in instructions you can edit in plain language instead of logic frozen in code the day you wrote it.

We were writing code to babysit a thing that is now smarter than the code.

因为 LLM 很贵，所以我们不得不约束它们

直到 2025 年，旧的成本逻辑是：LLM 调用很贵，而代码很便宜。 所以你写代码来配给模型，来约束它，小心而节约地调用它。架构是用大量软件包裹保护着少量宝贵的模型调用。

这个公式的两端都已经反转了。

模型现在变得越来越便宜，每个季度都在降价，而且它非常聪明，以至于价值成本比已经反转。模型还能写可用的代码。所以你不必再写代码来照看模型了。你现在可以 用自然语言指令来指导模型，让它只编写实际需要的最小量代码。

这就是即时软件（Just-in-Time Software），而我们正在进入它的黄金时代。

产物形态完全改变了。那个 Rails 应用是我编写和拥有的 54 万行代码，加上为了监管它而构建的测试。替代品是基于 markdown 和代码构建的 Agent，只有它的一小部分。同样的能力。更易阅读。更易维护。更加灵活，因为行为存在于你可以用自然语言编辑的指令中，而不是冻结在你写下代码那天的逻辑里。

我们一直写代码来照看一个现在比代码本身更聪明的家伙。

Inside the Foxconn factory, netting and all

If you've been coding lately, you probably are building this kind of factory without knowing it. Walk your own codebase and count the lines that exist only because you didn't trust the model to do its job.

Mine: about 262,000 lines of application code, and about 276,000 lines of tests bolted on to police it. The audit committee was bigger than the company. Sanitizers checking inputs the model would have handled. Validators checking outputs the model would have caught. Retry loops wrapping calls the model recovers from on its own. Every one of those lines is a bet that the worker will fail. You wrote the same bets. We all did.

127 background jobs, 33 of them on cron. That is not capability. That is 33 alarms set for an LLM worker who usually these days shows up on time.

In my Foxconn factory building days, Claude and I wrote a 1,778-line file whose only job is to second-guess the model's facts. It takes every claim the model makes, fans each one out to five separate sources in parallel, and grades them. A triage gate so the easy claims skip the full blast. A retry if the first pass comes back empty. Fallbacks for the fallbacks.

There's an episode of Rick and Morty where Rick builds a little robot at the breakfast table. It powers on, looks up, and asks what its purpose is. Rick says, "You pass butter." The robot slides the butter dish across the table, looks down at its own hands, and says, "Oh my god." Then it just sits there. That robot contains multitudes. It was built to pass butter. My 276,000 lines of tests were the butter dish.

在富士康工厂内部，处处是防护网

如果你最近在编程，你可能也在不知不觉中建造这种工厂。审视你自己的代码库，数一数那些仅因为你不信任模型能做好本职工作而存在的代码行。

我的情况是：大约 262,000 行应用代码，以及大约 276,000 行测试代码来监管它。审计委员会比公司本身还庞大。清理程序检查本应由模型处理的输入。验证器检查本应由模型捕获的输出。重试循环包裹着模型自身就能恢复的调用。每一行代码都是在赌那个工人会失败。你也写下过同样的赌注。我们都做过。

127 个后台任务，其中 33 个是 cron 任务。这不是能力。这是为一位（如今通常都能准时上班的）LLM 工人设下的 33 个闹钟。

在我建造富士康工厂的日子里，Claude 和我写了一个 1,778 行的文件，它的唯一工作就是质疑模型生成的事实。它获取模型作出的每一个声明，将每个声明并行分发给五个独立的来源，然后进行评分。一个分诊门控，让简单的声明跳过全面核查。如果第一次查询返回空结果，则进行重试。还有回退机制的回退。

《瑞克和莫蒂》里有一集，瑞克在早餐桌上做了一个小机器人。它启动，抬起头，问自己的目的是什么。瑞克说：“你递黄油。”机器人把黄油碟滑过桌子，低头看着自己的手，说：“哦，我的天。”然后就只是坐在那里。那个机器人蕴含着无穷潜力。它被制造出来只是为了递黄油。我那 276,000 行测试代码就是那个黄油碟。

When you build this kind of software, in the 2023 Foxconn factory way, you built a cage, and if you're not careful, you'll be the jailer maintaining the prison for your AI agents.

当你以 2023 年富士康工厂的方式构建这类软件时，你建造了一个笼子。如果不小心，你就会成为那个为你的 AI Agent 维护监狱的狱卒。

Markdown is the program now

When I say markdown, I do not mean prompting. Prompting is ephemeral. You type something, you get something, it evaporates.

This is building. Versioned, tested, reusable.

The markdown is the instruction layer: the intent, the skill, the judgment about how the work should be done. The TypeScript is the thin deterministic layer. The few things that genuinely have to be code, the I/O, the parts that must never hallucinate.

And critically, you test the markdown the way you'd test code. In my setup the loop is one word. I build something with the agent until it works, then I say "skillify it." The agent then writes:

the markdown skill
the minimal code it needs
a unit test for the code
an LLM eval for the skill
an integration test across both
a resolver so the agent invokes the skill automatically when it's relevant
and an eval for the resolver

That bundle is a skill pack. A unit of reusable capability that compounds. The tests are the magic: coverage on the skill is what lets it change without breaking. This is what separates it from vibe coding. Vibe coding is a vibe. A skill pack has tests.

We are only now figuring out the systems primitives for agentic engineering in real time, the way the early CPU era invented the stack, the heap, the registers, the von Neumann machine. I think a skill pack is one of those primitives. A harness is another. Most people haven't noticed, because they're still measuring software in lines.

现在，Markdown 就是程序

当我说 markdown 时，我不是指提示词工程。提示是短暂的。你输入一些东西，得到一些东西，然后就消散了。

这是在构建。版本化、可测试、可复用。

Markdown 是指令层：意图、技能、关于工作应如何完成的判断。TypeScript 是薄薄的确定性层它处理那些真正必须是代码的事情：I/O、绝不能产生幻觉的部分。

关键在于，你需要像测试代码一样测试 markdown。在我的工作流里，这个循环可以用一个词概括。我用 Agent 构建一些东西直到它工作，然后我说 "skillify it." 然后 Agent 会编写：

markdown 技能
所需的最小量代码
代码的单元测试
技能的 LLM 评估
两者的集成测试
一个 resolver，以便 Agent 在相关时自动调用该技能
以及 resolver 的评估

这个捆绑包就是一个 技能包（skill pack）。一个可复用的能力单元，可以叠加。测试是魔法所在：技能的测试覆盖率使其能够在不破坏功能的情况下进行更改。这就是它区别于“氛围编程”（vibe coding）的地方。氛围编程是一种氛围。而技能包是有测试的。

我们现在才实时摸索出用于 Agent 化工程（agentic engineering）的系统原语，就像早期 CPU 时代发明了堆栈、堆、寄存器和冯·诺依曼体系结构一样。我认为技能包就是其中一个原语。Harness 是另一个。大多数人还没有注意到，因为他们仍然在用代码行数来衡量软件。

The crazy shit you can actually build

This is not a toy argument. The agent does more than the five-hundred-thousand-line Rails app did, with a fraction of the new code. Concretely:

The hackathon judge. Two Saturdays ago we ran a GStack/GBrain hackathon. 85 submissions. I uploaded the Google Drive of submissions and said go. The agent analyzed every repo's code quality, did deep research on every single person who attended, watched and screenshotted each demo video, rated the screens, and rank-ordered all 85 teams. Then it told me the five apps from the batch worth paying attention to. Judging a hackathon went from a multi-day slog to about thirty minutes.

I didn't write the code. I had OpenClaw do the task, and I guided it. Then once it was done, I said skillify it, and now it's a tarball anyone can run against any hackathon spreadsheet, forever. I say "skillify" all the time now and I have more than 350 skillpacks. Almost every kind of personal and work task I need to do, now my agent can do.

That is the inversion in one example. A capability that would have been a real software project, with scrapers, a scoring pipeline, video processing, a research module, a ranking system, instead became markdown plus a little code, built by the agent, in an afternoon, reusable by everyone.

As an aside: The winner of the hackathon actually built code I ended up polishing up and landing on main! GStack can now test iOS apps both in simulator and on real devices, and that complete feature was made in less than 8 hours at a hackathon by a single person!

你能真正构建的那些疯狂东西

这不是一个理论上的争论。Agent 用更少的新代码，做得比那五十万行的 Rails 应用更多。具体来说：

黑客马拉松评审员。 前两个周六，我们举办了一场 GStack/GBrain 黑客马拉松。85 个参赛作品。我上传了存放作品的 Google Drive 文件夹，然后说“开始”。Agent 分析了每个仓库的代码质量，对每位参赛者进行了深度研究，观看并截取了每个演示视频，为画面评分，并对所有 85 个团队进行了排名。然后它告诉我在这批作品中值得关注的五个应用。评审一场黑客马拉松从几天的苦差事变成了大约三十分钟。

我没有写代码。我让 OpenClaw 执行任务，并指导它。完成后，我说 skillify it，现在它成了一个任何人都可以永久用来评审任何黑客马拉松电子表格的 tarball 包。我现在经常说“skillify”，我已经有超过 350 个技能包。几乎所有我需要做的个人和工作任务，现在我的 Agent 都能做。

这就是反转的一个例子。一个本来需要真正软件项目（包括爬虫、评分管道、视频处理、研究模块、排名系统）的能力，变成了 markdown 加少量代码，由 Agent 在一个下午内构建完成，并且每个人都可以复用。

顺便提一下：黑客马拉松的获胜者实际编写了代码，我最终打磨后合并到了主分支！GStack 现在可以在模拟器和真实设备上测试 iOS 应用，而这个完整的功能是在一场黑客马拉松中由一个人不到 8 小时完成的！

Tokenmaxxing

There's a price of admission, and almost nobody is paying it: you have to be willing to spend on tokens.

Peter Steinberger built OpenClaw, my favorite harness. He has said he's willing to spend on the order of a million dollars a year in tokens to do it. Most people hear that and flinch, but they shouldn't because that's the gold: you can live in 2028 if you can this, and it will be years before people catch up.

This is why OpenAI decided to offer $2M to every YC company as an uncapped SAFE in the form of token credits. There's something magical that happens when you can turn raw intelligence into tokens and then output that is actually usable by users and solves real needs for users that they'll pay for. If you're a founder you need to be maxxing out this capability. (This is why I keep harping on skillify because it's a real way to achieve these good outcomes.)

We spent the last era treating LLM calls like they were too expensive to make. We rationed them. That instinct is now the thing holding people back. If you are willing to tokenmax, to let the agent burn tokens freely and run constantly, you get a 1994 head start on the internet, paid for in tokens. It prices out the >99.99% of organizations still counting pennies on a resource that is collapsing in price, and hands the head start to the few who get it.

For a few hundred thousand dollars a year, for some far less, you can run today the way the rest of the world will be forced to run in a few years.

You can live in 2028 but in 2026, and that is worth the trade in paying more now since, those same tokes that cost $100K today will be $10K next year and $1K the year after that, and maybe $100 by end of 2028. If you could tell any founder in the history of the world that you could invest 6 figures in capital into living 2 to 3 years in the future and hold that advantage for years, 100 out of 100 founders worth their salt would take that deal.

The only thing in the way is the 2013 instinct that says the model calls are too expensive to make freely. They aren't. That was the old economics. The inversion already happened.

Tokenmaxxing (最大化 Token 利用)

这是需要付出入场费的，而且几乎没人愿意付：你必须愿意在 Token 上花钱。

Peter Steinberger 构建了 OpenClaw，我最喜欢的 harness。他曾表示他愿意为此每年在 Token 上花费大约一百万美元。大多数人听到这个会退缩，但他们不应该，因为这是金矿：如果你能做到这一点，你就活在了 2028 年，而且别人要好几年才能追上。

这就是为什么 OpenAI 决定以 Token 积分的形式向每家 YC 公司提供 200 万美元的无上限 SAFE。当你能够将原始智能转化为 Token，然后输出用户实际可用、能解决他们愿意付费的真实需求的内容时，就会产生一种魔力。如果你是创始人，你需要最大化利用这种能力。（这就是为什么我一直唠叨 skillify，因为它是实现这些好结果的真正方法。）

上一个时代，我们对待 LLM 调用的方式是认为它们太贵了。我们配给它们。这种本能现在成了阻碍人们前进的东西。如果你愿意 tokenmaxxing，让 Agent 自由地消耗 Token 并持续运行，你就能获得相当于 1994 年互联网的领先优势，而成本就是 Token。这会把超过 99.99% 的那些还在对一个价格暴跌的资源锱铢必较的组织挡在门外，把领先优势交给少数明白这一点的人。

每年几十万美元，有些人则少得多，你就可以用世界其他地区几年后被迫采用的方式运营。

你可以活在 2028 年，但却是 2026 年。这笔交易值得你现在多付一些，因为今天价值 10 万美元的同样 Token，明年可能只要 1 万美元，后年 1 千美元，到 2028 年底可能只要 100 美元。如果你能告诉历史上任何一位创始人，你可以投入 6 位数的资金来换取活在 2 到 3 年后的未来，并保持这个优势数年，那么 100 个有价值的创始人里会有 100 个接受这个交易。

唯一的障碍是那个 2013 年的本能：认为模型调用太贵，不能随意使用。它们不贵了。那是旧的经济学。反转已经发生了。

Esalen, not Foxconn

If 540,000 lines of control code builds a Foxconn factory for the worker, the cure is to build the opposite.

There is a place on the cliffs at Big Sur called Esalen. People go there to be unmade and rebuilt, to drop the armor and come back more themselves. No assembly line, no foreman, no 6am whistle. Freedom, not control. Build that. Build a YC, where we try to help you build companies that solve real problems and reach product market fit.

Build places where the workers, both human and AI, are free and not enslaved.

That is the whole ethos. Make things where agents can be free. Make companies where humans can bounce their ball. In knowledge work, the factory is the failure mode. The institution that frees people is the goal, just now pointed at agents too.

OpenClaw is a Ferrari you have to bring a wrench for. The model is the engine, not the car. We're at the Apple I moment still, soldering breadboards. It ships rough. You have to finish it yourself still. GBrain, the retrieval engine and skillpacks I give away open source are not yet batteries included.

They say OpenClaw is unsafe. They don't understand the freedom is also how it is so powerful. You don't bolt safety rails onto a thing you trust before you know you hit the problem. The wrench in your hand is the sign nobody caged it.

A control system is polished because control needs total control, a Foxconn factory. A free system is rough because it trusts you to finish it. Pick which one you're building. Then look at how much code you wrote.

要 Esalen，不要富士康

如果 54 万行控制代码为工人建造了一座富士康工厂，解药就是建造相反的东西。

在大苏尔的悬崖上有一个叫 Esalen 的地方。人们去那里是为了被拆解和重建，卸下盔甲，回归更本真的自我。没有流水线，没有工头，没有早上 6 点的哨声。是自由，而非控制。建造那样的地方。建造一个 YC，在那里我们试图帮助你建立解决真实问题并达到产品市场契合的公司。

建造工人们——无论是人类还是 AI——都自由而非被奴役的地方。

这就是整个精神内核。创造 Agent 可以自由发挥的事物。创造人类可以施展才华的公司。在知识工作中，工厂模式是失败的模式。解放人的机构才是目标，现在这个目标也指向了 Agent。

OpenClaw 是一辆你需要自带扳手的法拉利。模型是引擎，而不是车。我们仍处在 Apple I 的时代，还在焊接面包板。它出厂时是粗糙的。你仍然需要自己把它完成。GBrain，我开源提供的检索引擎和技能包，还不是一个开箱即用的成品。

他们说 OpenClaw 不安全。他们不明白，正是这种自由赋予了它强大的力量。你不会在你信任的东西上，在你知道问题出在哪里之前，就加上安全护栏。你手里的扳手就是它没有被关进笼子的标志。

一个控制系统是精良的，因为控制需要完全的控制，像富士康工厂。一个自由系统是粗糙的，因为它信任你去完成它。 选择你正在建造的是哪一种。然后看看你写了多少代码。

What it actually means

540,000 lines of Rails was me proving I could still play the old game at the highest level, but that level was from Web 2.0, a decade ago.

I could play as well as I ever could, 1000x engineer in building Foxconn factories. Old code.

But the new game isn't played in lines of code at all. My haters, it turned out, were right. I tip my hat to you if you're reading, anons.

When you can turn intent directly into working, tested, reusable systems, the bottleneck stops being how much you can build and starts being what you actually want and whether it's worth building. The scarce resource becomes clarity, taste, and judgment. The engineer who writes the least code is often the one building the most.

I wrote 540,000 lines to learn that. You don't have to.