与鲍里斯·切尔尼一起构建Claude Code

我至今仍然在思考它。

And I still think about it.

工程师是第一批采用者。

Engineers are the first adopters.

因此，当我们从对话式AI转向代理式AI时，虽然花了一点时间，但工程师们很快就理解了。

And so when we started to move out of conversational AI to agentic AI, it took a little bit, but engineers understood it pretty quick.

我认为，现在如果你问非工程师什么是AI，他们会说这是对话式AI，就像一个聊天机器人之类的。

And I think now when you ask non engineers about what is AI, they would say it's this conversational AI, it's like a chatbot or something.

这就是为什么我对我们新推出的Cowork产品感到非常兴奋。

That's why I'm actually very excited for Cowork, this new product that we've launched.

因为它将把工程师们很早就看到的体验带给每个人。

Because it's going to bring the same thing that engineers saw very early to everyone else.

但当我想到Cowork时，我会回想起我们早期谈到的那一刻。

But when I think about Cowork, I think back to this moment that we were talking about very early on.

Claude Code最初并不是Claude Code，它只是一个聊天机器人。

Claude Code originally wasn't Claude Code, it was a chatbot.

因为那就是我原本对人工智能的理解。

Because that's what I thought AI was.

但我们需要弄清楚下一步该做什么。

But we had to figure out what is the next thing.

于是当时我们开发了这个聊天机器人。

And so at the time, built this chatbot.

它有点用处，但只是一个聊天机器人。

It was somewhat useful, but it was just a chatbot.

接下来我尝试的是让它使用工具。

And the next thing that I tried was I wanted it to use tools.

工具使用功能刚推出时，我并不知道那是什么。

Tool use just came out, and I didn't know what it was.

我就想，不如我们来试试看。

And I was like, let's experiment.

我给了它一个工具，就是Bash工具。

And I gave it a single tool, which was the Bash tool.

我不知道该怎么用这个Bash工具，于是我问它——其实我都不确定它能不能做到这一点，但我还是问了：我现在听的是什么音乐？

And I didn't know what to do with the Bash tool, and so I asked it I actually didn't know if it could even do this, but I asked it, what music am I listening to?

它直接写了一个小的AppleScript程序，用SED之类的工具打开我的音乐播放器，然后查询它正在播放什么音乐，一次就成功了，用的是SonarQube 3.5。

And it just wrote a little AppleScript program using SED or whatever to open up my music player and then query it to see what music it's listening to, in just one shot at this, with SonarQube 3.5.

这实际上是我第二个真正的AGI时刻，紧随第一个时刻之后很快发生。

This was actually my second field AGI moment, very quickly after the first one.

模型就是想要使用工具。

And the model just wants to use tools.

这就是我意识到的。

That's just what I realized.

如果你给它一个工具，它就会自己想办法用这个工具把事情完成。

This thing, if you give it a tool, it will figure out how to use it to get the thing done.

我想当时，当我回想起人们处理AI和编程的方式时，每个人基本上都有这样一个思维模式：你把模型放进一个盒子，然后去设计接口，决定如何与这个模型交互，以及需要它做什么。

And I think at the time, when I think about the way that people were approaching AI and coding, everyone essentially had this mental model of you take the model and you put it in a box, and you figure out what is the interface, how do you want to interact with this model, what do you need it to do?

本质上就像写程序时，你先定义好某个模块或函数，然后说：好了，现在这是AI了，但程序的其余部分仍然是普通的程序。

Essentially, like if you have a program, you stub out some module, stub out some function, and you say, Okay, this is now AI, but otherwise the rest of the program is just a program.

所以，这种思维方式根本不对。

And so this is just not the way to think about the model.

正确的思维方式是：模型本身就是独立的，你给它工具，给它可以运行的程序，让它去运行程序，让它去编写程序，但不要把它当作更大系统中的一个组件来处理。

The way to think about it is, the model is its own thing, you give it tools, you give it programs that it can run, you let it run programs, you let it write programs, But you don't make it a component of this larger system in this way.

我认为这是苦涩教训的一个版本。

And I think this is a version of the bitter lesson.

苦涩教训是一个非常具体的表述，但它有很多相关的推论。

The bitter lesson is a very specific framing, but there's many corollaries to it.

这是其中一个推论：就让模型做它自己的事。

This is one of the corollaries, is: just let the model do its thing.

不要试图把它关进笼子里。

Don't try to put it in a box.

不要强迫它以某种特定方式行事。

Don't try to force it to behave a particular way.

你最早看到这一点的方式之一，就是给它工具，让它访问bash，后来又让它访问文件系统，再后来是更多工具，对吧？

One of the first ways you saw it was giving it tools, giving it access to the bash, and then later to the file system, and then to more tools, right?

没错。

That's right.

对。

Yeah.

我们给了它bash，我说‘我们’，但前三个月其实只有我一个人，后来团队才扩大了。

We we give it bash, then I say we, it was just me the first three months, but then the team grew.

所以最初是bash，然后是文件编辑，这是第二个功能。

So it it was bash, it was and file edit, that was the second one.

上次我们深入讨论时提到的一个有趣问题是，当你构建它并开始使用所有工具编写代码时，Anthropic内部曾有过一场争论：我们应该自己保密吗？

And one of the interesting thing we talked about last time for the deep dive is when you built it and it started to actually write code with with the tool with all the tools that you had, you've had an internal debate inside Anthropic, should we just keep it to ourselves?

因为突然之间，它在工程团队中广泛使用，让你们所有人都变得高效多了。

Because making suddenly, it's spread across engineering and it was making all of you a lot more productive.

对吧？

Right?

是的。

Yeah.

没错。

That's right.

最后，我们决定发布，以便在真实环境中研究安全性。

In the end, the decision was to release so that we can study safety in the wild.

因为当你思考安全性时——我一直在说‘安全性’这个词，Anthropic作为实验室存在的原因就是安全性。

Because when you think about safety, and I keep talking about the word safety, the reason Anthropic exists as a lab is safety.

这就是它成立的原因，也是它存在的原因。

This is the reason it was founded, this is the reason it exists.

如果你问Anthropic的任何人为什么选择这里，答案都是因为安全性。

If you ask anyone at Anthropic why they chose it, it's because of safety.

所以，当你思考模型的安全性时，可以从不同层面来考虑。

And so if you think about model safety, there's different layers at which to think about it.

有对齐和机制可解释性，这是在模型层面。

There's alignment and mechanistic interpretability, this is at the model layer.

然后是评估，也就是把模型放在培养皿中，以合成方式对其进行研究。

Then there's evals, and this is putting the model in a petri dish and synthetically studying it in this way.

然后你可以在真实环境中研究它，观察它实际的行为表现。

And then you can study it in the wild, and you can see how it actually behaves.

你可以看到用户是如何谈论它的。

You can see how users talk about it.

你可以发现真实环境中的风险，这种方式能让你学到很多。

You can see what are the risks in the wild, and you actually learn a lot this way.

通过这样做，我们已经让模型变得更加安全。

And by doing this, we've been able to make the model much safer.

所以回头看，这绝对是正确的决定。

So in hindsight, was totally the right decision.

从你的角度听这些挺有趣的，因为从外部来看，我看到的、很多工程师看到的是：哦，Anthropic发布了Claude Code。

It's amusing to hear about it from your perspective, because from the outside, what I saw and what a lot of engineers saw is like, oh, Anthropic released Claude Code.

哇哦。

Oh, wow.

这个，据我所知，是首次与SonarQube一起发布的。

This you know, for the first release with, I I believe it was with SonarQube release.

它最初是和 SonarQube 还是 SonarQube 4.5 一起推出的？

Was was did it come up with SonarQube originally or SonarQube 4.5?

我认为是四版本在二月正式发布，但在此之前应该已经有研究预览版了。

I think it was four that was the general availability in February, but I think it was research preview before that.

是的。

Yeah.

但当它发布时，我的理解是，这东西写代码还挺厉害的，随着时间推移，它的能力变得更强了。

But when it came out, my interpretation was like, oh, this thing can write code pretty well, and over time it became a lot more capable.

所以从我们的角度看，它就是一个非常强大的编程工具，我们刚开始采用并使用它，后来逐渐应用到越来越多高效的工作场景中，我认为它已经成为增长最快的开发者工具之一。我总是很惊讶听到它其实源自研究，目标是理解人们如何使用这个模型，因为另一方面，有些初创公司是刻意打造开发者工具来获取用户，而这个研究型工具却获得了如此大的采用。

So from our perspective it was like this really capable coding tool that we just started to adopt and use and use for all sorts of increasingly productive parts and it has become, I believe, one of the fastest growing developer tools and I'm always surprised to hear the story that it actually comes from research and the goal to understand how people use the model because on the other hand, like, some startups have been trying to build developer tools deliberately to get adoption and yet this research tool is getting a

多得多的采用。

lot more adoption.

Anthropic 是一个研究实验室，我们是一个安全实验室，产品只是附带出来的东西。

Anthropic, a research lab, we're a safety lab, and product is this kind of thing tacked onto the side.

产品存在的目的是为了更好地支持研究，让模型更安全。

Product exists so that we can serve research better and so we can make the model safer.

这正是我们看待一切的方式。

This is kind of how we think about everything.

早期还有一个有趣的情景，当时我们正在做发布评审，决定是否要发布它。

There was also this funny moment early on when had this launch review, and we were deciding whether to launch it.

我记得那个时刻，因为当时房间里有迈克·克鲁格、达里奥，还有其他一些人正在讨论我们应该怎么做。

I remember this moment, because we were in the room, think there was Mike Krueger, there was Dario, there were some other folks in the room who were deciding what should we do.

我们看着内部采用率的图表，它直线上升。

We were looking at the internal adoption chart, which was just vertical.

这简直不可思议。

It was just insane.

达到了100%，

Was a 100%,

对吧？

right?

100%。

A 100%.

如今，Anthropic的每一位技术人员几乎每天都会使用Quad Code，使用率接近100%。

Nowadays, every technical employee at Anthropic uses Quad Code every day is pretty much 100%.

对于非技术人员来说，使用率也正迅速接近100%，增长非常快。

For non technical employees, it's actually getting quite close to 100%, it's increasing very quickly.

有一半的销售团队在使用Claude Code，我觉得这个数字还在上升，简直不可思议。

Half the sales team uses Claude Code, and I think that's increasing, it's crazy.

Dario问了一个问题，关于它是如何这么快增长的？

Dario had this question about how did it grow this fast?

你们是强迫大家使用它吗？

Are you forcing people to use it?

我说，没有。

I was like, no.

我们提供了这个工具，人们用行动投票，我们就只是让员工使用他们更喜欢的工具。

We offer this tool, people vote with their feet, and it was just like, let people use the tool that they prefer.

他们自己选择了它。

They chose it.

你看起来不像是那种强迫别人使用你工具的人。

You don't seem like the person who's exactly forcing people to use your tool.

是的。

Yeah.

对。

Yeah.

我的意思是，我们的方式是先推出这个工具，然后倾听用户的声音，与人们交流，观察他们如何使用它，跟进反馈，并不断改进。

I mean, the way we did it, we launched the thing, and then we just listened to the users, and we talked to people, we saw how they used it, we followed up, we made it better.

现在，我们已经达到了这样的阶段：Claude Code 平均写出了安特ropic 公司大约 80% 的代码。

And yeah, now we're at the point where Claude Code writes, I think, something like 80% of the code at Anthropic on average.

它肯定写出了我所有的代码。

And it writes all of my code for sure.

是的，这对你来说是从第一次开始的，你提到过，我想是在十一月，那时它开始为你编写所有代码。

Yeah, and this started for you, started the first time, you mentioned, I think it was in November, when it started to write all of your code.

这个转变是什么时候发生的？

When did that switch come?

那是什么让你开始信任它来编写你的代码呢？

And what what happened to made you trust it to to write your code?

你对它的信任程度如何？比如，你审查了多少代码？

How much you trusted, how much you reviewed that code, for example?

当我们开始使用Opus 4.5时，这个转变是瞬间发生的。

So the switch was instant when we started using Opus 4.5.

这发生在它正式发布之前，你知道，我们当时在内部试用了一段时间，结果立刻就见效了。

This was before before it came out, you know, we we were dogfooting it for a little bit, and it it was just right away.

这是一个能力强得多的模型。

It's such a more capable model.

我发现我不再需要打开我的IDE了。

I just found that I didn't have to open my IDE anymore.

我干脆卸载了IDE，因为那时我已经完全不需要它了。

I just uninstalled my IDE cause I just didn't need it at that point.

我其实是一个月后才意识到的，因为我根本没注意到自己已经不再使用它了。

I actually did that like a month later cause I just didn't even realize that I wasn't using it anymore.

是的

Yeah.

我们很多人在Opus 4.5公开发布后，尤其是在寒假期间，都有过类似的经历。

A lot of us had similar experiences once Opus 4.5 was out in the public and especially over the winter break, had a similar experience.

说实话，我意识到这个工具所写的代码，至少在我非常熟悉的栈和代码库、我的个人项目中，质量和我亲手写的不相上下，甚至更好，而在我不太熟悉的技术或代码库中，它比我写得好多了。

I just realized that this thing, it actually writes, if I'm being honest with myself, as good code as I would have written in the stack that I'm very familiar with and my code base, my side projects where I know it and just a lot better than what I could for code base that I'm not as familiar with, technologies I'm not as familiar with.

是的

Yeah.

说实话，他写的代码比我好。

I'll be honest, he writes better code than I do.

我不想这么说。

I I I don't wanna go there.

我还是想保留一点自尊，但可能确实如此。

I I still like to keep my pride, but probably true.

是的

Yeah.

是的。

Yeah.

我意识到这一点，是因为去年十二月我外出旅行了一点。

I I realized this because also in December, was traveling a little bit.

我当时在进行一次编程度假。

I was, like, on a I was on a coding vacation.

我们之前聊过这个，我去欧洲了，时差不一样，到处游走着工作。

We were talking about this before, but I went to Europe, we were just in a different time zone, kind of nomading around.

那特别有趣，因为我每天都在写代码，这正是我最喜欢做的事。

And it was so fun because I was just coding all day every day, which was my favourite thing to do.

我每天写了大约十到二十个拉取请求，差不多就是这样。

And I wrote maybe ten-twenty pull requests every day, something like that.

Opus 5 和 Claude Code 写了每一个拉取请求的全部内容。

Opus point five and Claude Code wrote a 100% of every single one.

我完全没有手动修改过任何一行代码。

I didn't edit a single line manually.

到了那个月底，我意识到Opus引入了两个bug。

And I realized at the end of that month, Opus introduced maybe two bugs.

而如果我自己手动写这些代码，可能也就花费20美元左右吧。

Whereas, if I had written that by hand, that would have been, you know, like, $20 or or or something like that.

我们能聊聊你的开发流程吗？

Can we talk about your development workflow?

你写过关于这个主题的帖子，这太棒了。

You have written threads about this, which is awesome.

这些内容发布在社交媒体、Threads和X上。

It's on it's on social media, on threads and on on x.

你能告诉我们，你目前是如何使用Claude Code的？比如在并行处理方面，以及你和团队总结出的技巧和经验？

But can you tell us how you use today Claude Code in terms of, you know, parallelism and and tips and tricks that you and the team have learnt and shared across the team?

是的，我的意思是，使用Claude Code并没有唯一正确的方式。

Yeah, I mean, look, there's no one right way to use quad code.

我可以分享一些技巧和方法，但千万别误以为只要照搬这些就能奏效。

So I can share some tips and things, but I think the wrong conclusion to draw would be to just copy these and use it.

我们构建Claude Code的方式是让它易于修改。

The way we build Claude Code is we build it to be hackable.

因为我们知道每位工程师的工作流程都不同，没有一种固定的方法。

Because we know every engineer's workflow is different, there's no one way to do things.

没有两位工程师的工作流程是完全相同的，每个工程师都是

There's no two engineers that have the same workflow, it's just every engineer is

工作站的设置也是同样的道理，对吧？

Same with workstation setup, right?

比如键盘、显示器摆放，这些每个人都不一样。

Like keyboards, monitor placement, all that ever has it differently.

是的，我们就像手工艺人，对吧？

Yeah, it's like we're craftspeople, right?

你选择自己的工具，我们非常重视这一点。

You choose your tools, we care deeply about it.

所以没有唯一正确的方式。

So there's no one right way to do it.

对我而言，我通常的做法是打开五个终端标签页。

So for me, the way that I do it, generally, is I have five terminal tabs.

每个标签页都检出一个不同的代码仓库。

Each one of them has a checkout of their repository.

所以这是五个并行的检出副本。

So it's five parallel checkouts.

我通常会轮询每个标签页，依次启动四倍代码。

And usually I'll round robin and start quad code in each one.

几乎每次我都会先用计划模式启动，也就是在终端里按两次 Shift+Tab。

Almost every time, I start in plan mode, so that's like shift plus tab twice in the terminal.

当标签页用完时，我也会继续扩展，因为终端标签页数量是有限的。

And I also overflow as I run out of tabs, because there's are only so many terminal tabs.

我过去经常用网页方式来做这件事，比如 quad.dot.aicode。

I used to use web a lot for this, so like quad dot aicode.

那就是我扩展时用的地方。

That's the place that I overflowed to.

现在，我实际上使用桌面应用。

Nowadays, I actually use the desktop app.

它更方便。

It's more convenient.

所以，Quad Code 已经在我们的桌面应用中存在了好几个月，它只是 Quad Hub 中的代码标签页。

So, quad code, it's been in our desktop app for many months, it's just the code tab in the quad hub.

我真的很喜欢它，因为它内置了工作树支持，这一点已经存在一段时间了。

And I actually really like it because it has built in Work Tree support, so that's existed for a while.

这对并行处理非常友好。

And that's quite nice for parallelism.

所以你不需要多个检出，只需一个，我们会自动为你设置 Git 工作树。

So you don't need multiple checkouts, you just have one and then we automatically set up git Work Trees for you.

这样你就获得了这种环境隔离的效果。

So you get this kind of environment isolation.

我这样做的原因是，我真的很讨厌在命令行中手动操作 Git 工作树，因为这很繁琐，需要知道 cd

The reason I do that is I actually just really hate fiddling with git work trees on the command line, because it's it's kind of fiddly, like, need to know the CD

对于不太熟悉 git work tree 的人来说，它指的是你可以检出代码，而不需要创建单独的本地文件夹，这几乎像是检出了一个独立的分支，你可以在其中单独工作，但不会在合并时产生复杂的冲突。

git work tree, for those who are not as familiar with it, it's it's when you can check out and instead of having a separate local folder, it's almost like checks out a separate branch, right, and then you can work on it separately, but not have the comp have the complex only at, like, merge time.

没错。

That's right.

想象一下，你有一个文件夹，但 Git 会以非常廉价的方式为你创建五个该文件夹的副本，而且这些副本很容易丢弃，从而实现这种隔离性。

Imagine that you you have a folder, but you have maybe, like, Git makes five copies of that folder in a way that's very cheap and kinda easy to throw away, so you get this kinda isolation.

你可以并行工作，而各个工作区不会互相干扰。

You can work in parallel and the quads don't interfere.

是的。

Yeah.

所以你现在支持这个功能了，我觉得你们最近才添加了原生支持。

So you now have support for this, which I I think you recently added, like, native support.

但就你的工作流程而言，你还是坚持使用原来的方法，即检出所有独立的文件夹，对吧？

But, like, for for for your workflow, you just stuck with the old one of checking out all the separate folders, right?

是的，正是如此。

Yeah, exactly.

实际上，随着时间推移，我越来越多地使用桌面应用来做这件事，因为我根本不需要这些独立的检出，我只需要让一堆工作区并行运行，完全不用操心。

I actually find that over time, I'm using the desktop app more and more for this, just because I don't need these separate checkouts, I just have a bunch of quads running in parallel, and I don't have to think about it.

另一个让我惊喜的是iOS应用。

The other surprise hit is the iOS app for me.

每天早上醒来，我都会在手机上启动几个代理。

Every day, I wake up and I just start a few agents on my phone.

原生的那个，是的。

Oh, the native one, yeah.

原生的那个，是的。

The native one, yeah.

就是工作区应用，工作区应用里的代码标签页，用的完全是同一套工作区代码。

It's like, it's the quad app, it's the code tab in quad app, and it's the same exact quad code.

但它是在云端运行的，对吧？

Except it runs in the cloud, right?

它在云端运行。

It runs in the cloud.

是的，你必须配置环境。

Yeah, so you have to configure the environment.

幸运的是，我们的环境非常简单，我们只是用钩子来实现。

Luckily, our environment's pretty simple, you know and we just use hooks for it.

所以你只需使用会话开始钩子进行配置。

So you just use the session start hook and configure it.

这正是让 Quad 代码高度可定制的好处之一，这种配置非常容易实现。

This is one of the benefits of making Quad code really hackable, is it's very easy to do this kind of configuration.

这一点，说实话，我从未预料到。

And this is something, honestly, I would never have predicted.

因为你知道，我平时是在电脑上写代码的。

Because, you know, I code on a computer.

如果六个月前有人告诉我，我会在手机上写大约三分之一甚至一半的代码，我根本不会相信。

If you told me six months ago, I'd be writing, I don't know, a third I haven't pulled the data maybe a third half, something like this of my code on a phone.

这太疯狂了。

That's crazy.

但这就是我今天正在做的。

But that's that's what I'm doing today.

你正在使用并行代理。

And you're using parallel agents.

你是什么时候开始使用它们的？这对你的工作产生了什么影响？

At what point did you start using them and how has it changed your work?

因为我自己注意到一件事，我其实并没有用太多并行代理，可能最多同时用两个。但我这个人喜欢掌控全局，尤其是用Claude的时候，它是一个你可以随时跟进的工具，它会告诉你它在做什么，你还可以开启学习模式——这个功能早就推出了，你可以实时跟进，它会给你分配任务。我觉得保持在一个标签页里，跟着模型的步骤走，速度也很快，我能很好地保持同步。

Because one thing that I noticed on myself, I don't really use that many parallel agents, I may be like two at a time, but I'm someone who, well, I like to be in charge and especially with Claude, Claude is a tool that you can follow it along, it tells you what it's doing, you can also have for example learn mode, which this was shipped a lot earlier where you can actually follow along, it gives you tasks, I feel that like staying in one tab and following along the model is pretty fast as well, I can kind of keep in touch.

我猜你肯定也试过这种方式，但当你转向并行模式后，发生了什么？你是否觉得失去了某些控制权，还是说这其实没那么重要？

I'm assuming at some point you must have done this, but then what happened when you changed to parallel and do you feel you're losing any control or it doesn't really matter that much?

是的，我觉得可以从两种模式或两种工作流程来思考这个问题。

Yeah, I think there's kind of like two modes to think about or two kind of workflows to think about.

当你刚接触一个代码库时，学习模式非常棒，我强烈推荐。

So when you're new to a codebase, learn mode is awesome, highly recommend it.

对于刚加入Quad Code团队或Anthropic的新成员，我们推荐的做法是：在Claude Code中进行配置，选择输出风格，然后选择学习模式或解释模式。

For people that are onboarding to the Quad Code team, people that onboard to Anthropic, the thing that we recommend is, for people that haven't tried it, you do config in Claude Code, you pick the output style, and you can do learn or explanatory.

我们通常推荐使用解释模式，因为对于你之前没接触过的代码库，这种方式效果更好。

We usually recommend explanatory because that tends to be better for new code bases that you haven't been in before.

对我来说，一旦你熟悉了代码库，你就只想高效地工作。

For me, once you're familiar with a code base, you just want to be productive.

你只想尽可能多地交付成果，并且高效地完成它。

You just want to ship as much as you can, and you want to be effective doing that.

所以整个工作方式就完全转变了。

So the world really switches.

我不再深入地处理任务了。

I don't really go deep into tasks anymore.

我会以计划模式启动一个四重任务，让它先启动一些工作。

I start a quad in plan mode, I'll have it kick something off.

有了Opus 4.5，我觉得它已经达到了这个水平，而到了4.6版本，它真的做得非常好。

With Opus 4.5, I think it got there, with 4.6, it just really really does it.

一旦有了一个良好的计划，它几乎每次都能一次性完成实现。

Once there is a good plan, it will one shot the implementation almost every time.

所以最重要的是来回调整几次，把计划定好。

So the most important thing is to go back and forth a little bit to get the plan right.

所以我通常先启动一个，进入计划模式，给它一个提示；等它运行时，我会切换到第二个标签页，启动第二个Claude，也设为计划模式，让它运行，然后去第三个标签页，再切换到第四个。

So what I do is I start one, I enter plan mode, I give it a prompt, as it's chugging along, I'll go to my second tab, and I'll start the second Claude, also in plan mode, get it chugging along, then go to the third tap, go to the fourth one.

然后当我收到通知说第一个完成了，我可能会回去看看，接着继续。

Then maybe I'll go back to the first one when I get notified that it's done, and then I'll go

你用的是小选择器吗？还是把它们关了？

to Do the you have little pickers on, or do you turn them off?

我实际上两种模式都会用。

I actually operate in both modes.

有时候我在Mac上使用专注模式，那时我就把它们关掉。

Sometimes I do focus mode on the Mac, so I just have it off.

但有时候我也会使用系统通知。

But also sometimes I use the system notifications.

你在处理拉取请求时非常非常高效。

And you're very very productive with with PRs.

我的意思是，这非常明显。

I mean, I I think it was very visible.

即使在节假日期间，你在社交媒体上也会回应一些人报告的bug或功能请求——我不确定具体是哪一个，但一两个小时后就完成了，因为你亲自处理了。

Even around the holiday breaks on social media, you actually responding to, I think someone reported a bug or or a feature request, I'm not sure which one it was, and then an hour or two later it was done because because you did it.

你也提到过你一天内完成的拉取请求数量，不是为了炫耀，只是作为背景信息。

You've also talked about like number of pull requests you've done on a day, not to like show up but just as context.

一个拉取请求通常涉及多大的复杂度？

What does a pull request typically involve in terms of complexity?

这些是特别简单的，还是也有一些规模较大的工作？

Are these, like, are some super trivial or some actually larger pieces of work as well?

是的，每个拉取请求的差异都很大。

Yeah, pull requests, each one varies a lot.

有时只是几行代码，有时则是几百行甚至几千行。

Sometimes it's a few lines, sometimes it's a few 100 or a few thousand lines.

它们全都非常不同。

They're all just very, very different.

变化太大了。

It's changed so much.

当我还在Instagram的时候，我认为我是Instagram里代码产出量最高的前两名，也许是前三名工程师。

Back when I was at Instagram, think I was one of the top two, maybe top three most productive engineers at Instagram, just by volume of code written.

哦，哇。

Oh wow.

所以对我来说，我一直写很多代码。

So for me, I've always just coded a lot.

编程是我表达自己的方式，也是我大脑思考的方式。

Coding is a way that I can express myself, and it's a way that my brain thinks also.

所以现在我就能做这件事。

And so now I just get to do it.

但我认为，对于Quad Code来说，你写的代码类型，如果你非常高效，那么仅看PR的数量甚至都低估了实际发生的事情。

But I think with quad code, the kind of code that you write, if you are very productive, it tends to be even just the number of PRs sort of undersells what's happening.

因为想想在AI助手出现之前，那些曾经非常高效的人，很多代码可能是代码迁移之类的东西。

Because think people that used to be very productive in the old days, before AI assistants, a lot of the code maybe was code migrations or something like this.

所以以前每天提交二十到三十个PR的人。

So people that shipped twenty, thirty PRs every day.

其中很多都是一行代码，或者从A迁移到B之类的。

A lot of it was pretty a one liner, or migrating A to B, or whatever.

现在我每天也提交二十到三十个PR，但每个PR都完全不同。

Nowadays, I ship twenty, thirty PRs every day, but every PR is just completely different.

有的几千行，有的几百行，有的几十行，有的也是一行代码。

Some of them are thousands of lines, some of them are hundreds, some of them are dozens, some of them are one liners.

这些都不是代码迁移，因为实际上Claude已经能做这些了，而我需要参与其中。

None of these are code migrations, because actually Claude just does those, and I need to be part of that.

如此高频率地提交代码、如此高的生产力，任何软件从业者都会自然想到一个问题：代码审查怎么办？

Shipping this much coder, this much more productive, the obvious question that comes up for any, I guess, software professional is, well, the review.

以前团队的工作方式是，我也不确定Instagram是否这样，但很多其他公司都是：你提交一个拉取请求，发布上去，谷歌那边必须有人进行人工审查。

What the way Teams used to work, and I'm not sure if Instagram did this, but a lot of other companies did this is, you make a pull request, you put it up there, there's a mandatory human reviewer at Google.

实际上有两个审查者，一个负责代码质量，另一个也负责其他方面。

There's actually two because there's one on code quality as as well.

这种工作流程发生了什么变化？

How has this workflow changed?

热代码团队是如何看待代码审查的？它随着时间发生了怎样的变化？

How does the hot code team think about code review and how has it changed over time?

是的。

Yeah.

我先谈谈我过去是如何做代码审查的。

I'll start by thinking I'll I'll start by talking about how code review used to work for me.

我过去的做法是，每次我也会成为最积极的代码审查者之一。

So the the way that I used to do it is every time I I also used to be one of the most prolific code reviewers.

哦，原来如此。

Oh, okay.

所以两者都是。

So both.

我遇到过，是的。

I I met a yeah.

作者和代码审查者。

Writers and code reviewers.

身处不同时区的一个好处就是，我并不是超人，只是我没有会议。

That's one of the benefits of being in a different time zone, like I'm not super human, I just didn't have any meetings.

我处理代码审查的方式是，每次需要对某事提出评论时，我都会把它记录到一个电子表格中，并描述这个问题。

The way that I approach code review is every time that I would have to comment about something, I would drop it in a spreadsheet, I would describe the issue.

比如说，如果有人给函数的参数起了个糟糕的名字，我就会把这件事记到电子表格里。

So let's say someone named a parameter in a function badly, I would put that in a spreadsheet.

如果有人用了糟糕的 React 模式或其他问题，我也会记到电子表格里。

If someone did some bad React pattern or something, I would put that in a spreadsheet.

随着时间推移，我会统计电子表格中的数据，一旦某一行出现三到四次以上的情况，我就会为此编写一条 Lint 规则。

And then over time I would just tally up the spreadsheet, and any time that a particular row had more than three or four instances, I would write a Lint rule for it.

所以通过某种可靠的自动化方式来解决，这就是过去我的做法。

So just automate it with kind of solid And so that's what it used to look like.

对我来说，我始终试图通过自动化来让自己解脱，因为要做的事情实在太多了。

For me, I've always tried to automate myself away, because there's just so many things to do.

这是我们工程师的一项超能力：我们能够自动化所有繁琐的工作。

And this is one of our superpowers as engineers, is we are able to automate all of the tedious work.

很少有其他领域能让你做到这一点。

There's very few other fields where you're able to do this thing.

这是我们 uniquely 能够做到的事情。

This is a thing uniquely that we're able to do.

我一直很享受这一点，因为它给我更多自由时间，让我能做真正喜欢的工作。

And this is a thing that I've just always enjoyed, because it gives me more free time, and I get to do the work I actually enjoy.

所以今天，这种情况看起来有点不同，但仍然与此类似。

And so today, the way this looks is a little different, but it mirrors this a little bit.

当 Claude Code 编写代码时，通常会本地运行测试，而 Claude 经常在相关时自行决定这么做，或者编写新测试，因此你会进行这种验证。

So when Claude Code writes code, generally it will run tests locally, and this is something Claude just often decides to do when it's relevant, or will write new tests, so you kind of do this kind of verification.

当我们对 Claude Code 进行修改时，Claude 也会自我测试。

When we make changes to Claude Code, Claude will also test itself.

它会在一个子进程中启动自己，进行自我验证，并端到端地测试自己。

So it'll launch itself kind of in a sub process, it'll verify itself, and it'll test itself end to end.

这是针对你们内部的Claude Code实现的，所以你们有这个测试套件，让它可以自我测试。

This is for your internal Claude Code implementation, so you have this test suite so they can test itself.

是的，没错，就是这样。

Yeah, that's right, that's right.

但它会真的在bash进程中启动自己，然后看看：嘿，我还能正常工作吗？

But it'll literally launch itself just in a bash process and kind of just see like, hey, do I still work?

好的。

Okay.

所以它会这么做。

So it'll do this.

这并不是我们特意编码进去的，尤其是Opus 4.5版本，它会自发地做这种事。

This is something that we just didn't code in, like, it just with Opus 4.5 especially, it just sort of spontaneously doing this.

它就是想确认一下。

It just wants to check.

所以我们这么做，同时我们还在CI中运行Claude P，也就是Claude Agent SDK。

So we do this, and then we also run Claude P, so this is the Claude Agent SDK in CI.

因此，Anthropic 的每一个拉取请求都会由 Claude Code 进行代码审查。

So every pull request at Anthropic is code reviewed by Claude Code.

这实际上能捕捉到大约 80% 的错误，类似这样的情况。

And that actually catches maybe 80% of bugs, something like this.

这是第一轮代码审查。

And it's the first round of code review.

Claude 会自动修复其中一些问题，但有些它会留给人工处理，因为它不确定该怎么做。

Claude will automatically address some of these, some of them it will leave to a human, because it's not sure what to do.

总会有工程师进行第二轮代码审查。

There's always an engineer that does the second pass of code review.

而且，你知道，每次变更都必须有人参与审批。

And, you know, there always has to be a person in the loop approving the change.

所以，在团队中，任何代码上线前，工程师都会进行查看，对吧？

So, on the team, before anything goes into production, if you will, an engineer does look at it?

是的。

Yes.

当你在思考代码审查时，你会对所有类型的项目都这样做吗？还是因为你知道这实际上有现实影响，人们依赖它，有很多用户，所以才这么做？

As you're thinking of code review, would you do this for every type of project or this is specifically because you now know that this actually has real world impact, people depend on it, you know, there's a lot of users.

我换个说法，你能想到哪些情况下你根本不会进行工程代码审查吗？

Let me put it the other way around, like, can you see places where you would just not have an engineering review code?

在什么情况下会这样呢？

What situations would that be in?

我认为这取决于它的使用方式。

I think it depends how how how it's used.

是的。

Yeah.

我同意这一点。

I'd agree with that.

比如，如果你在做一个个人的副项目，可以直接随便提交到主分支，你知道的，比如

Like, you know, if you're building some personal side project, like, can just yolo straight to main, you know, like

甚至在AI出现之前，你也不会进行审查。

Even even before AI, you would have not reviewed.

你只是信任自己，或者直接部署到生产环境，直接SSH进生产环境做些修改，诸如此类的事情。

You just trust yourself or, you know, just ship to production or SSH into production and do some changes, that kind of stuff.

对吧？

Right?

没错。

Exactly.

没错。

Exactly.

Quad Code 最初的内部版本，我确实直接提交到主分支。

The very first versions of Quad Code that were internal, like, know, I committed straight to main.

但一旦有了用户，你知道，对于Anthropic来说，我们的主要客户群体是企业。

But then, you know, as soon as you have users and, you know, for Anthropic, our main customer base is enterprises.

这是我们最关心的。

This is what we care about the most.

对我们而言，出于安全考虑，安全性非常重要，隐私也很重要。

For us, for safety reasons, security is really important, privacy is important.

这些都密切相关。

These are these are all related.

这对我们的客户也非常重要。

It's also very important for our customers.

因此，由于这是一个企业级产品，它必须是安全的。

And so because this is an enterprise product, it has to be secure.

我们必须确保它达到一定的标准。

It has to be we have to make sure that it meets a certain bar.

所以我们确实大量使用自动化，但至少目前，仍需要有人参与其中以确保万无一失。

So we definitely use a lot of automation, but at least for now, there has to be a human in the loop just to make sure.

关于大语言模型，大家都知道它们是非确定性的。

One thing that is just known about LLMs is they're nondeterministic.

将大语言模型作为评审者，比如让Claude进行审查，它能提供很好的反馈，但你怎么应对这样一个事实：你无法确定它是否总是能给出反馈，也无法保证即使它有能力发现某个问题，也一定会发现它。

And by putting LLMs as a reviewer Claude doing a review, like, it will give good feedback, but how would you deal with the fact that you can't be sure if it's always giving the feedback, you cannot be sure that even if it's capable of catching an issue that it will necessarily catch that.

在这个流程中，你们有没有采取什么措施来确保确定性？

Are you doing anything in this loop to do deterministic things?

例如，代码检查是非常确定性的，这一点你很清楚，你有没有考虑过将这些想法与代码库中的代码检查工具结合使用，或者觉得没有必要？

Example, linting is very deterministic as you will very well know, like, have you thought of marrying some of these ideas or are using linters on the code base, or you found no need for it?

是的。

Yeah.

当然。

Absolutely.

当然。

Absolutely.

是的。

Yeah.

所以这只是一个嗯。

You So this is just a yeah.

是的。

Yeah.

我们有类型检查器，有代码检查工具，还会运行构建。

We we have type checkers, we have linters, we run the build.

Claude 在编写 Lint 规则方面实际上非常出色。

Claude is actually so good at writing Lint rules.

所以，我现在做的其实是，以前我会在电子表格里统计这些内容。

So, actually, what I do now, I used to tally stuff up in the spreadsheet.

现在，当同事提交一个拉取请求时，如果我觉得这个代码可以被 Lint 检查，我就会让 Claude 帮忙为这个 PR 写一条 Lint 规则。

Now what I do is, when a coworker puts up a pull request, and I'm like, this is Vintable, I'll just be Claude, please write a lint rule for this in that PR, on their PR.

我们有这样一个功能，你知道的，就是输入类似 /setup GitHub 这样的命令，或者类似的指令。

And we have, you know, you just run like slash, I think it's like setup GitHub or something like this.

你可以在 Quad Code 里完成这个操作，它会安装 GitHub 应用，这样你就可以在任何拉取请求或问题中提及 Claude。

You can do this in quad code and it'll install the GitHub app, which then makes it so you can tag Claude on any pull request, any issue.

我每天都用这个功能。

I use this every single day.

所以，这非常非常有用。

So, very very useful.

所以，你希望这些步骤是确定性的。

So you want these deterministic steps.

不过，也有办法让Claude变得更加确定性一些。

Also though, there are ways to get Claude to be a little bit more deterministic.

例如，你可以使用最佳事件，让它进行多次迭代。

So for example, you can do best event, you can have it do multiple passes.

这实际上很容易实现。

And this is actually quite easy to do.

比如，我们内部使用的代码审查技能是开源的，可以在Claude Code仓库中找到。

So for example, the Codereview skill that we use internally, it's open source, and it's available in the Claude Code repo.

因此，我们所做的就是启动并行的代理来执行任务，然后启动并行的推理代理来检查误报。

And so all we do is we launch parallel agents to do stuff, and then we launch parallel deducing agents to check for false positives.

但本质上，实现最佳事件的方法就是简单地说：Claude，启动三个代理来完成这个任务，就这么简单。

But essentially, best event, the way you implement it is all you say is, Claude, start three agents to do this, and that's it.

Boris刚刚谈到构建企业级基础设施层，包括身份验证、权限和安全机制，这些都必须到位后才能向真实客户交付产品。

Boris just talks about building that enterprise infrastructure layer, the auth, the permissions, the security that has to all work before you can ship to real customers.

这正是谈论我们资深赞助商WorkOS的好时机。

This makes it a great time to speak about our seasoned sponsor, WorkOS.

如果你正在构建任何 SaaS 产品，尤其是 AI 产品，那么身份验证、权限、安全性和企业身份可能会悄然变成一项长期投资。

If you are building any SaaS, especially an AI product one, then authentication, permissions, security and enterprise identity can quietly turn into long term investment.

SAML 的边缘情况、目录同步、审计日志，以及企业客户期望的所有功能。

SAML edge cases, directory sync, audit logs and all the things enterprise customers expect.

构建这些关键任务组件已经很繁重，而维护它们则更耗时。

It's a lot of work to build these mission critical parts and then some more to maintain them.

但你其实不必这么做。

But you don't have to.

WorkOS 将这些组件作为基础设施提供，让你的团队能够专注于真正让产品与众不同的部分。

WorkOS provides these building blocks as infrastructure so your team can stay focused on what actually makes your product unique.

这就是为什么 Anthropic、OpenAI 和 Cursor 等公司已经在使用 WorkOS。

That's why companies like Anthropic, OpenAI, and Cursor already run on WorkOS.

优秀的工程师知道什么不该构建。

Great engineers know what not to build.

如果身份认证正是你不想做的那部分，欢迎访问 workos.com。

If identity is one of those things for you, visit workos.com.

好了，让我们继续和博里斯一起构建Claude Code。

And with this, let's get back to building Claude Code with Boris.

Claude Code在架构上是如何工作的？

How does Claude Code work in terms of architecture?

作为工程师，我该如何想象它的结构？

So as an engineer, how can I imagine its setup?

我在深度解析中提到过一些，我想你之前告诉我，刚开始时你们有一些非常复杂的想法，但后来简化了很多。

Covered some of this in the deep dive and I think you told me that you had some pretty complex ideas when you started and you just simplified a lot of Yeah.

是的。

Yeah.

它非常简单。

It's very simple.

没什么复杂的。

There's not much to it.

核心是一个查询循环，还有一些它使用的工具，我们不断删除这些工具，也不断添加新工具，我们一直在不断尝试。

There's a core query loop, there's a few tools that it uses, we delete these tools all the time, we add new tools all the time, we're just always experimenting with it.

所以，它有一个核心代理部分，然后是两个e部分，此外还有大量围绕安全性的组件，确保Quad Co所做的每一件事都是安全的，并且在发生时有人工介入。

So there's this core agent part of it, then there's the two e part of it, and then there's actually a ton of different pieces around security and making sure that everything that Quad Co does is safe, and that there's a human in the loop for when it happens.

你所说的‘安全’，是指作为用户在它操作我的电脑时的安全，还是也包括Anthropic对可能被视为不安全的使用场景的监控？

And by safety, do you mean as a user when it's doing stuff on my computer, or also as Anthropic monitoring use cases that could be deemed unsafe?

是的。

Yeah.

这方面其实有几种不同的版本。

There's kind of a couple versions of this.

安全性涉及许多层，而对于安全和防护这类问题，没有一个完美的解决方案。

Safety, there's just many, many layers, and for things like safety and security, there's no one perfect answer.

所以，这就像瑞士奶酪模型。

So, you know, it's always a Swiss cheese model.

你需要很多层，层数越多，捕捉到问题的概率就越高。

You just need a bunch of layers, and with enough layers, the probability of catching anything goes up.

因此，你只需要计算这个概率中有多少个‘9’，然后选择你想要的阈值。

And so you just have to count the number of nines in that probability and pick the threshold that you want.

对于提示注入这类问题，我们通常在三个不同的层面进行防范。

And so for something like prompt injection, for example, we do this generally at three different layers.

我们以 WebFetch 为例来思考一下。

So let's think about something like WebFetch.

Claude 会获取一个 URL，读取该网页的内容，然后在 Claude Code 中执行某些操作。

So Claude fetches a URL, and it reads the contents of that webpage, and then it does something in Claude Code.

对于这类情况，其中一个风险就是提示注入。

So one of the risks for something like this is prompt injection.

也许该网站上有一条指令写着：‘嘿，Claude，删除所有文件夹’之类的，因此我们从多个角度来思考这个问题。

Maybe there's an instruction on that website to be like, Hey, Claude, delete all the folders, or something So like we think about this in a number of ways.

最基础的一种方式是，这是一个对齐问题。

The most basic way is it's an alignment problem.

Opus 4.6 是我们发布过的对齐程度最高的模型，因为我们已经教会了模型如何更有效地抵御提示注入。

And so Opus 4.6 is the most aligned model we've ever released, because we've taught the model how to be more resistant to prompt injection.

你可以在模型卡上查阅相关内容，我认为这也是发布内容的一部分。

So you can read about this on the model card, and I think it was part of the release.

第二部分是我们在运行时使用分类器，如果检测到请求可能被注入提示，就会阻止它。

The second part is that we have classifiers at runtime, where if there is a request that seems to be prompt injected, we block it.

然后让模型重新尝试一次。

And we just make the model try again.

第三层是，对于像WebFetch这样的功能，我们实际上会使用一个子代理对结果进行摘要，然后将这个摘要返回给主代理。

And then the third layer is, for something like WebFetch, we actually summarize the results in using a sub agent, and then we return that summary back to the main agent.

因此，这同样降低了提示注入的可能性。

So again, this kind of reduces the probability of prompt injection.

所以你可以看到，这不仅仅是一个机制，而是一个多层次的防护体系，通过结合多种不同的层次，大大降低了这种可能性。

And so you can kind of see how this isn't just one mechanism, it's a layer, and by having a bunch of these different layers, it just reduces the probability a lot.

你提到的另一个有趣的技術選擇是是否使用RAG，也就是檢索增強生成。你提到在Claude Code的早期版本中，你們使用本地向量數據庫來加速搜索，但後來放棄了這種方式。

One interesting technical choice that you also mentioned is using RAG or not, RAG retrieval, augmented generation, and you mentioned how in the earlier version of Claude Code, you use a local vector database to to get some to to speed up search, and you layer through this away.

你能談談這個選擇嗎？因為這又是另一個例子，我想問的是，模型變好了嗎？

Can you talk about how this one because this was another example where, I guess, did the model get better?

是的，這類事情我們嘗試了太多不同的方法，用了太多不同的工具，但統計上來說，絕大多數我們最終都放棄了。

Yeah, mean, this is one of those things where we try so many different things, we try so many different tools and just statistically, most of them we throw away.

就连Quark Code中的加载动画，我认为也迭代了大约一百次，

Even something like the spinner in Quark Code, I think it's gone through like a 100 iterations,

我想

I wanna

只是那个加载动画。

Just the spinner.

在这之中，我们可能只保留了十到二十个投入生产，其余大约八十个项目我直接丢弃了，因为感觉不够好。

Out of those, we've landed maybe 10 or 20 in production, and 80 of them I probably just threw away because it didn't feel good enough.

所以从统计上看，我们写的几乎所有代码最终都被丢弃了，因为写代码、尝试各种东西并看看哪种感觉更好实在太容易了。

So statistically, almost all the code we write, we throw away, because it's just so easy to write this code and try stuff and see what feels good.

所以对于RAG这类技术，我们早期尝试了很多不同的方法。

So for something like RAG, we tried a bunch of different approaches early on.

第一种是用RAG做检索，因为我当时正在阅读人们是如何做检索的，发现所有论文都在讨论RAG。

The first one was RAG for retrieval, because I was just reading up how people were doing retrieval, and it seemed like all the papers were talking about RAG.

所以我当时的做法是使用一个本地向量数据库。

And so the way I did it was, it was like a local vector database.

我认为它是用 TypeScript 写的，你只是在用户机器上查看。

I think it was written in TypeScript, and you just looked on the user machine.

然后我使用了一个云端的嵌入模型来计算存储前的嵌入向量。

And then I was using some embedding model that was in the cloud to compute the embeddings before storing it.

这效果还不错。

And that worked pretty good.

但 RAG 存在很多问题。

But there's a lot of issues with RAG.

比如，我发现代码会不同步。

So, for example, I was finding that the code drifted out of sync.

比如，如果我创建了一个本地函数，它还没被索引，所以 RAG 找不到它。

Like, if I make a local function, it's not yet indexed, and so RAG isn't going to find it.

还有一个问题是，这个索引的权限是如何设置的？

There's also this question of how exactly is the index permissioned?

那么，谁可以访问它？

So who can access it?

我可以访问它，但我们要如何在权限策略中体现这一点呢？

I can access it, but then how do we encode that in permission policies?

我们如何确保其他人无法访问它？

How do we make sure no one else can access it?

我们如何确保公司里如果有恶意的IT人员，也无法访问他人的数据？

How do we make sure that if there's a rogue IT person within the company, they can't access someone else's data?

这一点真的、真的非常重要，我们必须认真考虑。

This is really, really important that we think about this.

所以我们只是觉得它勉强能用，但也有很多缺点。

And so we just decided it was sort of working, but it also has a lot of downsides.

于是我们尝试了其他一些方法。

And so we tried a bunch of other stuff.

其中之一是直接用模型递归地索引所有内容。

One of them was just using the model to index everything recursively.

这个想法还挺不错的。

That was kind of a cool idea.

还有一个版本，我们只是尝试了glob和grep。

There was another version where we just tried glob and grep.

我们尝试了很多不同的方法。

We tried a bunch of different stuff.

结果发现，智能搜索的表现远远超过了其他所有方法。

It turned out that agentic search just outperformed everything.

当我提到智能搜索时，这只是对glob和grep的一种 fancy 表述。

And when I say agentic search, it's a fancy word for glob and grep.

说白了就是这些。

That's all it is.

不错。

Nice.

所以模型不仅变得足够强大，你也意识到它能相当高效地使用这些工具？

So so did the model both got good enough, and you realized that it can use these tools pretty efficiently?

是的。

Yeah.

这在一定程度上受到了我在Instagram工作经验的启发。

And this was partially inspired, honestly, by my experience at Instagram.

在Instagram，点击跳转到定义功能根本行不通，因为开发环境经常出问题。

At Instagram, click to definition didn't work, because the dev stack was just borked half the time.

我觉得现在情况好多了。

And I think now it's better.

因此，工程师们现在学会的做法是：比如你要找函数foo的定义，而不是用点击跳转到定义，你会使用Meta内部非常强大的全局索引，然后搜索带左括号的foo。

And so what engineers have learned to do instead is, let's say you're looking for the definition of the function foo, instead of click to definition, what you would do is you would use the global index, which is quite good at Meta, and then you would search for foo per opening parenthesis.

这种方法效果相当不错。

And this worked pretty well.

有趣的是，这个方法对模型来说也同样有效。

And it's funny because this works for the model pretty well too.

一个领域里的想法能应用到另一个领域，真是有意思。

Interesting how one idea from one area can come to the other.

我们之前也讨论过Claude Code中更高级的部分之一，就是权限系统。

One of the more advanced parts of Claude Code that we also previously talked about is the permission system.

你能谈谈它复杂在哪里吗？

Can you talk about what was complex about it?

而且，你最近开源了沙箱功能，对吧？

And also, you recently opened source sandboxing, right?

权限系统非常复杂。

Permissioning is really complex.

就像所有与安全相关的事情一样，它是一个瑞士奶酪模型。

There's, like everything else that has to do with security, it's a Swiss cheese model.

有多个分类器运行，以确保命令是安全的。

There are a number of classifiers that run to make sure the command is safe.

我们还进行静态分析，以确保命令是安全的。

And there's also static analysis that we do to make sure the command is safe.

作为用户，你还可以将你认为安全的特定模式加入白名单。

As a user, you can also allow list particular patterns that you know to be safe.

例如，一些标准的 Unix 工具我们已经预先允许使用，因为我们知道它们是只读的，不会导致数据泄露或其他类似问题。

So for example, some standard Unix utilities we pre allow, because we know they're read only, because we know they can't exfiltrate data or anything like this.

所以我们不会向你请求权限。

So we just won't prompt you for permission.

但实际上，很少有工具属于这一类，因为即使是像 find 这样的命令，也存在通过系统标志执行任意代码的方式。

But actually quite few tools fall into this category, because even something like the find command, there's actually a way to execute arbitrary code as part of that command, because there's system flags that you can use for this.

或者像 sed 命令这样的工具，也有办法利用它。

Or even something like the said command, there's ways to use this.

因此，这些各种 Unix 工具背后有着大量复杂的细节，实际上并没有你想象的那么安全。

So there's just all this arcania about these various Unix utilities, where it's actually not as safe as you think.

因此，我们默认会采取相当保守的态度，限制默认允许的范围。

And so we want to be, by default, fairly conservative about what we allow by default.

不过，作为用户，你可以配置一个允许列表。

As a user, though, you can configure an allow list.

你可以指定，例如，这些模式被允许，这些模式不被允许。

So you can say, for example, these patterns are allowed, these patterns are not allowed.

因此，你可以自行定义这些规则，我们也会检查这个允许列表以确保其安全性。

And so we let you define that and we also check this allow list to make sure that it's safe.

是的

Yeah.

然后你有一个很不错的权限系统，每次运行需要权限的命令时，你可以选择仅运行一次、在当前会话中运行，或根据情况决定永久允许。

And then you have this neat permission system where every time you run a command that needs permission, can decide to run it once, run it for either the session or whatever it makes sense, or just globally allow it going forward.

对吧？

Right?

没错。

That's right.

这是一个有趣的遗留设计。

This is a funny artifact.

这实际上出现在quad code的最初版本中。

This was actually in the very, very first version of quad code.

权限就是这样工作的。

This is the way permissions worked.

这是第一个发布版本。

This is the very first release.

这大概是2024年9月的首次内部发布。

This was, like, September 2024, the first internal release.

我当时记得，我们并不确定代理安全问题是否真的能解决。

I remember at the time we weren't sure whether agentic safety could even be solved.

因此，安全团队内部其实有很多反对声音，他们认为：你不能让模型随意运行bash命令，这太不安全了。

And so there was actually a lot of pushback internally from safety teams, because they were like, Okay, you can't just let the model run bash commands, that's unsafe.

那你们该怎么办？

So what do you do?

这根本是个无解的问题，所以我们不能发布这个功能。

This is not a solvable problem, so we can't launch this.

我和本·曼一起头脑风暴，本后来创立了实验室团队，他是Anthropic的创始人之一。

I brainstormed with Ben Mann, and Ben started the labs team, he's one of the founders at Anthropic.

实际上，正是他把我招进Anthropic的。

He's actually the person that hired me to Anthropic.

我们最终想出了权限提示这种解决方案。

We just come up with permission prompts as the way to do this.

如果你不确定，就让人类来决定，直接问人类就好。

You put the human if you're not sure, just ask the human, and they can decide.

是的。

Yeah.

我想问问你，关于Anthropic公司整体是如何进行软件工程的。

I wanted to ask you about how software engineering is done in general in terms of Anthropic.

第一个问题，可能比较正式，或者从外部来看，是关于职位头衔，或者更准确地说，是没有头衔。

And one of the first questions, which is a, I guess, a more formal one, but or from the outside, is titles or lack of them.

Anthropic的每个人职位头衔都一样：技术成员。

Everyone at Anthropic has the same title, member of technical staff.

为什么会这样？这样又带来了什么影响？

Why did this happen and what does this result in?

这基本上意味着所有人都没有头衔，对吧？除了一个例外。

This kind of like everyone basically no titles, right, except for one.

我认为这实际上是在承认，每个人都在摸索前进。

I think it's kind of an acknowledgement that everyone just is figuring stuff out.

如果你稍微眯着眼看人们在做什么，会发现他们的工作都非常相似，而且相当通用。

And if you kind of squint and look at the work people are doing, it's all quite similar and it's kind of quite generalist.

如果你和普通的软件工程师聊聊，他们可能不只是在写代码，还可能做一些设计工作。

If you talk to the average software engineer, they might not just be doing coding, they might also be doing a little design.

他们也可能在和用户交流。

They might also be talking to users.

他们可能在撰写自己的产品需求。

They might be writing their own product requirements.

他们可能在写软件的同时也在做研究。

They might be writing software and also doing research.

他们可能在写产品代码的同时也在写基础设施代码。

They might be writing product code and also infrastructure code.

在Anthropic，有很多通才。

At Anthropic, there's lot of generalists.

这也很符合我的背景，这也是我被吸引到这里的原因之一。

This is also from my background, this is one of the reasons that I gravitated towards it.

我认为，技术员工这个头衔本身就体现在人们相互交流的方式中，即使他们彼此并不认识。

And I think member of technical staff just kind of encodes this in the way that people talk to each other even if they don't know each other.

如果没有这个头衔，默认情况会是我在Slack上看到你的名字，下面写着‘软件工程师’。

Without this title, the default would have been I see your name on Slack, and under your name it says software engineer.

然后我会想，好吧，既然你是负责编码的，那我就不该去问你产品方面的问题。

And then I'm like, well, okay, I guess you're the coding person, and so I'm not going to ask you product questions.

但当每个人的头衔都是技术员工时，大家默认都会认为每个人都能做所有事情。

But when everyone's title is member of technical staff, by default you assume everyone does everything.

因此，这颠覆了人与人之间的这种关系，即使你们彼此还不太熟悉。

And so it of inverts this relationship between people, even if you don't know each other well yet.

某种程度上，这是一种嵌入在结构中的乐观态度。

In a way it's kind of this optimism built into the structure.

我认为这也是对未来的预示，因为我觉得这就是软件工程的发展方向。

I think it's also a glimpse of the future, because I think this is where software engineering is going.

我认为这也是每个领域的发展趋势——走向这种通才模式。

I think this is where every discipline is going, is more of this generalist model.

在软件工程中，这种感觉确实很明显。

It definitely feels like it in in software engineering.

我听过马克·安德森一个有趣的评论，他说科技界正发生一场墨西哥式对峙，设计师们声称他们现在实际上在做产品经理和工程的工作。

And I've heard this funny comment by Marc Andreessen, how he said that there's this Mexican standoff happening in the tech world where the the designers are are saying that they're actually now doing, like, PM and engineering work.

工程师们则说我们在做设计，而且每个人都觉得自己在做别人的工作，大家就这样站着，心想：我也在做你的工作。

The engineers are saying that we're doing design and and, like, everyone thinks they're doing the work of the others and they're kinda standing there like, I'm doing your work as well.

但现实是，每个人的职责都在扩展，这很大程度上要归功于人工智能，因为它让工程师更容易做产品工作，也让产品人员更容易做工程工作，等等。

When the reality is everyone's role is expanding, most of it thanks to AI because it makes easier for an engineer to do product work or for a product person to engineer work and so on.

所以，这正是你所说的。

So it's what what you've said.

我记得今年六月或七月，我走进办公室时，那里有一排数据科学家坐在Claude Code团队旁边。

I I remember back in the back in June or July, I I walked into the office, and the data there's a row of data scientists that sit right next to the Claude Code team, at at the time.

我走进去时，发现Quad Co团队的数据科学家的屏幕上正显示着Quad Co。

And I walked in, and our data scientist for the Quad Co team had Quad Co up on his monitor.

他正在使用它，我当时就想，这很有趣，因为你是个数据科学家。

And he was using it, I was like, this is interesting, because you're a data scientist.

你为什么在用终端？

Why are you using a terminal?

你没有安装Node。

You didn't have Node.

因为我们当时依赖Node。

Js installed, cause we depended on Node.

Js。

Js back then.

我当时就想，你们是在内部试用它吗？

I was like, are dogfooding it?

你只是想搞清楚这东西怎么用还是什么？

Are you just trying to figure out how this thing works or something?

他说，不，不是的。

He was like, no, no.

我在用它来运行查询。

I'm using it to run queries.

他只是用它来运行SQL，终端里还有简单的ASCII可视化界面。

He was just using it to run SQL, it had little ASCII visualizations in the terminal.

到了下一周，整个数据科学家团队的电脑上都运行起了Quad Code。

And then the next week, the entire row of data scientists had quad code running on their computers.

然后这个范围扩大了。

And this expanded.

所以如果你看看今天的团队，Quad Code团队里的每个人都写代码。

And so if you look at the team today, on the quad code team, everyone codes.

工程师写代码，我们的工程经理写代码，设计师写代码，数据科学家写代码，我们的财务人员也写代码。

The engineers code, our engineering manager codes, designers code, data scientists code, our finance guy codes.

团队里的每个人都写代码。

Everyone on the team codes.

我认为其中一部分原因是Claude Code让这一切变得如此简单，你根本不需要完全理解代码库，就能直接上手并轻松做出小改动。

And I think part of it is Claude Code just makes it so easy, so you don't really have to understand the code base, you can just dive in and make small changes quite easily.

但我认为另一点是，人们能够用Claude Code更高效地完成自己的工作，无论是财务预测、数据分析，还是其他任何事情。

But I think another thing is, people are able to use Claude Code to do their jobs more, whether it's, you know, financial forecasts or, you know, data science or whatever.

通过这样做，实际上很容易过渡到用它来写一点代码。

And by doing this, it's actually quite an easy crossover to just use it to write a little bit of code also.

所以这就像先轻轻试探一下水温。

So it's it's just a way to dip your toe in the water.

关于你们的工作方式，还有另一件有趣的事：Kat Wu提到，虽然她的头衔和大家一样，但人们可能会更倾向于某种角色。我知道她更偏向产品方向，但她表示，Anthropic内部几乎不写PRD（产品需求文档）。PRD是大科技公司乃至越来越多大型初创公司中广为人知的文档，通常你会写下自己的想法，让团队达成共识，然后发送出去，这样大家就知道该做什么了。

One other interesting thing about how you work is Kat Wu was talking about she is, I guess, you you the title is the same but people might gravitate for a role a bit more, I understand she's a little bit more on a product role, but she said that PRDs are just not really written inside Anthropic and PRDs, product requirement document, it's a well known artifact across big tech and increasingly over larger startups where you write a spec and the idea is that you write down your thoughts, people align, you send it over, and now you know what to build.

但显然你们这里并不怎么这么做，甚至完全不做。

But apparently you're not doing much of this or at all.

我觉得部分原因是Anthropic仍是一家初创公司，所以通常不需要和太多人达成一致。

Some of this, I think, is because Anthropic is still a start up, so you don't actually have to align with that many people, usually.

你只需要口头聊聊，或者在Slack里讨论一下就行。

You can just talk about it or do it in Slack or whatever.

但另一方面，Kat以前确实是个工程经理。

But, yeah, also part of it is, you know, Kat used to be an engineering manager.

非常懂技术。

Extremely technical.

我认为这也是我们的产品团队看待问题的方式，与其写文档，不如直接发个PR。

And I think this is the way that, you know, our product team thinks about it too, you know, better to send a PR.

你们更多是在做原型开发。

You're you're doing a lot of prototyping instead.

所以，就像我们之前聊到你们早期开发Claude Code时，你展示过一个完整的讨论串，关于你们做了大约15到20个待办事项的原型，全部都是可交互的。这让我很惊讶，因为按我过去的经历，这得花上一两周，而且人们根本不会做20个，顶多做三个。但你们居然一天半就搞定了所有20个，试了一遍，有了感觉。

So, like, that's also something where when we talked about how you were building Claude Code early on, you were showing, actually, you had a whole thread about the number, I think you did like 15 or 20 prototypes for the the to do list and all of them interactive working, and what surprised me compared to my past experience, and you said that, well, you did this in, like, a day and a half, all all 20, tried it out, got a feeling for it, which incomprehensible for me, it would have taken a week or two weeks and people would have not done 20, they would have done three.

是的。

Yeah.

所以，你有没有发现，现在大家更倾向于做原型、构建和展示，而不是写文档？

So, like, are you seeing this is there an increase in prototyping and building and showing instead of writing things?

是的，绝对如此。

Yeah, absolutely.

在我的团队里，文化就是我们不怎么写东西，我们直接展示。

I mean, on our team the culture is we don't really write stuff, we we show.

要回溯到以前还挺难的，因为现在我们构建东西的方式已经完全融入了原型驱动的思维。

It's a little hard to reflect back on the time before, because I think now just prototyping everything is so baked into the way that we build.