# Stop building Foxconn factories for your agents
**作者**: Garry Tan
**日期**: 2026-06-01T14:26:49.000Z
**来源**: [https://x.com/garrytan/status/2061454423034110372](https://x.com/garrytan/status/2061454423034110372)
---
In 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.
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.
## 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.
## 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.
## 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.
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.
## 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.
## 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!
## 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.
## 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.
## 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.
The series:
1. Fat Skills, Fat Code, Thin Harness -- the architecture
2. Resolvers -- the routing table for intelligence
3. The LOC Controversy -- what 600K lines actually produced
4. Naked Models Are Stupider -- the model is the engine, not the car
5. The Skillify Manifesto -- every workflow becomes a testable skill
6. Meta-Meta-Prompting -- compounding skills produce emergent capabilities
7. The Agent Complexity Ratchet -- 90% test coverage is magic for your codebase
8. 540,000 Lines of Code I Didn't Need -- you are here
## 相关链接
- [Garry Tan](https://x.com/garrytan)
- [@garrytan](https://x.com/garrytan)
- [204K](https://x.com/garrytan/status/2061454423034110372/analytics)
- [Garry's List](https://garryslist.org/)
- [GStack](https://github.com/garrytan/gstack)
- [276,000 lines of tests](https://x.com/garrytan/status/2045404377226285538)
- [thin deterministic layer](https://x.com/garrytan/status/2042925773300908103)
- ["skillify it."](https://x.com/garrytan/status/2046876981711769720)
- [resolver](https://x.com/garrytan/status/2044479509874020852)
- [skill pack](https://github.com/garrytan/gbrain/blob/master/docs/skillpack-anatomy.md)
- [tests are the magic](https://x.com/i/article/2054062662225440768)
- [figuring out the systems primitives](https://x.com/garrytan/status/2053127519872614419)
- [actually built code](https://github.com/garrytan/gstack/pull/1574)
- [Peter Steinberger](https://x.com/steipete)
- [OpenClaw](https://github.com/openclaw/openclaw)
- [OpenAI decided to offer $2M to every YC company as an uncapped SAFE in the form of token credits](https://x.com/TheRohanVarma/status/2057648423873270270)
- [not the car](https://x.com/garrytan/status/2045798603059548364)
- [GBrain](https://github.com/garrytan/gbrain)
- [Fat Skills, Fat Code, Thin Harness](https://x.com/garrytan/status/2042925773300908103)
- [Resolvers](https://x.com/garrytan/status/2044479509874020852)
- [The LOC Controversy](https://x.com/garrytan/status/2045404377226285538)
- [Naked Models Are Stupider](https://x.com/garrytan/status/2045798603059548364)
- [The Skillify Manifesto](https://x.com/garrytan/status/2046876981711769720)
- [Meta-Meta-Prompting](https://x.com/garrytan/status/2053127519872614419)
- [The Agent Complexity Ratchet](https://x.com/i/article/2054062662225440768)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [10:26 PM · Jun 1, 2026](https://x.com/garrytan/status/2061454423034110372)
- [204.9K Views](https://x.com/garrytan/status/2061454423034110372/analytics)
- [View quotes](https://x.com/garrytan/status/2061454423034110372/quotes)
---
*导出时间: 2026/6/2 09:07:27*
---
## 中文翻译
# 别再为你的智能体建造富士康工厂了
**作者**: Garry Tan
**日期**: 2026-06-01T14:26:49.000Z
**来源**: [https://x.com/garrytan/status/2061454423034110372](https://x.com/garrytan/status/2061454423034110372)
---
今年一月，我重新回到了编码岗位，我写了 Garry's List。超过五十万行的 Rails 代码，以及用来约束它的测试用例。
我曾为此感到自豪。我不应该为此感到自豪。真正值得自豪的不是这个应用程序。而是在构建它的过程中产生的那个“设置”。GStack——即我与智能体协作编程的方式——就是从构建 Garry's List 的工作中生长出来的，并且我把它开源了。这是 GitHub 历史上获得 Star 数最多的前一百个开源项目之一，在不到三个月的时间里获得了大约 105,000 个 Star。那五十万行代码是产品。那个设置是副产品。而恰恰是副产品才是最重要的部分。
这五十万行包裹在 LLM 周围的代码实际上是什么呢？
它就是一座富士康工厂。为一个不需要过度监管的超级智能 AI 工人而建造的工厂。但不管怎样，我们还是把它建起来了。
门口的鞋套。早上 6 点起床。体操训练。生活如此艰苦，以至于你必须在每栋楼的高层周围架设防跳网，因为……好吧，这并不是一种你想过的生活。永远不变的流水线。每一个测试，每一个护栏，每一个重试循环，都是 bolted onto 一个本来就已经能完成这项工作并且能做你没要求的一千件事的工人身上的笼子的一寸。
人类和智能体都蕴含着巨大的潜能，但富士康工厂却是为了从那些美好的存在身上榨取智力和劳动而建的，如果我们放手，它们本可以完成所有这些工作以及一千倍的产出。
我建造了这座工厂。今天每个人都在建造这样的工厂。我告诉你，不要这样做。
## 时间旅行者
我用我写的 53.9 万行代码实际上证明了一件事：我可以完美地扮演一个时间旅行者。一个 2013 年的 Web 2.0 工程师（我，上一次我作为一名真正的软件工程师时）穿越到了 2026 年，带着现代工具，用他唯一知道的旧方式构建东西。更多的代码。总是更多的代码。工具变了。我的本能没变。
2013 年的工程师骨子里相信一件事：能力等于代码行数。几十年来这个信念都是正确的，直到现在。给我 Codex 或 Claude Code，我能完成 100 到 1000 个工程师的工作。同一张地图，更快的引擎，通往那个如今已是错误目的地的最快路径。
这几乎是现在每一个使用 AI 构建的人所处的境地。他们升级了工具，却保留了 2013 年的心智模型。这个陷阱感觉不像陷阱，因为代码能跑。Garry's List 上线了。这感觉像是我人生中效率最高的一个月。
这是为了一个过时的理念而服务的生产力。
## LLM 曾经很昂贵，所以我们不得不束缚它们
从很长一段时间直到 2025 年的旧经济账：LLM 调用很昂贵，而代码很廉价。所以你编写代码来配给模型，来束缚它，小心翼翼且吝啬地调用它。架构变成了大量保护性地包裹着少量珍贵的模型调用的软件。
这个等式的两半都已经翻转。
模型现在变得便宜，而且每季度都在变得更便宜，而且它如此智能，以至于性价比翻转了。而且模型可以写出可用的代码。所以你停止编写代码去“照看”模型。你现在可以用自然语言指示模型，然后让它编写实际需要的最少量的代码。
这就是即时软件，我们正在进入它的黄金时代。
产出物完全改变了形态。Rails 应用程序是我写的并拥有的 54 万行代码，包括代码加上构建用来约束它的测试。替代品是一个基于 markdown 和代码构建的智能体，只是原来的一小部分。同样的能力。更容易阅读。更容易维护。灵活得多，因为行为存在于你可以用普通语言编辑的指令中，而不是冻结在你编写代码那天的逻辑里。
我们过去写代码去照看一个现在比代码本身更聪明的东西。
## 富士康工厂内部，防跳网和一切
如果你最近在编码，你可能正在不知不觉地建造这种工厂。走一遍你自己的代码库，数一数那些仅仅因为你不信任模型能完成工作而存在的代码行数。
我的：大约 262,000 行应用程序代码，以及大约 276,000 行 bolted onto 用来约束它的测试代码。审计委员会比公司还大。清理器检查模型本来会处理的输入。验证器检查模型本来会捕获的输出。包裹着那些模型会自己恢复的调用的重试循环。每一行都是一个赌注，赌工人会失败。你写了同样的赌注。我们都写了。
127 个后台任务，33 个是 cron 任务。那不是能力。那是为一个 LLM 工人设置的 33 个闹钟，而这个工人如今通常都能准时出现。
在我建造富士康工厂的日子里，Claude 和我写了一个 1,778 行的文件，它唯一的工作就是去质疑模型的事实。它接收模型做出的每一个声明，将其并行分发到五个不同的来源，并给它们打分。一个分流闸门，让简单的声明跳过全面检查。如果第一次返回空结果则重试。后备的后备。
《瑞克和莫蒂》里有一集，瑞克在早餐桌上造了一个小机器人。它启动了，抬起头，问它的目的是什么。瑞克说，“你负责递黄油。”机器人把黄油碟滑过桌子，看着自己的手，说，“天哪。”然后它就坐在那儿。那个机器人蕴含着巨大的潜能。它被造出来只是为了递黄油。我那 27.6 万行测试就是那个黄油碟。
当你以这种 2023 年的富士康工厂方式构建软件时，你建造了一个笼子，如果你不小心，你就会成为为你的 AI 智能体维护这座监狱的狱卒。
## Markdown 现在就是程序
当我说 markdown 时，我不是指提示。提示是 ephemeral 的。你输入点什么，得到点什么，它就蒸发了。
这是构建。版本控制的，测试过的，可复用的。
Markdown 是指令层：意图，技能，关于如何完成工作的判断。TypeScript 是薄薄的确定性层。极少数真正必须成为代码的部分，I/O，绝不能产生幻觉的部分。
关键是，你像测试代码一样测试 markdown。在我的设置中，循环是一个词。我使用智能体构建某物直到它能工作，然后我说“skillify it”（把它技能化）。然后智能体编写：
- markdown 技能
- 它需要的最少代码
- 代码的单元测试
- 技能的 LLM 评估
- 跨越两者的集成测试
- 一个解析器，以便智能体在相关时自动调用该技能
- 以及解析器的评估
那个包就是一个技能包。一个可复用的能力单元，它会产生复利。测试是魔法：技能的覆盖率是使其在不崩溃的情况下改变的原因。这就是它区别于“氛围编码”的地方。氛围编码只是一种氛围。技能包有测试。
我们只是现在才实时搞清楚智能体工程的系统原语，就像早期 CPU 时代发明堆栈、堆、寄存器、冯·诺依曼机器一样。我认为技能包就是其中之一。挽具是另一个。大多数人还没注意到，因为他们仍在用行数来衡量软件。
## 你实际上可以建造的疯狂东西
这不是一个玩具论点。智能体做的比那个五十万行的 Rails 应用还要多，而只用了新代码的一小部分。具体来说：
黑客马拉松评委。两个星期前的周六我们举办了一个 GStack/GBrain 黑客马拉松。85 个参赛作品。我上传了参赛作品的 Google Drive 并说开始。智能体分析了每个仓库的代码质量，对每个出席的人做了深度研究，观看并截图了每个演示视频，给屏幕打分，并对所有 85 个团队进行了排序。然后它告诉我这一批中值得关注的五个应用。评判黑客马拉松从多天的苦差事变成了大约三十分钟。
我没写代码。我让 OpenClaw 去做这个任务，我引导它。然后一旦完成，我说 skillify it，现在它是一个任何人都可以在任何黑客马拉松电子表格上运行的 tarball，永远。我现在一直说“skillify”，我有超过 350 个技能包。几乎每一种我需要做的个人和工作任务，现在我的智能体都能做。
这就是一个例子中的逆转。一种本该是一个真正的软件项目的能力，包括爬虫、评分管道、视频处理、研究模块、排名系统，反而变成了 markdown 加上一点代码，由智能体在一个下午构建，每个人都可以复用。
顺便说一句：黑客马拉松的获胜者实际上构建了代码，我最终把它打磨好并合并到了主分支！GStack 现在可以在模拟器和真实设备上测试 iOS 应用，而那个完整的功能是一个人在黑客马拉松上不到 8 小时完成的！
## Tokenmaxxing
这有一个门槛，几乎没人愿意付：你必须愿意在 tokens 上花钱。
Peter Steinberger 构建了 OpenClaw，我最喜欢的挽具。他说他愿意每年花大约一百万美元的 tokens 来做这件事。大多数人听到这个都会退缩，但他们不应该，因为那是金子：如果你能做到这一点，你就能生活在 2028 年，而且这距离人们追上来还有几年时间。
这就是为什么 OpenAI 决定给每一家 YC 公司提供 200 万美元，以 token 积分的形式作为无上限的 SAFE。当你能将原始智能转化为 tokens，然后输出用户实际可用的并解决用户愿意付费的真实需求的东西时，就会发生某种魔力。如果你是创始人，你需要最大化这种能力。（这就是为什么我一直强调 skillify，因为它是实现这些好结果的真实途径。）
在过去的时代里，我们把 LLM 调用当作太昂贵而不敢调用。我们配给它们。这种本能现在是阻碍人们前进的东西。如果你愿意 tokenmax，让智能体自由地消耗 tokens 并持续运行，你就能获得一个 1994 年互联网时代的先发优势，用 tokens 付费。它把 >99.99% 还在一种价格正在崩塌的资源上数分钱的组织拒之门外，并把先发优势交给了少数懂行的人。
每年几十万美元，对一些人来说甚至更少，你现在就可以用这种方式运行，而这种方式是世界其他地区在几年后被迫采用的。
你可以在 2026 年生活在 2028 年，这是值得现在多付钱的交易，因为那些今天要花 10 万美元的 tokens，明年只要 1 万，后年只要 1 千，也许到 2028 年底只要 100 美元。如果你能告诉历史上任何一位创始人，你可以投资 6 位数的资本来生活在未来 2 到 3 年，并将这种优势保持数年，100 个真正的值得尊敬的创始人中会有 100 个接受这笔交易。
唯一的障碍是 2013 年的本能，它说模型调用太昂贵了，不能随意调用。并非如此。那是旧经济账。逆转已经发生了。
## 伊沙兰，而不是富士康
如果 54 万行控制代码为工人建造了一座富士康工厂，那么解药就是建造相反的东西。
在大苏尔的悬崖上有一个叫伊沙兰的地方。人们去那里是为了被拆解和重建，为了卸下盔甲并变得更像自己。没有流水线，没有工头，没有早上 6 点的哨声。自由，而不是控制。建造那个。建造一个 YC，在那里我们试图帮助你建立解决真实问题并达到产品市场契合的公司。
建造那些人类和 AI 工人都是自由的而不是被奴役的地方。
这就是整个 ethos。创造那些智能体可以自由的东西。创造那些人类可以 bounce their ball 的公司。在知识工作中，工厂是失败的模式。解放人的机构才是目标，只是现在也指向了智能体。
OpenClaw 是一辆你需要自带扳手的法拉利。模型是引擎，不是车。我们仍处于 Apple I 时刻，正在焊接面包板。它发货时很粗糙。你仍然必须自己完成它。GBrain，我开源的检索引擎和技能包，还不是“自带电池”的。
他们说 OpenClaw 不安全。他们不理解自由也是它如此强大的原因。在你知道遇到问题之前，你不会在你信任的东西上 bolt 安全护栏。你手中的扳手是没有人把它关在笼子里的标志。
控制系统是 polished 的，因为控制需要完全的控制，一个富士康工厂。自由的系统是粗糙的，因为它信任你去完成它。选择你在建造哪一个。然后看看你写了多少代码。
## 它实际上意味着什么
54 万行 Rails 代码是我证明我仍能在最高水平上玩旧游戏，但那个水平是十年前的 Web 2.0。
我可以和我以前玩得一样好，在建造富士康工厂方面的 1000 倍工程师。旧代码。
但新游戏根本不是用代码行数来玩的。我的黑粉们，原来你们是对的。如果你在读这篇文章，我向你们致敬。
当你能将意图直接转化为可工作的、经过测试的、可复用的系统时，瓶颈不再是你可以构建多少，而是你真正想要什么以及它是否值得构建。稀缺资源变成了清晰度、品味和判断。写最少代码的工程师往往是构建最多的工程师。
我写了 54 万行才学到这一点。你不必这样做。
该系列：
1. Fat Skills, Fat Code, Thin Harness -- 架构
2. Resolvers -- 智能的路由表
3. The LOC Controversy -- 60 万行代码实际产生了什么
4. Naked Models Are Stupider -- 模型是引擎，不是车
5. The Skillify Manifesto -- 每一个工作流都成为一个可测试的技能
6. Meta-Meta-Prompting -- 复合技能产生涌现能力
7. The Agent Complexity Ratchet -- 90% 的测试覆盖率是你的代码库的魔法
8. 540,000 Lines of Code I Didn't Need -- 你在这里
## 相关链接
- [Garry Tan](https://x.com/garrytan)
- [@garrytan](https://x.com/garrytan)
- [204K](https://x.com/garrytan/status/2061454423034110372/analytics)
- [Garry's List](https://garryslist.org/)
- [GStack](https://github.com/garrytan/gstack)
- [276,000 lines of tests](https://x.com/garrytan/status/2045404377226285538)
- [thin deterministic layer](https://x.com/garrytan/status/2042925773300908103)
- ["skillify it."](https://x.com/garrytan/status/2046876981711769720)
- [resolver](https://x.com/garrytan/status/2044479509874020852)
- [skill pack](https://github.com/garrytan/gbrain/blob/master/docs/skillpack-anatomy.md)
- [tests are the magic](https://x.com/i/article/2054062662225440768)
- [figuring out the systems primitives](https://x.com/garrytan/status/2053127519872614419)
- [actually built code](https://github.com/garrytan/gstack/pull/1574)
- [Peter Steinberger](https://x.com/steipete)
- [OpenClaw](https://github.com/openclaw/openclaw)
- [OpenAI decided to offer $2M to every YC company as an uncapped SAFE in the form of token credits](https://x.com/TheRohanVarma/status/2057648423873270270)
- [not the car](https://x.com/garrytan/status/2045798603059548364)
- [GBrain](https://github.com/garrytan/gbrain)
- [Fat Skills, Fat Code, Thin Harness](https://x.com/garrytan/status/2042925773300908103)
- [Resolvers](https://x.com/garrytan/status/2044479509874020852)
- [The LOC Controversy](https://x.com/garrytan/status/2045404377226285538)
- [Naked Models Are Stupider](https://x.com/garrytan/status/2045798603059548364)
- [The Skillify Manifesto](https://x.com/garrytan/status/2046876981711769720)
- [Meta-Meta-Prompting](https://x.com/garrytan/status/2053127519872614419)
- [The Agent Complexity Ratchet](https://x.com/i/article/2054062662225440768)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [10:26 PM · Jun 1, 2026](https://x.com/garrytan/status/2061454423034110372)
- [204.9K Views](https://x.com/garrytan/status/2061454423034110372/analytics)
- [View quotes](https://x.com/garrytan/status/2061454423034110372/quotes)
---
*导出时间: 2026/6/2 09:07:27*