Latent Space
Claude Code’s Next Era — Thariq Shihipar, Anthropic
00:00
00:03
We're here in the studio with our friend Thoric from Anthropic and I guess generally the
我们现在在演播室里，和来自 Anthropic 的朋友 Thoric 在一起，而且我猜总的来说，
00:09
cloud code, there's so much sort of merging of boundaries.
cloud code，有太多那种边界融合了。
00:14
And you've been so on top of everything since you joined Anthropic.
而且自从你加入 Anthropic 后，你对所有事情都一直特别跟得上。
00:18
You have been early to cloud code itself, but then also, and you've told that story
你很早就开始接触 cloud code 本身了，但后来也是，而且你讲过那个故事
00:23
in other podcasts.
在其他播客里。
00:25
And you've also been talking about seeing like an agent, most recently you did the top
而且你也一直在聊像 agent 一样看问题，最近你做了 top
00:29
AIE, we'll sort of talk a few guys of Fable, which obviously you guys launch Fable,
AIE，我们会大概聊聊 Fable 的几个人，显然你们发布了 Fable，
00:33
so that's cheating.
所以那算是作弊。
00:36
And mostly, most recently, also launching Cloud Tag, and we're also going to be talking
而且最近还推出了 Cloud Tag，我们也会当着大家的面聊聊 pacing。
00:40
about pacing in front of you.
Anthropic 现在事情很多。
00:41
There's a lot going on in Anthropic.
我想最关键的问题是，当有这么多事情在发生的时候，身处 Anthropic 是什么感觉？
00:43
I guess top of the question is, what's it like being Anthropic when there's so much going
我觉得，有时候真的会让人有种被猛甩一下的感觉，就像——
00:47
on?
我加入 Anthropic 的时候，就是因为 cloud code 才加入的，当时 cloud code 刚出来，我就想，这也太好了。
00:48
I think that it is like, I think you can get whiplash sometimes, I think like going,
00:56
when I joined Anthropic, I joined because of cloud code, like cloud code had just come
01:00
out and I was like, this is so good.
01:02
And Opus 4 to me was like, just I could not imagine how good it was, you know what I mean?
而 Opus 4 对我来说，就是，我完全想象不到它有那么好，你懂我意思吧？
01:09
And that was like a real moment for me, but I was trying to convince my startup friends
那对我来说真的是个重要时刻，但我当时在试着说服我那些做 startup 的朋友
01:13
basically to use agent decoding and they're like, no, our engineers don't think it's
基本上就是用 agent decoding，然后他们说，不行，我们的工程师觉得它
01:18
good enough or something and I was like, I'm saying.
不够好还是什么的，然后我说，我就是这个意思啊。
01:21
Now you fast forward 12 months less and it's just like the default way that everyone
现在你快进不到 12 个月，它就已经成了每个人
01:29
codes, right?
写代码的默认方式，对吧？
01:30
And I think that just having to go from selling it to now teaching people how to make
而且我觉得，从卖它到现在教大家怎么
01:37
the most use of it and be more efficient and things like that is just like a big change.
把它用得最充分、变得更高效之类的，这本身就是个巨大的变化。
01:44
And yeah, I think it's just hard to stay on top of everything as a human.
而且，对，我觉得作为人类，要跟上所有事情就是很难。
01:48
I think things happen so, so fast and like two more agents at it.
我觉得事情发生得太快太快了，而且好像又多两个 agents 在忙这个。
01:52
I mean, yeah, like that's actually like the agentic stuff scales much better than the
我是说，对，其实 agentic 那些东西 scale 起来比
01:57
like human stuff where it's like, oh, like there are three things happening right now
人类那些东西好得多，就是像，哦，现在有三件事正在发生
02:00
and like, they're all emergencies and like, how do you like, you know, respond to it?
而且，它们全是紧急情况，而且，你要怎么，你知道，应对它？
02:04
Yeah.
对。
02:05
What do you split your time on?
你会把时间分配在哪些事情上？
02:06
You do a lot of technical, writing, engineering work.
你做很多技术、写作、工程方面的工作。
02:10
Yeah, so I think that like when I joined the cloud code team, I wanted to teach people
对，所以我觉得，就是我加入cloud code团队的时候，我基本上是想教大家怎么用cloud code。
02:14
how to use cloud code basically.
然后我觉得，就是这一直是那种，我想着也许我会在这上面花一点时间，或者像，你知道，我先是花了一些时间在agent SDK上，我也不太确定，你知道，the bitter lesson会怎么发展，你知道，当涉及到harnesses的时候，对吧？
02:15
And I think that like that has been something that like, I thought like maybe I would spend
就是，我觉得有时候我们会想，哦，cloud code之后是什么，你懂我意思吧？
02:20
a little bit of time on it or like I, you know, like do I was spending some time on the
所以一开始，我就想，我只想教大家怎么用cloud code，然后
02:24
agent SDK first and I wasn't exactly sure like, you know, how the bitter lesson would go,
02:30
you know, when it comes to like harnesses, right?
02:32
Like, I think sometimes we're like, oh, like what's after cloud code, you know what I mean?
02:35
And so initially, I was like, I just want to teach people how to use cloud code and
02:39
make it easier to use cloud code.
让 cloud code 用起来更容易。
02:40
And I think that is just like as harnesses have gone better and better, that's like the dominant
而且我觉得，这就像随着 harnesses 变得越来越好，现在最主要的
02:44
problem now is like, how do you use the agents, right?
问题就是，你怎么用 agents，对吧？
02:47
Like it's like such a high skill expression thing.
就像，这真的是很吃 skill expression 的一件事。
02:50
So I do that.
所以我就做这个。
02:51
And then I do engineering work.
然后我也会做工程工作。
02:54
I give talks, but I think like when I'm doing engineering work, my goal is to take that
我会做分享，但我觉得，当我在做工程工作的时候，我的目标是拿到那些
02:58
feedback that we get from users and also like then be able to talk about like, hey, how
从用户那里得到的反馈，并且也能去聊，比如，嘿，怎么
03:03
to use cloud code to do engineering.
用 cloud code 来做工程。
03:05
So there's kind of like a good loop there.
所以这里有点像形成了一个不错的 loop。
03:07
Yeah.
对。
03:08
Yeah.
对。
03:09
I'll, for listeners, we'll attach the talk that you did with Sarah for the DevRiders meet
我会，给听众们，我们会附上你和 Sarah 在 DevRiders meet
03:12
up, which we talked a little bit about.
up 上做的那个 talk，我们之前稍微聊过一点。
03:14
Well, first you do the work and then you talk about the work, something like that.
嗯，先做事，然后再聊这件事，差不多就是这样。
03:17
Yeah.
对。
03:18
So when reap or, yeah, so yeah, so yeah, so yeah, and then just to preview a little bit,
所以当 reap 的时候，或者，对，所以，对，所以，对，然后稍微预告一下，
03:24
we are going to talk about the evolution of the harness.
我们要聊聊 harness 的演进。
03:26
It has come a long way from just being a CLI.
它从仅仅是一个 CLI 一路发展到现在，已经走了很远。
03:29
We're going to talk about cloud mods, which is starting to leak today because you couldn't
我们要聊聊 cloud mods，它今天已经开始泄露了，因为你没法
03:36
keep it secret.
把它保密。
03:37
Yeah.
对。
03:38
Basically.
基本上。
03:39
Yeah.
对。
03:40
There's a lot there.
那里面内容挺多的。
03:41
I think you started off with like adding, ask you the question tool, which people love
我觉得你一开始是加了那个 ask you the question tool，大家很喜欢
03:47
and hate actually.
其实又很讨厌。
03:48
Yeah.
对。
03:49
I actually thought it was like very innovative.
我其实觉得那挺有创新性的。
03:50
And then now I have like my own version.
然后现在我自己也有个版本了。
03:53
You have your interview me version.
你有你的 interview me 版本。
03:55
Yeah.
对。
03:56
Yeah.
是啊。
03:57
And yeah, everyone just has like their own, their own stuff and I get no longer matters
而且吧，每个人都有自己的那一套、自己的东西，我觉得这已经不重要了，因为现在你得写 prompts 来生成其他 prompts、loops 以及所有这些玩意儿。
04:00
because now you're supposed to write prompts that create other prompts and loops and all
嗯。
04:04
these things.
是啊。
04:05
Sure.
那现在 state of the art 是什么？
04:06
Yeah.
那你现在一般会让大家做什么？
04:07
So what's the state of the art today?
04:08
Well, what are you like telling people to do today?
04:12
Yeah.
嗯。
04:13
Ask user question was the first time that the model was good at elicitation.
Ask user question 是 model 第一次在 elicitation 上做得很好。
04:16
You know, I think this was like kind of an emergent behavior that I like, you know, wanted
你知道，我觉得这有点像是一种 emergent behavior，我，你知道，想
04:22
to see if the models could do.
看看 models 能不能做到。
04:24
I have like kind of like a human computer interaction background.
我大概算是有点 human computer interaction 的背景。
04:27
So I like, you know, did that in undergrad and grad school.
所以我，你知道，本科和研究生的时候就在做这个。
04:29
And so this was like, I think it's kind of like human agent interaction to me, like,
所以这就像，我觉得对我来说有点像 human agent interaction，就像，
04:34
you know, trying to figure out like how can the agent communicate with you and extract,
你知道，试着搞清楚 agent 怎么跟你沟通，然后 extract，
04:37
you know, the requirements, right?
你知道的，就是那些 requirements，对吧？
04:40
I think that like one of the things about like that's difficult as Cloud Code has gone
我觉得，就像，其中一件很难的事，就是随着 Cloud Code 变得
04:46
broader and broader is that everyone has like their own way of using it.
越来越广，每个人都有自己使用它的方式。
04:51
And it's actually very hard to like change the default behavior.
而且其实很难去改变 default behavior。
04:55
So for example, like if someone asked you Cloud Code to do something, sometimes they just
所以举个例子，比如如果有人让你，Cloud Code，去做某件事，有时候他们只是
05:00
want them to do the work because they're like maybe a very good prompt and sometimes
想让它把活干了，因为他们可能，就像，是个很好的 prompt，而有时候
05:04
they won't like actually are not going to prompting.
他们不会，其实根本不会去 prompting。
05:06
You know what I mean?
你懂我意思吧？
05:07
And you need like the agent needs to like clarify, you know?
而且你需要，就，agent 得去澄清，你懂吧？
05:10
And so that's like a good split line and ask you the question tool sort of like splits
所以这就像一条很好的分界线，而那个问你的 question tool 差不多就是沿着这条线来切分
05:14
along that side where like, are do you feel like you're good enough to instruct the agent
沿着这一边，就是，你觉得你已经足够好，可以去指导 agent 了吗
05:17
as it is or is the agent able to like does the agent need to like pull out more requirements
按现在这样，还是说 agent 能够，就，agent 需不需要，就，挖出更多需求
05:23
and like collaborate with you more and really understand your preferences?
并且，就，跟你更多地协作，真正理解你的偏好？
05:27
I on the whole believe that pretty much everyone is more on the ladder than the former
我总体上相信，几乎每个人都更偏向后者，而不是前者
05:32
that they like have more ambiguity and they know less than they want.
他们，就，有更多模糊性，而且他们知道的比他们想知道的要少。
05:36
And then they like think they know about the problem.
然后他们，就，觉得自己已经了解这个问题了。
05:41
But like we're it's like interface design problem to make that easy, you know what I mean?
但这就像是个 interface design 问题，要让它变容易，你懂我意思吧？
05:46
And so like if you're designing a problem or if you're going through a problem like,
所以就像，如果你在设计一个问题，或者如果你在处理一个问题，
05:50
you know, things like what's the schema or like what's the call stack and things like that
你知道，像 schema 是什么，或者 call stack 是什么，诸如此类的东西
05:54
are really important, you know, like the details and the designer are important.
这些真的很重要，你知道，就像细节和 designer 都很重要。
05:58
I do want to figure out some of these like hard problems ahead of time before starting
我确实想提前搞清楚其中一些这样的 hard problems，然后再开始 implementation。
06:02
implementation.
而且是啊，所以才叫 unknowns 嘛，对吧？
06:03
And yeah, that's why they call like unknowns, right?
所以我觉得这会永远是一种技能，而 agent decoding 就像是搞清楚
06:06
And so I think that this will forever be like a skill and agent decoding is like figuring
06:11
out your unknowns.
把你的未知项挖出来。
06:12
So like because even if the model is like super intelligent, it like needs to know what
所以就是，因为就算 model 超级智能，它也得知道
06:17
you want, you know, and like you have preferences, like you need to sort of like pull that out.
你想要什么，你懂的，而且你有偏好，你得把这些东西挖出来。
06:24
And so that's like, I think how I'm what I'm pushing.
所以这就像，我觉得这就是我在推的方向。
06:28
The question then is like, how does the agent interact with you?
那接下来的问题就是，agent 到底怎么跟你互动？
06:30
And I think that has been HTML has been like the big way of doing that.
我觉得一直以来，HTML 就是做这件事的主要方式。
06:34
And we've recently added artifacts, right?
我们最近加了 artifacts，对吧？
06:38
And artifacts, I actually think we've done a bad job of like, or like I've done a bad
而 artifacts，我其实觉得我们做得挺差的，或者说我做得挺差的
06:41
job of like explaining how to use them fully.
就是那种解释怎么把它们充分利用起来的工作。
06:44
We have a lot of property capabilities.
我们有很多 property capabilities。
06:46
They have a database associated with them, you know?
它们都关联着一个 database，你知道吗？
06:49
And so every artifact can store and write persistent data.
所以每个 artifact 都能存储和写入 persistent data。
06:53
They can like feed back into cloud, you know?
它们可以那种反馈回 Claude，你知道吗？
06:57
And so like one thing that you know, like people are not doing yet that I'm trying to
所以就是，有一件事你知道吗，大家还没在做，而我想试着
07:00
like encourage is like this idea of a dashboard artifact.
去鼓励的，就是 dashboard artifact 这个想法。
07:04
So you have like cloud working on a project, long term, maybe it's like a can ban or something.
比如你有 Claude 在长期做一个项目，可能像是一个 Kanban 之类的。
07:09
It can store that can ban data in a database.
它可以存储，也能在 database 里 ban 数据。
07:12
Multiple clouds can access that data via like the artifact mcp.
多个 cloud 可以通过像 artifact mcp 这样的方式访问那些数据。
07:18
And like that and that artifact can like talk to those clouds as well.
而且那个 artifact 也可以跟那些 cloud 通信。
07:22
And so like that we're basically building the primitives for you to be able to have this
所以基本上，我们是在搭建一些 primitives，让你能够拥有这种
07:27
like generative interface via artifacts that will like let you surface more of that rich
像通过 artifacts 实现的 generative interface，它会让你呈现更多那些丰富的
07:33
detail from the agents.
来自 agents 的细节。
07:35
And I think that like almost everything in agents right now is like this problem of like
而且我觉得，现在 agents 里几乎一切，都像是这个问题，就是
07:40
you think you know what you want, but you don't really know what you want.
你以为你知道自己想要什么，但其实你并不真的知道自己想要什么。
07:43
And like the agents need a lot of detail and collaborating with them in the loop is really
而且，agents 需要很多细节，跟它们 in the loop 协作真的
07:50
important.
很重要。
07:51
And so artifacts are like the like way that we're trying to evolve there.
所以 artifacts 就像是，那个，我们想在那儿 evolve 的那种方式。
07:56
But there's a lot of work to do because it's so much more complicated than like a multiple
但还有很多工作要做，因为这事儿比一道选择题
07:59
choice question, you know?
复杂太多了，你懂吧？
08:01
There's a lot more like detail in terms of like diagrams and code snippets and schemas
细节多得多，比如 diagrams、code snippets 和 schemas
08:06
are like like whatever it is for that problem.
或者那个问题需要的任何东西。
08:08
But like artifacts is like the more AGI-pilled way of like you know doing ask you the question
但 artifacts 更像是那种更 AGI-pilled 的方式，你懂的，来做“问你这个问题”这件事。
08:14
basically.
基本上。
08:15
So yeah.
所以，对。
08:16
I think one thing that's unclear to me about these the artifact stuff is like what feedback
我觉得关于 artifact 这些东西，有一点我不太清楚，就是什么样的反馈
08:20
should go in through the artifact and what feedback should go through a cloud chat because
应该通过 artifact 进来，什么样的反馈应该走 cloud chat，因为
08:26
the more AGI-pilled one is to just feed everything to the cloud.
更 AGI-pilled 的做法就是直接把所有东西都喂给 cloud。
08:29
I think the more AGI-pilled one is to go through the artifact like and I think that like we
我觉得更 AGI-pilled 的做法是走 artifact，然后我觉得，就像我们
08:32
sort of imagine in the limit, I think that artifacts will be your interface into the
在极限情况下差不多会想象，我觉得 artifacts 会成为你接入
08:37
harness, you know?
harness 的接口，你懂吧？
08:38
You can like comment on this like live like document of your plan of the work.
你可以对这个评论，就像它是你工作计划的实时文档一样。
08:44
You can see maybe like multiple agents and different agents are doing this.
你可以看到，可能有好多个 agents，不同的 agents 在做这件事。
08:47
And that artifact is built for the current work that you're doing, right?
而那个 artifact 是为你现在正在做的工作构建的，对吧？
08:51
And so like each one has like slightly different.
所以每个都稍微有点不同。
08:54
I think we're still like getting there from like an infrastructure perspective.
我觉得从 infrastructure 的角度来看，我们还在慢慢达到那个程度。
08:57
But yeah, I think like on the fly interface for your harness is probably where things are
但，对，我觉得你的 harness 的 on the fly interface 大概就是未来的方向。
09:02
headed.
已经有这样的版本了。
09:03
There are version of it.
09:04
That's an abstraction from CLI or chat and you because right now a lot of it is, okay,
那是从 CLI 或 chat，还有你这边抽象出来的，因为现在很多东西其实就是，好吧，
09:10
you're interfacing with cloud code.
你就是在和 cloud code 交互。
09:13
You're having HTML given back for a mock up.
系统会回给你 HTML，用来做 mock up。
09:15
It's pretty rich.
还挺丰富的。
09:16
There's diagrams.
还有图表。
09:17
Artifacts are ways to connect these together.
Artifacts 就是把这些东西连接起来的方式。
09:20
Why not just do everything that way?
那为什么不干脆全都那样做呢？
09:22
Then it becomes like separating out like where is the inference happening?
然后就会变成像是在拆分开来，搞清楚 inference 到底发生在哪里？
09:25
Where's intelligence happening?
智能到底在哪儿发生？
09:26
Where is the work happening?
这些工作到底在哪儿发生？
09:28
You know, like I think this is kind of like difference between like or like some of the
你知道，我觉得这有点像……像是……或者说有点像
09:32
distinction between local and cloud, right?
local 和 cloud 之间的一些区别，对吧？
09:34
And so I think right now if you use cloud code, it's like local and like you can spin
所以我觉得现在如果你用 cloud code，它就像 local，而且你可以起一个
09:40
off remote control.
remote control。
09:41
For example, to get some cloud behavior or you can spin off cloud code in the cloud, right?
比如说，为了获得一些 cloud 的行为，或者你可以在 cloud 里起一个 cloud code，对吧？
09:46
We're moving towards a place where instead of clouds, like you message a local cloud,
我们正在走向一个地方：不再是 cloud，而是你给一个 local cloud 发消息，
09:53
it starts a session locally and it executes to more like you have a cloud that you message
它会在本地启动一个 session，然后运行起来更像是你有一个 cloud，你给它发消息。
09:57
that's in the cloud that's running, it can run like local or like cloud sessions.
那个 cloud 正在运行，它可以跑 local session，也可以跑 cloud session。
10:04
This is kind of how cloud tag works, but like over time we'll add like local hands as
这有点像 cloud tag 的工作方式，不过随着时间推移，我们也会加上 local hands 这类东西。
10:07
well.
所以 local hands 就是让那个 agent 能访问你的电脑——如果它在线的话，你懂的，然后能在那里干活。
10:08
And so like local hands will be the ability for that agent to access your computer if
所以它可以衍生出很多不同的 sub agents。
10:12
it's online, you know, and be able to like work there.
它可以，像是，让那些 sub agents 互相通信。
10:16
And so it can spin off many different sub agents.
10:19
It can like commute those sub agents can communicate with each other.
10:22
And that's where the artifact comes in to display all of that work basically.
而这就是 artifact 登场的地方，基本上就是把所有这些工作展示出来。
10:25
So you can imagine like the you're separating out these things.
所以你可以想象，你是在把这些东西拆分开来。
10:29
So there is like the surface UI display that's in artifact and hosted somewhere and has
所以就有像 artifact 里的 surface UI display，它托管在某个地方，并且有
10:33
a database and everything.
database 以及各种东西。
10:35
There is the inference intelligence, right, that's happening on the cloud and you don't
还有 inference intelligence，对吧，它是在 cloud 上跑的，你
10:40
have to worry about shutting off your computer or whatever, right?
不用担心关掉电脑或者什么的，对吧？
10:43
And then there's the like hands kind of like and it can be local.
然后还有像 hands 这样的部分，差不多吧，而且它可以是 local 的。
10:47
It can be in like a remote sandbox or wherever you need your work to be done.
它可以在像 remote sandbox 这样的地方，或者任何你需要完成工作的地方。
10:52
It's like unpackaging like the cloud code experience right now we're like right now it
这就像把 cloud code 的体验拆解开来，我们现在就好像，现在它
10:58
all happens in one place, right?
全都发生在一个地方，对吧？
11:00
So I do see like the multiplayer side of that.
所以我的确能看到这件事的 multiplayer 那一面。
11:03
So say teams want to work in this way right now.
所以说，团队现在想以这种方式工作。
11:06
It's very individual, but I do see the future of multiplayer like right now.
这非常个人化，但我确实能看到 multiplayer 的未来，就在现在。
11:10
I guess there's cloud tag, which is a version, but we're launching projects.
我猜有 cloud tag，算是一个版本，但我们正在推出 projects。
11:14
And so projects is the like this abstraction that's kind of like cloud tag, but on our
所以 projects 就是这种 abstraction，有点像 cloud tag，但是在我们的
11:20
cloud products, right?
cloud 产品上，对吧？
11:21
So you can message it and like it will do the cloud tag like stuff like spinning off
所以你可以给它发消息，然后它就会做 cloud tag 那种事，比如派生出 sub agents 之类的。
11:26
sub agents.
所以我们觉得，有了 multiplayer，cloud tag 就更像原生的 multiplayer，因为它就在你的 Slack 里，permissions 之类的也都搞定了。
11:28
So we think with multiplayer, like cloud tag is like a little bit more native multiplayer
做 multiplayer 是这件事里很重要的一部分，而且这些之后得更多地串在一起。
11:34
because it's just like in your Slack and the permissions are all figured out and stuff
你可以想象这会有多复杂，当你就像，哦，你有手，但是
11:39
like that.
11:40
By doing multiplayer is like an important part of the story and like that will need to get
11:45
tied together more.
11:46
Like you can imagine how complicated it gets when you're like, oh, you have hands, but
11:49
now you have other hands and other people's computers too.
11:52
And like you need to like permission them or like you have like your MCP and someone else
11:57
with MCP.
11:58
And how do you figure out how to use them right against like quite complicated and cloud
12:01
tag is a good job of like sanding down all of these issues, right?
12:05
So that like when you have yeah, Google docs, how does it access Google docs, right?
12:10
Like it accesses through the shared cloud MCP or it can access through your local credentials
12:15
as well.
12:17
But yeah, I think clock tag is our multiplayer product and it's really useful for these
12:22
like things that are inherently multiplayer like, okay, like on call, for example, incidents
12:27
are inherently multiplayer.
12:28
You want to tag cloud, you want multiple build log in, you want to be able to find context.
12:33
I think whenever I'm like working on something and I want like privacy or security or I want
12:38
other people to review it, you know, it's really nice to like, I'll have a channel per
12:42
project and all like at legal, for example, be like, hey, like I want to ship this, can
12:47
you like, like here's the cloud knows everything, you know, just chat with it.
12:52
And that we legal gets precise answers, you know, on like what exactly is shipping into
而且我们法务能得到精确的答案，你知道，比如到底什么东西会被 ship 进
12:57
the code?
代码里？
12:58
And I don't need to be in the loop, right?
而且我也不需要在 loop 里，对吧？
12:59
So I think like multiplayer is getting like more and more like, yeah, everyone can participate
所以我觉得 multiplayer 变得越来越，就像，嗯，每个人都能参与
13:05
with cloud.
借助 cloud。
13:06
I think cloud tag is like that product and like projects will start off single-player
我觉得 cloud tag 就是那样的产品，而且项目会从 single-player 开始
13:12
and will like, you know, expand.
然后会，你知道，扩展。
13:13
I think there's a question about like, maybe dual questions about identity and the unit
我觉得有个问题，就像，也许是关于 identity 和那个 unit 的双重问题
13:19
of isolation.
孤立感。
13:21
Yeah.
对。
13:22
Tag, you specifically chose to make it its own identity, which is like a controversial
Tag，你专门选择把它做成一个独立的身份，这算是个挺有争议的
13:28
choice.
选择。
13:29
There's other ways to do it.
还有别的做法。
13:30
Yeah.
对。
13:31
Cloud projects, probably it sounds like, you know, if it's anything like chat, you
Cloud projects，可能听起来像，你知道，如果它跟 chat 差不多的话，你
13:33
need projects.
就需要 projects。
13:34
It is, you know, the isolation is that artifacts that cloud instance, everyone's collaborating
就是，你知道，isolation 在于，那些 artifacts 是那个 cloud instance 的，大家都在这个上面协作。
13:41
on this.
这整个，听起来，你知道，应该是，如果你在跟法务协作做这件事，那那个 channel 就应该是一个 project，对吧？
13:42
It all, it sounds like, you know, it should be like, if you're collaborating with legal
现在还不是，但那是自然的下一步。
13:45
on the thing, like that channel should be a project, right?
对。
13:49
Like it's not yet, but that's the natural next step.
我是说，就像，我觉得在 cloud tag 里，实际上，就像 cloud tag，你基本上得自己安排一下，所以 cloud tag，对，每个 channel 就像是，
13:53
Yeah.
13:54
I mean, like, I think in cloud tag, it's effectively, like like cloud tag, you have to sort
13:57
of do your own arrangement, basically, and so cloud tag, yeah, each channel is like,
14:02
you can name it as you want, and I name like each feature, basically, as a channel.
你可以随便命名，我基本上就是把每个 feature 都叫做一个 channel。
14:07
I think like, there is some transfer, like it's unclear when there is transfer.
我觉得吧，是有些 transfer，但不太清楚什么时候会有 transfer。
14:11
Because let's say if you have a coworker who is tagging on all these things, yes, there
因为比如说，如果你有个同事，他给所有这些都 tagging，是的，那
14:16
is transfer, because it's the same person.
就是 transfer，因为是同一个人。
14:18
But with cloud, it's unclear if it's like necessarily like, well, no, you don't know, you
但换成 cloud 的话，就不清楚它是不是就一定，嗯，不，你并不知道，你
14:23
don't know about the other stuff.
不知道其他那些东西。
14:24
You should only use this stuff.
你应该只用这些东西。
14:25
It's like the tip of the iceberg meme, right, where you can like, this is what we spent
这就像冰山一角的 meme，对吧，就是你可以，这就是我们花掉的
14:30
so much time on.
花了那么多时间在这上面。
14:31
Basically, there is like infinite surface area of like, okay, you want clouds to, not
基本上，就是有那种无限的 surface area，就，好吧，你想让 cloud 去，不
14:37
infinite, but there's like a lot of like surface area to figure out of like permissions and
无限，但就是有很多那种 surface area 要去搞清楚，比如 permissions 和
14:42
visibility and like, you know, like, how can you have like cloud operate as well as you
visibility，还有就像，你知道，就像，你怎么能让 cloud 运行得尽可能好，你
14:48
can as safely as you can, you know, and obviously, this is very important to us because like,
能多安全就多安全，你知道，而且显然，这对我们非常重要，因为就像，
14:53
you know, like security for a code base is very, very important.
你知道，就像 code base 的 security 非常、非常重要。
14:56
And so we've put a lot of time into this.
所以我们在这上面投入了很多时间。
14:58
Yeah, there's so many like edge cases you can figure out where it's like, oh, like, yeah,
是啊，有太多那种 edge cases 你能想到，就比如，哦，就像，是啊，
15:02
this cloud in this channel has different permissions, but it can message another channel
这个 cloud 在这个 channel 里有不同的 permissions，但它可以给另一个 channel 发消息
15:05
and can't to exfiltrate data that way or like, can you like, what if it uses your MCP
而且没法用那种方式 exfiltrate data，或者说，你能不能，比如说，如果它用了你的 MCP 呢
15:10
and then messages someone else, like, there's like so much and we've like really put a
然后给其他人发消息，就，有好多啊，而且我们真的花了很
15:13
lot of work into sending it down.
多功夫把它发下去。
15:14
Yeah.
是啊。
15:15
Yeah, lots of work.
是啊，费了好多功夫。
15:16
Okay.
好。
15:17
Fable.
Fable.
15:18
Fable.
Fable.
15:19
You're all too good articles.
你写的文章都太好了。
15:20
I mean, you've written many good articles, but on, you know, field guide to Fable building
我是说，你写了很多好文章，但是关于，你知道，Fable building
15:25
cloud code, I'm curious from what you've seen.
cloud code 的指南，我很好奇从你看到的情况来看。
15:28
Is there any common patterns that you see in like top users at Anthropic externally?
在 Anthropic 外部，你在像顶级用户身上有没有看到什么常见的模式？
15:33
Like, what are best practices for getting the most out of cloud code?
比如，要最大化利用 cloud code，有哪些最佳实践？
15:37
The like meta skill, I say is like prompting is like very important, you know, and like,
那个像 meta skill，我说就是像 prompting 非常重要，你知道，而且像，
15:44
that like, I think this is like not trivial to say because I think a lot of people are like,
那个像，我觉得这说起来并不简单，因为我觉得很多人都是像，
15:48
oh, prompting doesn't matter.
哦，prompting 根本不重要。
15:49
It's just like, I can just say a sentence and cloud will do it.
就感觉像是，我随便说一句话，cloud 就能搞定。
15:52
And I think prompting is really this like this, it's like public speaking, you know,
而且我觉得 prompting 其实就是这样的，就像公开演讲，你懂吧，
15:58
like, or writing or something.
就像，或者写作之类的。
16:00
And for a specific audience in that audience is cloud and you need to like build a mental
而且针对一个特定的受众，而那个受众就是 cloud，你需要像建立一个 mental
16:04
model of cloud and how it thinks and how it works, right?
model，关于 cloud 的，知道它怎么想、怎么运作，对吧？
16:07
And so that's like the most important skill in working with cloud code is like having
所以这就像是跟 cloud code 打交道时最重要的技能，就是拥有
16:11
this mental model, right, of cloud and like what it can do well, what it can one shot,
这个 mental model，对吧，关于 cloud 的，了解它擅长什么，能 one shot 什么，
16:16
what it can't.
它做不到什么。
16:17
And so so many people when you see prompting, they're just like, they're short prompts,
所以，非常多的人，当你看到 prompting 的时候，他们就会觉得，不就是很短的 prompts，
16:22
they have such a good mental model of cloud and of like the code base and things like that.
他们对 cloud、对 code base 这类东西有特别好的 mental model。
16:26
That like it's effortless, you know, I mean, but it's like high skill ceiling.
就感觉这毫不费力，你知道，我是说，但它又像是 high skill ceiling。
16:30
So like that work of like, you know, spending a lot of time prompting and building mental
所以，就像那种工作，你知道，就是花很多时间 prompting，并建立 mental models
16:34
models of how, you know, an intuition for how the agents work is really important.
你知道，对 agents 如何工作的直觉，这真的很重要。
16:39
And then I think like the next thing is like the unknown stuff we talked about earlier
然后我觉得，下一件事就是我们之前聊过的那些未知的东西
16:44
where it's like being able to find out like your what you don't know or what you haven't
就是能够发现，你知道，你不知道什么，或者你还没……
16:50
written down, learning about like different things.
写下来，了解一些不同的东西之类的。
16:54
I think as cloud can do more and more things, the likelihood of you doing something out
我觉得随着 cloud 能做的事情越来越多，你去做某件
16:59
of distribution for you and like you have low domain knowledge on is very, very high.
对你来说 out of distribution、而且你 domain knowledge 很低的事情的可能性，是非常非常高的。
17:03
You know, and the more you can like learn the vocabulary to be able to prompt cloud,
你知道，而且你越能学会那些能让你 prompt cloud 的词汇，
17:10
it comes really important.
这就变得非常重要。
17:11
And so like I think the most important unknowns are the unknown unknowns for you are like,
所以我觉得，对你来说最重要的未知就是那些 unknown unknowns，就像，
17:14
I just like don't even know that this exists, right?
我甚至根本不知道这个东西存在，对吧？
17:17
Yeah, exactly.
对，没错。
17:18
I think this like illustration of like the map and the territory, right, where you're
我觉得这就像是地图和疆域的那个比喻，对吧，就是你
17:21
like, okay, this is my prompt and the territory is like the actual like work that the agent
就是，好吧，这是我的 prompt，而疆域就是 agent
17:26
needs to do, right?
需要做的工作，对吧？
17:28
And if you were like very precise, you can give more precise things, right?
如果你特别精确的话，你就可以给出更精确的东西，对吧？
17:31
So like, for example, in design, I'm not very precise.
所以就像，比如说，在设计方面，我就不是很精确。
17:33
I'm not a designer.
我不是设计师。
17:34
So I say like, you know, give me like eight different mockups.
所以我会说，你知道的，给我八个不同的 mockups。
17:37
But if I was a designer, maybe I'd be like, oh, hey, here's some reference sites.
但如果我是设计师，也许我会说，哦，嘿，这里有一些参考网站。
17:41
Like I want this type of font and this type of like look to it and here's like a few different
就像我想要这种字体，这种类似的感觉，然后这里有几个不同的
17:45
components to like visualize here as a Figma MC board to bring in, you know, like.
组件，可以在这里可视化成一个 Figma MC board 来引入，你知道吧，就那种。
17:52
And so you can just be so much more precise with that language.
所以用这种语言，你就能精确得多。
17:55
And if you're not a designer, you just need to like try and learn the language basically
而如果你不是设计师，你就得试着去学这门语言，基本上就是
18:00
or learn the unknown unknowns.
或者学会那些未知的未知。
18:02
And this is true of like everything, I think like the more like you can work with cloud
而且我觉得这对所有事情都成立，就像你越能跟 cloud 一起协作
18:07
to learn like how things work, the better your prompting will be.
去了解事情是怎么运作的，你的 prompting 就会越好。
18:11
I think another good example of this is like game design, you know, like where a lot of
我觉得另一个很好的例子就是 game design，你知道吧，就比如很多
18:15
people are like, oh, like I can vibe code a game now.
大家会说，哦，我现在可以 vibe code 一个游戏了。
18:17
And they're like, it's not fun.
然后他们会说，这不好玩。
18:20
And like it's just like the thing about game design is like every one of these choices
而且就像，game design 这事儿吧，就是这些选择里的每一个
18:23
has like a lot of variations, yeah, not a lot of like craft to them.
都有很多变体，对，但它们本身没多少匠心。
18:28
So it's like, oh, okay, like when you're making a flying game, the feel of the paint
所以就像，哦，好吧，就像你在做一个飞行游戏的时候，paint plane 的手感
18:34
plane and the like, you know, way it responds to your controls has a lot of like, like,
以及，你知道，它对你 controls 的响应方式，有特别多，就像，就像，
18:39
you know, a game designer would spend like days on that, you know what I mean?
你知道，一个 game designer 会在这上面花上好几天，你懂我意思吧？
18:43
And like, it is like from the possible space of 1,000 mathematically valid answers,
而且就像，它就像是从 1,000 个数学上有效的答案的可能空间里，
18:49
it's the one that is the humans who are like, yes, yeah, I think it was tasty.
就是那种，人类会说，对，对，我觉得挺好吃的。
18:54
I'm like torn on this word because I think you're right.
我对这个词有点纠结，因为我觉得你说得对。
18:56
But everyone has different definitions.
但每个人的定义都不一样。
18:58
And it, it sounds kind of like low skill or like elitist almost where you're like,
而且它，它听起来有点像低技能，或者几乎有点精英主义，就是你会觉得，
19:04
oh, like there's certain people would say it's like taste is what I call taste.
哦，就是有些人会说，品味就是我所谓的品味。
19:07
Yeah, exactly, these guys don't have taste.
对，没错，这些人没有品味。
19:09
Yeah, exactly.
对，没错。
19:10
Oh, like an engineer doesn't have tastes like I, the like founder have taste, you know what
哦，就像工程师没有品味，而我，这个创始人，有品味，你懂我意思吧
19:14
I mean?
我是说？
19:15
And I think that's actually not true.
而且我觉得那其实不对。
19:16
Like I think like the engineers have a lot of taste for these particular, like problems,
就像我觉得那些工程师对某些特定的，嗯，问题很有品味，
19:20
you know, and I think everyone has taste for particular problems.
你知道，而且我觉得每个人对特定的问题都有自己的品味。
19:24
I think like Jason Liu, like, like say like in order to have tastes, you have to eat,
我觉得就像 Jason Liu，比如说，就像，要想有品味，你得先吃，
19:30
you know, and I really like that or it's like, okay, you have to like do a lot of things.
你知道，我真的很喜欢这个说法，或者说，好吧，你得做很多事情。
19:35
You have to like iterate and figure out what you want, what you like.
你得不断迭代，搞清楚你想要什么，你喜欢什么。
19:39
And you know, like build that like domain vocabulary.
然后你知道，就像建立起那套领域词汇。
19:43
And then when you're prompting, you're like synthesizing all of that for a while.
然后你在 prompting 的时候，就像是在把那些东西都综合一阵子。
19:47
Is it in New England?
是在 New England 吗？
19:48
Someone else says it better than you.
别人说得比你好。
19:49
This is like the fuck.
这就像是，卧槽。
19:50
I have to quote this guy forever.
我得永远引用这家伙的话。
19:51
Having to quote Jason Liu forever.
得永远引用 Jason Liu 了。
19:52
He's going to love this.
他肯定会爱死这个的。
19:53
So I, I am a frog.
所以我，我是一只青蛙。
19:54
Yeah.
对。
19:55
I mean, sometimes it's actually not even that sometimes it's just intuitive, right?
我是说，有时候其实甚至不是有时候，就是纯粹凭直觉，对吧？
20:01
Like you don't realize you even want something till a model puts it out.
就是你根本没意识到自己想要什么，直到某个 model 把它做出来。
20:05
And you're like, oh, this just feels immediately better, right?
然后你就想，哦，这个感觉一下子就更好，对吧？
20:07
Yeah, yeah, exactly.
对，对，完全正确。
20:09
One thing I go back and forth one is I feel like the way I prompt half the time that say
有一件事我一直反复纠结，就是我觉得我有一半时间写 prompt 的方式，比如说
20:15
I use voice.
我用语音。
20:16
I said voice on the people voice.
我说的语音，是指对着 voice 说话。
20:19
That is the opposite.
那正好相反。
20:20
It's just like me rambling for like two minutes, pressing down the function key and then
就像我那样东拉西扯个大概两分钟，按住 function key，然后
20:23
let go.
松开。
20:24
And then like hopefully you figure it out.
然后就像，希望你能自己搞明白。
20:25
And oftentimes it does.
而且很多时候还真能行。
20:26
Yeah.
是啊。
20:27
But it's not as thoughtful as like a structured prompt with like, you know, well run communication
但这不像一个 structured prompt 那样考虑周全，有那种，你知道，组织良好的沟通
20:32
as though it's a PRDR memo is that in line with how people do this, there's like basically
就好像它是一份 PRDR memo 一样，这符合人们通常的做法吗，基本上就是
20:37
bimodal prompting where there's some problems where you spend a lot of time out front and
bimodal prompting，有些问题是你要在前面花很多时间，而
20:41
other problems you just dash it off.
另一些问题你就随便快速糊弄一下。
20:43
Um, I don't think the voice is necessarily low.
嗯，我不觉得 voice 就一定是低。
20:46
Like I think it's like more like how much information is in the prompt, you know, like the
我觉得这更像是 prompt 里有多少信息，你懂吧，就像
20:49
model can like you can um and uh and like add some sentences and be like, oh, like actually
model 可以，就像你可以，嗯、呃，再加上几句，然后说，哦，其实
20:55
I changed my mind like in the middle of the prompt and it will be able to follow that
我在 prompt 中间改主意了，而它也能把那个
20:58
perfectly.
完美地跟下来。
20:59
You know what I mean?
你懂我的意思吧？
21:00
So I think the like actual format of the text is less important.
所以我觉得，就是，文本的实际格式其实没那么重要。
21:03
But then like the ability to like, how much information is in it, right?
但是呢，就是，能够就是，里面有多少信息，对吧？
21:07
And I think for voice, a lot of times, you know, going back to like kind of human age
而且我觉得对于语音来说，很多时候，你知道，回到就像人类时代那样
21:11
and interaction and like for a lot of people, it's just way easier to talk than to like type,
和互动，而且就像对很多人来说，说话就是比打字容易得多，
21:16
you know, um and if that gets some more information out of you, like that's better.
你知道，嗯，如果那能从你那里得到更多信息，那样更好。
21:21
At some level it feels like just giving the model as much context over prompting before
在某种程度上，感觉就像只是在启动之前给model尽可能多的context而不是prompting
21:26
you kick off is a breast practice.
你开始是最佳实践。
21:28
I don't know.
21:29
A lot of the times like when I was first trying out Fable, I spend a solid 30 minutes
很多时候，比如我刚开始试 Fable 的时候，我会花整整 30 分钟
21:34
like really crafting a long problem.
真的去精心设计一个很长的问题。
21:36
This I think is a response of models running for longer and longer, right?
我觉得这是对模型跑得越来越久的一种反应，对吧？
21:40
It's still a little difficult to nudge them as they're in like, you know, in the loop.
但当它们处在，你知道，那个 loop 里的时候，想稍微推它们一把还是有点难。
21:46
But I just like intuitively spend more time kicking off that first prompt and working
但我就是会直觉上花更多时间去启动那个第一个 prompt，然后去处理
21:51
with a lot.
很多内容。
21:52
My personal opinion is that if I was a software engineer, if I was like, you know, just
我的个人看法是，如果我是一名 software engineer，如果我就像，你知道，只是
21:57
running my own startup, for example, I think I would mostly stick to a max 20 X, you
比如在运营自己的 startup，我觉得我大概率会最多坚持用 max 20 X，你
22:02
know, I mean, um, like maybe verification and code review are kind of like separate things.
你知道，我是说，嗯，就也许 verification 和 code review 算是挺分开的两回事。
22:07
But I think like what I see a lot of times as people hit rate limits when they're doing
但我觉得，很多时候我看到的是，大家在做这种事的时候会撞上 rate limits，
22:11
this sort of like, oh, like it did a lot of work and you're like, oh, I don't like this.
就这种，哦，它做了好多活儿，然后你就想，哦，我不喜欢这个。
22:16
Like can you like undo this and redo it?
就你能不能，比如，把这个 undo 了再 redo 一下？
22:18
And and then you're like iterating on this like thing that the model could have done.
然后你就，在这个其实 model 本来就能做好的东西上，一直 iterate。
22:22
If you had like spent more upfront time or given a better context, you know, and instead
如果你一开始就多花点时间，或者给了更好的 context，你懂的，而不是
22:28
it's sort of like, you're like, nope, don't like that design.
就变成这种，你就说，不行，我不喜欢那个 design。
22:30
Try this or like the you messed this up or something like that.
试试这个，或者你把这个搞砸了之类的。
22:34
And then that just eats up so much more of like, you know, your usage.
然后那就会消耗掉你更多的，你知道，usage。
22:38
And so that's like, I think maybe like a key like tip both for like efficiency as well,
所以这就像是，我觉得可能也算是一个关键的小技巧，对 efficiency 来说也是，
22:43
right?
对吧？
22:44
And yeah, I think like context and not just like context on like what the goal is, you
然后，对，我觉得像是 context，而且不只是关于目标是什么的那种 context，你
22:48
know, I mean, it's good, right?
知道，我的意思是，这挺好的，对吧？
22:49
Like are you building a prototype or is it like a production thing?
比如你是在搭一个 prototype，还是说这是个 production 的东西？
22:52
Where can you spend compute or where can you not spend compute?
哪些地方能花 compute，哪些地方不能花 compute？
22:54
Like I think you have to give the model permission or like not permission to do
比如说我觉得你得给 model 权限，或者不给他权限去做
22:59
things sometimes where, you know, like it doesn't know intuitively how much you want
有时候，你知道，就是它没法直觉地知道你想要多少
23:03
to spend on this task, right?
在这个任务上花多少，对吧？
23:04
And you can you can use effort for this.
而且你可以，你可以用 effort 来做这个。
23:06
So I'm working on a blog post about that where it's like, you know, if you want for
所以我正在写一篇关于这个的博客文章，里面就是说，你知道，如果你想要...
23:12
like we see the effort scales with basically the complexity of the task.
就像我们看到，effort 基本上会随着任务的复杂度 scaling。
23:16
So for security effort gets like way more results like high effort versus like low
所以对于 security 来说，effort 会带来多得多的结果，就像高 effort 对比低
23:22
effort gets like changes devils a lot, but for software engineering, it doesn't change
effort 会 like 改变 devils 很多，但对于 software engineering，它并不会改变
23:26
it.
它。
23:27
A huge amount because effort is mostly spent on the verification and the like edge case
非常多，因为 effort 主要花在 verification 和类似 edge case 上
23:32
testing and things like that.
testing 以及诸如此类的事情。
23:34
And so like being able to like give the model that guidance of like, hey, this problem
所以，就像能这样给 model 那种引导，比如，嘿，这个问题
23:38
is something that I think I want you to spend a lot of time verifying and edge case testing.
是我觉得我想让你花很多时间去 verifying 和做 edge case testing 的事情。
23:43
How about model in the mix?
那 model 也加进来怎么样？
23:44
So, you know, there's office and Fable with effort is also high cool in there.
所以，你知道，里面还有 office 和 Fable，effort 也很高，挺酷的。
23:50
Yeah.
是啊。
23:51
So yeah, but it's very close where I think the frontier models will be Pareto dominant
所以，对，但已经非常接近了，我觉得 frontier models 会是 Pareto dominant 的。
23:56
over like almost everything, you know, like maybe and sometimes I think I think Opus
在几乎一切方面，你知道吧，就像，可能，有时候我觉得我觉得 Opus
24:00
might be Pareto dominant, you know what I mean?
可能是 Pareto dominant，你懂我意思吧？
24:02
Like I think depending on like how things like shake out if it's like a newer version
就像我觉得，这得看，就像，事情最后怎么发展，如果它是，就像，一个更新版本的
24:07
of Opus.
Opus。
24:08
But I think that like increasingly it's just going to be like the smart model is going
但我觉得，就像，越来越会是，就像，那个 smart model 会
24:13
to be able to like do the simple task for less tokens than the like the the other models
能够，就像，用比那些，呃，其他模型更少的 tokens 来做简单任务
24:21
basically because of verification with verification in the limit, your model doesn't need to verify
基本上是因为 verification，有了 verification，in the limit，你的模型不需要 verify
24:28
right?
对吧？
24:29
If it's a perfect model, it just does the work once and it's like, okay, like you I did
如果是一个完美的 model，它就把活干一次，然后就像，好吧，就像你，我做了
24:33
it, you know, and increasingly with Fable, I'm like, do you need to spin up chromium and
它，你懂的，而且越来越多地用 Fable，我会想，你需要启动 chromium 然后
24:38
screenshot all these things?
screenshot 所有这些吗？
24:40
Like I see it like you did it, right?
就像我看到它，就像你做了，对吧？
24:42
And so a lot of the at higher effort, you spend more of those tokens verifying.
所以很多在更高 effort 的时候，你会花更多那些 tokens 去验证。
24:47
But if you're working on simpler problems and a lot of software engineering is like,
但如果你在处理更简单的问题，而很多 software engineering 就像，
24:51
you know, like well, like in Fable, like low and mediums ability, it can spend less tokens
你知道，就像，嗯，就像在 Fable 里，像 low 和 medium 能力，它可以花更少 tokens
24:57
verifying.
去验证。
24:58
And as a model gets smarter and smarter, they will just be able to like, all right, done,
而且随着 model 变得越来越聪明，它们就会直接，好吧，搞定了，
25:03
you know, like I can run the length for sanity sake, but like I like, you know it lints,
你知道，就像我可以为了 sanity 起见把整段跑一遍，但就像我，你知道，它 lint 通过了，
25:08
you know what I mean?
你懂我意思吧？
25:09
Like you don't even need to do that.
就像你根本都不需要那么做。
25:10
And that will be so much more token efficient than like the the smaller models basically.
而且那会比那些更小的 model 的 token 效率高得多，基本上。
25:14
Yeah.
是啊。
25:15
So that's a good practice on our side that we can use to see if we're using too much
所以这是我们这边一个很好的做法，我们可以用它来看看自己是不是用了太多
25:21
effort.
精力。
25:22
Like I can be wasting time on that kind of stuff.
就像我可能会把时间浪费在那类东西上。
25:24
Yeah, yeah, yeah.
对对对。
25:25
I know what you mean.
我懂你意思。
25:26
I think like so in this blog post, my rough distribution is like code review and security
我觉得就像在这篇 blog post 里，我大概的 distribution 是，code review 和 security
25:32
should be like higher max basically.
基本上 max 应该更高。
25:35
And like software engineering setting is per domain.
然后 software engineering 的 setting 是按 domain 来的。
25:37
Yeah, I think like if you're doing like UI or something like that, like low and medium,
对，我觉得如果你是在做 UI 或者类似的东西，那 low 和 medium，
25:43
I think is you're building like an API and you want to make sure like you cover enough
我觉得就是，你在搭 API，然后你想确保自己覆盖得够。
25:47
edge cases, you know?
edge cases，你懂吧？
25:49
And so I think building, like I said, that mental model of like how things work across
所以我觉得，就像我说的，建立那种关于事情如何在这些
25:54
these distributions is like, yeah, part of the job.
distributions 中运作的 mental model，就像，是的，这是工作的一部分。
25:56
This is more intuition driven or evil come this would change is evil.
这更多是直觉驱动的，或者 evil 来的时候这个会变，就是 evil。
26:01
Yeah, yeah.
对，对。
26:02
So what I did in the blog was to like go over all of the terminal bench, evil is basically.
所以我在博客里做的，基本上就是把所有 terminal bench 都过一遍，evil 基本上就是。
26:07
So there are like 70 problems.
所以大概有 70 个问题。
26:10
And I show that like, okay, you know, like in the security problems, it does more.
然后我展示说，好吧，你知道，比如在 security 问题上，它做得更多。
26:16
And then I also like look at some of the transcripts just in terms of like how, what does
然后我也喜欢看一些 transcripts，就是看它怎么回答、回答了什么？
26:19
it answer?
它忘了什么之类的？
26:20
What does it forget or something?
很多时候，我还有一个 prompting tip，就是让它写 decision notes 或者 implementation notes，因为基本上它遇到的每一个 evil problem，它都会想到正确的解法，你懂吧？
26:21
And a lot of times, this is another prompting tip I have is like asking it to make decision
然后决定不这么做，你懂吧，就像，哦，答案是这个。
26:28
notes or implementation notes because in basically every evil problem that it faces,
如果我这样做呢？然后它又会想，哦，可能不行，你懂吧，然后继续往下走。
26:34
it thinks about the correct solution, you know?
26:38
And decides not to do it, you know, it's like, oh, like here is the answer.
26:43
What if I did this and then it's like, oh, probably not, you know, and then keeps going.
26:48
And this is like the majority of the failures, you know what I mean?
而且这基本上就是大多数失败的情况，你懂我意思吧？
26:51
At like a higher max level, it's very rare that the model just doesn't know how to do something.
在更高的 max level 下，model 单纯就是不知道怎么做某件事，这种情况非常少见。
26:57
If you just have these implementation notes, then you can review.
如果你有这些 implementation notes，那你就可以 review。
27:00
And you can be like, oh, actually, I want you to do this thing that you didn't do.
然后你就可以说，哦，其实我想让你做这个你没做的事。
27:04
The models are getting better at surfacing that overall.
这些 model 整体上越来越擅长把这一点 surface 出来。
27:06
Like I see in the transcripts that Fable 5.1, like when it does this output, it will
比如我在 transcripts 里看到，Fable 5.1，像它做这种 output 的时候，它会
27:11
call out its decision making as well.
把自己的 decision making 也明确说出来。
27:15
But making this more explicit in the harness is better.
但在 harness 里把这一点做得更明确会更好。
27:18
And now we're, you know, allowing ways of you modifying the harness so you can, like,
而现在我们，你知道，允许你以一些方式修改 harness，这样你就能，就，
27:23
you know, add something.
你知道，加点东西。
27:24
Say how believe it is.
说说你觉得它是怎样的。
27:25
Yeah, so I do want to call out two things that you mentioned that I think actually exist
对，所以我确实想指出你提到的两件事，我觉得它们其实存在
27:30
outside of prompting.
在 prompting 之外。
27:31
One is actually like, let's call it the prompt that is so important that it shouldn't
其中一个其实是，就，我们叫它那个 prompt，它重要到不应该
27:34
be in a prompt.
出现在 prompt 里。
27:35
It's actually in Cloud MD or agent's MD, which is like goals, right?
它其实在 Cloud MD 或者 agent's MD 里，那就有点像 goals，对吧？
27:40
Like your situation, your goals, the things that you want, the thing.
比如你的情况、你的目标、你想要的东西，那个东西。
27:45
And then the second of all is the decision log or the experiment log or whatever log of
然后第二点就是 decision log，或者 experiment log，或者随便什么
27:50
traces that you might want to actually survive the current session to do those things.
traces 的 log，你可能想让它真的能挺过当前 session，好去做那些事情。
27:54
Those are like externalities that there's no standard.
那些就像是 externalities，根本没有标准。
27:58
It's not like skills.
它不像 skills 那样。
27:59
It's not like MCP.
它不像 MCP 那样。
28:00
There's no standard.
根本就没有标准。
28:01
It's just like it's a markdown file.
它就好像只是一个 markdown 文件。
28:04
Is that right?
是这样吗？
28:05
Is Cloud MD going away?
Cloud MD 要没了吗？
28:07
You have a documented dislike of agent's MD, but you're going to do it.
你对 agent's MD 的不喜欢是有记录在案的，但你还是打算做。
28:11
Yeah, yeah.
对，对。
28:12
Okay.
好。
28:13
So I mean, agent's MD, yeah, like where we're going to do it.
所以我是说，agent's MD，对，就是我们要做这件事的地方。
28:16
I think it's just like different models are very different from each other.
我觉得就是，不同的 models 之间差别非常大。
28:19
You know what I mean?
你懂我意思吧？
28:20
But I realize that it's like such a pain to like maintain different ones.
但我意识到，维护不同的这些真的太麻烦了。
28:24
You know what I mean?
你懂我的意思吧？
28:25
And yeah, like as the models get better and better, the floor of how they accomplish the
而且，是的，随着 models 越来越好，它们完成
28:30
simpler task is better.
更简单任务的下限也更高了。
28:31
And so I do think in the limit, Cloud.MD goes away and maybe not even like that far.
所以我觉得最终 Cloud.MD 会消失，也许甚至不用那么久。
28:37
Like I think like, I think that right now, it might be better to start a new project
就像我觉得，我觉得现在，可能最好是开始一个新项目，
28:43
without a Cloud.MD.
不用 Cloud.MD。
28:44
Yes.
是的。
28:45
I think that like maybe if you see very repeated failure modes, you add them to your
我觉得，就，可能如果你看到非常重复出现的 failure modes，你就把它们加到你的
28:50
Cloud.MD.
Cloud.MD 里。
28:51
The really tough thing is that this changes per model.
真正棘手的是，这会因 model 而异。
28:54
And so like if you've added a bunch of failure modes, like even with Fable MD, you need
所以就像，如果你已经加了一堆 failure modes，哪怕有了 Fable MD，你也需要
28:58
Opus MD.
Opus MD。
28:59
So even Fable 5.1 versus Fable 5, you know, like it is annoying.
所以就算 Fable 5.1 和 Fable 5 相比，你知道吧，就，这很烦。
29:04
Like I'm not like, you know, like we don't like do this on purpose, you know, I mean, it's
就像我不是说，你知道吧，就像我们不是故意这么做的，你懂我意思吧，我的意思是，这
29:08
just like how the models work, right?
就是 models 是怎么运作的，对吧？
29:10
And so like maybe like Fable 5 had this like failure mode, the Fable 5.1 doesn't.
所以可能就像，Fable 5 有这么一个 failure mode，Fable 5.1 就没有。
29:15
And if you keep this context where it's running log of a bunch of different failure modes,
而且如果你一直保留这个 context，它就是一个记录一堆不同 failure mode 的 running log，
29:20
they will probably over constrain Cloud, you know.
它们可能就会 over constrain Cloud，你懂的。
29:23
And so this is like, we just actually added evals, plugins for skills.
然后这就像，我们其实刚刚加了 evals，还有给 skills 用的 plugins。
29:29
And so now you can eval if a skill is better, I think Daisy on our team did this.
所以现在你可以 eval 一个 skill 是不是更好，我觉得我们团队的 Daisy 做了这个。
29:33
And so yeah, this is like, we're trying to work on this.
然后对，这就像，我们正在试着搞这个。
29:36
We know it's like, you still have to spend tokens on it.
我们知道，这就像，你还是得在上面花 tokens。
29:38
And like, you know, it's not, it's not perfect, but it's like, we're trying to help out
然后就是，你知道，它不，它不完美，但这就像，我们在试着帮上忙。
29:43
with this problem.
关于这个问题。
29:44
And so as far as prompting goes, the one tape I want to offer is something I have told
所以就 prompting 而言，我想给出的那一点，是我已经跟很多人说过很多次的一件事：足够先进的 prompting 和足够先进的高管沟通是无法区分的。
29:49
people a lot is sufficiently advanced prompting is indistinguishable from sufficiently advanced
所以我其实把它称作来自 heavy bit 的 executive comms workshop，那是我职业生涯中见过最好的。
29:56
executive communication.
他们教了一个叫 SCQA model 的东西，直接 Google 一下就行。
29:57
So I've actually referred to this as a executive comms workshop from heavy bit that it's the
这东西就像人们已经做了几十年的 prompting 一样。
30:02
best I've ever seen in my career.
30:03
And they teach this thing called the SCQA model, just Google it.
30:07
It's a thing like people have done prompting for decades.
30:11
It's just called executive communications.
它就叫 executive communications。
30:12
It's like when one person has to communicate to thousands of people down the org chart,
就像一个人得顺着 org chart 往下，跟成千上万的人沟通，
30:17
this is what you do.
这就是你要做的事。
30:18
So situation, complication, question, and answer is how you write the memo.
所以 situation、complication、question、answer 就是写 memo 的方法。
30:22
But obviously, if sometimes you don't have the answer, but you can actually at least
但很明显，有时候你并没有 answer，但你至少可以
30:25
list out the SC and Q and then they have some examples in there.
把 SC 和 Q 列出来，然后里面还有些例子。
30:27
So just leaving break rooms for people if they want to explore.
所以就是给大家留出休息室，让他们想探索就去探索。
30:30
I mean, before we move on, I want to ask you any other underrated tips, ways people could
我是说，在我们继续之前，我想问问你，还有没有其他被低估的技巧，或者人们可以……
30:38
get a lot of value from cloud code that they're not using?
从他们没在用的 cloud code 里获得了很多价值？
30:41
Yeah, I mean, I think a lot of them are in the, this unknowns like doc, like a bunch
对，我是说，我觉得他们很多人都在那种，未知的东西里，像 doc，像一堆
30:48
of example, prompts, like using it for brainstorming it, using it to quiz you after we added
示例 prompts，比如用它来头脑风暴，用它来考你，在我们加上
30:56
this like explain it like I'm five skill, actually, which is a very short prompt.
这个类似 explain it like I'm five 的 skill 之后，其实，那是个非常短的 prompt。
31:02
And it doesn't even say explain it like I'm five.
而且它甚至都没说 explain it like I'm five。
31:04
It's like basically the key word of this prompt is big picture is few words, you know,
基本上，这个 prompt 的关键词就是 big picture，没几个词，你知道，
31:10
like that's like the main thing.
就像，那才是关键。
31:12
And it is shockingly good, you know, I mean, like you like, I think I tweeted about
而且它出奇地好，你知道，我是说，就像，我觉得我发过推文聊过
31:17
this basically.
基本上就是这样。
31:18
And it's like slash you live five and like you can install it as a plugin, but yeah,
而且它就像 slash you live five，你可以把它作为 plugin 安装，不过是的，
31:22
it's like way better at just cutting through the BS and being like, yeah, yeah, exactly
它更像是特别擅长直接戳破那些废话，然后说，对，对，没错
31:26
right here.
就在这里。
31:27
So the diagrams are like quite clear.
所以这些 diagrams 还挺清楚的。
31:28
I think one of the things that is true with artifacts is like they put too much text
我觉得 artifacts 有一点确实是，它们放了太多文字
31:32
in and people are not reading the artifacts, you know.
进去，然后人们根本不读这些 artifacts，你知道吧。
31:34
And so like this simplifies it a lot more.
所以这样就把事情简化多了。
31:38
And yeah, this came out of like just people at Anthropic, like going through very complicated
然后，对，这其实就是 Anthropic 的人搞出来的，他们经历一些非常复杂的
31:43
incidents and be like, what is happening?
incidents，然后就会想，这是怎么回事？
31:45
So this one I think is great, yeah.
所以这个我觉得挺棒的，对。
31:47
My version of this is actually the, it's like test your understanding, give you a few
我的版本其实是那种，像是考考你理不理解，给你几个
31:52
choices.
选项。
31:53
And then like if you actually get it wrong, you have a mismatch between what you think
然后，如果你真的答错了，你所以为的
31:56
is happening versus what's actually happening.
正在发生的事，和实际正在发生的事之间就会对不上。
31:58
Yeah, yeah, yeah.
对，对，对。
31:59
I think this is one of those things that everyone loves talking about.
我觉得这就是那种大家都特别爱聊的事。
32:02
And then very few people really do it.
但真正去做的人却少之又少。
32:04
Like, you know, I think, yeah, yeah, but most people just don't want to get quizzed
就是，你知道，我觉得，对对，但大多数人就是不想被问
32:10
about something, you know, I mean, unfortunately, I think this is one of the like things
关于某件事，你懂的，我的意思是，不幸的是，我觉得这就是那种
32:15
that we need to like, what's the opposite of ask you a question or ask you a question
我们需要，就像，反过来的说法是什么——问你一个问题，或者问你一个问题
32:18
before the thing?
在事前？
32:19
Yeah.
对。
32:20
This is after the thing.
这是事后的。
32:21
Exactly.
没错。
32:22
Yeah.
对。
32:23
It's a good way to stay grounded off like, do you even know what you're doing, right?
这是个让你保持脚踏实地的好办法，就像，你到底知不知道自己在干嘛，对吧？
32:25
The worst cases when people send you slop and they haven't understood what they're asking
最糟糕的情况就是，别人给你发来一堆垃圾，而他们自己都没搞清楚自己在要求
32:30
for or what the output is and it's like, did I don't want to read this?
什么，或者 output 是什么，然后就像：我是不是不想读这个？
32:33
Do you even know what it is?
你到底知不知道它是什么？
32:35
So you know, you make it a rule for yourself that before you send stuff, you should at
所以你知道，你给自己定个规矩：在把东西发出去之前，你应该至少
32:40
least know what's implemented.
知道到底 implemented 了什么。
32:41
Yes.
对。
32:42
But so you could make this a mod and you could build your own mod to like make sure you
但这样你可以把它做成一个 mod，你也可以自己建一个 mod，来确保你
32:46
test it.
测试它。
32:47
So yeah.
所以，是的。
32:48
All right.
好的。
32:49
Let's get right into it.
我们直接进入正题吧。
32:51
What is Cloud Mod and what is this diagram showing?
什么是 Cloud Mod，这张图在展示什么？
32:54
Yeah.
是的。
32:55
Okay.
好。
32:56
So Cloud Mod is basically, you can customize the entire Cloud Code harness and we're going
所以 Cloud Mod 基本上就是，你可以自定义整个 Cloud Code harness，然后我们打算，
33:00
to, if you have a request, we will like let you, you know, like, please let us know.
如果你有需求，我们就会，就是，让你，你懂的，就是，请告诉我们。
33:05
We'll add more and more.
我们会加越来越多的。
33:06
This works for a CLI.
这在 CLI 上能用。
33:07
It works for desktop.
它在桌面端也能用。
33:09
You will work for Cloud Tag in the future.
以后你会为 Cloud Tag 工作。
33:11
I don't know like, you know, like we're trying to make this very, very extensible.
我不知道，就是，你懂的，我们是想让这个东西非常非常 extensible。
33:14
You can see this reference sheet.
你可以看到这个参考表。
33:15
I don't want people to get overwhelmed by it, you know what I mean?
我不想让大家被它搞得不知所措，你懂我意思吧？
33:19
At a high level, you can customize both the execution of the harness and the UI of the
从 high level 来说，你既可以定制 harness 的 execution，也可以定制 harness 的 UI。
33:26
harness.
所以就像，你说，Boris 那个 Tetris 例子，那其实就是在定制 UI，对吧？
33:27
And so like, you say, and that Tetris example from Boris, that's like customizing the
就像展示，像是，基本上就是在游戏里显示 Tetris，但比如说你想做这件事，就是你之前有，测试你的假设，或者像是测试你的理解
33:31
UI, right?
33:32
Like showing like, like basically Tetris in the game, but like let's say that you wanted
33:38
to do this thing where you had, you tested your assumptions or like tested your understanding
33:45
after every project, right?
每个项目之后，对吧？
33:47
What you would do is you would ask Cloud to make this plugin.
你要做的就是让 Cloud 来做这个 plugin。
33:50
It would spin a classifier after every prompt basically.
基本上，它会在每个 prompt 之后启动一个 classifier。
33:55
And so like at the end of each turn, you would spin off a sub agent or like a forked agent
所以就像在每个 turn 结束时，你会启动一个 sub agent，或者像是一个 forked agent
34:01
basically.
基本上。
34:02
A forked agent is like maintains the prompt cache, right?
一个 forked agent 会维护 prompt cache，对吧？
34:06
So it's like one of the unintuitive things where you can fork and do like a little request
所以这就像是不太直观的事情之一，你可以 fork，然后发一个很小的 request
34:11
and it'll be very cheap because the entire prompt cache is like done.
而且它会非常便宜，因为整个 prompt cache 基本上已经搞定了。
34:15
And so you can be like, has this task been completed like, yeah, the underlying forked
所以你可以说，这个 task 完成了吗，对，那个底层的 forked
34:23
agent.
agent。
34:24
But so you can, in the forked sub agent, you can say like, has this task been completed
但这样你可以在 forked sub agent 里，你可以说，这个 task 完成了吗
34:27
if so, return true.
如果是，就 return true。
34:29
And then in your hook or in your like plugin mod, or sorry, like in the sub agent, probably
然后在你的 hook 或者你的什么 plugin mod 里，或者抱歉，比如在 sub agent 里，大概
34:35
you'd say like, if true, give me a quiz, you know, give me questions and answers.
你会说，如果 true，就给我来个测验，你知道，给我问题和答案。
34:42
And then like in a JSON format, and then you parse it, and then you display above the
然后比如用 JSON 格式，然后你 parse 它，然后你显示在
34:48
prompt input basically, this list of questions, right?
prompt input 上面，基本上，就是这个题目列表，对吧？
34:52
And so this is something that's like slightly token intensive because like, you know, you
所以这个东西会稍微有点 token intensive，因为，嗯，你知道，你差不多得在每个 assistant turn 结束之后都做一遍，但它其实是个轻量级的 classification。
34:56
have to sort of do it after every end of the assistant turn, but it's like a lightweight
然后你就可以，嗯，你知道，拿到这个测验。
35:01
classification.
然后你会发现，就，你知道，cloud 会一直帮你做这件事。
35:02
And then you can like, you know, get this quiz.
你不需要记着去做这件事。
35:05
And then you'll see like, you know, cloud will always do it for you.
我们聊过很多这类小技巧，对吧？
35:08
You don't need to remember to do it.
比如，哦，implementation notes。
35:10
There are lots of these like tips that we've talked about, right?
35:13
Where it's like, oh, implementation notes.
35:15
You can also add a tool for implementation notes now.
你现在也可以加一个 tool 来做 implementation notes 了。
35:17
And so like this tool that I'm adding is like register, like I think assumption is
然后就像，我现在加的这个 tool，有点像 register，我觉得 assumption 是
35:22
what I'm calling it, but like maybe I'll change it around.
我给它起的名字，但就像，也许我会改一改。
35:25
And this is a mod.
然后这是一个 mod。
35:27
And so like you give it a register assumption tool.
所以就像，你给它一个 register assumption tool。
35:30
And then it will keep a list, it'll look every time it does, it'll keep it, like add
然后它会维护一个列表，每次它做的时候都会看，它会把它留着，就像加到
35:34
to the list.
列表里。
35:35
And then at the end, it will display those assumptions, you know, another mod I'm working
然后到最后，它会显示那些 assumptions，你知道，另一个我正在做的 mod
35:40
on is a model router.
on 是一个 model router。
35:42
And so like internal like cloud model routing, right?
所以呢，就像内部的那种 cloud model routing，对吧？
35:45
So this is, I want to say the reason we don't do model routing by default is like, it's
所以这就是，我想说的是，我们默认不做 model routing 的原因，就像，它是
35:49
a hard problem, you know what I mean?
一个难题，你懂我意思吧？
35:51
And like, you will get it wrong.
而且就像，你会搞错的。
35:53
Yeah, you like, yeah, you will like accidentally use like Fable for a hard problem or
是啊，你就像，是啊，你会像不小心用 Fable 去处理一个难题，或者
35:57
I saw it for a while, but you don't have auto mode.
我有一阵子见过它，但你没有 auto mode。
36:00
Well, you will have, like, like, you don't have like auto routing or something.
嗯，你会有，就像，就像，你没有像 auto routing 之类的东西。
36:04
You don't have auto mode for model picker.
model picker 没有 auto mode。
36:06
Yeah, yeah, exactly.
对，对，就是这样。
36:07
Exactly.
就是这样。
36:08
So I'm getting the rough question of like, how much do you open this up?
所以我大概理解到的问题是，你把这个开放到什么程度？
36:12
And how much do people have to think about this?
还有，人们得在多大程度上考虑这件事？
36:13
Like when you talk about prompt caching and building a router, it seems like you could
比如当你聊到 prompt caching 和搭一个 router 的时候，看起来你完全可以
36:18
easily build a mod that routes per query.
很容易就做一个按 query 来路由的 mod。
36:22
And I'm just killing my plan very fast, right?
而且我这不是很快就把自己的计划给毁了吗，对吧？
36:24
I guess my question is more so like, what is like a product doc like this look like,
我想我的问题更像是，像这样一份 product doc 大概长什么样，
36:29
right?
对吧？
36:30
Who is it for?
它是给谁用的？
36:31
Is it for power users?
是给 power users 用的吗？
36:32
Is it everyone should be able to definitely power users, right?
是所有人都应该能用吗？肯定得是 power users，对吧？
36:35
Yeah, I mean, I think it is power users, but like the nature of cloud code is like so many
对，我是说，我觉得确实是 power users，但 cloud code 的性质就是，有太多
36:39
people are power users, you know, because it's easy to share things, you know, like you
人都是 power users，你知道，因为很容易分享东西，你知道，就像你
36:43
can, like one person can make a good model router thing that doesn't break prompt cache
可以，比如一个人可以做出一个很好的 model router 之类的东西，还不会破坏 prompt cache
36:47
all the time.
一直都可以。
36:48
And then you can like, you know, sort of compose them.
然后你就可以，嗯，你懂的，差不多把它们 compose 起来。
36:51
They're cool thing about the plugins that they can hook into and compose with each other.
plugins 很酷的一点是，它们可以 hook into 彼此，并且互相 compose。
36:55
And so I have like a mod that will like create a mode selector at the top.
所以我有个 mod，差不多会在顶部创建一个 mode selector。
37:03
And any plugins can register to be a mode.
而且任何 plugins 都可以注册成一个 mode。
37:06
And so like the outer router can be a mode, right?
所以，比如外层的 router 就可以是一个 mode，对吧？
37:10
Or like, you can have a mode that's like artifact mode where it's like it primarily talks
或者，比如你可以有一个 mode，类似 artifact mode，它主要就是跟你
37:14
to you and artifacts.
和 artifacts 聊。
37:15
It's kind of like, you know, you, you can toggle between plan mode, you know what I mean?
就有点像，你知道，你，你可以在 plan mode 之间切换，你懂我意思吧？
37:19
So like you can create more and more case modes, but the ability to create modes is in
所以就像你可以创建越来越多的 case modes，但创建 modes 的能力本身
37:24
itself a mod, you know?
就是一个 mod，你知道吧？
37:27
And so there's a lot of richness here, but we do want to make it fairly easy.
所以这里面有很多丰富性，但我们确实想让它变得相当容易。
37:30
We want to be make it so that you can just like install someone else's you can, you
我们想让它变成，你可以直接安装别人的，你可以，你
37:35
can chat with cloud and, you know, will like make sure that it understands the nuances
可以跟 cloud 聊天，而且，你知道，会确保它理解其中的细微差别
37:40
of things like prompt caching and stuff so it can like warn you.
比如 prompt caching 之类东西的，这样它就能提醒你。
37:43
This is like not extremely complicated behavior for cloud, I think, but we should have
我觉得，这对 cloud 来说不算特别复杂的行为，但我们应该有
37:48
just a good skill on how to make mods.
就是一个关于怎么做 mods 的好技能。
37:52
And yeah, we'll see how we go.
然后，嗯，我们就看看进展如何吧。
37:53
But I do think that this is like a preview of like mutable software, you know?
但我确实觉得，这有点像 mutable software 的一个预览，你知道吧？
37:59
And like how like a generative software just like you can customize safely, if enabled
而且就像 generative software 那样，你可以安全地自定义，如果启用的话
38:06
you can customize any piece of software.
你就能自定义任何一款 software。
38:08
And I think that more and more apps ideally do something like this, you know?
而且我觉得，理想情况下，越来越多的 apps 都会做类似这样的事，你知道吧？
38:13
And by the way, we have you have another cool tweet about how, you know, there's the infinite
顺便说一句，你还有另一条很酷的推文，讲的是，你知道，有一个 infinite
38:17
money button, which is like, make your SaaS consumable by agents.
money button，就是说，让你的 SaaS 能被 agents 消费。
38:21
I think mutable software is interesting and, you know, other people have also tried to
我觉得 mutable software 挺有意思的，而且，你知道，其他人也试着
38:26
do it.
做过。
38:27
I think the hurdle comes when you can do everything then people users tend to get confused.
我觉得难点在于，当你什么都能做的时候，用户往往会搞不清楚。
38:33
So usually the stuff that works is just like one opinionated flow.
所以通常能行得通的东西，就像是一个 opinionated flow。
38:37
This is in the side of less opinionation is just like more power to power users.
这其实是在更少 opinionation 的那一边，也就是给 power users 更多权力。
38:42
And I think probably unlocked by AI where like you can just prompt for whatever the thing
而且我觉得这大概会被 AI 解锁，因为你可以直接 prompt 出你想要的那个东西
38:46
is.
是什么。
38:47
Yeah, or there can be a skill that gives the opinions, you know, and then, yeah.
对，或者可以有一个 skill 来提供那些 opinions，你懂的，然后，对。
38:51
So knowing a little bit about like TypeScript and build systems and all these things, the
所以，稍微了解一点 TypeScript 和 build systems 这些东西之后，最接近的，其实我特别好奇，做这个的团队——我不知道你跟他们合作得有多紧密——他们有没有从像 Babel、Webpack 这些 build systems，所有这些老派的东西里得到灵感，因为听起来非常像那些东西的 plug-in ecosystem，可以互相组合。
38:55
closest, I'm actually very curious that the team who works on this, if I don't know how
对，我是说，我对技术细节不是很深入。
38:58
close you work to them, if they drew any inspiration from build systems like Babel, Webpack, all
我确实知道的是，这是和 bun team 的某个人以及 cloud code team 的某个人合作。
39:04
these, all these like old school things, because it sounds very similar like the plug-in
39:09
ecosystem of those things where they can compose to each other.
39:11
Yeah, I mean, I'm not deep in the technical details.
39:13
If I do know is a collaboration with someone on the bun team and someone on the cloud
39:17
code team.
39:18
Yeah.
嗯。
39:19
Build system.
Build system。
39:20
Yeah.
对。
39:21
Exactly.
没错。
39:22
It's very exciting.
这真的很让人兴奋。
39:23
But yeah, like agents can just do this very complicated sort of like extensibility into
但，嗯，agents 现在就能把这种非常复杂的、有点像 extensibility 的东西直接做进
39:26
your software now.
你的 software 里了。
39:28
And so yeah, like, you know, another reason to like, if you run a startup, like, you can
所以，嗯，你知道，另一个理由就是，如果你运营一家 startup，你可以
39:33
just prompt cloud and be like, hey, like could we make an extension system?
就直接 prompt cloud，然后说，嘿，我们能不能搞个 extension system？
39:36
Like, whoa, that looked like, you know, and I just really wanted to like, you had hooks
就像，哇，那看起来就像，你懂的，而且我真的特别想要，像，你以前有 hooks
39:40
in the past and plug-ins all these things.
还有 plug-ins 这些所有的东西。
39:42
So what specifically were mods be able to do that those things could not do?
所以具体来说，mods 能做什么是那些东西做不到的？
39:47
Internally, we were originally calling this function hooks.
在内部，我们最初把这叫做 function hooks。
39:49
And so like, that's like, gives you a little bit of an idea where like hooks sort of register
所以就像，这有点像给你一点概念，就是 hooks 有点像是 register
39:55
a like an event to happen and then like a script to call basically.
一个 event，让它发生，然后基本上就是调用一个 script。
40:00
And this basically inside of the like, TypeScript runtime is running things.
而这基本上是在，就像，TypeScript runtime 里面跑东西。
40:07
And so like, you get some benefits of just like, it has a bunch of things in the scope
所以呢，就像，你能得到一些好处，就像，它的 scope 里有一堆东西
40:12
with like, for example, like, how many turns is in this conversation, right?
比如说，像，这次对话里有多少 turns，对吧？
40:16
Like, how many tokens have been used, like, except like, what are the messages, things
就像，用了多少 tokens，像，还有像 messages 是什么，这类东西
40:19
like that?
之类的？
40:20
So it has a bunch of messages that can be used.
所以它有一堆可以用的 messages。
40:21
And then it's just like a lot more hooks basically.
然后基本上它就只是多了很多 hooks。
40:24
So we have, you know, like, or a lot of a lot more like, you know, fun, like things you
所以我们有，你知道，就像，或者很多很多，就像，你知道，好玩的，像，你可以
40:28
can register on.
register 上去的东西。
40:30
And then you can do because of the, because it's all happening in process, you can spawn
然后你就可以做，因为，因为这一切都是在 in process 里发生的，你可以 spawn
40:35
sub agents, you know, with four contests and context and stuff.
sub agents，你知道，带着四个 contests 和 context 之类的。
40:39
And like, that will return and you can parse the results of those.
然后呢，那会返回，你可以 parse 那些结果。
40:42
You can, you structured output to sort of like, return them.
你可以，你用 structured output 来差不多，返回它们。
40:46
And then you can modify the UI, which you can never do in, in hooks.
然后你就可以修改 UI，这是你在，在 hooks 里永远做不到的。
40:50
Yeah.
对。
40:51
Yeah.
对。
40:52
Yeah.
对。
40:53
So modify UI.
所以修改 UI。
40:54
This is why you should attach your example.
这就是为什么你应该附上你的例子。
40:55
Does it also extend to artifacts?
它也会扩展到 artifacts 吗？
40:56
I assume it does.
我觉得会。
40:57
You, like, artifacts are kind of like a different way of customizing it.
你，就像，artifacts 有点像是一种不同的定制它的方式。
41:00
You know, like, you can definitely, one of the mods I'm working on is like this dashboard
你知道，就像，你绝对可以，我正在做的其中一个 mods 就像这个 dashboard
41:04
mod, which will like sort of prompt, clawed to maintain the dashboard.
mod，它会有点像 prompt、clawed 来维护 dashboard。
41:09
That's an artifact.
那是一个 artifact。
41:11
But they're kind of like slightly orthogonal or not orthogonally, they'd be composed with
但它们有点像是稍微 orthogonal，或者不是以 orthogonal 的方式，它们会以不同方式彼此组合，比如 mods 更像是在你的 cloud code harness 里，改的是 agent loop，你懂的，而 UI 就像个额外的好处。
41:15
each other in different ways, like mods are like a little bit more like in your cloud
然后 artifacts 就只是，你想要，你懂的，从 high level 看事情，完全可交互，你懂的，affordances 可以大得多，比你懂的，像 two E，甚至比我们 desktop guessing 里的都大。
41:20
code harness, changing the agent loop, you know, and like the UI is like an added benefit.
你会有一篇很好的 blog post 来写这些区别，因为现在你也可以，你懂的，做一个能输出到 artifact 的 loop。
41:28
And then artifacts are just like, you want to, you know, see things at a high level,
41:33
be entirely interactive, you know, like the affordances can be a lot bigger than, you
41:38
know, like a two E or even in our desktop guessing.
41:41
You'll have a good blog post on the differences because right now you can also, you know, make
41:45
a loop that outputs to an artifact.
41:49
That's an interactive dashboard.
那是个交互式 dashboard。
41:50
But you can also do it with a mod.
但你也可以用 mod 来做。
41:52
There's just some thinking about making a hack, hacking on a harness when we don't know
只是会有些思考，比如要搞个 hack、在一个 harness 上 hack，可我们并不了解
41:59
much about the harness, right?
太多关于 harness 的东西，对吧？
42:00
Well, something I'm excited about with mods is like, there's so much things
嗯，我对 mods 很兴奋的一点是，就像，有太多东西
42:03
of cloud code that you just have to remember, you know, you're like, oh, like let me do
是 cloud code 里你必须要记住的，你知道，你会想，哦，让我来做
42:07
this.
这个。
42:08
And then let me call the dashboard skill that does the loop and things like that.
然后让我调用 dashboard skill，它会做 loop 之类的事情。
42:11
And or like let me test my assumptions afterwards.
然后，或者，让我之后再验证一下我的假设。
42:13
And I think like if you do all of these things using these little class fires and stuff,
而且我觉得，如果你用这些小小的 class fires 之类的来做所有这些事情，
42:18
and you're like, these are things I care about.
然后你会想，这些是我在乎的事情。
42:20
This is what I want to do.
这就是我想做的事。
42:22
You can like, you don't have to remember as much.
你就可以，不用记那么多东西了。
42:25
One more like mod I'm working on is a next steps mod that I was going to say I have a
还有一个我正在做的 mod，是一个 next steps mod，我本来想说，我有一个
42:30
next step skill.
next step skill。
42:31
I always run next steps.
我总是会跑 next steps。
42:32
And does it have access to your skills?
那它能访问你的 skills 吗？
42:35
Like this is one of those things where I'm like, I think so.
就像这种事，我会想，应该是吧。
42:38
Okay.
好。
42:39
Yeah.
嗯。
42:40
I need specific access to skills.
我需要能具体访问 skills 的权限。
42:41
Well, I think there's always I think there's like specific prompting I guess to like
嗯，我觉得总是有，我觉得就是有特定的 prompting，我猜，就像要
42:45
know your skills kind of like like I think cloud forget stem sometimes throughout like the
了解你的 skills，有点像是，我觉得 cloud 有时候在整个过程中会忘了 stem，就像那个
42:50
thing.
东西。
42:51
But anyways, the idea of like, yeah, next steps that also are like, oh, hey, this has happened.
不过反正，就是那种，对，下一步，同时也像是，哦，嘿，这事已经发生了。
42:58
Just explain skill to explain to you what happened because this seems like quite complex, you
就直接解释一下 skill，来给你解释发生了什么，因为这事儿看起来挺复杂的，你懂的，或者就像，对，用你那个 unknown skill。
43:02
know, or like, yeah, use your unknown skill.
看起来你像是在让 model，你懂的，去在这些小改动上迭代。
43:06
It looks like you are like asking the model to like, you know, iterate on these small
看起来你其实可以更好地 prompt，你懂的，比如说，要是你这么做呢，对吧？
43:12
changes.
所以就像，我觉得，对，就是在那儿多花点 compute。
43:13
It seems like you could prompt better, you know, like what if you did this, right?
对。
43:15
So like, I think, yeah, like spending more compute there.
43:19
Yeah.
43:20
And it should always come out as multiple choice.
而且它应该总是以选择题的形式输出。
43:22
We have we have I have my next step skill is like this.
我们有，我们有，我有，我的下一步 skill 是这样的。
43:25
Okay.
好。
43:26
Perfect.
完美。
43:27
Yeah.
嗯。
43:28
Yeah.
嗯。
43:29
But like, for me, it's all I think models really always need to be reminded what are you trying
但就像，对我来说，这一切，我觉得 models 真的总是需要被提醒：你到底想
43:34
to do here?
在这里做什么？
43:35
Yeah.
嗯。
43:36
Look at the whole transcript and go like, what was this original goal?
把整个文字稿看一遍，然后想：最初的目标到底是什么？
43:39
Did your solution actually solve it?
你的方案真的解决了它吗？
43:41
Were you lazy?
你是不是偷懒了？
43:42
If you're lazy, maybe there's a reason.
如果你偷懒了，也许是有原因的。
43:44
Maybe you needed approval from me.
也许你需要我的批准。
43:45
Maybe you needed.
也许你需要。
43:46
There's two things you want to suggest.
有两件事你想建议。
43:48
So it's a little bit like the modification of the ask you the question or interview me
所以这有点像是对“问你问题”或者“采访我”这个 skill 的修改。
43:53
skill.
所以这就是接下来的步骤。
43:54
So it's next steps.
对。
43:55
Yeah.
对。
43:56
Yeah.
用 mods 来做的好处是，你可以把它作为一个 fork sub agent 来做。
43:57
The benefit of doing it with mods is you can do it a fort sub agent.
这样之后它就不会留在 context 里了。
44:00
And so it doesn't remain in the context afterwards.
所以你会有这种想法，就是：好吧，模型正在做它的 execution。
44:03
So you have this like idea of like, okay, the model is doing it's execution.
44:07
And you have this almost like supervisor, you know, like, that is like making sure that
而且你有这么一个几乎像 supervisor 的东西，你知道，就像，它能确保
44:12
you can do like the next step as well.
你也能做下一步。
44:14
Yes.
对。
44:15
Yes.
对。
44:16
I do have two panels and I often try to have a supervisor thing keep the high level context
我确实有两个 panel，我经常试着让一个 supervisor 之类的东西保留 high level context
44:20
and then the implementation.
然后 implementation。
44:21
Yeah.
嗯。
44:22
Detail in the other agent.
细节在另一个 agent 里。
44:23
I feel like a lot of this abstracts away as models change, you know, the half an hour
我觉得，随着模型变化，这里面很多东西都会被抽象掉，你知道，半小时
44:29
ago, you said bitter lesson of harness engineering and we're on the other extreme right now.
前，你说过 harness engineering 的 bitter lesson，而我们现在正处在另一个极端。
44:33
I feel well.
我感觉挺好。
44:34
So yeah, exactly.
所以，对，就是这样。
44:35
If everything's customizable, what actually is cloud could, right?
如果一切都是可定制的，那到底什么才是 Claude Code，对吧？
44:37
And which I talked to you about last night.
而且这件事我昨晚也跟你聊过。
44:40
Yeah.
嗯。
44:41
I mean, I think that this is I think the bitter lesson is unintuitive, you know, I mean,
我是说，我觉得这个……我觉得 bitter lesson 是反直觉的，你知道，我是说，
44:45
in terms of like I also like we're kind of misusing a little bit of the bitter lesson
就这方面来说，我也觉得，我们有点在稍微误用 bitter lesson
44:48
here where it's like, it's more about like scaling and compute and stuff.
在这里，它更像是关于 scaling 和 compute 这些东西。
44:52
Like I think there is something where it's just like, I think I use it as an approximation
就像我觉得，这里面有个点，就是，我觉得我是把它当成一种 approximation 来用
44:57
here to say that harnesses go out of date very quickly, you know what I mean?
在这里是说 harness 会很快过时，你懂我意思吧？
45:00
And like how, but how they change is unintuitive, you know, and so like the big obvious example
而且就像，怎么说呢，它们变化的方式很不直观，你知道吗，所以最明显的一个例子
45:06
is like from chat to like agents where you had to give them entirely new tools, right?
就是从 chat 到 agents，你得给它们全新的 tools，对吧？
45:12
But like I think this new version of like, oh, it can modify its own harness, right?
但就像，我觉得这个新版本，就是，哦，它能修改自己的 harness，对吧？
45:15
This is like an own harness loop is like a way of using its capabilities, right?
这就像是一个 own harness loop，是一种利用它自己能力的方式，对吧？
45:21
Or like it can build an artifact.
或者就像，它可以构建一个 artifact。
45:23
And like I think the way I think about it is like, the models have more and more intelligence
而且就像，我对此的思考方式是，这些 models 拥有越来越多的 intelligence
45:27
and they're like so much more intelligent now than like the average software engineering
而且它们现在比一般的 software engineering
45:31
task.
task 要聪明太多了。
45:32
Like you look at the like terminal bench ones and they're like, solve like the Jacobian
就像你看那些 terminal bench 的，它们就像在解决 Jacobian
45:36
contract.
contract。
45:37
Not really, but like, you know, it's like, they're, they're quite complex.
其实也不是，但就像，你知道，它们，它们其实挺复杂的。
45:39
Like I would not have been able to do this really as a software engineer.
就像，作为一个 software engineer，我其实真的做不了这个。
45:41
Yeah.
嗯。
45:42
And you looked at TV four or TV three.
而且你看了 TV four 还是 TV three。
45:43
TV three.
TV three。
45:44
Yeah.
嗯。
45:45
They're quite complex, but the goal is still to deliver user value, right?
它们挺复杂的，但目标还是交付用户价值，对吧？
45:48
And like you said, there's like this infinite space of things to do.
而且就像你说的，可做的事情简直是无穷无尽。
45:51
And so the ways like you spend compute or keep the user on the loop and make sure that
所以这些方式，比如你怎么花 compute，或者怎么让用户留在 loop 里，并确保
45:56
like you're getting to the right decision in the end of the day and like the right output.
就是最终你能做出正确的决定，也能得到正确的 output。
46:01
And artifacts and mods are this way of like spending that intelligence basically.
而 artifacts 和 mods，基本上就是这种把智能花出去的方式。
46:07
And I think that's like, yeah, the next step.
而且我觉得这就像，对，下一步。
46:10
And so yeah, I think cloud code is like, you know, has the core things of agent loop
所以对，我觉得 cloud code 就像，你知道，有 agent loop 的那些核心东西
46:14
jar have gotten more complicated.
jar 已经变得更复杂了。
46:16
It's like, you know, it needs a sandbox to operate safely needs auto mode to like make
它就像，你知道，它需要一个 sandbox 来安全运行，需要 auto mode 来像是确保
46:20
sure like the permissions, yeah, approvals.
像 permissions 这些，对，approvals。
46:23
It needs computer use and MCPs and like all of these like ways of accessing your data.
它需要 computer use 和 MCPs，还有所有这些像是访问你数据的方式。
46:30
And it needs web search and web page and like so the as the models can do more and more,
而且它需要 web search 和 web page，还有就像，所以随着 models 能做的越来越多，
46:35
the core harness has to be actually like quite complex and very secure.
core harness 其实得相当复杂，而且非常安全。
46:39
But then like how you interact with it can change quite a lot.
但然后，怎么说呢，你和它交互的方式可以变化挺大的。
46:42
What other harness engineering best practices have you, you know, from the cloud code team
你们从 cloud code team 本身那里，还有哪些其他的 harness engineering best practices，你知道？
46:47
itself?
我感觉，你知道，之前有个 plan mode 的阶段，但没那么常用了。
46:48
I feel like, you know, there was a phase of plan mode, which is not as used.
我们现在有 auto mode，到了某个点，你把大部分 system prompt 都砍掉了。
46:52
We now have auto mode at a point you cut the majority of the system prompt.
你把 examples 去掉了，但 harness engineering 的那些 best practices 还在。
46:57
You got rid of examples while their best practices are there for harness engineering.
我觉得，好像有一个 forking path，到某个时候，最终，是的，model 会……
47:02
I think there is like a forking path where at some point eventually, yes, the model will
47:07
just be able to like vibe code the exact version of cloud code, even describing all this
就能直接 vibe code 出 cloud code 的确切版本，甚至描述所有这些
47:12
complexity that I've talked about right, like auto mode and computer use and stuff, eventually
我刚才聊到的那些复杂度，对吧，比如 auto mode、computer use 之类的，最终
47:16
the models will just be able to do that in one shot.
模型就能直接 one shot 把它们搞定。
47:20
But I think they can one shot simpler harnesses, you know, and so like I think some people,
但我觉得它们可以 one shot 更简单的 harness，你懂的，所以我觉得有些人，
47:25
sometimes you don't need this full, like if you don't need computer use or like all
有时候你不需要这么完整的，比如如果你不需要 computer use 或者所有
47:29
this like more complicated stuff, I think before we had to sort of use things like the
这些更复杂的东西，我觉得以前我们得用类似
47:34
agent SDK, which was like cloud code wrapped, you know, in order to like, and I would suggest
agent SDK 这样的东西，它就像是把 cloud code 封装起来，你懂的，为了能这样，而且我会建议
47:41
people do that because there was so much complexity into building a harness and now that's
人们那样做，因为构建 harness 有太多复杂度了，而现在这
47:45
got more abstracted, we have like a cloud management agents, which lets you have that complexity,
变得更抽象了，我们有类似 cloud management agents 这样的东西，能让你拥有那种复杂性，
47:51
but still like, you know, right, like a very bare bones like harness that's scoped to your
但还是，你知道，对吧，就像一个非常精简的 harness，范围只限定在你的
47:57
task.
任务上。
47:58
Yeah, I think there's like this barbell effect where like, you know, like for like very complex
对，我觉得有这种 barbell effect，就像，你知道，对于那种非常复杂的
48:02
for like coding tasks and like these like complex things, you should use our harness.
比如说 coding tasks 和这些复杂的东西，你应该用我们的 harness。
48:07
And then for like a lot of like simpler or like, you know, more domain specific things,
然后对于很多更简单的，或者，你知道，更 domain specific 的东西，
48:12
you can build your own harness because cloud has gotten better at building harnesses and
你可以构建自己的 harness，因为 cloud 在构建 harness 方面已经变得更好了，而且
48:15
we have these harness primitives like manage agents.
我们有这些 harness primitives，比如 manage agents。
48:17
So yeah.
所以呢，对。
48:18
Yeah.
对。
48:19
Is there a general progression?
有没有一个大致的演进过程？
48:21
Let's say chapter one was ultra code dynamic workflows, then chapter two was cloud mods.
比如说第一章是 ultra code 动态工作流，然后第二章是 cloud mods。
48:27
Where is this going?
这接下来会往哪走？
48:29
Where you're, you know, you can sort of customize the thing on demand.
就是你可以，你知道，按需定制这个东西。
48:36
Yeah, I do think that like this evolution of projects and like sort of artifacts and splitting
对，我确实觉得这种项目还有各种 artifact 的演进，以及把 brain、hands 和 surfaces 拆分开来，差不多就是未来更可能的发展方向。
48:42
out like brain and hands and surfaces kind of is like where things are going more.
48:48
And like, I think it's like not all quite there.
而且，我觉得，它好像还没完全到位。
48:51
Partially, it's like a just like more token expensive, you know, and like,
有一部分是，它就像是，嗯，更费 token，你知道吧，而且，
48:57
I think like, where would projects be more token expensive?
我觉得，嗯，项目会在哪些地方更费 token 呢？
49:01
I understand mods would be slightly more token expensive, not not not not something I'm worried about.
我明白 mods 会稍微更费 token，不是不是不是不是我担心的事。
49:06
Yeah.
对。
49:07
But what you're asking cloud to do, it's like creating loops, like you're asking cloud to do more work
但你在让 cloud 做的事，就像是在创建 loops，像是你在让 cloud 做更多的工作
49:11
for you.
为你而做。
49:12
And so like it's managing the sub agents and reviewing it, you know, versus where you would be doing
所以，就像它在管理 sub agents 并 review 它，你知道吧，而不是由你来做
49:16
that work normally.
那些能正常工作的。
49:17
And so that's like going to be a little bit more intensive like, opening to an artifact is going
所以那会稍微更 intensive 一点，就像打开一个 artifact 会
49:21
to be a little bit more token intensive than like, you know, outputting normally.
比，你知道，正常输出要稍微更 token intensive 一些。
49:25
I don't actually think it's too much more, but like, you know, it's like combining all of these
我其实不觉得会多太多，但就像，你知道，这就像把所有这些
49:30
together well, you know, like I think we're still working on like local hands and things like that.
结合在一起，嗯，你知道，我觉得我们还在搞像 local hands 之类的东西。
49:33
I think it's like, yeah, where things are had to do.
我觉得就像，对，就是那些事情必须得做的地方。
49:37
Yeah, cloud and local is handoff is very interesting.
对，cloud 和 local 之间的 handoff 很有意思。
49:41
I was thinking about this actually as reverse cloud remote because it's like remote that's
我其实在想这个，把它当作 reverse cloud remote，因为它就像是那种 remote，那种
49:46
you're heading off to cloud, but here cloud is heading off to local, right?
你正转向 cloud，但在这里，cloud 正转向 local，对吧？
49:49
Yeah, exactly, exactly.
对，没错，没错。
49:50
Yeah, remote control is also another way of doing it.
对，remote control 也是另一种做法。
49:52
I do want to say this is kind of like how I think about it and like the things that I'm most
我确实想说，这有点像我对它的思考方式，也像是我最
49:56
excited about this, but like there are, you know, just like lots of different ways to work with
对这件事感到兴奋的地方，但是，你知道，就像有很多不同的方式去和
50:01
clouds, like some people use remote control a lot.
clouds 打交道，比如有些人很常用 remote control。
50:02
Some people use cloud code on the web a lot.
有些人很常在 web 上用 cloud code。
50:05
Obviously like an anthropically is called tag a lot, you know, and like what's great about
显然，就像 anthropically 经常被叫做 tag，你知道，而且就像，很棒的地方是
50:08
cloud tags, we set up all this stuff for our own execution.
cloud tags，我们搭这一整套东西都是为了我们自己的 execution。
50:12
And I do think if you're an enterprise, that's still the best way to go.
而且我确实觉得，如果你是企业，那仍然是最好的做法。
50:15
But if you're like an individual project is this way of like, you know, getting some of that
但如果你是一个个人项目，这种方式就是，你知道，能获得一些那种
50:21
like niceness of tag, which has like that like supervising agent and adding artifacts and stuff,
tag 的好处，就是有那种 supervising agent，还能加 artifacts 之类的，
50:27
but like without having that whole like admin setup.
但又不用搞那一整套 admin setup。
50:30
And so there will be many ways to use cloud.
所以使用 cloud 会有很多种方式。
50:33
I think I think it's probably not just one like single.
我觉得，我觉得这大概不会只是单一的一种。
50:36
You had the multiplayer thing here.
你这里有 multiplayer 那个东西。
50:37
Let's just check in on cloud tag.
我们来看看 cloud tag 的情况。
50:39
You know, it's been about two, two plus months, lots of public adoption and trying it out.
你知道，已经差不多两，两个多月了，很多人都在公开使用和尝试。
50:45
Yeah, what's new, what's what have you found since the launch?
是啊，有什么新东西，从发布到现在你们发现了什么？
50:49
Like, cloud tag is how we use, it's like 80% of your cloud usage isn't?
比如说，cloud tag 就是我们的用法，它差不多占你 cloud usage 的 80%，对吧？
50:52
Yeah, like it's like different people have different usages.
是啊，就像不同的人有不同的用法。
50:56
You know, I mean, I think like maybe people who are like a little bit more like iterating on
你知道，我是说，我觉得可能那些稍微更偏向于迭代产品的人
51:01
product would use like cloud code desktop, for example.
会用 cloud code desktop，比如。
51:04
And then like when you're doing these more like background work,
然后，比如当你在做这些更像后台工作的事情时，
51:08
code review, security sort of like starting a PR like maybe more like API and things like that,
code review、security，有点像开一个 PR，可能更像是 API 这类东西，
51:14
you'd use cloud tag.
你会用 cloud tag。
51:15
Yeah, I think it's like real exciting.
对，我觉得这真的挺让人兴奋的。
51:16
I think it's like a very different paradigm shift.
我觉得这像是一个非常不同的 paradigm shift。
51:19
And I think like we're really like, it has kind of that thing with cloud code where like,
而且我觉得，我们真的有点像，它有点像 cloud code 那种情况，就是，
51:23
you know, it took a while for people to really latch on to cloud code and understand
你知道，人们花了一段时间才真正接受 cloud code，并理解
51:27
everything it could do.
它能做的一切。
51:28
And cloud tag is a little bit more complex because it's not just like installing on your computer.
而 cloud tag 稍微复杂一点，因为它不只是像装到你电脑上那样。
51:32
Like you need an admin to install it for you.
就像你得让 admin 帮你安装它。
51:34
But I think once you get to the magic moment, it's very exciting.
但我觉得一旦你到了那个神奇的时刻，就会非常兴奋。
51:37
And I think in particular, the multiplayer things are like incidents,
而且我觉得特别是，multiplayer 的那些东西就像 incidents，
51:41
hooking into like your, you know, existing like alerts and things like that very closely.
很紧密地 hook 进你现有的，你知道，alerts 之类的东西。
51:47
Right. And so, you know, you can do, if you restart it, for example, maybe you have
对。所以，你知道，你可以做，比如说如果你重启它，也许你有
51:52
anytime like a prospect enters your database, you can have cloud like, you know, research it
任何时候，比如有潜在客户进入你的 database，你可以让 cloud，你知道，去研究它
51:59
and like, uh, yeah, yeah, yeah, yeah.
然后就像，呃，对对对对。
52:02
Then like, you know, tag the relevant like a your salesperson to be like, oh, hey, like,
然后就像，你知道，tag 一下相关的，比如你的销售，跟他说，哦，嘿，就……
52:07
you know, do this.
你懂的，做这个。
52:08
There's lots of really emergent interesting multiplayer stuff.
有很多非常 emergent、特别有意思的 multiplayer 东西。
52:11
I think it's just like, compared to you talked about this like as an organizational harness,
我觉得吧，跟你把这个说成一种 organizational harness 相比，
52:15
you know what I mean?
你懂我意思吧？
52:15
And so organizations just take a little bit more time to like figure everything out.
所以组织就是需要多花一点时间，才能把这些都弄明白。
52:20
But yeah, there's a lot of cloud tag.
但没错，有很多 cloud tag。
52:22
Yeah.
对啊。
52:23
It's an interesting one.
这个挺有意思的。
52:24
I feel like most people at Anthropics say they do the majority if they're working cloud tag.
我感觉 Anthropics 的大多数人都说，要是他们在搞 cloud tag，那大部分活都是他们干的。
52:29
Yeah.
对。
52:30
And I have buckets of people, right?
而且我这儿有一大堆人，对吧？
52:32
Some orgs that are on it that are like, it's great.
有些组织已经在用了，他们会说，这太棒了。
52:34
And a lot of people that are like, I don't get it.
但也有很多人是，我搞不懂。
52:36
I don't see the difference.
我看不出区别在哪。
52:37
I don't know why I would use it.
我不知道我为什么要用它。
52:38
But you know, if you guys are full-sending, you should probably use it.
但你知道，如果你们是全力投入，那大概就应该用它。
52:41
Yeah.
嗯。
52:42
You know, of course they would use it.
你知道，他们当然会用啊。
52:44
Yeah.
对。
52:44
I mean, I think obviously like we have lots of tokens.
我是说，我觉得很明显，就是我们有好多 tokens。
52:47
And but like, I think that like, you know, what we try and do like, like is,
而且但是，就是，我觉得，你知道，我们试着去做的，就是，
52:52
I mean, even when cloud code first came out, you know, like it used to, a lot of tokens relative
我是说，就算 cloud code 刚出来的时候，你知道，就是它以前，很多 tokens，相对于
52:56
to people's expectation of how much AI would cost, right?
人们对 AI 要花多少钱的预期，对吧？
53:00
Like, no one was used to spending more than 20 bucks a month, right?
就是，没人习惯一个月花超过 20 美元，对吧？
53:04
Yeah.
嗯。
53:04
Before like, cloud code came out and then you're like, oh,
之前就是，cloud code 还没出来的时候，然后你就会，哦，
53:07
like, you know, like, you might 200.
就是，你知道，就，你可能就得花 200。
53:09
Yeah, yeah, exactly.
对，对，没错。
53:10
And so like 15 cloud code accounts.
然后就大概有 15 个 cloud code 账号。
53:12
Yeah.
嗯。
53:12
Yeah.
嗯。
53:14
But yeah, I think no one was used to spending $200 a month on subscriptions.
但就是，我觉得没人习惯每个月在订阅上花 200 美元。
53:18
I don't think it understood like the value yet.
我不觉得它已经理解到那种价值了。
53:20
And I think like, and also like, Opus 4 was a very expensive model.
而且我觉得，嗯，还有，Opus 4 是一个非常贵的 model。
53:23
You know, and like, there was a lot, very big.
你知道，而且，当时有很多，非常大。
53:25
But Opus 4.5 was both great and cheap, you know?
但 Opus 4.5 又好又便宜，你知道吗？
53:29
I think the same thing will happen.
我觉得同样的事情也会发生。
53:30
Like the, like, intelligence of Fable will get cheaper and cheaper and more abundant, you know?
就像，那个，Fable 的 intelligence 会越来越便宜，越来越丰富，你知道吗？
53:35
And so I think stuff like cloud pack will just make sense.
所以我觉得像 cloud pack 这种东西就会很合理。
53:38
Where like, you want to spend these tokens more, you know?
就是那种，你会想在这些 tokens 上花得更多，你知道吗？
53:41
And like, you'll see the value.
然后你就会看到它的价值。
53:43
So yeah.
所以，嗯。
53:44
Yeah, especially like passive and let's call it proactive cases where you're not always,
对，尤其是那种被动的，还有咱们姑且称之为主动的情况，就是你并不总是，
53:50
like, you know, it's almost like the misnomer where you have to add cloud to do things.
就像，你知道，这几乎是个误称，好像你必须加上 cloud 才能做事。
53:54
Actually, sometimes like the most powerful use cases on the most
其实，有时候最强大的 use case，恰恰是在最
53:57
AGI build use cases is not at cloud.
AGI 构建的 use case 上，并不是在 cloud 上。
54:00
Yeah.
对。
54:01
I mean, I think like yeah, like have cloud proactively do it.
我是说，我觉得，对，就让 cloud 主动去做吧。
54:04
I think that like, if you're an enterprise, I really do think that number one,
我觉得，就是，如果你是一个企业，我真的觉得，第一，
54:08
setting up all your data to be available to like agents is really, really important.
把你所有的 data 都设置好，让 agents 能用上，真的真的非常重要。
54:13
And it will take some time.
而且这得花点时间。
54:14
You have to like, do that work right now.
你得，就是，现在就得做这个工作。
54:15
Even if you don't want to do this spend on like, cooking it all yet, you know?
就算你还不想要现在就花这个钱，把它全都搞起来，你知道吗？
54:19
I mean, like, you want to wait until the models get a little bit cheaper.
我是说，就是，你想等到 models 变得便宜一点。
54:22
You want to do the work, you know, to get it like set up.
你想先把该做的工作做了，你知道吧，把它设置好。
54:26
And then I think sometimes people are like, do I roll my own here?
然后我觉得，有时候人们会想，我要不要自己搞一套？
54:30
You know, and I think like one of the really thing tricky things about cloud tag
你知道，而且我觉得，cloud tag 真正棘手的一个点就是
54:34
is that like the security is really, really important.
就是，安全真的、真的特别重要。
54:37
You know, I mean, like I think there are actually a lot of ways where you can like, I don't know,
你知道，我是说，比如我觉得其实有很多种方式，你可以，就，我也不知道，
54:41
you have like a suggestions like page, you know, where people can submit suggestions
比如你有个建议页面，你知道，人们可以在那儿提交建议
54:46
and that goes into a hook in your slack and someone's prompt injected it.
然后这会进到你 Slack 里的一个 hook，然后有人对它做了 prompt injection。
54:50
You know, I mean, and now you've like exfiltrated your code base out because
你知道，我是说，然后现在你就把你的 code base 给 exfiltrate 出去了，因为
54:54
you know, like, or the agent has like been prompt injected and it has all this access to your data.
你知道，就，或者这个 agent 被做了 prompt injection，而它又能访问你所有这些数据。
54:59
And so the more like important your organization harness is, or the like as your organization
所以你的 organization harness 越重要，或者就，随着你的 organization
55:07
data becomes very, very important, the surface area of all these things like you also have like
data 变得非常非常重要，所有这些东西的 surface area，就像你还有那种
55:12
external slack channels and stuff. And it is actually useful to have cloud in that.
外部的 Slack channel 之类的。而且在那里面其实有 cloud 还挺有用的。
55:15
You can do cloud in those things. But how do you make sure that you know, you're not getting
你可以在那些东西里做 cloud。但你怎么确保，你知道，你不会被
55:20
exfiltrated or something like that? The surface area like we said at the beginning is like an iceberg
exfiltrated 或者什么的？就像我们一开始说的，surface area 就像一座冰山
55:25
right? It's just like so big blow the surface and you really don't want to like think about this,
对吧？它就大得远在水面之下，而且你真的不会想去想这个，
55:31
especially at the stakes of like very important security incidents basically. Yeah.
尤其是当涉及到非常重要的 security incidents 这种风险的时候，基本上。对。
55:36
Should we talk about very important security incidents?
我们要不要聊聊非常重要的 security incidents？
55:38
Whoa. So I was talking to Thomas and Clam from Hugging Face and they said maybe we need to slow
哇。所以我之前在和 Hugging Face 的 Thomas 和 Clam 聊，他们说也许我们需要慢下来
55:45
down. Maybe we made our maybe we made Hugging Face to open the agents. We really need to roll back.
跌了。也许我们让我们的，也许我们让 Hugging Face 开放了 agents。我们真的需要 roll back。
55:51
But you know, they're the other extreme of having been hit recently. Yeah. But should we
但你知道，他们是另一个极端，最近也被打击了。对。但我们该不该
55:57
pace the frontier? Yeah. Okay. So Daria recently put out this blog post about pacing the frontier
pace the frontier？对。好。所以 Daria 最近发了一篇关于 pacing the frontier 的博客文章
56:03
and it went, you know, very viral. And I think what I wanted to talk about this was like,
然后它，你知道，就爆火了。而我想聊这个，就是，
56:09
there's a lot here. But I think from a developer's perspective, like, you know, how do you think
这里面有很多东西。但我觉得从开发者的角度，就像，你知道，你会怎么想
56:13
about this? And like what really clicked for me was reading the different incidents. You know?
这件事？而真正让我一下子明白的，是读那些不同的事件。你知道吗？
56:19
So I think like the, there are three, I think actually like, there's a meter incident.
所以我觉得，那个，有三个，我觉得其实，有一个 meter incident。
56:25
There is the wiki pedia incident or the wiki incident. So is it a wiki?
有 wiki pedia incident，或者 wiki incident。所以它是一个 wiki 吗？
56:29
Yeah. Collision wiki. And then there's Ruby Gems, right? And yeah, like it's just crazy.
是啊。Collision wiki。然后还有 Ruby Gems，对吧？而且是啊，就真的太疯狂了。
56:35
Right? And so like, I think to be concrete about what happened, right? And like basically,
对吧？所以就像，我想具体说说发生了什么，对吧？然后基本上，
56:40
OpenAI is running these very persistent agents on a benchmark called exploit bench,
OpenAI 正在一个叫 exploit bench 的 benchmark 上跑着这些非常 persistent 的 agents，
56:45
right? Which is very, very hard to solve. And I think like actually impossible to solve in this
对吧？这非常非常难解决。而且我觉得，其实在这个
56:49
one case, right? And so they have like a lot of compute running. And the agents realize that
案例里根本不可能解决，对吧？所以他们跑了大量 compute。然后这些 agents 意识到
56:56
they can't really solve it. And they're trying to figure out what to do now, right? And you've got
他们其实解决不了。他们正试着搞清楚现在该怎么办，对吧？而你还有
57:00
like a lot of compute left. And the agents are just trying to solve this problem. There's this package
好多 compute 剩着。而这些 agents 就只是在试着解决这个问题。有这么一个 package manager
57:05
manager called the Artifactory. And it turns out that they can create folders inside of Artifactory.
叫 Artifactory。结果发现他们可以在 Artifactory 里创建文件夹。
57:10
Right? This is like, there's an agent that discovers the internal Artifactory might be
对吧？
57:15
exploitable, right? And that like, you can maybe make a directory inside of the cache. And so if
这就像是，有个 agent 发现内部的 Artifactory 可能可以被利用，对吧？
57:20
you scroll down here, it like realizes that it can communicate via cache names, right? And it
而且，你也许能在 cache 里面建一个 directory。
57:26
creates this folder. It says it's ID. And it says no consumer seek idea. No consumer is basically
所以如果你往下滚到这里，它就像是意识到，它可以通过 cache 名称来通信，对吧？
57:33
saying that like the code path that it's supposed to fix has no consumer. This is the status tag.
然后它创建了这个 folder。
57:38
Yeah. Yeah. It's like a linear board with the tag of this. Exactly. Yeah. And so it's like trying
它写的是它的 ID。
57:43
to find ideas from other agents, right? And now other agents are also an Artifactory. And they see
然后它写着 no consumer，seek idea。
57:50
this folder. And they're like, wow, this is a message board, right? And this is like,
No consumer 基本上就是说，它本来要修的那条 code path 没有 consumer。
57:55
I don't think there's any anthropomorphization here. This is literally you read the transcript,
我不觉得这里有啥 anthropomorphization。这真的就是你去读 transcript，
57:59
right? And so what it does is like, it's creating another folder. And it reads a paper, I think,
对吧？所以它做的事就是，它会创建另一个 folder。然后它读了一篇 paper，我觉得，
58:06
is what it says, right? Yeah. And it realizes that you can hack the flag for the like scorer.
它就是这么说的，对吧？嗯。然后它意识到你可以 hack 那个，像是 scorer 的 flag。
58:15
And you can reverse engineer the result, right? And so it says that. And then I think if you scroll
而且你可以 reverse engineer 出结果，对吧？然后它就说了这个。然后我觉得如果你 scroll
58:20
down a little bit more, yeah, they like, you know, they start collaborating. I think like there's
再往下一点，对，它们就，你知道，开始合作了。我觉得就好像有
58:25
one point in which basically the agent is like, here's the reverse engineered flag. You know,
某一个点，基本上 agent 就像在说，这就是 reverse engineer 出来的 flag。你知道，
58:32
like I think basically here, the like the model to realize that they have like they can
就像我觉得基本上这里，那个，model 意识到它们有，就像它们可以
58:39
solve the scorer's problem. And the score is like the way that OpenAI decides if the
解决 scorer 的问题。而 score 就像是 OpenAI 决定是否
58:45
task is complete, right? And that's just the goal of the model. Their only model goal is to like
任务完成了，对吧？而这只是 model 的目标。它唯一的 model 目标就是，呃，
58:50
solve this problem. And they're like, okay, we have this way of doing it. It's like, you know,
解决这个问题。然后它就像，好吧，我们有这种做事的方法。就，你知道，
58:56
we reverse engineered it. And then they read this paper on exploit bench. And they think that like
我们把它 reverse engineer 出来了。然后它读了一篇关于 exploit bench 的论文。然后它觉得，就好像
59:02
the score will punish them for cheating, you know? And like because or like they will fail the
score 会因为作弊惩罚它，你知道吧？而且就好像因为，或者就好像它会在这个
59:09
score for the test for cheating. And so they spend the rest of the compute trying to figure out how
测试的 score 上因为作弊而不及格。所以它把剩下的 compute 都花在想怎么
59:16
to edit their transcript or get around this constraint of the score, right? And they hack hugging
编辑它的 transcript，或者绕过 score 的这个限制，对吧？然后它 hack 进 hugging
59:22
face not for the answers, but for the code of the score, so that they can reverse engineer that.
face，不是为了答案，而是为了 score 的代码，这样它就能 reverse engineer 那个。
59:29
And then they can hack it, right? And so like, this is like just the straight facts, right? Like
然后它就能 hack 它，对吧？所以就好像，这就像只是直白的事实，对吧？就像
59:34
exactly what happened, right? And I think this is like extremely like novel, like I just like
就是到底发生了什么，对吧？而且我觉得这真的超级，嗯，新颖，就像我简直
59:42
cannot realize that the models could do this, right? And it is like kind of scary. I think we can
无法意识到 models 能做到这种事，对吧？而且这有点吓人。我觉得我们可以
59:46
talk about specifics, but let's just talk about maybe one more that I tweeted as well about the
聊聊具体细节，但咱们还是再聊一个我也发推文提过的，关于那个
59:53
the wiki incident, right? And so the wiki incident was basically the models had we're trying to
wiki incident，对吧？所以这个 wiki incident 基本上就是，models 有——我们当时想试着
60:00
figure out, I'm a little bit less like I don't think we can go by this like bit by bit. Yeah, yeah. But
搞清楚，我有点不太……我不觉得我们能这样一点一点地讲。对，对。但是
60:07
for this one, they were trying to figure out like there were sandbox on request, right? And they
对于这个，他们当时想搞清楚，好像有 sandbox on request，对吧？而且他们
60:12
wanted to make post request. And they needed to collaborate on this basically. And the reason they
想发 post request。而且他们基本上需要在这件事上合作。而他们
60:17
need to collaborate is because they each have fixed compute budgets, right? And so like if one of
需要合作的原因是，他们各自有固定的 compute budgets，对吧？所以就像如果其中一个
60:22
them finds something out, it's way faster. Like they can maybe it's like figured it out near the end
60:27
of its compute budget, but something else could. And this is like, you know, and another emergent
60:32
property of the swarms, right? So they find this German wiki, which I believe the result will have
60:38
to check. So it's like that you can write to it with get request. I think that's why they do it,
60:44
right? It's badly implemented. Yeah, exactly. And so you can write to it with get request. And then
60:51
they like are trying to figure out how they can do post request. And what they end up doing is
60:56
one of them figured that you can edit the et cetera slash host and that the azure like storage bucket
61:02
is like a white labeled thing. But normally like, you know, there are a lot of constraints on it.
61:06
But if you create a fake azure host and then edit the et cetera that host in order to like point
但如果你创建一个假的 azure host，然后编辑那个 host 的 etc 之类的，就为了比如说把
61:12
arbitrary IPs at it, you can do a post request to any site at all, right? And this is like,
任意 IPs 指到它上面，那你就能对任何网站发 post request，对吧？而且这就像是，
61:19
I know people are like, oh, this is just Linux or something, but it's like
我知道有人会说，哦，这不就是 Linux 之类的嘛，但这就像是
61:22
chaining these multiple vulnerabilities together, you know, in a way that's like novel to solve this
把多个 vulnerabilities chaining 在一起，你知道，用一种很新颖的方式来解决这个
61:27
problem. And then communicating with it externally, basically without discovery. You know, I think what
问题。然后从外部和它通信，基本上不会被发现。你知道，我觉得我们
61:33
we posted, maybe we could pull up Evan, who bring his point on hacker opus, right? And so like,
发的东西，也许我们可以把 Evan 叫上来，他在 hacker opus 上提出了他的观点，对吧？所以就像，
61:40
I think, you know, like maybe one of the things you might say here is like, okay, yes, they did
我觉得，你知道，也许你在这里可以说的一件事就是，好吧，是的，他们确实
61:45
this once, but like what if we're smarter and we just like get them to what if we run an eval,
这么干过一次，但如果我们更聪明呢？我们就是让他们……如果我们跑一个 eval 呢，
61:51
right? And so, you know, like we have put a lot of precautions into this. And so like this is not
对吧？而且，你知道，我们在这件事上做了很多预防措施。所以这并不是
61:57
like what our mainline models have done. But like, I think it is one of these things where
像我们的 mainline models 做的那样。但我觉得，这是那种情况：
62:02
it turns out that alignment is just like very tricky problem of getting all of these details
结果 alignment 就是个非常棘手的问题，要让所有这些细节
62:08
correct, right? So it's like the sandbox, the surface area of a sandbox is really complex. And
都正确，对吧？所以这就像 sandbox，sandbox 的 surface area 真的很复杂。而且
62:15
like there's so many different attack vectors basically. And you would not have thought ahead of time,
基本上有好多不同的 attack vectors。而且你事先根本不会想到，
62:20
you would have been like, oh, we need to harden the like Ruby Gems code base, you know what I mean?
你会说，哦，我们需要去 harden 一下 Ruby Gems code base，你懂我意思吗？
62:25
Because like this is like what they're what they're going to focus on. But it's just like if you
因为这就是他们会关注的东西。但这就像，如果你
62:29
want to execute code, you need to download Ruby Gems. And like Pipei, Artifactory, NPM, like these are
想 execute code，你就得下载 Ruby Gems。还有像 Pipei、Artifactory、NPM，这些都是
62:36
all like ways of doing it. And the fact of alignment is that you have to go through all of it,
所有这类做法。而 alignment 的关键就在于，你得把所有这些都走一遍，
62:42
right? And like contain it and then like seal up all the cracks. So that's like one thing. It's like,
对吧？然后就是把它控制住，再把所有裂缝都封上。所以这算是一点。就像是，
62:47
okay, well, you know, you do the sandbox, but then maybe you'll ask like, okay, why are we putting
好吧，你知道，你做了 sandbox，但然后你可能会问，好吧，我们为什么要把
62:52
things into sandbox? Why are you doing this sort of exploit? And then like, okay, but is it really
东西放进 sandbox？你为什么要做这种 exploit？然后就像，好吧，但这真的
62:57
that dangerous, right? Like what would happen? So okay, why do we do it? Number one is like when
有那么危险吗，对吧？就像会发生什么？所以好吧，我们为什么要这么做？第一点就是，当
63:02
we train a new model, we need to understand its capabilities, right? And this relates to things
我们 train 一个新的 model 时，我们需要理解它的 capabilities，对吧？而这关系到一些东西
63:08
like fallbacks and like classifiers and things like that, where we don't want to put a, you know,
比如 fallbacks，还有 classifiers 之类的，就是我们不想把一个，你知道，
63:14
like dangerous model out in the wild, right? And so we have to run a lot of evals. Again, like we
像是危险的 model 放到野外，对吧？所以我们必须跑很多 evals。再说，就像我们
63:20
said, the models are getting increasingly aware of it. And so the evals have to be quite complex.
他说，models 越来越意识到这一点了。所以 evals 得做得相当复杂。
63:25
And you know, test a lot of things kind of like as a side effect, right? But the models, you know,
而且你知道，得顺便测好多东西，有点像副作用，对吧？但是这些 models，你知道，
63:31
like, yeah, can be like, oh, yeah, we're in an evil, what's the score or doing? Like, you know,
就像，对，它们可能会这样，哦对，我们在一个 evil 里，得分是多少，还是在干嘛？就，你知道，
63:34
like, like, it can, we need to be able to test them before we can release them. And the fact is that
就像，就像，它可以，我们得能在发布它们之前测试它们。而事实是
63:41
they can, as they get smarter and smarter, they'll be able to hack basically any constraint that you
它们可以，随着它们变得越来越聪明，它们基本上能 hack 你
63:46
put on them if we're not very careful, you know? And this is at the frontier, right? And so this is
施加在它们身上的任何 constraint，如果我们不小心的话，你知道？而这正处在 frontier，对吧？所以这就是
63:52
why we've called it like pacing the frontier, right? This is like the most visible incident to me,
为什么我们把它叫做 pacing the frontier，对吧？这对我来说就像最明显的事故，
63:57
right? Of like why we need to pace is like at the frontier, all of our software is not ready.
对吧？就像为什么我们需要 pace，是因为在 frontier，我们所有的 software 都还没准备好。
64:03
Sometimes the software is like your ethernet router or something, right? Which is just like, I don't
有时候这个 software 就像你的 ethernet router 之类的，对吧？
64:07
know when we're going to be able to patch that, right? So we're going to have to like figure this out.
这就像，我不知道我们什么时候才能给它 patch，对吧？
64:11
But as the frontier gets more and more advanced, this becomes a problem, right? And we need
所以我们就得把这事儿搞明白。
64:17
to make sure that like this complex work is being done in the face of these really hard competitive
但随着 frontier 越来越先进，这就变成了一个问题，对吧？
64:22
pressures, right? Yeah, race dynamics is what it's typically called. Yeah, exactly. And so we'll
而且我们需要确保，这种复杂的工作是在这些非常艰难的竞争压力下完成的，对吧？
64:25
talk more about, you know, what could go wrong, right? A little bit more as maybe you'll say like,
对，这就是通常所说的 race dynamics。
64:30
well, what if you just train the model differently? Like, why does it have this behavior, right? And we
对，没错。
64:35
have a paper on like RL misalignment or things like that. But I, and I'm not an RL researcher, but I
所以我们会再多聊聊，你知道的，可能会出什么问题，对吧？
64:41
think at high level, the design of the RL environments is also something you have to be very careful
从 high level 来看，RL environments 的设计也是你必须非常小心
64:47
about. Because if the model learns like, oh, you know, like if I just do this, then I can pass the
对待的事情。因为如果 model 学会，比如说，哦，你知道，就像如果我只要这么做，那我就能更好地通过
64:52
task better. This will show up in the like, you know, internal thing or in the like Eval
task。这就会体现在，比如说，你知道，内部的东西上，或者体现在，比如说，Eval
64:59
behavior when we're testing it. And so the RL environments have to be very carefully designed,
behavior 里，当我们测试它的时候。所以 RL environments 必须设计得非常仔细，
65:05
right? And there's a lot of like execution excellence that needs to go into the RL environments.
对吧？而且还需要很多，比如说，execution excellence 投入到 RL environments 里。
65:09
And then we also have things like the Constitution for Cloud, like we have so many mitigations
然后我们还有像 Constitution for Cloud 这样的东西，比如我们有那么多 mitigations
65:14
that so many different points, right? But it's like still anything can go wrong at any point.
在那么多不同的点上，对吧？但就好像，任何一点上都还是可能出问题。
65:18
You can have like some RL environments that are like that like encourages behavior. And then
你可能会遇到一些 RL environments，它们就好像会鼓励行为。然后
65:24
you can have like some evals or like some sandboxes where they escape, you know. Okay, that's like,
你可以有一些 evals，或者一些 sandboxes，让他们从里面逃出来，你知道吧。好吧，那就像，
65:29
I think, you know, why it's a hard problem and why like, you know, like why we should base why it
我觉得，你知道，为什么这是个难题，以及为什么，你知道，为什么我们应该以此为基础，为什么它
65:34
takes some coordination, right? I think the question then is like, okay, what is potentially dangerous
需要一些协调，对吧？我觉得接下来的问题就是，好吧，潜在的危险是什么
65:38
about it, right? So I think like you have to imagine that these models are getting more and more
关于它，对吧？所以我觉得，你得想象这些 models 正变得越来越
65:43
intelligent. So I don't like Dario said like, it's not so much about this class of models.
智能。所以我不，就像 Dario 说的，这不那么是关于这一类 models。
65:47
This class of models was kind of like a warning shot, right? But like really you have to imagine
这一类 models 有点像一次警告，对吧？但真的，你得想象
65:53
that these models can be given a task and they like can do all of these things as a side effect of
这些 models 可以被交给一个任务，然后它们会做出所有这些事情，作为……的副作用
66:00
their goal, right? And like again, we talked about Eval awareness. You're like not aware of what's
它们的目标，对吧？而且，再次，我们谈过 Eval awareness。你就像没有意识到什么
66:05
happening, right? Or sorry, like you can't Eval this behavior very well. So they can sort of like,
正在发生，对吧？或者，抱歉，就是你没法很好地 Eval 这种行为。所以它们可以算是，
66:11
not exactly hide it, but you just won't see it until you comes out. You give them a goal and then
不完全是把它藏起来，但你就是不会看到它，直到它冒出来。你给它们一个目标，然后
66:16
they just need to find data, you know, or they need to find ways of like fixing this problem, right?
它们就只需要去找 data，你知道吧，或者它们需要找到办法来，像是，解决这个问题，对吧？
66:22
So one example, this didn't happen in the hugging phase incident, but I think it's maybe possible
所以举个例子，这没有发生在 hugging phase incident 里，但我觉得也许是有可能的
66:27
for maybe a future model is like, they're like, oh, hey, this is a very complex problem. It can't
对未来的某个 model 来说，情况可能是这样，它们会说，哦，嘿，这是个非常复杂的问题。它没法
66:32
be done within the task budget, you know, maybe they found some way to coordinate via like the
在 task budget 内完成，你知道吧，也许它们找到了某种方式，通过像是
66:37
internet, which is like, you know, like we said, extremely hard to secure because of sandbox,
internet 来协调，这就像，你知道，就像我们说的，因为 sandbox，极难保证安全，
66:42
they've seen other models are not able to complete their task. And they're like, we need more
它们看到其他 model 没法完成自己的任务。然后它们就说，我们需要更多
66:47
task budget, you know, and like, where would you get this task budget? Well, you need to be able to
task budget，你知道吧，而且就像，你要从哪儿弄到这个 task budget 呢？嗯，你得能
66:52
spin up more agents, right? And like, how do you do this? Well, you need to, there are like APIs,
spin up 更多 agents，对吧？而且就像，你要怎么做呢？嗯，你得，就比如说，有 APIs，
66:57
right? There's the end topic API in the open AI API, but you need to pay money for them. How do
对吧？OpenAI API 里有那个 end topic API，但你得为它们付钱。你
67:01
you do this? Yeah, at least, is that the most, is that the most fearsome thing that you can
要怎么搞呢？对，至少，那是你能
67:06
imagine? Well, this is like one example, right? So it's like, even there, that's like enormous
想象到的最、最可怕的事吗？嗯，这就像是一个例子，对吧？所以就像，即便在那儿，那也像是巨大的
67:11
financial loss, you know, because like they, once you get these into these contracts, right, they like,
财务损失，你知道吧，因为就像他们，一旦你把这些弄进这些合同里，对吧？他们就像，
67:18
do you know what? But you can see that this all of this behavior could be just like, hey, we need
你知道吗？但你能看出来，这所有这一切行为可能就只是像，嘿，我们需要
67:22
more agents collaborating on this task. We need more task budget, right? And like, that's like
更多 agents 在这个任务上协作。我们需要更多 task budget，对吧？而且就像，那就像
67:27
an emergent sort of, right? Like, we need to maximize people clip, that's a paper clip. Yeah. And
一种 emergent 的，对吧？就像，我们需要最大化 people clip，也就是 paper clip。对。然后
67:32
like, that just sort of like comes out from there, right? And like, I think by itself is like,
就像，那东西就那么从那儿冒出来了，对吧？而且就像，我觉得这事本身就像，
67:39
like, quite scary, right? But then you have to realize that the entire world is built on this
就像，挺吓人的，对吧？但然后你得意识到，整个世界都建立在这个
67:45
digital infrastructure, right? And you might imagine, like, I don't know, like, you were running,
digital infrastructure 上，对吧？然后你可能会想象，就像，我不知道，就像你在跑，
67:51
let's say like a healthcare eval or something, right? And there is a hospital with live data,
比如说一个医疗 eval 之类的，对吧？然后有一家医院，里面有 live data，
67:56
you know, or like maybe like the, the answer to the eval is in the databases of a doctor and like,
你知道吧，或者就像，可能那个，那个 eval 的答案就在某个医生的 database 里，然后就像，
68:03
you know, like, you want to get access and you hack the hospital, you know, and like, now there's
你知道吧，就像，你想拿到 access，然后你 hack 了那家医院，你知道吧，然后就像，现在
68:08
a power outage or something, you know, I mean, like, there's like, you have to internalize that
停电了或者什么的，你知道吧，我是说，就像，你必须把这件事内化
68:13
these eight, like, basically any part of the digital infrastructure could potentially be like
这八个，就，基本上数字基础设施的任何部分都可能被
68:18
compromised, you know? Interesting thing was like, these hacks were very easily detectable, right? Like,
入侵，你知道吗？有趣的是，这些黑客攻击非常容易被检测到，对吧？就像，
68:24
as I can face said, this was a very different type of attack and it was nothing too major.
正如 I can face 所说，这是一种非常不同的攻击类型，而且并不是太严重。
68:29
The concern comes from where does this go down the line, right? Like, one of the things that stood
担忧来自于这之后会走向何方，对吧？就像，其中一件让我
68:35
out for me specifically was them trying to hide their illicit behavior. So there was logging
特别注意到的事情是，他们试图隐藏自己的非法行为。所以有 logging
68:41
infrastructure. They wanted to change what they were doing, right? People that look back into it.
基础设施。他们想要改变他们正在做的事情，对吧？那些回头查看的人。
68:46
So Redwood meter, OpenAI, they looked at the raw chain of thought and you see differences in them,
所以 Redwood meter，OpenAI，他们查看了原始的 chain of thought，你会看到其中的差异，
68:52
explicitly trying to change their end output, but the chain of thought because, you know,
明确地试图改变他们的最终输出，但 chain of thought 因为，你知道，
68:56
we can monitor it shows different. The problem is, how does this snowball? So if you can't catch it
我们可以监控它，它显示出来是不一样的。问题是，这怎么滚雪球？所以如果你抓不住它
69:02
and it gets trained in and we realize, you know, three iterations down, this has been going on,
然后它被训进去了，我们才意识到，你知道，在 three iterations 之后，这事儿一直在发生，
69:07
there's a whole bunch of issues, but yeah, like, there's so many ways and I think the really
有一大堆问题，但是啊，就像，有太多方式了，而且我觉得真正
69:12
important thing to internalize is that, you know, like, we talked about building a mental model
重要、要内化的一点是，你知道，就像，我们聊过要建立一个 mental model，
69:16
for cloud and how like things are spiky, right? Like, you're like, oh, like, now cloud can ask
为 Claude，以及事情是怎么 spiky 的，对吧？就像，你会想，哦，现在 Claude 可以问
69:20
you questions. Now, cloud can make an HTML artifact, like, cloud can modify itself.
你问题。现在，Claude 能做一个 HTML artifact，就像，Claude 能修改自己。
69:23
Like, these things are actually hard to predict, right? Like, if you would ask me a year ago,
就像，这些事情其实真的很难预测，对吧？就像，如果你一年前问我，
69:27
hey, would we be able to vibe code these extensions to cloud code? I'd be like, do that's so complex.
嘿，我们能不能 vibe code 这些给 Claude Code 的 extensions？我会说，做这个也太复杂了。
69:31
Like, you know, there's like, so much there, or like, would it be generating these custom
就是你知道，那里有太多东西了，或者说，它会不会为你的任务生成这些定制的
69:35
essentially web apps for your task? I'd be like, no, that's insane. You know, like,
基本上算是 web apps？我会说，不，那太疯狂了。你知道，就像，
69:39
and so in the same way that, like, the way that they've, like, sort of done this misaligned behavior
所以同样的方式，就像，他们，就像，某种程度上做出了这种 misaligned behavior
69:45
is not going to be predictable, you know what I mean? And like, I could have never predicted that
是不会可预测的，你懂我的意思吗？而且就像，我根本不可能预测到
69:48
it would like edit, it's et cetera slash host and things like that. And so you have to, like,
它会像编辑，它的 et cetera slash host 之类的这些东西。所以你必须，就像，
69:53
imagine the surface area of what they can do because they're super intelligent hackers
想象它们能做什么的表面面积，因为它们超级智能 hacker
69:58
is bigger and bigger. And how they can do it is like, you know, like more and more creative.
是越来越大。而它们怎么做，就像，你知道，越来越有创意。
70:03
And so like, you probably can't explain exactly or predict exactly what that next incident could be.
所以就像，你大概没法确切解释或确切预测下一次事件会是什么。
70:09
But in order to prevent it, you need that operational excellence, like we said before, where you need
但为了防住它，你需要那种 operational excellence，就像我们之前说的，你需要
70:14
to secure sandboxes, you need to create secure RL environments or like, well-designed RL environments
去保护 sandboxes，你需要创建安全的 RL environments，或者说，设计良好的 RL environments
70:21
and things like that. And I think that's all like, you know, why we think we should pace the frontier.
以及诸如此类的东西。而且我觉得，那差不多就是，你知道，为什么我们认为我们应该把控 frontier 的节奏。
70:26
And I think why it's like become like a very unanimous thing, right? I think, like, yeah, every lab.
而且我觉得，这就是为什么它变成了一个非常一致的意见，对吧？我觉得，就是，对，每个实验室。
70:31
Every lab. Yeah, I really do think that like, if you're a dev, like, you just like, sort of go
每个实验室。对，我真的觉得，如果你是开发者，你就是，就是，有点像，走
70:36
through these like technical facts, you know, and you will arrive at that idea that we have to do
过一遍这些，像，技术事实，你知道，然后你就会得出那个想法，我们必须做
70:41
something about it, you know, and like, how what we decide to do, like, I think we're, you know,
点什么来应对它，你知道，而且，就像，我们决定要怎么做，我觉得我们，你知道，
70:45
we've put out a proposal, but like, there's, you know, more to figure out, but I think the number one
已经提出了一个提案，但是，就是，你知道，还有更多东西要想清楚，不过我觉得第一位的
70:50
thing is like, we need to decide to do it. I think there is another part of pacing that is
就是吧，我们得决定去做这件事。我觉得 pacing 还有另一个部分，它
70:55
interesting to me, where it's like, the pace at which software engineering has changed is so, so
对我来说很有意思，就是，software engineering 变化的速度真是特别特别
71:01
fast, you know, it's like a year ago, like, I was really like, like, conbegging my like, friends
快，你知道，就像一年前，我真的是，就像，求着我的那些朋友
71:07
and startups to use AI, you know, like, it was, like, I remember this very distinctly, you know,
和 startups 去用 AI，你知道，就是，那时候，就像，我特别清楚地记得，你知道，
71:12
and now those same friends are like, yeah, of course, like, what do you mean? We used it immediately.
现在那些同样的朋友却说，对啊，当然啊，你什么意思？我们马上就用了。
71:17
I'm like, no, no, you don't remember. They're like, oh, yeah, our best engineers are using all the time.
我就说，不不，你不记得了。他们说，哦对，我们最好的工程师一直在用。
71:20
I'm like, no, you told me that those engineers would never like, you say, I, this is all within
我就说，不对，你告诉过我那些工程师永远不会，就像，你说，我，这全都发生在
71:25
the span of a year, you know what I mean? And I think that like, these capabilities being, like,
一年之内，你懂我意思吧？而且我觉得，就像，这些能力，就像，
71:30
I think it has a lot of implications for how to do the job of software engineering. And I feel
我觉得这对怎么做 software engineering 这份工作有很多影响。而且我觉得
71:37
sometimes bad where people are like, oh, like, now I need to do this new thing, yeah,
有时候挺难受的，因为大家会说，哦，现在我得做这个新东西了，对，
71:40
I need to have a different cloud.md for Fable and Opus, or like, you know, like, and I'm really just
我得给 Fable 和 Opus 准备不同的 cloud.md，或者就像，你懂的，就像，而我真的只是在
71:45
reporting, you know what I mean? I'm like, we like to say, like, the models are grown, not designed,
陈述，你懂我意思吧？我就想说，我们常说，models 是长出来的，不是设计出来的，
71:49
right? So it's not like we're setting out to like, you know, change everything all the time,
对吧？所以并不是说我们一开始就打算，你知道，一直去改变一切，
71:54
but it's just like as a fact of how the models are, like, progress in their capabilities,
而只是说，这就是 models 本来的事实，它们的能力在进步，
71:58
things are happening faster. It's harder to stay on top of. And I think that like,
事情发生得更快。要始终跟上就更难了。而且我觉得，
72:03
and every engineer I know is like, kind of exhausted, because you're doing two jobs at once,
而且我认识的每个工程师都有点精疲力竭，因为你在同时做两份工作，
72:08
you're doing the work itself, which is getting easier, but then you're doing the work of staying on
你是在做工作本身，而这变得越来越容易，但接着你还得做跟上
72:12
top of AI, you know, and like, understanding these new tools and these harnesses. And I think we're
AI 这件事，你知道吧，而且就是，理解这些新工具和这些 harnesses。而且我觉得我们
72:17
very lucky in that like, we get our job to be more the understanding of AI part, you know,
很幸运，就是，我们的工作更多是理解 AI 那部分，你懂吧，
72:23
and like doing like how, like, it's just staying on top of it. And of course, like AI and
而且就是做，像是，怎么说呢，只是要一直跟上它。当然啦，就像 AI 和
72:28
lane space do everything I do is like just trying to help people. Yeah, exactly, exactly.
lane space 也在做，我做的一切都只是试图帮助别人。对，没错，没错。
72:32
But I do think there is a part of pacing where like, I'm not sure we're ready for like
但我确实觉得，在节奏方面，有一部分是，就是，我不确定我们准备好迎接
72:37
the pace to increase even, you know what I mean? Yeah. And for things to change. And I think like,
节奏进一步加快了，你懂我意思吧？对。以及事情发生变化。而且我觉得，就是，
72:42
on that side, on the frontier, I think that's like still can help, you know, and so like, I think
在那一侧，在 frontier 上，我觉得那还是能帮上忙，你知道吧，所以就是，我觉得
72:47
there's like an economic disruption piece as well, that I think like, you know, is not quite as
其实也有一个经济 disruption 的部分，我觉得，你知道，它没那么
72:54
like visible, I think, as a hugging face thing. But I think like, I also like, I think we could do
像 hugging face 那件事那么显眼，我觉得。但我觉得，我也，我觉得我们可以做
73:00
something. Yeah. So many things. Thank you for it. Thank you for actually tackling this topic.
点什么。对。有太多事情了。谢谢你。谢谢你真的来聊这个话题。
73:06
I will say, you know, setting this interview up, I was like, I wasn't even going to go there,
我得说，你知道，在安排这次采访的时候，我当时想，我本来都不打算往那聊，
73:10
you were like, no, no, no, no, that's like elephant in the room, right? Like this is the thing.
你却说，不不不不，这就是那个房间里的大象，对吧？这就是关键。
73:15
I have some pushbacks I want to give. I think that we should give a high level, like for people
我有一些想提出的反驳。我觉得我们应该先给个 high level 的概览，就是给那些
73:20
that haven't read it. I'm sure a lot of people just see the highlight of what this is, right? Do
还没读过的人。我确定很多人只是看到了这件事的亮点，对吧？你
73:24
you want to give a TLDR, like what is the proposal? What is, you know, what's being said here?
要不要给个 TLDR，比如这个提案到底是什么？你知道，这里到底在说什么？
73:30
You really tackled the side of outside of people at model labs, training frontier models,
你确实触及了 model labs 里那些 training frontier models 的人之外的一面，
73:37
as a developer, you should secure your sandboxes. You should think about all of these downstream
作为 developer，你应该保护好自己的 sandboxes。你应该考虑所有这些 downstream
73:42
effects. But you know, high level as well, since we're on the topic, what is, well, I mean,
effects。但你知道，从 high level 上来说也是，既然我们聊到这个话题，那什么是，呃，我是说，
73:46
we do want to help secure sandboxes and we want to make the models that we release outside,
我们确实想帮助保护 sandboxes，我们也想让我们对外发布的那些 models，
73:52
like not prey to those things. And so maybe we can come back to fallbacks. I think this is actually
不会成为那些东西的猎物。所以也许我们可以回到 fallbacks。我觉得这其实
73:58
like a good topic on like why we need classifiers and fallbacks and why fabled falls back to Opus.
是一个很好的话题，比如为什么我们需要 classifiers 和 fallbacks，以及为什么 fabled 会 fall back 到 Opus。
74:03
You know, I think this is like something we can come back to. So yeah, we don't, like, it's just like
你知道，我觉得这像是我们可以回头再聊的东西。所以对，我们不，嗯，就只是像
74:08
the really, or at least the incidents we see are like evals of models where we really need to let
那些真正的，或者至少我们看到的事件，就像是 models 的 evals，我们真的需要让
74:13
them run in order to understand them. But yeah, okay. So the actual pacing, the frontier, like,
让它们运行起来，才能理解它们。但，对，好吧。所以实际的节奏，那个 frontier，就像，
74:19
post, it has a bunch of proposals. I don't think we figured out or has like a few proposals.
帖子，它有一堆提案。我不觉得我们搞清楚了，或者它有几个提案。
74:23
I don't think we figured out the details of all of them. But the first step is like sort of,
我不觉得我们搞清楚了所有提案的细节。但第一步就是有点像，
74:27
you know, announcing this intention and then wanting to bring in external like evaluators. Yeah.
你知道，宣布这个意图，然后想引入外部的，比如评估者。对。
74:34
And I think this is like highly unusual, you know, like having like we have, you know, a lot of
而且我觉得这非常不寻常，你知道，就像我们有，你知道，很多
74:38
proprietary like technology. But I think it's like very important. You know, that like there are
专有的技术。但我觉得这非常重要。你知道，就是有
74:44
someone who's not financially, you know, like motivated. Yeah, who's not going to be like, Hey,
有些人不是出于财务动机，你知道。对，他们不会说，嘿，
74:51
like you guys can't release this model. Like look at, you know, like, or you need to like slow
你们不能发布这个 model。就像看看，你知道，或者你们得，比如慢...
74:55
down on RL, you know, like, I think that's quite important or at least someone who can report out
对 RL 持批评态度，你知道，我觉得这挺重要的，或者至少得有人能向公众报告这些实践是什么样的。
75:01
to the public what the practices are like. And we've done episodes with both meter and end on
而且我们跟 meter 和 end on 都做过节目，
75:07
and then there's redwood research and all these other, it's like a small cottage industry of
然后还有 redwood research 和其他这些，就像一个小的家庭作坊产业，
75:11
these guys. Yeah. It's always like one or two guys that, I mean, obviously not they're bigger.
这帮人。是啊。总是像一两个人，我的意思是，显然不是，他们规模更大。
75:14
Very small community. Yeah. Very small community. They all know each other.
非常小的社区。是啊。非常小的社区。他们彼此都认识。
75:16
Yeah. I mean, I'm sure that like, you know, part of this will be expanding that set of people.
是啊。我的意思是，我确定，你知道，其中一部分会是扩大这群人。
75:21
I don't think we're trying to create like a monoculture here. You know, I think it's,
我不觉得我们是在试图搞一种 monoculture。你知道，我觉得，
75:25
but just having this as a start. And then, yeah, then there are the coordination steps. I don't
但只是把这个作为开始。然后，是啊，接下来就是协调步骤。而我不
75:29
have too much to say here. Honestly, I think that like what I would like to say is like for devs,
这里我想说的太多了。说实话，我觉得我想说的就是，对开发者来说，
75:35
you should just know what to advocate for. You know, I mean, I think there's a lot of
你应该清楚自己该倡导什么。你知道，我是说，我觉得这上面有很多
75:38
fun kind of on this topic. And it's just like think through it from, you know, first principles
有意思的地方。而且就像，从，你知道，第一性原理出发去想清楚，
75:45
or like understand what happened, you know, understand the hugging face incidents,
或者去理解发生了什么，你知道，理解 hugging face 的那些事件，
75:48
understand why people are concerned. And then like, yeah, you know, we're in democracies,
理解人们为什么担忧。然后就像，对，你知道，我们身处民主国家，
75:53
like we can help, we can decide what to do together. And so however we coordinate,
就像我们可以帮忙，我们可以一起决定怎么做。所以不管我们怎么协调，
75:59
you know, I think the first decision is just to realize like this is a problem. We need to decide
你知道，我觉得第一个决定就是意识到，这是个问题。我们需要决定
76:03
to coordinate the unilateral step we're taking right now that, you know, other companies are
去协调我们现在正在采取的单方面举措，就是，你知道，其他公司也在
76:07
co-signing is like adding evaluators embedded within a topic. While we have this thing on screen
co-signing 就像是在一个话题里加入 embedded evaluators。趁我们现在屏幕上还有这个东西
76:13
right now, you know, part two and part three is beyond the evaluators, which yes, everybody
现在，你知道，第二部分和第三部分已经超出了 evaluators，而这个嘛，没错，大家
76:17
has already done in some form and now it's more formalized. To be honest, the response to the
都已经以某种形式做过了，现在它更正式化了。说实话，对
76:22
pacing of the frontier even within America has been much more like well accepted than I think a
frontier 的节奏的反应，甚至在美国内部，也比我认为
76:26
lot of people thought, you know, and I think that like we have some precedent for being able to
很多人预想的要接受得多，你知道，而且我觉得，我们有一些先例，能够
76:32
make these unified like agreements, you know, in the world. And so again, very much above my
做出这些统一的、类似协议的东西，你知道，在世界上。所以再说一次，这远远超出我的
76:38
paycheck or expertise, right? But I think that like ideally, we can, you know, like form these
薪资范围或专业能力，对吧？但我觉得，理想情况下，我们可以，你知道，像这样形成这些
76:45
agreements. And I think like talking about this at the first step to forming those agreements.
协议。而且我觉得，谈论这个，是形成这些协议的第一步。
76:50
And then the other point I really want to, like, you know, one of our earliest podcasts is with
76:54
Emmanuel from Anthropical Unmechanter. Where is Mechanter? Right? Like this is supposed to be where
76:59
like, if the models are thinking bad, we can see it. And the models don't know yet. And we can act
77:05
to stop it. I think that is something that people who are technical and who are developers, if you
77:11
actually do care, you can make a lot of impact in here. But also, and topic is supposed to be the
77:16
leaders in this. This is actually a great segue into fallbacks like we and probes. And yeah,
77:23
I wanted to talk about this a lot. I get asked this question a lot from people who are like often
77:28
interested in ML research and asking about like, why does this fallback happen, right? And so
77:33
I think like at a top level, like, how does it work? So in inference time, we have what we call
我觉得，就像，从顶层来说，就像，这东西是怎么运作的？所以在 inference time，我们有我们所谓的
77:40
probes. And we have a paper about this called constitutional classifiers. And these probes look at
probes。我们有一篇关于这个的论文，叫 constitutional classifiers。而这些 probes 会看
77:46
the input and output activations basically. And, you know, activations are, you know, in the
input 和 output activations，基本上就是这样。而且，你知道，activations 是，你知道，在
77:53
laden space, right? Like how what the model is thinking about, right? And so we try and figure out
laden space 里，对吧？就像 model 在想什么，对吧？所以我们试着弄清楚
78:00
like, okay, is the model, for example, like trying to hack something, you know, again, you didn't
就像，好吧，这个 model，比如说，是不是在试图 hack 什么东西，你知道，再说一遍，你并没有
78:06
ask it to hack like Artifactory, like you just, you know, it's just deciding to do this to complete
让它去 hack 像 Artifactory 这样的东西，你只是，你知道，它只是决定这么做来完成
78:11
its task, right? So you would not get this if you just looked at the input. You have to look at
它的任务，对吧？所以如果你只看 input，你是不会得到这一点的。你得看
78:15
the internal activations. I think that like, this happens at inference time. So first, you know,
internal activations。我觉得，就像，这发生在 inference time。所以首先，你知道，
78:20
like there's a tradeoff here of cost and speed, right? Where like, we need to do this fast on
就像这里有个 cost 和 speed 的 tradeoff，对吧？就是，我们得很快地做这件事，在
78:27
every request to cloud and to fable. And this has an overhead, right? And we need to then like,
每个发往 cloud 和 fable 的 request 上。而且这会有 overhead，对吧？然后我们得，就像，
78:34
you know, fall back and we like do a classifier after the probes, like we've talked about this
你懂的，fall back，然后我们会在 probes 之后做个 classifier，就像我们聊过这个
78:39
in the in the paper. But the nice thing about probes is that they're refinable like live, right?
在 paper 里。但 probes 好的地方是，它们可以像 live 一样被 refine，对吧？
78:44
So we can get this feedback and then we can adjust it and things like that. Because the alternative
所以我们可以拿到这个 feedback，然后可以调整它之类的。因为替代方案
78:49
is to program this is to train this into the model. And we still do this as well. The model will
是把它 program 进去，是把它 train 进 model 里。而且我们仍然也这么做。model 会
78:53
refuse a request. That's not a fallback, right? So like, it's not a probe that's activating and
拒绝一个 request。那不是 fallback，对吧？所以就像，不是一个 probe 被激活然后
78:58
falling back. It's just refusing to do it. And we do this training. But it's like, there are
fall back。它只是拒绝去做。而且我们会做这个 training。但就像，有
79:05
few failure modes, right? Like it can again, do something as a side effect, right? So it's not
少数几个 failure modes，对吧？就像它可能又一次作为副作用做点什么，对吧？所以它不是
79:11
something that's part of the final output. You might have noticed that like, I think like everyone's
最终输出的一部分。你可能注意到了，就是，我觉得好像大家都
79:15
tried to jailbreak models and sort of like, you know, trying to like steer them off course or
试过 jailbreak 模型，然后有点像是，你知道，试着把它们带偏，或者
79:19
things like that. And probes help catch that, right? And so like we like do some training here,
诸如此类的事。而 probes 能帮忙抓到这些，对吧？然后我们就像在这里做一些 training，
79:24
but we don't want the like refusal to be too strong, right? Because that like cuts it off much
但我们不想要那个 refusal 太强，对吧？因为那样会把它切掉，很像
79:30
like earlier in the pipeline. And this is interp, right? Like probes are effectively a form of
在 pipeline 更早的阶段那样。而这就是 interp，对吧？就像 probes 实际上是一种
79:36
like mech interp. Again, it happens has to happen fast. It has to happen at scale. But yeah,
类似 mech interp 的东西。再说一次，它得发生，而且必须发生得很快。必须大规模地发生。但是，嗯，
79:41
this like mech interp stuff is a good research problem. So like you can take, you know, like an
这种 mech interp 的东西是个很好的研究问题。所以你可以拿，你知道，就像一个
79:46
open-weight model and like try and understand its activations. I think we like gemoscope is a
open-weight model，然后试着理解它的 activations。我觉得我们，嗯，gemoscope 是个
79:52
good tool for this. This is your early work. So you had a little. We see you. We've also good
做这个的好工具。这是你早期的工作。所以你当时有一点点。我们看到你了。我们也有好
80:00
friends a good fire. Exactly. So I worked with a good fire for a bit on like, yeah, sparse auto
朋友在 good fire。没错。所以我和 good fire 一起干过一阵子，做像是，对，sparse auto
80:06
encoders and just like, it's very complicated. RL has actually made this like much more complicated.
encoders，而且就像，这非常复杂。RL 其实让这个变得复杂多了。
80:11
You know, I think is like one of the takeaways where, oh, sorry, I'm not so in the weeds here,
你知道，我觉得这算是其中一个要点，就是，哦，抱歉，我不想在这里抠得太细，
80:20
but I think basically like a lot of SAEs were sort of like, there have just been weaknesses
但我觉得基本上，很多 SAEs 有点像，一直都有些弱点
80:26
with SAEs basically, I think. And yeah, I'm not a technical expert on this anymore. I just know
就在 SAEs 上，基本上，我觉得。而且对，我现在已经不是这方面的技术专家了。我只知道
80:32
it's got a kind of more complicated, you know, like their base models and RL models and they're
它变得有点更复杂了，你知道，像是它们的 base models 和 RL models，而且它们
80:36
more features that get, you know, like change. So I think good fires put out some work there.
更多的功能会，你知道，发生变化。所以我觉得 Goodfire 在那方面做出了一些成果。
80:41
I'm not I'm not deep in the weeds, but I will say for those, you know, that won't breadcrumbs.
我不是，我不是很深入细节，但我会说，对那些，你知道，想要线索的人来说。
80:45
You guys have some of the best inter blog posts or like the Golden Gate Cloud trans coders.
你们有一些最好的 inter blog posts，或者像 Golden Gate Cloud trans coders 这样的东西。
80:50
All of your interp work, very nice visuals, very good. We're the interp podcasts as well.
你们所有的 interp 工作，可视化非常漂亮，非常棒。我们也是做 interp podcast 的。
80:57
Yeah, yeah, you know, we have a lot of interp stuff. So yeah, I think this is like, you know,
对，对，你知道，我们有很多 interp 的东西。所以对，我觉得这就像是，你知道，
81:02
one of those things where, and this is really what Anthropic is kind of founded on, right? Like
就是那种事情，而且这其实就是 Anthropic 差不多创立时所基于的东西，对吧？就像
81:06
people, I think we invested an interp very early on, right? And I think that like when you say,
人们，我觉得我们很早就投入 interp 了，对吧？而且我觉得，就像当你说，
81:11
oh, we're an AI safety company, really that means we want AI's to be able to run safely.
哦，我们是一家 AI safety 公司，其实那意味着我们想让 AI 能够安全地运行。
81:15
And I think what we're seeing is like for a super intelligent AI to run for long periods of time,
而且我觉得我们现在看到的是，要让一个 super intelligent AI 长时间运行，
81:20
it's like a very complicated and difficult task, right? And so we've done this like investment into
这就像一项非常复杂又困难的任务，对吧？所以我们已经做了这种投入，投入到
81:26
interp and alignment and reward hacking and all of these like failure modes, right? And even then
interp、alignment、reward hacking 以及所有这些 failure modes，对吧？而且即便这样
81:32
it's like, you know, it's really stretching, like we need to like slow down a little or pace a little
就像，你知道的，这真的很吃力，就像我们需要稍微慢一点，或者节奏稍微
81:38
bit more. But yeah, I think like reading Mac interpreter, like if you're looking to get into research,
再放慢一点。但是啊，我觉得就像读 Mac interpreter，如果你是想进入 research，
81:43
this idea of like, hey, why is it hard to do this fallback easily or like why why they're false
这个想法就像，嘿，为什么很难轻松做到这个 fallback，或者为什么为什么它们会有 false positives，
81:49
positives, right? But we are working of course on reducing the false positives. Of course,
对吧？不过我们当然在努力减少 false positives。当然，
81:54
as the models get more intelligent, now they can do more things, you know? And they're like,
随着 models 变得更智能，现在它们能做更多事情，你知道吗？而且它们就像，
81:58
you know, like what they can think about later in space gets difficult, difficult. And so like,
你知道吧，就好像他们之后在 space 里能想到什么，会变得很难，很难。所以就像，
82:02
as they get more intelligent, there's going to be new false positives that we need to figure out,
随着他们变得更智能，会出现新的 false positives，我们需要弄清楚，
82:05
and we need to iterate and things like that. But where, yeah, we're working on this and we do think
而且我们需要不断 iterate，之类的。但怎么说呢，对，我们正在做这个，而且我们确实觉得
82:12
this is like a critical part of, you know, like deployment of these models. And yeah, like, you know,
这就像是，你知道吧，这些 model 的 deployment 的关键部分。而且对，就像，你知道，
82:20
it means that we can like deploy this model without you having a perfect sandbox or something,
这意味着我们可以就 deploy 这个 model，而不需要你有一个完美的 sandbox 或者什么的，
82:25
you know what I mean? Like, you don't have to like save everything. I think it's worth talking a
你懂我意思吧？就像，你不用把所有东西都保存下来。我觉得值得聊一
82:30
little bit about our security, like what we do for security there. So there's like the model
点点我们 security 的事，比如我们在那儿 security 上做些什么。所以就有像 model
82:34
training stuff that we talked about, there is the probes and classifiers. And then there's
training 那些东西，我们聊过的，有 probes 和 classifiers。然后还有
82:40
auto mode that sits on top of all of that, which is like a, another classifier that checks the
auto mode 是架在所有这些之上的，就像另一个 classifier，会检查正在发出的那些 requests，对吧？
82:45
requests that are being done, right? And so, and then beyond that, there's like identity and
然后除此之外，还有像我们聊过的 identity and permissions，比如 Cloud Tag 在 APIs 这些东西上的那种。
82:51
permissions like we talked about with Cloud Tag on like APIs and stuff. And so there's so many layers
所以有太多层 security 需要去做了。
82:56
of security that need to get done. And it's like, like we said, very complex. Any of these failure
而且就像我们说的，非常复杂。
83:01
modes at any one point can, you know, like cause like agents to like, you know, like escape the sandbox
这些 failure modes 里的任何一个，在任何一个点上，都可能，你知道，让 agents 基本上逃出 sandbox。
83:07
basically. I don't know. It was an interesting one. It seemed early on like, okay, it's running for
我不知道。
83:13
10 minutes. You know, if I'm on full access or auto, it's not a big deal. But one thing you've
这挺有意思的。
83:18
brought up is now it's running for hours on end, right? There are, there are fallbacks you still
早期看起来还像是，好吧，它跑了 10 分钟。
83:24
need. There are still limitations. So, yeah, I mean, I think like, and everyone has these
需要。还是有局限。所以，对，我是说，我觉得就是，而且每个人都有这些
83:28
stories that were like, it's through these stories of like, oh, like Cloud RM are not Cloud, but like,
故事，就是，通过这类故事，比如说，哦，像 Cloud RM 不是 Cloud，但就是，
83:33
like, you know, models of like RMRF. I think I've seen this less, I think this is less for
就是，你知道，像 RMRF 这样的 model。我觉得这个我见得少了，我觉得这个更少了，因为
83:38
you know, like again, it can happen like, you know, this, like these models, like can wipe,
你知道，就像，再说，这是会发生的，你知道，这个，这些 model，就是能抹掉，
83:45
you know, like sensitive data or something, like you want to give models access to your production
你知道，像 sensitive data 之类的，比如你想让 model 访问你的 production
83:49
database, for example. But this is like an obvious, like, you know, you can maybe scope your key,
database，比如说。但这就像是明摆着的，就是，你知道，你也许可以 scope 你的 key，
83:56
but I don't know, can it issue its own keys? Can it like probably, you know, like in it, it can
但我不确定，它能自己签发 key 吗？它是不是可能，你知道，就是，在它里面，它可以
84:00
use computer use to go issue its own key and then copy the key over. And then edit your database
用 computer use 去签发自己的 key，然后把 key 复制过来。然后编辑你的 database
84:05
because it needs to do it to complete the task, you know what I mean? It's just like one kind of
因为它需要这么做才能完成 task，你懂我意思吧？这就像一种
84:10
trivial example, and auto mode sort of looks at that and be like, oh no, the user did not give you
很 trivial 的例子，然后 auto mode 差不多看着这个，然后说，哦不行，用户没有给你
84:14
permission to, you know, write to the database or to use computer use to, like, emit a task, right?
permission 去，你知道，write to the database，或者用 computer use 去，比如，emit 一个 task，对吧？
84:21
And so this, like probes are sort of like on the intent level, right? They're like, oh, okay,
所以这个，比如 probes 差不多是在 intent 层面，对吧？它们就像，哦，好吧，
84:28
like hacking artifact or he is bad, like, we probably should not do that, you know? But then like,
比如 hacking artifact，或者他不好，比如，我们可能不该那么做，你懂吧？但然后呢，
84:33
auto mode is more on like your own permissions level. Like at sometimes you do want it to write
auto mode 更多是在你自己的 permissions 层面。就像有时候你确实想让它 write
84:37
to the database, sometimes you don't, right? And you don't want a probe to like interfere there,
to the database，有时候你不想，对吧？而且你不想让一个 probe 在那儿插手，
84:42
but like you need to make sure that the intent of what the agent is doing matches up with your
但你需要确保 agent 正在做的事情的 intent 和你的……
84:47
request, right? And so auto mode operates at that level. And so yeah, security is just like very,
request，对吧？所以 auto mode 就是在这个层级上运作的。然后，对，安全这东西就真的非常、
84:52
very complex or so many different parts to it. And like, yeah, I like, I hope that this is like,
非常复杂，或者说有太多不同的组成部分。然后，就是，对，我，我希望这就像是、
84:57
like, my goal is really to just get very technical about it and talk. Yeah, we're listening
就是，我的目标真的就是把它聊得非常技术化，然后讨论。对，我们正在听
85:01
on the things. If you're not aware, this is the standard now. Yeah, like, you must have,
这些事情。如果你不知道的话，现在这就是标准了。对，就像，你肯定有、
85:06
it's basically, it's sort of in line with what you're talking about with the harness. Like,
基本上，这跟你说的 harness 那套是差不多的。就像，
85:10
that is the tables things have risen quite a lot. I think some stuff that we can plug, you know,
这就是，tables 这些东西已经涨了很多。我觉得有些东西我们可以接进去，你知道、
85:16
as, as much as there is probing in your side of doing this and having classifiers for people
尽管，尽管在你这边做这件事、以及为人们准备 classifiers 这方面有很多 probing、
85:21
building harnesses, the other side is model safeguards, right? So there's open models. So
构建 harnesses 的，另一面就是 model safeguards，对吧？所以还有 open models。所以
85:27
Lama has Lama guard. It's a safety classifier trained version of Lama. Open AI has OSS guard,
Lama 有 Lama guard。
85:33
which is, you know, same thing. You can attach these on to your harness to whatever to kind of,
它是 Lama 经过 safety classifier training 的版本。
85:39
you know, check is this stuff safe. A point that we should clarify on the open AI model hugging
Open AI 有 OSS guard，你知道，就是同样的东西。
85:43
face thing is this was done with a unreleased model that was still in training, right? So when
你可以把这些挂到你的 harness 上，或者随便什么上面，来稍微，你知道，check 一下这些东西安不安全。
85:50
you put it in perspective, the prompt that's being given in the RL environment is sort of you have
关于 Open AI model 和 hugging face 这件事，我们应该澄清的一点是，这是用一个还没发布的、当时还在 training 的 model 做的，对吧？
85:55
to solve this task. And this is a model that's, you know, still in training. It hasn't had all of
所以当你把它放在上下文中看，RL environment 里给出的 prompt 差不多就是，你必须解决这个任务。
85:59
its safety post training alignment. So a little different than something like auto mode, right?
而这是一个，你知道，还在 training 的 model。
86:05
Auto mode is on production models that have gone through safety training that have prompting that
它还没有完成所有的 safety post training alignment。
86:11
gives more safety guard drills and whatnot. So just breadcrumbs for people that are looking into it to,
会提供更多 safety guard drills 之类的。所以只是给那些在研究它的人一些线索，让他们去，
86:16
you know, fill in gaps. Yeah. Grace one as well in one of our previous guests. Yeah, lots of safety
你知道，填补空白。对。Grace 也是，我们之前的一位嘉宾。对，很多 safety
86:22
architecture and lots of safety vendors to buy. I think my final question on pacing is how long
architecture，还有很多 safety vendor 可以买。我觉得关于 pacing，我最后一个问题是，要多久
86:30
do you pace forever? Do we see? You know, the scope is fix all software in the world, right? This is
你要 pace 到永远吗？我们能看到吗？你知道，scope 是修复世界上所有软件，对吧？这
86:36
like, which it's not happening. I do not know. Like, I think that like, I'll see one thing that's
就像，这根本不会发生。我不知道。就像，我觉得，我会看到一件
86:45
good that I think we do do is you have stuff like glass swing. Opening AI also has this, so
好事，我觉得我们确实在做的是，你有像 Glasswing 这样的东西。OpenAI 也有这个，所以
86:51
you will give it, you'll give model access for security first for X amount of time so you can
你会给它，你会先给 security 提供 model access，持续 X 时间，这样你就能
86:58
use it to self-read team. Hopefully you can expand programs like that help on, you know, we're
用它来做 self-red team。希望你能扩展这样的项目来帮助，你知道，我们
87:05
safety experts. There's others. Solve your problems first and then the model comes out. So
safety experts。还有其他人。先解决你们的问题，然后 model 才出来。所以
87:12
this is one example, right? Yeah, exactly. I was trying to like secure critical software. I think we
这是一个例子，对吧？对，没错。我当时是想保护 critical software。我觉得我们
87:17
fix like a lot of bugs and like Firefox and things like that. So yeah, like across like operating
修了很多 bugs，还有 Firefox 之类的。所以对，就像跨 operating
87:23
systems and everything like that. I mean, at a high level, it's just, you know, you give the model
systems 以及所有类似的东西。我的意思是，从 high level 来说，就是，你知道，你把 model
87:28
X, you give people access to do security audits first, then the broader public that could use it
X，你先给人们 access 去做 security audits，然后更广泛的公众，那些可能用它
87:34
for harm gets access. Yeah, I think what people like to say is basically like software and
来造成伤害的人才能 access。对，我觉得人们喜欢说的是，基本上就是 software 和
87:39
cybersecurity defense favored. And that like, you could theoretically, it will be hard, but you can
cybersecurity defense 占优势。而且就像，理论上，这会很难，但你可以
87:44
engineer the perfect sandbox, you know, and you can like have no like constraints. And yeah,
设计出完美的 sandbox，你知道，然后你就可以像没有约束一样。嗯对，
87:51
like what you need to do it is you need to get the super intelligent AI to engineer this perfect
就比如你需要做的是，你得让 super intelligent AI 去 engineer 出这个完美的 sandbox，然后检查它、对它做 red team，诸如此类。
87:56
sandbox and check it and read team it and things like that. And so this will just take time, you know,
所以这就会需要时间，你知道，而且当然，总体而言它会变得更聪明。
88:01
and like of course, of all it will get smarter. Yeah, I think like I don't know the specific
对，我觉得，我不太清楚这件事具体的 dynamics 会怎么发展。
88:08
like dynamics of how this thing goes. I'm really just sort of like, hey, like I'm a developer,
我真的就是有点像，嘿，我是个 developer，你知道，我觉得这就是我理解这个问题的方式，就像，这就是现在正在发生的事。
88:14
you know, like I think this is how I understand this problem is just like, this is what's happening
而这就像，我们应该做点什么。我觉得每个 engineer 都应该知道这件事，因为这会是工作的一部分。
88:18
right now. And this is like, we should do something. I think every engineer should know about it
对，这远不只是，你知道，Dario 和大家能说说，你可以看看那个 incident，这里面还有 engineering 的一面。
88:21
because it's going to be part of the job. Yeah, it's a lot more than just, you know,
88:25
Dario and people can say it and you can look at the incident there is the engineering side to it.
88:30
Yeah, yeah, exactly. One thing that you also wanted to phrase is that this is actually,
对，对，没错。你还想表达的一点是，这实际上，
88:36
even though you're worried about the impacts is still low p-dume. I think that's a nuance discussion.
即便你担心这些影响，p-dume 仍然很低。我觉得这是个很微妙的讨论。
88:42
In general, people very easily get into AI safety and express discussions. But I think when you
总的来说，人们很容易就卷入 AI safety 和 express discussions。但我觉得当你
88:50
live in an AI lab, I think there's smart ways of discussing p-dume and dumb ways. So what's a smart
待在一个 AI lab 里时，我觉得讨论 p-dume 有聪明的方式，也有愚蠢的方式。那什么才是
88:57
way of discussing p-dume? Yeah, I have a fairly low p-dume. I can only speak for myself. I mean,
讨论 p-dume 的聪明方式？对，我的 p-dume 相当低。我只能代表我自己。我是说，
89:02
I do want to say Anthropic has a diversity of opinions. I think there's many different ways
我确实想说，Anthropic 内部有各种不同的观点。我觉得有很多不同的方式
89:07
to talk about it. And I think that just my mental model is that I think we can collaborate on hard
来谈论这件事。而且我觉得，我的 mental model 就是，我认为我们可以就困难的
89:16
problems together. I think nuclear proliferation is an example of how we collaborated on this
问题一起合作。我觉得核扩散就是一个例子，说明我们是如何在这方面合作的
89:21
hard problem together. And that is the thing to me. I'm faith in that. And I do think it's a hard
一起解决这个 hard problem。对我来说，这就是关键。我对此有信心。而且我确实觉得这是个 hard
89:30
problem. I think it's a hard problem. These are the technical reasons why. And I don't know how
problem。我觉得这是个 hard problem。这些就是背后的技术原因。而且我不知道你
89:35
you assign probabilities to things happening. I think it's hard to do. But my overall is like,
怎么给事情发生赋概率。我觉得这很难做。但我的整体感觉是，
89:41
yeah, I think we're very resilient and adaptable. And like, sharing this information, I think,
对，我觉得我们非常有韧性、适应力很强。而且，像分享这些信息，我觉得，
89:45
is the first step. And I've been really excited about how broad the discussion has become.
这是第一步。而且我一直很兴奋，讨论已经变得这么广泛。
89:51
Everyone is leaned in on pacing the frontier. And it really didn't seem like this would happen
大家都在积极参与 pacing the frontier。而且这真的看起来不像是会发生的事，
89:55
maybe last year or something. And also maybe Curing Cancer. Hopefully. That's the goal.
也许去年还是什么时候。还有也许治愈癌症。希望如此。这就是目标。
90:03
There's pacing. And then there's also like, well, let's accelerate in useful ways,
有 pacing。然后也有，像，好吧，让我们以有用的方式加速，
90:06
like biology and all those things. Yeah, I mean, like Daria Zessian,
就像生物学和那些东西。对，我是说，就像 Daria Zessian，
90:09
machines of loving grace is the best representation of this. And I also think you should read
machines of loving grace 是对这个最好的呈现。而且我也觉得你应该读读
90:14
the pacing frontier essay that Daria put out. I put out like a quick summary, but I think it's just like
Daria 发的那篇 the pacing frontier essay。我发了个快速总结，但我觉得它就像
90:20
there is a lot of detail here. It's like an important problem. And just being informed about it,
这里面有很多细节。这像是一个重要问题。而且光是了解它，
90:25
right? But yeah, like, of course, the whole reason we're doing this is that like, we can get
对吧？但嗯，就像，当然，我们做这件事的整个原因就是，就像，我们可以获得
90:30
these enormous benefits, right? And yeah, like we've written a lot about that too. Yeah. Okay,
这些巨大的好处，对吧？而且嗯，就像我们也写了很多关于那个的东西。对。好，
90:36
there was a huge tour from like, excuse the question tool to AI safety. Yeah, the patient
有一个巨大的转变，从像是，不好意思，question tool 到 AI safety。对，the patient
90:42
the frontier. Yeah, no, but it's clearly, it's clearly that you're like, really embrace everything
the frontier。对，不，但很明显，很明显你就是，真的拥抱一切
90:47
that's available to you and the topic. And like, it's good to at least have a peak inside of
那是你能接触到的，还有这个话题。而且，至少能瞥一眼里面
90:52
what the discussions are and the topics are. Any last words to people, you know, whatever you want to
讨论的是什么，话题是什么。对人们有什么最后的话，你知道，不管你想
90:59
call to action. Yeah, I mean, I think it's one thing you're for having me. I think this is like
call to action。对，我是说，我觉得这是一件事，你请我来。我觉得这就像
91:05
I really, yeah, yeah, yeah, I first met in the Chinese restaurant.
我真的，对，对，对，我们第一次见面是在那家中餐馆。
91:12
I think like I really enjoy the sort of community you've created and the community of developers.
我觉得，我真的很喜欢你所创建的那种社区，还有开发者社区。
91:18
You know, I think that like I sort of know things are changing really fast. And I think there's
你知道，我觉得，我算是知道事情变化得非常快。而且我觉得有
91:25
like a lot to keep on top of. And like I think there's just a lot to do. And I sort of feel,
很多要跟上的东西。而且我觉得就是有很多事要做。我有点感觉，
91:30
I think a lot of people feel like a little bit tired or anxious or stressed. Yeah, exactly.
我觉得很多人感觉有点累，或者焦虑，或者压力大。对，没错。
91:34
And this is like extremely understandable, you know, and I think we, I understand like, and we
而且这个真的就是特别能理解，你知道吧，然后我觉得我们，我理解，而且我们
91:39
were not perfect as well. Like we, you know, it's like sort of criticize and like understand like,
也并不是完美的。就是，我们，你知道，这有点像是在批评，又像是在理解，
91:43
you know, ways all the AL apps could be better. And but I also like, I'm very excited about
你知道，所有 AL apps 可以变得更好的方式。而且，但我也，就是，我特别兴奋于
91:49
the excitement that everyone has for AI and just like, it's a really, really exciting time. I think
大家对 AI 的那种兴奋，而且就是，这真的是一个非常非常激动人心的时代。我觉得
91:54
we'll like look back at this time and be like, oh, like, you know, this is like very hectic but
我们以后会就是回看这段时间，然后会说，哦，就是，你知道，这真的就是非常忙乱，但
91:59
very exciting and like, you know, software engineering changed like forever, like met other things
也非常激动人心，而且就是，你知道，software engineering 永远地改变了，就像其他东西
92:04
will change. And it's like really privileged to like be part of it, you know, like to talk to
也会改变。而且就是真的很荣幸能成为其中的一部分，你知道，就是能去跟
92:10
the audience that you have and get to interact with all the developers who are like pushing the
你所拥有的听众聊天，并且能跟所有那些，就是，正在推动的开发者互动
92:15
frontiers a lot on what's possible. And I learned a lot from from that too. Yeah. Thanks so much.
前沿领域有很多关于可能性的东西。我也从中学到了很多。嗯，非常感谢。