深入克劳德代码：与创始人鲍里斯·切尔尼的对话

有一类是极端的专业人士。

There's one side where it's extreme specialists.

就像我之前提到的贾里德，他就是一个很好的例子，整个团队也是如此。

And so like I named Jared before, like he's a really good example of this and kind of the team is a really good example.

他们是超级专家，对开发工具的理解比任何人都深。

Just hyper specialists, they understand dev tools better than anyone else.

他们对JavaScript运行时系统的理解也比任何人都透彻。

They understand JavaScript runtime systems better than anyone else.

而另一面则是超级通才，也就是团队的其他成员。

And then there's the flip side of kind of hyper generalists, and that's kind of the rest of the team.

很多人横跨产品和基础设施，或产品和设计，或产品和用户研究，产品和业务。

And a lot of people, they span like product and infra, or product and design, or product and user research, product and business.

我特别喜欢看到那些做些奇怪事情的人。

I really like to see people that just do weird stuff.

我觉得这在过去曾是一个警示信号，因为人们会想：这些人真的能做出有用的东西吗？

I think that's one of these things that was kind of a warning sign in the past, it's because like, can these people actually build something useful?

这就是极限测试。

That's the limits test.

是的，这就是极限测试。

Yeah, that's the limits test.

但如今，比如我们团队的一位工程师Daisy，她之前在另一个团队，后来转到了我们团队。

But nowadays, like for example, an engineer on the team, Daisy, she was on a different team and then she transferred onto our team.

我之所以希望她转过来，是因为她加入后不久就提交了一个关于QuadCode的PR。

And the reason that I wanted her to transfer is she put up a PR for QuadCode like a couple of weeks after she joined or something.

这个PR是为了给QuadCode添加一个新功能。

And the PR was to add a new feature to QuadCode.

但她并没有直接添加功能，而是先提交了一个PR，为QuadCode开发了一个工具，用于测试任意工具并验证其是否正常工作，然后才提交了那个功能PR。

And then instead of adding the feature, what she did is first she put up a PR to give QuadCode a tool so that it can test an arbitrary tool and verify that that works, and then she put up that PR.

接着，她让QuadCode自己编写这个工具，而不是亲自去实现它。

And then she had Quad write its own tool instead of herself implementing it.

我认为这种跳出框架的思维方式非常有趣，因为目前还没有多少人能理解这一点。

I think it's this kind of out of the box thinking that is just so interesting because not a lot of people get it yet.

你知道吗，我们使用Quad Agent SDK来自动化开发的几乎所有环节。

You know, like we use the Quad Agent SDK to automate pretty much every part of development.

它自动化代码审查和安全审查。

It automates code review, security review.

它为我们的所有问题打上标签。

It labels all of our issues.

它推动项目上线生产环境。

It shepherds things to production.

它几乎为我们做了所有事情。

It does pretty much everything for us.

但我认为，从外部来看，正有越来越多的人开始理解这一点。

But I think externally, I'm seeing a lot of people start to figure this out.

但实际上，要弄清楚如何以这种方式使用大语言模型花了挺长时间。

But it's actually taken a while to figure out how do you use LMs in this way?

如何使用这种新型的自动化？

How do you use this new kind of automation?

所以这算是一种新技能。

So it's kind of a new skill.

我想，我在和一些创始人进行办公时间交流时，遇到的一个有趣现象是：你有一个富有远见的创始人，他脑子里有一个想法。

I guess one of the funnier things that I've been having office hours with various founders about is you have, like, sort of the visionary founder who has, like, the idea.

他构建了自己想要打造的产品的水晶宫殿。

They've, like, built this, like, crystal palace of the product that they wanna build.

他完全把用户是谁、用户感受如何、用户动机是什么，都记在了脑子里。

They've totally loaded in their brain, you know, who the user is and what they feel and what they're motivated by.

然后他们坐在Claude代码前，能实现50倍的工作效率。

And then they're sitting in Claude code, they can do, like, you know, 50 x work.

但他们手下的工程师却没有那种关于产品理想形态的‘水晶记忆宫殿’，只能发挥5倍的效率。

And then but they have engineers who work for them who, like, don't have the, you know, crystal memory palace of, like, the platonic ideal of the product that the founder has, and they can only do, like, five x work.

你有没有听过类似的故事？

Are you hearing stories like that?

通常总会有一个人，是这个东西的核心设计师，他们只是想把自己的想法从脑子里彻底倾泻出来。

There's usually a person who's, like, the core, like, designer of a thing, and they're just, like, you know, trying to blast it out of their brain.

像这样的团队本质上是什么样的？

What's the nature of, like, teams like that?

你知道，这看起来几乎是一种稳定的配置。

You know, it it seems like that's almost a stable configuration.

你会有一个愿景者，现在彻底释放了。

Like, you're gonna have the visionary who, like, now is unleashed.

但回到最初，我现在正亲身体验着这一点。

But, you know, going back to the top of it, like, I'm experiencing this right now.

就像，哦，我只是一个单独的人，我需要吃饭睡觉，而且我还有整整一份工作。

It's like, oh, well, I'm only a solo person, and, you know, I need to eat and sleep, and I have, you know, a whole job.

那我该怎么做到这一点呢？

And it's like, how am I gonna do this?

你知道吧？

You know?

你知道，我们刚推出了QuadTeams，这是一种做法，但你也可以自己构建属于你的方式。

You know, like, we just launched QuadTeams, and, you know, this is a way to do it, but you can also just build your own way to do it.

这很容易。

It's pretty easy.

QuadTeams的愿景是什么？

What's the vision for QuadTeams?

就是协作。

Just collaboration.

这就像出现了一个全新的领域，人们正在探索代理道歉的方式。

It's like there's this whole new field of agent apologies that people are exploring.

比如，他们可以如何配置代理？

Like what are the ways they can configure agents?

有一个子想法是无关的上下文窗口。

There's this one sub idea which is uncorrelated context windows.

其理念就是多个代理。

And the idea is just multiple agents.

它们拥有全新的上下文窗口，不会被彼此的上下文或自身之前的上下文所污染。

They have fresh context windows that aren't essentially polluted with each other's context or their own previous context.

如果你向一个问题投入更多上下文，这就相当于一种测试时的计算。

And if you throw more context at a problem, that's like a form of test time compute.

因此，你就能以这种方式获得更强的能力。

And so you just get more capability that way.

如果在此基础上拥有正确的拓扑结构，使代理能够以正确的方式通信、合理地布局，它们就能构建出更庞大的系统。

And then if you have the right topology on top of it so the agents can communicate in the right way, they're laid out in the right way, then they can just build bigger stuff.

所以，Teams 是其中一个想法。

And so Teams is kind of like one idea.

还有一两个想法很快就会推出。

There's a few more that are coming pretty soon.

这个想法只是也许它能多构建一点东西。

And the idea is just maybe it can build a little bit more.

我认为第一个真正成功的大型例子是我们插件功能，它完全是由一个代理群在周末内构建完成的。

I think the first kind of big example where it worked is our plug ins feature was entirely built by a swarm over over a weekend.

它只是运行了几天左右。

It just ran for, like, a few days.

实际上并没有人为干预。

There wasn't really human intervention.

插件的形态基本和它刚发布时一模一样。

And plug ins is pretty much in the form that it was when when it came out.

你们是怎么设置的？

How did you set that up?

比如，你们是否先明确了期望的结果，然后让它自己去推敲细节，再让它运行？

Like, did you spec out sort of the outcome that you were hoping for, and then let it sort of figure out the details, and then, like, let it run?

是的。

Yeah.

团队里一位工程师给Quad提供了一份规范，并让他使用Asana看板。

An engineer on the team just gave gave Quad a spec, and told Quad to use Asana board.

然后Quad就在Asana上创建了一堆任务单，启动了多个代理，这些代理开始接手任务。

And then Quad just put up a bunch of tickets on Asana, then spawned a bunch of agents, and the agents started picking up tasks.

接着Quad给了它们一些指导，它们自己就全都搞定了。

And then Quad just gave it instructions, they all just figured it out.

那些没有整体规格背景的独立代理，对吧？

The independent agents that didn't have the context of the bigger spec, right?

对。

Right.

如果你想想现在代理是如何实际启动的？

If you think about the way that how are agents actually started nowadays?

我还没查过这方面的数据，但我敢打赌，如今大多数代理实际上是由Claude以子代理的形式触发的。

I haven't pulled the data on this, but I would bet the majority of agents are actually prompted by Claude today in the form of sub agents.

因为子代理其实就是一种递归的Claude代码。

Because a sub agent is just like a recursive Claude code.

代码里就是这么回事。

That's all it is in the code.

它只是被我们称作‘妈妈’的Claude所触发。

And it's just prompted by we call her mom a Claude.

就是这样。

That's all it is.

我认为，如果你观察大多数代理，它们都是以这种方式启动的。

And I think probably if you look at most agents, they're launched in this way.

我的Claude洞察建议我多用这种方式进行调试。

My Claude Insights just told me to do this more for debugging.

因为我花了很多时间在调试上，而让多个子代理并行启动来调试问题会更好。

So that I get I spent a lot of time on debugging, and it would just be better to have multiple sub agents spin up and debug something in parallel.

于是我把它加到了我的Claude MD里，就是说：嘿，下次你尝试修复bug时，让一个代理专注于日志，另一个代理专注于代码路径。

And so then I just added that to my Claude MD to just be like, hey, next time you try and fix a bug, have one agent that lives in the log, one that lives in the code path.

这看起来似乎是不可避免的。

That just seems sort of inevitable.

对于奇怪而棘手的bug，我会尝试在计划模式下修复，然后它似乎会使用代理来搜索一切。

For weird scary bugs, I try to fix bugs in plan mode, and then it seems to use the agents to sort of Yep.

搜索所有内容。

Search everything.

而当你只是逐行处理时，就会想：好吧，我就只做这一个任务，而不是广泛搜索。

Whereas like when you're just trying to do it in line, it's like, okay, I'm gonna do like this one task instead of search wide.

我也会经常这么做。

This is something I do all the time too.

只要任务看起来有点难，比如这种研究型任务，我就会根据任务的难度来调整让我使用的子代理数量。

Just say, if the task seems kind of hard, this kind of research task, I'll calibrate the number of sub agents I ask it to use based on the difficulty of the task.

所以如果任务特别难，我会说，使用三个，或者五个，甚至十个子代理。

So if it's really hard, I'll say, use three or maybe five or even 10 sub agents.

并行开展研究，然后看看它们能得出什么结果。

Research in parallel, and then see what they come up with.

我很好奇，那你为什么不在你的ClaudeMD文件里加上这个呢？

I'm curious, so then why don't you put that in your ClaudMD file?

这得视具体情况而定。

It's kind of case by case.

QuadMD，那是什么？

QuadMD, what is it?

这是一个快捷方式。

It's a shortcut.

如果你发现自己反复做同一件事，就把它们放进QuadMD里。

If you find yourself repeating the same thing over and over, you put in the QuadMD.

但除此之外，你没必要把所有东西都放进去。

But otherwise, you don't have to put everything there.

你只需直接提示quad即可。

You can just prompt quad.

你心里是不是也在想，也许六个月后，你就不再需要明确地这样提示了？

Are you also in the back of your mind thinking that maybe, like, in six months, you won't need to prompt that explicitly?

比如，模型本身已经足够智能，能自己判断了？

Like, the model would just be good enough to figure out on its own?

可能一个月就够了。

Maybe in a month.

一个月内就不用计划模式了？

No money for plan mode in a month?

天哪。

Oh my god.

我认为计划模式的生命周期可能是有限的。

I think plan mode probably has a limited lifespan.

有意思。

Interesting.

那就是

That's

给在座的每个人一些前沿进展。

some alpha for everyone here.

如果没有计划模式，世界会是什么样子？

What would the world look like without plan mode?

你只是在提示层面描述它，然后它就能一次性完成吗？

Do you just describe it at the prompt level and it would just do it, one shot it?

是的。

Yeah.

我们已经开始在这方面进行实验，因为Quad代码现在可以自行进入计划模式了。

We've started experimenting with this because quad code can now enter plan mode by itself.

我不知道你们有没有看过这个。

I don't know if you guys have seen that.

看过这个，是的。

Seen that, yeah.

所以我们正在努力让这个体验变得非常好。

So we're trying to kind of get this experience really good.

因此，它会在人类本想进入计划模式的同一时刻自动进入计划模式。

So it would enter plan mode at the same point where a human would have wanted to enter it.

所以我觉得大概是这样的。

So I think it's something like this.

但实际上，计划模式并没有什么神秘之处。

But actually, plan mode, there's no there's no big secret to it.

它只是在提示中添加了一句话，比如：请不要写代码。

All it does is it adds one sentence to the prompt that's like, please don't code.

就这么简单。

That's all it is.

你其实可以直接这么说。

You can you can actually just say that.

对。

Yeah.

所以听起来，Cloud Code 的许多功能开发都非常像我们在 YC 谈论的内容。

So it sounds like a lot of the feature development for Cloud Code is very much what we talk about at YC.

与用户交流，然后去实现它。

Talk to your users, and then you come and implement it.

并不是先有一个完整的计划，再逐一实现所有功能。

It wasn't the other way that you had this master plan and then implemented all the features.

是的。

Yeah.

对。

Yeah.

我的意思是，事情就是这么简单。

I mean, that that's all it was.

比如，计划模式是我们看到一些用户说，嘿，Quad。

Like, plan mode was we saw users that that were like, hey, Quad.

想出一个点子。

Come up with an idea.

把这个计划梳理清楚，但先别写任何代码。

Plan this out, but don't write any code yet.

这中间有过各种不同的版本。

And there was kind of various versions of this.

有时候只是简单地讨论一个想法。

Sometimes it was just talking through an idea.

有时候则是他们让Claude去写非常详细的规格文档。

Sometimes it was these very sophisticated specs that that they were asking Claude to write.

但共同点是，在还没写代码之前先做点别的。

But the common dimension was do a thing without coding yet.

所以， literally，这事儿就发生在周日晚上10点。

And so literally, like this was, like, Sunday night at 10PM.

我当时只是在查看 GitHub 的问题，看看人们在讨论什么，同时浏览我们内部的 Slack 反馈频道。

Was I was just, like, looking at GitHub issues and kinda seeing what people were talking about and looking at our internal Slack feedback channel.

我花了大约三十分钟写出了这个东西，然后当晚就发布了。

And I just wrote this thing in, like, thirty minutes and then shipped it that night.

它在周一早上上线了。

It went out Monday morning.

这就是计划模式。

It was plan mode.

所以你的意思是，计划模式在某种意义上不再需要了，比如我担心模型会做错事或跑偏方向，但仍然需要这种模式。

So do you mean that there'll be no need for plan mode in the sense of I'm worried that the model's gonna do it's gonna do like the wrong thing or head off in the wrong direction, but there will still be a need for that.

你需要仔细思考这个想法，弄清楚你到底想要什么，而这些必须在某个地方完成。

You need to think through the idea and figure out exactly what it is that you want, and you have to do that somewhere.

我倾向于从提升模型能力的角度来思考这个问题。

I kind of think about it in terms of increasing model capabilities.

所以六个月前，一个计划是不够的。

So maybe six months ago, a plan was insufficient.

所以你让Claude制定计划，即使使用计划模式，你也得坐在那儿盯着，因为它可能会跑偏。现在我大部分会话（大概80%）都会说，计划模式的使用寿命是有限的，但我还是个重度计划模式使用者。

So you get Claude to make a plan, let's say even with plan mode, you still have to kind of sit there and babysit, because it can go off Nowadays, I do is probably 80% of my sessions I say plan mode has a limited lifespan, but I'm a heavy plan mode user.

我大概80%的会话都从计划模式开始，Claude会先开始制定计划，然后我就切换到第二个终端标签页，再让它生成另一个计划。

Probably 80% of my sessions, I start in plan mode, and Claude will it'll start, he'll start making a plan, I'll move on to my second terminal tab, and then I'll have it make another plan.

等我用完所有标签页后，我就打开桌面应用，切换到代码标签页，然后在那里开一堆新标签页。

And then when I run out of tabs, I open the desktop app, and then I go to the code tab, and then I just start a bunch of tabs there.

它们几乎都是从计划模式开始的，大概80%的时间都是这样。

And they all start in plan mode, probably, you know, like 80% of the time.

一旦计划好了，有时需要来回调整几次，我就直接让Claude去执行。

Once the plan is good, and sometimes it takes a little back and forth, they just get Claude to execute.

现在我用Opus 4.5发现，我觉得是从4.6开始，它变得非常好用了。

Nowadays what I find with Opus 4.5, I think it started with 4.6, it got really good.

一旦计划完善了，它就能一直保持在正确的轨道上，几乎每次都能准确无误地完成任务。

Once the plan is good, it just stays on track, and it'll just do the thing exactly right almost every time.

所以以前，你不仅要在计划前盯着，计划后也得盯着。

And so, you know, before you had to babysit after the plan and before the plan.

现在只需要在制定计划之前了。

Now it's just before the plan.

所以也许下一步是你根本不需要监督，只需给出一个提示，Claude 就能自己搞定。

So maybe the next thing is you just won't have to babysit, you can just kind of give a prompt and Claude will figure it out.

下一步是 Claude 直接与你的用户沟通。

The next step is Claude just speaks to your users directly.

是的。

Yeah.

它完全绕过了你。

It just bypasses you entirely.

有趣的是，这实际上是我们目前的情况。

It's funny, this is actually the current stuff for us.

我们的四人小组实际上会彼此交流。

Our quads actually, they talk to each other.

它们经常通过 Slack 与我们的用户交流，至少在内部是这样。

They talk to our users on Slack, at least internally pretty often.

我的那个四足机器人偶尔会发一条推文。

My quad will, like, tweet once in a while.

不可能吧。

No way.

但我其实经常会删掉它发的内容。

But I actually, like, delete it.

感觉有点儿俗气。

It's just like it's a little, like, cheesy.

我不太喜欢那种语气。

Like, I don't love the tone.

它想发些什么内容呢？

What does it want to tweet about?

有时候它会回复某个人。

Sometimes it'll just respond to someone.

因为我总是在后台运行着协作者，真正喜欢做这个的是协作者四足机器人，因为它喜欢使用浏览器。

Because I always have like co work running in the background, and it's like, it's the co work quad that really loves to do that because it likes using a browser.

这很有趣。

That's funny.

一个非常常见的模式是，我让四足机器人构建某个东西，它会查看代码库，发现某个工程师在 Git 平台上修改了某些内容，然后就在 Slack 上给那位工程师发消息，提出一个澄清性问题。

A really common pattern is I ask quad to build something, it'll look in the code base, it'll see some engineer touch something in the Git plane, Then it'll message that engineer on Slack, just asking a clarifying question.

一旦它得到回复，就会继续下去。

Once it gets an answer back, it'll keep going.

对于现在的创业者来说，有哪些关于面向未来进行建设的建议？

What are some tips for founders now on how to build for the future?

听起来一切都正在发生巨大变化。

It sounds like everything is really changing.

有哪些原则会持续存在，又有哪些会改变？

What are some principles that will stay on and what will change?

我认为其中一些原则相当基础，但如今它们比以往任何时候都更重要。

I think some of these are pretty basic, but I think they're even more important now than they were before.

一个例子是潜在需求。

One example is latent demand.

我对自己说过无数次了。

I mentioned it a thousand times for me.

这是产品领域最重要的一个理念。

It's just the single biggest idea in product.

这是一个没人真正理解的东西。

It's a thing that no one understands.

在我最初的几次创业中，我当然也不理解。

It's a thing I certainly did not understand my first few startups.

它的意思是，人们只会去做他们原本就在做的事情。

And the idea is like people will only do a thing that they already do.

你无法让别人去做一件全新的事情。

You can't get people to do a new thing.

如果人们正在尝试做某件事，而你让它变得更简单，那就是一个好点子。

If people are trying to do a thing and you make it easier, that's a good idea.

但如果人们正在做某件事，而你试图让他们去做另一件事，他们是不会这么做的。

If But people are doing a thing and you try to make them do a different thing, they're not gonna do that.

所以你只需要让它们正在做的事情变得更简单。

And so you just have to make the thing that they're trying to do easier.

我认为Quad会越来越擅长帮你发现这类产品创意，因为它可以分析反馈、查看调试日志，从而慢慢弄清楚这些事情。

And I think Quad is gonna get increasingly good at kind of figuring out these kind of product ideas for you, just because it can look at feedback, it can look at debug logs, it can kinda figure this out.

这就是你所说的计划模式代表潜在需求的意思吧？人们其实已经打开浏览器里的聊天窗口，正在跟它对话，来弄清楚需求和该做什么。

That's what you mean by a plan mode was latent demand, that people were already like kinda had their clawed chat window open in the browser and were like talking to it to figure out like the spec and and what it should do.

现在Plan模式直接变成了这样，你只需要在Claude Code里做就行了。

And now that Plano just became that, you just do it in Claude code.

是的，没错。

Yeah, yeah.

有时候我会在办公室里走一走，站在人们身后。

Sometimes what I'll do is I'll just walk around the office on our floor and I'll just kind of stand behind people.

我会说：嗨，这样其实不太好。

I'll say like, hi, so it's not great.

然后我就观察他们是如何使用Claude Code的。

And then I'll just see kind of like how they're using Claude code.

这其实也是我经常看到的情况。

And this is also just something I saw a lot.

但GitHub上的问题里也提到了这一点，人们一直在讨论这个。

But it also came up in GitHub issues, like people were talking about it.

你似乎对终端已经发展到如此地步感到惊讶，它被推到了这么远。

It seems like you're surprised how far the terminal has gone and how far it's been pushed.

你觉得它还有多大的发展空间？

Like, how far do you think it has left to go?

考虑到这个多智能体协同的世界，你认为上面还需要一种不同的用户界面吗？

Just given with this world of swarm multiple agents, do you think there's going to be a need for a different UI on top of it?

这挺有意思的。

It's funny.

如果你一年前问我这个问题，我会说终端最多再撑三个月，之后我们就该转向别的东西了。

If you asked me this a year ago, would have said the terminal has like a three month lifespan and then we're going to move on to the next thing.

你能看到我们正在做这方面的尝试，对吧？

And you can see us experimenting this, right?

因为 Quad Code 最初是在终端里诞生的，但现在它已经迁移到了网页上。

Because quad code started in a terminal, but now it's in, you know, it's on web.

你可以访问 quad AI slash code。

You can like quad AI slash code.

它也在桌面应用里。

It's in the desktop app.

你知道的，我们已经在代码标签页里提供这个功能大约三个月、六个月了。

You know, we've had that for, you know, like three months or six months or something, just in the code tab.

它也出现在 iOS 和 Android 应用中，就在代码标签页里。

It's in the iOS and Android apps, just like in the code tab.

它也在 Slack 里。

It's in Slack.

它也在 GitHub 里。

It's in GitHub.

还有 Versus Code 的扩展插件。

There's Versus Code extensions.

还有 JetBrains 的扩展。

There's JetBrains extensions.

所以我们一直在尝试各种不同的形式，来看看下一个会是什么。

So we're just like, we're always experimenting with different form factors for this thing to figure out what's the next thing.

到目前为止，我对 CLI 的生命周期判断都错了，所以我可能不是预测这个的最佳人选。

I've been wrong so far about the lifespan of the CLI, so I'm probably not the person to forecast this.

那对于开发者工具的创始人，你有什么建议吗？

What about, like, your advice to DevTool founders?

比如，现在有人正在建立一个开发者工具公司。

Like, someone's building a DevTool company today.

他们应该只是为工程师和人类构建，还是应该更多地考虑 Claude 会怎么想、想要什么，从而为智能体构建？

Should they just, like, be building for engineers and humans, or should they be thinking more about what Claude's gonna think and want and build for the agent?

我会这样看待这个问题：思考模型想要做什么，然后想办法让它更容易实现。

The way I would frame it is think about the thing that the model wants to do and figure out how do you make that easier.

这一点我们在刚开始开发 Quad Code 时就意识到了，发现这个工具就是想要使用各种工具。

And that's something that we saw, you know, like when I first started hacking on quad code, realized like this thing just wants to use tools.

它只是想与世界互动。

It just wants to interact with the world.

你该如何实现这一点？

And how do you enable that?

你不能做的就是把它关在盒子里。

Well, the way you don't do it is you put it in a box.

然后你告诉它：这是API，这是你与我交互的方式，这是你与世界交互的方式。

And you're like, here's the API, here's how you interact with me, and here's how you interact with the world.

正确的方法是观察它想使用哪些工具，了解它想做什么，然后像为你的用户那样去支持它。

The way you do it is you see what tools it wants to use, you see what it's trying to do, and you enable that the same way that you do for your users.

所以，如果你正在创办一个开发者工具初创公司，你应该思考：你希望为用户解决什么问题？

And so if you're building a DevTool startup, would think about what is the problem you want to solve for the user?

当你用模型来解决这个问题时，模型想做什么？

And then when you use when you apply the model to solving this problem, what is the thing the model wants to do?

那么，什么样的技术和产品方案能同时满足这两者的潜在需求？

And then what is the technical and product solution that serves the latent demand of both?

YC的下一期项目现在开始接受申请。

YC's next batch is now taking applications.

你有创业想法吗？

Got a startup in you?

请前往 ycombinator.com/apply 申请。

Apply at ycombinator.com/apply.

永远不嫌太早，填写申请表能提升你的想法。

It's never too early, and filling out the app will level up your idea.

好的。

Okay.

回到视频。

Back to the video.

多年前，十多年前，你曾是 TypeScript 的重度用户，还写过一本关于它的书。

Back in the day, more than ten years ago, you were a very heavy user and you wrote a book about TypeScript.

对吧？

Right?

在TypeScript流行之前。

Before TypeScript was cool.

那时候大家都深陷在JavaScript中。

This is when everyone was deep in JavaScript.

那是二十世纪二十年代初。

This is back in early twenty tens.

对吧？

Right?

是的。

Yeah.

差不多就是这样。

Something like that.

在TypeScript还不存在的时候，因为那时候JavaScript是一种非常奇怪的语言。

Before TypeScript was a thing because back then is a very weird language.

它本来就不该在JavaScript中做这么多与类型相关的事情。

It's not supposed to do a lot of things with being typed in JavaScript.

而现在这是正确的方式。

And now is the right thing.

而且感觉终端里的ClotCode与TypeScript早期有很多相似之处。

And it feels like ClotCode in the terminal has a lot of parallels with TypeScript at the beginning.

TypeScript做出了很多非常奇怪的语言设计。

TypeScript makes a lot of really weird language decisions.

所以如果你看一下类型系统，几乎任何东西都可以是字面量类型。

So if you look at the type system, pretty much anything can be a literal type, for example.

这非常奇怪，因为就连Haskell都没有这样做。

And this is like this is super weird because like even like like Haskell doesn't even do this.

这太极端了。

It's like it's too extreme.

或者它有条件类型，我认为没有任何其他语言想过这一点。

Or it has conditional types, which I don't think any language thought of at all.

它是非常强类型的。

It was very strongly typed.

是的。

Yeah.

非常强类型。

Was very strongly.

当乔·派默、安德斯和早期团队在构建这个系统时，他们的做法是：我们有一些团队拥有庞大的无类型JavaScript代码库。

And the idea was when Joe Paymer and Anders and the early team was building this thing, the way they built it is, okay, we have these teams with these big untyped JavaScript code bases.

我们必须把类型引入进去，但不会要求工程师改变他们的编码方式。

We have to get types in there, but we're not going get engineers to change the way that they code.

你不可能让JavaScript开发者像Java程序员那样使用15层的类继承。

You're not going to get JavaScript people to have 15 layers of class inheritance like you would a Java programmer.

对。

Right.

他们会按照自己习惯的方式写代码。

They're going write code the way they're going write it.

他们会使用反射，会使用变异，会使用所有那些传统上非常难以类型化的特性。

Going to use reflection, and they're going to use mutation, and they're going to use all these features that traditionally are very, very difficult to type.

对任何坚定的函数式程序员来说，它们都是非常不安全的类型。

They're a very unsafe type to any strong functional programmer, really.

没错。

That's right.

没错。

That's right.

没错。

That's right.

因此，他们没有试图让人改变编码方式，而是围绕这一点构建了一个类型系统。

And so the thing that they did, instead of getting people to kind of change the way that they code, they built a type system around this.

这真是太巧妙了，因为当时根本没人想到这些想法。

And it was just brilliant because there's all these ideas that no one was thinking about.

甚至在学术界，也没人想过这么多点子。

Even in academia, like no one thought of a bunch of these ideas.

这些完全源于对人们的观察，看到了JavaScript程序员希望如何编写代码。

It purely came out of the practice of observing people and seeing how JavaScript programmers want to write code.

因此对于四元代码，有一些类似的想法，你可以像使用 Unix 工具一样使用它。

And so for quad code, there are some ideas that are kind of similar in that you can use it like a Unix utility.

你可以将数据管道输入到它里面。

You can pipe into it.

你也可以将数据从它里面管道输出。

You can pipe out of it.

在某些方面，它在这方面是严谨的，但在几乎所有其他方面，它只是我们想要的工具。

In some ways, it is rigorous in this way, but in almost every other way, it's just the tool that we wanted.

我为自己开发了一个工具，然后团队为自己开发了这个工具，接着为 Anthropic 的员工开发，最后为用户开发。

I built a tool for myself, and then the team built the tool for themselves, and then for Anthropic employees, and then for users.

它最终变得非常有用。

It just ends up being really useful.

它并不是一个基于原则或学术性的东西。

It's not this like principled and academic thing.

我认为，如今十五年多过去了，真正的证明就在于结果。

Which I think the proof is actually in the results now, fast forward more than fifteen years later.

很少有代码库使用Haskell，因为Haskell更偏向学术性。

Not many code bases are in Haskell, which is more academic.

而现在有大量代码库使用TypeScript，因为它更实用。

And there's tons of them now in TypeScript because it's way more practical.

没错。

Right.

这很有趣。

Which is interesting.

是的。

Yeah.

确实很有趣。

It is interesting.

对吧？

Right?

TypeScript解决了这个问题。

It's like TypeScript solves the problem.

我想有一件事很酷，我不知道有多少人知道，但这个终端其实是市面上最漂亮的终端应用之一，而且它实际上是用 React Terminal 写的。

I guess one thing that's cool, I don't know how many people know, but the terminal is actually one of the most beautiful terminal apps out there and is actually written with React terminal.

当我刚开始构建它的时候，你知道，我曾经做过一段时间的前端工程。

When I first started building it, you know, like, I I did front end engineering for for a while.

所以，我也算是一个混合型的人。

So and I was also like a you know, I'm I'm sort of like a hybrid.

比如，我会做设计、用户研究，还会写代码，所有这些我都做。

Like, I I do, like, design and user research and, write code and all this stuff.

我们特别喜欢招这样的工程师。

We love hiring engineers that are like this.

我们喜欢全才。

We love generalists.

对我来说，就是我正在为终端构建一个东西。

For me it's like, okay, I'm building a thing for the terminal.

其实我是个很烂的 VIM 用户。

I'm actually kind of a shitty VIM user.

我该如何为像我这样要在终端中工作的人打造一个产品？

How do I build a thing for people like me that going to be working in a terminal?

我觉得愉悦感真的非常重要。

And I think just the delight is so important.

我觉得在YC，你们经常谈论这一点，对吧？

I feel like at YC this is something you talk about a lot, right?

就是要打造一个让人喜爱的产品。

It's like build a thing that people love.

如果产品虽然有用，但你并不爱上它，那就不够好。

If the product is useful but you don't fall in love with it, that's not great.

所以它必须同时做到这两点。

So it kind of has to do both.

为终端设计，说实话，一直很难。

Designing for the terminal honestly has been hard.

对吧？

Right?

大概是80乘以100个字符之类的。

It's like 80 by 100 characters or whatever.

你只有256种颜色。

You have like two fifty six colors.

你只有一种字体大小。

You have one font size.

你不能使用鼠标交互。

You don't have like mouse interactions.

有这么多事情你做不到，而且还有很多艰难的权衡。

There's all this stuff you can't do, and there's all these very hard trade offs.

所以一个鲜为人知的技巧是，你实际上可以在终端中启用鼠标交互。

So like a little known thing for example is you can actually enable mouse interactions in a terminal.

所以你可以启用点击之类的操作。

So can you enable clicking and stuff.

哦，在Cloud Code里怎么做到这一点？

Oh, how do you do that in Cloud Code?

我一直在想办法

I've been trying to figure

怎么做到这一点

out how

实现这个功能。

to do this.

我们在 Cloud Code 中没有实现这个功能，因为我们曾经多次原型化过，但体验非常差，因为必须虚拟化滚动。

We don't don't have it in Cloud Code because we actually prototyped it a few times, and it felt really bad, because the trade off is you have to virtualize scrolling.

而终端的工作方式是没有 DOM。

And so there's all these weird trade offs because the way terminals work is there's no DOM.

对吧？

Right?

只有转义序列和这些自 1960 年代以来逐渐演变出来的奇怪规范。

There's antie escape codes and these weird organically evolved specs since the 1960s or whatever.

是的。

Yeah.

这感觉像BBS。

It feels like BBSs.

就像一个BBS门游戏。

It's like a BBS door game.

是的。

Yeah.

是的。

Yeah.

是的。

Yeah.

天啊。

Oh my gosh.

这简直是极大的赞美。

That's like that's like a great compliment.

是的。

Yeah.

是的。

Yeah.

让你感觉像是在发现《红龙之主》。

Get you feel like you're discovering Lord of

红龙。

the Red Dragons.

太棒了。

Fantastic.

天哪。

Oh my god.

是的。

Yeah.

但我们不得不自己去发现所有这些构建终端的用户体验原则，因为根本没人写过这些东西。

But we have we've had to just like discover all these kind of UX principles for building the terminal because no one really writes about this stuff.

如果你看看八九十年代或者 whatever 那时候的大型终端应用，它们都用像 Ed Curses 这样的工具，有很多窗口之类的东西，但以现代标准来看，它们的界面显得很粗糙。

And if you look at the big terminal apps of, you know, like the eighties or nineties or February or whatever, they use like Ed Curses, and they have all these like windows and things like this, and it just looks kind of like janky by modern standards.

它看起来太沉重和复杂了。

It just looks too heavy and complicated.

所以我们不得不重新设计很多东西。

And so we had to reinvent a lot.

比如终端旋转器，就是那些旋转的文字，到现在已经迭代了大概五六十次，甚至可能一百次。

And for example, something like the terminal spinner, just like the spinner words, it's gone through probably, I want to say like 50, maybe 100 iterations at this point.

其中大概80%都没能通过。

Probably 80% of those didn't chip.

我们试了，感觉不好，就换下一个。

So we tried it, it didn't feel good, move on to the next one.

试了，感觉不好，就换下一个。

Try it, didn't feel good, move on to the next one.

这其实是Quad Code的一个了不起之处，对吧？

And this was sort of one of the amazing things about quad code, right?

你可以写出这些原型，然后连续做二十个原型，看看哪个你喜欢，然后直接发布，整个过程可能只需要几个小时。

It's like you can write these prototypes and you can just do like 20 prototypes back to back, see which one you like and then ship that, and the whole thing takes maybe a couple hours.

而过去，你必须学习使用折纸或Framer之类的东西。

Whereas in the past, what you would have had to do is learn to use origami or Framer or something like this.

大概做出三个原型。

Built maybe three prototypes.

花了两周时间。

Took two weeks.

整个过程要长得多。

It just took much, much longer.

所以我们现在有这种优势，必须去发现这个新东西。

And so we have this luxury of we have to discover this new thing.

我们必须构建一个东西。

We have to build a thing.

我们不知道最终的正确形态是什么，但我们可以如此快速地迭代，这使得它变得非常容易，也让我们能够打造出令人愉悦、人们喜欢使用的產品。

We don't know what the right endpoint is, But we can iterate there so quickly, and that's what makes it really easy, and that's what lets us build a product that's joyous, and that people like to use.

鲍里斯，你对开发者还有其他建议，但我们一直打断你，因为问题太多了。

Boris, you had other advice for builders, and we kept interrupting you because we have so many questions.

我会说，好吧，可能有两条有点奇怪的建议，因为它们是关于为模型而构建的。

I would say, so okay, so maybe two pieces of advice that are kind of weird, because it's like about building for the model.

第一条是：不要为今天的模型构建，而要为六个月后的模型构建。

So one is, don't build for the model of today, build for the model of six months from now.

这有点奇怪，对吧？

This is, like, sort of weird.

对？

Right?

因为，如果你的产品根本无法运行，你就找不到产品市场契合点，但事实上，你应该这么做，否则你会花大量精力找到当前产品的市场契合点，然后很快就会被别人超越，因为他们正在为下一个模型构建，而新模型每隔几个月就会出现。

Because, like, you can't find PMF if the product doesn't work, but actually this is the thing that you should do because otherwise what will happen is you spend a bunch of work, you find PMF for the product right now, and then you're just gonna get leapfrogged by someone else, because they're building for the next model and a new model comes out every few months.

使用当前模型，探索它的能力边界，然后为六个月后可能存在的模型进行构建。

Use the model, fill out the boundary of what it can do, and then build for the model that you think will be the model maybe six months from now.

我认为第二点是，在我们所处的代码领域，我们墙上挂着一份《痛苦的教训》的复印件。

I think the second thing is actually in code the area where we sit, we have a framed copy of the bitter lesson on the wall.

这是里奇·萨顿的一篇博客文章，如果你还没读过，每个人都应该读一读。

And this is this Rich Sutton blog post that everyone should read it if you haven't.

核心理念是，更通用的模型总会胜过更具体的模型。

The idea is the more general model will always beat the more specific model.

对此有很多推论，但本质上就是：永远不要与模型作对。

And there are a lot of corollaries to this, but essentially what it boils down to is never bet against the model.

因此，这正是我们始终在思考的问题：我们可以在Quad Code中添加一个功能。

And so this is just like a thing to that that we always think about, where we could build a feature into quad code.

我们可以让产品变得更好，我们称之为脚手架。

We could make it better as a product, and we call this scaffolding.

这些代码都不是模型本身。

That's all this code that's not the model itself.

但我们也完全可以等几个月，模型可能就能直接完成这件事了。

But we could also just wait like a couple months and the model can probably just do the thing instead.

而且有一种直接的方法。

And there's a way to straight off.

对吧？

Right?

这现在更像是工程工作，你可以稍微扩展一下能力，比如在你试图拓展的某个领域中提升20%左右，就像那个蜘蛛图一样。

It's like engineering work now, and you can kind of extend the capability a little bit, maybe 20% or whatever in whatever domain on this like, you know, like the spider chart of what you're trying to extend.

或者你可以直接等一等，下一个模型就能做到。

Or you can just wait and the next model will do it.

所以一定要始终从这个权衡的角度来思考。

So just always think in terms of this trade off.

你到底想在哪里投入资源？

Where where do you actually wanna invest?

并且要假设，无论什么脚手架，都只是技术债务。

And assume that whatever the scaffolding is, it's just tech debt.

你们多久重写一次ClockCode的代码？

How often do you rewrite the code ways of ClockCode?

是每六个月就重写一次吗，就在这第一个阶段？

Is this every six months with this with this first

你们有没有删除过那些物理脚手架，因为模型已经进步了，你们不再需要它们了？

physical scaffolding that you've deleted because you don't need it anymore because the model just improved?

太多了。

Oh, so much.

是的。

Yeah.

就像四元代码被一遍又一遍地编写和重写。

Like, of quad code has just been written and rewritten and rewritten and rewritten over and over and over.

我们每隔几周就会下线一些工具。

We unship tools every couple weeks.

我们每隔几周就会新增一些工具。

We add new tools every couple weeks.

没有任何一部分四元代码是六个月前就存在的。

There's no part of quad code that was around six months ago.

它一直在不断地被重写。

It's just constantly rewritten.

但你说当前时钟代码的代码库中，大部分——大约80%——都不到几个月大？

But you say that most of the code base for current clock code is only say 80% of it is only less than a couple months old?

是的

Yeah.

当然

Definitely.

它甚至可能更少，没错。

It might it might even be like less than yeah.

也许只有几个月。

Maybe like a couple months.

这感觉差不多对。

That that feels about right.

如今代码的生命周期就是这样，另一个alpha期望它的使用寿命只有几个月，是的。

Just like the life cycle of code now, that's another alpha is expecting it to be the shelf life to be just a couple months Yeah.

对于最优秀的创始人来说。

For the best founders.

你看到史蒂夫·耶吉关于在Anthropic工作有多棒的帖子了吗？

Did you see Steve Yegi's post about how awesome working at Anthropic is?

而且里面有一句话说，Anthropic 的工程师目前的生产力平均是谷歌工程师在巅峰时期的 1000 倍，这真是一个惊人的数字。

And think there's a line in there that says that an Anthropic engineer currently averages 1,000 x more productivity than a Google engineer at Google's peak, which is really an insane number.

老实说，一千倍。

Honestly, like, thousand x.

你知道吗，三年前我们还在谈论十倍工程师。

Like, you know, we were three years ago, we were still talking about 10 x engineers.

现在我们却在说，比处于巅峰时期的谷歌工程师还要高出一千倍？

Now we're talking about a thousand x on top of a Google engineer in the prime?

这简直难以置信，说实话。

Like, is unbelievable, honestly.

是的。

Yeah.

我的意思是，从内部来看，如果你看技术员工，他们每天都在使用 Quad Code。

Mean, internally, if you if you look at, like, technical employees, they all use quad code every day.

甚至非技术人员，我觉得有一半的销售团队都在使用 Quad Code。

Even non technical employees, I think half the sales team uses quad code.

他们已经开始转向协作者，因为更容易使用，而且有虚拟机，更安全一些。

They have started switching to co workers because it's a little easier to use, it has VMs, it's a little bit safer.

不过，我们刚刚统计了数据，我觉得团队去年规模翻了一倍，但每位工程师的生产力提升了大约70%。

But yeah, we actually we just pulled the stat and I think the team doubled in size last year, but productivity per engineer grew something like 70%.

以什么为衡量标准？

As measured by?

就是最简单、最笨拙的指标：拉取请求。

Just like the simplest, stupidest measure, pull requests.

但我们还交叉核对了提交记录、提交的生命周期之类的其他数据。

But we also kind of cross checked that against commits and the lifetime of commits and things like this.

自从QuadCode推出以来，Anthropic每位工程师的生产力提升了150%。

And since QuadCode came out, productivity per engineer at Anthropic has grown 150.

天哪。

Oh my God.

这太疯狂了，因为在我以前的工作中，我负责Meta的代码质量。

And this is crazy because in my old life I was responsible for code quality at Meta.

我负责Facebook、Instagram、WhatsApp等所有产品线的代码质量。

And I was responsible for the quality of all of our code bases across every product, across Facebook, Instagram, WhatsApp, whatever.

团队当时的一项工作就是提升开发效率。

And one of the things that the team worked on was improving productivity.

那时候，如果能提升2%的效率，那都是数百人花上一年才做到的成果。

And back then, seeing a gain of something like 2% in productivity, that was like a year of work by hundreds of people.

所以这种100%的提升，简直是闻所未闻，完全不可思议。

And so this, like, a 100%, this is just like unheard of, just completely unheard of.

是什么吸引你来到Anthropic？

What drew you to come over to Anthropic?

我的意思是，作为一位构建者，你哪里都能去。

I mean, basically, as a builder, you could go anywhere.

是什么样的时刻让你觉得，就是这群人，就是这种做法？

What was the moment that made you say, like, actually, this is the set of people or this is the approach?

我当时住在日本乡村，每天早上都会打开Hacker News阅读新闻。

I was living in rural Japan, and I was opening up Hacker News every morning, and I was reading the news.

然后某一天，它就开始变成人工智能相关的东西了。

And it just started to be like AI stuff at some point.

于是我开始使用一些早期的产品。

And I started to use some of these early products.

我记得第一次使用时，简直让我瞠目结舌。

I remember the first couple of times that I used it, it just took my breath away.

这么说听起来有点俗气。

That was very cheesy to say.

但那确实是我的真实感受。

But that was actually the feeling.

太惊人了。

It was amazing.

作为一位构建者，我从未在使用这些非常早期的产品时有过这种感觉。

As a builder, I've just never felt this feeling using these very, very early products.

那大概是在Quad发布后两天左右吧。

That was like in the Quad two days or something like that.

所以我开始跟实验室里的朋友们聊天，想看看都在发生什么。

And so I just started talking to friends at labs just to kind of see what was going on.

我遇到了本·曼，他是Anthropic的联合创始人之一，他立刻就让我信服了。

And I met Ben Mann, who's one of the founders at Anthropic, and he just immediately won me over.

当我见到Anthropic的其他团队成员时，我也立刻被他们打动了。

And as soon as I met kind of the rest of the team at Ant, it just won me over.

我想，可能有两个方面的原因。

And I think I think probably in two ways.

一方面，它是一个研究实验室。

So one is it operates as a research lab.

所以产品工作非常非常微小。

So the product work was teeny, teeny, tiny.

它的核心完全是打造一个安全的模型。

It's really all about building a safe model.

这才是唯一重要的事。

That's all that matters.

因此，能够如此贴近模型、贴近开发，而不再把产品放在最重要的位置，这种理念让我非常认同，因为产品已经不再是最重要的了。

And so this idea of just being very close to the model and being very close to development and being not the most important thing because the product isn't anymore.

最重要的就是模型本身。

It's just the model is the thing that's the most important.

在多年从事产品工作之后，这一点深深打动了我。

That really resonated with me after building product for many years.

第二点则是它强烈的使命感。

And then the second thing was just how mission driven it is.

我是个狂热的科幻小说读者，我的书架上摆满了科幻作品。

Like I a huge sci fi reader, my bookshelf is just filled with sci fi.

所以我深知事情可能会有多糟糕。

And so I just know how bad this can go.

当我想到今年将会发生什么时，那一定会完全疯狂。

And when I kind of think about what is going to happen this year, it is going to be totally insane.

而在最坏的情况下，情况可能会变得极其糟糕。

And in the worst case, can go very, very bad.

所以我只是想在一个真正理解并深深认同这一点的地方工作。

And so I just wanted to be at a place that really understood that and kind of really internalized that.

最终，如果你在食堂或走廊里无意中听到人们的对话，他们谈论的都是人工智能安全。

And at end, if you overhear conversations in the lunch room or in the hallway, people are talking about AI safety.

这才是每个人最关心的事情，远超其他一切。

This is really the thing that everyone cares about more than anything.

所以我只是想待在这样一个地方。

And so I just wanted to be in a place like that.

对我来说，使命至关重要。

I know for me personally, mission is just so important.

今年会发生什么？

What is going to happen this year?

好的。

Okay.

如果你回想六个月前，人们当时做出了哪些预测？

So if you think back like six months ago, and kind of what are the predictions that people are making?

所以达里奥预测，Anthropic公司90%的代码将由Quad生成。

So Dario predicted that 90% of the code at Anthropic would be written by Quad.

这是真的。

This is true.

就我个人而言，自从Opus 4.5以来，我的代码已经是100%由它生成了。

For me personally, it's been 100% for like since Opus 4.5.

我卸载了我的IDE。

I uninstalled my IDE.

我再也不手动编写任何一行代码了。

I don't edit a single line of code by hand.

在Opus里，我的代码完全是Quad生成的。

It's just a 100% quad code in Opus.

我每天都会合并20个拉取请求。

And I land 20 PRs a day every day.

如果你看Anthropic整体情况，不同团队的代码生成比例在70%到90%之间浮动。

If you look at Anthropic overall, it ranges between 70 to 90% depending on the team.

很多团队也是100%。

For a lot of teams it's also 100%.

对很多人来说，这已经是100%了。

For a lot of people it's 100%.

我记得在五月我们正式发布Quad代码时就做过这个预测，说以后写代码根本不需要IDE了。

And I remember making this prediction back in May when we GA ed quad code that you wouldn't need an ID to code anymore.

当时说这话简直太疯狂了。

And it was totally crazy to say.

我觉得台下的观众都倒吸一口凉气，因为那时候这个预测听起来太荒谬了。

I feel like people in the audience gasped because it was such a silly prediction at the time.

但其实这只不过是追踪一下指数增长趋势而已。

But really all it is is you just trace the exponential.

因为我们的三位创始人都是扩展定律论文的合著者，所以这种理念已经深深融入了公司的DNA。

This is just so deep in the DNA at the end because three of our founders were coauthors of the scaling laws paper.

他们很早就看到了这一点。

They saw this very early.

所以这就像追踪指数增长，这就是即将发生的事，而确实，它发生了。

So this is just like tracing the exponential, this is what's going to happen, and yes, that happened.

继续追踪指数增长，想想会发生什么：编程将对每个人普遍变得易如反掌。

So continuing to trace the exponential, think what will happen is coding will be generally solved for everyone.

我认为如今编程对我而言已经基本解决了，我相信对每个人也都会如此，无论你身处哪个领域。

And I think today coding is practically solved for me, and I think it'll be the case for everyone, you know, regardless of domain.

我认为我们将开始看到‘软件工程师’这个头衔逐渐消失。

I think we're gonna start to see the title software engineer go away.

也许未来只会保留‘构建者’或‘产品经理’这样的称谓。

And I think it's just gonna be maybe builder, maybe product manager.

也许我们会保留‘软件工程师’这个头衔作为某种残留的痕迹，但人们实际做的工作将不再仅仅是写代码。

Maybe we'll keep the title as kind of a vestigial thing, but the work that people do, it's not just gonna be coding.

软件工程师还将撰写规格文档。

It's software engineers are also gonna be writing specs.

他们还将与用户沟通。

They're gonna be talking to users.

就像我们团队现在开始出现的情况一样，工程师们都是全才，我们团队的每个成员都会写代码，我们的产品经理写代码，设计师写代码，工程经理写代码，连我们的财务人员也写代码，我们团队里的每个人都写代码。

Like this thing that we're starting to see right now on our team where engineers are very much generalists, and every single function on our team codes, like our PM's code, our designer's code, our EM codes, our finance guy codes, everyone on our team codes.

我们会看到这种现象在各个地方都开始出现。

We're going to start to see this everywhere.

如果我们继续这个趋势，这就是最低限度的情况。

This is the lower bound if we just continue the trend.

而上限，我认为要可怕得多。

The upper bound, I think, is a lot scarier.

这就像我们达到了ASL四。

And this is something like, you know, we hit ASL four.

在Anthropic，我们讨论过这些安全级别。

And this you know, at Anthropic, we talked about these safety levels.

ASL三就是目前模型所处的水平。

ASL three is where the models are right now.

ASL四则是模型能够递归地自我改进。

ASL four is the model is recursively self improving.

如果这种情况发生，我们就必须满足一系列条件才能发布模型。

And so if this happens, essentially, we have to meet a bunch of criteria before we can release the model.

极端情况下，这种情况会发生，或者出现某种灾难性的滥用。

And so the the extreme is that, you know, this happens, or there is some kind of catastrophic misuse.

比如有人用这个模型来设计生物病毒、寻找零日漏洞，类似这样的事情。

Like people are using the model to design bio viruses, design zero days, stuff like this.

我们正在非常积极地努力防止这种情况发生。

And this is something that we're really, really actively working on, so that doesn't happen.

老实说，看到人们如何使用CodeQwen，这真的让人感到兴奋又谦卑。

I think it's it's just been honestly, it's just been like so exciting and humbling, like seeing how people are using quad code.

我只是想做一个酷炫的东西，结果却变得非常有用。

Like, you know, I just wanted to build a cool thing, and it ended up being really useful.

这让我感到既惊讶又兴奋。

And that was so surprising and so exciting.

我从Twitter或外界的观感是，大家在假期期间都离开了，然后突然发现了Claude Code，从此就一发不可收拾了。

My impression from Twitter or just the outside is basically everyone went away over the holidays and then like found out about Claude code and it's just been crazy ever since.

但对你来说，当时是不是这样？你正享受着一个愉快的圣诞节假期，然后回来后，发生了什么？

But is that how it was for you at like in time that you were you having like a nice Christmas break and then came back here, like, what happened?

实际上，整个十二月我都在旅行，还度过了一个编程假期。

Well, actually, for all of December, I was traveling around, and I I took a coding vacation.

所以我们一路旅行，我每天都只是在写代码。

So we were kinda traveling around, and I was just, like, coding every day.

那真的很好。

So that was really nice.

然后我也开始使用推特，因为那时候我一直在用Threads，早就已经是Threads的用户了。

And then I also started to use Twitter at the time, because like I I worked on threads back then, way back when, so I've been a threads user for a while.

所以我只是想看看其他人活跃在哪些其他平台上。

So I just like tried to see kind of like other platforms where people are.

是的。

Yeah.

我觉得对很多人来说，他们正是在那时发现了OPUS 4.5，而这一点我早就知道了。

I think for a lot of people, they kind of discovered that was the moment where they discovered OPUS 4.5 that I kind of already knew.