From Six Reactions to 65% of PRs

Claude Tag is your proactive teammate.

Claude Tag 是你的主动型队友。

What's really special about Claude Tag is it has all of the kind of connectors and tools and context that you're used to when you're using Claude Code, but it's got this extra degree of proactivity and the persistence to see pieces of work through for longer periods of time.

Claude Tag 特别的地方在于,你用 Claude Code 时习惯的那些 connector、工具和 context,它全都有;但它还多了一层主动性,以及在更长时间里把一件件工作跟到底的持久性。

Since we've started using Claude Tag internally, our product teams have 65% of their PRs opened by Claude Tag and I think there comes a point where it feels like this product is really leaning into like where we see model capabilities today and it's the one that's really our daily driver at this point.

自从我们内部开始用 Claude Tag,产品团队 65% 的 PR 都是 Claude Tag 开的;到了某个节点你会感觉,这个产品真的是顺着我们今天看到的模型能力在发力,它现在确实是我们的日常主力。

The AI Native Dev is a podcast for developers and engineering leads at the cutting-edge of AI and agentic coding.

《AI Native Dev》是一档播客,面向站在 AI 与 agentic 编码最前沿的开发者和工程负责人。

Join your hosts Guy Podjarny and me Simon Maple every week as we [music] chat with the most exciting voices in AI and tackle the biggest questions facing developers today.

欢迎每周跟主持人 Guy Podjarny 和我 Simon Maple 一起,[music] 对话 AI 领域最有意思的声音,直面今天开发者面前最大的那些问题。

This is the AI Native Dev.

这就是《AI Native Dev》。

Hello and welcome to another episode of the AI Native Dev and it's wonderful and my pleasure to introduce Lamis Mukta, member of technical staff from Anthropic.

大家好,欢迎收听 AI Native Dev 新一期节目,今天很高兴也很荣幸请到 Anthropic 的 member of technical staff,Lamis Mukta。

Welcome to the podcast.

欢迎来我们的播客。

Hey Simon, so happy to be here today.

嘿 Simon,今天很高兴能来。

Amazing.

太好了。

We're going to have a great conversation about agentic coding in general, how Anthropic use Claude Code and agentic development in your environment, and also a massive congratulations for the very recent announcement and release of Claude Tag, which we'll go into in just a second.

今天我们要好好聊一聊:整体上的 agentic 编码,Anthropic 内部怎么在你们自己的环境里用 Claude Code 和 agentic 开发,另外也要隆重祝贺一下就在前不久宣布并发布的 Claude Tag,这个我们马上就讲。

But Lamis, tell us first a little bit about yourself, your role in Anthropic, and what you do.

不过 Lamis,先请你介绍一下自己、你在 Anthropic 的角色,还有你平时做什么。

Yeah, absolutely.

当然可以。

So, I'm Lamis.

我是 Lamis。

I'm a member of technical staff Anthropic, and I sit in our applied AI team.

我是 Anthropic 的 member of technical staff,在 Applied AI 团队。

So, this is a team which sits between product, research, and go to market.

这个团队的位置在产品、研究和 go to market 之间。

And so, we do a mixture of working directly with customers.

所以我们的工作一部分是直接跟客户打交道。

I tend to work with startups and founders, and we also work on some internal projects with the product and research departments.

我这边一般对接创业公司和创始人,同时我们也和产品部门、研究部门一起做一些内部项目。

Amazing.

太好了。

And we've got we've got a lot to talk about today, but let's

今天要聊的东西很多,不过我们先

start at the very exciting news.

从最激动人心的消息说起。

Very recently, Claude Tag was announced.

就在不久前,Claude Tag 对外宣布了。

You've obviously been using this internally for for for many weeks now.

你们内部想必已经用了好几周了。

Tell us a little bit about Claude Tag.

跟我们说说 Claude Tag。

What is it, and how do you use it?

它到底是什么,你又是怎么用的?

Yeah, absolutely.

对,当然。

So, Claude Tag is your proactive teammate, which you which meets you right where you work in Slack for now.

Claude Tag 是一个会主动出手的队友,它直接出现在你干活的地方——目前是 Slack 里。

And what's really special about about Claude Tag is it has all of the kind of connectors and tools and context that you're used to when you're using Claude Code, but it's got this extra degree of periods of time.

Claude Tag 真正特别的地方在于,你在 Claude Code 里习惯的那些 connector、工具和 context 它都有,但它还额外多了一层长时间持续做事的能力。

And like we said, it is able to collaborate with you and your teammates at the same time.

而且像我们刚说的,它能同时跟你和你的队友一起协作。

Yeah, and that's amazing.

对,这太棒了。

And and even internal internally in Tessl, we use Claude Code very very heavily.

在 Tessl 内部,我们 Claude Code 用得非常重。

And one of the things that we do, which sounds a little bit similar, so I'd love to kind of ask how it differs, is we have an integration of Claude and Claude Code within Slack.

我们做的其中一件事听起来有点像,所以我很想问问区别在哪:我们在 Slack 里接了 Claude 和 Claude Code。

So, we very often tag Claude to do certain things for us.

所以我们经常 tag Claude,让它替我们做点事。

That That's been available for a little while.

这个能力已经有一段时间了。

What's the difference between that, tagging Claude there and Claude Tag?

在那边 tag Claude,跟 Claude Tag,区别在哪?

Yeah, so I think um this is a great question because I think on the surface these things look really similar and it's actually some of the more intricacies underneath that differentiate these two products a bit.

这个问题问得很好,因为表面上看这两个东西真的很像,真正把它们稍微区分开的,是底层那些更细的门道。

But I would say first of all um Claude Claude Tag is incredibly proactive so it can uh kind of go and execute pieces of work for long periods of time and then come back and let you know when that thing is done.

但首先我想说,Claude Tag 极其主动:它可以自己去执行一块工作、一直做很久,做完了再回来告诉你。

So it's really leveraging the ability of coding or agents these days to do tasks for very long periods of time.

所以它真正吃到的是如今编码或者 agent 能长时间执行任务这个能力。

So that's one thing.

这是一点。

Um the second is like often you would kind of go and trigger your um your agents by asking them questions and kind of Claude and Slack would reply.

第二点是,过去往往是你抛个问题把 agent 触发起来,然后 Slack 里的 Claude 给你回一条。

Claude Tag will actually like sometimes come and find you and tell you that something needs your attention.

而 Claude Tag 有时候会自己来找你,说有件事需要你关注。

So again there's this element of proactivity.

所以这里又有主动性这个要素。

It also has memory and context which can kind of span your channels so it can kind of understand what one whole team is working on and because it's chatting to all of your teammates at the same time that's something that builds up over time.

它还有记忆和 context,而且能横跨你的多个频道,所以它清楚一整个团队在做什么;又因为它同时在跟你所有队友聊,这些东西会随时间攒起来。

So rather than you just kind of having these one-off interactions um Claude Tag is able to kind of uh move out of the scope of kind of sessions and individuals

所以不再只是一次次孤立的交互,Claude Tag 能跳出 session 和个人的范围

That's really cool.

这真的很酷。

So so so it can almost like initiate the conversation to ask

所以它几乎可以自己开口发起对话来问

It absolutely can, yeah.

完全可以,是的。

Yeah, amazing.

对,太棒了。

So the way we tend to use uh the @Claude uh invocation or in or tag within I shouldn't call it tag, should I?

我们通常用 @Claude 这个调用方式,或者说 tag——我不该叫它 tag,对吧?

The @Claude [laughter] Yeah, the Claude and Slack.

就是 @Claude,[笑] 对,Slack 里的 Claude。

So so the way we tend to use it is um very often we'll start discussing a need or a feature or a bug maybe uh in Slack and then we'll maybe @Linear and say we need a we need a ticket about this and then we'll pretty soon after that just you know hit hit up Claude and say, "Can you just implement this, please?" And it will return pretty quickly and say, "Okay, I'll I'll I'll use the the context from this thread." It obviously knows the code base as well and then it will provide something like a pull request and say, "Can you have a look at this and see?" And then we'll say, "Yeah, absolutely.

我们通常这么用:经常先在 Slack 里聊起一个需求、一个功能,或者一个 bug,然后可能 @Linear 说这事得开一张 ticket,紧接着就直接找 Claude:「你能把这个实现一下吗?」它很快就回:「好,我用这个 thread 里的 context。」它当然也熟悉代码库,然后它会给出一个 pull request,说:「你看一下?」我们就说:「好,完全可以。

This looks good.

看起来不错。

Merge this and and we're good." So there's a couple of changes there then.

merge 掉,就搞定了。」所以这里有几处不一样。

The first one is um obviously the the history there it sounds like the history it will know about past interactions across the Slack or or beyond.

第一处显然是历史记录——听起来它会知道过去在 Slack 里、甚至 Slack 之外的交互。

Was that one of the first ones that you mentioned?

这是你刚才提到的第一点吗?

Yeah, absolutely.

对,完全是。

So, I think on that context point, the So, we we kind of we have this whole permissioning system with Claude Tag, and you can really control that and tune it to how you want it, but essentially it's kind of scoped to a channel level.

关于 context 这一点,Claude Tag 有一整套权限体系,你完全可以自己掌控、调成你想要的样子,但本质上它的范围限定在频道这一级。

So, if this is a channel where you're always talking about feature requests, it has a ton of context on historical feature requests, and how like what the process is, for example, through skills for seeing those processes through end-to-end like.

所以如果这个频道你们一直在聊功能需求,它就攒下了大量历史功能需求的 context,也知道流程长什么样——比如靠 skills 把这些流程端到端走完。

So, there's a lot of history and context.

所以历史和 context 都很足。

If configured as well, it can also have the ability to search other public channels that Claude Tag is in.

如果这么配置,它还能搜索 Claude Tag 所在的其他公开频道。

So, maybe you have like a customer support um channel where there's a bit more context on where this issue arose, and Claude Tag, given the permissions, could also access that information and surface it where maybe you might not even have that kind of visibility.

比如你可能有个客户支持频道,那里有更多关于这个问题从哪来的 context,权限允许的话,Claude Tag 也能拿到那些信息、把它端出来——而这些你原本可能根本看不到。

So, that's one thing, it's just this like this context window or the the memory scope that it has is larger.

所以这是一点:它的 context window,或者说记忆范围,更大。

I think a second is you mentioned that do you go to Claude Code to implement the tickets afterwards after that in Linear?

第二点是,你刚提到——在 Linear 里开完 ticket 之后,你们是去 Claude Code 里实现这些 ticket 的?

I think that's typically the way we do it.

我们一般就是这么做的。

Okay.

好。

Yeah, so I think one one thing to surface here is you could achieve that whole end-to-end workflow in just one thread in Slack.

对,这里值得点一句:整条端到端的工作流,你在 Slack 的一个 thread 里就能跑完。

So, let's imagine in this case a piece of feedback comes through.

那我们设想一下:有一条反馈进来了。

In the Claude Tag world, you could have it configured so that Claude Tag actually picks up the feedback first and tags everybody they think should be responsible like should be involved in the response to that.

在 Claude Tag 的世界里,你可以配置成让 Claude Tag 先接住这条反馈,并且把它认为该负责、该参与回应的人全都 tag 上。

As part of its skills and workflows, it could also then automatically raise the Linear ticket because that's the workflow that you have configured.

作为它 skills 和工作流的一部分,它接着还能自动开出那张 Linear ticket,因为这就是你配好的工作流。

Um and that's available just through kind of prompting and and it learning over time through doing that workflow.

这靠 prompt 就能做到,它也会在反复跑这条工作流的过程中慢慢学会。

And then the final thing is, which I think is the real difference, is you no longer need to open Claude Code to go and ask it to execute that.

最后一点,我觉得这才是真正的区别:你不再需要打开 Claude Code 去让它执行。

So, again, it could just understand that the workflow it needs to do is kind of raise it start coding so it can spin up its own sandbox, it can start running the code in your repository if you've got access to it, and then it can ping you when the PR is ready.

所以同样,它能自己判断该走的工作流是先开 ticket、再开始写代码,于是它可以起一个自己的 sandbox,只要你给了访问权限,它就能在你的仓库里跑代码,PR 好了再戳你一下。

It can also do things like verify the aspects of that meet the original requirements from whatever ticket was raised in the first place.

它还能做这类事:核对这些改动是否满足最初那张 ticket 里的原始需求。

So, I think what we see here overall is more proactivity end to end if you do want it to be able to run that process from kind of ticket to from probably asking you if it if you want it to execute the code first if you want a human gate there and then kind of seeing that PR through prompting people to review it etc. etc. It's much more proactive in that sense and it has access to the context and memory to do that job well.

所以我们在这里整体看到的是端到端更强的主动性——如果你确实想让它把流程从 ticket 一路跑下来:先问你要不要它去执行代码,要是你想在那里留一个人工闸口;然后把这个 PR 一路盯到底,提醒该 review 的人去 review,等等等等。这个意义上它主动得多,而且它拿得到 context 和记忆,能把这件事做好。

And it sounds as well that it it's becoming more of the orchestrator as well.

听起来它也越来越像那个 orchestrator(编排者)了。

So, whereas I would need to normally hit up linear and say raise a ticket for this.

以前我通常得去戳 Linear,让它给这事开一张 ticket。

It sounds like if I can just pull Claude Tag in, it can actually do that behind the scenes and I'm more thinking about the functionality or the feature that I want to change versus the mechanism of the workflow of okay, let's raise a ticket first. Now, let's pull Claude in at that at that stage.

听起来只要把 Claude Tag 拉进来,这件事它在幕后就做了,而我想的更多是我要改的功能本身,不是工作流的机制——好,先开一张 ticket,现在这个阶段再把 Claude 拉进来。

Yeah, absolutely.

对,完全是。

So, I think again, it's really for individual teams and to to think about the degree to which like where where it is in that workflow that they want to steer the agent.

所以这还是得每个团队自己想清楚:在这条工作流的哪个位置、用多大力度去引导 agent。

So, you can be very clear about like these are the absolute gates where either you absolutely do not have the permissions to do these things or I always want you to ask for my input on these these areas.

你可以说得非常明确:这几处是绝对的闸口,要么你根本没有做这些事的权限,要么这几块我永远要你先来问我。

And I think what we've seen is because Claude Tag is able to build up this memory over time, it gets a really good feel for what those workflows look like and it adjusts.

我们看到的是,因为 Claude Tag 能随时间攒起这份记忆,它对这些工作流长什么样摸得很准,而且会自己调整。

Um so, that's really cool and I think just to throw in one last difference on that new workflow, what you'll see if you kind of went and implemented this tag um is just the ability to enable this cross-functional workflow is really cool.

这挺酷的。另外我想再补充一个新工作流上的差别:如果你真去落地这个 tag,你会看到它能撑起跨职能的工作流,这点真的很酷。

So, for example, like you have the customer support ticket raised, you might kind of tag some of the account executives that are on on that account just to see if they like for their visibility so that they know what's going on.

比如说,客户支持的 ticket 开出来了,你可能会 tag 上负责这个客户的几位客户经理,就是让他们看见、知道出了什么事。

You can then kind of tag in looping your engineers or product people for feedback on some of the product implementation.

然后你可以把工程师或者产品的人拉进来,让他们对产品实现的一些部分给反馈。

Maybe if if tag comes back to you with a plan and then have your engineers looped in later when you need that code review to go through and the whole deployment to work.

也许 tag 先带着一个方案回来找你,等你需要走 code review、需要整条部署跑通的时候,再把工程师拉进来。

So, I think what we see is this like multiplayer ability, which has been quite difficult to achieve so far with maybe just working through Claude Code or CoWork or something like that.

所以我们看到的是这种多人协作的能力,而这以前——比如只在 Claude Code 或者 CoWork 里做事——是相当难做到的。

So, I think this is where we see some of those effects really multiplying.

所以我觉得,这些效应真正开始成倍放大,就是在这个地方。

Amazing.

太棒了。

And there are going to be a lot of listeners who maybe don't use Claude or Claude Tag in the in the Slack environment today.

会有很多听众今天还没在 Slack 环境里用 Claude 或者 Claude Tag。

So, it's actually a pretty a pretty major change.

所以这其实是一次相当重大的变化。

So, when we think about the the process change, what are we going from and to?

那说到流程上的变化,我们是从什么变到什么?

So, let's assume people are agentic developers today.

我们就假设大家今天已经是 agentic 开发者了。

Uh-huh.

嗯哼。

How does it change the flow whereby we're essentially living more in our chat environments, more in our Slack versus potentially our more agentic flows or IDE?

我们基本上更多活在聊天环境里、更多活在 Slack 里，而不是活在更 agentic 的流程或 IDE 里——这会怎么改变整个流程？

How How does that How does that workflow change?

这套工作流会怎么变？

Yeah, so I think there's a a couple of things.

我觉得有几点。

And just to just to frame it in terms of the impact that we've seen internally, since we've started using Claude Tag internally, our product teams like like product engineering teams have 65% of their PRs opened by Claude Tag.

先拿我们内部看到的效果给它定个坐标：自从内部开始用 Claude Tag，我们的产品团队——也就是产品工程团队——有 65% 的 PR 是 Claude Tag 开的。

Wow.

哇。

So, that's kind of the the scale of which like we obviously were the early adopters of Claude Code.

这大概就是它的量级——我们显然是 Claude Code 最早的采用者。

And now that's like often the the port of call for how we would kick off some of these workflows and how those things originate.

而现在它往往就是我们启动这类工作流的第一站，这些事情也大多从这里发起。

So, yeah, that that's how I'd frame it in terms of like where where we're at today.

我大概会这样描述我们今天所处的位置。

In terms of workflow, yeah, I think this chat interface is definitely different.

说到工作流，这个聊天界面确实很不一样。

I think what it allows um what it allows us to achieve is when you're using Claude Code, so let's say you're and you know, doing agentic development, you have these this concept of it's it's quite single player.

它让我们能做到的是这样：用 Claude Code 的时候，比如说你在做 agentic 开发，整个模式相当单人（single-player）。

So, you're often kind of moving into your Claude Code instance, you're potentially like running Claude Code locally, and you're kicking off individual sessions.

你往往是进到自己的 Claude Code 实例里，可能在本地跑 Claude Code，然后一个个地启动 session。

Like we do have this perimeter which is a concept of a session, and that's where you're kind of stating what you're trying to achieve, managing the context for that, and then you have some kind of like outcomes or or goals or loops that you're running.

我们确实有一圈边界，就是 session 这个概念：你在里面说明自己想达成什么、管理对应的 context，然后有一些产出、目标，或者你正在跑的循环。

What we have with Claude Tag is it all becomes a little bit more amorphous, so it we're starting to like be less session focused and it's less single-player focused.

到了 Claude Tag，这一切的边界模糊了一些，我们开始不再那么以 session 为中心，也不再那么以单人（single-player）为中心。

So, when you're kicking off these agentic coding um or just agentic processes with Claude Tag, what you're seeing is that it's so much more multiplayer from the get-go.

所以你用 Claude Tag 启动这些 agentic 编码、或者说 agentic 流程的时候，会发现它从第一步就多人协作得多。

So, Tag can like get the opinions from people that might be needed for a for a workflow.

Tag 可以去征询某个工作流可能需要的那些人的意见。

So, rather than me as the developer having to go and ping like some product folks or some um sales folks on something, I can get that embedded in the Claude Tag flow.

所以不用我这个开发者亲自去戳产品或销售的同事问一件事，我可以把这一步嵌进 Claude Tag 的流程里。

Also, ultimately all of this work is potentially happening in public, which means that those people have visibility on those workflows from the get-go.

另外，所有这些工作最终都可能是在公开场合进行的，也就是说那些人从一开始就能看到这些工作流。

They know exactly what kind of product specs the engineer is giving um and can always like chip in if they want to with like extra context, etc. and maybe their own Claude Tags are going to like ping these things over to them.

他们清楚知道工程师给的是什么样的产品 spec，想插一句就随时能插，补一点额外的 context 之类；也许他们自己的 Claude Tag 还会把这些东西戳到他们面前。

So, there's this whole like collaborative nature, which is which is really different.

所以整件事带上了一种协作属性，这一点非常不一样。

The other thing is um it's a lot more asynchronous than what you'd achieve with Claude Code.

另一点是，它比 Claude Code 能做到的要异步得多。

So, I'd say that with Claude Code, you're kind of it it it's great for when you kind of want to be there for every single turn of the agent.

我会说，Claude Code 的强项在于：你想守着 agent 的每一轮时，它非常合适。

Like, you want it to come back to you with exactly what it did, um anything that needs follow-up, uh updates, etc. And when you really want to steer that thing more closely, that's a great thing to do.

你想让它回来准确交代自己做了什么、有什么需要跟进、有哪些更新；当你真想把它盯得更紧、引导得更细，这种方式很好。

With Claude Tag, we're seeing more of a pattern uh of these kind of long-running asynchronous tasks and that's really leaning into some of the model model capabilities that have been unlocked with kind of recent iterations of of models.

在 Claude Tag 上，我们看到的更多是长时间运行的异步任务这种模式，而这正是顺着最近几代模型解锁出来的一些模型能力在发力。

And so, what you see is like you kind of ping Claude Tag and it comes back to you maybe um a couple of hours later having like built end-to-end this feature that you talked about.

所以你看到的是：你戳一下 Claude Tag，它可能几个小时后回来找你，你说的那个功能它已经端到端做完了。

And so, you're kind of able to just leave the agent to itself and it will come back to you when something's done, which is quite different, I think, uh to Claude Code.

所以你可以把 agent 丢在那儿让它自己跑，有东西做完了它会回来找你——我觉得这跟 Claude Code 挺不一样。

I mean, it's inspired by some features that we've released in Claude Code, but that would be how I think things have changed.

它是受我们在 Claude Code 里发布的一些功能启发的，但我认为变化就体现在这些地方。

And the way the industry is evolving, it's funny actually, about maybe a year ago or so, I I was having a chat with uh one of the VPs of um product, I believe, at Slack.

说到行业演进的路径，其实挺有意思：大概一年前，我跟 Slack 的一位 VP 聊过，我记得是管产品的。

Uh, and I kind of I mused like, is is Slack becoming the new IDE of a developer?

我当时就琢磨：Slack 是不是正在成为开发者新的 IDE？

And it's kind of very interesting when we think about the evolution you know, developers obviously loving their IDEs, it's becoming the most productive place that that that they're in.

回头看这个演进过程挺有意思：开发者显然很爱自己的 IDE，那里成了他们待着最有产出的地方。

Then all of a sudden when we started using, you know, with the co-pilots of the world where we started introducing agentic assistance, I would say, into the IDE.

然后突然之间，我们用起了市面上那一批 copilot，开始把 agentic 的辅助——姑且这么叫——引进 IDE。

Um, with that gradually became more and more, um, evolved with multi-file changes and and, you know, things like Cursor coming in and those types of things.

这个东西慢慢越来越进化，能改多个文件了，Cursor 这类产品也进来了，诸如此类。

But then as soon as Claude Code really hit the terminal IDE, it changed people's way of working.

但一旦 Claude Code 真正打进终端这个 IDE，人们的工作方式就变了。

And I see this is like almost the next shift where it it really requires trust, and I'd love to talk about trust for a little while.

我看这几乎就是下一次转变，而它真的需要信任——信任这件事我很想多聊几句。

It really requires trust to actually step away from the IDE because you're not focused on code, which I think, you know, will be the future uh, the space whereby actually we get to that level of trust where we don't even need to look at the code.

真正离开 IDE 是需要信任的，因为你不再盯着代码；我觉得那才是未来，就是我们信任到连代码都不必看的那个阶段。

But today, I think there's this big shift of as soon as we're in the terminal IDE we are we're actually relying much much more on the tests and the validations versus looking at the code or or the results from a code review.

但今天，我觉得有一个很大的转变：一进到终端 IDE，我们实际上远远更多地依赖测试和验证，而不是去读代码、或者看 code review 的结果。

As soon as that then then gets extended beyond and into into Slack or a chat environment, we're almost like abstracting away from the code one stage further.

一旦这件事再往外延伸，进到 Slack 或聊天环境里，我们几乎是又往上抽了一层，离代码更远了。

I think this kind of a tool like a Claude Tag or anything from within Slack, this wouldn't have been accepted a year ago, right?

我觉得 Claude Tag 这类工具、或者任何从 Slack 里发起的东西，一年前是不可能被接受的，对吧？

But we're so much more trusting of AI doing the right thing, and actually the results of AI generated code and agentic code being reliable that we're able to use agents from from a space which is further abstracted away from a a very code-centric environment.

但我们现在对 AI 做对事、对 AI 生成的代码和 agentic 代码的结果可靠，信任度高了太多，以至于我们能在一个离以代码为中心的环境更远、抽象层次更高的地方去用 agent。

Is Slack and chat the new IDE?

Slack 和聊天是新的 IDE 吗？

Uh this is a this is a great this is a great question.

这是个很好的问题。

Um I guess it's hard to I I don't think these are like like-for-like replacements.

这不太好说——我不觉得两者是一对一的替代关系。

Like I think each has their their place and their purpose.

各有各的位置，各有各的用途。

But I really resonate with this trend that you mentioned in terms of how our behavior, the way that we interact with agents, is changing for a number of reasons.

但你提到的这个趋势我很有共鸣：我们的行为、我们跟 agent 打交道的方式，正在因为好几个原因发生改变。

Um So I think one is that to this trust point, like one is that models are just getting better and better.

一个原因，回到你说的信任这一点，就是模型本身在不断变好。

Like we are squarely on this exponential trend in terms of how long agents can run for.

就 agent 能跑多久这件事，我们正好就在这条指数曲线上。

Um so the the METR chart always shows us that roughly every 4 months the amount of time that agents are able to run for autonomously is like doubling.

METR 那张图一直显示，大约每 4 个月，agent 能自主运行的时长就翻一倍。

And so this is from a sheer capability perspective, we're allowed like we're able to trust these agents more because of the actual capability that's improving.

所以纯从能力角度看，我们能更信任这些 agent，是因为实打实的能力在提升。

I'd love to just double down on that what you just said.

你刚说的那点,我很想再往下追一层。

Every 4 months the the the time that an agent can do something more autonomously is doubling.

每 4 个月,agent 能更自主地做事的时间长度就翻一倍。

In terms of And is that the capability of that model or is that almost cuz there's a human aspect to that as well, right?

那这究竟是模型本身的能力,还是说——因为这里面也有人的因素在,对吧?

In terms of if it goes off and does something, am I able to interact with it?

我是说,如果它自己跑出去做一件事,我能不能跟它交互?

Is it pure capability of the model and the agent that's that's unlocking that?

解锁这一点的,纯粹是模型和 agent 的能力吗?

so this is this is an interesting one and it's um So METR produced this research and it covers a couple of different domains and essentially time horizons, so that's how long agents are able to kind of successfully complete a task of a certain length, is um a measure of capability.

这个问题挺有意思。METR 做了这项研究,覆盖了几个不同领域,核心是时间跨度——也就是 agent 能成功完成多长的任务,这是一种能力度量。

It's not perfect.

它并不完美。

Like there's other evals and benchmarks that we use to measure model capability, but it's one generally broad one that has really mirrored like what it feels like to interact with these models.

衡量模型能力我们还用别的 evals 和基准,但这是一个总体上比较宽泛的指标,而且它确实很贴合跟这些模型打交道的真实体感。

So the the longer that they're able to complete these tasks for, it often is mirroring the fact that they're doing more complicated things.

它们能把任务持续做下去的时间越长,往往就意味着它们在做更复杂的事。

Like they're able to do these multi-step tasks, they're able to verify the results of their work at multiple stages and come back and successfully complete these tasks.

比如它们能做多步骤的任务,能在多个阶段验证自己的产出,然后回来把任务成功做完。

So this is one kind of like industry board trend that we see.

所以这是我们看到的一个行业层面的大趋势。

Um and it's I mean if you look at it it's just like it's quite shocking cuz every time you think that you're not going to keep up with that that nice log chart on the straight line that you you just do every time.

而且你真去看那张图,会觉得挺震撼——因为每次你以为自己要跟不上对数坐标上那条漂亮的直线了,结果每次你都跟上了。

And that's been [snorts] happening for the best part of a decade.

而这件事已经持续了差不多十年。

So this is this is really interesting and I think when we talk about model capability, obviously you know, the amount of time it runs for is one thing.

所以这真的很有意思,我觉得谈模型能力的时候,它能连续跑多久显然只是其中一面。

But what what we see over time is like a lot of behaviors which previously we'd kind of put in the harness are getting embedded into the models.

但一段时间下来我们看到的是,很多以前得由我们塞进 harness 的行为,正在内化进模型本身。

So to make that concrete, models are a lot better at verifying their own work these days.

说具体一点,如今的模型在验证自己的工作上强了很多。

So both from like an instinctual perspective, like they do just check over their own work before coming back to you and saying it's complete.

一方面是本能层面的,它们真的会在回来跟你说“完成了”之前,先自己把活复查一遍。

And where they have the tools to verify their own work, whether that's through like front end test or running tests or creating their own evals, they're getting a lot better at doing that themselves as well.

另一方面,当它们手上有工具可以验证自己的工作时——不管是前端测试、跑测试,还是自己造 evals——它们自己动手做这件事也越来越在行。

And so to your trust point, I think these things go hand in hand.

所以回到你说的信任那一点,我觉得这两件事是相辅相成的。

Like you give the models the tools to verify their own work and they are better at kind of doing that themselves.

你把验证自己工作的工具交给模型,它们自己做这件事就做得更好。

And I think another pattern that we see in development today is that the behavior of the developer or the engineer is shifting much more towards how well can you define what success looks like in your case.

我觉得今天的开发里还有另一个模式:开发者或者工程师的行为,正越来越转向你能把“什么算成功”定义得多清楚。

And that's not just for coding, that's really for everything.

而这不只是写代码的事,而是所有事都这样。

Like do you have a really good sense of what success looks like?

你对“什么算成功”有没有一个很清楚的判断?

And if so, hand it to the model and it can loop over or have another agent review its work until they both kind of until the reviewer kind of believes that that thing is complete.

如果有,就把它交给模型,让它自己反复迭代,或者让另一个 agent 来审查它的工作,直到审查方认为这件事做完了。

So I think these are the two things.

所以我觉得就是这两件事。

It's like on the on the agent and model side, they're they're just getting more capable and better at doing these things.

在 agent 和模型这一侧,它们本身就是变得更强、把这些事做得更好了。

And then on the human side, like we are getting our behavior shifting more to just like can we define what good looks like?

而在人这一侧,我们的行为正越来越转向:我们能不能定义出“什么算好”?

Um and I think another thing to just like round that off is that having really like for a lot of us having used these tools in anger for like the last year, we're getting a really good sense of like where are these tools really useful?

还有一点可以给这个话题收个尾:我们中不少人过去一年是真刀真枪把这些工具用在生产里的,所以对“这些工具到底在哪儿真有用”摸出了很准的体感。

Where is it that they need a bit more supervision?

哪些地方它们还需要多一点监督?

And we can kind of tune our behaviors and inputs more to like what makes those things work really well in in tandem.

然后我们就能把自己的行为和输入调得更贴合那些让两边真正配合默契的做法。

Mhm.

嗯。

Uh so to your to to finally to your point on like is Slack the new home or is Slack the new IDE?

所以最后回到你那个问题:Slack 是不是新的主场,或者说 Slack 是不是新的 IDE?

I think it's a surface that allows your agents to be closer to where you're doing your work all the time anyway.

我觉得它是一个新的入口,能让你的 agent 离你本来就一直在干活的地方更近。

It allows you to tag them in in places like anywhere really like anytime you need more context or you want to delegate something, you're able to just loop the agent in and sometimes that is a coding task, sometimes it's like build this feature or this dashboard, sometimes it's just like what does this acronym stand for like can you please just tell me what happened last week or something like that.

它让你几乎在任何地方都能把它们 @ 进来——任何时候你需要更多 context,或者想把某件事委派出去,直接把 agent 拉进来就行;有时候那是个编码任务,比如“把这个功能或这个仪表盘做出来”,有时候就只是“这个缩写是什么意思”,或者“能不能告诉我上周发生了什么”这类。

So I think it just allows a bit more flexibility.

所以我觉得它就是多给了一点灵活性。

Um you're not kind of switching context between working with my agents and working with my team.

你不用在“跟我的 agent 干活”和“跟我的团队干活”之间来回切 context。

It's all a bit more um integrated.

整体上更一体化一点。

And it's it's really interesting when you when you kind of like mentioned of defining what good looks like.

你刚提到定义“什么算好”,这一点真的很有意思。

When we as humans you know we we we always want to use the best tools the best place for the best task at hand and and and in the case of defining what good looks like when we focus on code, yes absolutely the the we want to describe tests, we want to write some test cases and we want to we want to build them out and a lot of the time we we we'd lean into the IDE to actually build that out.

我们作为人,总想用最好的工具、在最合适的地方、做手头最该做的那件事;而在定义“什么算好”这件事上,如果聚焦在代码,那当然,我们要描述测试、写几个测试用例、把它们搭出来,而很多时候我们会靠 IDE 真正把这些搭起来。

But when we want to collaboratively define what good looks like, we are not we naturally find ourselves in a chat environment and it it it is the right place to define it and so tagging something in at that stage, giving it the context of what of what good looks like is is super important.

但当我们想协作着定义“什么算好”时,我们会很自然地跑到聊天环境里,那确实就是该定义它的地方,所以在那个阶段把某个东西 @ 进来、把“什么算好”的 context 喂给它,就极其关键。

Let's um let's step a little bit back and look more broadly cuz I think people who are the power users will look at something like Claude Tag and think this is exactly what I need.

我们稍微往回退一步,看得更宏观些,因为我觉得那些重度用户看到像 Claude Tag 这样的产品,会觉得这正是我要的。

I want to bring this in immediately.

我想马上把它引进来。

So here actually in the Tessl office today we have a hackathon kicking off and there's like 100 150 folks out Very very broad sets of existing adoption.

比如今天在 Tessl 办公室就有一场 hackathon 要开场,现场有 100、150 号人,大家现有的采用程度差得非常非常远。

Some people are more new to agentic coding, others have been using it obviously for a for a for a long time.

有些人刚接触 agentic 编码不久,另一些人显然已经用了很长时间。

I'd love to ask you about the external adoption of Claude Code from, you know, obviously the wider the broader industry.

我很想问问你,Claude Code 在外部、在更广的整个行业里的采用情况。

From a purely agentic coding and development point of view, um at what stage of um maturity would you say is the industry at in terms of using Claude Code?

纯粹从 agentic 编码和 agentic 开发的角度看,你觉得整个行业用 Claude Code 用到了什么成熟度阶段?

Obviously, we'll we'll talk about Anthropic's adoption in the second, but externally, uh how are people mostly using Claude Code today?

Anthropic 内部的采用我们待会儿肯定要聊,但在外部,今天大家主要是怎么用 Claude Code 的?

Absolutely.

完全同意。

Um and I think we see this in in all sorts of like shapes and flavors and forms from um being able to like for individual pieces of work, being able to complete that to like a higher degree of quality faster.

这件事我们看到过各种形态、各种样子:小到单件工作,现在能以更高的质量、更快地做完。

That's something we see on the kind of individual level.

这是我们在个人层面看到的。

Um and when we scale this to teams and across organizations, we've seen some pretty phenomenal things.

而当我们把规模放大到团队、放大到跨组织,我们看到了一些相当惊人的东西。

Like, we've seen organizations um for example, like Stripe, do entire code base rewrites that would have taken weeks or months in like days or hours.

比如 Stripe 这样的组织,把原本要花几周、几个月的整个代码库重写,在几天甚至几小时里做完了。

So, this is the kind of scale we're talking about when we when we like really deploy these things at scale and everyone's kind of on board.

所以当我们真的把这些东西大规模铺开、所有人都认这件事,这就是我们讲的量级。

Um these kind of ambitious projects that maybe you just like would always put off for like months or years because it's just where do you find the resource are finally doable and that's allowing people to focus on like other parts of like product and engineering work.

那些雄心勃勃的项目——你可能一直往后拖几个月甚至几年,因为问题永远是资源从哪来——现在终于做得了了,这让人能把精力放到产品和工程工作的其他部分上。

Um and we yeah, we we really see this consistently like other teams like shipping millions of lines like a million line of lines of code in just a month or something like that.

而且这种情况我们确实一直在看到:另一些团队一个月左右就交付上百万行、一百万行代码。

So, I think when everyone kind of like really leans in, um that's the scale at which we're able to see development happening.

所以当所有人真正投入进去,我们看到的开发就是这个量级。

And I think the other thing is you start to see more teams pursuing these kinds of moonshot projects that they just like wouldn't have time, resources, or capacity to otherwise.

另一件事是,你开始看到更多团队去做那种 moonshot 项目——换作以前,他们根本没有时间、资源或产能去做。

Like on the product side, something that we see is teams like basically prototyping a couple of different ideas or approaches to something, um testing a bunch of them either like with agentic tools or internally, and then just like going in all in on the one that they see work best. So, there's a bit more room for like experimentation and um I guess a bit more like bravery and boldness in the way that you're approaching product development.

在产品这边我们看到的是:团队会给同一件事先做出几个不同思路或方案的原型,拿 agentic 工具测、或者在内部测一批,然后全力押在效果最好的那一个上。所以实验的空间更大了,你做产品开发的方式也更敢闯、更大胆。

And of course the the the build versus buy question then becomes super interesting because it you know, tools like Claude will make it so much cheaper to build rapidly.

当然,自建还是采购(build versus buy)这个问题就变得特别有意思,因为像 Claude 这样的工具会让快速自建的成本低得多。

You can take an idea or or or a prototype very very quickly to to an actual live working application.

你可以很快地把一个想法、一个原型变成真正上线运行的应用。

And I guess the question then is if teams want to continue maintaining that over time.

那接下来的问题就是,团队是否愿意长期把它维护下去。

Um and I guess you know, when we think about um what's changing quickly in this industry is it humans and people that are slowest here in terms of the adapting?

再说到这个行业里变化最快的是什么——在适应速度上,最慢的是不是人?

Uh are people able to keep up with the with the rapid change and delivery that's happening in the AI coding space?

人跟得上 AI 编码领域正在发生的这种快速变化和交付吗?

It's a it's a great question.

这是个很好的问题。

Um I've been I've been on a bit of a tour around a couple of European cities recently talking to some like founder communities.

我最近在欧洲几个城市走了一圈,跟一些创始人社群聊。

And one question I love to ask everyone in the room is like who here has FOMO that they're not using AI like they're not using they're not AI pulled enough in their day-to-day work and their life etc. And it's always just like a full room of hands.

我很喜欢问在场所有人一个问题:这里有谁有 FOMO,觉得自己没在用 AI、在日常工作和生活里 AI 用得还不够?结果总是全场的手都举起来。

And the Anthropic employees as well, we all have our hands up.

Anthropic 的员工也一样,我们的手都举着。

Like who can keep up with the pace of this?

谁跟得上这个节奏呢?

Karpathy famously in his tweet as well said he's never felt more out of touch with something.

Karpathy 在他那条著名的推文里也说过,他从没像这次这样觉得自己跟一件事如此脱节。

And if Karpathy's saying that

如果连 Karpathy 都这么说……

I just like [snorts] ultimately the this the scale of things, the speed of things is like more than like one human like mind or person can keep up with.

说到底,事情的规模、事情的速度,已经超出一个人的头脑、一个人能跟上的范围了。

Like I mean it's more than a full-time job at this point I think.

到这个阶段,这已经不止是一份全职工作了。

Um sometimes like I even discover features I didn't know that we had because who who can keep up with that?

有时候我甚至会发现一些功能,连我都不知道我们已经有了——因为谁跟得上啊?

Um but I think that there's like we've talked a lot about this the speed and the pace at which these things are developing.

不过这些东西发展的速度和节奏,我们已经聊了很多。

And there's a there's another story as well, right?

而这里还有另一面,对吧?

Which is like well, how much is this translating into actual impact for people?

那就是:这些到底有多少真正转化成了对人的实际影响?

Like as um product developers or builders, like how are you mirroring that exponential in the value that you're able to deliver to your customers?

作为产品开发者、作为构建者,你怎么在能交付给客户的价值上,把那条指数曲线复刻出来?

And in the in the like impact on processes internally.

以及内部流程受到的影响。

And I think this is the much harder question, and this is the much harder problem to solve.

我觉得这才是难得多的问题,也是难得多的待解难题。

Like we can we can have all this raw intelligence, but do we have the infrastructure to kind of bring that value to life?

我们手里可以有这么多原始智能,但我们有没有把这份价值落地的基础设施?

And there's so much that covers.

这里面覆盖的东西非常多。

Like it covers your harnesses and how you're managing maybe your like context and your memories, how you're managing your tools, how you're giving access giving these agents access everything they need, and also in a secure way.

它覆盖你的 harness、你怎么管理 context 和记忆、怎么管理工具、怎么让这些 agent 拿到它们需要的一切访问权,而且还得用安全的方式。

Like how are you permissioning that?

这些权限你怎么设?

Um it's something we thought a lot about when we were designing Claude Tag, that specific problem.

我们设计 Claude Tag 的时候,对这个具体问题想了很多。

Um and then there's there's everything else.

然后还有其他所有东西。

Like there's all of the infrastructure.

比如所有那些基础设施。

Like how are you going to host and deploy these models?

这些模型你要怎么托管、怎么部署?

Um how are you going to deal with with yeah, all of the inference essentially.

说白了,所有的推理你要怎么扛?

So I think that yes, whilst it's amazing that there's lots of like shiny amazing things happening, like those are the problems that like everyone should be really laser-focused on.

所以我觉得,尽管有很多亮眼、了不起的事情在发生,但那些才是所有人真该死盯住的问题。

Um and we've you know, we we always try and like develop tools that help people like really access that value because on paper it's there.

我们也一直想做出能帮人真正拿到那份价值的工具,因为那份价值在纸面上是有的。

We can see it.

我们看得见。

Um but in in in order to make sure that people really feel that, I think that's like a lot more hard work.

但要让人真的感受到它,得下多得多的苦功。

And I I think it's something that a lot of developers experience.

我觉得这也是很多开发者的切身体会。

Yeah, very very interesting.

对,非常有意思。

And you mentioned memories, and I'd also love to chat a little bit about dreaming as well, which is something that you talked about at AI Native DevCon, our our conference in London here.

你提到了记忆,我也很想聊聊 dreaming,那是你在 AI Native DevCon——我们在伦敦办的这场大会上讲过的。

Um and I'd love to talk about that in just a second.

这个我们稍后马上聊。

But before we do, I talked to a little bit about external communities and industry.

但在那之前,我们刚聊了一点外部社群和整个行业。

I'd love to talk about internally at Anthropic now, and how um Anthropic develops software itself.

现在我想聊聊 Anthropic 内部,聊聊 Anthropic 自己是怎么开发软件的。

Yeah.

好。

Um and then I'll love to talk a little bit about how Anthropic uses Claude Code generally in the org as well as coding.

然后我还想聊聊,除了写代码,Anthropic 在整个组织里总体是怎么用 Claude Code 的。

So So first of all, why don't we go back to day zero?

那首先,我们何不回到第 0 天?

Uh Boris is playing around in his basement playing, you know, building this thing called Claude Code.

Boris 在自家地下室里瞎捣鼓,正在做一个叫 Claude Code 的东西。

Take us through that story.

带我们过一遍那个故事。

Yeah, so this is like very much um like a side project that Boris was working on.

是的，这真的就是 Boris 当时在做的一个 side project。

Um and I think there's first of all, like culturally at Anthropic, there's this real um there's this real experimental culture.

我觉得首先，从文化上说，Anthropic 内部本来就有一种很强的实验文化。

Like people are always building their own tooling and experimenting with things, and this was something that Boris was working on.

大家总在自己造工具、自己捣鼓各种东西，Boris 当时做的就是这么一件事。

And the funny thing is that originally, I think when he shared this in a Slack post, it got like six reactions.

有意思的是，他最初把这个发到 Slack 上的时候，只收到了 6 reactions。

Which always tells you that like you just like data isn't perfect.

这件事总在提醒你：数据并不完美。

You can't There's not like perfect processes for understanding like what what good products look like, etc. Um but a couple of people like saw this and were really excited by it and continued to work on it.

你没法——并没有一套完美的流程能告诉你什么才算好产品之类的。但有几个人看到了，特别兴奋，就接着把它做下去了。

And over a short period of time, we saw like amazing adoption within the company, like half of the company using this like weekly.

很短的时间里，我们就看到公司内部的采用率高得惊人，差不多一半的人每周都在用它。

Um another thing that's important here, and I think it's a really key principle when when you're developing products in this space is that we saw a real takeoff in the adoption of this product once the models improved a little bit more to make it like really achievable to kind of work on these coding tasks for long periods of time.

另一件重要的事，我觉得这也是在这个领域做产品的一条关键原则：这个产品的采用率真正起飞，是在模型又强了一点、让长时间连续处理这些编码任务真正变得可行之后。

So like early iterations felt a lot less agentic.

所以早期那几版感觉上 agentic 程度要低得多。

Uh they, you know, it it just was more similar to kind of just like getting like chunks of code back through, whereas later it really could start to like access different kinds of tools, work really efficiently over the code base, um and like stay on top of a lot of context and stay goal-oriented.

那时候它更像是把一块块代码吐回来给你；而后来它真的能开始调用各种工具、在代码库上高效地干活，同时掌住大量 context、保持目标导向。

So one of the big things that we always say to people when they're developing is like build for where the models are going to be in the future.

所以我们总跟做开发的人强调的一点是：要按模型未来会到的水平去构建。

Don't build for where they are today because as we've said, these things move so quickly.

不要按它们今天的水平去构建，因为就像我们说过的，这些东西变化实在太快。

Super interesting.

非常有意思。

And there's a couple of things I want to unpack here.

这里有几点我想拆开聊聊。

Of course.

当然。

So so let's jump into the dogfooding first of all.

那我们先从 dogfooding 聊起。

Cuz I think this was This is a real like dogfooding success story within Anthropic, right?

因为我觉得这在 Anthropic 内部算是一个真正的 dogfooding 成功案例，对吧？

Um it it was it was it was documented how popular Claude Code was internally, yeah, and how it kind of it how it was realized all of a sudden that actually this is a this is a huge thing that if our engineers are using this so so broadly and getting so so value out of this, this is something we absolutely need to productize.

有人记录过 Claude Code 在内部有多受欢迎，也记录过大家是怎么突然意识到这是件大事的——如果我们的工程师用得这么广、从里面拿到这么大的价值，那这东西我们绝对得产品化。

Um talk about talk about how you know, when Anthropic knew this was super valuable and and and you know, wanting to share this with the with the broader audience.

讲讲 Anthropic 是什么时候意识到这东西极有价值、又是怎么想把它分享给更广的人群的。

Yeah, so I think it comes back to this idea that I think like I think like half I think it was like half of the team that time were just like using Claude Code every week, which is quite crazy like for a for a new product.

是的，我觉得这还是回到刚才那个点：当时差不多一半的团队每周都在用 Claude Code，对一个新产品来说这挺疯狂的。

I think that sense of internal PMF really made us realize that it was time to release this product more broadly.

那种内部 PMF 的感觉真的让我们意识到，是时候把这个产品更广泛地发布出去了。

And it's really the same story with Claude Tag.

Claude Tag 也完全是同一个故事。

Like like I said, prior to the release 65% of our PRs have been raised by Claude Tag.

就像我说的，在发布之前，我们 65% 的 PR 都是 Claude Tag 提的。

And I think there comes a is really leading into like like where we see model capabilities today and it's the one that's really our daily driver at this point.

我觉得这真的是顺着我们今天看到的模型能力在发力，它现在是我们真正的日常主力工具。

And I think one of the the big patterns there is like what happened with Claude Code is at first it was all of the engineers who were relying on this to ship a ton of code really quickly.

我觉得这里一个很大的模式是：Claude Code 当初也是这样，一开始是所有工程师靠它飞快地交付大量代码。

And then we saw this pattern where all of the teams at Anthropic were like totally going all in on Claude Code.

接着我们看到这样一个模式：Anthropic 的所有团队都彻底全押在 Claude Code 上。

Like there's this crazy story of someone on the marketing team whose day started with like Googling what the terminal was and how to use it.

市场团队有个人的故事特别疯狂：他那天是从 Google 搜「terminal 是什么、怎么用」开始的。

And by the end of the day they'd like automated one of their workflows which took them 30 minutes and now it took 30 seconds.

到那天结束，他已经把自己的一个工作流自动化掉了，原来要 30 minutes，现在只要 30 seconds。

Like they were able to produce these like ads in that short period of time.

他们能在这么短的时间里做出这些广告。

And so I think what we've seen is like everyone is seeing the power of these tools and is very is able to kind of creatively find ways to map that to their workflows um in different different domains that are not coding.

所以我觉得我们看到的是：每个人都在体会到这些工具的威力，也都能很有创造性地找到办法，把它对接到自己在非编码的各个领域里的工作流上。

Maybe that kind of problem of verification and context is a bit harder.

在那些领域，验证和 context 这类问题可能会更难一点。

Like you're not set up so well with like neat file systems, GitHub to kind of manage your version control and like the ability to kind of unit test things.

你的条件没那么好——没有整齐的文件系统，没有 GitHub 帮你管版本控制，也没有做单元测试的能力。

Like you have to be a bit more creative, but I think that that's like where we're all headed, right?

你得更有创造性一点，但我觉得那就是我们所有人要去的方向，对吧？

Like we're able to kind of set out like outcomes and success criteria or rubrics for like what a good document looks like or what a good briefing looks like.

我们可以把预期结果、成功标准，或者说判定一份好文档、一份好 briefing 长什么样的 rubric 定出来。

Um, people are, you know, changing their behavior around how they uh, kind of create and produce data and where they store it so that agents are able to more easily access that.

大家也在改变自己的行为方式——怎么创建和产出数据、把它存在哪里，好让 agent 更容易取用。

So, like we have this huge culture Anthropic where we work really, really publicly in Slack.

比如 Anthropic 有一个很强的文化：我们的工作非常非常公开地放在 Slack 里进行。

Um, and so we we do that on purpose because it means that our agents can kind of connect the dots in ways that no person could like possibly ever have the visibility over.

我们是刻意这么做的，因为这样我们的 agent 就能把各种点连起来——那种全局视野是任何个人都不可能有的。

So, sometimes like I was working on I like to the extent where my I talk to Claude Tag in a public channel.

所以有时候——我甚至做到这种程度：我在公开频道里跟 Claude Tag 对话。

Like all of my work with Claude Tag, unless it's something that's really private, I do in a public channel.

我跟 Claude Tag 的所有工作，除非是真的很私密的内容，都在公开频道里做。

And it means sometimes people on my team people like in my company who I've never met will message me being like, "I saw you working on this thing.

这也意味着有时候我团队里的人、公司里我从没见过的人会给我发消息说：「我看到你在做这个东西。

Like I'd love to use it.

我很想用它。

Like, please can you tell me like is that shareable and like can we collaborate on this kind of thing?" So, I think just the ability to kind of connect an organization at that scale is only possible because of the kinds of tools that we have.

能不能告诉我这个能不能共享、我们能不能在这类事情上一起做？」所以我觉得，能把一个这种规模的组织连起来，只有靠我们手上这些工具才做得到。

Super interesting.

非常有意思。

It's actually it resonates a lot because even our legal team, for example, you know, build apps using Claude Code, add some skills, check our skills into the Tessl registry.

这其实很有共鸣，因为连我们的法务团队都在用 Claude Code 做应用、加一些 skills、把我们的 skills 提交进 Tessl registry。

And it's like it it's it's it's amazing how much that's empowering not just the engineering community but the the the the whole organization which we'll touch in a little bit more depth.

这真的很惊人：它赋能的不只是工程群体，而是整个组织——这点我们待会儿会聊得更深一些。

Um, I'd love to ask the question about, you know, when there's so much of a dogfooding culture around Claude Tag, around Claude Code in in the early days as well, how much is the product direction driven by your internal feedback and and the [clears throat] internal dogfooding?

我很想问一个问题：围绕 Claude Tag、以及早期围绕 Claude Code 有这么强的 dogfooding 文化，产品方向有多大程度上是由你们的内部反馈、内部 dogfooding 驱动的？

Yeah, that's a a really good point.

是的，这个点提得非常好。

Um, I think this is yeah, this is really important but I think there's a there's a couple of things to think about here because like quite often with I think product development in the agentic era there's there's things that on the surface look like an amazing idea and feel like an amazing experience like single player.

我觉得这确实很重要，不过这里有几点要想清楚：在 agentic 时代做产品，经常有些东西表面上看是个绝妙的主意，在单人（single-player）场景下体验也很好。

But when you really think about what it takes to scale that thing to the enterprise it's a really different shape of problems. So, like in terms of the interaction with Claude Tag, like I think we all knew really early that this was something that was working really effectively.

但你真去想把它扩展到企业级需要什么，那就是完全另一种形态的问题了。所以就跟 Claude Tag 的交互而言，我觉得我们都很早就知道这东西跑得非常有效。

Um we're also aware that like at Anthropic, we're pretty liberal with the way that we like or we're pretty generous with the way that we like share information with each other.

我们也清楚，在 Anthropic，我们彼此分享信息的方式相当放开——或者说相当大方。

Obviously, there's like some very like strong guardrails there for like what is like strictly private information to a team, but we kind of have all of that set out in our like Slack workspaces etc. Like we have really good guardrails for the permissioning.

当然，一个团队严格意义上的私密信息，那里有非常强的护栏（guardrail），但这些我们在 Slack workspace 之类的地方都设定好了。我们在权限体系上有很好的护栏。

And what that means is that within those spaces where you know that it's like trusted places to share information, people can be really open and that's what allows our agents to perform really well.

这意味着，在那些你知道可以放心分享信息的空间里，大家可以非常开放，而这正是我们的 agent 能表现得这么好的原因。

So, one of the design um one of the design principles that we had with Claude Tag is just like we've really carefully designed how you permission each channel.

所以我们在 Claude Tag 上的一条设计原则就是：非常仔细地设计了每个频道的权限该怎么配。

So, each channel um the workspaces and the channels have their own permission scopes in terms of what tools they can access, what API keys they have for different services and connectors, um and potentially what other channels etc. they can access.

每个频道——workspace 和频道——都有自己的权限范围：能访问哪些工具，为不同的服务和 connector 持有哪些 API key，以及可能还能访问哪些别的频道等等。

So, I think like obviously on one level, we want to kind of share what cultural practices are allowing us to um work really well with agents.

所以我觉得，在一个层面上，我们当然希望分享出来：是哪些文化做法让我们能跟 agent 配合得这么好。

So, one of these is like working in public.

其中一条就是公开地工作。

But at the same time, make sure that our products come with the guardrails baked in so that you can reasonably achieve this behavior in a way that's not like that you can actually scale to an enterprise.

但同时也要确保我们的产品自带内置的护栏，让你能以真正可以扩展到企业级的方式，合理地实现这种行为。

Like we think that that that works really well.

我们觉得这套跑得非常好。

Um another thing that we did to make this uh work more effectively is we came up with this concept of agent identities.

我们为了让这件事跑得更有效还做了另一件事：提出了 agent 身份这个概念。

So, one really big difference between Tag and you working with like Claude Code or CoWork is when you work with Claude or CoWork, they kind of assume your own permissions.

Tag 和你用 Claude Code 或 CoWork 之间一个非常大的区别是：你用 Claude 或 CoWork 的时候，它们基本上是沿用你自己的权限。

So, I'll they'll kind of you work using kind of uh my API like yeah, my API keys or my permission systems and I grant access to all those things.

也就是说，它们干活用的是我的 API key 或者我的权限体系，是我把这些东西的访问权授给了它们。

Whereas with Claude Tag, we actually give that um agent its own permissions and its own keys etc. so that it can go off and like work autonomously on these things.

而在 Claude Tag 这边，我们实际上给这个 agent 它自己的权限、它自己的 key 等等，这样它就能自己跑出去自主地做这些事。

Um it's not working on behalf of one individual, it's working on behalf of the team.

它不是代表某一个个人在工作，它代表的是整个团队。

And it's much easier to kind of audit that.

而且这样审计起来也容易得多。

It's not like doing this as you, it's doing this as itself.

它不是以你的身份在做这件事，而是以它自己的身份在做。

And so that's another key architectural change that we needed to do to enable this multiplayer behavior.

所以这是我们为了让这种多人协作行为成为可能，必须做的另一项关键架构改动。

Um So yeah, I think to round that point off, there's definitely a lot of the kind of product level feedback um that all of the teams will chip in with and will make sure that it really works for different kinds of use cases and different types of users.

所以，把这个点收个尾：确实有大量产品层面的反馈是各个团队补进来的，这些能确保它对不同类型的用例、不同类型的用户都真的好用。

But at the same time, we think a lot of the work goes into making sure that this is something that actually scales to enterprises and people can really get value out of.

但同时，我们认为很大一部分工作是花在确保这东西真的能扩展到企业、人们真的能从里面拿到价值上。

Amazing.

太棒了。

And let's let's talk I know our audience as well as the industry, the way they improve, the way they get better is through understanding and hearing what not just what worked for us, but also how we tripped over, how we fell and had to had to get up and try and find another another path.

我们来聊聊——我知道,我们的听众也好、整个行业也好,要进步、要变得更好,靠的是了解和听到:不只是哪些做法对我们奏效了,还有我们是怎么绊倒的、怎么摔了一跤、又得爬起来另找一条路的。

And I'm sure Anthropic just like every organization have, you know, areas that they that they tried and and and and didn't get on with.

我相信 Anthropic 跟每家公司一样,也有些地方试过但不对路。

So I guess from an adoption point of view or from a ways of working with agentic coding, what were some of your or Anthropic's greatest learnings would you say in the way you were using Claude Code, the way you were using maybe even Claude Tag as well?

所以我想问,从采用的角度,或者从 agentic 编码的协作方式来看,你或者 Anthropic 在用 Claude Code、甚至在用 Claude Tag 的过程里,最大的收获有哪些?

Yeah, of course.

当然。

Um so I think yeah, there's a few.

我觉得有几点。

There's like some on the development side and some on the behavioral side.

有些在开发层面,有些在行为层面。

I think on the development side, one thing I said before like we should always build for like what you think is going to be like where the models are headed, not where they are today.

开发层面,我前面提过一点:我们应该始终面向你判断的模型走向去构建,而不是面向它们今天的水平。

And one thing that we think about a lot on the Claude Code side is every time that we have a new model, we've discussed kind of how those models themselves become more capable in certain dimensions.

在 Claude Code 这边我们经常想的一件事是,每次有新模型出来——我们前面也讨论过——模型本身在某些维度上都会变得更强。

And what that means is that we like very regularly revisit what those harnesses look like.

这就意味着,我们会非常频繁地重新审视那些 harness 该长什么样。

And we're very happy to like delete stuff from that harness over time to make it more simple and more lightweight and just let the model do the heavy lifting.

而且我们很乐意随着时间从 harness 里删东西,让它更简单、更轻,重活交给模型去干。

So over time, we see something like the harness actually gets smaller because like we can trust the model more with certain capabilities and we just need what's there to like, you know, give it the tool use and infrastructure that it needs.

所以随着时间推移,我们看到 harness 本身反而变小了,因为某些能力上我们可以更信任模型,留下的部分只需要给它工具调用和它需要的基础设施。

So that's one thing.

这是一点。

I think it does new model doesn't mean like chuck in like way more prompts and way more more architecture.

我觉得,新模型不代表要塞进多得多的 prompt、多得多的架构。

Sometimes it means like less is more.

有时候恰恰是少即是多。

Um I think another thing is like to to reference back to that talk that I did for you guys on dreaming.

另一点,得回到我给你们做的那场关于 dreaming 的分享。

We, especially working with startups, I get a lot of people asking me about memory and context infrastructure in particular.

我们——尤其是在跟创业公司打交道时——很多人会来问我记忆,特别是 context 基础设施的事。

And you know, it's it's not a one-size-fits-all kind of solution.

而这件事上并没有一套通吃的方案。

And I think that, you know, people come up with really innovative ways to structure their memory databases or memory structures, etc. And the solution we have in our managed agents API is like a very simple memory file system that just leans on agents' abilities like read and write to to memory.

我觉得,大家会想出非常有创意的方式来组织自己的记忆数据库、记忆结构等等;而我们在 Managed Agents API 里给的方案,是一个非常简单的 memory 文件系统,直接依赖 agent 自己读写记忆的能力。

And something I touched on on in that talk is that we tried a lot of different things in the past like indexed um memory stores or like tools that were very specific about how to read and write to memory.

我在那场分享里也提到,我们过去试过很多不同的做法,比如带索引的 memory store,或者把怎么读写记忆规定得很死的工具。

And I think what we learned over time was like this was just this had a like a number of problems like sometimes we were being too opinionated about how the agents should interact with memory and they were better left especially as they became more capable to just manage that themselves and they were great at just using file systems and the native like bash and grep tools.

我觉得我们后来学到的是,这类做法有一堆问题:有时候我们对 agent 该怎么跟记忆打交道管得太死,其实更好的办法是让它们自己管——尤其是它们能力越来越强之后;而它们直接用文件系统、用 bash 和 grep 这些原生工具,就用得非常好。

So one thing we learned was like we could actually just remove some of these abstractions and even our like being opinionated on the structure of those like memory structures, um we realized over time that like indexing it wasn't something that we thought was best practice across the board and we thought a simple file system was better.

所以我们学到的一点是,其实可以把这些抽象拿掉一部分,连我们对那些记忆结构该长什么样的预设也可以拿掉;我们慢慢意识到,加索引并不是我们眼中放到哪儿都成立的最佳实践,简单的文件系统反而更好。

So obviously you have to learn these things by trying um and all of these things are very open areas of research and development and I'm sure we'll find more best practices down the line.

这些事情当然只能靠试才学得到,而且它们都还是非常开放的研究和开发方向,我相信往后我们还会摸出更多最佳实践。

But these are a couple of examples where we've kind of tried a few things out and simplified our workflows a bit.

但这算是两个例子:我们试了一些东西,然后把工作流简化了一点。

It's really interesting I'm really curious about the kind of like the context piece because or not sorry, the context piece but the the the the agentic model changes and the whether it's the agent change or the model change, it really does affect what we actually need to provide it whether that's context or memory in order for it to perform the best it can.

这真的很有意思,我特别好奇 context 那一块,因为——不,抱歉,不是 context 那块,而是 agentic 模型这边的变化。不管变的是 agent 还是模型,它确实会影响我们到底得喂给它什么,不管那是 context 还是记忆,它才能跑出最好的效果。

And I think And I think what's most interesting is we don't need to change our code or our context in order for us to need to rerun an eval to see is this actually still valuable in its current state or because of a model change or because of a an agent upgrade, you know, do I actually need to provide it with less context because the model of the agent has actually got better doing these things without the context.

我觉得最有意思的是,并不需要我们改自己的代码或 context,就已经有理由重跑一遍 eval 了——看看这东西在当前状态下还值不值,或者因为模型换了、因为 agent 升级了,我是不是其实该少给它 context,毕竟模型或者 agent 在没有那些 context 的情况下已经做得更好了。

And as a result, am I just bloating context by adding this skill or am I or do I need to change the skill for this model?

于是问题就变成:我加上这个 skill,是不是只是在把 context 撑胀?还是说我得为这个模型改一改这个 skill?

And I think it's that continuous evaluation of our environment that we need to do on a regular basis to say what do I need to change?

我觉得,正是这种对自身环境的持续评估,需要我们定期做一遍,来回答:我该改什么?

Is it the context?

是 context 吗?

Is it my prompt?

是我的 prompt 吗?

Is it my harness because of an agent change?

还是因为 agent 变了,该改的是 harness?

Yeah.

对。

And that's like it sounds like that's something that's very commonplace then within Anthropic.

听起来,这在 Anthropic 内部是件很常规的事。

Yeah, so I think when we're when we're testing these new models, um especially on the applied AI side because we're working closely with with customers, uh we'll in our early early stages of testing like really look out for what are these changes in behavior that we need to prompt around and like where are the areas that we can be a bit more relaxed about now because the the model is just better.

对,我觉得我们测这些新模型的时候,尤其在 applied AI 这边,因为我们跟客户配合得很紧,测试的最早期阶段我们就会特别留意:哪些行为变化需要我们用 prompt 去应对,以及哪些地方现在可以松一点,因为模型本身就是更强了。

So, we'll always like come out with some guidance on like what are the best practices for working with this new model and help uh customers with those migrations as well.

所以我们每次都会出一份指引,讲清楚跟这个新模型协作的最佳实践是什么,也会帮客户把迁移做完。

So, yeah, there's a lot of helpful resources that we'll always publish around model releases to help people make sure that they can like move over really easily.

所以说,每次模型发布我们都会放出不少有用的资料,确保大家能非常轻松地迁过去。

Let's talk a little bit about you mentioned very briefly a while back about how the marketing team, for example, created an app, which is wonderful and I and I think Claude Tag really makes this easier and empowers people because you know, folks who are non-technical or rather outside of the engineering team are probably much more comfortable engaging and interacting with an agentic coding environment when they're doing it through Slack.

我们来聊聊你前面很简略提到的一件事——比如市场团队做了一个 app,这很棒,我觉得 Claude Tag 确实让这件事变得更容易,也把能力交到了更多人手上,因为非技术的人、或者说工程团队之外的人,如果是通过 Slack 来做,多半会自在得多,更愿意去接触和使用 agentic 编码环境。

How has Anthropic used Claude Code, Claude Tag outside of the traditional engineering spaces?

Anthropic 在传统的工程场景之外,是怎么用 Claude Code 和 Claude Tag 的?

Yeah, in in just so many ways, honestly.

说实话,用法实在太多了。

Um I think every team, like the whole company is running on the rails of Claude.

我觉得每个团队——其实整个公司都跑在 Claude 的轨道上。

Like ultimately, um another another like fun stat is in the last year, the amount of work which we as a company are comfortable delegating to Claude across all teams has doubled.

另一个有意思的数据是:过去一年里,我们整家公司各团队愿意委派给 Claude 的工作量翻了一倍。

So it's gone out from like 30% to like 60% in terms of like where we're able to rely on Claude.

就我们能依赖 Claude 的程度而言,从 30% 涨到了 60%。

So yeah, the marketing one is fun.

所以是的,市场团队那个例子挺有意思。

That one was like a like a pipeline for like ad generation or like copy generation.

那是一条做广告生成、或者说文案生成的流水线。

We have a lot of our like um incident response infrastructure also relies on Claude to some extent to like triage things and like looping the right people.

我们相当一部分故障响应基础设施也在一定程度上依赖 Claude,来做分级、把对的人拉进来。

Um and where it can, it can kind of like start to diagnose like code problems, etc. So all of these different solutions rely on slightly different configurations of your agent.

力所能及的地方,它还能开始诊断代码问题等等。所以这些不同的方案,各自依赖的 agent 配置略有不同。

So like for example, on sales, we um on our sales teams, we have like weekly briefs that Claude kind of like runs over what everyone did that week and gives you all of the stats and dashboard updates so that everyone's ready for the meeting and nobody had to like labor over the slides.

比如销售这边,我们的销售团队有每周简报,Claude 会把每个人那一周做了什么过一遍,给出所有数据和 dashboard 更新,这样大家开会前就都准备好了,没人再需要费劲折腾幻灯片。

So that's one thing that just like runs on a schedule.

这件事就是按时间表定时跑的。

It's just like so clearly a time save for everybody.

它给所有人省下的时间显而易见。

And then there's other things that are more responsive like these incident response things where Claude knows when to jump in, and it knows how to like proactive to be.

另外还有一些更偏响应式的事,比如刚说的故障响应,Claude 知道什么时候该介入,也知道该多主动。

So, that we really see like all flavors of these things.

所以这些东西的各种形态我们都见到了。

Um like I, for example, on when I'm developing products, I'll have like interfaces where I can like type feedback into prototypes, and then there's like Claude Code will just like work on those in the background.

比如我自己做产品的时候,会搭一些界面,可以直接把反馈打进原型里,然后 Claude Code 就在后台处理这些反馈。

So, everyone builds their own tooling in this sense.

所以在这个意义上,每个人都在搭自己的工具。

And I think a lot of this has gone into how we've thought about that development of tag then, which is Claude Tag, which is meant to be um really accessible across the board for all teams. And for example, like that proactivity thing is something you can really dial up and down.

我觉得这些经验里很多东西,后来都进到了我们对 Tag——也就是 Claude Tag——开发思路的思考里,它的定位就是让所有团队都能普遍上手。比如主动性这件事,就是你可以真正调高调低的。

So, you can have everything from like Claude only responds when it's tagged, or Claude uh creates a schedule on which it runs its tasks, or Claude like will proactively jump into threads here when it thinks that it's got relevant context to share.

所以从「Claude 只在被 tag 时才回应」,到「Claude 自己定一个时间表、按表执行任务」,再到「Claude 觉得自己有相关 context 可以分享时,主动跳进某个 thread」,全都可以。

Um and what we've learned from like previous products like Claude Code um and also on our managed agents is like what works well in terms of this like scheduling and like knowing how proactive to be, because the worst thing in the world is a bot that responds to everything with kind of annoying context.

我们从 Claude Code 这类早先的产品、以及我们的 Managed Agents 上学到的,是在定时调度、以及判断该多主动这件事上什么做法有效——因为世上最糟的东西,就是一个什么都要回一句、还带着一堆烦人 context 的 bot。

We see this proactivity thing as a real um spectrum, and we've like kind of really tuned over time so that kind of knows what's appropriate, where to jump in, and when not to, and when to do things on a programmatic schedule.

我们把主动性看成一个真正的连续区间,并且随着时间不断调优,让它知道什么算合适、该在哪里介入、什么时候别介入、什么时候该按程序化的时间表做事。

Uh and that's something that you can also steer as a team.

这也是团队自己可以去引导的。

Like if Claude does something that you think is not not aligned with your preferences, you can just tell it, and it will update its memory and behave um more similarly to what you want in the future.

比如 Claude 做了某件你觉得跟你偏好不符的事,直接告诉它就行,它会更新自己的记忆,以后的行为会更接近你想要的样子。

Yeah.

是的。

Yeah, kind of reminds me of thinking back to a previous episode that we ran of something which Olivier Pomel, the CEO of Datadog, was was talking about about how, you know, is us getting up, humans getting up at 3:00 a.m. because of a of a critical issue, uh you know, how long is that actually going to last for?

是的,这让我想起我们之前做过的一期节目,Datadog 的 CEO Olivier Pomel 在里面聊到:我们、人因为一个严重问题在 3:00 a.m. 爬起来,这种事到底还能持续多久?

How much do we trust agents to go ahead and, you know, on an incident actually um you know, go ahead, make a fix that could be reversible, hopefully will be reversible, and then maybe in the morning we wake up, notice something happened, and and choose if it's the right way of doing something, perhaps reverse it, do it a different way, but we can allow we can rely upon agents to do this.

我们能多信任 agent 直接上手,在一次故障里做一个可以回滚、但愿是可以回滚的修复,然后我们早上醒来,发现出过事,再判断这是不是正确的做法,也许把它回滚掉、换一种方式来做——但我们可以放手让 agent 干这件事、可以指望 agent 干这件事。

And thinking about what you were saying, I I kind of like envision this space whereby we have observability data, which is maybe even going into into into Slack, providing information, and then I can see something like Claude Tag looking at something like that, and then when it realizes something is perhaps a little bit off, looking say, "Oh, should I raise the incident?" And you'll just like have you know, an agent like Claude Tag saying, "Actually, I am going to raise an incident here, and then I'm going to do some make some changes, document what I'm doing, make my change, push that." Is is you know, it feels like this is actually I'd love to actually experiment with this now and actually see if that's a an interesting path.

顺着你刚说的往下想,我大致能想象出这样一个场景:我们有可观测性数据,甚至可能直接进到 Slack 里给出信息,然后我能想到像 Claude Tag 这样的东西去盯这些数据,当它发现有些地方不太对,就会问「哦,我该不该报一个故障?」——然后你会看到 Claude Tag 这样的 agent 说「其实我打算在这里报一个故障,接着我要做些改动、记录下我在做什么、把改动做完、推上去」。感觉这条路我现在就很想真的试一试,看看是不是一条有意思的路。

Is that something you do at Anthropic?

这是你们在 Anthropic 正在做的事吗?

So, yeah, the the incident response agent is definitely a pattern that we see working really well.

是的,故障响应 agent 绝对是我们看到效果非常好的一种模式。

Uh and as somebody who used to be an engineer who was on call, I know the fear of the PagerDuty call coming through at 3:00 in the morning, and it's not a nice one.

作为一个当过工程师、要 on call 的人,我很清楚凌晨 3:00 收到 PagerDuty 电话是什么恐惧,那可不好受。

Um but I think this is a really interesting one which which plays on a couple of important design principles.

但我觉得这个例子很有意思,它牵涉到几条重要的设计原则。

Like one is how much how much First of all, like for this agent to do a good job, you need to give it good good access to different data sources.

一是——先说第一点——要让这个 agent 干得好,你得让它能好好接入各种数据源。

So, like your data warehouse, um potentially like whatever logging and metrics you have, and also potentially your repository so that it can start to diagnose things.

比如你的数据仓库,可能还有你手上的日志和指标,以及可能还有你的代码仓库,这样它才能开始诊断问题。

This is like a very good starter kit, I think, for that kind of agent.

我觉得这就是这类 agent 非常好的一套起步套件。

Um but [snorts] the other thing that's really important and actually something which feeds into how we designed our managed agents uh product, is where do you want to design those gates between like human agent interaction?

但另一件真正重要的事——也确实影响了我们怎么设计 Managed Agents 这个产品——是:人与 agent 交互之间的那些闸口,你想设在哪里?

So, it's really up to teams, and we totally understand that rolling these things out at scale needs this like journey of trust that you need to go on.

这完全取决于团队,我们也完全理解,把这些东西大规模铺开,需要走过一段建立信任的历程。

So, like maybe when you start doing this, you just like let Claude have a go, and you also like keep your traditional process, and you just like check that on whatever like success threshold it did what you wanted it to and then over time you like get more confident like delegating more and more of that work over or maybe it just starts like diagnosing fixes and passing that over to engineering team waking them up up if it they think it's critical enough to like potentially starting to raise a draft PR to like whatever other like gates of access you want.

所以刚开始做的时候,也许就是让 Claude 试一把,同时保留你传统的流程,你只是按某个成功阈值去检查它有没有做到你想要的;随着时间推移,你会更有信心把越来越多的工作委派过去;或者也许它一开始只是诊断问题、给出修复,再把结果交给工程团队,如果它判断足够严重就把人叫起来;一直到可能开始提一个 draft PR,再到你想设的任何其他访问闸口。

So I think this is just like one of those where you can really see the value for like engineering teams of like this being a massive problem and helping you resolve incidents much faster which is definitely what we've seen internally and just needs you to like carefully think about like yeah where do you want Claude to ask for your your approval on these things and that's something that is you know teams themselves should think about and configure we can suggest like what we've seen work well but it's a yeah I think it's obviously a high trust.

所以我觉得这就是那种你能真切看到价值的场景:对工程团队,故障是个大问题,而它能帮你把故障解决得快得多,这也确实是我们内部看到的;它只需要你仔细想清楚,你希望 Claude 在哪些事上来请求你批准——这是团队自己该去思考和配置的,我们可以给出哪些做法我们见过有效的建议,但这显然是件高度依赖信任的事。

Yeah it's funny actually on my previous laptop I used to have a sticker that said AI works while I sleep and now I'm kind of like there will be a you know we'll break through that trust barrier and it will be AI fixes production while I sleep and it's it's it's a it's the right path I think it's a it's it's you know in terms of diagnosing in terms of getting root causes agentic you know agents will find that data more accurately quicker I think and the the the loss of the outage you know it's more expensive sometimes when you look at it from the from the cost of an outage to have a have a a human you know diagnose find the root cause propose a fix etc etc. So there's definitely an interesting balance there that we're going to see how it's going to be it's going to be fascinating to see that that shift.

是的,说来有趣,我以前那台笔记本上贴过一张贴纸,写着「AI 在我睡觉时干活」;现在我觉得,我们会突破那道信任门槛,变成「AI 在我睡觉时修生产环境」,我觉得这是对的方向;就诊断问题、找根因来说,agent 会更准、更快地找到那些数据,我是这么认为的;而宕机的损失——有时候你从一次宕机的成本去算,让一个人去诊断、找根因、提修复方案等等,反而更贵。所以这里面确实有个很有意思的平衡,我们会看到它最后是什么样子,看这个转变会非常精彩。

Definitely definitely and I think in any case I would much rather be woken up with a call that's like hey there was this incident I think this is the PR that fixes it here's the test I ran to verify that's the case like this is the blast radius I'd much rather that was I wake up to than like please can you like look at this incident and figure out what happened?

绝对是,绝对是。而且我觉得不管怎样,我宁愿被这样一个电话叫起来:「嘿,出了这么一个故障,我认为这个 PR 能修掉它,这是我跑来验证的测试,这是影响面」——我宁愿醒来看到这个,而不是「麻烦你看看这个故障,搞清楚发生了什么」。

Exactly exactly so even if you still have that human gate, I think that like that information handover looks quite different in the two cases.

正是如此,正是如此,所以即使你仍然保留那个人工闸口,这两种情况下的信息交接也很不一样。

So, I'd happily like approve that PR.

所以我会很乐意批准那个 PR。

Absolutely.

完全同意。

So, Lamis, you you gave a wonderful session at AI Native DevCon London just a number of weeks ago actually.

那么 Lamis,其实就在几周前,你在 AI Native DevCon London 上做了一场很精彩的分享。

And in fact, we have AI Native DevCon in New York, which was announced.

而实际上,我们还宣布了纽约的 AI Native DevCon。

That's going to be happening in November 2026.

那场会在 2026 年 11 月举行。

So, take a look at that as well.

所以也可以关注一下那场。

And now you mentioned a concept called dreaming, which was super curious.

然后你提到了一个叫 dreaming 的概念,这个我特别好奇。

First of all, why don't you tell us a little bit about dreaming what it is?

首先,你能不能先跟我们讲讲 dreaming 是什么?

So, dreaming is a research preview feature that we have on our managed agents offering.

dreaming 是我们在 Managed Agents 这个产品上推出的一个 research preview 功能。

And for those who aren't familiar with managed agents, it's called managed agents.

可能有人不熟悉 Managed Agents——产品名就叫 Managed Agents。

This is a product which essentially allows you to build and deploy agents much faster in production.

这个产品本质上是让你在生产环境里构建和部署 agent 快得多。

So, we've we take on a lot of the everything from kind of managing the harness of your agent on Anthropic's side, some of the infrastructure and the observability, etc. And what we're really doing with this product is taking all the learnings that we've we've got from building these agents over some period of time and building them into like really concrete primitives like agents and environments and sessions that allow you to quickly compose those agents and deploy them really fast. So, that's the managed agents product.

我们替你接下了很多事:从在 Anthropic 一侧管理你 agent 的 harness,到一部分基础设施和可观测性等等。而我们用这个产品真正在做的,是把一段时间以来构建这些 agent 攒下的全部经验,沉淀成非常具体的原语,比如 agents、environments、sessions,让你能迅速把 agent 组合起来、飞快部署。这就是 Managed Agents 产品。

And of course, given how important context has been as a concept in agentic development, it wouldn't be complete without a memory feature.

当然,考虑到 context 这个概念在 agentic 开发里有多重要,少了记忆功能它就不算完整。

So, this allows agents to read and write to different memory stores as they learn things.

它让 agent 一边学到东西,一边读写不同的 memory store。

And that's like very well access gated.

而且访问权限分得很严。

So, there's like huge organization level context which is really important and like can only be read from to like agent scratch pads that allow them to drop context about the work they're doing, which is just amazing in terms of enabling their work.

范围从组织层级那份很重要、但只能读取的巨大 context,一直到 agent 自己的 scratchpad——它们能把手上工作的 context 随手丢进去,这对它们干活的帮助大得惊人。

And like I said, people often ask about like what how what is the best practices for structuring these memory systems. This really starts to run the risk as you run it over longer periods of time that there's like stale information in there.

像我刚说的,大家常问:组织这些记忆系统的最佳实践是什么。而系统跑得越久,风险就越大——里面会积下过期的信息。

Some stuff has gone out of date, uh there's missing information, it's just confusingly written, etc. And so, what we designed and introduced is this concept called dreaming, uh which is kind of what it sounds like, I suppose, where essentially you are able to run these dreaming jobs at whatever cadence you like, where you input some of your memory stores, um and some of your session transcripts from managed agents.

有些内容过时了,有些信息缺失,有些写得让人看不懂,等等。于是我们设计并推出了 dreaming 这个概念,大概就跟它字面听起来的意思差不多:你可以按自己喜欢的频率去跑这些 dreaming 任务,输入一部分 memory store,以及 Managed Agents 里的一部分 session 记录。

So, these are basically uh like basically the traces of how your agents have gone and carried out a couple of tasks.

这些其实就是你的 agent 一路执行几个任务留下的轨迹。

And you push put give this all to another agent, and it basically reviews those transcripts, and it reviews the memories, and it looks for any kinds of discrepancies.

你把这些一并交给另一个 agent,它会审阅那些记录、审阅那些记忆,找出任何形式的不一致。

So, maybe it finds that some information is missing that the agents would have performed better if they had that context, or vice versa that there's something misleading in there, which is degrading performance, um or it just finds a new way to kind of reorganize that information to make it easier to search and surface for the agents.

比如它可能发现某些信息缺失了——agent 当时若有那份 context,表现会更好;或者反过来,里面有些误导性的东西正在拉低表现;又或者它就是找到了一种新的组织方式,让 agent 更容易检索和调出这些信息。

And it does this in all in like a pretty um like a pretty extensive manner.

而它这套活儿做得相当详尽。

Like, it gives you hypotheses for what to change, um gives you attachments to the sessions where it thinks that the evidence is there.

它会给出该改什么的假设,还会附上它认为证据所在的那些 session。

And then you can basically decide which of those changes to implement.

然后你就可以决定其中哪些改动要落地。

And I think what's really important here is like this really opens the path towards continual learning.

我觉得这里真正重要的一点是,它确实打开了通往持续学习的路径。

Like, this idea that you can run your agents on one day, and then based on whatever could have been optimized, you can run them the next day and actually see that they get better.

就是这么个想法:今天跑一遍你的 agent,再根据哪些地方本可以优化,第二天再跑一遍,而且真能看到它们变好了。

And with dreaming, you can kind of hand over that kind of to to to a a large degree, like allow that process to run in an automated fashion, and then just approve whatever you think is is relevant.

而有了 dreaming,这件事你可以很大程度上交出去,让这个过程自动跑起来,你只批准你认为相关的部分。

So, it's uh something we're really excited about, and we've seen a bunch of customers just see much better performance improvements with their deployed agents when they run processes like this.

所以这是我们相当期待的一块;我们也看到不少客户跑了这类流程之后,已部署 agent 的表现提升明显得多。

Amazing.

太好了。

And for if folks in the in the audience who want to learn more, uh your your talk is actually online, so we'll make sure we link uh the audience to that, and you can see Lamis's uh session in full.

听众里想深入了解的朋友,你那场演讲其实网上有,我们会把链接放上,大家可以看到 Lamis 那场 session 的完整版。

And yeah, just add another point there, I guess.

对,我再补一点。

I mean, that it was such a delight to be there that day, and I think, like we said about FOMO with features, it's nice to have the opportunity to speak about one of those

那天能到现场真的很愉快;而且像我们刚说的对功能的 FOMO,能有机会讲讲其中

more um more complicated features potentially that people have less opportunity to use.

一个可能比较复杂、大家平时用得比较少的功能,挺好的。

So, yeah, I hope folks will find that enjoyable.

所以,希望大家看得愉快。

Absolutely.

那当然。

It was a people loved the loved the session.

大家非常喜欢那场 session。

We got amazing feedback about your session.

关于你那场 session,我们收到的反馈特别好。

So, thank you very much for that.

所以非常感谢你。

So, what are we we're we're we're running out of time, but we should we should wrap.

那么,时间快到了,我们该收尾了。

I I'd love um we always love, you know, giving practical advice and and and practical things that our listeners can do.

我们一向喜欢给点实用建议,给听众一些能直接上手去做的事。

Um So, so what would you say is is um something that you would say uh for folks who are maybe, you know, trying to introduce uh maybe it's managed workflows, introducing agentic development further in their organizations?

那对那些想在自己组织里引入——可能是 managed workflows,或者想把 agentic 开发再往前推一步的人,你想说点什么?

Uh what would you say are some day-to-day practices that people can can do from your experience that will that will massively unlock the next stage for folks?

从你的经验看,有哪些日常做法是大家可以直接上手的,能帮他们大幅解锁下一个阶段?

Yeah, of course.

好的,当然。

Um and I think just like thinking about, you know, potentially broad audience here, I would really encourage people to like go and set up Claude Tag and give it a try.

考虑到这里听众面可能挺广,我很建议大家去把 Claude Tag 配起来试一试。

You just need to get your Slack admin to turn it on.

你只需要让你的 Slack 管理员把它打开。

Um and do some of the configuration, but it really doesn't take long.

再做一点配置,但真的花不了多久。

And to give you a flavor of the things that I'm doing with this, so the first thing I set up was a daily briefing.

讲讲我拿它在做的事,让你有个体感:我设置的第一件事是每日简报。

And because of the connectors and context that Tag has access to, it's able to tell me about things that happened over the past 24 hours, especially working with international teams. Like things that my teams who are in San Francisco did, it just like immediately surfaces that all to me.

因为 Tag 能访问那些 connector 和 context,它能告诉我过去 24 小时里发生了什么,跟跨国团队协作时尤其管用。比如我在 San Francisco 的团队做了哪些事,它立刻就全都摊给我看。

So, I don't have to wake up to like a wall of like emails and Slack messages, but I just have a nice curated brief about what needs my attention.

所以我不用一睁眼就撞上一大堆邮件和 Slack 消息,而是直接拿到一份整理好的简报,告诉我什么需要我关注。

Um it has contacts to my ongoing workflows as well, so it can tell me like this thing that I'm working on, maybe this talk, like maybe you want to review these documents before um before doing that, etc. So, daily brief is great.

它也有我正在进行的那些工作流的 context,所以它能告诉我,我手上这件事,比如这场演讲,也许你想在动手前先看看这几份文档,等等。所以每日简报很好用。

Uh and then something else I have set up is it it knows like which channels are important to me, and it pings me about anything urgent that needs my attention on a live basis.

我还设置了另一件事:它知道哪些频道对我重要,任何需要我关注的紧急事,它会实时戳我。

So, anything it sees that like uh thinks is relevant to me, it will tell me about, and that's great because uh whilst working in public as a company is fantastic, it means there's a lot of things going on on Slack and I cannot keep on top of that.

所以任何它看到、觉得跟我相关的事,都会告诉我,这很好——因为公司里的事都公开着做固然很棒,但这意味着 Slack 上有大量动静,我根本盯不过来。

And then some some other things like on a team level, what we have is like Tag will do like weekly reports on various things.

团队层面还有些别的用法,比如 Tag 会就各种事情出周报。

So on the Applied AI team, we have a weekly report of like his different things that the team learned and saw this week, which is really nice.

在 Applied AI 团队,我们有一份周报,汇总团队这周学到和看到的各种东西,挺好用的。

Encourages people to kind of keep sharing that context and really scales that knowledge across the organization.

它促使大家持续分享 context,也真正把这些知识规模化地铺到了整个组织。

So that's cool in terms of like best practices and Yeah, I think these are I think these are a couple of good places to get started and I think you'll very quickly get a feel for what the kind of capability of that is.

所以在最佳实践上,这挺酷的。我觉得这几个是不错的起步点,而且你会很快摸到它的能力大概到什么程度。

You know, one final flourish you can do is like ask Tag to build some custom software for you and it can deploy it into like Claude Code artifact and then you can kind of share that as a even maybe just a personal dashboard or you can share it with your team and be like, "Hey, this is something to track XYZ workflow that we have." So yeah, these are some good places to get started.

最后还能再加个花活:让 Tag 给你写一段定制软件,它可以直接部署成 Claude Code artifact,然后你就能分享出去——哪怕只当个人看板,或者发给团队说“嘿,这个是用来追踪我们那个 XYZ 工作流的”。所以,这些都是不错的起步点。

Amazing.

太好了。

It's actually super timely cuz just this week, I'm a big fan of things like getting things done and the the those types of workflows.

这其实特别应景,因为就在这周——我是 Getting Things Done 这类工作流的忠实粉丝。

And one of my biggest areas of trouble of doing those types of things is the reviews and the check-ins.

而做这类事情最让我头疼的一块,就是回顾和 check-in。

And so what I did was I created an app which I've which I've deployed and it essentially does very similar.

所以我做了个应用,已经部署上线了,做的事基本一样。

It looks through my Slack, it looks through my email, it looks through my Todoist to-do lists.

它会翻我的 Slack、翻我的邮件、翻我的 Todoist 待办清单。

And it also looks through my Granola notes as well

它还会翻我的 Granola 笔记

and it will add a whole bunch of to-dos that I am extracting out from Granola and it will it will essentially say, "Oh, here are some things that you should be aware of or should add to your calendar." It adds them in.

然后把我从 Granola 里提取出来的一大堆待办加进去,并且会说:“哦,这几件事你该知道,或者该加进你的日历。”然后它就加进去了。

It's kind of like a little bit like my EA as well.

它还有点像我的 EA。

And I'll tell you what, that's really unlocking productivity.

跟你说,这真的把生产力解锁了。

So I totally am on board with those reviews, weekly reviews, monthly reviews and daily daily check-ins and reflections.

所以我完全认同这些回顾——周回顾、月回顾,还有每天的 check-in 和反思。

It's it's a real game-changer from a productivity point of view.

从生产力的角度看,这真的是个 game-changer。

Yeah, no, definitely give it a go with Claude Tag and

对,一定要拿 Claude Tag 试一把,而且

to I need to switch to Claude Tag and try

我得切到 Claude Tag 上试试

and see how it goes.

看看效果如何。

Some of the ones I really like as well are like just getting these agents to like tell you what you did well that week.

我自己特别喜欢的一类用法,就是让这些 agent 告诉你,这一周你哪些地方做得好。

Like that's a really nice thing sometimes that you don't have time to reflect on.

这挺不错的,毕竟有时候你根本没时间回头反思这些。

Just like tell me like three wins I had this week.

就比如:告诉我这周我有哪三件事做成了。

Tell me a couple of reflections on things I could like optimize, etc. Um but sometimes like you don't have time to reflect on those things and you know, in the world of AI a lot is happening very quickly.

再给我几条反思,讲讲哪些地方我可以优化,等等。但有时候你确实没时间反思这些事,而 AI 这个世界里,很多事发生得非常快。

It's nice to be able to take moments to reflect on what's going on.

能停下来抽点时间想想正在发生什么,是件好事。

what I also do is I actually also put my I've just recently had an annual.

我还会做一件事——我最近刚做完一次年度评估。

So what I do is I put my annual feedback in

我的做法是,把我的年度反馈放进去

uh as well as other things that I feel like my management team and things like that would would want of me.

还有我觉得管理团队之类希望我做到的其他事情。

And it also gives me feedback based on what I'm doing.

然后它也会根据我正在做的事给我反馈。

Am I am I, you know, taking my next steps in improvement?

我有没有在改进上迈出下一步?

Am I am I doing what the team uh uh are needing from me and those types of things which are actually really valuable in terms of you're doing what you want and actually, you know, other people their needs are also being satisfied by the some of the stuff that you're doing.

我有没有在做团队需要我做的那些事——这类判断其实很有价值:你既在做自己想做的事,同时别人的需求也确实被你做的一些事满足了。

So it it I don't know.

所以……我也说不好。

So all I need is an agent to just do my work as well and then I'm I'm I can just let it go on.

所以我现在只差一个 agent 把我的活也一起干了,然后我就可以撒手让它跑了。

just, you know,

就是说啊,

Yeah.

是啊。

We can we can yeah, go enjoy the sun.

我们就能去晒太阳了。

Amazing.

太好了。

Lamis, this has been this has absolutely flown by.

Lamis,这次时间过得真是飞快。

It's been an incredible discussion.

这场讨论非常精彩。

I very very much thank you not just for AI Native Dev session which was like I say was very well received but absolutely wonderful and fascinating conversation.

我非常非常感谢你,不只是为了那场 AI Native Dev 的 session——像我说的,它反响非常好——还有这场特别精彩、特别有意思的对话。

So really really appreciate you joining us and thanks for all the insights as well as to how Anthropic are using Claude Tag, Claude Code, things that you've learned.

所以真的很感谢你来,也谢谢你分享的所有洞见,包括 Anthropic 内部怎么用 Claude Tag、Claude Code,以及你学到的那些东西。

It's been it's been wonderful.

这次聊得非常愉快。

Thank you so much, Simon.

非常感谢你,Simon。

It's been an absolute blast as well.

我也聊得非常过瘾。

And thank you so much for having me.

也非常感谢你邀请我。

Amazing, Lamis.

太好了,Lamis。

Thank you so so much.

非常非常感谢你。

I'm sure our audience uh enjoyed that discussion.

相信我们的听众很喜欢这场讨论。

Tune into the next episode.

记得收听下一期。

Bye for now.

先聊到这儿,再见。

The AI Native Dev is brought to you by Tessl, the package manager for skills and context.

AI Native Dev 由 Tessl 呈现,Tessl 是 skills 和 context 的包管理器。

Your hosts are Guy Podjarny and me, Simon Maple.

你们的主持人是 Guy Podjarny 和我,Simon Maple。

Our producer is ⟨?Tom Dawler⟩.

我们的制作人是 ⟨?Tom Dawler⟩。

The AI Native Dev is not just a podcast, it's a community and we host monthly meetups at the Tessl offices in Central London.

AI Native Dev 不只是一个播客,更是一个社区,我们每月在 Tessl 位于 Central London 的办公室办线下聚会。

Visit tessl.io/community to learn more and I hope to see you

访问 tessl.io/community 了解更多,希望能见到你