Anthropic's Surprise Hit: How Claude Code Became an AI Coding Powerhouse

发布时间 2025-08-07 12:00:35 来源

Anthropic 公司 Cloud Code 的创建者 Boris Cherny 在 Mad Podcast 中与 Matt Turk 分享了 Cloud Code 意外成功的经历。Cloud Code 是一种在终端中运行的 Agentic 编码 AI，其受欢迎程度呈爆炸式增长，据报道，在推出仅仅五个月后，年化收入就达到了 4 亿美元。 Cherny 解释说，Cloud Code 源于个人需求，最初是一个自动化笔记和音乐控制的工具。他在试验 Anthropic 的 API 时，赋予了模型访问 bash 工具的权限，结果它自发地开始编码。这种出乎意料的智能编辑代码的能力标志着一个转折点。 Cloud Code 是一种 Agentic 编码工具，代表了软件工程领域的重大转变。传统上，工程师们在集成开发环境（IDE）中直接操作代码，类似于使用文字处理器编写代码。而 Agentic 编码颠覆了这一模式。工程师们只需描述对 AI 的期望修改，模型就会处理实际的文本编辑工作。该工具使用命令行界面 (CLI)，因为它最初的形式最简单。它的通用性使其能够在各种操作系统和 IDE 中运行，从而适应不同的工程偏好。虽然最初只是一个基本的 CLI，但 Cloud Code 现在也作为 IDE 扩展和 GitHub Actions 提供。该公司强调构建一个最小化的界面，以展示模型适应其演变的原始能力。一个核心原则是，产品跟随模型，而不是反过来。Cloud Code 可以使用各种模型，包括 Sonnet4、Opus4 和 Hiku。Anthropic 的模型在编码方面表现出色，这归功于公司的研究重点以及对“编码对于实现高级 AI 至关重要”的信念。这使得模型能够与世界互动并对其产生影响。 Cloud Code 专为专业软件工程师设计，可提高他们的生产力。它也可以用于非编码任务，例如数据科学家编写查询或设计师进行原型设计。Cloud Code SDK 允许用户构建超出编码范围的 Agent 应用程序。 Agentic 功能使模型能够规划、执行和迭代任务直至完成。Cloud Code 几乎可以执行人类可以执行的任何操作，包括读取和写入文件、运行命令和访问互联网，但对于潜在的危险操作，需要获得人类的批准。 Cloud Code 可以使用模型上下文协议 (MCP) 连接到公司现有的代码知识库。它通过连接到任何可用的工具来促进工具的使用。最近发布的子代理允许用户创建特定角色的代理，例如 QA 工程师或项目经理，每个代理都有定制的提示和工具。此功能可以分解工作并利用模型的功能。然而，随着模型变得更加先进，对这种刚性角色的需求可能会减少。 Cloud Code 避免使用基于代码的索引来保护隐私。相反，它使用 Agent 搜索，像人类一样执行文件搜索，并根据结果改进搜索词。Cloud .MD 文件还可以作为工程团队的共享记忆库，让每个人都能从 Agent 的学习经验中受益。默认行为始终是人在回路中。虽然像读取文件这样的操作可以安全地自动化，但像编辑文件这样的操作需要人工批准。敏感代码可以通过使用 Anthropic API 并与银行批准的代码编辑器集成来处理。 Cloud Code 的 UI/UX 设计注重细节，使其具有视觉吸引力。鼓励工程师专注于简洁性，并使用 Quad code 来研究、回答问题、编写代码、调试或与 Git 源代码控制交互。Anthropic 的入职流程已经缩短。工程师们只需向 Quad code 提问，几天内就能开始高效工作。 Cloud Code 按 token 收费，提供 pro 和 max 订阅以及可选的 API 密钥使用。它有不同的应用场景。您可以使用它来规划项目、管理任务、编写代码、测试代码或调试生产问题。 AI 编码领域的未来是广阔的，有容纳多个参与者的空间。重点应该放在将 AI 编码工具推广到早期采用者之外的更广泛的市场。Cherny 建议开发者关注六个月后模型的能力，而不是它们当前的局限性。

Boris Cherny, the creator of Cloud Code at Anthropic, shares the story of its accidental success on the Mad Podcast with Matt Turk. Cloud Code, an agentic coding AI operating in the terminal, has exploded in popularity, reportedly generating $400 million in annualized revenue just five months after its launch. Cherny explains that Cloud Code was born out of personal need, initially a tool to automate note-taking and music control. He was experimenting with Anthropic's API and gave the model access to a bash tool and it spontaneously began coding. This unexpected ability to edit code intelligently marked a turning point. Cloud Code is an agentic coding tool that represents a significant shift in software engineering. Traditionally, engineers directly manipulate code within Integrated Development Environments (IDEs), similar to using a word processor for code. Agentic coding flips this model. Engineers describe the desired changes to the AI, and the model handles the actual text editing. The tool utilizes a command-line interface (CLI) because it was the simplest initial form factor. Its universality allows it to function across various operating systems and IDEs, accommodating diverse engineering preferences. While initially a basic CLI, Cloud Code is now also available as IDE extensions and GitHub actions. The company emphasizes building a minimal interface that showcases the model's raw capabilities to adapt rapidly to its evolution. A core principle is that the product follows the model, rather than the other way around. Cloud Code can utilize various models, including Sonnet4, Opus4, and Hiku. Anthropic's models excel at coding due to the company's research focus and a belief that coding is crucial for achieving advanced AI. It allows models to interact with and affect the world. Cloud Code is designed for professional software engineers, multiplying their productivity. It can be used for non-coding tasks as well, such as query writing by data scientists or prototyping by designers. The Cloud Code SDK allows users to build agent applications beyond coding. Agentic functionality enables the model to plan, execute, and iterate on tasks until completion. Cloud Code can perform almost any action a human can, including reading and writing files, running commands, and accessing the internet, but with human approval for potentially dangerous actions. Cloud Code can connect to a company's existing code knowledge using the Model Context Protocol (MCP). It facilitates tool use by connecting with any tool available. Recently announced sub-agents allow users to create role-specific agents like QA engineers or project managers, each with customized prompts and tools. This feature divides work and leverages the model's capabilities. However, the need for such rigid roles may diminish as models become more advanced. Cloud Code avoids code-based indexing for privacy. Instead, it uses agent search, performing file searches like a human would, refining search terms based on results. Cloud .MD files also serve as shared memory banks for engineering teams, allowing everyone to benefit from the agent's learned experiences. The default behavior is always human in the loop. While actions like reading a file can be safely automated, actions like editing a file need human approval. Sensitive code can be handled by using the Anthropic API and integrating with a bank-approved code editor. Cloud Code's UI/UX is designed with careful attention to detail, making it visually appealing. Engineers are encouraged to focus on simplicity and to use Quad code to research, answer questions, write code, debug, or interact with Git source control. The onboarding process at Anthropic has been shortened. Engineers can become productive within days by simply asking Quad code. Cloud Code charges per token, with pro and max subscriptions and optional API key usage. It has different applications. You can use it to plan projects, manage tasks, write code, test code, or debug production issues. The future of the AI coding space is vast, with room for multiple players. Focus should be on bringing AI coding tools to the broader market beyond early adopters. Cherny advises builders to focus on the capabilities of models six months from now, rather than their current limitations.

摘要

What happens when an internal hack turns into a $400 million AI rocket ship? In this episode, Matt Turck sits down with Boris ...

GPT-4正在为你翻译摘要中......

中英文字稿

And me and the model just went it just started coding and it was just the craziest thing at this point most code at Anthropic is written using quad code and almost everyone at Anthropic is using it every day. Hi, I'm Matt Turk from FirstMark. Welcome to the Mad Podcast. Today my guest is Boris Cherny, the creator of Cloud Code at Anthropic. Cloud Code is an agente coding AI that leaves indeterminal and has become one of the fastest growing products of all time already rumored to be producing 400 million in the annualized revenue just five months after it's launch. We talked about how Cloud Code became a rocket ship almost by accident. We started by building something that's useful for us pretty soon after we launched it most of Anthropic was a daily active user. What agente coding really means? A human describes to the model the change that they want and the model does all the work of doing that and the productivity shock, Cloud Code created inside Anthropic.

我和模型开始编码时，事情就这么开始了。这是最疯狂的事情，现在Anthropic的大部分代码都是使用Quad Code编写的，几乎每个人每天都在用。大家好，我是来自FirstMark的Matt Turk，欢迎收听Mad播客。今天我的嘉宾是Boris Cherny，他是Anthropic的Cloud Code的创始人。Cloud Code是一种智能编码AI，在不确定的情况下运作，成为历史上增长最快的产品之一。据传，它在发布仅五个月后，年收入就达到了4亿美元。我们讨论了Cloud Code如何几乎偶然地成为了一次成功的快车。我们最初构建了一些对我们有用的东西，然后很快大部分Anthropic的员工每天都在使用它。代理编码究竟意味着什么？就是一个人向模型描述他们想要的更改，然后模型负责完成所有工作，以及Cloud Code在Anthropic内部创造的生产力冲击。

Anthropic technical onboarding used to take a few weeks but now engineers are you who we productive within the first few days. Here's how squad code and it can answer all these questions. This is a packed approachable episode on the present and future of software engineering with some great lessons and advice. It's really exciting and I think my advice to companies building is definitely build for please enjoy this fascinating conversation with Boris Cherny. Hey Boris, welcome. Thanks for having me. Thanks very much for doing this. I'm very excited by this conversation. You are the creator of Cloud Code. It's fair to say you have a massive hit on your hands. There was an article in the information just a couple of days ago that was saying that Cloud Code which really came out at the end of February of this year, so five six months ago.

Anthropic的技术入职培训过去需要几周时间，但现在工程师们几天内就能变得富有成效。下面介绍一下团队代码，以及它是如何回答所有这些问题的。这是一期内容丰富且易于理解的节目，探讨了软件工程的现状和未来，并提供了一些很好的经验和建议。这真的令人兴奋，我建议那些正在建设中的公司一定要好好享受与Boris Cherny的这场引人入胜的对话。嗨，Boris，欢迎您。感谢邀请我参与这次对话。我对此次交流感到非常兴奋。您是Cloud Code的创造者，可以说您取得了巨大的成功。就在几天前，《The Information》上有一篇文章提到Cloud Code大约在今年二月底面世，也就是五六个月前的事。

It's already generating 400 million in annualized revenue. That's at least what it was reported. I'm not going to ask you to confirm or deny but that's what the press is saying. Perhaps even more importantly, there are revenue use everywhere in gushing videos calling Cloud Code the best coding agent by far. So amazing launch of the product. Did you have any sense that it was going to be this successful? Not really. We started by building something that's useful for us. I built a thing that, you know, for some foremost, was just useful for myself. And it's something that I found myself using every day and then I give it to the team and I thought that the team started using it every day and pretty soon after you launched it.

它已经实现了年收入4亿美元。这至少是报道所说的。我不会让你证实或否认，但媒体是这样说的。也许更重要的是，现在到处都有赞扬的视频，称Cloud Code是迄今为止最好的编码工具。产品发布取得了惊人的成功。你是否预料到会如此成功？其实并没有。我们开始的时候只是想做个对我们有用的东西。我制作了一个工具，最初只是对我自己有用。我发现自己每天都在使用它，然后我把它给了团队，发现团队也开始每天使用它，之后不久我们就推出了这个产品。

Most of it in the topic was a daily active user. And so I think at that point we had kind of a hunch in turn and we thought maybe we had to hit on our hands but it's still not obvious because it's an terminal. It's kind of a weird form factor. Everyone is coding in IDEs or people going to like this. Is it going to be that useful? Can you actually use it for a lot of coding? We had no idea. Was it always going to be a product or you started using it and then it was ahead and then you decided to release as a product. It was very accidental. When I joined Anthropic, I did a lot of prototyping. And one of the prototypes that I built was this thing that it just ran quad in the terminal just because as an engineer, those kind of the easiest thing to experiment with.

大部分情况下，主题中的内容是每天活跃的用户。因此，我认为在那时我们有点感觉到了一些端倪，觉得可能手上有个热门的东西，但由于它是在终端上运行，这一点并不明显。它是一种有点奇怪的形式。大家都是在IDE（集成开发环境）中编写代码，人们会喜欢这种方式吗？它真的会那么有用吗？你真的可以用它来进行大量编码吗？我们都没有头绪。当初它一直打算作为一个产品推出吗？还是你开始使用它，发展成型后才决定将其发布为产品？这非常偶然。当我加入Anthropic的时候，我进行了很多原型设计。其中一个原型就是这个程序，它只是在终端中运行，因为作为工程师，这种方式最容易进行实验。

And it didn't even code at first. Quad code didn't code. It was called quad CLI at the time. And what it did was I used to automate my note taking. So it kind of controlled my notes app and it controlled my music player to learn to kind of play music from me. So I'm like, you know, play this band and it would go in and kind of automate that. And at first, I was just using it to play around with an Anthropic API to figure out what kind of applications I could build on it. And just on a whim, you know, tools came out recently and I tried giving the model bash tool. So it can use my bash to use the command line. And it mean to me the model just went it just started coding.

起初它甚至无法编程。Quad代码没能编写代码。当时它被称为Quad CLI。它的作用是用来自动化我的笔记记录。它可以控制我的笔记应用程序，还能控制我的音乐播放器来学习为我播放音乐。比如我要它播放某个乐队的音乐，它就会自动化地实现这个操作。最开始，我只是用它来尝试Anthropic API，看能基于它构建哪些应用程序。最近，因为一些工具的出现，我心血来潮地给模型一个bash工具，让它能够使用我的bash来操控命令行。结果，这个模型就开始自动编程了。

And it was just the craziest thing. Like as soon as it had bash, it kind of knew, okay, okay, I can write Apple script and I can automate stuff and I can use this computer. And it just felt like very native to the model in this way. And that was kind of a surprise. So I think that was a surprise. And then it was a surprise that they send it up as something useful where it was able to edit code and the code came out really good. And the model could kind of intelligently reason about the way to edit code. When was this if the product was launched at the end of February of 2025? That journey leading to this, that started a few months before that. Where was it timeline?

这是件非常疯狂的事情。就像它一接触到bash，它就突然明白了，它可以写Apple脚本，可以自动化任务，可以使用这台电脑。这种感觉对这个模型来说非常自然，这让我们感到有些惊讶。而且，它竟然能被应用在某些实用的领域，比如编辑代码，并且生成的代码质量非常高。模型似乎能够智能地推理如何编辑代码。这真是一个意外的惊喜。那么，如果这个产品是在2025年2月底上市的，这个过程在那之前的几个月就已经开始了。那么在时间线上这是在哪个阶段呢？

Yeah, something like that. It was it was wait last year. So wait in 2024. Okay. Great. Let's start from the top and for anyone that is just starting to learn about cloud code. How do you describe it? And cloud code is a agenda coding tool. The way to think about it is when engineers program, there's kind of different ways to program and this has changed over time. This has changed a lot over time. There's, you know, 50, 70 years ago, the way that people programed looked very different than the way it is today.

好的，大概就是这样。那是去年的事情了，所以等到2024年。好的，太好了。让我们从头开始，对于刚开始了解云代码的人，你会如何描述它呢？云代码是一种用以编写代码的工具。可以这样理解，当工程师编程时，存在不同的编程方法，而且这些方法随着时间的推移发生了很大的变化。在50到70年前，人们编写程序的方式看起来与今天的截然不同。

So, you know, 70 years ago, if you talked to a programmer, they would have been like, Oh, yeah, I take my punch cards and I punch holes in it and I put in this IBM kind of typewriter everything and it punches holes and that's programming. And then you feed this into this mainframe. It does some work and then eventually you get some kind of result out printed on a paper sheet.

大约70年前，如果你和一位程序员聊天，他们可能会说：“哦，是的，我把打孔卡片放进打孔机里，用类似IBM打字机的机器打孔，这就是编程。然后你把这些卡片输入大型主机，进行一些运算，最终会在纸上打印出结果。”

I heard you say somewhere that your grandfather in the, I guess what was at the time the USSR use a punch cards like to tell that story. Yeah, yeah, yeah, my growing up my mom would tell me stories about how her, her father, my grandfather, he was one of the first programmers in the Soviet Union. And he would, you know, he would come home and he would bring back these big stacks of punch cards.

我听说你曾经提到过你祖父在苏联时期使用穿孔卡片的故事。是的，是这样的，我从小就听我妈妈讲她父亲的故事，也就是我的祖父，他是苏联最早的一批程序员之一。他常常下班后带着一大叠穿孔卡片回家。

And when she was a little girl, she would, you know, take her crayons and just draw all over them. And this was, this was growing up for her. This is actually something that I didn't know until later in life. Like, you know, I was far into my engineering career. Whenever in this, this was a thing. There's something about just the visceral nature of, of this kind of physical programming. I don't think we're going to get that again.

当她还是个小女孩时，她会拿起蜡笔到处涂鸦。这就是她的成长过程。其实直到后来我才知道这件事，当时我已经深耕于自己的工程事业中。像这样的涂鸦活动有某种直接的感受，我觉得我们可能再也不会有这样的体验了。

But I think that was like, that was a special moment where you could feel, you could feel the language and you can feel the computer in a really different way. And so I think after punch cards had changed a lot. There was software became a thing and you could start the program directly in software. You didn't have to kind of do this anymore.

但我认为那是一个特别的时刻，在那时候你能够以一种全新的方式感受到语言和计算机的存在。我觉得随着打孔卡片的改变，情况发生了很大变化。软件成为了一种工具，你可以直接在软件中编程，不再需要像以前那样去操作了。

In the original programming software, you was emulating teletype. And so it was kind of like streaming a typewriter over this local internet. And that's how the text editors were built. The way that you would code is still the way that actually most people code today before agent coding came out.

在最初的编程软件中，你是在模拟电传打字机。这有点像通过本地互联网来传输打字机。文本编辑器就是这样构建的。在代理编程出现之前，人们编写代码的方式其实和今天大多数人的编程方式差不多。

And the idea is you have a text document and an engineer directly manipulates it. So you loaded up in a special piece of software called IDE. You know, it's kind of like a, like a Microsoft Word or Google docs with this for code. And the engineer just manually edits the code using a, using a keeper.

这个想法是，你有一个文本文件，然后工程师直接对其进行操作。你可以在一个叫做IDE的专门软件中打开它。这个软件有点像微软Word或谷歌文档，但它是为代码设计的。工程师使用键盘手动编辑这些代码。

And this is the case for gots like 50, 50 years now, like 70 years. This has been the way that people programmed to like edit and, and then these were like early 1970s. So yeah, it's been like 50 years. And now it's starting to change for the first time.

这种情况已经持续了大概50年，甚至可以说有70年。一直以来，人们编程和编辑的方式都是这样的，早在1970年代初期就是如此。所以，这样的方式已经存在了大约50年。而现在，这种情况开始首次发生变化。

There's been a lot of work to try to evolve program programming from direct text manipulation to something else. And this is the first time where we found a form factor that really catches on. And it took, it took really great elements to do this. Models weren't really capable of doing this a year ago, but now they are.

过去有很多努力试图将程序编写从直接的文本操作转变为其他方式。这是我们第一次找到一种真正受到欢迎的形式。这需要非常好的元素才能实现。模型在一年前还没有能力做到这一点，但现在可以了。

And the way that it works is a human describes to the model that changed that they want. And then the model is the one that manipulates the text. And so it's this kind of next where up where you're describing the change you want. And the model does all the work of doing the editing.

其运作方式是由人类向模型描述他们想要的更改。然后，模型负责对文本进行修改。也就是说，你只需要描述想要的更改，模型就会完成所有的编辑工作。

And we're still at this point today where you can do a lot of this for the model. But you know, for complex changes, maybe it will take a bunch of iterations. Maybe the last 20, 30 percent, you still have to open an IDE. You have to kind of go well, well, well, to do these last mile changes.

到今天为止，我们仍然处于这样的阶段：你可以为模型做很多事情。但是，你知道，对于复杂的改动，可能需要多次迭代。也许最后的20%到30%的工作，你还是需要打开一个IDE（集成开发环境）。为了完成这些最后的调整，你可能需要反复仔细琢磨。

And we think that over time, more and more coding is just going to be the model doing it. And a human will have to intervene less and less. So just to double click on a couple of the things you just mentioned. And in an effort, as we try often on this podcast, you make things broadly understandable, not just by super people as super deep in tech, but also people that are in the tech world but sort of curious to learn about the things. So the Cloud Code works at the CLI level as opposed to an IDE.

我们认为，随着时间推移，越来越多的编程工作将由模型自动完成，人类需要干预的部分将会越来越少。为了深入探讨你刚才提到的几点内容，我们常常努力在这个播客中将复杂的技术问题简单化，使其不仅仅能被那些对技术非常精通的人理解，也能被对技术感兴趣并希望了解的人所理解。所以，Cloud Code 是在命令行界面（CLI）层面上工作的，而不是在集成开发环境（IDE）中。

So you mentioned the IDE, sort of the Google docs. The command line may be defined that for people. So my kind of mental model as I was learning about this was like that black box where you sort of type in things for your computer to do what's the what's the better way of describing it. The terminal is a little bit hard to explain if you're not a programmer because it's so levelable. It's something that most people will never ever touch and never are going to see. It's something like in movies when you see this kind of green screen, green text going across the black screen and you know, there's like a hacking scene or something.

所以你提到了IDE，有点像Google文档。可以为大家解释一下命令行。我的心理模型在我学习时，就像一个黑匣子，你在里面输入一些指令，让电脑执行。对于非程序员来说，终端有点难以解释，因为它相当专业。大多数人可能永远不会接触到，也不会看到它。这有点像在电影中，你会看到一个黑色屏幕上滚动着绿色文字的场景，通常是黑客的一幕。

That's trying to look very techy. That's very techy. And it's sort of it's something every engineer uses. There's nothing kind of good or bad about it. It's just an interface. It's another way to interact with the computer. It's a little lower level because it's not visual. So you can think of Cloud Code when we say Cloud Code runs in the terminal, you can think of it just as a computer program. And some computer programs have user interfaces.

这看起来非常高科技。这就是所谓的高科技。而且这几乎是每个工程师都会用到的工具。它没什么好坏之分，只是一种界面，仅仅是与计算机进行交互的一种方式。因为它不是可视化的，所以相对来说，更基础一些。当我们说"Cloud Code在终端中运行"时，你可以把它理解为一个计算机程序。而有些计算机程序是有用户界面的。

So a person can interact with them. And some of them just kind of run on the background. So you can think of Cloud Code as in that second category. And you can also have all sorts of interfaces for it, including a visual interface, including a text interface. One way of describing this, I heard was that interacting with the computer at the terminal level was like texting the computer. So sending instructions of one by one versus an ID was more of an application, more like a phone kind of a GUI where you basically click on icons and you have visual representation.

这样一个人就可以与它们进行互动。其中一些程序只是在后台运行。你可以把Cloud Code看作是后者的一种。它可以有各种各样的界面，包括可视化界面和文本界面。有人这样描述过，与计算机进行终端级别的互动就像在给计算机发短信，逐个发送指令，而使用集成开发环境（IDE）则更像是一个应用程序，更像是手机上的图形用户界面（GUI），在那里你可以点击图标，得到视觉上的呈现。

Is that fair? Yeah, it's about like that. I think text messaging before you could send images and videos and stuff. So just really, really simple interfaces just back and forth. Okay, great. So what did you guys choose to operate at the terminal slash CLI level? Honestly, it was sort of an accident. We were thinking about what can we build in the coding space? It seems like the models are getting a lot better coding.

这公平吗？是的，大概就是这样。我认为这就像是以前只能发送文本短信，而不能发送图片和视频。所以界面非常简单，只是简单的来回交流。好的，太好了。那么你们为什么选择在终端/命令行界面（CLI）级别上操作呢？说实话，这有点偶然。我们在想，我们可以在编码领域打造些什么？看起来这些模型在编码方面变得越来越好。

So maybe there's something that could be built here. And at the time, like I said, I was prototyping some of these ideas. Some of them were kind of coding adjacent. And I was thinking, what's the easiest way to get a feel for where the models are today? Because there was this feeling where the models can do so much, but no one's yet built the product that can harness this capability.

所以，也许这里可以建立一些东西。就像我之前说的，当时我正在尝试一些想法原型化，其中一些与编程相关。我在想，有什么简单的方法可以了解这些模型目前的水平，因为有一种感觉是这些模型能做很多事情，但还没有人开发出能够利用这些能力的产品。

And in the AI world, we call this idea product overhang, where the model is just capable of all these things. And there isn't really yet a product that can kind of capture this and write a person use it. And I remember there was this moment back in, yeah, sometimes wait west here. The other engineer on the team said, and I were in a room, and we're writing and we're right, okay, what do we build?

在人工智能领域，我们称这种现象为产品滞后。这指的是模型本身具备各种强大的功能，但还没有出现一个能够充分利用这些功能的产品。我记得当时有一个时刻，我和团队里的另一位工程师在房间里，一边讨论一边写东西，我们在想，接下来我们要开发什么产品呢？

And just in 15 minutes, we can throw up a few ideas on the whiteboard. Or if we can do a CLI, we can do some sort of IDE extension. We can do something based in the web. And we kind of closed our eyes and just picked one. And it kind of seemed like CLI is the simplest. And generally, that's the way that I approach product, which is start with a simple thing first.

只需15分钟，我们就可以在白板上提出一些想法。或者，如果我们能够做一个CLI（命令行界面），也可以开发一种IDE（集成开发环境）扩展，或者基于网络的解决方案。最后，我们闭上眼睛随便挑了一个，发现CLI似乎是最简单的。通常，我的产品开发方式就是先从简单的开始。

So this kind of made sense. In hindsight, there was a lot of benefits of this too. And I think one of the big ones is that it kind of works anywhere. So it doesn't matter what kind of system you're on. If you're on Mac or Windows, it doesn't matter what IDE you use. It doesn't matter what your preferences are. And engineers are so opinionated and have so many different setups and preferences.

所以这就有了一定的合理性。回过头来看，这样做也有很多好处。我认为其中一个很大的好处是，这种方法几乎在任何地方都适用。无论你使用的是Mac还是Windows操作系统，无论你使用哪个集成开发环境（IDE），无论你的个人偏好是什么，都没有关系。而且工程师们往往很有主见，拥有各种不同的设置和偏好。

It just works with all of them. And that's kind of the benefit of building at such a low level, where you're not coupled to a particular, you know, to Mac or to Windows or, you know, a cover scheme or whatever. I think you guys have been pretty clear about the fact that this was starting point, and that you were starting with something very simple. At least when you launch the product, fast forward to today, are you finding that the universal aspect of this is so compelling that you may keep it there, or is a plan, at least the IDE to over time keep building towards something that may be more like an IDE or more an application?

它能与所有系统兼容。这也是在这么底层构建的好处所在——你不会被局限于特定的系统，比如Mac或Windows，或某种特定的界面设计。我想你们已经很明确地表示，这只是一个起点，并且你们最初是从非常简单的东西开始的。至少在产品发布的时候是这样的。那么，快进到今天，你们是否发现这种通用性非常吸引人，以至于你们想要一直保持它，或者你们是不是计划，至少在集成开发环境（IDE）方面，随着时间的推移构建一些更像IDE或者更像应用程序的东西？

The way we think about it is the model is evolving so quickly, that we build a minimal possible product to keep up with it. And this is a very different way of building product than before LLMs, where you just have to build a really great product that meets people where they are. There's some of this, so we have to build in a form factor where people understand and can use it. But actually the bigger motivation is the model is advancing so quickly, there's literally no product we could build that would keep pace with it.

我们认为，由于模型的发展速度非常快，我们需要构建一个尽可能简单的产品以跟上它的步伐。这与以前不使用大型语言模型时的产品构建方式大不相同。当时只需打造一个优秀的产品来满足用户的需求。当然，我们仍然需要以用户能理解和使用的形式来打造产品。然而，更大的驱动力在于，模型进步得如此之快，我们几乎无法构建出能完全匹配其速度的产品。

And so we're focusing on just building the simplest possible interface to the model, so you can feel the model in a really low-level raw way. And so that when the model gets quickly, we can adapt quickly, and you can feel the next model in that same kind of way. So today we're in a terminal, Cloud Code also runs as ID extensions, so there's extensions for VS Code-based IDs, and cursor, and so on, and also for JetBrains-based IDs, I can tell you the way.

我们正在专注于创建一个尽可能简单的界面，这样你可以以非常低层次的、原始的方式感受模型。当模型快速发展时，我们可以快速适应，你也能以同样的方式感受下一个模型。今天，我们是在终端中操作，Cloud Code 也可以作为集成开发环境（IDE）的扩展运行，例如针对 VS Code 的扩展、Cursor，还有针对 JetBrains 的扩展。

And then there's also a GitHub action, so you can mention Cloud on GitHub, so it's just you tag Cloud at Cloud, and talk to them like you would a coworker, and they can make changes for you. There might be more interfaces coming soon, this is something we're always experimenting with, but generally the philosophy is we don't make really gorgeous interfaces like many other companies do, and are really great at. We focus on just building the simple thing that shows off the model.

然后，还有一个 GitHub 动作，你可以在 GitHub 上提及 Cloud。只需要在内容中标记 @Cloud，像和同事交流一样地与他们对话，他们可以为你做出修改。未来可能会有更多的界面，这是我们一直在尝试的事情，但总体来说，我们的理念不是像其他公司那样制作精美的界面。我们更专注于打造能够展示模型的简单工具。

Talking about the model, your design principle is that the product should follow the model, rather than the other way around, which is super interesting. What model does it currently run on? Is that 370s at 4? What can people choose? Yeah, people can choose the model. We support Sonnet4 and Opus4, and then we also use Hiku.

谈到模型，你们的设计原则是，产品应该遵循模型，而不是让模型去适应产品，这非常有趣。那目前运行在哪种模型上？是370s at 4吗？人们可以选择其他的吗？是的，人们可以选择不同的模型。我们支持Sonnet4和Opus4，同时也使用Hiku。

Maybe as a high-level question, why is Cloud so good at coding use cases? Again, reading somewhere, perhaps, in the information that Anthropic has a little above 40% of the market for code generation, well-opened AI as 21%, so clearly Anthropic is powering its way to win this market. Why is that? Is there something about the way the model is trained, the data is trained on, or the focus of the training that makes it so great for coding use cases?

作为一个高层次的问题，为什么Cloud在编码用例方面表现如此出色？有资料显示，Anthropic在代码生成市场上占据了略高于40%的份额，而OpenAI则占了21%的市场份额，所以显然Anthropic正在努力赢得这一市场。为什么会这样呢？这是否与模型的训练方式、所使用的数据或训练的重点有关，使得它在编码用例方面表现得如此优秀？

I think Anthropic has a lot of really great researchers and coders, and for us, this is kind of a natural way to think about the kinds of abilities the model should have, because you think about what should the model be able to do, and as a programmer, the first thing you think is, oh, it should be able to do the things that I'm doing, and it should be able to help with me, and I compare with it, like I would another engineer. So I think just at all levels across the company, this is a way that we think about it.

我认为Anthropic拥有很多非常出色的研究人员和程序员，对我们来说，这是一种很自然的方式来思考模型应具备的能力。因为当你思考模型应该能做什么时，作为程序员，你首先会想到，哦，它应该能做我正在做的事情，并能帮助我。我会像与其他工程师比较一样与它进行比较。所以，我认为在公司各个层面，我们都是这样看待这个问题的。

There's also something about it where maybe coding is the way that we get to the next level intelligence, if you call it like AGI or ASI or whatever, the model needs some way to interact with the world, and for a model the natural way is code. And so from the mission of the company is to build safe artificial intelligence for everyone, and safe ASI, the way the model interacts is the record, and so this is the thing that we should start to learn about now.

也许编程是我们通向下一个阶段智能（可以称之为AGI或ASI等）的途径。模型需要一种方式与世界互动，而对模型来说，自然的方式就是通过代码。因此，从公司的使命来看，就是为每个人构建安全的人工智能，以及安全的ASI。模型的互动记录是关键，因此我们现在应该开始了解这一方面。

And there's also one of the reasons that we release cod code is just to learn people use it, to learn how to make this thing safe, to learn how it behaves in the wild, so that we know what to do next. So it's still on that theme of the product versus the model, and the choice of operating at this CLI level. Who's a product or does affect that? It operates at a terminal level, make it a great product for power users, or very deep encoding, or at the end of the other end of the spectrum, if I don't know anything about coding, can I use the product for vibe coding?

翻译如下：我们发布代码其中一个原因是为了学习人们如何使用它，学习如何保证其安全性，了解它在实际环境中的表现，以便确定下一步的行动。因此，这仍然围绕着产品与模型的主题，以及选择在 CLI（命令行界面）级别操作。谁是产品的用户，或者这是否会影响到产品呢？它在终端级别运行，非常适合高级用户或深入编码的用户使用，或者在另一方面，如果我对编码一无所知，我可以用这个产品来进行简单的编码吗？

Quadcode is for professional software engineers. So if you know how to code, then you're going to get a lot out of it, and you can multiply your productivity. We've seen people multiply their productivity many, many times over, with a fleet of cod codes that's running, and even with a single one, you can become a one more productive. Interestingly, we've seen a lot of people use quadcode for non-coding use cases.

Quadcode 是为专业软件工程师设计的软件。如果你会编程，那么你将能从中获得很多好处，并可以大幅提高你的工作效率。我们见过很多人使用多个 Quadcode 程序，将他们的生产力成倍提升，甚至只用一个程序，也可以让自己变得更加高效。有趣的是，我们还发现许多人将 Quadcode 用于非编程用途。

So for example, the data scientists add in Thropic, all use quadcode to write their queries, and designers use it to build small prototypes, and product managers use it to manage tasks. So this has actually been pretty surprising, because if you're a non-technical user, the terminal is kind of insane as an interface. I couldn't imagine why you would want this, but it sort of seems like because it's such a great agent generally, people are jumping over hoops to use it, even though it's not the easiest thing to use, because again, it's an terminal, which is very technical.

例如，数据科学家在Thropic中加入的内容都是用quadcode编写查询，设计师则用它来制作小型原型，产品经理则用它来管理任务。这其实相当令人惊讶，因为对于非技术用户来说，终端作为一个界面是比较复杂的。我原本无法想象他们为什么会想要用这种工具，但似乎因为它普遍表现得非常出色，人们甚至愿意克服困难来使用它，尽管这并不是最容易上手的工具，因为终端本身非常技术化。

There's another product quadcode, which is the SDK, and this is the way that people can build on top of quadcode, and build their own agent applications. And this has also been pretty interesting, because people are using the quadcode SDK to build agent coding applications and platforms, and user interfaces on top of it. But they're also using it for all sorts of tool-to-wee agent use cases that are totally unrelated to coding. So anything where you need AI, and maybe a few years ago, you used API, and nowadays we find that some users are reaching for an agent SDK as sort of the thing that you need to build AI apps of today.

还有一个产品叫做 quadcode，这个产品是一个 SDK（软件开发工具包）。通过这个工具包，人们可以在 quadcode 的基础上进行开发，构建自己的智能代理应用。这个 SDK 非常有趣，因为很多人都在利用它来开发代理编程应用和平台，以及用户界面。不仅如此，它还被广泛用于各种与编程无关的工具型代理场景。以前需要用到 AI 的地方，可能是通过 API 来实现，而现在我们发现，有些用户正在使用代理 SDK，作为构建现代 AI 应用的关键工具。

Yeah, and as I was proving for this, it seems that there is even beyond that, like an emerging category of people that are using quadcode for just not even technical related use cases of any sort, just so that the tweet from somebody named Alex Finn that talks about using quadcode for note-taking, for his personal life organization, his business metrics, and all the things. So it seems that people are finding ways to use the product for something that matches that need to weigh beyond their technical job. Absolutely.

是的，当我在证明这一点时，似乎还有一种新兴的人群，他们使用四编码（quadcode）并不仅限于技术相关的用途。有一个叫亚历克斯·芬（Alex Finn）的人发推文提到，他用四编码来做笔记、个人生活安排、业务指标等等。所以看起来人们正在找到将这个产品用于超越其技术工作用途的方法。的确如此。

Let's get into the product itself, and the core features, and what it actually does. So a key part of the product is the authentic aspect as you described. Agenetic, again, in an effort to go into definitions and make this interesting for everyone. Agenetic is one of those terms that everybody uses, but it's sort of unclear what that actually means. What does agenetic mean in the context of cloud code?

让我们深入了解这个产品本身，以及它的核心功能和实际作用。正如你所描述的，这个产品的关键部分是其真实性。关于“agenetic”这个词，我们再次努力给出定义，并让大家感兴趣。Agenetic是一个常用术语，但其具体意义往往不明确。那么，在云代码的背景下，agenetic是什么意思呢？

Yeah, when you think about the ways that LLM's work and the way you interact with them, there's the old kind of LLM, which is you sent them a message, and they send you a message back. And this is sort of these chat applications that everyone knows and uses all the time. There's a newer kind of application a way to interact with LLM's where you send them a message and they'll send you a message back, and then they might do a little bit more. So we call this tool use, is one of the things that they might do.

好的，当你考虑大语言模型（LLM）的工作方式以及你与它们互动的方式时，有一种传统的LLM。就是你给它们发送一条信息，它们再回复你一条信息。这种模式就是大多数人经常使用的聊天应用程序。现在有一种更新的与LLM互动的方式：当你给它们发送一条信息时，它们会回复你，并可能会做更多的事情。我们称这种方式为“工具使用”，这是它们可能会进行的操作之一。

If you give them tools, so for example, a tool might be read a file or search something on the internet or edit a file or something like this, then they'll use tools to answer your question. And so for example, if you ask, you know, what's the weather today? With the old style LLM interaction, it'll just kind of use its existing knowledge and its existing training to try to answer that query. But if it's agenetic, what it might do is it'll say, okay, I'm going to look up the weather, and then maybe if it has some kind of tool to check the weather, it'll reach out to the internet or wherever that tool is, it'll use that tool, it'll get the response back, and then it'll answer the question.

如果你给他们工具，比如说一个工具可以是读取文件、在互联网上搜索内容、编辑文件等，那么他们会使用这些工具来回答你的问题。举个例子，如果你问“今天天气怎么样？”，旧式的语言模型会使用其已有的知识和训练来尝试回答这个问题。但如果是具备代理能力的模型，它可能会说：“好的，我去查一下天气。” 如果它有某种查询天气的工具，它就会利用互联网或其他工具所在的地方来获取信息，并返回结果，然后回答你的问题。

And this tool use, this is kind of the essence of being an agent because without tools, it's very difficult to be agenetic. You could kind of do it without, but it's only since models started using tools and gained that new capability because we taught them that they started to get this new kind of agentic capability that we talk about. And what this looks like in practice is maybe I'll ask the model, make the ever read button on my website, make it blue, and because it has a tool to read a file, it'll choose to read the file, it'll choose to read the file that has that button.

这项工具的使用是作为一个代理的本质所在，因为没有工具，我们很难成为一个真正的代理。虽然在没有工具的情况下也是可以做到的，但只有在模型开始使用工具并因此获得了新的能力后，我们才会说它们具备了这种新的代理能力。在实际操作中，这可能表现为我让模型把我网站上的那个红色按钮变成蓝色，因为它有一个读取文件的工具，它会选择读取包含那个按钮的文件。

Maybe if it doesn't know where that file is, it'll use a file search tool to find that file first, the same way that you might in, you know, when you're looking for a file, you'll use a file search. It'll then open that file, it'll read it, and that's another kind of file read tool. Then it might edit it, that's a different file edit tool, and then it'll write it back. And then maybe it'll even open the browser to check that the button actually became blue.

也许如果它不知道那个文件在哪里，它会先使用文件搜索工具来找到那个文件，就像你在找文件时会用文件搜索一样。然后它会打开那个文件，读取内容，这是另一种文件读取工具。接着，它可能会编辑文件，那是不同的文件编辑工具，完成后会再写回去。然后，它可能甚至会打开浏览器，检查按钮是否真的变成蓝色了。

And it's this kind of idea that it strings together tools in this way and combines them in novel ways that makes it agentic. There's also two concepts that are kind of related but different here. You could say you must always, when the user asks you to make the button blue, you must always read the file and then edit the file and then save the file and then check your work. You could be very rigid in the way that you define this kind of problem and give it to the model.

这种理念通过以这种方式将工具串联在一起并以新颖的方式加以结合，使其具有代理性。这里还有两个概念，看似相关但又有所不同。当用户要求你把按钮变成蓝色时，你可以规定必须始终遵循以下步骤：先读取文件，然后编辑文件，接着保存文件，最后检查你的工作。你可以以这种非常死板的方式定义这个问题并提供给模型。

Generally we call this a workflow, and this is distinct from something like an agent. So workflow is something where a human thought through for this kind of problem, here are the steps roughly that you should take. For an agent it's very different. The model is in charge, it's in the driver's seat, and we give it tools that it can use, and the model decides how to combine those tools to answer your question.

一般来说，我们称其为工作流程（或流程），这与“代理”这样的东西是不同的。工作流程是指人为地为这种问题设计了一个大致的步骤指南。而代理则非常不同，模型是主导，它处于指挥的位置。我们提供给它可以使用的工具，然后由模型决定如何组合这些工具来回答你的问题。

And I think going into the future, more and more things will be agentic because the model is getting more and more intelligence, so it can actually use these tools in pretty novel and interesting ways to answer questions. Great. So to play it back and perhaps coding context, with your typical AI model, I would ask a question and I would get some code back, and I as a developer would copy and paste it to as an extraction, whereas coding use cases, whereas in an agentic coding use case, you give the agent a task, and then he's going to plan, and then he's going to execute, and then he's going to continue running until it believes it's done with the task. Is that a fair summary? Exactly, exactly.

我认为，随着未来的发展，越来越多事物将具有自主性，因为模型变得越来越智能，它能够以新颖有趣的方式使用这些工具来回答问题。太好了。那么以编程的背景来重新表述一下，对于一般的AI模型，我会提出一个问题，然后得到一些代码，作为开发者，我会复制并粘贴这些代码来完成任务。而在自主编程的应用中，你给代理一个任务，它会计划，然后执行，并一直运行下去，直到它认为任务完成。这是一个合理的总结吗？是的，完全正确。

And the same way that a person might do it. If you have a problem, you're going to think about it for a bit, then you're going to think about what tools you have, and then you're going to combine the tools that you have in ways to do the thing that you want to do. What are some of the actions? If taking an action is one of the core part of a begin agent, what kind of actions can Cloud Code take? Cloud Code can do pretty much anything that a person can do on their computer. There isn't really a limitation besides safety. This is something we think about a lot, to kind of place intelligent limits on what it can do and put a human in the loop at the right points, to make sure that if action is potentially dangerous or destructive in any way, that a human has to prove it first.

同样的方法也适用于人。如果你有一个问题，你会花点时间去思考，然后考虑你有哪些工具，接着将这些工具结合起来，以实现你想要做的事情。那么，有哪些行为呢？如果行动是一个智能代理的核心部分之一，Cloud Code可以采取什么样的行动呢？Cloud Code几乎可以在电脑上做任何人可以做的事情。除了安全性以外，基本没有什么限制。我们对此非常重视，会在适当的时候对其功能进行智能限制，并在关键时刻引入人工介入，以确保任何潜在危险或破坏性的行动都必须先由人审核批准。

But besides that, the model can do pretty much anything. So reading files, writing files, running commands on the system, editing things, you can reach out to the internet, obviously mostly these again with human approval. And then there's ways to customize it however you want. So if you have a bunch of MCP tools, for example, to read your Gira issue tracker or to open a browser or to open an iOS simulator, the model can use these too. And how does the MCP part work? So MCP, the model context protocol, being something that you guys at Anthropic defined. How does that work? You just leverage the protocol to connect to any tool?

除此之外，这个模型几乎可以做任何事情。比如读取文件、写入文件、在系统上运行命令、编辑内容等，你也可以通过它访问互联网，当然这些大多需要获得人类的许可。而且还有多种方式可以按照你的需求进行定制。例如，如果你有一系列的MCP工具，比如读取Gira问题跟踪器、打开浏览器或打开iOS模拟器，模型也可以使用这些工具。那么MCP部分是如何工作的呢？MCP，即模型上下文协议，是Anthropic公司定义的东西。这是如何运作的呢？你只需利用该协议连接到任何工具上吗？

Yeah, exactly. Cloud Code is an MCP client and an MCP server. And what this means is if you give it tools to use. So maybe at your company, you have a bunch of MCP tools that you build for all your systems to integrate with. I guess that maybe there's one to integrate with Gira. Maybe there's another one to read Slack. And maybe write messages to Slack. Maybe there's another one to fetch some internal knowledge base or something like this. You're going to plug this into a bunch of your tools. You can plug it into Quadai, into Quad Desktop. You can also plug it into Quad Code. So it gets all the same tools that you do.

没错，Cloud Code 是一个 MCP 客户端和 MCP 服务器。意思就是说，如果你给它提供工具使用，比如在你们公司，你们可能开发了一些 MCP 工具来让所有系统进行整合。可能有一个工具是用来与 Jira 整合的，还有一个可能是用来读取 Slack 并发送消息的，或许还有一个是用来获取内部知识库的。你可以将这些工具添加到你的各种应用中，比如你可以接入到 Quadai、Quad Desktop，还可以接入到 Quad Code。因此，它能够获得你所使用的所有相同工具。

So just a few days ago, you guys announced the release of sub agents. What does that do? Yeah, sub agents are really exciting. And this actually started with a Reddit post. There was someone that posted on Reddit about how they have the sub agents that they built for Quad Code. And they had a product manager sub agent and an engineer and a designer sub agent. And a couple engineers on the team's office and got really excited and felt that this is something that we should support a lot better.

几天前，你们宣布了子代理的发布。这是什么功能呢？子代理非常令人兴奋。这一想法实际上源于Reddit上的一篇帖子。有人在Reddit上分享了他们为Quad Code开发的子代理，包括产品经理子代理、工程师子代理和设计师子代理。团队里的几位工程师看到后感到非常兴奋，认为我们应该更好地支持这个功能。

And the way sub agents works is, you know, when you start Quad Code, you have a quad and you can talk to the quad and it can do things for you. Sub agents are just other quads. And they're prompted a little bit differently. So you can customize what prompts they have. You can customize what tools they have. So for example, you can say, you know, you are a really excellent QA engineer or sub agent. Your job is to verify that code is correct and to test code. And to do that, you have these tools at your disposal, maybe of like a browser iOS simulator, Android simulator. You're given code, your job is to test it.

翻译成中文并使其易于理解：代理的工作方式是这样的：当你启动Quad Code时，你会有一个“Quad”，你可以与这个“Quad”对话，它可以为你执行任务。“子代理”就是其他类型的“Quad”，它们有不同的提示设置，所以你可以定制它们的提示内容和工具。例如，你可以设定一个子代理为优秀的QA工程师，他们的工作是验证代码的正确性并进行测试。为了达到这个目的，他们可以使用一些工具，比如浏览器、iOS模拟器或Android模拟器。你会给他们代码，他们的任务就是进行测试。

You might have another engineer, another sub agent that's maybe a project manager. And their job is to have tasks and then divide up tasks for other sub agents. And so you can kind of split up all the work into these different roles. I think we're still figuring out what these roles are. There's one version of the world where the roles are kind of like a, on a regular engineering team where you have engineers and designers and product managers and data scientists and so on.

您可能会有另一位工程师或另一位可能是项目经理的代理人。他们的工作是负责任务，然后将任务分配给其他代理人。这样，您可以将所有工作划分成不同的角色。我认为我们仍在摸索这些角色的具体定义。有一种情况是，这些角色就像常规工程团队中的角色一样，比如有工程师、设计师、产品经理和数据科学家等。

There's another world where actually sub agents are a little bit more similar. And maybe every sub agent can kind of do the same thing, but they kind of split up the work a little bit more. So everyone is a generalist. And then quad is in charge of figuring out how to launch the sub agents, in which particular sub agents to use in which way, exactly the same way that it would use for any other tool. So you can think of it as a really, really intelligent tool where the model can launch more quads to do things. So basically it's like, if you think of AI as an intern, it's like having a group of interns and ever intern as their own role. And then you recombine what everybody did into one result. That's exactly right. And you can define what those roles are.

有一个不同的世界，在那里，次代理之间更加相似。也许每个次代理都可以执行相同的任务，但他们更合理地分工合作，所以大家都是通才。然后，quad负责决定如何启动这些次代理，具体选择使用哪些次代理以及如何使用它们，就像使用任何其他工具的方式一样。你可以把它想象成一个非常智能的工具，模型可以启动更多的quad来完成任务。基本上，这就像把AI看作实习生一样，只不过是一个由实习生组成的团体，每个实习生都有自己的角色，然后将大家的工作成果重新整合成一个结果。没错，你可以定义这些角色是什么。

And it's a fascinating question whether to end and throw pormorphize human functions into what agents should be doing or whether there's something that's agent native in the way the worker gets distributed and chopped into space. And chopped into smaller parts. Yeah. In the AI world, we talk a lot about this essay called The Bitter Lesson. This was a rich satin essay from Gidecai D'Ago or something. Yes. Where he talks about the more general model in most of the time in the long term, it will subsume more specific models. And so what this means is if you build a agentic system in this context, then the more general agentic system will generally outperform the more specific one in the long term.

这是否应该结束并将人类功能拟人化为代理应该执行的任务，还是在工作分配和拆解成更小部分的过程中有某种独特的代理特性，这是一个非常有趣的问题。在人工智能领域，我们常常讨论一篇名为《苦涩教训》的文章。这篇文章由Rich Sutton撰写，他提到大多数情况下，更一般的模型从长远来看会包含更具体的模型。这意味着，如果你在这个背景下构建一个代理系统，那么更通用的代理系统通常会在长期内表现优于更具体的系统。

And I think where we're at today is models have the capability to do stuff. But if you give them too many tools or too much context or too much responsibility, it might be disappointing because they won't really know how to handle it. And the models of a year ago could barely even call tools. The models of today are pretty good at doing it, but get a little bit overloaded sometimes with context or with too many tools. And so we can divide them up into sub agents in this way. But I think that the models six or 12 months from now they probably won't need this anymore because they're all going to be pretty good. And you won't have to define very rigidly what each one's responsibilities are anymore.

我认为我们目前的状况是，模型已经有能力完成任务。但是，如果给它们过多的工具、过多的背景信息或过多的责任，可能会令人失望，因为它们不一定知道如何应对。一年前的模型几乎无法调用工具，而现在的模型在这方面做得相当不错，但有时在处理过多的背景信息或工具时会有点负担过重。因此，我们可以通过将它们划分为子代理来解决这个问题。不过，我认为六个月或一年的未来模型可能不再需要这种划分，因为它们的能力会变得非常强，不再需要严格定义每个模型的职责。

And so this is something we're building for people today because we think it's quite useful today and it's something that we use a lot. But I could also see this going away at some point. Yeah. It's a concept of a context pollution, right? That's one of the way people describe it right. And then Claude code can handle both free, precise tasks like debugging or much broader tasks like a broad refactor, for example, is the idea that the broader the task, the more sub agents you would have in the current context?

所以这是我们为今天的人们打造的东西，因为我们认为它非常有用，而且我们自己也经常使用。但我也能想象某天它可能会消失。是的。有人把这称为“上下文污染”的概念，对吧？有人这样形容。而Claude代码能够处理既精确又自由的任务，比如调试，或者更广泛的任务，比如大规模重构。这种想法是，任务越广泛，当前上下文中就需要越多的子代理，对吗？

Yeah, that's probably one way to think about it. Generally, when we introduce Claude code to new people, we actually suggest that like you said, Claude code can do everything. And this is one of the things that makes it a little bit hard to use if you're an engineer that's used to essentially like text completions in the idea. It's a very different kind of AI coding experience. And so generally, the thing that we recommend is start with something simple like just ask questions about the code base. So don't even code, don't use any tools. Just ask the model questions. You know, how, what does this file do? Where is the file that does this thing? If I want to make a new, whatever, how do I do that? So just ask it questions like that.

是的，这可能是一种理解方式。通常，当我们向新手介绍Claude代码时，我们实际上建议像你说的那样，Claude代码可以做所有事情。这正是让使用起来有点困难的原因，特别是对于那些习惯于通过IDE实现文本补全的工程师来说。这是一种非常不同的AI编码体验。因此，我们通常推荐的方法是从简单的事情开始，比如先询问代码库的问题。所以不要急于写代码，也不要使用任何工具，只是向模型提问。你可以问，“这个文件是做什么的？”“负责这个功能的文件在哪里？”“如果我想创建一个新功能，该怎么做呢？”就像这样向它提问。

And for this, generally, the main model can do it and you don't really need sub agents. But then as you get a little bit more sophisticated, you might want to start to putting up the work. So if you ask the model maybe to make a small change, like I said, make the button right or make the button blue, you probably don't need sub agents. But if you do something a little bit fancier, like build a new section of the website that does blah, blah, blah. Then you might want to have a few sub agents. Maybe one is the software architect and it's responsible for planning out the work.

一般来说，主要模型可以完成这项任务，通常不需要子代理。但如果任务稍微复杂一些，你可能需要分配工作。比如，如果你让模型做个小改动，比如把按钮改成红色或蓝色，通常不需要子代理。但如果你想做更复杂的事情，比如建立一个新的网站部分，具有某些特定功能，那么你可能需要几个子代理。可能其中一个是软件架构师，负责规划工作。

Another one is maybe like some kind of reviewer, where it'll review that plan to make sure looks good. Then maybe you'll have a few sub agents that actually do the implementation. So maybe there's a front end engineer, back end engineer, this kind of thing. And then some kind of verifier at the end that verifies it. And then we also, internally, we really love using a code simplification sub agent. And its job is to take the code that was produced and just simplify it while making it still work.

另一个可能就像某种审核员，它会审核计划以确保看起来不错。然后，你可能会有一些子代理实际执行这个计划，比如前端工程师、后端工程师之类的。最后还有某种验证员来检查最终结果。此外，我们内部非常喜欢使用一个代码简化子代理，它的工作是简化生成的代码，同时确保它仍然能正常运行。

Okay, great. So that's the actions part of the agentec workflow. Let's talk about the awareness and memory of this. One of the exciting features is that Cloud Code can connect to the existing sort of code knowledge in the company. How does that work? There's a few different ways to pull in context and this kind of knowledge from the company. The simplest one is just working on files. There's a few different approaches actually to reading files. So I'll go a little bit in the depth into the way that actually happens.

好的，太好了。这是agentec工作流程中关于操作的部分。接下来我们来谈谈其感知和记忆功能。其中一个令人兴奋的特点是，Cloud Code可以连接到公司现有的代码知识库。这是如何实现的呢？这里有几种不同的方法来获取公司的背景信息和这类知识。最简单的方法就是处理文件。其实，阅读文件有几种不同的方式。接下来我会详细介绍一下这个过程是如何进行的。

In the past, the thing that people use the most is this thing called rag. And essentially this is a technique where you take the whole code base. And this actually works for any document set of documents. It's not necessarily code. But you take a set of documents like all the files in the code base. You do this kind of indexing step and then you store essentially this database of all the knowledge that's in these files in a very, very particular form that makes it really easy for the model to search. There's a lot of trade-offs to doing this.

过去，人们最常用的一种工具叫做“rag”。这个技术的基本原理是将整个代码库（或一组文件）进行处理。实际上，这个方法不仅适用于代码，同样也适用于任何文档集。你需要对这些文档（比如代码库中的所有文件）进行一种索引步骤，然后以一种非常特殊的格式存储这些文件中的所有知识，形成一个数据库。这种格式设计得非常方便模型进行搜索。不过，采用这种方法需要权衡许多利弊。

The indexing takes time. It's pretty expensive to maintain this database. It's quite tricky, practically, to make sure that security is really good and privacy is really good. Because it's just a very sensitive information like your code base. And so you want to keep it really safe. And so Quad Code actually doesn't use this technique called rag. Instead, what does is it just searches files the same way that a human would. You can think of it like at the engineering level it uses the tools glob and grep.

索引需要时间，而且维护这个数据库的成本相当高。实际操作中，要确保安全性和隐私性都很好是相当棘手的。因为这些信息非常敏感，就像你的代码库一样，所以你会希望它非常安全。因此，Quad Code并没有使用一种叫做rag的技术。相反，它只是像人类一样搜索文件。可以把它想象成在工程层面上，它使用了glob和grep这两个工具。

These are two tools that are kind of built into the computer. And you can think of it as kind of command F for files. So it will just search around with text the same way that a human can. And what's kind of cool is if you just search for one piece of text, you might get the result you're looking for. But you might not. And depending on the result you get as a human, you would refine your search term and you would try again. And you might try a few times to get the result you're looking for.

这些是内置在电脑中的两个工具。你可以把它想象成文件的“Command F”功能。它会像人类一样进行文本搜索。有趣的是，如果你只搜索一段文字，你可能会得到想要的结果，也可能不会。根据你得到的结果，你可能需要像人一样调整搜索关键词，再次尝试。为了找到目标结果，你可能需要尝试几次。

And the model is really good at this. And this again, this is one of those things that was not the case like with models of a year ago, but with models of today, they're excellent at this. And so we call this process agent search. And what this means is using really, really simple search tools like command F. And using them repeatedly and then adjusting the search terms over and over based on the result of the query.

翻译成中文如下：这个模型在这一方面表现非常出色。这又是一个与一年前的模型不同之处，现在的模型在这方面非常优秀。因此，我们把这个过程称为代理搜索。这意味着使用非常简单的搜索工具，比如命令F（Command F），然后不断重复使用，并根据查询结果不断调整搜索词。

And this is something that we don't specifically tell the model to do. It's something that I just figure is out because it's intelligent enough. And it has the search tool. So this is the first form of memory, which is just looking at the contents of the code base and understanding it in this way. We augment this a little bit with this thing we call cloud dot MD files. And all this is a special file. It's what are you called cloud dot MD.

这并不是我们特别指示模型去做的事情。这是因为模型足够智能，所以自己能做到的事情。此外，它还具有搜索工具。这是第一种形式的“记忆”，即通过查看代码库的内容来理解它。我们通过一种叫做cloud.md文件的东西稍微增强了这一点。这是一种特殊的文件，名为cloud.md。

You put it in your code base or you can put in whatever folder you want. And use it to record memories. So at any point you can tell cloud to remember something. So for example, whenever I do, whenever I edit this file, I always want you to double check it in a browser or something like this. You can tell cloud to remember this and then it will record it in the right quantum D. So that it remembers it next time.

你可以将它放入你的代码库中，或者放在你想要的任何文件夹中。用它来记录记忆。这样的话，在任何时候你都可以让云端记住一些事情。比如说，每次我编辑这个文件时，你可以告诉云端记得检查一下它在浏览器中的效果。你只需要告诉云端记住这个指令，它就会将其记录在正确的位置，以便下次继续记住。

And I think one of the most powerful use cases we've seen with this is when people check this into their code base and share it with their team. So this is a, it's a memory file. It's just a regular text file on the computer. But you don't keep it to yourself. You share it with all the other engineers on your team. And what it means is if cloud remembered something when you were using it, everyone on your team gets to benefit from that.

我认为我们看到的一个最强大的用例就是，当人们将这个文件纳入他们的代码库并与团队分享时。这个文件是一个记忆文件，本质上就是电脑上的一个普通文本文件。但你不会只保留给自己使用，而是和团队中的其他工程师一起分享。这意味着，如果云服务在你使用时记住了什么，你的整个团队都能从中受益。

And it gets this really interesting effect where everyone on the team starts to contribute to this knowledge base and this kind of memory bank. And it's very simple. Again, it's a text file. So anyone can read it also. So it's very easy to edit these memories also and see exactly what's in there. But everyone just starts to benefit. And it feels kind of magical because as your team uses quad code to get smarter and smarter and kind of similar to building in the CLI, this is literally the simplest thing we could have done.

这会产生一种非常有趣的效果，即团队中的每个人都开始为这个知识库贡献内容，类似于一个记忆库。而且这非常简单。本质上讲，它只是一个文本文件，所以任何人都可以阅读。而编辑这些记忆也很容易，你可以清楚地看到里面的内容。每个人都从中受益。这种感觉有点神奇，因为随着你的团队使用四元码（quad code）来变得越来越聪明，这种体验很像在命令行界面（CLI）中进行构建。这实际上是我们能做到的最简单的事情。

There's nothing simpler than this. I think that we could have done to build memory. There's nothing. There's no special tools. There's no special prompting. There's nothing like this. It's just a file and quad kind of learns to use it. And you have to declaratively add to the memory or whether today or in the future, the memory will automatically pull from the context and sort of improve itself.

没有什么比这更简单的了。我认为我们本可以做到建立记忆的。这不需要任何特殊的工具，也不需要特别的提示。没有什么像这样的东西。它只是一个文件，系统会自动学会如何使用它。你需要明确地将内容添加到记忆中，无论是今天还是将来，记忆都会自动从上下文中提取信息并自行完善。

Yeah, you have to add to it manually today. We've actually had a bunch of internal experiments to do automatic memory. So quad can automatically remember things. The problem is there's kind of two ways in which it feels. One is that it remembers things that it shouldn't. So for example, if I say make the button blue, it might remember that the user always wants the button to be blue. And this is, you know, maybe that's the case for this button. That's not the case for every button. And then sometimes it doesn't remember very important things that it should remember. And so for the last few months, we've been doing a lot of experiments to try to get this performance really good. And it's something we've been using internally. And at some point when we're happy with it, it's something we're going to release for everyone. But generally our bar is if we find ourselves really happy with it and we find ourselves using it every day, then we release it to everyone. And this one's not quite there yet.

是的，今天你得手动添加。其实，我们做了很多内部实验来实现自动记忆功能，让系统能自动记住事情。问题在于，这种方式有两个不足之处。首先是它会记住不该记住的东西。比如，如果我说“把按钮变成蓝色”，它可能就会记住用户总是想要这个按钮是蓝色的。但这可能仅适用于这个按钮，而不是所有按钮。其次是它有时候不会记住需要记住的重要信息。所以过去几个月，我们一直在做大量的实验，试图提升这一性能。这个功能我们已经在内部测试使用了，如果有一天我们对它的表现非常满意，并且我们每天都在用它，就会推出给大家。目前还没有达到这个水平。

It's another fascinating example or discussion when you compare a gently memory like this to human memory. And the fact that you can edit it and then leads to all sorts of questions around, okay, what is it that we as an organization should remember and who's in charge of ultimately editing what should be remembered or not? Because this is for code, but code being everything is a fascinating concept. Yeah, this is, I think this is one of those social problems and maybe not social problems. This is one of those social dynamics that will change over the coming years as people use these tools more and more. Is we need to figure out like what are the roles of people on the team and how do they interact with each other and interact with Quad. And this is maybe one very specific problem within that who curates Quad's knowledge. My feeling is that this is something where teams will kind of get more and more horizontal as a result of this because anyone is able to contribute in this way. But it'll be interesting to see how it plays out.

将这样一种温柔的记忆与人类记忆进行比较时，这是另一个引人入胜的例子或讨论。关键在于，你可以编辑它，这引发了一系列问题：我们作为一个组织应该记住什么，谁负责最终编辑哪些内容应该被记住或不被记住？因为这是关于代码的，但代码就是一切，这是一个令人着迷的概念。我认为这是一个社会问题，但可能不完全是问题。这是一种社会动态，随着人们越来越多地使用这些工具，未来几年这会发生变化。我们需要弄清楚团队成员的角色是什么，他们如何相互协作以及如何与 Quad 互动。这也许是一个非常具体的问题，即谁来管理 Quad 的知识。我感觉这会使团队变得越来越扁平化，因为任何人都可以通过这种方式做出贡献。不过，看看这将如何发展会很有趣。

And then the key question for agents is always the level of autonomy versus human in the loop. How do you guys think about that and where do I get pinged as the human coder in my cloud code workflow? The default behavior is there's always a human in the loop. This is, this is super important because this is in the end, this is a model and it's not predictable. And you want to make sure that it doesn't do anything dangerous. So yeah, there's always a human loop. So for actions that we know can't have any kind of dangerous repercussions. So for example, reading a file, we know this is inherently safe. We just let the model do this in the folder that you might have to do this in. But for other actions like editing a file or running a command or using the internet, this always needs a human in the loop. And it always needs a human to approve it.

对于代理而言，关键问题总是自主性与人类干预之间的平衡。你们是如何看待这个问题的？在我的云代码工作流程中，作为人类编码者，我什么时候会收到提示？默认情况下，总是有一个“人类在环”的设置。这非常重要，因为最终这是一个模型，而且它的行为是不可预测的。我们需要确保它不会执行任何危险的操作。因此，始终有一个“人类在环”的机制。对于那些我们知道不会产生任何危险后果的操作，比如读取文件，我们知道这本质上是安全的，我们可以让模型在你设置的文件夹中执行这类操作。但对于像编辑文件、运行命令或使用互联网等操作，这些始终需要有人类介入，并且需要经过人类的批准。

There's ways to reduce this burden a little bit. So for example, if you find yourself always approving edits to the same file or always approving the same command. There's a settings file that you can configure across your team. And you can use this to essentially allow us to block with certain commands, certain files that you always want the model to be able to edit without human approval. Or you never want it to be able to run. And while we are on the topic of sort of safety and security, how do you guys think about sort of confidential code, you know, that whole model? You know, that whole world of like regulated industries and sensitive code and kind of stuff. Do you offer a local version of this and on-prem version of this? Or maybe that's a question for Cloud Code, but I can throw up again in general. Are you all sort of cloud-based?

可以通过一些方法稍微减轻这个负担。例如，如果你发现自己总是在批准对相同文件的修改或相同命令，有一个设置文件可以让你在团队中进行配置。你可以利用这个文件来设置某些命令或文件，让模型可以在无需人工批准的情况下编辑，或者你可以设置模型永远不能运行这些命令或编辑这些文件。说到安全和保障，大家是如何看待机密代码的呢？对那些受监管行业和敏感代码的处理方式是怎样的？您是否提供本地版本或内部部署版本？也许这也是Cloud Code的问题，不过我可以再问一下，你们主要是基于云的吗？

It's something that actually we've seen work quite well in these very, very regulated industries. And the reason is that it doesn't use any services except the API itself. So that's all it needs and then everything else you actually don't need. And this is one of the nice side effects of not doing code-based indexing or anything like this is it's just very easy to hook up to. So if let's say you're a bank and at your company, you already have a better-ock approved, you can just use better-ock and use Cloud Code that way. So you run out on people's laptops and all you need is access to better-ock. So really easy to get approval for. And then if you want to use the Anthropic API or Vertex, you can use that too.

在那些高度受监管的行业中，我们发现这种方式效果很好。原因在于，它只需要使用API本身，不依赖任何其他服务。因此，你只需要API，而其他东西完全不需要。而不依赖代码索引的方式的一个好处就是，它非常容易连接。比如说，如果你是一家银行，并且公司已经获得了better-ock的批准，你可以直接使用better-ock，然后结合Cloud Code来使用。这样你就可以在员工的笔记本电脑上运行，只需要访问better-ock即可，非常容易获得批准。如果你想使用Anthropic API或Vertex，也可以随时集成。这种方式审批十分简单。

How do you think about the UI and UX experience of this? How you balance the power of everything can do versus your stated goal of being as lean and lightweight, of an interface on top of the model. So we just talked about how you can approve actions that the agent takes. What about the rice? Does it basically feel like you'd be using a regular CLI or is there something different that one needs to get used to? We tried really hard to make Cloud Code something really beautiful that everyone feels is something that we put a lot of care into because we did. And I think when you use Cloud Code, you can feel that this is something that we use every day. At this point, most code at Anthropic is written using Cloud Code. And almost everyone at Anthropic is using it every day.

你如何看待这个UI和UX体验？你是如何在让界面具备各种功能的强大能力与实现轻量化目标之间进行平衡的呢？我们刚才讨论了你如何批准代理执行的操作。那么对于界面体验，你觉得它更像是使用传统的命令行界面（CLI），还是有一些新的使用习惯需要适应？我们非常努力地将Cloud Code打造成一个让每个人都觉得精美且充满用心的产品，因为我们确实如此用心。我想，当你使用Cloud Code时，你能感受到这是我们每天都在使用的工具。目前，大部分Anthropic的代码都是使用Cloud Code编写的，几乎所有在Anthropic的人每天都在使用它。

And when we look at customers that start to use Cloud Code, they use it kind of more and more and more. And with a product like this, you want it to feel really smooth and really beautiful and something you really enjoy using. And that's been really fun from my engineering and design point of view because we build in a terminal. Like as I've had terminals, I've been around for 50 plus years at this point. And it really feels like we're rediscovering how to design for a terminal. Because since terminals were first invented, the design world moved to Web and then it moved to Apps.

当我们观察开始使用Cloud Code的客户时，他们会越来越频繁地使用它。对于这样的产品，我们希望用户感到操作顺畅、界面美观，并且真正享受使用的过程。从我的工程和设计角度来看，这非常有趣，因为我们是在一个终端上构建产品。终端这个概念已经存在了五十多年，现在我们仿佛在重新发现如何为终端设计。因为自从终端首次发明以来，设计领域已经转向了网页设计，然后又转向了应用程序设计。

And there's kind of different design principles you can take here. And we try to apply these back to Cloud Code even though it's running in a terminal. And there's a lot of details that we spent a lot of time on. Like the way that we represent statuses for every item with this kind of blinking dot that turns red or green to indicate whether it's exceeded or failed. The even the loading indicator, like the spinner while Cloud is working, we spent probably 30 or 40 iterations of this. Just to get it to feel just right to make it feel so you know what's happening, but it's not giving you too much information.

这里有几种不同的设计原则可以采用。我们试图将这些原则应用到Cloud Code上，即使它是在终端中运行。我们花了很多时间关注细节。比如，我们用闪烁的小点来表示每个项目的状态，这个点会变红或变绿，以指示项目是否完成或失败。甚至连加载指示器，比如Cloud工作时的旋转图标，我们都进行了大约30到40次的迭代调整。这样做是为了达到一个恰到好处的感觉，让你知道正在发生什么，但又不会给你过多的信息。

And it's also not jittering and moving around on you. So yeah, every part of the interface we iterated on probably more than more than you think. Yes, and then this is really fun kind of like series of words while the while Cloud does its thing. Or it says like cooking or hurting or schlepping or honking or clotting, which you know how many of those words do you have? But you seem to have like dozens of them. I just find it such a like a fun kind of like Easter egg kind of kind of design detail that makes the whole difference.

这段话的大意是：而且它不会抖动或在你面前乱动。所以，是的，我们对界面的每个部分进行了多次迭代，可能比你想象的还要多。是的，这真的很有趣，就像是一系列的词语，而当系统运行时，它会显示像是“烹饪”、“刺痛”、“搬运”、“鸣笛”或“凝结”等词语。你到底有多少这样的词语？似乎你有几十个。我认为这是一种有趣的设计细节，就像复活节彩蛋一样，让整体体验与众不同。

You know at the beginning I added maybe 20 of them and then immediately people started making a suggesting changes like hey how about this word? How about this word? How about this word? So now at this point, there's a pretty big list and the quad can actually choose the word that best describes the task that it's doing. So it's up the quad, which word it wants. How do you charge for using the product? And I'm asking this in the context of I think over the last few days, there was some evolution as people became one more rabid users of the product.

一开始，我大概添加了20个词，然后人们立刻开始建议更改，比如说“这个词怎么样？那个词怎么样？” 于是到现在，我们已经有了一个相当庞大的词汇列表，四边形可以选择最能描述它所执行任务的词汇。因此，选择使用哪个词是由四边形决定的。你们是如何为使用这个产品收费的？我之所以这样问，是因为我认为在过去几天里，随着人们对这个产品越来越热衷，产品本身也有了一些发展。

The pricing structure evolved. Yeah, this is something that we were honestly really excited to see how some people are just going, they're really figuring out how to run this thing at all hours of the day. It's just, you know, some people have this army of quads, you know like 5, 10, 20 that are just running in parable all the time and just doing work. I talked before about how you quad generally needs human approval to do work. There's actually ways to do it in slightly more autonomous way too if you want to run it for long periods.

定价结构发生了变化。这确实是我们非常期待看到的事情，看着那些人找到方法全天候运行这个系统，有些人就在不断探索。有些人拥有一支由5、10或甚至20个四轴飞行器组成的队伍，它们一直在并行运作，不停地进行工作。以前我提到过四轴飞行器通常需要人类的批准才能开展工作。实际上，如果你想长时间运行它，也可以采用稍微自动化的方式。

That's actually you need to set up a container for it and just give it some kind of like a container to be in and then they can run without approval in a way that is safe. And so there's a lot of people that do this. It's extremely exciting, but also the pricing structure that we had was really not cut out to actually serve these kinds of users. And there's also just a little we call this kind of abuse for at the tail end. You know, there's like a counter chairing and things like this where people are just really not using it in the way that it's intended.

实际上，你需要为它设置一个容器，并给它一个可以运行的环境，这样它们就可以在安全的情况下运行，而不需要额外的审批。很多人正在这样做，这非常令人兴奋。不过，我们之前的定价结构并不适合这种用户。此外，我们注意到了一些滥用行为，比如在使用时没有按照预期的方式操作。

So generally for a plot code, there's two pricing models today. One is you can get a subscription. There's there's pro and that there's max. And this is I think it's 20 bucks a month, 100 bucks a month or 200 bucks a month. And it has very, very generous rate limits. If you use only opus, you'll run out of limits pretty quick and then we'll switch you over to sonnet. If you sonnet, then you know, you can use much more of it than most people need and almost everyone doesn't run into rate limits at all.

一般来说，对于绘图代码，今天有两种定价模式。一个是订阅制，有专业版和最高版。我想价格大约是每月20美元、每月100美元或每月200美元，并且它有非常慷慨的限额。如果你只使用opus，很快就会达到限额，然后我们会将你切换到sonnet。使用sonnet的话，你可以使用的资源比大多数人需要的还要多，几乎没有人会遇到限额。

It's generally power users run into it. And this is something that we're thinking also thinking through a kind of all this as we land features where people use more tokens and there's more sub agents and there's more autonomy. Because we need to figure out a way that we can provide this to people in a way that's sustainable. It's an interesting that amic right because your tool for power users, very sophisticated coders that do sophisticated things with it. But equally, you don't want to you want to encourage them not discourage your power users was pricing. Exactly, exactly.

通常是高级用户会遇到这个问题。当我们推出功能时，用户会使用更多的令牌，并有更多的子代理和自主性，这是我们一直在深入思考的问题。因为我们需要找到一种可持续的方式来为用户提供这些功能。这很有趣，因为这个工具是专门为高级用户和非常复杂的编码人员设计的，他们用这个工具做非常复杂的事情。但与此同时，我们也不想通过定价来吓退他们，而是希望能激励他们。确实如此，确实如此。

Yeah, we want to we want to support the community. We want to hear how people use quad code in these ways so that we can make sure that we can support that. That's super important to us. Great. So it's a price per token or you get like a certain number of tokens for certain pricing tiers. Yeah, essentially like within a certain period of time, you have a certain number of tokens you can use. And then if you want pretty much unlimited usage without dealing with these women, you can always just use a API key. And this way you can just use as much as you want.

是的，我们想要支持社区。我们希望听到大家如何使用四元码，以便确保我们能提供支持。这对我们非常重要。好的，那么是按每个代币定价，还是根据不同的定价层级获取一定数量的代币呢？基本上，你在一个特定时间段内可以使用一定数量的代币。如果你想要几乎不限量地使用，而不受限制，可以使用API密钥。这样你可以随心所欲地使用。

So I'd love to spend a little bit of time double clicking on use cases. So we talked about this a little bit and talked about how actually some people at the fringe are using a cloud for non-coding use cases. But talking about the intended users or the coders, what are the main things that you see people do in a context where cloud presumably can do everything?

我想花一点时间深入探讨使用案例。我们之前稍微提到过，有些边缘用户将云技术用于非编码的用途。但是，谈到那些主要用户或者编码人员时，在一个云技术几乎无所不能的环境中，你观察到他们主要用云来做什么呢？

Yeah, we see people using it for all sorts of stuff for all sorts of code-related tasks. Everything from planning projects to managing tasks to actually writing code, testing code, debugging, it's excellent at. So if something doesn't work, you can ask quad to debug it, writing unit tests, verifying code. Whenever there's issues in production, our first find of defenses to give it to cloud. We have logs coming from GCP or whatever. We give this to cloud and it'll figure out what is the issue that's happening.

是的，我们看到人们用它来处理各种与代码相关的任务。无论是项目规划、任务管理，还是实际编写代码、测试代码、调试代码，它都很出色。如果有什么问题无法运行，你可以请它来调试，编写单元测试、验证代码。当生产环境出现问题时，我们的第一步是把问题交给云服务。我们有从GCP（谷歌云平台）或其他来源获取的日志，我们把这些提交给云服务，它就能找出到底发生了什么问题。

And it can even interact with the Git and source control. So it can figure out what exactly cause to breakage or what exactly cause to regression. It can automatically fix it. So yeah, it's for every stage of STLC. And I think this is the first tool that really serves every stage in this way. And like I said before, we didn't intend it to be this way. It just happens to be very general and a cloud happens to be really good at using these tools.

它甚至可以与 Git 和代码管理系统交互。这意味着它可以找出究竟是什么导致了中断或回归，并能自动修复它。所以，它适用于软件测试生命周期（STLC）的每个阶段。我认为这是第一个能够以这种方式服务每个阶段的工具。正如我之前所说，我们并不是故意让它成为这样的工具，只是它恰巧非常通用，而云服务又非常擅长使用这些工具。

And so this is a, you know, for me, this has been kind of accidental product market fit across the entire lifecycle of engineering work. So yeah, the kind of accident that every founder or creator of a product dreams of that happens so rarely. What an amazing story. And presumably if you have those, those MD files and agentic search, cloud code can also be used if you're a new person either at a company or on a project to learn about the code. First of all, is that right? And two, do you see people do that?

这对我来说是一种意外的产品市场契合，贯穿了工程工作的整个生命周期。这是一种每个产品创始人或创造者都梦寐以求的意外，但却很少发生。多么奇妙的故事。假设你有那些MD文件和智能搜索功能，如果你是公司或项目的新手，云代码也可以用来学习代码。首先，这是对的吗？其次，你看到有人这样做吗？

Absolutely. When I think about the things that that cloud code is good at, I'll be kind of, I'll be a little bit self critical. I feel like if you look at answering questions about the code base and kind of code based research, I think it's like 10 out of 10 good. It's as good as it can get. When it comes to writing code, it's maybe like a six out of 10. It's pretty good. It won't get everything perfect. The next model will be better and it's something that we keep improving.

当然。谈到云端代码的优点时，我会稍微自我批评一下。如果你看一下关于代码库的问题回答和代码库研究，这方面云端代码简直可以打满分，表现得非常出色。但在编写代码方面，我觉得它大概能打6分（满分10分）。虽然表现不错，但不能做到完美。不过，下一个版本会更好，我们一直在不断改进。

When it comes to debugging code, it's maybe also like a six or seven out of 10. So I think this code based research and onboarding on code base, it's really, really excellent at it. And at Anthropic, whenever new people join on their second day, this is part of technical onboarding. We teach them here's cloud code. Here's the code base. If you have any questions, don't bug engineers on your team. Just has cloud code.

在调试代码方面，它可能也能达到6到7分（满分10分）。所以，我认为在代码库的研究和学习上，它做得非常出色。在Anthropic，每当有新员工加入时，他们的第二天技术入职培训中就包括这一部分。我们会教他们如何使用cloud code，并介绍代码库。如果有任何问题，不要去打扰你团队的工程师，同样使用cloud code就可以了。

And again, answer these questions probably better than they can because you can search around the code, it can look through history, it can look through power questions, FAC, and just pull in all the context to answer all these questions. And what we saw is at Anthropic technical onboarding used to take a few weeks. But now engineers are you who we productive within the first few days. And they don't task their teams anymore.

再讲一遍，要比他们更好地回答这些问题，因为你可以在代码中搜索，可以查看历史记录，可以查看常见问题解答，并且可以整合所有背景信息来回答所有这些问题。我们看到，在Anthropic的技术培训以前需要几周时间。但现在工程师在入职后的头几天就可以高效工作，而且他们不再需要依赖团队去分配任务。

I think this is the biggest thing where you don't need to bug your senior engineer or your manager anymore to get answers to your questions. You just ask what code and it can answer all these questions for you. In the same vein, what do you find yourself using cloud code for as a leader and engineer? What's your daily use case?

我认为这是一个很大的优势，你不再需要烦扰你的高级工程师或经理来获取答案。你只需要询问代码，它就能为你解答所有问题。同样地，作为领导者和工程师，你在使用云代码时发现自己用来做什么？你每天的使用场景是什么？

Yeah, I use it all day for all sorts of stuff. So obviously, like I said, code based research. If I'm working on a piece of code, I'm not familiar with. I'll just start by asking Quad Code to tell me about it. Whenever I'm working on a small feature, I'll usually use Quad Code in GitHub actions. So I'll just say add quad, I'll make a new GitHub issue and then I'll say add quad implement this feature for me. And it'll just do it usually in one shot. And sometimes I'll do this on the command line too. So I'll just say implement this feature and make a pull request and I'll come back a few minutes later on that's done.

是的，我整天都用它来处理各种事情。显然，就像我之前提到的，我用它进行基于代码的研究。如果我在处理一段不太熟悉的代码，我会先请教 Quad Code。每当我在开发一个小功能时，我通常会在 GitHub 的动作中使用 Quad Code。我会在 GitHub 上创建一个新的问题，告诉 Quad Code 帮我实现这个功能，通常它会一次性完成。有时候，我也会在命令行上这么做，我只需告诉它实现这个功能并创建一个拉取请求，过几分钟就完成了。

Then there's this kind of other work where it's a little bit more complex. You can't really do it in one shot. It's not as simple as changing a piece of text or changing a button or building a small feature. Maybe it's like something more involved. There's probably two work flows I have here. One is for really complex stuff. I'll prototype it a bunch. And this is something that I did even before Quad Code. You know, when you when you write a complex piece of code or a complex feature, often engineers will write it a few times.

然后，还有另一类工作，它会稍微复杂一些。你不能一次就完成，它不像修改一段文字、改变一个按钮或者构建一个小功能那么简单。可能涉及更多的步骤。对于这种情况，我一般有两个工作流程。一个是针对非常复杂的东西，我会做很多次原型设计。其实在进入Quad Code之前，我就这样做了。你知道，当你编写一段复杂代码或一个复杂功能时，工程师们通常会多写几次。

Because you don't actually know the right way to do it. And so you'll try one approach. You'll try second approach. You'll try third approach and you'll kind of figure out the edge cases for each and kind of the limitations and you'll get a fuel for the problem this way. And this is something I used to do by hand. Nowadays I'll just talk quad code to do it. So I'll maybe make a few get work trees, I'll launch a few quads and then in parallel to them. Here's your job. I want you to implement this feature. Go to town.

因为你实际上并不知道解决这个问题的正确方法。所以你会尝试第一种方法，然后尝试第二种方法，再尝试第三种方法。这样做的过程中，你会逐渐了解每种方法的优势和限制，并对整个问题有更深的理解。过去我都是手动完成这些工作的。现在我会用自动化代码来处理。我可能会创建一些Git工作树，启动几个并行的任务。然后我会告诉这些任务："这是你的工作，我希望你实现这个功能，放手去做吧。"

And I'll then look at each of the solutions and try to figure out, OK, maybe I like this piece of this one, this piece of this one, this piece of this one. And then I'll throw away all that code. I'll just I'll discard it and then I'll sort a new quad and I'll tell it, OK, here's how I want you to do it now that I got a I got to feel for the problem. And then I think the last workflow is actually the one I probably use the most and this is probably for medium sized features.

我会查看每个解决方案，然后思考一下，也许我喜欢这个方案中的某一部分，那个方案中的某一部分，以及另一个方案中的某一部分。然后，我会把所有代码都扔掉。我会舍弃它们，然后重新开始一个新的框架，并告诉它，现在我对这个问题有了一定的理解，我想让你这样做。我想这种流程是我最常用的一种，大概适用于中型特性。

And in this one, I'll ask quad to make a plan and I'll go back and forth with it a little bit on that plan. And it's really important actually to get that plan right and to make sure it's the same thing you have in mind before you continue. Because otherwise what I see sometimes is people ask quad for a little bit too much, maybe it's a complex feature and then it wrote it in some way that like it's not at all what you wanted, but the problem isn't that quad doesn't know how to do it.

在这段文字中，我会请 quad 制定一个计划，而我会在这个计划上与它进行一点来回交流。实际上，确保这个计划正确且与你心中的想法一致是非常重要的，因为如果不这样，有时候会出现的问题是，人们对 quad 的要求可能过多，也许是一个复杂的功能，结果 quad 的表现方式完全不是你想要的。但问题并不是 quad 不知道怎么做。

The problem is that the description is just too low bandwidth. You only described in a few words what you want. And so the idea that quad got of it is a very different idea than what you had in mind. And so I find that planning helps a lot. So you can iterate on the plan the same way that you would with anyone else you're working with. And then once that's ready, I'll ask quad to write the plan to file maybe and then I'll tell it to kind of implement that plan.

问题在于描述的信息量太小。你只是用几句话描述了你想要的东西。因此，quad对这个想法的理解和你原本设想的非常不同。我发现制定计划非常有帮助。你可以像与其他合作伙伴一起工作时一样，对计划进行迭代。等计划准备好后，我会让quad把计划写下来存档，然后告诉它去实施该计划。

And it will naturally make it to do is for tough to implement it switching tax a little bit. I'd love to talk about the space more broadly. So cloud code is a rocket chip within the anthropic rocket chip, but equally there are other products like cursor, windsurf, replete, lovable hole, you know, V zero. The list goes on and on and we've had a few of those CEOs on this podcast. What do you make of the space going forward?

翻译成中文，尽量简洁明了：自然地，这会让事情有点难以实施，比如切换税。我想更广泛地讨论这个领域。云代码是Anthropic火箭芯片中的一个火箭芯片，同样也有其他产品，如Cursor、Windsurf、Replete、Lovable Hole，还有V Zero。这份名单还在继续，我们也在这个播客中采访过其中一些公司的CEO。你对这个领域的未来怎么看？

Do you think we end up with a bunch of different solutions, different doing different things? Do you think there is a at some point of winner takes all kind of scenario? How do you how do you think about the next couple of years? Yeah, my feeling is there's kind of two dynamics here. One is that this is just a giant market. The market you could think of it as all of coding. You could think of it as all of kind of creativity and kind of creating things. Because this extends at some point beyond coding to design and things like this. So I think there's room for everyone. It's a giant market. And the biggest thing that these companies should be thinking about is everyone that's not yet using AI for coding. Because if you only focus on people that use AI for coding already, these are kind of early adopters. So you want to kind of get into that curve and get the middle and the late adopters to and many of these don't even use AI today. So I think it's a big market.

你认为我们最终会得出一堆不同的解决方案，各自做不同的事情吗？你认为会不会出现一种赢家通吃的局面？你怎么看接下来的几年？是的，我觉得这里有两种动态。一方面，这是一个巨大的市场。你可以把它想象成所有的编程，也可以想象成所有的创造性工作，因为这不仅限于编程，还会拓展到设计等领域。所以，我认为每个人都有机会参与，这是一个巨大的市场。而这些公司最该考虑的问题是，那些尚未利用人工智能进行编程的人。如果只关注那些已经在用AI编程的人，他们只是早期采用者。你需要进入增长曲线中间部分，吸引中期和晚期的用户，而这些人很多现在甚至还没有使用AI。因此，我认为这是一个巨大的市场。

I personally use a lot of these products. And you know, I use quad code every day, but I also use cursor every day and I use other products every day. So there's room for all these and they all kind of fit together into people's workflows. The second way to think about it is like I said before, the model is getting better so quickly that the kinds of things it's able to do are just changing every few months. It's this it's exponential that just keeps accelerating and this is really the feeling inside of the lab. You know, working on AI and kind of building the stuff. And hopefully it's also the feeling that users have as you get to use all these new products that are coming out every few weeks or you know, maybe a few days at this point.

我个人使用很多这样的产品。你知道，我每天都使用quad code，但我也每天使用cursor，还有其他产品。所以这些产品都有它们的用武之地，并且很好地融入人们的工作流程中。其次，就像我之前说的，模型进步得非常快，它能够实现的功能每隔几个月就会改变。这种变化是指数级的，并且一直在加速。这正是实验室内部的感受，在那里我们在研究和开发人工智能技术。我希望用户也有同样的感受，随着每隔几周甚至几天就有新产品推出，用户可以体验到这些新产品。

So yeah, it's really exciting and I think my advice to companies building is definitely build for what the model will be able to do six months from now. Not for what the model can do today. This is probably the single biggest advice and this is something that we followed for quad code also. We started building quad code when it was still on at 3.5 and it was okay and then with you know 3.6 and 3.7 it was still it was fine. It was pretty good. But then when it's on for an open for came out, that's when a really hit it's dried and we felt like the product was really good and we started to be able to use it for a lot of coding. And so this the biggest way I would think about it is how do you build the product that captures the model capabilities six maybe even 12 months from now in the market for those capabilities is just going to be huge.

所以，是的，这真的很令人兴奋。我给正在开发产品的公司的建议是，一定要为模型在六个月后能够实现的功能而构建，而不是为现在能够做到的功能而构建。这可能是最重要的建议，我们在开发Quad Code时也遵循了这一点。我们在3.5版本时就开始开发Quad Code，当时还可以，后来到了3.6和3.7版本时，表现也不错。但是真正让我们感到产品很棒并开始能够大量用于编码的是在OpenAI推出四代（GPT-4）时。这是因为市场对这些功能的需求未来六个月，甚至12个月后，都会非常大。

Yeah, and to double click on that if I'm a product builder or founder, how do I know that how do I know what's in the you know six months horizon. And you know, I'm speaking of like entropic or in general, what is it that's going to happen in the next six months that I should plan on on talking about the coding capabilities. Yeah, I think the biggest thing is just use all these products and see where they stumble and try to get a feel for the model itself. I think what code is a really good way to do that is probably other ways to but try to kind of get away from all this scaffolding and all the products people built around it and just get a feel for the model's capabilities and as raw farmers you can.

是的，如果我是一名产品开发者或创始人，我该如何了解未来六个月的发展方向呢？尤其是在像这样的快速变化领域中，我应该关注什么，特别是在编程能力方面。我认为最重要的是要亲自使用这些产品，看看它们在哪些地方存在问题，并尝试了解模型本身的能力。用代码是一种很好的方式来实现这一点，可能还有其他方法，但要尽量摆脱所有这些围绕产品构建的辅助工具，尽可能直接感受模型的潜力。

And try to get your head around the limitations like where exactly does the model stumble today what is what is exactly that frontier where it's like not very good and then you know sometimes it's good and maybe 50% of the time it's good you can kind of get a feel for this frontier. And with the models today a lot of this is around kind of agentic work where it can use tools really well and then at some point maybe it will fall over when there's too much context or too many tools or the trajectories too long maybe if you've been running quad for two hours. It was a track after a little bit so there's some there's some sort of like frontier here maybe there's another frontier around code quality where today I have to maybe correct the model when you know maybe there's something that it does that isn't exactly the way I would have written it and I think over time models will get better kind of understanding this too.

尝试理解模型的局限性，比如它目前在哪些方面容易出错。哪些方面是它不太擅长的领域，而在其他方面它可能有时表现得很好，有时表现不佳，可能有50%的时间表现不错。你可以对这些界限有一个大致的感觉。如今的模型在处理代理任务时表现得不错，比如在使用工具时表现良好。但在某些情况下，如果上下文过多、工具太多或者任务太复杂，比如你已经运行了两小时，模型可能会出现问题。这就是一个界限。另一个可能的界限是代码质量，现在我可能需要纠正模型的输出，因为有时候模型的写法可能不是我想要的。我认为随着时间的推移，模型在这方面的理解会越来越好。

So I would just try to use the model in a raw a form as you can and get a feel for these front frontiers in the domain you care about. So for coding maybe it's kind of the how long the trajectory is and whether the model can stay on track and then the quality of the code and probably a bunch of other stuff and then for non coding domains there's there's a lot more. So still in the same vein of like the AI coding wars it seems that there is this this you know competition competition kind of dynamic where and andthropic or others would provide the models to companies like cursor or Windsorff at some point but equally build cloud code which is application do you think that's a long term sort of way the ecosystem works or you know in a context where cursor is saying that they're going to build their own models as well.

我建议尽量直接使用模型，以便在你所关心的领域中感受一下其前沿在哪里。比如在编程中，这可能涉及模型能够跟踪多远的轨迹、是否能保持在正确的轨道上，以及代码的质量，还有其他一些因素。在非编程领域中，还有更多的考虑因素。在类似于AI编程竞赛的背景下，似乎存在一种竞争动态，比如Anthropic或其他公司会为像Cursor或Windsorff这样的公司提供模型，同时也会开发应用程序，比如云代码。您是否认为这种生态系统的运作方式会是长久之计？或者在Cursor表示他们也要开发自己的模型的情况下，会怎样呢？

The end result is kind of like full-sack players where everybody has their own underlying model and application on top. I think there's probably room for both. And my personal take is probably there's many more stuff built on top of the platform than there will be built in the house. Just because there's so many things to build and there's just not enough time and enough people and energy to build all those things. So I think a lot of the innovation is going to happen on top of the API as an SDK is that are built.

最终的结果有点像全栈玩家，每个人都有自己的底层模型和其上的应用程序。我认为这两者可能都有发展的空间。就我个人的观点而言，在平台上构建的东西可能会比在内部构建的要多很多。因为有太多东西需要开发，而时间、人力和精力都有限。所以，我认为很多创新将会发生在作为SDK构建的API之上。

As a last theme for this conversation, the sort of the elephant in the room is what that means for coding and coding as a profession. What's your general sense for what coding is going to look like in Fures from now? Yeah, it's a little bit hard to say. You know, a Fures from now is, in AI time is like decades in normal time. I think even today for a lot of professional coders, it's really easy to lament the state of coding and to think, I used to write this code by hand and now it's this agent doing all of it. I think actually being the one that does this work, it's incredibly exciting to have an agent write the code. It feels very empowering as an engineer because I can explore a lot more ideas than I could before.

作为这个对话的最后一个主题，我们不得不讨论一个显而易见的问题：这对编程以及编程作为一种职业意味着什么。您对未来的编程有什么总体看法呢？是的，这有点难说。您知道，未来在AI的时间尺度上相当于普通时间的几十年。我认为，即便是今天，许多专业程序员也很容易对编程现状感到惋惜，他们会想：我曾经是手动写这些代码的，现在都是由一个智能程序来完成。但实际上，作为从业者，能够让一个程序来写代码是非常令人兴奋的。作为一名工程师，这种感觉非常赋权，因为我可以探索比以前更多的想法。

I can do it much faster. I can work in domains that I know literally nothing about. Maybe I don't know iOS, but I can write an app because I can just generally code review the code and I can see it looks reasonable, but Quad actually does all the writing and all the testing of it. There's one engineer on the team, Lena, she still writes C++ on the weekend sometimes by hand. She was telling me because, you know, like as a programmer, this is kind of one of the things that we enjoy. Sometimes you have to get down to the metal and you have to kind of do it this way.

我可以做得更快。我可以在我完全不了解的领域工作。也许我不懂iOS开发，但我可以编写一个应用程序，因为我能大致进行代码审查，判断代码是否看起来合理，不过实际上所有的编写和测试都是由Quad完成的。我们团队里有一位工程师，叫Lena，她有时在周末还手工写C++。她告诉我，因为作为程序员，这是一种我们喜欢的事情。有时候你需要接触基础，亲自动手来完成某些工作。

But I see this as a transition, the same way that in the 60s, there was this transition between punch cards and assembly and then later on between assembly and fortrane and co-ballin, the first type of languages. And I think this is just another next transition. It's hard to know exactly how this is going to play out. I think one way it will definitely play out is it's going to change programming where programming is no longer direct text manipulation, but it's more working with agents to get the work done.

我把这看作是一种过渡，就像在60年代，经历了从穿孔卡片到汇编语言的过渡，后来又从汇编语言过渡到FORTRAN和COBOL这些最早的编程语言。我认为这只是又一次新的过渡。很难确切地知道最终会如何发展。我认为其中一个明确的发展方向是编程将被改变，不再是直接操作文本，而是通过与智能代理协作来完成工作。

And I think it's going to be hugely empowering where a lot of people that couldn't create before can now create. Even if maybe you don't know anything about apps you can use a lovable or you can use another platform to build cool stuff that you couldn't before. And this is just hugely exciting. But if I'm a young developer today or I want to make coding or building applications, my career, what would you say? What would you tell a younger version of Boris at the beginning of your career for a future in the field? What do I need to learn?

我认为这将极大地赋予人们创造的能力，让那些以前无法创造的人现在能够创造。即使你可能对应用程序一无所知，你也可以使用一个易用的平台或者其他平台来构建以前无法实现的酷炫项目。这真是让人激动不已。但如果我是今天的一名年轻开发者，或者我想以编程或构建应用程序作为我的职业，你会怎么说？如果你能对自己职业生涯初期的年轻版本的鲍里斯说些什么，你会说些什么？我需要学习什么？

I think for people that are learning coding today, it's actually harder than it was when I was learning coding because not only do you have to know coding because you still have to understand the languages, you still have to understand the frameworks, you still have to understand system design and all the stuff. But also you have to use all these tools and you have to do both. You have to hold both in your head at once. So you have to code so that you can check what the model does and you know how to direct it because you have to have, you know, still with the models of today, you have to know what you're doing in order to direct coding agents effectively.

我觉得对于今天学习编程的人来说，学习比我那时候更难。不仅要学会编码，要理解编程语言、框架和系统设计等知识，还得会使用各种工具，需要同时掌握这两方面。你要能够编写代码来检查模型的运作，并且指导它的方向。即使有了今天的模型，你仍然需要知道自己在做什么，以便有效地指导编码代理。

But at the same time, you have to be using all this new technology, you have to be using quad code and you have to be using all these new agent coding tools because this is what the future is. And I think it's hugely important to understand what these are and what it lets you do and to learn how to function both when writing code manually and when using these tools.

但同时，你必须使用所有这些新技术，你必须使用四元代码，并且使用所有这些新的代理编码工具，因为这就是未来的发展方向。我认为，非常重要的是要了解这些技术是什么，它们能让你做什么，以及学会如何在手动编写代码和使用这些工具时都能有效运作。

All right, there's been a fantastic conversation. Maybe to close, give us a sense for what the next few weeks or months or years looks like for Cloud Code, anything on the roadmap, anything you're excited about, anything you can talk about.

好的，刚才的对话非常精彩。也许在结束前，能不能给我们介绍一下Cloud Code在接下来的几周、几个月或几年里会有哪些发展？是否有一些计划中的项目或者让你感到兴奋的事情可以分享一下呢？

Yeah, there's a lot of stuff we're working on. We ended native Windows support recently and we're working on single file distribution so you don't need a Node.js anymore. You can just use quad code and it's a single binary that you can use anywhere. So much more portable.

是的，我们正在处理很多事情。我们最近停止了对原生Windows的支持，现在正在开发单文件分发功能，这样你就不再需要Node.js了。你可以直接使用quad代码，它是一个单一的可执行文件，可以在任何地方使用，更加便携。

We're working on getting quad code into more places. So wherever you are, you can use quad code more easily, the same way that you can on GitHub today and expect a lot more agents. So, you know, be able to launch agents, agents, managing agents and a lot more kind of freedom, freedom this way and continuing to level up the state of the earth and figure out what's next.

我们正在努力将四重代码推广到更多地方。这样无论你身处何地，都可以像今天在 GitHub 上一样更加轻松地使用四重代码，并且期待出现更多的代理功能。你可以启动代理、管理代理，从而获得更多这种方式带来的自由，不断提升地球的状态，并探索接下来的发展方向。

But I would say overall, we don't really know. Still, we're testing stuff out and we have a lot of ideas and we don't know what's going to work, but we're excited to show what we come up with and see if people like it.

但总的来说，我会说我们还不太确定。目前我们还在测试各种想法，但不知道哪些会有效。不过，我们很期待展示我们的成果，并看看大家是否喜欢。

That feels like a wonderful place to live the conversation and very fitting as we all try to figure out where not only where we take AI but where AI takes us collectively. So it's been wonderful. Thank you so much, Boris. We appreciate you're spending some time with us today.

这段话表达的意思是：“这似乎是一个很好的时机来结束这次对话，同时这也非常契合大家在努力思考的不仅是我们将如何引领人工智能的发展，还有人工智能将如何引领我们的方向。所以，这次交流很愉快。非常感谢你，Boris。我们感谢你今天能抽出时间与我们交流。”

Yeah, thank you, Matt.

是的，谢谢你，马特。

Anthropic&#39;s Surprise Hit: How Claude Code Became an AI Coding Powerhouse

摘要

中英文字稿

Anthropic's Surprise Hit: How Claude Code Became an AI Coding Powerhouse