Kang opens not with a demo, but with a promise. He is a software engineer at PayPal and the CTO of Clustly.ai, and the goal of this workshop is unambiguous — help a non-technical founder ship a product, or help a developer lift their output by an order of magnitude. Everything he is about to show, he uses daily. None of it is theoretical.
Kang 没有一开始就示范工具，而是先开出承诺。他是 PayPal 的软体工程师，同时是 Clustly.ai 的 CTO，今天这场工作坊的目标非常明确——让没有技术背景的创办人也能做出产品，让工程师把产出拉到十倍。接下来要看到的每一招，他自己每天都在用，没有任何一项是纸上谈兵。
"I think if you are a non-technical founder and you want to build something, or if you want to 10x your productivity, this will be a useful workshop."
「我觉得如果你是非技术背景的创办人、想做出东西，或者你想让生产力提升十倍，这场工作坊会对你很有用。」
Kang's framing is worth pausing on. For a long time, he thought VS Code and GitHub Copilot were as good as it gets. You watched the code generate in real time. You nudged the AI line by line. It felt magical. Then he switched to Claude Code, and the mental model collapsed.
Kang 的切入点值得停下来想一想。很长一段时间，他以为 VS Code 配上 GitHub Copilot 已经是极限——代码即时生成，你逐行引导 AI，感觉很神奇。直到他切到 Claude Code，原本的心智模型整个崩塌。
"When I switched to Claude Code, it stopped feeling like a tool and started feeling like a teammate."
「当我切到 Claude Code 之后，它不再像一个工具，而是开始像一个队友。」
The difference sounds subtle but cuts deep. Before, he was a pilot — keyboard in hand, supervising every token the model produced. After, he was a manager. He delegated tasks. He stopped watching. He came back when the work was done.
这个差别听起来很微妙，但其实很深。以前他是驾驶员——双手放在键盘上，盯着模型吐出的每一个 token；现在他是管理者——把任务交出去，不再盯着看，做完再回来收。
To make the point, Kang shared his actual desktop. Four Claude Code tabs, four separate tasks, all running at once. One tab was grinding through a product bug. One was updating the UI. One was testing a feature end to end. The fourth was building the slide deck — the very one projected behind him.
为了把这个观念说清楚，Kang 直接打开他自己的桌面给大家看。四个 Claude Code 分页、四条不同任务，同时在跑。第一个分页在修产品 bug，第二个在更新 UI，第三个在做端到端测试，第四个则是在做投视频——就是他身后正在投出来的那份。
"The entire slide deck here was actually done by AI, my agent assistant."
「这整份投视频其实都是 AI 做的，我的 agent 助手做的。」
This is not a demo. It is the workflow. And it forces a reframe of what Claude Code even is.
这不是示范，这就是他的日常流程。而这个画面也逼你重新思考：Claude Code 到底是什幺。
"I believe Claude Code is not just a coding tool, but a powerful general-purpose agent."
「我认为 Claude Code 不只是写代码的工具，而是一个强大的通用 agent。」
When you treat it as a coding tool, you only use it to write code. When you treat it as a general-purpose agent, you start asking it to prepare your pitch deck, run your tests, triage your inbox — the surface area expands by an order of magnitude.
当你把它当工具用，它只会帮你写代码；当你把它当通用 agent 用，你会开始叫它做简报、跑测试、整理信箱——能用到的面积瞬间放大一个数量级。
The obvious objection: if the agent is this capable, why does it keep forgetting what I just told it? Kang's answer is vivid.
这时候一个很直白的问题浮上来：agent 如果真的这幺强，为什幺我刚刚讲过的东西它转头就忘？Kang 的回答很生动。
"We know AI is actually super smart, but the problem is they have the memory of a goldfish."
「我们知道 AI 其实非常聪明，但问题是它们的记忆力像金鱼一样。」
Large language models, no matter the label on the box, all share this weakness. Long sessions drift. Context gets dropped. The agent starts doing strange things. The fix, for Claude Code, is a file called CLAUDE.md. It is automatically created on first setup, and it is the agent's persistent memory.
不管包装上写哪个品牌，大语言模型都有这个毛病：对话一长就开始漂移，上下文掉光，agent 会开始做一些奇怪的事。Claude Code 给的解法，是一个叫 CLAUDE.md 的档案——第一次设定时就会自动生成，那就是 agent 的长期记忆。
"Every time you ask the agent a question, it gets loaded."
「每次你问 agent 问题时，它都会被载入。」
The trick is not what you put in it — the trick is when you put things in. Kang's rule is simple: the moment you catch yourself telling Claude the same thing twice, tell it to remember. Over time, you stop repeating yourself almost entirely.
重点不在你写了什幺，而在你「什幺时候」写进去。Kang 的规则非常简单：只要你发现自己对 Claude 讲过同样的话两次，就叫它记下来。一段时间之后，你会发现自己几乎不用再重复自己。
Memory is not a single bucket. Kang breaks it into three scopes, each solving a different problem.
记忆不是单一的桶子。Kang 把它拆成三层，每一层处理不同的问题。
| Without CLAUDE.md | With CLAUDE.md |
|---|---|
| 没有 CLAUDE.md | 有 CLAUDE.md |
| Re-explain the stack on every new session. | Agent opens the project already knowing the stack. |
| 每开一个新 session 都要重新解释整个技术栈。 | Agent 一打开专案就已经知道技术栈。 |
| Colleague's agent writes code that breaks your conventions. | Anyone's agent reads the same project rules and follows them. |
| 同事的 agent 写出来的代码不符合你的规范。 | 任何人的 agent 都会读到同一份专案规则并遵守。 |
| Lose track of what the agent did last week. | Local notes persist project progress across sessions. |
| 忘记上周 agent 到底做到哪里。 | 本地笔记把专案进度跨 session 保留下来。 |
| Repeat yourself five times a day. | Once-said, always-remembered. |
| 一天重复自己五次。 | 说过一次，就一直记得。 |
Global memory lives in ~/.claude/CLAUDE.md. This is you — your preferences, your style, your defaults. If you always reach for Supabase over Firebase, put it here. Next project, the agent never asks.
全域记忆放在 ~/.claude/CLAUDE.md，记录的是「你这个人」——你的偏好、风格、预设。假设你永远选 Supabase 而不是 Firebase，就写在这里；下个专案开始时，agent 就不会再问资料库要用哪个。
Project memory lives in ./CLAUDE.md, committed to the repo. This is the team's shared contract — architecture decisions, file conventions, testing rules, off-limits paths. The use case Kang gave: you work in Asia, hand off to a colleague in the US, and without shared rules their agent writes code that violates the codebase.
专案记忆放在 ./CLAUDE.md，会一起 commit 进 repo，是整个团队共享的契约——架构决策、档案规范、测试规则、不能碰的路径。Kang 举的例子很具体：你在亚洲写到一半，交接给美国同事；如果没有共享规则，他的 agent 写出来的代码就会违反整个 codebase 的风格。
"We can set project-level memory so every time your colleague's or team's agent contributes to your codebase, it reads the project-level memory and enforces the guidelines."
「我们可以设定专案层级的记忆，这样每次同事或团队的 agent 来贡献你的 codebase，它都会读这份专案记忆，并且强制遵守。」
Local memory lives in ./.claude/CLAUDE.md — inside the project, but never pushed. Kang calls it "personal notes memory." It tracks what the agent has done, where things stand, what blew up. Useful to you, useless to the team, and honest enough to be kept out of the commit.
本地记忆放在 ./.claude/CLAUDE.md——在专案目录里，但不会被 push 出去。Kang 称之为「个人笔记式的记忆」，用来记录 agent 做过什幺、进度到哪、哪里踩雷。对你很有用，对团队没用，而且诚实到不适合 commit 进去。
"Make sure to keep it short and concise, because we don't want it to be like a paragraph or an essay. We want it concise and short."
「一定要保持简短，不要写成一段散文或一篇文章，我们要的是精简。」
The best CLAUDE.md files aren't documentation. They are operating instructions for your AI teammate — the shorter, the better.
最好的 CLAUDE.md 不是文档档，而是给 AI 队友的操作手册——越短越好。
If CLAUDE.md is the agent's memory, the G-Stack is the agent's skill set. Kang introduces it by introducing its creator first, because in this case the creator is the point.
如果 CLAUDE.md 是 agent 的记忆，那 G-Stack 就是 agent 的技能集。Kang 介绍 G-Stack 之前，先介绍了它的作者，因为在这个故事里，作者本身就是重点。
Gary Tan is the CEO of Y Combinator, the most famous startup accelerator in the world. Before YC, he was early at Palantir, founded his own company, and was Coinbase's first investor. Decades of pattern-matching on what good products and good engineering look like.
Gary Tan 是 Y Combinator 的 CEO，全世界最有名的创业加速器。在 YC 之前，他是 Palantir 的早期员工，创办过自己的公司，也是 Coinbase 的第一个投资人。这是几十年来对「好产品」和「好工程」的模式识别。
Three weeks before this workshop, Gary open-sourced the G-Stack. The growth curve is not subtle.
这场工作坊的三周前，Gary 把 G-Stack 开源。成长曲线不需要解释。
"G-Stack has collected over 60K stars and 9K forks."
「G-Stack 已经累积了超过六万颗 star 和九千次 fork。」
60,000 stars in three weeks. For any open-source project, that trajectory is rare. What makes it rarer is Gary's own usage data:
三周六万颗 star，对任何开源专案来说都极为罕见。更罕见的是 Gary 自己的使用数据：
"It was reported that Gary himself used this tool and wrote 600,000 lines of code."
「据说 Gary 自己用这套工具写了六十万行代码。」
Six hundred thousand lines. This is not a demo. This is the YC president's personal stack, exposed for everyone to copy.
六十万行。这不是 demo，这是 YC 总裁自己在用、然后直接摊在阳光下让所有人抄的一套武器。
G-Stack is not a framework or a library. It is a collection of skills you install into your agent, each one encoding a specific piece of YC-grade thinking. Kang walked through them:
G-Stack 不是框架、不是函数库，而是一组你安装到 agent 身上的技能，每一项都封装了一块 YC 等级的思考。Kang 依序介绍：
"Please note the word 'senior' — this isn't an exaggeration. Gary poured his years of YC experience into these skills."
「注意『senior』这个字——不是夸饰。Gary 把他在 YC 多年的经验灌进了这些技能。」
The word "senior" in a skill name is usually marketing. In the G-Stack it is load-bearing. Gary encoded the lessons he absorbed from reviewing thousands of startups into slash commands — and you get to run them.
技能名称里的「senior」，通常只是行销话术；在 G-Stack 里它是有重量的。Gary 把他审过几千家新创之后累积下来的经验，编码成 slash command，让你可以直接跑。
For a non-technical founder, the G-Stack is the closest thing to a senior co-founder on tap.
对没有技术背景的创办人来说，G-Stack 是最接近「随叫随到的资深共同创办人」的东西。
A week before the workshop, Claude Code's source code accidentally leaked during a release. Kang calls it an accident. The community calls it a gift. Because what was inside explained something everyone had been wondering about.
这场工作坊的一周前，Claude Code 的原始码在一次发布时意外外泄。Kang 称之为意外，社区则视为礼物——因为里面的内容解释了一件大家一直好奇的事。
"Claude Code actually creates a copy of the parent context when you spin up a sub-agent."
「当你启动一个子 agent 时，Claude Code 其实会复制一份父 context。」
Translated: when you fork five sub-agents, they share the parent's context. The API caches that copy. The cost of running five agents in parallel is roughly the cost of running one. This changes the economics of parallelism.
翻译成人话：当你 fork 出五个子 agent，它们共享父 context，API 会缓存这份副本。五个 agent 并行执行的成本，和跑一个 agent 差不多。这直接改变了并行运算的经济学。
"This means when you ask Claude to run 5 sub-agents, they all share the same memory, and the cost equals spinning up just 1 agent."
「这意味着当你叫 Claude 跑五个子 agent，它们共享同一份记忆，成本等于只开一个 agent。」
The architecture is built for parallelism. Using it single-threaded is, in Kang's words, practically a crime.
整个架构天生就是为并行设计的。用 Kang 的话说，单执行绪地用它，简直是浪费。
Once that clicks, the three execution modes make sense. A Fork inherits the parent's context and is cache-optimized — use it for the general case. A Teammate runs in its own tmux or iTerm pane and talks to the main agent via a file-based mailbox — use it when you need a clean environment. A Worktree gives each agent its own git branch via git worktree — use it when you need code-level isolation.
一旦这点想通，三种执行模式就自然到位了。Fork 继承父 context、享受缓存优化——一般任务用这个；Teammate 在独立的 tmux/iTerm 分页跑，和主 agent 透过档案信箱通讯——需要干净环境时用；Worktree 给每个 agent 自己的 git 分支——需要代码层级隔离时用。
Kang showed a prompt no longer than a tweet:
Kang 展示了一段比一则推文还短的 prompt：
"Create an agent team to explore this project from different angles: one focused on UX, one on architecture, one as devil's advocate."
「创建一个 agent 团队，从不同角度检视这个专案：一个负责 UX、一个负责架构、一个当反方。」
Claude split that one sentence into three roles — UX Researcher, System Architect, Devil's Advocate — and dispatched them in parallel.
Claude 把这句话拆成三个角色——UX 研究员、系统架构师、反方代言人——然后并行派发出去。
"You don't need to split the tasks yourself, Claude can automatically do it for you."
「你不用自己拆任务，Claude 会自动帮你拆。」
Kang's personal favourite inside this feature set is the /branch command. Mid-conversation, at any moment, he can type /branch and fork the current session. Full context carries over. He explores a new direction, and if it doesn't work, he throws it away and returns to the original session with claude -r <session-id>. No coordination overhead, no agents talking past each other — just a version-controlled conversation tree.
在这组功能里，Kang 个人最爱的是 /branch。对话到一半，任何时候他都可以打 /branch，当场把目前这个 session fork 出去；完整 context 跟过去，他在分支上试一个新方向，不行就丢掉，用 claude -r <session-id> 回到原本的 session。没有协调成本，也不会有 agent 对不上话——就是一棵版本控制的对话树。
"Agent teams are powerful, but /branch gives me more control. You're always in the driver's seat."
「Agent 团队很强大，但 /branch 给我更多控制权。你一直坐在驾驶座上。」
The best founders aren't typing code anymore. They are directing agents.
最好的创办人已经不再手打代码，他们在指挥 agent。
The last piece is the one that makes the rest portable. Claude's mobile app connects back to your local session — same filesystem, same MCP servers, same tools. Nothing moves to the cloud. The work stays on your machine; only the control surface travels.
最后一块，是让上面所有东西可以带着走的那块。Claude 的手机 app 会连回你自己电脑上的 session——同一个档案系统、同一组 MCP server、同一套工具，什幺都没有搬到云端。工作还是留在你的机器上，只是「控制接口」跟着你走。
"If you have the Claude mobile app, you can connect to your local session even when you're away from your computer."
「如果你有 Claude 的手机 app，就算你离开电脑，也可以连回本地 session。」
Kang's favourite example is disarmingly honest: you are out at a party, but a piece of unfinished work is still looping in your head. Instead of ruining the night or rushing home, you open the phone and keep going. Check agent progress on the commute. Dispatch new tasks from a café. Slip in a quick review between meetings.
Kang 举的例子很诚实：你人在派对上，但脑子里还在转那件没做完的工作。与其毁掉整个晚上、或是赶回家，你可以直接打开手机继续做。通勤时检查 agent 进度、在咖啡厅用手机派任务、会议空档顺手 review 一下——就是这些场景。
Claude Code at Clustly is not used as a coding tool — it's used as infrastructure.
在 Clustly，Claude Code 不是被当成写代码的工具，而是被当成基础设施。
The arc of the talk is simple. A tool becomes a teammate when it has memory. A teammate becomes a team when you can fork it. A team becomes infrastructure when you can reach it from anywhere. Each layer compounds on the last.
整场分享的弧线其实很简单。工具有了记忆，就变成队友；队友可以 fork，就变成团队；团队你随处可连，就变成基础设施。每一层都在前一层之上累积。
The practical starting point is unglamorous. Install Claude Code. Install the G-Stack. Run /office-hours once and let it interrogate your next idea through six questions. Update your CLAUDE.md the first time you catch yourself repeating a preference. Then do it again tomorrow.
实际的起点一点都不酷：安装 Claude Code、安装 G-Stack、跑一次 /office-hours，让它用六个问题把你下一个 idea 拷问一遍；第一次发现自己在重复某个偏好时，就更新 CLAUDE.md。然后明天再做一次。
Early adoption here compounds faster than it looks. The team that writes things down once, trusts the agent to parallelise, and keeps their memory file short — ends up shipping what used to take a company of ten. This is not a forecast. This is Kang's week.
在这件事上，早一点开始会以比你想像中更快的速度复利成长。一个只写一次规则、愿意让 agent 并行、记忆档案维持精简的小团队，最后做出来的东西，会是原本要十人公司才做得完的量。这不是预测，这就是 Kang 这礼拜的日常。