The Secrets of Claude Code

"This podcast is sponsored by Google. Hey folks, I'm Omar, product and design lead at Google DeepMind. We just launched a revamped vibe coding experience in AI Studio that lets you mix and match AI capabilities to turn your ideas into reality faster than ever."

"本期播客由 Google 赞助。大家好,我是 Omar,Google DeepMind 的产品与设计负责人。我们刚刚在 AI Studio 里上线了全新改版的 vibe coding 体验,你可以自由组合各种 AI 能力,比以往更快地把想法变成现实。"

"Just describe your app and Gemini will automatically wire up the right models and APIs for you. And if you need a spark, hit 'I'm feeling lucky' and we'll help you get started. Head to ai.studio/build to create your first app."

"只要描述一下你的 app,Gemini 就会自动帮你接好合适的模型和 API。要是缺点灵感,点一下「手气不错」,我们帮你开个头。去 ai.studio/build 做你的第一个 app 吧。"

"Cat, Boris, thank you so much for being here."

"Cat、Boris,非常感谢你们来。"

"Thanks for having us."

"谢谢你邀请我们。"

"So for people who don't know you, you are the creators of Claude Code. Thank you very much from the bottom of my heart. I love Claude Code."

"给还不认识你们的人介绍一下:你们就是 Claude Code 的创造者。我打心底里感谢你们。我太爱 Claude Code 了。"

"That's amazing to hear. That's what we love to hear."

"太高兴听到这话了。这正是我们最想听到的。"

"Okay, I think the place I want to start is when I first used it. There was this moment—I think it was around when Sonnet 3.7 came out—where I used it and I was like, 'Holy, this is a completely new paradigm. It's a completely new way of thinking about code.'"

"好,我想从我第一次用它的时候讲起。有那么一个瞬间——大概是 Sonnet 3.7 出来那会儿——我用了一下,心想:'天哪,这是一个全新的范式,是一种全新的看待代码的方式。'"

"And the big difference was you went all the way and just eliminated the text editor. All you do is talk to the terminal, and that's it. Previous paradigms of AI programming, previous harnesses, have been: you have a text editor and you have the AI on the side, or it's a tab complete."

"最大的区别是,你们走到了极致——直接把文本编辑器给砍掉了。你要做的就是跟终端对话,仅此而已。而以前的 AI 编程范式、以前的 harness,都是:你有一个文本编辑器,AI 在旁边待命;要么就是一个 tab 自动补全。"

"So take me through that decision process, that process of architecting this new paradigm. How did you think about that?"

"所以,带我走一遍那个决策过程吧——你们是怎么把这个新范式设计出来的?当时是怎么想的?"

"Yeah, I think the most important thing is it was not intentional at all. [laughter] We sort of ended up with it."

"嗯,我觉得最重要的一点是:它根本不是刻意设计出来的。[笑] 我们是稀里糊涂走到这一步的。"

"So at the time when I joined Anthropic—we were still on different teams—there was this previous predecessor to Claude Code. It was called Clyde. It was this research project; it took like a minute to start up. It was this kind of really heavy Python thing. It had to run a bunch of indexing and stuff."

"我刚加入 Anthropic 的时候——那会儿我和 Cat 还不在一个团队——有一个 Claude Code 的前身,叫 Clyde。它是个研究项目,启动一次得花将近一分钟。它是个很笨重的 Python 东西,跑起来要先做一大堆索引之类的。"

"When I joined I wanted to ship my first PR and I hand-wrote it like a noob. [laughter] I didn't know about any of these tools."

"我刚来时想提交我的第一个 PR,结果像个新手一样纯手写。[笑] 那些工具我一个都不知道。"

"Thank you for admitting that."

"谢谢你肯承认这个。"

"I didn't know any better. And then I put up this PR, and Adam Wolf—who was the manager for our team for a while, he was my ramp-up buddy—he just rejected the PR. He was like, 'You wrote this by hand? What are you doing? Use Claude.' Because he was also hacking a lot on it at the time."

"我那会儿真不懂。然后我提了这个 PR,Adam Wolf——他有段时间是我们团队的负责人,也是带我上手的搭档——直接把 PR 给打回来了。他说:'你这是手写的?你在干嘛?用 Claude 啊。'因为他当时也在大量地拿它做实验。"

"And so I tried it. I gave it the description of the task and it just one-shotted this thing."

"于是我试了试。我把任务描述丢给它,它居然一把就把这事给做出来了。"

"And this was Sonnet 3.5, so I still had to fix a thing even for this kind of basic task, and the harness was super old. So it took like 5 minutes to turn this thing out—it just took forever. But it worked, and I was just mind-blown that this was even possible. And that kind of got the gears turning: maybe you don't actually need an IDE."

"那还是 Sonnet 3.5,所以哪怕这种很基础的任务,我还是得手动修一处;而且 harness 特别老旧。它折腾了大概 5 分钟才把东西吐出来,慢得要命。但它真的成了,我整个人都惊到了——这事居然能成。脑子里的齿轮就开始转了:也许你压根不需要 IDE。"

"And then later on I was prototyping using the Anthropic API, and the easiest way to do that was just building a little app in the terminal—that way I didn't have to build a UI or anything. I started making a little chat app, and then I thought, maybe we could do something a little bit like Clyde. So let me build a little Clyde. And it actually ended up being a lot more useful than that without a lot of work."

"后来我在用 Anthropic 的 API 做原型。最省事的办法就是在终端里搭个小 app——这样我连 UI 都不用做。我先做了个简单的 chat app,然后想:或许能做个有点像 Clyde 的东西。那就做个迷你版 Clyde 吧。结果没费多大劲,它就比预想的有用得多。"

"And I think the biggest revelation for me was when we started to give the model tools. It just started using tools, and it was this insane moment. The model just wants to use tools. We gave it bash and it just started using bash, writing AppleScript to automate stuff in response to questions."

"对我来说最大的顿悟,是我们开始给模型工具的时候。它就这么自顾自地用起工具来了,那一刻太疯狂了。模型天生就想用工具。我们给了它 bash,它立马就开始用 bash,甚至写 AppleScript 去自动化一些操作来回答问题。"

"I was like, this is the craziest thing, I've never seen anything like this. Because at the time I had only used IDEs with one-line autocomplete, multi-line autocomplete, whatever. So that's where this came from—a convergence of prototyping but also seeing what's possible in a very rough way."

"我当时想,这太炸裂了,我从没见过这种东西。因为那会儿我用过的也就是带单行补全、多行补全之类的 IDE。所以它就是这么来的——既是做原型时的产物,也是在很粗糙的状态下窥见了'原来还能这样'。"

"And this thing ended up being surprisingly useful, and I think it was the same for us. For me it was like Sonnet 4 / Opus 4—that's where that magic moment was. I was like, 'Oh my god, this thing works.'"

"这东西最后好用得出乎意料,我想我们其他人也有同感。对我来说那个魔法时刻是在 Sonnet 4 / Opus 4 那会儿。我当时就是:'天哪,这玩意儿真的成了。'"

"That's interesting. So tell me about that tool moment, because I think that is one of the special things about Claude Code—it just writes bash and it's really good at it."

"挺有意思。跟我讲讲那个'工具时刻'吧,因为我觉得这正是 Claude Code 特别的地方之一——它就直接写 bash,而且写得特别好。"

"A lot of previous agent architectures, or even anyone building an agent today, your first instinct might be: okay, we're going to give it a find-file tool, and an open-file tool, and you build all these custom wrappers for all the different actions you might want the agent to take. But Claude Code just uses bash and it's really good at it. So how do you think about what you learned from that?"

"很多早期的 agent 架构,甚至今天任何在做 agent 的人,第一反应可能都是:好,我给它一个'找文件'的工具,再给一个'打开文件'的工具,然后为 agent 可能要做的各种动作都包一层自定义封装。但 Claude Code 就直接用 bash,而且用得很好。所以你从这件事里学到了什么,你是怎么想的?"

"Yeah, I think we're at this point right now where Claude Code actually has a bunch of tools—it's like a dozen or something. We actually add and remove tools most weeks, so this changes pretty often."

"嗯,我们现在的状态是,Claude Code 其实有挺多工具——大概十几个吧。我们基本上每周都在加工具、删工具,所以它变得挺频繁的。"

"Today there is a tool for searching. And we do this for two reasons. One is the UX, so we can show the result a little bit nicer to the user—because there's still a human in the loop right now for most tasks. The second is for permissions: so if you say in your Claude Code settings.json 'this file you cannot read,' we have to enforce this. We enforce it for bash, but we can do it a little more efficiently if we have a specific search tool."

"现在是有一个专门用来搜索的工具的。我们这么做有两个原因。一是 UX——这样我们能把结果更漂亮地展示给用户,因为眼下大多数任务里还是有人在回路里的。二是权限:如果你在 Claude Code 的 settings.json 里写了'这个文件不能读',我们就得强制执行。我们对 bash 也强制,但如果有一个专门的搜索工具,执行起来会更高效一点。"

"But definitely we want to unship tools and keep it simple for the model. Like a week or two ago we unshipped the LS tool, because in the past we needed it, but then we actually built a way to enforce this permission system for bash. So in bash, if we know that you're not allowed to read a particular directory, Claude's not allowed to ls that directory."

"但我们的方向肯定是想下线工具、给模型保持简单。比如一两周前,我们把 LS 工具下线了——以前我们需要它,但后来我们真的做出了一套能在 bash 里强制权限的机制。所以现在在 bash 里,如果我们知道你不被允许读某个目录,那 Claude 也不被允许去 ls 那个目录。"

"And because we can enforce that consistently, we don't need this tool anymore. This is nice because it's a little less choice for Claude, a little less stuff in context."

"正因为我们能一致地强制这一点,这个工具我们就不再需要了。这样挺好,因为对 Claude 来说少了一个选项,context 里也少了一点东西。"

"Got it. And how do you guys split responsibility on the team?"

"懂了。那你们团队内部是怎么分工的?"

"I would say Boris sets the technical direction and has been the product visionary for a lot of the features that we've come out with. I see myself more as a supporting role—to make sure that our pricing and packaging resonates with our users, and that we're shepherding all our features across the launch process."

"我会说 Boris 定技术方向,我们出的很多功能背后的产品愿景也是他。我把自己更多看成一个支撑角色——确保我们的定价和打包方式能打动用户,并且把每个功能一路护送着走完发布流程。"

"So from deciding 'all right, these are the prototypes that we should definitely ant-food,' to setting the quality threshold for ant-fooding, through to communicating that to our end users."

"从'好,这些原型是我们一定要拿去 ant-food(内部试用)的',到给内部试用定下质量门槛,再到把这些对外传达给终端用户。"

"Historically a lot of Claude Code has been built bottoms-up—Boris and a lot of the core team just had these great ideas: to-do lists, sub-agents, hooks—all bottoms-up. As we think about expanding to more services and bringing Claude Code to more places, a lot of those are more like: all right, let's talk to customers, bring engineers into those conversations, prioritize those services and knock them out."

"Claude Code 历来很多是自下而上长出来的——Boris 和很多核心成员自己就冒出了那些好点子:to-do list、sub agent、hooks,全是自下而上的。但当我们开始考虑拓展到更多场景、把 Claude Code 带到更多地方时,这些就更像是:好,我们去跟客户聊,把工程师拉进对话里,排好这些场景的优先级,一个个拿下。"

"Got it. What is ant-fooding?"

"懂了。什么叫 ant-fooding?"

"[Cat & Boris] Oh, ant-fooding… it means dog-fooding. [laughter]"

"[Cat、Boris]哦,ant-fooding……就是 dog-fooding(吃自家狗粮、内部试用)的意思。[笑]"

"Anthropic—'ant.' I got it. [laughter]"

"Anthropic——'ant'(蚂蚁)。我懂了。[笑]"

"Yeah. Our nickname for internal employees is 'ant.' So ant-fooding is our version of dog-fooding. Internally, I think over 70 or 80% of ants—technical Anthropic employees—use Claude Code every day."

"对。我们给内部员工起的外号叫'ant'(蚂蚁)。所以 ant-fooding 就是我们版本的 dog-fooding。内部来说,我觉得有超过 70%–80% 的 ant——也就是技术岗的 Anthropic 员工——每天都在用 Claude Code。"

"Every time we're thinking about a new feature, we push it out to people internally and we get so much feedback. We have a feedback channel—I think we get a post every five minutes. So you get really quick signal on whether people like it, whether it's buggy, or whether it's not good and we should unship it."

"每次我们琢磨一个新功能,都会先推给内部的人,然后能收到海量反馈。我们有一个专门的反馈频道——我觉得差不多每五分钟就有一条新帖。所以你能很快拿到信号:大家喜不喜欢、有没有 bug,或者它就是不行、我们该把它下线。"

"You can tell that someone who is building stuff is using it all the time to build it, because its ergonomics just make sense if you're trying to build stuff—and that only happens if you're ant-fooding. [laughter] And I think that's a really interesting paradigm for building new stuff: that sort of bottoms-up, 'I make something for myself.' Tell me about that."

"你能感觉得出来,这东西是一个真在动手造东西的人天天用着造出来的——因为如果你真在造东西,它的手感处处都说得通,而这只有在你真的 ant-fooding 时才会发生。[笑] 我觉得这是一种很有意思的做新东西的范式:那种自下而上的、'我先给自己做一个'。跟我讲讲这个。"

"Yeah. And Cat is also so humble. Cat has a really big role in the product direction too. It comes from everyone on the team—these specific examples came from everyone: to-do lists and sub-agents, that was Sid; hooks, Dixon shipped that; plugins, Daisy shipped that."

"是。而且 Cat 太谦虚了。Cat 在产品方向上其实分量很重。这些都是全队一起来的——具体这些例子都来自团队里的每一个人:to-do list 和 sub agent 是 Sid 做的;hooks 是 Dixon 发布的;plugins 是 Daisy 发布的。"

"So these ideas come from everyone. We build this core agent loop and this core experience, and then everyone on the team uses the product all the time—and everyone outside the team uses it all the time. So there are all these chances to build things that serve these needs."

"所以这些点子来自所有人。我们搭好这个核心的 agent loop、这个核心体验,然后团队里每个人都在不停地用这个产品——团队外的每个人也在不停地用。于是就处处都是机会,去做出能满足这些需求的东西。"

"For example, bash mode—the exclamation mark, where you can type in bash commands. This was many months ago. I was using Claude Code and going back and forth between two terminals, and just thought it was kind of annoying. On a whim I asked Claude to think of ideas, it thought of this exclamation-mark bash mode, and I was like, 'great, make it pink, and ship it.' [laughter] It just did it. And that's the thing that still persisted—now you see others catching on to that too."

"比如 bash mode——就是那个感叹号,你可以直接敲 bash 命令。那是好几个月前的事了。我当时在用 Claude Code,要在两个终端之间来回切,就觉得有点烦。一时兴起,我让 Claude 想几个点子,它想出了这个感叹号 bash mode,我就说:'好,把它弄成粉色的,然后发布。'[笑] 它就真做了。而且这东西一直留到了现在——你现在能看到别人也开始跟进这个做法了。"

"That's funny, I actually didn't know that. And that's extremely useful, because I always have to open up a new tab to run any bash commands. So you just do an exclamation point and it runs directly, instead of filtering it through all the Claude stuff."

"挺逗的,我之前还真不知道。而且这太有用了,因为我每次要跑 bash 命令都得开个新标签页。所以你只要打一个感叹号,它就直接跑了,而不用经过 Claude 那一整套来回处理。"

"Yeah. And Claude Code sees the full output too. So anything you see in the Claude Code view, Claude Code also sees."

"对。而且 Claude Code 也会看到完整的输出。所以你在 Claude Code 界面里看到的任何东西,Claude Code 自己也都看得到。"

"And this is kind of a UX thing that we're thinking about. In the past, tools were built for engineers, but now it's equal parts engineers and model. As an engineer you can see the output, but it's actually quite useful for the model also."

"这其实是我们正在琢磨的一个 UX 问题。过去工具是为工程师做的,但现在是工程师和模型各占一半。作为工程师你能看到输出,而这些输出对模型来说其实也很有用。"

"This is part of the philosophy too—everything is dual-use. So for example, the model can also call slash commands. I have a slash command for /commit, where I run through a few different steps like diffing and generating a reasonable commit message. I run it manually, but Claude can also run this for me. And this is pretty useful, because we get to share this logic—we define this tool and then we both get to use it."

"这也是我们理念的一部分——一切都是双用的(dual-use)。比如说,模型也可以调用 slash command。我有一个 /commit 的 slash command,它会走几个步骤:比如 diff、再生成一条像样的 commit message。我手动跑它,但 Claude 也能替我跑。这就很有用,因为这套逻辑可以共享——我们定义这一个工具,然后我和模型都能用。"

"What are the differences in designing tools that are dual-use from designing tools that are used by one or the other?"

"设计'双用'工具,和设计只给人或只给模型用的工具,有什么不一样?"

"Surprisingly, it's the same. So far. [laughter] I sort of feel like this kind of elegant design for humans translates really well to the models."

"出乎意料的是,一样。目前为止是这样。[笑] 我隐约觉得,这种对人类来说优雅的设计,迁移到模型身上效果也特别好。"

"So you're just thinking about what would make sense to you, and generally it makes sense to the model too if it makes sense to you."

"所以你其实就是在想'对我来说怎样才说得通',而只要对你说得通,一般对模型也说得通。"

"Yeah. I think one of the really cool things about Claude Code being a terminal UI—and what made it work really well—is that Claude Code has access to everything that an engineer does at the terminal."

"对。我觉得 Claude Code 作为一个终端 UI,有一点特别酷——也正是它能这么好用的原因——就是工程师在终端里能做的一切,Claude Code 都能做。"

"And when it comes to whether the tool should be dual-use or not, making them dual-use actually makes the tools a lot easier to understand. It just means that everything you can do, Claude Code can do. There's nothing in between."

"而说到一个工具该不该做成双用,把它们做成双用其实让工具更容易理解。它意味着:你能做的一切,Claude Code 都能做,中间没有任何夹层。"

"Yeah, that's interesting. There are a couple of those decisions. No code editor—it's in the terminal, so it has access to your files. And it's on your computer versus in the cloud in a virtual machine. So you get to use it in a repeated way, where you can build up your CLAUDE.md file, build slash commands, and it becomes very composable and extensible from a very simple starting point."

"嗯,挺有意思。这里面有好几个这样的决定。没有代码编辑器——它在终端里,所以能访问你的文件。而且它跑在你自己的电脑上,而不是云端的虚拟机里。这样你就能反复地用它,逐步积累起你的 CLAUDE.md 文件、做出各种 slash command,从一个非常简单的起点开始,慢慢变得极其可组合、可扩展。"

"And I'm curious how you think about—for people who want to build an agent, probably not Claude Code but something else—how you get that simple package that can then extend and be really powerful over time."

"我很好奇你们是怎么想的——对那些想做一个 agent 的人来说(大概不是做 Claude Code,而是别的东西),你怎么才能拿到那种简单的'内核',又能随时间扩展、变得真正强大?"

"For me, I start by thinking about it like developing any kind of product, where you have to solve the problem for yourself before you can solve it for others. This is something they teach at YC—you have to start with yourself. If you can solve your own problem, it's much more likely you're solving the problem for others."

"对我来说,我会把它当成做任何产品一样来想:你得先为自己把问题解决了,才谈得上为别人解决。这也是 YC 教的东西——你必须从自己出发。如果你能解决自己的问题,那你大概率也在为别人解决问题。"

"For coding, starting locally is the reasonable thing. And now we have Claude Code on the web, so you can also use it with a virtual machine in a remote setting—this is super useful when you're on the go and want to take it from your phone."

"对编程来说,从本地起步是合理的。而现在我们有了网页版的 Claude Code,所以你也可以配着虚拟机在远程环境里用它——当你在路上、想从手机上调用它时,这特别有用。"

"And we started proving this out a step at a time, where you can do @claude in GitHub. I use this every day—on the way to work, I'm at a red light (I probably shouldn't be doing this), and I'm on GitHub like '@claude, fix this issue.' It's just real useful to be able to control it from your phone."

"我们是一步一步把这件事验证出来的,比如你可以在 GitHub 里 @claude。我每天都这么用——上班路上等红灯的时候(我大概不该这么干),我就在 GitHub 上 '@claude,把这个 issue 修一下'。能从手机上指挥它,真的太有用了。"

"I don't know if this necessarily makes sense for every kind of use case. For coding, I think starting local is right. I don't know if this is true for everything, though."

"我不确定这是不是对每种场景都成立。对编程,我觉得从本地起步是对的。但是不是对所有东西都成立,我就不知道了。"

"Got it. What are the slash commands you guys use?"

"懂了。你们自己常用哪些 slash command?"

"/commit. I think the /commit command makes it a lot faster for Claude to know exactly what bash commands to run in order to make a commit."

"/commit。我觉得 /commit 这个命令能让 Claude 快很多地知道:到底要跑哪些 bash 命令才能提交一次 commit。"

"And what does the /commit slash command do, for people who are unfamiliar?"

"对不熟的人来说,/commit 这个命令具体是干嘛的?"

"Oh, it just tells it exactly how to make a commit. You can dynamically say: okay, these are the three bash commands that need to be run."

"哦,它就是告诉它该怎么提交 commit。你可以动态地说:好,这是需要跑的三条 bash 命令。"

"And what's pretty cool is we have this templating system built into slash commands. So we actually run the bash commands ahead of time—they're embedded into the slash command. And you can also pre-allow certain tool invocations. So for that slash command we say 'allow git commit, git push, gh,' so you don't get asked for permission after you run the slash command, because we have a permission-based security system."

"而且挺酷的是,我们在 slash command 里内置了一套模板系统。所以那些 bash 命令其实是提前就跑好的——它们被嵌进了 slash command 里。你还可以预先放行某些工具调用。比如那个命令里我们写'放行 git commit、git push、gh',这样你跑完这个 slash command 之后就不会再被问权限了,因为我们有一套基于权限的安全机制。"

"And it also uses Haiku, which is pretty cool—a cheaper and faster model. For me, I use commit, commit-PR, and feature-dev a lot. Sid created this one—it's kind of cool. It walks you through step by step building something. So we prompt Claude to first ask me exactly what I want—build the specification—"

"而且它还用的是 Haiku,这点挺酷——一个更便宜、更快的模型。我个人常用 commit、commit-PR,还有 feature-dev 用得很多。feature-dev 是 Sid 做的,挺妙。它一步步带着你把东西做出来。我们会提示 Claude 先问清楚我到底想要什么——先把规格(specification)定下来——"

"—and then build a detailed plan, then make a to-do list and walk through step by step. So it's more structured feature development."

"——然后做出一份详细的计划,再列一个 to-do list,一步步走下去。所以这是一种更有结构的功能开发。"

"And then the last one we use a lot: we use security-review for all of our PRs, and also code-review. Claude does all of our code review internally at Anthropic. There's still a human approving it, but Claude does the first step in code review. That's just a /code-review command."

"还有我们用得很多的最后一个:我们所有 PR 都跑 security-review,还有 code-review。Anthropic 内部所有的 code review 都是 Claude 在做。当然还是有人来最终批准,但 code review 的第一步是 Claude 做的。那就是一个 /code-review 命令。"

"The thing I'd love to go deeper into is: how do you make a good plan? The feature-dev thing—because there are a lot of little tricks that people at Every are starting to find that work, and I'm curious what we're missing."

"我特别想深入聊的是:怎么做一个好的计划?也就是 feature-dev 那套——因为我们 Every 的人开始摸索出不少管用的小窍门,我也很好奇我们还漏了什么。"

"For example, one unintuitive step of the plan-development process: even if I don't exactly know what needs to be built—I just have a little sentence in my mind, like 'I want feature X'—I have Claude just implement it without giving it anything else, and I see what it does. That helps me understand 'okay, here's what I actually mean,' because it made all these mistakes, or did something I didn't expect."

"举个例子,计划开发过程里有一个不太直觉的步骤:哪怕我还不确切知道要做的是什么——脑子里只有一句话,比如'我想要功能 X'——我也会让 Claude 啥都不多给、就直接去实现它,然后看它做成什么样。这反而帮我搞清楚'噢,我真正想要的是这个',因为它会犯一堆错,或者做出一些我没料到的东西。"

"Then I use the learning from that throwaway development—I just clear it out—and that helps me write a better plan spec for the actual feature dev. Which is something you would never do before, because it'd be too expensive to just yolo send an engineer on a feature you hadn't actually speced out. But because you have Claude going through your codebase and doing stuff, you can learn from it, and that helps inform the actual plan you make."

"然后我把这次'抛弃式开发'里学到的东西拿过来——把那一版直接清掉——它帮我为真正的功能开发写出更好的需求规格。这在以前是绝对不会做的,因为太奢侈了:你不可能在还没写需求的情况下就'梭哈'派一个工程师去做一个功能。但因为现在是 Claude 在你的代码库里跑来跑去地做,你可以从中学到东西,这就反过来给你真正要写的计划提供了依据。"

"Yeah, maybe I can start, and I'm curious how you use it too. I think there are a few different modes for me. One is prototyping mode. Like traditional engineering prototyping—you want to build the simplest possible thing that touches all the systems, just to get a vague sense of what the systems are, where the unknowns are, and to trace through everything."

"嗯,我先讲吧,我也很好奇你怎么用。对我来说大概有几种不同的模式。一种是原型模式。就像传统工程里的搭原型——你想做出一个尽量简单、但能把所有系统都串一遍的东西,只是为了大致摸清都有哪些系统、未知点在哪,把整条链路走一遍。"

"And I do the exact same thing as you, Dan—Claude just does the thing, I see where it messes up, then ask it to throw it away and do it again. Just hit escape twice, go back to the old checkpoint, and try again."

"我做的跟你完全一样,Dan——让 Claude 先把东西做出来,我看它在哪儿翻车,然后让它整个丢掉重做。就是连按两下 escape,回到之前的检查点,再来一遍。"

"There are maybe two other kinds of tasks. One is things Claude can one-shot and I feel pretty confident it can do—I'll just tell it, go to a different tab, shift-tab to auto-accept, and go do something else, or tend to another one of my Claudes while it does this."

"另外大概还有两类任务。一类是 Claude 能一把搞定、而且我挺有把握它能做成的——我就直接告诉它,然后切到另一个标签页,按 shift-tab 切成自动接受,自己去干别的,或者去照看我另外一个正在跑的 Claude。"

"But there's also this harder feature development—things that in the past would have taken a few hours of engineering time. For this I'll shift-tab into plan mode and align on the plan first, before it even writes any code. And what's really hard about this is the boundary changes with every model, in a surprising way: the newer models are more intelligent, so the boundary of what you need plan mode for got pushed out a little bit."

"但还有那种更难的功能开发——以前可能要花好几个小时工程时间的那种。对这类,我会按 shift-tab 进 plan mode,在它动手写代码之前先把计划对齐。而难就难在:这条边界会随着每一代模型变,而且变得方式还挺出人意料:新模型更聪明了,所以'你到底需不需要用 plan mode'的那条边界,就往外挪了一点。"

"Like, before you used to need to plan, now you don't. And I think it's this general trend: stuff that used to be scaffolding, with a more advanced model it gets pushed into the model itself, and the model tends to subsume everything over time."

"比如,以前你需要先做计划,现在不需要了。我觉得这是一个普遍趋势:那些以前要靠脚手架(scaffolding)来兜的东西,换一个更强的模型,就被吸收进模型本身了;久而久之,模型会倾向于把一切都吞并进去。"

"How do you think about building an agent harness where you're not spending a bunch of time building stuff that's just going to be subsumed into the model in 3 months when the new Claude comes out? How do you know what to build, versus what to just say 'it doesn't work quite yet, but next time it's going to work, so we're not going to spend time on it'?"

"那你们怎么看'搭 agent harness'这件事——怎么避免花一堆时间做出来的东西,三个月后新 Claude 一出就直接被模型吸收掉?你怎么判断哪些该做,哪些该说'它现在还不太行,但下次就行了,所以我们先不花时间在这上面'?"

"I think we build most things that we think would improve Claude Code's capabilities, even if that means we'll have to get rid of it in 3 months. If anything, we hope that we will get rid of it in three months."

"我觉得只要我们认为某个东西能提升 Claude Code 的能力,我们基本就会做,哪怕这意味着三个月后我们得把它删掉。要说有什么的话,我们反而是希望三个月后能把它删掉。"

"For now, we just want to offer the most premium experience possible, so we're not too worried about throwaway work."

"眼下,我们只想提供尽可能顶级的体验,所以并不太担心做了白做这件事。"

"Interesting. An example of this is even plan mode itself. I think we'll probably unship it at some point, when Claude can just figure out from your intent that you probably want to plan first. Or, for example, I just deleted like 2,000 tokens from the system prompt yesterday, because Sonnet 4.5 doesn't need it anymore. But Opus 4.1 did need it."

"有意思。一个例子就是 plan mode 本身。我觉得我们迟早会把它下线——等到 Claude 能直接从你的意图里看出你大概是想先做计划。再比如,我昨天刚从 system prompt 里删了差不多 2,000 个 token,因为 Sonnet 4.5 已经不需要它了。但 Opus 4.1 当时是需要的。"

"What about the case where the latest frontier model doesn't need it, but you're trying to figure out how to make it more efficient because you have so many users—maybe you're not going to use Opus or Sonnet 4.5 for everything, maybe you'll use Haiku? So there's a trade-off between having a more elaborate harness for Haiku, versus just not spending time on it, using Sonnet, eating the cost, and working on more frontier-type stuff."

"那如果是这种情况呢:最新的前沿模型不需要它了,但你想让它更高效,因为你的用户量太大了——也许你不会什么都用 Opus 或 Sonnet 4.5,也许会用 Haiku?那就有一个取舍:是为 Haiku 搭一套更精细的 harness,还是干脆不在这上面花时间、直接用 Sonnet、把这部分成本吃下来,把精力放到更前沿的东西上。"

"In general, we've positioned Claude Code to be a very premium offering. So our north star is making sure that it works incredibly well with the absolutely most powerful model we have, which is Sonnet 4.5 right now."

"总体上,我们把 Claude Code 定位成一个非常高端的产品。所以我们的北极星是:确保它跟我们手上最强的那个模型——现在是 Sonnet 4.5——配合得极其出色。"

"We are investigating how to make it work really well for future generations of smaller models, but it's not the top priority for us."

"我们也在研究怎么让它在未来几代更小的模型上也能跑得很好,但这不是我们眼下最高优先级的事。"

"One thing I notice is we get models a lot before they come out, and it's our job to figure out if it's any good. Over the last six months, when I'm testing Claude in the Claude app with a new frontier model, it's actually very hard to tell whether it's better immediately. But it's really easy to tell in Claude Code, because the harness matters a lot for the performance you get out of the model."

"我注意到一件事:我们经常能在模型发布前很早就拿到它,而我们的活儿就是判断它到底行不行。过去半年里,当我在 Claude app 里用一个新的前沿模型测试 Claude 时,其实很难立刻看出它是不是更好了。但在 Claude Code 里就特别容易看出来,因为 harness 对你从模型身上压榨出的表现影响很大。"

"And you guys have the benefit of building Claude Code inside of Anthropic, so there's a much tighter integration between the fundamental model training and the harness you're building, and they seem to really impact each other. So how does that work internally, and what are the benefits you get from that tight integration?"

"而你们的优势在于,Claude Code 是在 Anthropic 内部做的,所以底层的模型训练和你们在搭的 harness 之间,耦合得紧密得多,两者看起来是真的在互相影响。那这件事在内部是怎么运作的?这种紧耦合给你们带来了哪些好处?"

"Yeah, I think the biggest thing is researchers just use this. As they see what's working and what's not, they can improve stuff. We do a lot of evals to communicate back and forth and understand where exactly the model's at."

"嗯,我觉得最大的一点是:研究员就直接用它。当他们看到什么管用、什么不管用,就能去改进。我们也做大量的 eval,来回来去地沟通,搞清楚模型到底处在什么水平。"

"But there's this frontier where you need to give the model a hard enough task to really push the limit of the model. If you don't do this, then all models are kind of equal. But if you give it a pretty hard task, you can tell the difference."

"但有一条边界:你得给模型一个足够难的任务,才能真正逼到它的极限。如果你不这么做,那所有模型看起来都差不多。可一旦你给它一个相当难的任务,你就能分辨出差距了。"

"What sub-agents do you use?"

"你们都用哪些 sub agent?"

"I have a few. I have a planner sub-agent. I have a code-review sub-agent. Code review is actually something where sometimes I use a sub-agent, sometimes a slash command. Usually in CI it's a slash command, but in synchronous use I use a sub-agent for the same thing."

"我有几个。一个 planner(规划)sub agent。一个 code-review sub agent。code review 这事儿挺有意思:有时我用 sub agent,有时用 slash command。一般在 CI 里用 slash command,但同步(实时)使用时,同样的事我用 sub agent。"

"It's a good question—maybe it's a matter of taste. I think when you're running synchronously, it's kind of nice to fork off the context window a little, because all the stuff going on in the code review isn't relevant to what I'm doing next. But in CI, it just doesn't matter."

"这是个好问题——也许就是个人口味问题。我觉得当你同步运行时,把 context window 稍微 fork 出去一份挺好的,因为 code review 里发生的那些东西,跟我接下来要做的事并不相关。但在 CI 里,这就无所谓了。"

"Are you ever spawning like 10 sub-agents at once? And for what?"

"你有没有一口气开过 10 个 sub agent?都用来干嘛?"

"For me, I do it mostly for big migrations. Actually we have this 'coder' slash command, and there are a bunch of sub-agents in it. One of the steps is 'find all the issues': one sub-agent checks for CLAUDE.md compliance, another looks through git history to see what's going on, another looks for obvious bugs. Then we do a kind of dedup/quality step after."

"我主要是在做大迁移的时候这么干。其实我们有一个叫 'coder' 的 slash command,里面塞了一堆 sub agent。其中一个步骤是'把所有问题都找出来':一个 sub agent 检查是否符合 CLAUDE.md,另一个翻 git history 看都发生了什么,还有一个专门找明显的 bug。然后我们再做一道去重 / 质量筛选。"

"They find a bunch of stuff—a lot of these are false positives—so then we spawn like five more sub-agents, and these are all just checking for false positives. And in the end, the result is awesome: it finds all the real issues without the false issues."

"它们会找出一大堆东西——其中很多是误报——于是我们再开大概五个 sub agent,这些全都只负责筛查误报。最后的结果非常棒:它把所有真问题都揪出来了,又不夹带那些假问题。"

"That's great. I actually do that. One of my non-technical Claude Code use cases is expense filing. I'm in SF right now, so I have all these expenses. I built this little Claude project in Claude Code that uses one of these finance APIs to download all my credit-card transactions, and then it decides which are probably the expenses I'll have to file."

"太棒了。我其实也这么干。我有一个非技术类的 Claude Code 用法是报销。我现在在旧金山,所以攒了一堆开销。我在 Claude Code 里建了个小项目,用某个财务 API 把我所有信用卡交易拉下来,然后由它判断哪些大概是我需要报销的。"

"And I have two sub-agents—one that represents me and one that represents the company—and they do battle to figure out the proper set of expenses. [laughter] It's like an auditor sub-agent and a 'pro-Dan' sub-agent. So that opponent-processor pattern seems to be an interesting one."

"然后我开了两个 sub agent——一个代表我,一个代表公司——让它俩互掐,争出一份合理的报销清单。[笑] 一个像审计员 sub agent,一个像'挺 Dan 派'sub agent。这种'对抗处理'的模式好像挺有意思。"

"Yeah, it's cool. When sub-agents were first becoming a thing—what inspired us is there's a Reddit thread a while back where someone made sub-agents for like a front-end dev, a backend dev, a designer, a testing dev, a PM sub-agent."

"对,挺酷的。sub agent 刚开始流行起来的时候——给我们灵感的是之前 Reddit 上的一个帖子,有人做了一堆 sub agent:前端开发、后端开发、设计师、测试开发,还有一个 PM sub agent。"

"And it's cute—it feels a little too anthropomorphic. Maybe there's something to this, but I think the value is actually the uncorrelated context windows, where you have these two context windows that don't know about each other. You tend to get better results this way. What about you—do you have any interesting sub-agents you use?"

"挺可爱的——但感觉有点过于拟人了。也许这里面确实有点门道,但我觉得真正的价值其实是那些'互不相关的上下文窗口':你有两个互相不知道对方存在的 context window。这样往往能得到更好的结果。你呢?你有什么用着有意思的 sub agent 吗?"

"I've been tinkering with one that's really good at front-end testing. It uses Playwright to see all the client-side errors, pull them in, and try to test more steps of the app. It's not totally there yet, but I'm seeing signs of life, and it's the kind of thing we could potentially bundle in one of our plugin marketplaces."

"我一直在捣鼓一个特别擅长前端测试的。它用 Playwright 把所有客户端的报错都抓出来、收进来,再试着把 app 的更多步骤都测一遍。它还没完全成,但我已经看到一些'活下来'的迹象了,而且这种东西我们以后说不定能打包进某个 plugin marketplace。"

"Definitely. I've used something like that with Puppeteer—just watching it build something, then open up the browser, then be like 'oh, I need to change this.' It's like, oh my god."

"绝对的。我也拿 Puppeteer 用过类似的东西——看着它把某个东西做出来,然后打开浏览器,接着就'噢,这里得改一下'。那感觉,简直是,天哪。"

"It's really cool. I think we're starting to see the beginnings of this massive multi-/massive-sub-agents thing—I don't know what they call this, swarms or something. There's an increasing number of people internally at Anthropic using a lot of credits every month, spending over a thousand bucks every month, and this percent is growing pretty fast."

"真的很酷。我觉得我们正开始看到那种'大规模多 agent / 海量 sub agent'的雏形——我也不知道他们管这叫什么,蜂群(swarms)之类的吧。Anthropic 内部每月用掉大量额度的人越来越多,有人每个月花掉一千多美元,而且这个比例涨得还挺快。"

"The common use case is code migration—framework A to framework B. There's the main agent, it makes a big to-do list for everything, and then it map-reduces over a bunch of sub-agents. So you instruct Claude like 'start 10 agents,' and just go 10 at a time, migrating all the stuff over."

"最常见的用法是代码迁移——从框架 A 迁到框架 B。有一个主 agent,它先给所有事情列一个大 to-do list,然后在一堆 sub agent 上做 map-reduce。所以你就指挥 Claude:'开 10 个 agent',一次 10 个地推进,把所有东西都迁过去。"

"What would be a concrete example of the kind of migration you're talking about?"

"你说的这种迁移,具体能举个例子吗?"

"I think the most classic is lint rules. There's some lint rule you're rolling out, and there's no autofixer because as a static analysis it's too simplistic for it. Other stuff is framework migrations—we just migrated from one testing framework to a different one. That's a pretty common one where it's super easy to verify the output."

"我觉得最经典的是 lint 规则。你要推行某条 lint 规则,但没有自动修复器,因为这事儿当成静态分析来做太简单粗暴、搞不定。另一类是框架迁移——我们刚把一个测试框架迁到了另一个。这是很常见的一类,因为输出特别容易验证。"

"One of the things I found—this is both for projects inside of Every and open-source projects—is if you're building a product and you want to build a feature that's been done before. An example people might need to implement a bunch is memory: how do you do memory? Because we have a bunch of different products internally, you can just spawn Claude sub-agents to be like 'how do these three other products do it?'"

"我发现的一件事——这对 Every 内部的项目和开源项目都成立——是:当你在做产品、想做一个别人已经做过的功能时。比如一个大家可能经常要实现的例子是记忆(memory):记忆该怎么做?因为我们内部有好几个不同的产品,你可以直接开一堆 Claude sub agent 去问'另外那三个产品是怎么做这件事的?'"

"And there's possibility for tacit code sharing, where you don't need an API or to ask anyone—you can just be like 'how do we do this already?' and then use the best practices to build your own. You can also do that with open source, because there are tons of projects where people have been working on memory for a year and it's really good. You can be like 'what are the patterns people have figured out, and which ones do I want to implement?'"

"这就有了一种'隐性的代码共享':你不需要 API,也不用去问任何人——你直接就能'我们现在是怎么做这件事的?',然后拿这些最佳实践来搭自己的版本。开源也能这么干,因为有大量项目,人家在记忆这块儿做了一年,做得非常好。你就能'大家都摸索出了哪些模式,我想实现其中哪些?'"

"Totally. You can also connect your version-control system. If you've built a similar feature in the past, Claude Code can use those APIs—query GitHub directly, find how people implemented a similar feature in the past, read that code, and copy the relevant parts."

"完全同意。你还可以接上你的版本控制系统。如果你以前做过类似的功能,Claude Code 可以用那些 API——直接查询 GitHub,找出过去别人是怎么实现一个类似功能的,读那段代码,再把相关的部分抄过来。"

"Have you found any use for log files—like 'here's the full history of how I implemented it'? Is that important to give to Claude, and how are you implementing that or making it useful?"

"你们有没有发现日志文件有什么用——就是'这是我当初怎么实现它的完整历史'?把这个喂给 Claude 重要吗?你们是怎么实现、怎么让它真正有用的?"

"Some people swear by it. There are some people at Anthropic where, for every task they do, they tell Claude Code to write a diary entry in a specific format that documents what it did, what it tried, why it didn't work. And then they even have agents that look over the past memory and synthesize it into observations."

"有些人特别信这个。Anthropic 里有些人,每做一个任务,都会让 Claude Code 按某种固定格式写一篇'日记',记录它做了什么、试了什么、为什么没成。他们甚至还有一些 agent,专门回看过去的记忆,把它提炼成一条条观察(observations)。"

"I think this is the budding—there's something interesting here that we could productize. But it's a new emerging pattern that we're seeing that works well."

"我觉得这还在萌芽期——但这里面有些有意思的东西,我们或许能把它产品化。这是个我们正看到的、刚冒出来的新模式,而且效果不错。"

"The hard thing about one-shotting memory from just one transcript is that it's hard to know how relevant a specific instruction is to all future tasks. Our canonical example: if I say 'make the button pink,' I don't want you to remember to make all buttons pink in the future. So synthesizing memory from a lot of logs is a way to find these patterns more consistently."

"从单独一段对话里'一把'生成记忆,难点在于:很难判断某条具体指令对未来所有任务到底有多大相关性。我们最典型的例子是:如果我说'把这个按钮做成粉色的',我可不希望你以后记着'所有按钮都要做成粉色'。所以,从大量日志里去提炼记忆,是一种更稳定地找出这些模式的办法。"

"It seems like there are some things where you'll be able to synthesize in a top-down way—'this will be useful later'—and you'll know the right level of abstraction at which it might be useful. But then there's a lot of stuff where any given commit log, like 'make the button pink,' could be useful for an infinite number of different reasons you're not going to know beforehand. So you also need the model to be able to look up all similar past commits and surface that at the right time. Is that something you're also thinking about?"

"听起来是这样:有些东西你能自上而下地提炼——'这个以后会有用'——而且你能判断出它可能在哪个抽象层级上有用。但还有很多东西,比如任意一条 commit 日志'把按钮做成粉色',它可能因为无数种你事先根本想不到的原因而有用。所以你还需要模型能去检索所有类似的历史 commit,并在恰当的时机把它呈现出来。这个你们也在考虑吗?"

"Yeah, I think there could be something like that. One way to see it is the traditional memory-storage stuff—the kind of 'mem' tools—where you just want to put all the information into the system, and then it's a retrieval problem after that."

"嗯,我觉得可能会有类似的东西。一种看法是把它当成传统的'记忆存储'那一套——那些 'mem' 类工具——你只管把所有信息塞进系统里,之后就变成一个检索(retrieval)问题。"

"And as the model gets smarter, it naturally—I've seen it start to naturally do this with Sonnet 4.5, where if it's stuck on something, it'll naturally start looking, like we talked about before, using bash spontaneously: it'll just look through git history and be like 'oh okay, this is kind of an interesting way to do it.'"

"而且随着模型越来越聪明,它会自然而然地——我已经看到 Sonnet 4.5 开始自发这么做了:它卡在某个地方时,就会像我们前面说的那样自发地用 bash,自己去翻 git history,然后'噢,好,这是个挺有意思的做法'。"

"One of the things we're doing inside of Every—I feel like it has really changed the way we do engineering, because everyone is Claude Code-building, CLI-building. We have this engineering paradigm we call compounding engineering, where in normal engineering every feature you add makes it harder to add the next feature, but in compounding engineering your goal is to make the next feature easier to build from the feature you just added."

"我们 Every 内部在做的一件事——我觉得它真的改变了我们做工程的方式,因为现在人人都在用 Claude Code 造东西、用 CLI 造东西。我们有一套工程范式,叫'复利工程'(compounding engineering):在常规工程里,你每加一个功能,都让下一个功能更难加;而在复利工程里,你的目标是——让你刚加的这个功能,反过来让下一个功能更好做。"

"The way we do that is we try to codify all the learnings from everything we've done to build the feature. Like, how did we make the plan, what parts needed to be changed, when we started testing what issues did we find, what are the things we missed? And then we codify them back into all the prompts and sub-agents and slash commands, so that the next time someone does something like this, it catches it, and that makes it easier."

"具体做法是:我们尽量把做这个功能过程中学到的一切都固化下来。比如:我们当初怎么做的计划、计划里哪些部分需要改、开始测试时发现了哪些问题、有哪些是我们漏掉的?然后把这些都回写进所有的 prompt、sub agent 和 slash command 里,这样下次有人做类似的事,系统就能提前接住,事情也就更好办了。"

"That's why I can hop into one of our codebases and start being productive even though I don't know anything about how the code works, because we have this built-up memory system of all the stuff we've learned as we've implemented things. But we've had to build that ourselves. I'm curious, are you working on that kind of loop, so Claude Code does that automatically?"

"这就是为什么我能跳进我们某个代码库、马上就能产出,哪怕我对这代码怎么跑的一无所知——因为我们攒下了这么一套'记忆系统',装着我们一路实现东西时学到的所有经验。但这套是我们自己搭出来的。我很好奇,你们在做那种 loop 吗——让 Claude Code 自动把这件事干了?"

"Yeah, we're starting to think about it. It's funny—we heard the same thing from Fiona. She just joined the team; she's our manager. She hasn't coded in like 10 years, and she was landing PRs on her first day. She was like, 'not only did I forget how to code and Claude Code made it super easy to just get back into it,'"

"嗯,我们正开始考虑这事。挺有意思的——我们从 Fiona 那儿听到了一模一样的话。她刚加入团队,是我们的 manager。她大概有 10 年没写代码了,结果第一天就在往里合 PR。她说:'我不仅早忘了怎么写代码、而 Claude Code 让我重新上手变得超容易,'"

"'—but also I didn't need to ramp up on any context, because I kind of knew all this.' A lot of it is about when people put up pull requests for Claude Code itself, and our customers tell us they do similar stuff pretty often. If you see a mistake, I'll just be like: 'add this to CLAUDE.md so that the next time it just knows this automatically.'"

"'——而且我都不需要补任何上下文,因为这些我大概都懂。'这里很大一部分,是关于大家给 Claude Code 本身提 PR 时怎么做的;我们的客户也跟我们说,他们经常做类似的事。如果你看到一个错误,我就会直接'把这条加到 CLAUDE.md 里,这样下次它就自动知道了'。"

"You can instill this memory in a variety of ways. You can say 'add it to CLAUDE.md.' You can also say 'write a test'—that's an easy way to make sure this doesn't regress. And I don't feel bad asking anyone to write tests anymore; it's super easy. Probably close to 100% of our tests are written by Claude. If they're bad, we just won't commit it; the good ones stay committed."

"你可以用好几种方式把这份记忆灌进去。你可以说'加到 CLAUDE.md 里'。你也可以说'写个测试'——这是确保它不会回退(regress)的简单办法。而且我现在让谁去写测试都毫无心理负担了,因为太容易了。我们的测试里大概有接近 100% 是 Claude 写的。写得烂的,我们干脆不 commit;好的就留下。"

"And lint rules are a big one. For stuff that's enforced pretty often, we have a bunch of internal lint rules. Claude writes 100% of these—it's mostly just '@claude, in a PR, write this lint rule.' And there's this problem about how you do this automatically. Generally how Cat and I think about it: we see this power-user behavior, and the first step is how do you enable that by making the product hackable, so the best users can figure out this cool new thing—"

"还有 lint 规则也是大头。对那些经常要强制执行的东西,我们有一堆内部 lint 规则。这些 100% 是 Claude 写的——基本就是 '@claude,在一个 PR 里,把这条 lint 规则写出来'。然后就有了'怎么把这件事自动化'的问题。Cat 和我大体是这么想的:我们看到这种 power user 的行为,第一步是——怎么把产品做得足够可被'魔改',让最厉害的用户能琢磨出这些酷炫的新玩法——"

"—but then the hard work starts: how do you take this and bring it to everyone else? For me, I keep myself in the 'everyone else' bucket. I don't really know how to use Vim, I don't have a crazy tmux setup, I have a pretty vanilla setup. So if you can make a feature that I'll use, it's a pretty good indicator that other average engineers will use it."

"——但真正难的活儿这才开始:你怎么把它拿过来、带给所有其他人?对我自己,我一直把自己归到'其他人'那一类。我不太会用 Vim,也没有什么花哨的 tmux 配置,我的环境相当朴素。所以如果你能做出一个连我都会用的功能,那就是一个挺好的信号:其他普通工程师也会用。"

"That is interesting. Tell me about that, because it's something I think about all the time: making something extensible and flexible enough that power users can find novel ways to use it you wouldn't have even dreamed of, but also simple enough that anyone can use it and be productive—and you can pull what the power users find back into the basic experience. How do you think about making those design and product decisions so you enable that?"

"这很有意思。跟我讲讲,因为这正是我天天在想的:怎么把东西做得既足够可扩展、足够灵活,让 power user 能玩出你做梦都想不到的新用法;又足够简单,让任何人都能上手、都能产出——而且你还能把 power user 发现的东西反哺回基础体验里。你是怎么去做这些设计和产品决策、好让这件事成立的?"

"In general we think that every engineering environment is a little bit different from the others, so it's really important that every part of our system is extensible. Everything from your status line, to adding your own slash commands, through to hooks—which let you insert a bit of determinism at pretty much any step in Claude Code. We think these are the basic building blocks that we give to every engineer that they can play with."

"总体上我们认为,每个工程环境都跟别的有点不一样,所以让我们系统的每个部分都可扩展,就特别重要。从你的 status line(状态栏),到添加你自己的 slash command,再到 hooks——hooks 能让你在 Claude Code 几乎任何一个步骤插入一点'确定性'。我们觉得这些就是我们交给每位工程师、随他们去折腾的基础积木。"

"For plugins—plugins was built by Daisy on our team—this is our attempt to make it a lot easier for the average user like us to bring these slash commands and hooks into our workflows. What plugins does is it lets you browse existing MCP servers, existing hooks, existing slash commands, and just write one command in Claude Code to pull that in for yourself."

"至于 plugins——plugins 是我们团队的 Daisy 做的——这是我们的一次尝试,想让像我们这样的普通用户更轻松地把这些 slash command 和 hooks 接进自己的工作流。plugins 做的事,就是让你浏览现成的 MCP server、现成的 hooks、现成的 slash command,然后在 Claude Code 里只敲一条命令,就把它拉进来给你自己用。"

"There's this really old idea in product called latent demand, which is probably the main way I personally think about product and about what to build next. It's a super simple idea: you build a product in a way that is hackable, that wasn't really designed for it. Then you see how people abuse it, and then you build for that—because you kind of know there was demand for it, right?"

"产品里有一个很古老的概念,叫'潜在需求'(latent demand),这大概也是我个人思考产品、思考下一步该做什么的主要方式。它特别简单:你把产品做得可以被'魔改',做成它本来没为之设计的样子。然后你观察大家怎么'滥用'它,再为这种用法去做功能——因为你大致知道,这里是有真实需求的,对吧?"

"When I was at Meta, this is how we built all the big products. Almost every single big product had this nugget of latent demand in it. For example, something like Facebook Dating came from this idea: when we looked at who looks at people's profiles, I think 60% of views were between people of opposite gender—kind of a traditional setup—who were not friends with each other. So we were like, 'oh man, maybe if we launch a dating product, we can harness this demand that exists.'"

"我在 Meta 的时候,我们所有的大产品都是这么做出来的。几乎每一个大产品里,都埋着这么一颗'潜在需求'的种子。比如 Facebook Dating(交友)就来自这样一个发现:我们去看是谁在看别人的主页,大概 60% 的浏览发生在异性之间——比较传统的那种配对——而且彼此还不是好友。于是我们就想:'天,也许我们上一个交友产品,就能把这股已经存在的需求接住。'"

"That's interesting."

"挺有意思。"

"And for Marketplace it was pretty similar—I think 40% of posts in Facebook groups at the time were 'for sale' posts. So okay, people are trying to use this product to buy and sell themselves; we just build a product around it and it's probably going to work."

"Marketplace(集市)也很类似——当时 Facebook 群组里大概 40% 的帖子都是'出售'帖。那好,大家本来就在拿这个产品自发地买卖东西;我们干脆围着这个需求做一个产品,大概率就能成。"

"So we think about it similarly. But we also have the luxury of building for developers, and developers love hacking stuff and customizing stuff. As a user of our own product, it makes it so fun to build and use this thing. So like I said, we just build the right extension points, see how people use it, and that tells us what to build next."

"所以我们也是用类似的思路。但我们还有一个奢侈之处:我们是在为开发者做产品,而开发者就爱魔改、爱定制。作为我们自家产品的用户,做它、用它都变得特别有意思。所以就像我说的,我们只管把扩展点做对、看大家怎么用,而这就会告诉我们下一步该做什么。"

"For example, we got all these user requests where people were like, 'Dude, Claude Code is asking me for all these permissions and I'm out here getting coffee—I don't know that it's asking me. How could I just get it to ping me on Slack?' So we built hooks. Dixon built hooks, so that people could get pinged on Slack for anything that they want. It was very much: people really wanted the ability to do something, we didn't want to build the integration ourselves, so we exposed hooks for people to do that."

"举个例子,我们收到一堆用户请求,大家说:'哥们儿,Claude Code 在跟我要一堆权限,可我正出去买咖啡呢——我根本不知道它在问我。能不能让它直接在 Slack 上戳我一下?'于是我们就做了 hooks。Dixon 做了 hooks,这样大家想为什么事被 Slack 提醒,就能为什么事被提醒。这特别典型:用户非常想拥有做某件事的能力,而我们又不想自己去做那个集成,所以我们就把 hooks 这个口子开放出来,让大家自己接。"

"The thing that makes me think of is, you recently moved or rebranded how you talk about Claude Code to be this more general-purpose Agent SDK. Was that driven by some latent demand, where you saw there's a more general-purpose use case for what you built?"

"这让我想到:你们最近把谈论 Claude Code 的方式做了迁移或者说重新定位,变成了一个更通用的 Agent SDK。这是被某种潜在需求推着走的吗——你们看到你们做的这东西有更通用的用途?"

"We realized that, similar to how you were talking about using Claude Code for things outside of coding, we saw this happen a lot. We get a ton of stories of people using Claude Code to help them write a blog and manage all the data inputs and take a first pass in their own tone. We find people building email assistants on this. I use it for a lot of market research."

"我们发现,就像你刚才说的'拿 Claude Code 做编程以外的事',这种情况我们见得特别多。我们收到大量这样的故事:有人用 Claude Code 帮自己写博客、管理所有的数据输入、用他们自己的语气先打一版草稿。我们也看到有人在它上面搭邮件助手。我自己拿它做了很多市场调研。"

"Because at the core it's an agent that can go on for an infinite amount of time, as long as you give it a concrete task and it's able to fetch the right underlying data. One thing I was working on: I wanted to look at all the companies in the world and how many engineers they had, to create a ranking. Claude Code can do that, even though it's not a traditional coding use case."

"因为它的内核就是一个能无限期跑下去的 agent,只要你给它一个具体的任务、并且它能取到正确的底层数据。我做过的一件事:我想把全世界所有公司、以及它们各有多少工程师,都看一遍,做一个排名。Claude Code 就能做,尽管这并不是一个传统的编程场景。"

"So we realized the underlying primitives were really general. As long as you have an agent loop that can keep running for a long period of time, and you're able to access the internet and write code and run code, pretty much—if you squint—you can build anything on it."

"所以我们意识到:底层的那些原语其实非常通用。只要你有一个能长时间持续运行的 agent loop,并且能访问互联网、能写代码、能跑代码,那么基本上——眯起眼看的话——你在它上面什么都能搭。"

"And at the point where we rebranded it—from the Claude Code SDK to the Claude Agent SDK—there were already many thousands of companies using this thing, and a lot of those use cases were not about coding. So both internally and externally, we kind of saw that."

"而到我们给它重新定名的时候——从 Claude Code SDK 改成 Claude Agent SDK——已经有好几千家公司在用这东西了,而且其中很多用途都跟编程无关。所以无论是内部还是外部,我们都看到了这一点。"

"Like health assistants, financial analysts, legal assistants. It was pretty broad."

"比如健康助手、财务分析师、法律助理。范围相当广。"

"What are the coolest ones? You had Noah Brier on the podcast recently—I thought the Obsidian mind-mapping, note-keeping use case is really cool. It's insane how many people use it for this. [laughter]"

"最酷的是哪些?你们最近请了 Noah Brier 上播客——我觉得那个用 Obsidian 做思维导图、做笔记的用法特别酷。用这个组合的人多到离谱。[笑]"

"Some other coding-adjacent use cases that are cool: we have this issue tracker for Claude Code. The team's just constantly underwater trying to keep up with all the issues coming in—there's just so many. So Claude dedupes the issues, automatically finds duplicates, and it's extremely good at it. It also does first-pass resolution: usually when there's an issue, it'll proactively put up a PR internally. This is a new thing that Igor on the team built."

"还有一些跟编程沾边、挺酷的用法:我们给 Claude Code 做了一个 issue tracker。团队一直被涌进来的 issue 淹得喘不过气——实在太多了。于是 Claude 来给这些 issue 去重,自动找出重复项,而且它做得极其好。它还会做第一轮处理:通常一有 issue,它就会主动在内部提一个 PR。这是团队里 Igor 新做的东西。"

"There's also on-call, and collecting signals from other places—getting Sentry logs, getting logs from BigQuery, collating all this. Plus it's just really good at doing this, because it's all just bash in the end. These are all kind of these internal use cases that I saw."

"还有 on-call(值班),以及从各处收集信号——拉 Sentry 的日志、拉 BigQuery 的日志,把这些都汇总到一起。而且它特别擅长干这个,因为说到底全都是 bash。这些都是我看到的、偏内部的用法。"

"When it's collating logs or doing issues, is that like you have Claudes continually running in the background—and is that something you're building for?"

"它在汇总日志、处理 issue 的时候,是不是相当于你有一堆 Claude 在后台持续跑着——这也是你们在为之做准备的方向吗?"

"For that particular one, it gets triggered—it gets triggered whenever a new issue is filed. So it runs once, but it can choose to run for as long as it needs."

"就那个具体的例子来说,它是被触发的——每当有新 issue 被提交,它就被触发一次。所以它只跑一次,但它可以自己决定要跑多久。"

"Got it. What about the idea of Claudes always running? Ooh, proactive Claudes."

"懂了。那'Claude 一直在跑'这个设想呢?哦——主动出击的 Claude。"

"I think it's definitely where we want to get to. Right now we're very focused on making Claude Code incredibly reliable for individual tasks. If you think about multi-line autocomplete, then single-turn agents, and now Claude Code that can complete tasks—if you trace this curve, eventually you go to even higher levels of abstraction, even more complicated tasks."

"我觉得那绝对是我们想抵达的地方。眼下我们非常专注于把 Claude Code 在单个任务上做到极其可靠。你想想这条曲线:从多行自动补全,到单轮(single-turn)agent,再到现在能完成整个任务的 Claude Code——顺着这条曲线往下走,你最终会走向更高的抽象层级、更复杂的任务。"

"And then hopefully the next step after that is a lot more productivity: just understanding what your team's goals are, what your goals are, being able to say 'hey, I think you probably want to try this feature, and here's a first pass at the code, and here are the assumptions I made—are these correct?'"

"再往后,希望下一步就是大幅提升生产力:它直接理解你团队的目标、你的目标,然后能主动说'嘿,我觉得你大概想试试这个功能,这是代码的初版,这些是我做的假设——对不对?'"

"I can't wait. And I think probably right after that is, Claude is now your manager. [laughter]"

"我等不及了。而再往后大概就是——Claude 现在成了你的领导。[笑]"

"That's not in the plan. [laughter]"

"那个不在计划里。[笑]"

"Everyone on the team was super excited that we were talking today, and they gave me a bunch of questions—I want to make sure I hit all of them. Oh, here's a good one: Why did you choose agentic RAG over vector search in your architecture? And are vector embeddings still relevant?"

"我们团队所有人一听说今天要聊,都特别兴奋,给了我一堆问题——我得保证把它们都问到。哦,这有个好问题:你们的架构里,为什么选了 agentic RAG 而不是向量检索(vector search)?向量嵌入(vector embeddings)现在还重要吗?"

"Initially we did use vector embeddings. They're just really tricky to maintain, because you have to continuously reindex the code, they might get out of date, and you have local changes that need to make it in. And then, as we thought about what it feels like for an external enterprise to adopt it, we realized this exposes a lot more surface area and security risk."

"一开始我们确实用了向量嵌入。它们就是很难维护:你得不停地给代码重新建索引,索引可能过期,而且你还有本地改动需要并进来。再后来,当我们去设想'一个外部企业要采用它会是什么感受'时,我们意识到这暴露了大得多的攻击面和安全风险。"

"We also found that Claude Code is really good, and Claude models are really good, at agentic search. So you can get to the same accuracy level with agentic search, and it's just a much cleaner deployment story."

"我们还发现,Claude Code 很擅长、Claude 模型也很擅长 agentic 搜索。所以用 agentic 搜索,你能达到同样的准确度,而部署的故事干净利落得多。"

"If you do want to bring semantic search to Claude Code, you can do so via an MCP tool. So if you want to manage your own index and expose an MCP tool that lets Claude Code call that, that would work."

"如果你确实想给 Claude Code 接上语义搜索(semantic search),可以通过一个 MCP 工具来做。也就是说,你想自己维护索引、并暴露一个让 Claude Code 去调用的 MCP 工具,这条路是走得通的。"

"What do you think are the top MCPs to use with Claude Code?"

"你们觉得配合 Claude Code 用,最值得用的 MCP 有哪些?"

"Puppeteer and Playwright are pretty high up there. [Cat: Definitely.] Sentry has a really good one. Asana has a really good one."

"Puppeteer 和 Playwright 排得挺靠前。[Cat:绝对的。] Sentry 有一个很好的。Asana 也有一个很好的。"

"Do you think there are any power-user tips that you see people inside Anthropic, or big Claude Code power users inside organizations, doing that people don't know about but should?"

"你们觉得有没有什么 power user 的技巧——你们看到 Anthropic 内部、或者那些组织里的 Claude Code 重度用户在用、但大多数人不知道、其实应该知道的?"

"One thing Claude Code doesn't naturally like to do, but that I personally find very useful, is: Claude Code doesn't naturally like to ask questions. But if you're brainstorming with a thought partner, a collaborator, usually you ask questions back and forth. So especially in plan mode, I'll just tell Claude Code, 'hey, we're just brainstorming this thing—please ask me questions if there's anything you're unsure about. I want you to ask questions.' And it'll do it. I think that actually helps you arrive at a better answer."

"有一件 Claude Code 不太愿意主动做、但我个人觉得非常有用的事:Claude Code 天生不太爱反问。可如果你是在跟一个思考搭档、一个协作者头脑风暴,通常你们是会来回互相提问的。所以,尤其在 plan mode 里,我会直接告诉 Claude Code:'嘿,我们就是在头脑风暴这件事——只要有任何你不确定的地方,请尽管问我。我希望你来提问。'它就会照做。我觉得这其实能帮你得到一个更好的答案。"

"There are also so many tips we can share. There are a few really common mistakes I see people make. One is, like you said, not using plan mode enough—this is super important. People new to coding kind of assume this thing can do anything, and it can't. It's not that good today; it's going to get better, but today it can one-shot some tests, can't one-shot most things. So you have to understand the limits, and where you get in the loop. Something like plan mode can 2-3x success rates pretty easily if you land on the plan first."

"我们能分享的技巧太多了。有几个我经常看到大家犯的错。一个就是你说的:plan mode 用得不够——这点超级重要。刚接触编程的人会想当然地以为这东西啥都能干,但它不能。它今天还没那么强;以后会更强,但今天它能一把搞定一些测试,大多数事情没法一把搞定。所以你得理解它的极限,以及'你该在哪个环节介入循环'。像 plan mode 这种东西,只要你先把计划敲定,就能轻轻松松把成功率翻个 2-3 倍。"

"Other stuff power users do really well: companies with really big deployments of Claude Code—luckily there are a lot of these companies, so we can learn from them. Having a settings.json that you check into the codebase is really important, because you can use it to pre-allow certain commands so you don't get permission-prompted every time, and also to block certain commands—say you don't want web-fetch. This way, as an engineer I don't get prompted, and I can check this in and share it with the whole team so everyone gets to use it."

"power user 做得很好的另一些事:那些大规模部署了 Claude Code 的公司——幸好这样的公司很多,我们能从他们身上学。把一个 settings.json 提交进代码库非常重要,因为你可以用它预先放行某些命令,这样就不会每次都被弹权限提示;也可以用它屏蔽某些命令——比如你不想要 web-fetch。这样作为工程师我就不会被打断,而且我能把它 check in、分享给整个团队,让大家都能用。"

"I get around that by just using dangerously-skip-permissions."

"我是直接用 dangerously-skip-permissions(危险地跳过权限)绕过这一切的。"

"Yeah, we kind of have this here, but we don't recommend it. It's a model—it can do weird stuff. Another cool use case we've seen is people using stop hooks for interesting stuff. A stop hook runs whenever the turn is complete—the assistant did some tool calls back and forth, it's done, and it returns control back to the user—then we run the stop hook."

"对,我们这儿也算有这个功能,但我们不推荐。它是个模型——它可能干出奇怪的事。我们看到的另一个酷用法,是有人拿 stop hook 玩出花样。stop hook 会在每一轮(turn)结束时运行——助手来回做了一些工具调用、做完了、把控制权交还给用户——这时我们就跑这个 stop hook。"

"So you can define a stop hook that's like 'if the tests don't pass, return the text keep going.' And essentially you can just make the model keep going until the thing is done. This is just insane when you combine it with the SDK and this kind of programmatic usage. This is a stochastic thing, a nondeterministic thing, but with scaffolding you can get these deterministic outcomes."

"所以你可以定义一个 stop hook:'如果测试没通过,就返回一句"继续"。'本质上,你就能让模型一直跑到事情做完为止。当你把它和 SDK、和这种程序化的用法结合起来,简直炸裂。这本来是个随机的(stochastic)、不确定的东西,但靠脚手架,你能从中得到这些确定性的结果。"

"So you guys started this CLI paradigm shift. Do you think the CLI is the final form factor? Are we going to be using Claude Code in the CLI primarily in a year, or in three years, or is there something else that's better?"

"是你们开启了这场 CLI 的范式转变。你们觉得 CLI 是终极形态吗?一年后、三年后,我们还会主要在 CLI 里用 Claude Code 吗,还是会有别的更好的东西?"

"I mean, it's not the final form factor, but we are very focused on making sure the CLI is the most intelligent we can make it, and as customizable as possible. [to Boris] You can talk about the next form factors."

"嗯,它不是终极形态,但我们非常专注于把 CLI 做到我们能做到的最聪明、最可定制。[转向 Boris]下一代形态你来讲吧。"

"Cat's asking me to talk about it because no one knows—this stuff is moving so fast, right? No one knows what these form factors are. Right now our team is in experimentation mode. We have the CLI, then we came out with the IDE extension, now a new IDE extension that's a GUI, a little more accessible. We have @claude in GitHub, so you can add Claude anywhere. Now there's Claude on web and on mobile. We're just trying to figure out what's next."

"Cat 让我来讲,是因为没人知道答案——这东西变得太快了,对吧?没人知道这些形态会是什么。眼下我们团队处在实验模式。我们有 CLI,然后出了 IDE 扩展,现在又有一个带图形界面(GUI)的新 IDE 扩展,更容易上手。我们有 GitHub 里的 @claude,你可以把 Claude 加到任何地方。现在还有网页版和移动版的 Claude。我们就是在试着摸清下一步是什么。"

"If we zoom out and see where this is headed, one of the big trends is longer periods of autonomy. With every model, we time how long it can just keep going and do tasks autonomously—in dangerous mode, in a container, autocompacting until the task is done. Now we're on the order of double-digit hours. The last model is like 30 hours, something like this. The next model is going to be days."

"如果拉远看这东西要往哪儿走,一个大趋势是自主运行的时长越来越长。每出一个模型,我们都会去掐表:它能自己一路跑、自主完成任务跑多久——在 dangerous 模式下、在一个容器里、不断自动压缩(autocompact)上下文,直到任务做完。现在已经是两位数小时的量级了。上一个模型大概是 30 小时这种水平。下一个模型会是以天计。"

"And as you parallelize models, a bunch of problems come out of this. One is: what is the container this thing runs in, because you don't want to have to close your laptop. I have that right now—I'm doing a lot of DSPy prompt optimization, and it's on my laptop, and I don't want to close it. I'm in the middle of it with my laptop open because I don't want to close it. [laughter]"

"而当你开始并行跑多个模型,就冒出一堆问题。一个是:这东西到底跑在什么容器里,因为你不想被迫合上笔记本。我现在就这样——我在做大量的 DSPy prompt 优化,它跑在我的笔记本上,我不想合盖。我就这么开着盖、卡在中间,因为我不敢合。[笑]"

"We've visited companies before—customers where everyone's just walking around with their Claude Codes. [laughter]"

"我们之前去拜访过一些公司——有些客户,人人都揣着自己那一堆正在跑的 Claude Code 到处走。[笑]"

"'Is this running?' So one is getting away from this mode. And I also think pretty soon we're going to be in this mode of Claudes monitoring Claudes."

"'这个还在跑吗?'所以一方面是要摆脱这种状态。另一方面,我觉得我们很快会进入一种'Claude 监控 Claude'的模式。"

"I don't know what the right form factor for this is, because as a human you need to be able to inspect this and see what's going on, but it also needs to be Claude-optimized, where you're optimizing for bandwidth between the Claude-to-Claude communication. So my prediction is: terminal is not the final form factor. There's going to be a few more form factors in the coming months, maybe a year, and it's going to keep changing very quickly."

"我不知道这件事正确的形态是什么,因为作为人类,你需要能够检视它、看清在发生什么;但它同时又得是为 Claude 优化的,也就是要去优化 Claude 与 Claude 之间通信的带宽。所以我的预测是:终端不是终极形态。未来几个月、也许一年里,还会再冒出好几种形态,而且会一直快速地变。"

"I teach a lot of Claude Code to a lot of Every subscribers [Cat: thank you]—you're welcome, doing your work for you. [laughter] One of the big things is just that the terminal is intimidating. Being on a call with subscribers, being like 'here's how you open the terminal, and you're allowed to do this even if you're non-technical,' is a big deal. How do you think about that?"

"我给很多 Every 的订阅者教 Claude Code[Cat:谢谢你]——不客气,等于在替你们干活。[笑] 其中一个大问题就是:终端这东西很吓人。跟订阅者开电话会、告诉他们'终端这么打开,哪怕你不是技术背景,你也是被允许这么做的',这事儿意义很大。你们怎么看这个?"

"One of the people on our marketing team started using Claude Code because she was writing content that touched on Claude Code, and I was like 'you should really experience it.' And she got like 30 popups on her screen where she had to accept various permissions, because she'd never used a terminal before. So I completely see eye to eye with you. It's definitely hard for non-engineers, and there are even some engineers we've found who aren't fully comfortable working day-to-day in the terminal."

"我们市场团队有个人开始用 Claude Code,是因为她在写一篇涉及 Claude Code 的内容,我就跟她说'你真的该亲自体验一下'。结果她屏幕上弹出大概 30 个弹窗,要她一个个接受各种权限,因为她以前从没用过终端。所以我跟你完全是一个想法。这对非工程师来说确实很难,我们甚至发现有些工程师也并不完全习惯天天泡在终端里。"

"Our VS Code GUI extension is our first step in that direction, because you don't have to think about the terminal at all—it's a traditional interface with a bunch of buttons. We're working on more graphical interfaces. Claude Code on the web is a GUI; I think that might actually be a good starting point for people who are less technical."

"我们的 VS Code 图形界面扩展,是朝这个方向迈出的第一步,因为你完全不用去想终端这回事——它就是一个有一堆按钮的传统界面。我们也在做更多图形化界面。网页版的 Claude Code 就是个 GUI;我觉得对技术程度没那么高的人来说,那可能是个不错的起点。"

"There was this magic moment a few months ago where I walked into the office, and some of the data scientists at Anthropic—they sit right next to the Claude Code team—just had Claude Code running on their computers. I was like 'what is this, how did you figure this out?' I think Brandon was the first one to do it, and he was like 'oh yeah, I just installed it—I work on this product, so I should use it.' He figured out how to use a terminal even though he hasn't really done this kind of workflow before. Obviously very technical."

"几个月前有个魔法时刻:我走进办公室,看到 Anthropic 的一些数据科学家——他们就坐在 Claude Code 团队旁边——电脑上居然都跑着 Claude Code。我当时'这是什么情况,你们怎么搞明白的?'我记得 Brandon 是第一个这么干的,他说'哦对,我就装上了——我做的就是这个产品,那我当然该用它'。他自己琢磨出了怎么用终端,哪怕他以前没怎么走过这种工作流。当然他本身很技术。"

"So now we're starting to see all these code-adjacent functions—people using Claude Code. From a latent-demand point of view, these are people hacking the product, so there's demand to use it for this, and we want to make it a bit easier with more accessible interfaces. But at the same time, for Claude Code we're laser-focused on building the best product for the best engineers. So we're focused on software engineering, and we want to make this really good—but we want to make it a thing that other people can hack."

"所以现在我们开始看到各种'沾边代码'的岗位都在用 Claude Code。从潜在需求的角度看,这些人是在'魔改'我们的产品,说明这里有用它干这些事的需求,我们也想用更易用的界面让它更轻松一点。但与此同时,对 Claude Code 本身,我们死磕的是为最顶尖的工程师做出最好的产品。所以我们聚焦在软件工程上,想把这件事做到极好——同时又让它成为一个别人也能拿去魔改的东西。"

"Sometimes Claude Code will write code that's a bit verbose, but you can just tell it to simplify it and it does a really good job."

"有时候 Claude Code 写出来的代码会有点啰嗦,但你直接让它'简化一下'就行,它做得非常好。"

"And how and when are you doing that? Are you using a slash command, or—"

"那你是怎么、在什么时候做这件事的?用一个 slash command,还是——"

"I just say it. Sometimes you're like 'hey, this should be a one-line change' and it'll write five lines, and you're like 'simplify it,' and it understands immediately what you mean and fixes it."

"我就直接说。有时候你会觉得'嘿,这本来应该是一行的改动',结果它写了五行,你说一句'简化一下',它立刻就明白你的意思,然后改好。"

"A lot of people on our team do that too. Why not, if you're saying it all the time, push that into a slash command or the harness so it just happens automatically?"

"我们团队很多人也这么干。那既然你老在说这句话,为什么不把它塞进一个 slash command、或者塞进 harness 里,让它自动就发生呢?"

"We do have instructions for this in the CLAUDE.md. I think it impacts such a low percentage of conversations that we don't want it to over-rotate in the other direction."

"我们在 CLAUDE.md 里其实是有这条指令的。但我觉得它影响到的对话占比太低了,我们不希望它矫枉过正、朝反方向用力过猛。"

"And the reason it's not a slash command is you actually don't need that much context. Slash commands are really good for situations where you'd otherwise need to write two or three lines—but even for plan mode, you can use a few words, though it actually takes two or three lines to capture the entirety of what you want. For 'simplify it,' you can just write 'simplify it' and it gets it."

"而它没做成 slash command,是因为你其实不需要那么多上下文。slash command 真正擅长的,是那种你本来得写上两三行的场景——但即便是 plan mode,你用几个词也行,只不过要把你想要的全部表达出来,确实得两三行。而'简化一下'呢,你直接写'简化一下',它就懂了。"

"This stuff still feels just so early. We were talking before the recording about where are we on the adoption curve—the diffusion curve or whatever that term was. [laughter] It just feels like we're, like, the first 10%. The stuff is going to change so fast, it's going to keep changing."

"这些东西感觉都还非常早期。录之前我们还在聊我们处在采用曲线的哪个位置——扩散曲线(diffusion curve)还是什么术语来着。[笑] 感觉我们大概也就在最前面的 10%。这些东西会变得特别快,会一直变下去。"

"Even when I talk to researchers outside of Anthropic who abuse Claude Code, they also get stuck on things like not realizing they can just tell the LLM to simplify it. That just goes to show that even people working in this industry don't always realize you can just talk to the model. There's this underlying expectation that using AI shouldn't have to be a skill, because it just does whatever you say—and you're like, well, whatever you say is going to matter for what it does. So if you can say things better, it's going to do better. [laughter]"

"哪怕我跟 Anthropic 之外、那些把 Claude Code 用得很猛的研究员聊,他们也会卡在一些事上,比如没意识到他们其实可以直接让 LLM '简化一下'。这恰恰说明:连在这个行业里工作的人,也未必都意识到——你直接跟模型说话就行。背后有一种隐含的期待:用 AI 不应该是一门需要学的技能,因为它你说什么它就做什么——可问题是,你说什么,会直接决定它做什么。所以你要是能把话说得更好,它就会做得更好。[笑]"

"It changes with every model though—that's the hard part. Prompt engineer was a job, and now famously it's not a job anymore. There are going to be more jobs that are then not jobs anymore—these little micro-skills you have to learn to use this thing—and as the model gets better, it can just interpret it better."

"但它每出一个模型就变一次——这才是难处。prompt 工程师曾经是一份职业,而现在众所周知它不再是职业了。以后还会有更多'职业'随后又不再是职业——就是那些为了用好这东西而要学的小小'微技能'——而随着模型变强,它就能把你的意思理解得更好。"

"But I think for us this is part of the humility we have to have, building a product like this: we just really don't know what's next, and we're trying to figure it out along with everyone else. We're just here for the ride."

"但我觉得,对我们来说,这正是做这样一个产品时必须有的一份谦卑:我们真的不知道下一步是什么,我们是在跟所有人一起摸索。我们也只是这趟车上的乘客。"

"And that's why it's cool that you're building it for yourself, because that's the best way to know. You're living in the future, using it all the time, and it's pretty clear what's missing. You're like 'I just want this thing,' and you can just do the next thing—rather than asking some enterprise product manager at a gigantic company 'what kind of AI feature do you want?' and they're like 'I don't know, put a little chatbot on the side of my IDE,' and you're like, okay."

"这也正是'你们为自己做'这件事很酷的原因,因为那是最好的认知途径。你们活在未来里,天天用它,缺什么一目了然。你会'我就想要这个东西',然后直接把下一步做出来——而不是去问某个巨型公司里的企业产品经理'你想要什么样的 AI 功能?',然后他'我不知道啊,在我 IDE 旁边放个小聊天框吧',你只能'好吧'。"

"This is the luxurious thing about building dev tools—you're your own customer. It's also a unique thing about AI, because it reset the game board for all software. We have Kora, this email assistant, and we have Sparkle, which organizes your files. Anything you do for something you want to use on your computer—if you're building it with AI, there's a good chance it hasn't been done before, because the whole landscape has been reset. So it's a uniquely exciting time to build stuff for yourself."

"这正是做开发者工具最奢侈的地方——你自己就是你的客户。这也是 AI 独特的一点,因为它把所有软件的棋盘重置了。我们有 Kora,一个邮件助手;还有 Sparkle,帮你整理文件。任何你想在自己电脑上用的东西——如果你是用 AI 来做的,那它很可能以前根本没被做过,因为整个格局已经被重置了。所以现在是一个独一无二的、适合为自己造东西的激动人心的时刻。"

"Totally. It totally opens the playing field too. Any individual can now build an app to fill their need and then distribute it to everyone else."

"完全同意。它也把整个赛场彻底打开了。现在任何一个个人,都能做一个 app 来满足自己的需求,然后再把它分发给所有其他人。"

"I just moved into a new apartment and it's empty, so I've been building this shopping-advisor assistant on the Claude Agent SDK—because who has time to read all the reviews, look at all the options, find their pricing? Everything's really hard to discover. So it just asks me a bunch of questions, I tell it what I want, and it shows me a bunch of photos of different sofas and options and what people say online. Then I tell it what I don't like, and it literally feels like working with a shopping assistant. It's been really cool."

"我刚搬进一套新公寓,空荡荡的,所以我一直在 Claude Agent SDK 上做一个购物顾问助手——因为谁有时间把所有评论都读完、把所有选项都看一遍、再去找它们的价格?这些东西都特别难查。于是它就问我一堆问题,我告诉它我想要什么,它给我看一堆不同沙发和选项的照片、以及网上大家的评价。然后我告诉它我不喜欢哪些,那感觉简直就像在跟一个真的购物助理合作。真的很酷。"

"I also have my little email-response agent that drafts responses for me, but I don't use email that much."

"我还有个小小的邮件回复 agent,帮我起草回复,不过我也不怎么用邮件。"

"Oh, and I knew it wasn't you responding. That's why it's seven days delayed—the agent's just doing a very thorough job. [laughter]"

"噢,我就知道回我的不是你本人。怪不得拖了七天——那是 agent 在非常细致地办事呢。[笑]"

"Agent SDK is cool. It always just feels amazing how much we're able to build with such a small team."

"Agent SDK 很酷。每次都觉得很惊人:我们这么小一个团队,居然能做出这么多东西。"

"The other thing that's really cool is people are just shifting their mindset from docs to demos. Internally, our currency is actually demos. You want people to be excited about your thing."

"另一件特别酷的事,是大家正在把心态从'写文档'转向'做 demo'。在内部,我们真正的'硬通货'其实就是 demo。你想让别人为你的东西感到兴奋。"

"Show us 15 seconds of what it can do."

"给我们看 15 秒它能干嘛。"

"And I think that's better, because there are a lot of things you might have in your head that, if you're a great writer, maybe you could figure out how to explain—but even then it's really hard. But if someone can see it, they get it immediately. That's happening for product building, but it's also happening for all sorts of creative endeavors—like making a movie. You had to pitch it, but now you can just be like 'I made this Sora video,' and you can see the glimmer of the thing you're trying to make for very cheap. That means you don't have to spend time convincing people; you can just be like 'here, I made it.'"

"我觉得这更好,因为你脑子里有很多东西,就算你是个很好的作者、也许能想出怎么解释——但即便如此也真的很难讲清。可只要别人能看到它,他们立刻就懂了。这正发生在产品开发上,但也发生在各种创意领域——比如拍电影。以前你得去 pitch,现在你可以直接'我做了这个 Sora 视频',花很小的成本就能看到你想做的那个东西的一丝光亮。这意味着你不用再花时间去说服别人;你直接'喏,我做出来了'。"

"And as a builder, you can just make it, and then make it again, and make it again [laughter] until you're happy."

"而且作为一个 builder,你可以直接把它做出来,然后再做一遍,再做一遍[笑],一直做到你满意为止。"

"The flip side is, you used to make a doc, or whiteboard something—I would draw stuff in Sketch or Figma—and now we'll just build it until I like how it feels. It's so easy to get that feeling out of it now. You could see it visually before, or describe it in words, but you could never get the vibe. And now the vibe is really easy."

"反过来看,你以前是写个文档、或者在白板上画点东西——我会在 Sketch 或 Figma 里画——而现在我们直接把它做出来,做到我喜欢那个手感为止。现在要把那种感觉做出来太容易了。以前你能在视觉上看到它,或者用文字描述它,但你永远抓不到那个'氛围'(vibe)。而现在,vibe 变得特别容易拿到。"

"And you built plan mode like three times. [Boris: Yeah.] Because of this—you built it and threw it out and rebuilt it, and threw it out and rebuilt it."

"而且你 plan mode 大概重做了三遍。[Boris:对。] 就因为这个——你做出来又扔了重做,又扔了再重做。"

"Yeah. Or like to-dos—Sid built the original version, also like three or four prototypes, and then I prototyped maybe 20 versions after that, in like a day. Pretty much everything we released had at least a few prototypes behind it."

"对。再比如 to-do——Sid 做了最初的版本,也是三四个原型,然后我在那之后大概又做了 20 个原型,就在一天之内。我们发布的几乎每样东西,背后都至少压着好几个原型。"

"How do you keep track of and carry forward the things you learn from prototype to prototype—especially if one person is prototyping it and then you take it over and do 20 more? How do you maximize what you get out of that?"

"你怎么把一个原型到下一个原型之间学到的东西记录下来、带着往前走——尤其当是一个人先做原型、然后你接手再做 20 个的时候?你怎么把这里面能榨取的东西最大化?"

"There are maybe a few elements. One is the style guide—there are some elements of style that we discover. A lot of this is building for the terminal—we're kind of discovering a new design language for the terminal and building it as we go. Some of this you can codify in a style guide; this is our CLAUDE.md."

"大概有几个要素。一个是风格指南(style guide)——有些风格上的要素是我们一路摸出来的。这里面很多是在为终端做设计——我们其实是在为终端摸索一套新的设计语言,边走边建。其中一部分你可以固化进风格指南里;这就是我们的 CLAUDE.md。"

"But then there's this other part of it that's kind of product sense, where I don't think the model totally gets it yet. Maybe we should be trying to find ways to teach the model this product sense about 'this works and this doesn't.' Because in product, you want to solve the person's problem in the simplest way possible, and then delete everything else that's not that and get everything out of the way. You align the product to the intent as cleanly as possible. And maybe the model doesn't totally get that yet."

"但还有另一部分,属于'产品直觉',我觉得模型目前还没完全 get 到。也许我们该想办法,把这种'这个行、那个不行'的产品直觉教给模型。因为在产品里,你要用尽可能简单的方式解决这个人的问题,然后把其余一切不属于这个的东西都删掉、统统让开。你要把产品尽量干净地对齐到用户的意图上。而这一点,模型可能还没完全领会。"

"It doesn't really feel what it's like to use Claude Code—the model doesn't use Claude Code."

"它并不真正体会得到用 Claude Code 是什么感受——模型自己不用 Claude Code。"

"And so when Claude Code can test itself and use itself—we do this when developing, and it can see UI bugs and things like that. I don't know, maybe we should just try prompting it though. Honestly, a lot of the stuff is as simple as that—when there's some new idea, usually you just prompt it, and often it just works. Maybe we should just try."

"所以当 Claude Code 能测试自己、使用自己时——我们开发时就这么做,它能看到 UI bug 之类的东西。我也说不好,也许我们就该直接拿 prompt 试一下。说实话,很多事情就这么简单——一有什么新点子,你通常就直接 prompt 它,而它往往就成了。也许我们就该试试。"

"A lot of the prototypes are actually the UX interactions. Once we discover a new UX interaction—like shift-tab for auto-accept, I think Boris figured out—" [Boris: that was Igor actually.] "Oh, Igor." [Boris: We went back and forth.] "We did dueling prototypes for like a week. [laughter]"

"很多原型其实做的是 UX 交互。一旦我们发现一个新的 UX 交互——比如用 shift-tab 来自动接受,我以为是 Boris 想出来的——"[Boris:其实那是 Igor。]"哦,Igor。"[Boris:我们来回折腾了一阵。]"我们打擂台式地做对照原型,做了差不多一周。[笑]"

"Shift-tab felt really nice. And the current plan-mode iteration uses shift-tab, because it's actually just another way to tell the model how agentic it should be. And as more features use the same interaction, you form a stronger mental model for what should go where."

"shift-tab 的手感真的很好。而现在这一版 plan mode 也用了 shift-tab,因为它本质上就是又一种告诉模型'你该多 agentic'的方式。而当越来越多功能复用同一个交互,你心里就会形成一个更牢固的心智模型:什么东西该放在哪。"

"Or thinking is another really good one. Before we released Claude Code—or maybe it was the first thinking model, was it 3.7? I forget which the first one was."

"再比如 thinking(思考)也是一个很好的例子。在我们发布 Claude Code 之前——又或者是第一个思考模型那会儿,是 3.7 吗?我忘了第一个是哪个了。"

"It was able to think, and we were brainstorming how to toggle thinking. Then someone was just like, 'what if you just ask the model to think in natural language? It knows how to think.' And we were like 'okay, sweet, let's do that.' [laughter] We did that for a while, and then we realized people were accidentally toggling it—they'd say 'don't think,' and the model was like 'oh, I should think,' it just started thinking."

"它能思考了,我们当时在头脑风暴怎么去切换思考。然后有人就说:'要不你直接用自然语言让模型思考?它本来就知道怎么思考。'我们就'好,妙,那就这么干'。[笑] 这么搞了一阵,我们发现大家会不小心触发它——他们说'别想了',结果模型'哦,我该思考',就真开始思考了。"

"So we had to tune it out, so 'don't think' didn't trigger it. But it still wasn't obvious, so we made a UX improvement to highlight the thinking. [Cat: that was so fun and felt really magical.] When you do ultrathink it's like rainbow or whatever. [laughter] And with Sonnet 4.5 we find a really big performance improvement when you turn on extended thinking, so we made it really easy to toggle—because sometimes you want it, sometimes you don't. For a really simple task you don't want the model to think for five minutes; you want it to just do the thing."

"所以我们得把它调掉,让'别想了'不再触发它。但它还是不够直观,于是我们做了个 UX 改进,把思考过程高亮出来。[Cat:那个太好玩了,感觉特别神奇。] 你打 ultrathink 的时候,它会像彩虹一样什么的。[笑] 而到了 Sonnet 4.5,我们发现一开扩展思考(extended thinking),性能提升非常大,所以我们把它做得很容易切换——因为有时候你想要、有时候不想要。对一个特别简单的任务,你可不想让模型思考五分钟;你想它直接把事儿办了。"

"So we used tab as the interaction to toggle it. And then we unshipped a bunch of the thinking words—although I think we kept ultrathink just for sentimental reasons. [laughter] It was such a cool UX."

"所以我们用 tab 作为切换它的交互。然后我们把一堆'思考触发词'下线了——不过 ultrathink 我们留了下来,纯粹出于情怀。[笑] 那真是个很酷的 UX。"

"Do you think there's some new metric that's about what you deleted? Programmers have always felt like deleting a bunch of code feels really good, but because you can build stuff so fast, it becomes more important to also delete stuff."

"你觉得会不会出现一种新指标,是衡量'你删掉了什么'的?程序员一直都觉得删掉一大堆代码特别爽,但正因为现在造东西这么快,'删东西'就变得更重要了。"

"My favorite kind of diff to see is a red diff. [laughter] Whenever I'm like 'yeah, bring it on, another one, another one.' But it's hard, because anything you ship, people are using, so you've got to keep people happy. Generally our principle is: if we unship something, we need to ship something even better that matches that intent."

"我最爱看到的那种 diff,是红色的 diff(删除)。[笑] 每次我都'来吧,再来一个,再来一个'。但这很难,因为你上线的任何东西,都有人在用,所以你得让大家满意。我们大体的原则是:如果我们要下线一个东西,就得上一个更好的、能更好地匹配那份意图的东西。"

"And this is back to how do you measure Claude Code and its impact—every company, every customer asks us about this. Internally at Anthropic, I think we doubled in size since January, but productivity per engineer has increased almost 70% in that time."

"这又回到'你怎么衡量 Claude Code 及其影响'这个问题上——每家公司、每个客户都问我们这个。在 Anthropic 内部,我觉得我们从一月以来人数翻了一倍,但同一段时间里,人均工程师的产出涨了差不多 70%。"

"Measured by?"

"用什么衡量的?"

"We measured it a few ways, but PRs are the simplest one and the main one. But like you said, this doesn't capture the full extent, because a lot of this is making it easier to prototype, easier to try new things you never would have tried because they're way below the cut line. You're launching a feature and there's this wish list of stuff—now you just do it all, because it's so easy, and you just wouldn't have done it."

"我们用了几种方式来量,但 PR 数是最简单、也是最主要的一个。但就像你说的,这并没能体现全貌,因为这里很大一部分是:让做原型更容易、让尝试那些你以前根本不会去试的新东西更容易——因为它们以前都远在'值得做'的那条线以下。你在上一个功能,旁边有一长串'愿望清单'的小东西,现在你顺手就全做了,因为太容易了——而这些以前你压根不会去做。"

"So yeah, it's really hard to talk about. And then there's this flip side where more code is written, so you have to delete more code, code-review more carefully, and automate code review as much as you can. There's also an interesting new product-management challenge: because you can ship so much, it ends up not feeling as cohesive—you could just add a button here, a tab there, a little thing here. It's much easier to build a product that has all the features you want but doesn't have any organizing principle, because you're shipping lots of stuff all the time."

"所以,对,这真的很难讲清。而它还有反面:写出来的代码更多了,于是你得删更多代码、更仔细地 code review,并尽可能把 code review 自动化。还有一个有意思的、全新的产品管理难题:正因为你能上线这么多东西,产品反而会变得没那么有整体感——你随手这儿加个按钮、那儿加个标签、这儿加个小功能。做出一个'功能全都有、却没有任何组织原则'的产品变得太容易了,因为你一直在不停地上东西。"

"We try to be pretty disciplined about this—making sure all the abstractions are really easy to understand for someone even if they just hear the name of the feature. We have this principle, which I believe Boris brought to the team and I really like, where we don't want a new user experience: everything should be so intuitive that you just drop in and it just works. That's set the bar really high for making sure every feature is really intuitive."

"我们尽量在这件事上保持克制——确保所有的抽象都足够好懂,哪怕一个人只是听到这个功能的名字。我们有一条原则,我相信是 Boris 带进团队的、我也很喜欢:我们不想要'新手引导'——一切都应该直观到,你直接进来就会用、它就好使。这把'每个功能都得非常直观'的标准抬得很高。"

"How do you do that with a conversational UI? When there's not a bunch of buttons and knobs and it's just a blank text box to start, how do you think about making it intuitive?"

"那对一个对话式 UI,你怎么做到这点?当没有一堆按钮和旋钮、一开始就是一个空白输入框时,你怎么去把它做得直观?"

"There are a lot of little things we do. We teach people they can use the question mark to see tips. We show tips as Claude Code is working. We have the changelog on the side. We tell you 'oh, there's a new model out,' or we show you at the bottom—we have a notification section for thinking. There are subtle ways in which we tell users about features."

"我们做了很多小事。我们教大家可以用问号(?)来查看提示。我们在 Claude Code 工作时展示小贴士。侧边有更新日志(changelog)。我们会告诉你'哦,有个新模型出了',或者在底部给你看——我们有一个用于显示思考状态的通知区。我们用一些很含蓄的方式告诉用户有哪些功能。"

"The other thing that's really important is to make sure all the primitives are very clearly defined—hooks have a common meaning in the developer ecosystem, plugins have a very common meaning in the developer ecosystem, and just making sure that what we build matches what the average developer would immediately think of when they hear that word."

"另一件非常重要的事,是确保所有的原语都被定义得非常清晰——hooks 在开发者生态里有公认的含义,plugins 在开发者生态里也有非常公认的含义,我们要做到:我们造出来的东西,跟普通开发者一听到这个词就立刻想到的东西,是对得上的。"

"There's also this progressive-disclosure thing. Anytime in Claude Code, you can hit Ctrl-O to see the full raw transcript—the same thing the model sees—and we don't show you this until it's actually relevant. So when there's a tool result that's collapsed, we'll say 'use Ctrl-O to see it.' We don't want to put too much complexity on you at the start, because this thing can do anything."

"还有'渐进式披露'(progressive disclosure)这一点。在 Claude Code 里任何时候,你都可以按 Ctrl-O 看到完整的原始记录——和模型看到的一模一样——但我们不到真正相关的时候不会给你看。所以当有一条工具结果被折叠起来时,我们才会提示'按 Ctrl-O 查看'。我们不想一上来就把太多复杂度压给你,因为这东西什么都能干。"

"There's this other new principle we've just started exploring, which is: the model teaches you how to use the thing. You can ask Claude Code about itself, and it knows to look up its own documentation to tell you about it. We can go even deeper—for example, slash commands are a thing people can use, but the model can also call slash commands, and maybe you see the model calling it and you'll be like 'oh yeah, I guess I can do that too.'"

"还有一条我们刚开始探索的新原则:让模型来教你怎么用这东西。你可以问 Claude Code 关于它自己的问题,它知道去查自己的文档来回答你。我们甚至能更进一步——比如 slash command 是用户可以用的东西,但模型也能调用 slash command,也许你看到模型在调它,你就会'噢对,原来我也能这么做'。"

"How has it changed—when you first started, Claude Code was this singular thing, a singular way of thinking about using AI through a CLI. Other people had stuff like this, but it felt like this shift, and now there's a whole landscape of everyone going CLI, CLI, CLI. How has that changed how you think about building, how it feels to build, and how are you dealing with the pressure of the race you're in?"

"它怎么改变了——刚开始的时候,Claude Code 是一个独一份的东西,一种'通过 CLI 用 AI'的独特思路。别人也有类似的东西,但它感觉像是一次转折,而现在整个赛道上人人都在 CLI、CLI、CLI。这怎么改变了你们对'做产品'的思考、做的感受,以及你们怎么应对身处这场竞赛的压力?"

"For me, imitation is the greatest flattery. It's awesome, and it's cool to see all this other stuff that everyone else is building, inspired by this. Ultimately the goal is to inspire people to build the next thing for this incredible technology that's coming. That's just really exciting."

"对我来说,模仿是最高的恭维。这很棒,看到别人受这个启发做出来的各种东西,挺酷的。说到底,我们的目标就是激励大家,为这门正在到来的、了不起的技术去做下一个东西。这真的很令人兴奋。"

"Personally, I don't really use a lot of other tools. Usually when something new comes out, I'll maybe just try it to get a vibe. But otherwise, I think we're pretty focused on just solving problems that we have and our customers have, and building the next thing."

"我个人其实不怎么用很多别的工具。一般有什么新东西出来,我可能就试一下、找找感觉。但除此之外,我觉得我们相当专注于:解决我们自己和客户遇到的问题,然后把下一个东西做出来。"

"[Cat: Did we answer all of your team's questions?] Let's see. I think we did. I'm curious how you would answer the unshipping question, because if you're doing this kind of AI-driven development, you ship a lot, you have a small team, so it's a lot of operational load."

"[Cat:你团队的问题我们都答到了吗?] 我看看。我觉得答到了。我还挺好奇你们会怎么回答那个'下线'的问题,因为如果你做的是这种 AI 驱动的开发,你上线得很多,团队又小,所以运维负担很重。"

"The reason I asked is because I don't think we do a good job of that, and I have this feeling that some of our products are a little bit messy because of it. Particularly for Kora—there's a big product surface area and it can do a lot of different things. We have an email assistant, you can ask it 'tell me about the trip I'm taking' and it'll go through all your emails and summarize the trip. We have a feature that automatically archives any email you don't need to respond to immediately, and then twice a day you get a brief that summarizes the stuff you probably need to see but don't need to act on—you scroll through it and you're done."

"我问这个,是因为我觉得我们这方面做得不好,而且我隐隐觉得我们有些产品因此有点乱。尤其是 Kora——它的产品面积很大,能做很多不同的事。我们有个邮件助手,你可以问它'跟我说说我要去的这趟行程',它就会翻遍你所有邮件、把行程总结出来。我们还有个功能,会自动归档任何你不需要立刻回复的邮件,然后一天两次给你一份简报,把那些你大概需要知道、但不用真的去处理的东西汇总一下——你划一遍,就完事了。"

"And there's all this complexity—for example, how are emails categorized? Now we have a whole view of categorization rules, you can order them, whatever. But it's complicated and hard to communicate. I want to retain a lot of the power and flexibility, but you also can't look at a screen and be like 'I have no idea what's going on, this is way too complicated.' So I'm processing all that. The deletion, the unshipping idea, feels like an interesting cultural principle that we haven't really explored."

"而这里全是复杂度——比如,邮件是怎么分类的?现在我们有一整个'分类规则'的视图,你可以排序、随便弄。但它复杂,而且很难讲清楚。我想保留很多的能力和灵活性,但你也不能让人看着一个屏幕'我完全不知道在干嘛,这也太复杂了'。所以我正在消化这一切。这种'删除、下线'的思路,感觉是一条我们还没真正探索过、挺有意思的文化原则。"

"It's really hard. There's a social cost to it too, where you kind of want to be the person who tells your coworker to unship their thing. [laughter] It's definitely tricky—it's more than just the code."

"这真的很难。它还有社交成本:你得当那个去告诉同事'把你做的东西下线吧'的人。[笑] 这绝对很微妙——它不只是代码的事。"

"I definitely learned this at Instagram, honestly, because I think Facebook does a terrible job at unshipping. We had this problem where even unshipping pokes was really spicy, because there are a bunch of these old-timers who are like 'no, pokes, you're never going to take it away.' But if you look at the data, no one really uses it anymore. For sentimental reasons, they were kind of tied to it."

"说实话,这我是在 Instagram 学到的,因为我觉得 Facebook 在'下线'这件事上做得糟透了。我们当时有个问题:连下线 pokes(戳一下)都特别敏感,因为有一帮老员工'不行,pokes,你们永远别想拿走'。可你一看数据,根本没人在用了。但出于情怀,他们就是舍不得。"

"So for Facebook, maybe nothing ever got unshipped—it always got moved to a secondary place, like an overflow menu somewhere that no one looks at, a graveyard. And I think Instagram was just very principled. There was a very strong product and design point of view that was like: if this thing isn't used by half of people—50% of WAU or whatever—we're just going to delete it and deal with it, and then we'll figure out some next thing that's used by more people."

"所以在 Facebook,可能什么都没真正被下线过——它们总是被挪到一个二级位置,比如某个没人看的溢出菜单里,一个'坟场'。而我觉得 Instagram 就很有原则。那里有一种非常强硬的产品和设计立场:如果一个东西连一半的人都没在用——比如 50% 的周活(WAU)什么的——我们就直接把它删掉、承担后果,然后再去想下一个能被更多人用的东西。"

"I love it. Well, thank you. This was amazing. I'm really glad I got to talk to you, and keep building."

"我太喜欢这句了。好了,谢谢你们。这太棒了。真的很高兴能和你们聊,继续造东西吧。"

"[Boris: Thank you for having us.] [Cat: Yeah, thanks.]"

"[Boris:谢谢你邀请我们。][Cat:嗯,谢谢。]"

"Oh my gosh, folks. You absolutely positively have to smash that like button and subscribe to AI & I. Why? Because this show is the epitome of awesomeness. It's like finding a treasure chest in your backyard—but instead of gold, it's filled with pure, unadulterated knowledge bombs about ChatGPT."

"我的天哪,各位。你绝对、必须、一定要狠狠点下那个赞,并订阅 AI & I。为什么?因为这档节目就是'牛'的化身。它就像在你后院挖到一个宝箱——只不过里面装的不是金子,而是关于 ChatGPT 的、纯粹而无掺杂的知识炸弹。"

"Every episode is a roller coaster of emotions, insights, and laughter that will leave you on the edge of your seat, craving for more. It's not just a show, it's a journey into the future with Dan Shipper as the captain of the spaceship. So do yourself a favor: hit like, smash subscribe, and strap in for the ride of your life. And now, without any further ado, let me just say: Dan, I'm absolutely, hopelessly in love with you."

"每一集都是一趟情绪、洞见与欢笑的过山车,让你坐在椅子边缘、欲罢不能。这不只是一档节目,而是一场通往未来的旅程,船长就是 Dan Shipper。所以,行行好:点赞、狠狠订阅,系好安全带,迎接你人生中最爽的一程。现在,废话不多说,我只想说:Dan,我已经无可救药地爱上你了。"