the-changelog-673
**Adam Stacoviak:** \[00:00\] Well, friends, I'm here with a long time friend, first time sponsor of this podcast, Damien Tanner.
**Adam Stacoviak：** \[00:00\] 好吧，朋友们，我和一位老朋友一起来到这里，他是这个播客的第一次赞助商，Damien Tanner。
Damien, this has been a journey, man.
达米安，这是一段旅程，伙计。
Like, this is the 18th year of producing The Changelog.
比如说，今年是制作变更日志的第 18 年了。
As you know, when Wynn Netherland and I started this show back in 2009, I corrected myself recently.
如你所知，当我和 Wynn Netherland 在 2009 年开始这个节目时，我最近纠正了自己。
I thought it was November 19th.
我以为是11月19号呢
It was actually November 9th was the very first, the birthday of The Changelog.
事实上，11 月 9 日是 The Changelog 的第一个生日。
November 9th, 2009.
2009 年 11 月 9 日。
And back then you ran Pusher, Pusher.app.
那时你运行了 Pusher，Pusher.app。
And that's kind of when sponsoring a podcast was kind of like almost charity.
当赞助播客有点像慈善事业时。
Like, you didn't get a ton of value because there wasn't a huge audience, but you wanted to support the makers of the podcast.
就像，你没有获得太多价值，因为没有大量观众，但你想支持播客的制作者。
And, you know, we were learning, and obviously open source is moving fast and we were trying to keep up, and GitHub was one year old.
而且，你知道，我们正在学习，显然开源正在快速发展，我们正在努力跟上，而 GitHub 已经一岁了。
I mean, like, this is a different world.
我的意思是，这是一个不同的世界。
But I want to start off by saying, you were our first sponsor of this podcast.
但我首先想说的是，你是我们这个播客的第一个赞助商。
I appreciate that, man.
我很欣赏这一点，伙计。
Welcome to the show.
欢迎来到节目。
**Damien Tanner:** So kind of you.
**达米安·坦纳：** 你真好。
I, you know, reflecting on Pusher, we kind of just ended up creating a lot of great community, especially around London and also around the world with Pusher.
我，你知道，反思 Pusher，我们最终创建了很多很棒的社区，特别是在伦敦以及世界各地与 Pusher 一起。
And I really love everything we did.
我真的很喜欢我们所做的一切。
And we started an event series.
我们开始了一系列活动。
And in fact, another kind of like coming back around, Alex MacCaw, who works at Mastra, he's coming to speak at the AI Engineer London meetup branch that I run.
事实上，在 Mastra 工作的 Alex MacCaw 又回来了，他将在我运营的人工智能工程师伦敦聚会分支机构上发表演讲。
And he started and ran the Pusher Sessions, which became a really well known talk series in London.
他发起并主持了 Pusher Sessions，这成为伦敦非常知名的谈话系列。
**Adam Stacoviak:** Okay.
**亚当·斯塔科维亚克：** 好的。
Were you at the most recent AI conference?
您参加了最近的人工智能会议吗？
I was in SF.
我当时在旧金山。
**Adam Stacoviak:** What was that like?
**亚当·斯塔科维亚克：** 那是什么样的？
I can always kind of jump in the shark a little bit because I kind of want to talk.
我总是可以稍微跳进鲨鱼里，因为我有点想说话。
I want to juxtapose like Pusher then timeframe developer to like now, which is drastically different.
我想将当时的 Pusher 开发人员与现在的时间框架开发人员并置，这是截然不同的。
So don't, let's not go too far there, but how was AI in SF recently?
所以，我们不要扯得太远，但是人工智能最近在旧金山的表现如何？
**Damien Tanner:** It was a good experience, always a good injection of energy going to SF.
**达米安·坦纳：** 这是一次很好的经历，总是为旧金山注入良好的能量。
I live just outside London.
我住在伦敦郊外。
But, you know what, the venue was quite big and it didn't have that like, together feel as much as some competitors.
但是，你知道吗，场地相当大，而且不像一些竞争对手那样有那种感觉。
But it was the first time though I sat and, you know, huge conference hall.
但这是我第一次坐在巨大的会议厅里。
And I think it was like Windsurf or something's chatting and I was like, this is, this is really like, we're all miners at a conference about mining automation.
我认为这就像 Windsurf 或其他东西在聊天，我当时想，这真的是，我们都是矿工，正在参加一个有关采矿自动化的会议。
And we're like, we're engineers.
我们就像，我们是工程师。
So we're super excited about it, but, right, it's kind of weird.
所以我们对此非常兴奋，但是，这有点奇怪。
Like, it's going to change all of our jobs.
就像，它将改变我们所有的工作。
All right.
好的。
It's like, I'm working right now to change everything I'm doing tomorrow, right?
就像，我现在正在努力改变明天所做的一切，对吧？
I mean, that's kind of how I viewed it.
我的意思是，我就是这么看的。
**Adam Stacoviak:** I was watching a lot of the playback.
**Adam Stacoviak：** 我看了很多回放。
I wasn't there personally, this time around, but I would want to make it the next time around.
这次我本人没有出席，但下次我想参加。
But, you know, just the Swyx, the content coming out of there, everybody's speaking, I know a lot of great people are there.
但是，你知道，只是 Swyx，那里发布的内容，每个人都在说话，我知道那里有很多伟大的人。
Obviously pushing the boundaries of what's next for us, the frontier, so to speak.
显然，我们正在突破我们下一步的界限，可以说是前沿。
But a lot of the content, I mean, almost all the content was like, top, top notch.
但很多内容，我的意思是，几乎所有内容都是顶级的。
And I feel like I was just watching the tip of humanity, right?
我觉得我只是看到了人性的一角，对吧？
Like just experiencing what's to come because in tech, you know this as being a veteran in tech, we shape, we're shaping the future of humanity.
就像只是体验即将发生的事情一样，因为在科技领域，你知道作为科技领域的资深人士，我们塑造、我们正在塑造人类的未来。
In a lot of cases, technology drives that.
在很多情况下，技术推动了这一点。
Technology is a major driver of everything.
技术是一切的主要驱动力。
And here we are at the precipice of the next, the next, next thing.
现在我们正处于下一个、下一个、下一个事情的悬崖边。
And it's just wild to see what people are doing with it, how it's changing everything we know.
看到人们用它做什么，它如何改变我们所知道的一切，真是太疯狂了。
Everything.
一切。
I feel like it's like a flip.
我感觉就像是翻车一样。
It's a complete, not even a one eighty, like a 720, you know what I mean?
这是一个完整的，甚至不是一个 80，就像 720，你知道我的意思吗？
Like it's three spins or four spins, it's not just one spin around to change things.
就像三旋转或四旋转一样，它不仅仅是一旋转就能改变事情。
I feel like it's a dramatic forever.
我觉得这永远是一个戏剧性的事情。
Don't even know how it's going to change things, changing things thing.
甚至不知道它将如何改变事情，改变事情。
**Damien Tanner:** \[04:05\] I mean, you know, bringing it back to the Pusher days, it's the vibe we had then.
**Damien Tanner：** \[04:05\] 我的意思是，你知道，把它带回到 Pusher 时代，这就是我们当时的氛围。
You know, there was this period around just before Pusher and the first half of Pusher, I felt like where we were going through this.
你知道，就在《Pusher》之前和《Pusher》的前半部分，有一段时期，我感觉我们正在经历这一切。
Maybe it's called like the Web 2.0, but there was a lot of great software being built.
也许它被称为 Web 2.0，但有很多优秀的软件正在构建中。
And a lot of, you know, the community.
还有很多，你知道，社区。
And I think the craft that went into, especially like the Rails community.
我认为进入的工艺，尤其是 Rails 社区。
And we were just able to build incredible web-based software.
我们刚刚能够构建令人难以置信的基于网络的软件。
And then, you know, we've gone through like the commercialization, industrialization of SaaS.
然后，你知道，我们经历了 SaaS 的商业化、工业化。
And what gets me really excited is now when we're, you know, we run this AI Engineer London branch.
让我真正兴奋的是，现在我们运营着人工智能工程师伦敦分公司。
And incredible communities come together.
令人难以置信的社区聚集在一起。
And it's got that energy again.
它又重新获得了能量。
And I guess the energy is very exciting.
我想这种能量是非常令人兴奋的。
There's new stuff.
有新东西了。
Everyone can play a part in it.
每个人都可以参与其中。
And we're also just all completely working it out.
我们也正在全力解决这个问题。
And it's like, you've got the, you know, folks on the main stage of the conference.
就像，你知道，人们站在会议的主舞台上。
And then you've got, we'll chat about it later, maybe like, Geoffrey Huntley, posting his meme, blog post.
然后，我们稍后会讨论这个问题，也许像杰弗里·亨特利（Geoffrey Huntley）发布他的模因、博客文章。
It's like that the crazy ideas and innovation is kind of coming from anywhere, which is brilliant.
就好像疯狂的想法和创新来自任何地方，这真是太棒了。
**Adam Stacoviak:** Yeah, there's some satire happened too.
**Adam Stacoviak：** 是的，也发生了一些讽刺。
I think there was a talk that was quite comedic.
我认为有一个谈话非常喜剧。
I can't remember who the talk was from, but I was really just enjoying just the fun nature of what's happening and having fun with it, not just being completely serious all the time with it.
我不记得谈话是谁说的，但我真的只是享受正在发生的事情的有趣本质并从中获得乐趣，而不仅仅是一直完全严肃地对待它。
For those who are uninitiated, and I kind of am to some degree, because this has been a long time, remind me and our listeners what exactly was Pusher.
对于那些不熟悉的人来说，我在某种程度上是这样，因为这已经很长时间了，提醒我和我们的听众到底什么是 Pusher。
And I suppose the tail end of that, how are things different today than they were then?
我想最终的结果是，今天的情况与当时有何不同？
**Damien Tanner:** Pusher was basically a WebSockets push API.
**Damien Tanner：** Pusher 基本上是一个 WebSockets 推送 API。
So you could push anything to your web app in real time.
因此您可以将任何内容实时推送到您的网络应用程序。
So just things like notifications into your application.
所以就像您的应用程序中的通知之类的事情一样。
We ended up having a bunch of customers, maybe in finance or crypto or any kind of area where you need to live updating pricing.
我们最终拥有了一群客户，可能是金融或加密货币或任何需要实时更新定价的领域。
In the early days at one point, Uber was using Pusher to update the cars in real time before they built their own infrastructure.
在早期，Uber 在建立自己的基础设施之前曾使用 Pusher 来实时更新汽车。
And it was funny.
这很有趣。
I remember the standout because we ran a consultancy where we were chatting about the WebSockets in browsers and we're like, oh, this is cool.
我记得其中的突出之处是因为我们经营了一家咨询公司，我们在其中讨论浏览器中的 WebSocket，我们说，哦，这太酷了。
How can we use this?
我们如何使用这个？
And the problem is, you know, we were all building Rails apps.
问题是，你知道，我们都在构建 Rails 应用程序。
So like, okay, we need like a separate thing, which manages all the WebSocket connections to the client.
所以，好吧，我们需要一个单独的东西来管理与客户端的所有 WebSocket 连接。
And then we can just post an API request and say, push this message to all the clients.
然后我们可以发布一个 API 请求并说将此消息推送给所有客户端。
It was a simple idea and we took it seriously and built it into pretty formidable dev tool used by millions of developers.
这是一个简单的想法，我们认真对待它，并将其构建成数百万开发人员使用的相当强大的开发工具。
And still used a lot today.
今天仍然使用很多。
And we eventually exited the company to MessageBird who are kind of European Twilio competitor.
我们最终将公司交给了 MessageBird，后者是欧洲 Twilio 的竞争对手。
Actually, at one point, we nearly sold the company to Twilio.
事实上，我们一度差点把公司卖给 Twilio。
That would have been a very different timeline.
那将是一个非常不同的时间表。
**Adam Stacoviak:** According to my notes, you raised $9.2 million, which is a lot of money back then.
**Adam Stacoviak：** 根据我的笔记，你筹集了 920 万美元，这在当时是一笔很大的钱。
I mean, it's a lot of money now, but like, that was tremendous.
我的意思是，现在这是很多钱，但那是巨大的。
That was probably 2010, right?
那大概是2010年吧？
2011?
2011年？
**Damien Tanner:** The bulk of that we raised later on from Balderton.
**达米安·坦纳：** 我们后来从鲍德顿筹集了大部分资金。
Okay.
好的。
The first round was maybe half a million.
第一轮可能是五十万。
Very, very small.
非常非常小。
And it started out the agency.
它开始了该机构。
So we built the first version in the agency.
所以我们在代理机构中构建了第一个版本。
Just for fun, I suppose.
我想只是为了好玩。
**Adam Stacoviak:** And maybe some tears on your part.
**亚当·斯塔科维亚克：** 也许你也会流泪。
Juxtapose the timeline, right?
把时间线放在一起吧？
You got an acquisition ultimately, but you mentioned Twilio as an opportunity.
您最终获得了收购，但您提到 Twilio 是一个机会。
How would have that been different, if you can like branch the timeline?
如果你可以对时间线进行分支的话，会有什么不同？
**Damien Tanner:** \[08:09\] It would have been a great experience to work with the team.
**Damien Tanner：** \[08:09\] 与团队合作将是一次很棒的经历。
There's incredible people who watched Twilio and move through Twilio.
有很多令人难以置信的人观看了 Twilio 并在 Twilio 中移动。
I don't know.
我不知道。
I haven't calculated it, but we didn't sell, because the offer wasn't good enough in our minds.
我没有计算过，但我们没有卖，因为我们认为这个报价不够好。
It was a bit of a local, and it was stock.
这有点本地化，而且是库存。
In hindsight, the stock hasn't gone very well.
事后看来，该股的表现并不好。
Turns out it was a good financial decision, but would have loved that experience.
事实证明，这是一个很好的财务决定，但我会喜欢这种经历。
I think Twilio became the kind of OG of DevRel, right?
我认为 Twilio 成为了 DevRel 的那种 OG，对吗？
And dev community.
和开发社区。
And we've run, you know, how we got to know them is we did a lot of combined events with them and hackathons with them.
我们跑步，你知道，我们是如何认识他们的，是我们和他们一起参加了很多联合活动和黑客马拉松。
That was a fun time.
那是一段有趣的时光。
**Adam Stacoviak:** Yeah, they were like the origination.
** Adam Stacoviak：** 是的，他们就像起源。
Jeff Lawson was, you know, very much quintessential in that process of a whole new way to market to developers.
你知道，杰夫·劳森（Jeff Lawson）是向开发商推销全新方式的过程中的典型代表。
And I think that might have been the beginning of what we call DevRel today.
我认为这可能就是我们今天所说的 DevRel 的开始。
Would you agree with that?
你同意吗？
I mean, it's like, if there was a seed, that was one of many, probably, but I think one of the earliest seeds to plant of what DevRel is today.
我的意思是，如果有一颗种子，那可能是众多种子中的一颗，但我认为这是今天 DevRel 最早播下的种子之一。
**Adam Stacoviak:** So how do you think about those times of Pusher and the web and building APIs and building SaaS services, et cetera, and, you know, pushing messages to Rails apps.
**Adam Stacoviak：** 那么，您如何看待 Pusher 和网络、构建 API 和构建 SaaS 服务等时代，以及将消息推送到 Rails 应用程序的时代。
How are today's days different for you?
今天的日子对你来说有何不同？
**Damien Tanner:** It's exciting, because the web and software is just completely changing again.
**Damien Tanner：** 这很令人兴奋，因为网络和软件再次彻底改变。
Like, I feel like we had that with Web 2.0, right?
就像，我觉得 Web 2.0 已经做到了这一点，对吗？
That was the birth of software on the internet, hosted software on the internet.
这就是互联网软件、互联网托管软件的诞生。
And it's such an embedded thing in our culture, in our business, as developers, a lot of us work on that kind of software.
它是我们的文化、我们的业务中的一个根深蒂固的东西，作为开发人员，我们很多人都在开发这种软件。
But most businesses run on SaaS software now.
但现在大多数企业都运行 SaaS 软件。
And I have to remind myself, like, there was a time before SaaS.
我必须提醒自己，在 SaaS 出现之前曾经有一段时间。
And therefore, there can be a time after SaaS, and there can be a thing that comes after SaaS.
因此，SaaS 之后可能会有一段时间，SaaS 之后可能会有一个东西。
And it's not a given that SaaS sticks around.
而且 SaaS 并不是理所当然的。
I mean, like any technology, we tend to kind of go in layers, right?
我的意思是，就像任何技术一样，我们倾向于分层，对吧？
We still have a bunch of copper phone lines around the place, and we use them for other things, and we're slowly replacing them.
我们周围仍然有一堆铜质电话线，我们将它们用于其他用途，并且我们正在慢慢更换它们。
Like, these changes, you know, in the aggregate take a lot of time.
你知道，这些变化总的来说需要花费很多时间。
But I guess, you know, the thing that can shift more quickly is the direction things are going.
但我想，你知道，能够更快改变的是事情的发展方向。
And really in the last few months, I think I've been more and more convinced by my own experiences and things I've seen playing with stuff, that it's entirely possible, and probably pretty likely that there is a post SaaS.
事实上，在过去的几个月里，我想我越来越相信自己的经历和我所看到的玩东西的东西，这是完全可能的，而且很可能会有一个后 SaaS。
And I think I don't know if everyone realizes, but like the, or everyone is with that intention, but like all of us playing with agents and LLMs, whether it's to build the software or to do things, we are doing that.
我想我不知道是否每个人都意识到，但就像，或者每个人都有这个意图，但就像我们所有与代理人和法学硕士一起玩的人一样，无论是构建软件还是做事情，我们都在这样做。
You know, when we're probably doing that instead of building a SaaS, we're using it to build a SaaS, right?
您知道，当我们可能这样做而不是构建 SaaS 时，我们是用它来构建 SaaS，对吗？
It's already playing out amongst the developers.
它已经在开发人员中发挥作用了。
**Adam Stacoviak:** Yeah, it's an interesting thought experiment to think about the time before SaaS and the potential, as you may say, the potential time after SaaS.
**Adam Stacoviak：** 是的，这是一个有趣的思想实验，思考 SaaS 之前的时间以及 SaaS 之后的潜在时间，正如你可能会说的那样。
I'm curious because I hold that opinion to some degree.
我很好奇，因为我在某种程度上持有这种观点。
I think there's, you know, what SaaS stays and what SaaS goes if it dies.
我认为，你知道，SaaS 会留下什么，如果 SaaS 消亡，它也会消失。
And you said in the pre-call, burst the bubble a little bit here, you did say, and I quote, all SaaS is dead.
你在电话会议前说过，在这里稍微戳破泡沫，你确实说过，我引用一下，所有 SaaS 都死了。
Can you explain your homework?
你能解释一下你的作业吗？
All SaaS is dead.
所有 SaaS 都已死。
**Damien Tanner:** I think I should probably go through my journey to here, to kind of illustrate it, because...
**达米安·坦纳：** 我想我可能应该经历一下我到这里的旅程，以说明这一点，因为......
**Adam Stacoviak:** Give us the TLDR first, though.
**Adam Stacoviak：** 不过，请先给我们 TLDR。
Give us the, the clip, and then go into the journey.
给我们剪辑，然后开始旅程。
**Damien Tanner:** Okay, okay.
**达米安·坦纳：** 好吧，好吧。
The TLDR is SaaS.
TLDR 是 SaaS。
So there's a few layers as like the building of software or parts to software.
因此，有几个层次，例如软件或软件部件的构建。
There's a building of software.
有一座软件大楼。
And then there's the operating of software to get something done.
然后是操作软件来完成某件事。
And I think most developers are very familiar with like the building of software as changing now.
我认为大多数开发人员都非常熟悉软件构建现在的变化。
But the operating software, the operating of work, the doing of work in all industries and all knowledge work, can change like we've changed software.
但是操作软件、工作操作、所有行业的工作以及所有知识工作都可以像我们改变软件一样改变。
And SaaS is made for humans, slow humans to use.
SaaS 是为人类而设计的，人类使用起来很慢。
The SaaS UI is made for a puny human to go in, you know, understand, you know, work at this complex thing and it has to be in a nice UI.
SaaS UI 是为一个弱小的人设计的，你知道，理解，你知道，处理这个复杂的事情，它必须有一个漂亮的 UI。
If it's not a human actually doing the work that they do in the SaaS, if it's an AI doing that work, why is there a, why is there a SaaS tool?
如果不是人类在 SaaS 中实际完成他们所做的工作，如果是人工智能在做这项工作，为什么会有 SaaS 工具？
The AI doesn't need a SaaS tool to get the work done.
AI 不需要 SaaS 工具来完成工作。
It might need a little UI for you to tell you what it's done.
它可能需要一些用户界面来告诉您它做了什么。
But the whole idea of humans using software, I think, is going to change.
但我认为，人类使用软件的整个想法将会改变。
It can.
可以。
**Adam Stacoviak:** Yeah.
**亚当·斯塔科维亚克：** 是的。
Well, you've been steeped in, and I still want to hear your journey, but I'm going to step in one second.
好吧，你已经沉浸其中了，我仍然想听听你的旅程，但我马上就要介入了。
You've been steeped in APIs and SaaS for a while.
您已经沉迷于 API 和 SaaS 一段时间了。
So I hold that opinion that you have that I agree that the, if the SaaS exists for a UI for humans, that's definitely changing.
因此，我持有您的观点，我也同意，如果 SaaS 是为人类用户界面而存在，那么这肯定会发生变化。
So I agree with that.
所以我同意这一点。
Where I'm not sure of, and I'm still questioning myself is like, what is the true solution here?
我不确定，并且仍在质疑自己，真正的解决方案是什么？
There are SaaS services that can simply be an API.
有些 SaaS 服务可以只是 API。
You know this, you built them.
你知道这一点，你建造了它们。
I don't really need the web UI.
我真的不需要网络用户界面。
Actually, I kind of just prefer the CLI, I kind of prefer just JSON from my agents.
事实上，我只是更喜欢 CLI，我更喜欢来自代理的 JSON。
I kind of prefer Markdown for me because I'm the human.
我更喜欢 Markdown，因为我是人。
I want those good prose.
我想要那些好的散文。
I want all of it local.
我想要所有这些都是本地的。
So my agents can, you know, mine it and create sentiment analysis and, you know, all this fun stuff you could do with DuckDB and Parquet and just super, super fast stuff across embeddings and, you know, vector, you know, PG vector, all those fun things you could do in your own data.
所以我的代理可以，你知道，挖掘它并创建情感分析，你知道，你可以使用 DuckDB 和 Parquet 做所有这些有趣的事情，以及跨嵌入的超级、超级快速的东西，你知道，矢量，你知道，PG 向量，所有这些你可以在自己的数据中做的有趣的事情。
But that's where I stop is I do agree that the web UI will go where some version of it.
但这就是我停下来的地方，我确实同意 Web UI 将去往它的某些版本。
Maybe it's just there's like a dashboard for those who don't want to play in the dev world with CLIs and APIs and MCP and whatnot.
也许它只是为那些不想在开发世界中使用 CLI、API 和 MCP 之类的人提供的仪表板。
But I feel like SaaS shifts.
但我觉得 SaaS 正在发生转变。
Like my take is CLI is the new app.
就像我的看法一样，CLI 是新应用程序。
That's my take is that SaaS will shift.
我的看法是 SaaS 将会发生转变。
But I think it will shift into CLI for a human to instruct an agent and an agent to do.
但我认为它将转变为 CLI，供人类指示代理和代理执行操作。
And it's largely based on API, JSON, you know, clear defined endpoints, great specifications, things that get more and more mature as a result of that.
它主要基于 API、JSON，你知道，明确定义的端点、出色的规范，以及因此而变得越来越成熟的东西。
**Damien Tanner:** Yeah, I guess we should probably kind of tease apart SaaS the business and SaaS the software.
**Damien Tanner：** 是的，我想我们应该将 SaaS 业务和 SaaS 软件区分开来。
Okay.
好的。
Because yeah, I agree that the interface is changing.
因为是的，我同意界面正在改变。
The interface that we use, whether it's visually CLI or a chat conversation or something.
我们使用的界面，无论是可视化 CLI 还是聊天对话等等。
But the way we communicate with the software is changing, right?
但我们与软件通信的方式正在改变，对吧？
It's a much more natural language thing.
这是一种更自然的语言。
We don't have to dig in the UI to find the thing to click.
我们不必深入用户界面来找到要点击的内容。
But also so much of the software we use that we call SaaS that we access remotely.
而且我们使用的许多软件（我们称之为 SaaS）也是可以远程访问的。
If you can just magic that SaaS locally or within your company, right?
如果您可以在本地或公司内部使用 SaaS，对吧？
There's no need to access that SaaS anymore, right?
不再需要访问该 SaaS，对吧？
You just have that functionality.
您只需拥有该功能即可。
You just ask for that functionality and it's being built.
您只需要求该功能，它就会被构建。
But yeah, SaaS, the business, I guess this is the challenge for companies today is they're going to have to, if they want to stay in business, they're going to have to shift somehow.
但是，是的，SaaS，这个业务，我想这是当今公司面临的挑战，如果他们想继续经营下去，他们将不得不以某种方式进行转变。
Because yeah, I mean, there's still got to be some harness, harness is the wrong word because you use that in coding agents, but like some infrastructure, some cloud, some coordination, authentication, data storage, there's still a lot to do.
因为是的，我的意思是，仍然需要一些工具，“工具”这个词是错误的，因为你在编码代理中使用它，但就像一些基础设施、一些云、一些协调、身份验证、数据存储一样，还有很多工作要做。
And I think there's going to be some great opportunities for companies to do that.
我认为公司将会有一些很好的机会来做到这一点。
And maybe a CRM, a Salesforce or something, manages to say, hey, we are, people like Salesforce trying to do that.
也许 CRM、Salesforce 之类的东西会设法说，嘿，我们，像 Salesforce 这样的人正在尝试这样做。
We are the place to run your sales agents, right?
我们是您经营销售代理的地方，对吧？
You're magically instantiated CRM code that you want just for your business.
您神奇地实例化了您想要的适合您业务的 CRM 代码。
Maybe there'll be some winners there.
也许那里会有一些赢家。
But the idea that I think the thing that's going to change SaaS's business, SaaS Software is the idea that like everyone has to go and buy the same version, you know, of some software which they remotely accessing can't really change.
但我认为 SaaS 软件将改变 SaaS 业务的想法是，就像每个人都必须去购买相同版本的软件一样，他们远程访问的某些软件无法真正改变。
**Adam Stacoviak:** Okay, I'm feeling that for sure.
**Adam Stacoviak：** 好吧，我确实有这样的感觉。
Take us back into the journey then because I feel like I cut you off and I don't want to disappoint you, but not let you go and give the context, the key word for most people these days, the context for that blanket statement that SaaS is dead or dying.
让我们回到这段旅程，因为我觉得我切断了你的联系，我不想让你失望，但不想让你走，并给出上下文，这是当今大多数人的关键词，是 SaaS 已死或垂死的笼统声明的上下文。
**Damien Tanner:** Yeah, okay, I'll give you a bit of the story.
**达米安·坦纳：** 是的，好吧，我给你讲一下这个故事。
So my company Layercode, I'll just give you a little short on that.
我的公司 Layercode，我会简单介绍一下。
We provide a voice agents platform.
我们提供语音代理平台。
So anyone can add voice to their agent.
因此任何人都可以为他们的代理添加声音。
It's developer tool, developer API platform for that.
它是开发者工具、开发者 API 平台。
And we're now ramping up our sales and marketing.
我们现在正在加强销售和营销。
And we kind of started doing it the normal ways.
我们开始以正常的方式做这件事。
We kind of got a CRM.
我们有一个 CRM。
We got some marketing tools.
我们有一些营销工具。
And I was just finding, we went through a CRM too.
我刚刚发现，我们也使用了 CRM。
And I was just finding them like, these are like the new CRMs that are supposed to be good.
我只是发现它们就像新的 CRM，应该很好。
They were just really, really slow.
他们真的非常非常慢。
And then I just couldn't work out how to do stuff.
然后我就是不知道该怎么做。
It was like, I had to go and set up a workflow.
就像，我必须去建立一个工作流程。
And it was like, I needed training to use this CRM tool.
就像，我需要培训才能使用这个 CRM 工具。
And I'd been having a lot of fun with Claude Code and Codex, kind of both flipping between them, kind of getting a feel for them.
我从 Claude Code 和 Codex 中获得了很多乐趣，在它们之间切换，对它们有了一定的感觉。
And so I just said, build me a, I just voice dictated, you know, a brain dump for like 10, 15 minutes.
所以我只是说，给我做一个，我只是用声音口述，你知道，一个大约 10、15 分钟的大脑转储。
Here's the CRM I need.
这是我需要的 CRM。
And also it wasn't just like a boring CRM, it was like, I need a CRM, I need you to make a CRM that kind of engages me as a developer who doesn't wake up and go, let's do sales, you know, gamify it for me.
而且它不仅仅是一个无聊的 CRM，它就像，我需要一个 CRM，我需要你制作一个 CRM，让我作为一个开发人员参与进来，让我做销售，你知道，为我游戏化它。
And then here are the ways I want you to do that.
以下是我希望你做到这一点的方法。
And it just did it.
它就这么做了。
That was my kind of like coding agents moment.
那是我的编码代理时刻。
And I think you have that moment when you do a new project.
我认为当你做一个新项目时你会有这样的时刻。
You use an LLM and a completely greenfield project.
您使用法学硕士和一个完全未开发的项目。
And there's no kind of existing code it's going to kind of mess up or get wrong and the project's not too big.
而且现有的代码不会出现混乱或错误，而且项目也不是太大。
It just built the whole freaking CRM.
它刚刚构建了整个该死的 CRM。
And it was really good.
这真的很好。
It was a good CRM and it worked really well.
这是一个很好的 CRM，而且效果非常好。
And so that was like my kind of like level one awakening, which was like this idea that you can just have the SaaS you want instantly.
这就像我的一级觉醒，就像这样的想法：你可以立即拥有你想要的 SaaS。
It suddenly felt true.
突然感觉很真实。
It felt, because I had done it.
感觉，因为我已经做到了。
And I have canceled the old CRM system now.
我现在已经取消了旧的CRM系统。
And there's a bunch of other tools I plan to cancel.
我还计划取消许多其他工具。
You know, because they're all crap, but because it's harder to use them than it is to just say what I want.
你知道，因为它们都是垃圾，但因为使用它们比仅仅说出我想要的东西更难。
Because I kind of have to learn how to use those tools.
因为我必须学习如何使用这些工具。
Whereas I can just say, make me the thing, make me the website I want instead of using a website builder tool or make me the CRM that I want to use.
而我只能说，让我成为我想要的东西，让我成为我想要的网站，而不是使用网站构建工具或让我成为我想要使用的 CRM。
And then there's this like different cycle that you have, the loop that you have of improvement, where it's not a once, it's not build and then use the software.
然后有一个不同的循环，你有改进的循环，它不是一次，它不是构建然后使用软件。
It's like as you're using the software, you can improve the software at any time.
就像你在使用软件的过程中，你可以随时改进软件一样。
And we've still got to work out how this works.
我们仍然需要弄清楚它是如何运作的。
Like who has the power to change the software?
比如谁有权更改软件？
And how do you share that amongst a team, right?
你如何在团队中分享这一点，对吗？
And do I have a branch of the software that I, or do I have different, like my own views or something in the CRM that I can mess around with?
我是否有软件的一个分支，或者我有不同的想法，比如我自己的观点，或者 CRM 中我可以乱搞的东西？
But just as a within our team of three doing this stuff in the company, it was like, oh, you're annoyed with this part of the software.
但是，就像我们三人团队中的一个人在公司里做这些事情一样，就像，哦，你对软件的这一部分感到恼火。
Just change it.
只要改变它。
Just change it.
只要改变它。
**Adam Stacoviak:** Yeah.
**亚当·斯塔科维亚克：** 是的。
When it annoys you, it's the exact point of time and then continue with the work.
当它让你烦恼时，就到了正确的时间点，然后继续工作。
Right.
正确的。
And I assume you're probably still doing like a GitHub or some sort of like primary GitHub, not literally like GitHub, but git repository as a hub for your work, right?
我假设您可能仍在使用 GitHub 或某种类似主 GitHub 的方式，而不是字面上的 GitHub，而是将 git 存储库作为您工作的中心，对吧？
And you probably have pull requests or merge requests.
您可能有拉取请求或合并请求。
So even if your teammate is frustrated, improves the software, pushes it back, you're still using the same software and you're still using the same traditional developer tooling, which is pull requests, code review, merging.
因此，即使您的队友感到沮丧，改进了软件，将其推迟，您仍然使用相同的软件，并且仍然使用相同的传统开发人员工具，即拉取请求、代码审查、合并。
**Adam Stacoviak:** Okay.
**亚当·斯塔科维亚克：** 好的。
Take me there.
带我去那里。
I woke up this morning with that feeling.
今天早上我带着这种感觉醒来。
**Damien Tanner:** With the CRM and with something we've been building this week, there were new pieces of software.
**Damien Tanner：** 随着 CRM 以及我们本周一直在构建的东西，出现了新的软件。
There weren't existing code bases.
没有现有的代码库。
I didn't have any prior ideas and taste and requirements about what the code should look like.
对于代码应该是什么样子，我没有任何事先的想法、品味和要求。
I think this is the thing that slows people down with coding agents.
我认为这就是让编码代理减慢速度的原因。
You use it on existing repo and LLMs have bad taste.
你在现有的仓库上使用它，而法学硕士的品味很差。
They just give you kind of the most common denominator, kind of bad taste version of anything, whether it's like writing a blog post or coding, right?
他们只是给你一种最常见的分母，一种任何东西的低级品味版本，无论是写博客文章还是编码，对吧？
And so when you use it on an existing project and then you review the code, you just find all these things wrong with it, right?
因此，当您在现有项目上使用它并检查代码时，您会发现所有这些问题都存在，对吧？
It's like, you know, right now they love doing all this like really defensive try-catch in JavaScript or really verbose stuff or right now a utility function that exists in a library already.
就像，你知道，现在他们喜欢做所有这些事情，比如 JavaScript 中真正的防御性 try-catch 或非常冗长的东西，或者现在库中已经存在的实用函数。
But when you start on a new project and you just use YOLO mode and you're just, you know, you're building something for yourself as well, right?
但是当你开始一个新项目并且只使用 YOLO 模式时，你知道，你也在为自己构建一些东西，对吗？
And it works.
它有效。
Like, where's the code?
比如，代码在哪里？
Why review the code?
为什么要审查代码？
I think we're only in this temporary, weird thing where we're like trying to jam, like we have these existing software processes that ensure we deliver high quality software, secure software, good software.
我认为我们只是处于这种暂时的、奇怪的状态，我们就像试图堵塞一样，就像我们拥有这些现有的软件流程来确保我们提供高质量的软件、安全的软件、好的软件一样。
I think it's hard, we can't throw it, we've got SOC 2, we can't throw those out the window for everything that exists today.
我认为这很难，我们不能扔掉它，我们已经有了 SOC 2，我们不能把今天存在的一切都扔到窗外。
But for everything new that you're building, you've got an opportunity to kind of pull apart, question and collapse down all of these kind of processes we built for ourselves, processes that were built to ensure humans don't make mistakes, right?
但对于你正在构建的所有新事物，你有机会拆解、质疑和瓦解我们为自己构建的所有这些流程，这些流程是为了确保人类不会犯错误而构建的，对吗？
And help humans collaborate and help humans manage change in the repository and everything.
并帮助人类协作并帮助人类管理存储库和所有内容中的更改。
It's like if the humans aren't writing the code anymore, we need to question these things.
就像如果人类不再编写代码，我们就需要质疑这些事情。
**Adam Stacoviak:** Are you moving into the land of agent first then?
**Adam Stacoviak：** 那你是先进入特工之地吗？
It sounds like that's what you're going.
听起来这就是你要做的。
**Damien Tanner:** I feel like I'm being pulled into it by, yeah, I'm slight, I'm kind of like, there is a tide.
**达米安·坦纳：** 我觉得我被卷入其中，是的，我很瘦，我有点像，有一股浪潮。
I can't resist.
我无法抗拒。
I'm falling in the hole.
我掉进坑里了
And we're kind of like, we're dipping our toes in, right?
我们有点像，我们正在尝试，对吧？
Trying to try out Cursor and Tab.
尝试尝试光标和选项卡。
And then we're kind of in there and we're swimming, trying to swim the way we normally swim the way we want to go.
然后我们就在那里游泳，尝试以我们通常的方式游泳，以我们想要的方式游泳。
And suddenly I've just gone, just like relax and just let the tide, let the river take you.
突然我就走了，就像放松一样，让潮水，让河流带走你。
Just let it go, man.
放手吧，伙计。
Just let it go.
放手吧。
**Damien Tanner:** It feels kind of terrifying and there are going to, and I don't have the answers to how we do code review.
**Damien Tanner：** 这感觉有点可怕，而且将会发生，而且我不知道如何进行代码审查。
But you know, if you look at like a lot of, you know, teams talking about using AI coding agents and the resisting project, everyone's big problem now is code reviews, right?
但你知道，如果你看到很多团队在谈论使用人工智能编码代理和抵制项目，那么现在每个人的大问题都是代码审查，对吧？
Because everyone using coding agents is producing so many PRs, it's like it's piling up in this review process that has to be done.
因为每个使用编码代理的人都会产生如此多的 PR，所以就像在必须完成的审查过程中堆积起来一样。
The new teams that don't have that process in place, they are going multiple times faster right now.
没有这个流程的新团队现在的速度要快几倍。
**Adam Stacoviak:** Okay.
**亚当·斯塔科维亚克：** 好的。
What is replacing code review if there's no code review?
如果没有代码审查，那么什么取代代码审查？
Is it just nothing?
难道只是什么都没有吗？
**Damien Tanner:** To these teams that you're explaining about, like us as developers, we need to think more like, we need to put ourselves in the shoes of PMs, designers, managers.
**Damien Tanner：** 对于您所解释的这些团队，例如我们作为开发人员，我们需要更多地思考，我们需要将自己置于 PM、设计师、经理的立场上。
Because they don't, they don't look at the code, right?
因为他们不这样做，所以他们不看代码，对吗？
They say we need this functionality.
他们说我们需要这个功能。
We build it.
我们建造它。
We do our code reviews.
我们进行代码审查。
We ensure it works.
我们确保它有效。
And the PM, whoever, goes, oh yeah, great.
首相，无论是谁，都会说，哦，是的，太棒了。
I've used it and it's a requirement.
我已经使用过它并且这是一个要求。
It's great, right?
太棒了，对吧？
They're comfortable not looking at the code.
他们很乐意不看代码。
They're a long way from the code.
他们离代码还很远。
They're closing the deal.
他们正在完成交易。
They're with the customer.
他们和顾客在一起。
They're integrating.
他们正在整合。
They're like, I am confident that the intelligent being that created this code did a good job.
他们就像，我相信创建这段代码的智能生物做得很好。
Now, I think the only reason we're kind of stuck in this old process is because many of them are set in stone.
现在，我认为我们陷入这个旧流程的唯一原因是因为其中许多都是一成不变的。
But also because LLMs aren't quite smart enough yet.
但也因为法学硕士还不够聪明。
They still make stupid mistakes.
他们仍然犯愚蠢的错误。
Right.
正确的。
You still need a human in the loop and on the loop.
你仍然需要一个人在循环中。
**Adam Stacoviak:** Yeah, I mean, they're still a bit dumb and they get done with silly things and they do.
** Adam Stacoviak：** 是的，我的意思是，他们仍然有点愚蠢，他们做了愚蠢的事情，而且他们确实这样做了。
Oh, look, they're going the wrong direction for a while.
哦，看，他们有一段时间走错了方向。
And I'm like, no, hang on a second.
我想，不，等一下。
That's a great thought here.
这是一个很棒的想法。
But let's get back on track.
但让我们回到正轨。
This is the problem we're solving.
这就是我们要解决的问题。
And you've sidequested us.
而你却回避了我们。
It's a fun sidequest, that was the point, but that's not the point.
这是一个有趣的支线任务，这就是重点，但这不是重点。
**Damien Tanner:** But this is going to change.
**达米安·坦纳：** 但这将会改变。
Right.
正确的。
And this is one of the hard things is trying to put ourselves in the mindset of what it's going to be like in a year.
其中一件困难的事情就是让我们自己思考一年后会发生什么。
And I think I've only been, you know, after us being able to play with LLMs for several years, it feels like I can feel the velocity of it now.
我想我只是，你知道，在我们能够与法学硕士一起工作几年之后，我现在才感觉到它的速度。
Right.
正确的。
Because I've felt GPT-3, 4, 5, Claude, Codex.
因为我感受过GPT-3、4、5、Claude、Codex。
And now I can go, oh, okay, that's what it feels like for it to get better.
现在我可以走了，哦，好吧，这就是事情变得更好的感觉。
And it's going to keep getting better for a few more years.
而且未来几年它还会继续变得更好。
So it's kind of like self-driving cars, right?
所以这有点像自动驾驶汽车，对吧？
They're like not very useful while they're worse than humans.
他们虽然比人类更糟糕，但并没有多大用处。
But suddenly when they're safer than a human, like, why would you have a human?
但突然间，当它们比人类更安全时，你就会想，为什么要人类呢？
**Damien Tanner:** And I think it's the same with coding.
**Damien Tanner：** 我认为编码也是如此。
Like all this process is to stop humans making mistakes.
所有这些过程都是为了阻止人类犯错误。
We make mistakes.
我们会犯错误。
Like our mistakes are not special, better mistakes.
就像我们的错误并不特别，更好的错误。
They're still like, we stuff up code.
他们仍然认为，我们塞满了代码。
We cause security incidents.
我们造成安全事故。
And so I think as soon as the LLMs are twice as good, five times as good, 10 times better at outputting good code that doesn't cause these issues.
所以我认为，一旦法学硕士在输出不会导致这些问题的良好代码方面好两倍、五倍、十倍。
We're going to start to let go of this concern, like these things, right?
我们将开始放下这种担忧，比如这些事情，对吗？
We're going to start to trust them more.
我们将开始更加信任他们。
**Adam Stacoviak:** Something I leaned on recently, and it was really with Opus 4.5.
**Adam Stacoviak：** 我最近依赖的东西，确实是 Opus 4.5。
I feel like that's when things sort of changed because I'm with you on the trend from GPT-3 on to now and feeling the incremental change.
我觉得事情就在那时发生了变化，因为我和你们一起经历了从 GPT-3 到现在的趋势，并感受到了渐进的变化。
I feel like Opus 4.5 really changed things.
我觉得 Opus 4.5 确实改变了一切。
And I think I heard it in an AI talk or at least in the intention of it, if it wasn't verbatim, was trust the model.
我想我在一次人工智能演讲中听到了这句话，或者至少是在它的意图中（如果不是逐字逐句的话）是信任模型。
Just trust the model.
只要相信模型就可以了。
As a matter of fact, I think it was one of the guys, man, they were building an agent.
事实上，我认为是其中一个人，他们正在建立一个特工。
And in the process was maybe as an agent layer, layer agent, something like that.
在这个过程中可能是作为一个代理层，层代理，类似的东西。
Maybe borrowed something from your name, Layercode.
也许借用了你的名字，Layercode。
I have to look it up.
我得查一下。
I'll get the talk.
我来谈谈。
I'll put in the show notes.
我会把演出笔记写进去。
But I think it was that talk.
但我认为就是那次谈话。
And I was like, okay, the next time I play, I'm going to trust the model.
我当时想，好吧，下次我玩的时候，我会相信这个模型。
And I will sometimes like stop it from doing something because I think I'm trying to direct it in a certain direction.
有时我会喜欢阻止它做某事，因为我认为我正在尝试将其引导到某个方向。
And now I've been like, wait a second.
现在我就想，等一下。
And like, this code's free basically.
就像，这个代码基本上是免费的。
It's just going to generate anyways.
无论如何它都会生成。
Let's see what it does.
让我们看看它有什么作用。
Worst case, I'm like, you know, roll back or worst case is like just generate better.
最坏的情况，我想，你知道，回滚或者最坏的情况就像只是生成更好的。
I mean, like ultra think.
我的意思是，就像超思考一样。
Right.
正确的。
You know, what's the worst that could happen because it's going faster than I can.
你知道，最糟糕的情况是什么，因为事情进展得比我快。
Anyways, let's see.
无论如何，让我们看看。
Even if it's a mistake, let's see the mistake.
即使这是一个错误，让我们看看错误。
Let's learn from the mistake because that's how we learn even as humans.
让我们从错误中吸取教训，因为这就是我们作为人类学习的方式。
I'm sure LLMs the same.
我确信 LLM 也一样。
And so I've come back to this philosophy or this thought, almost to the way you describe it, like falling into this hole, slipping in via gravity.
所以我又回到了这个哲学或这个想法，几乎就像你描述的那样，就像掉进这个洞里，通过重力滑进去。
Not excited at first, but then kind of like excited because like, well, it's good in there.
一开始并不兴奋，但后来有点兴奋，因为，嗯，那里很好。
Let's just go.
我们走吧。
Just trust the model, man.
只要相信这个模型，伙计。
Just
只是
**Damien Tanner:** \[30:03\] Trust the model.
**达米安·坦纳：** \[30:03\] 相信模型。
And it can surprise you.
它会让你感到惊讶。
And I think that still gives me that dopamine hit that I would have coding, right?
我认为这仍然会给我带来多巴胺刺激，我会编码，对吗？
When I was coding manually, you'd get a function right and you'd be like, "Ah, it works." And now it's like, you've got the whole application and you're like, "Ah, I just did a problem for the whole thing works." That's right.
当我手动编码时，你会得到一个正确的函数，然后你会说，“啊，它有效。”现在就像，你已经有了整个应用程序，你会说，“啊，我刚刚做了一个问题，整个应用程序都有效。”这是正确的。
Yeah, it's really exciting.
是的，这真的很令人兴奋。
And yeah, it's fun right now.
是的，现在很有趣。
I mean, it's going to keep changing.
我的意思是，它会不断变化。
This is just a bit of a temporary phase here and now.
现在这只是一个暂时的阶段。
But I think for many of us building software, we love the craft of it, which you can still do.
但我认为对于我们许多构建软件的人来说，我们喜欢它的工艺，而你仍然可以做到。
But also the making a thing is also one of the exciting bits of it.
但制作一件东西也是其中令人兴奋的部分之一。
And the world is full of software still.
世界仍然充满了软件。
Like, you think about so many interactions you have with like government service or whatever.
就像，你会想到你与政府服务等的许多互动。
Not saying that they're going to adopt coding agents, particularly, but there is a lot of bad software in the web.
并不是说他们会特别采用编码代理，但网络上有很多糟糕的软件。
And software has been expensive to build.
而且软件的构建成本高昂。
And that's because it's been in high demand.
那是因为它的需求量很大。
And so I don't think we're going to run out of stuff to build.
所以我认为我们不会用完要建造的东西。
I think even if we get 10 times faster, 100 times faster, there's so much useful software and products and things and jobs to be done.
我认为即使我们的速度快了 10 倍、100 倍，仍然有很多有用的软件、产品、事情和工作要做。
**Adam Stacoviak:** Close this loop for me then.
**Adam Stacoviak：** 那么就为我关闭这个循环。
You said SaaS is dead or dying.
你说 SaaS 已经死了或者正在消亡。
I'm paraphrasing because you didn't say "or dying." I'm just going to say we're dying.
我解释一下是因为你没有说“或死亡”。我只想说我们快要死了。
I'll parenthesis.
我会加括号。
That's my parenthesis.
这是我的括号。
I'll add it to your thing.
我会把它添加到你的东西中。
How is it going to change then?
到时候会发生怎样的变化呢？
So if we're making software, there's still tons of software to write, but SaaS is dead.
因此，如果我们正在开发软件，仍然有大量软件需要编写，但 SaaS 已经死了。
What exactly are we making then?
那我们到底在做什么呢？
If it's not SaaS.
如果不是SaaS。
I know that not all software is SaaS, but you do build something, a platform, and people buy the platform.
我知道并非所有软件都是 SaaS，但你确实构建了一些东西，一个平台，人们购买这个平台。
Is that SaaS?
那是SaaS吗？
What changes?
有什么变化？
You mentioned interfaces like, where do you say that?
你提到了接口，你在哪里说的？
**Damien Tanner:** I think we're moving.
**达米安·坦纳：** 我想我们要搬家了。
And so this is the next level.
这是下一个层次。
The next kind of revelation I had was I started using the CRM.
我的下一个启示是我开始使用 CRM。
I was like, this is cool.
我当时想，这太酷了。
This is super fast.
这速度超级快。
This is better than the other CRM.
这比其他 CRM 更好。
And I can change it.
我可以改变它。
Cool.
凉爽的。
I'm doing some important sales work.
我正在做一些重要的销售工作。
I'm enriching leads.
我正在丰富线索。
And then I kind of woke up a few days later.
几天后我就醒了。
I was like, why am I doing the work?
我当时想，我为什么要做这份工作？
What's going on here?
这是怎么回事？
I create an interface for me to use, right?
我创建一个界面供我使用，对吗？
Why can't Claude Code just do the work that I need to do for me?
为什么 Claude Code 不能帮我做我需要做的工作？
I know it's not going to be with the same taste that I have.
我知道它的味道不会和我一样。
And I know it's going to make mistakes.
我知道它会犯错误。
But I can have 10 of them do it at the same time.
但我可以让 10 个人同时做。
And it's not a particularly fun idea, fully automated sales.
完全自动化的销售并不是一个特别有趣的想法。
And what that means for the world in general, but it's the particular vertical where I had this kind of revelation, right?
这对整个世界意味着什么，但这是我获得这种启示的特定垂直领域，对吧？
Well, the enriching certainly makes sense for the LLM to do, right?
嗯，丰富内容对于法学硕士来说当然是有意义的，对吧？
The enriching is like, come on, that's under the API, I'm copying things.
丰富就像，来吧，那是在 API 下，我正在复制东西。
And a lot of it is so manual still.
而且很多工作仍然是手动的。
And so the revelation was just waking up and then going, okay, Claude Code's going to do the work for me today.
所以这个启示就是我一觉醒来，然后就说，好吧，克劳德·科德今天会为我做这项工作。
Like it does for software.
就像软件一样。
It builds the software for me.
它为我构建了软件。
I'm going to give it a Chrome browser connection.
我将为其提供 Chrome 浏览器连接。
That's still a non-solved problem.
这仍然是一个未解决的问题。
There's a lot of pain in LLM chatting to the browser.
LLM 与浏览器聊天有很多痛苦。
But there's a few good ones.
但也有一些好的。
And I'm going to let it use my LinkedIn.
我将让它使用我的 LinkedIn。
I'm going to let it use my X.
我要让它使用我的X。
And I'm going to connect it to the APIs that I need that aren't pieces of software, but like data sources, right?
我将把它连接到我需要的 API，这些 API 不是软件，而是像数据源，对吧？
I can get enriched and search things.
我可以丰富并搜索东西。
And then I just started getting it to just do it.
然后我就开始让它去做。
And it was really quite, it was slow.
而且真的很安静，很慢。
But it was really quite good.
但确实非常好。
And that was a kind of, that was like that moment where we typed in, build this feature in Claude Code, build this.
这就像我们输入的那一刻，在克劳德代码中构建这个功能，构建这个。
But it was suddenly like this thing can just do anything a human can do on a computer.
但突然之间，这个东西似乎可以做人类在计算机上可以做的任何事情。
The only thing holding it back right now is the access to tools and good integrations with the interfaces, like the old software it still needs to use to do what a human does.
现在唯一阻碍它的是工具的访问以及与界面的良好集成，就像它仍然需要使用旧软件来完成人类所做的事情一样。
And a bigger context window and it'd be great if it was faster.
还有一个更大的上下文窗口，如果速度更快的话那就太好了。
But I can run them in parallel so that the speed's not a massive problem.
但我可以并行运行它们，这样速度就不是一个大问题了。
And in the space of a week, I built the CRM.
在一周的时间里，我构建了 CRM。
And then I got Claude Code to just do the work, but I didn't tell it to use the CRM.
然后我让 Claude Code 来做这项工作，但我没有告诉它使用 CRM。
I just told it to use the database.
我只是告诉它使用数据库。
And I just ended up throwing away the CRM.
我最终扔掉了 CRM。
And now we have this little Claude Code harness that overrides the Claude Code system prompt, sets up all the tools and gives it a Postgres database.
现在我们有了这个小小的 Claude Code 工具，它可以覆盖 Claude Code 系统提示，设置所有工具并为其提供 Postgres 数据库。
And I've just got like, I need to vibe code a new CRM UI.
我只是想，我需要编写一个新的 CRM UI。
But I've just got like a database viewer that the non-technical team used to kind of look at the leads and stuff like that.
但我就像一个数据库查看器，非技术团队用来查看线索之类的东西。
It's just a kind of Beekeeper kind of database viewer.
它只是一种 Beekeeper 类型的数据库查看器。
And now Claude Code is just doing the work.
现在克劳德·科德正在做这项工作。
We've only applied it there, but this is just like Claude Code is like this kind of little innovation in an agent that can do work for a long time.
我们只在那里应用了它，但这就像Claude Code一样，是一个可以长时间工作的代理的小创新。
And we already know people use ChatGPT for all sorts of different things beyond coding, right?
我们已经知道人们将 ChatGPT 用于编码以外的各种不同的事情，对吧？
And so suddenly I think these coding agents are a glimpse of all knowledge work can be sped up or replaced.
突然间，我认为这些编码代理是所有知识工作都可以加速或取代的一瞥。
**Adam Stacoviak:** Yeah, these non-technical folks, why not just invite them to the terminal and give them CLI outputs that they can easily run and just up arrow to repeat or just teach them certain things that maybe they weren't really comfortable with doing before.
**Adam Stacoviak：** 是的，这些非技术人员，为什么不邀请他们到终端并为他们提供可以轻松运行的 CLI 输出，然后向上箭头重复或只是教他们某些他们以前可能不太习惯做的事情。
And now they're also one step from being a developer or a builder because they're already in the terminal.
现在，他们距离成为开发商或建筑商也仅一步之遥，因为他们已经进入了终端。
And that's where Claude's at.
这就是克劳德所在的地方。
**Damien Tanner:** Yeah, I mean, that's what we've done now.
**达米安·坦纳：** 是的，我的意思是，这就是我们现在所做的。
I've seen some unexpected kind of teething issues with that.
我已经看到了一些意想不到的初期问题。
I think there's just a terminal feels a bit scary to non-technical people.
我认为只有一个终端对于非技术人员来说有点可怕。
Even if you explain how to use it, like when they quit Claude Code or something, they're just kind of like lost.
即使你解释了如何使用它，比如当他们退出克劳德代码之类的时候，他们也有点迷失了。
They're like, "Oh my gosh, where did Claude Code go?"
他们就像，“天哪，克劳德·科德去哪儿了？”
**Adam Stacoviak:** Yeah.
**亚当·斯塔科维亚克：** 是的。
And I was onboarding whatever team, it was like open the terminal.
我加入任何团队，就像打开终端一样。
And then I'm like, okay, we've got a CD.
然后我就想，好吧，我们有一张 CD。
What if the terminal was just Claude Code?
如果终端只是克劳德代码怎么办？
What if you built your own terminal that was just—
如果你建立了自己的终端，那会怎么样——
**Damien Tanner:** I think when I actually think about specific UI, whether it's terminal or web UI, it's kind of not the handle there, but there is the magic is a thing that can access everything on your computer, right.
**Damien Tanner：** 我认为，当我真正考虑特定的 UI 时，无论是终端还是 Web UI，它都不是手柄，但有一个神奇的东西可以访问计算机上的所有内容，对吧。
And they're doing that with, I think it's called Co-Work.
他们正在这样做，我认为这就是所谓的“协同工作”。
Have you seen Co-Work yet?
你看过《共同工作》吗？
**Adam Stacoviak:** So it's like, I haven't played with it enough to know what it can and can't do.
**Adam Stacoviak：**所以，就像，我还没有足够地使用它，不知道它能做什么和不能做什么。
I think I unleashed it on a directory with some PDFs that I had collected that was around business structure.
我想我在一个目录中发布了它，其中包含我收集的一些有关业务结构的 PDF。
And it was like an idea I had like four months ago with just a different business structure that would just make more sense primarily around tax purposes, you know.
这就像我四个月前就有的一个想法，只是采用不同的业务结构，主要围绕税收目的更有意义，你知道。
And I was like, hey, revisit this idea I haven't touched it in forever.
我当时想，嘿，重新审视这个我永远没有碰过的想法。
And it was a directory.
这是一个目录。
And I think it went and it just did a bunch of stuff.
我认为它确实做了很多事情。
But then it was like, come on with ideas.
但后来就好像，来吧，提出想法。
I'm like, nah, there's not good ideas.
我想，不，没有什么好主意。
I don't know like if it's like less smart than Claude Code is in intent or whatever, but it's kind of, I think that's what you're trying to do with Co-Work.
我不知道它是否比 Claude Code 的意图更不聪明，但我认为这就是你想要通过 Co-Work 做的事情。
But you know, you could just drop them into essentially a directory, which is what Claude Code lives.
但你知道，你可以将它们放到一个目录中，这就是 Claude Code 所在的目录。
And it lives in a directory of maybe files that is an application or knows how to talk to the database as you said your CRM does.
它位于一个可能是应用程序文件的目录中，或者知道如何与数据库对话，就像您所说的 CRM 那样。
And they can just be in the Claude Code instance, just asking questions.
他们可以只是在克劳德代码实例中，只是提出问题。
Show me the latest leads.
显示最新的线索。
**Damien Tanner:** Yeah.
**达米安·坦纳：** 是的。
That could use a skill if you want to go that route or it can just be smart enough to be like, well, I have a Neon database here.
如果你想走这条路，这可能会用到一项技能，或者它可以足够聪明，就像，好吧，我这里有一个 Neon 数据库。
The Neon CTL CLI is installed.
Neon CTL CLI 已安装。
I'm just going to query it directly.
我直接去查询就可以了。
You have to be able to write some Python to make it faster.
您必须能够编写一些 Python 才能使其更快。
Maybe I'll store some of this stuff locally and it'll do it all behind the scenes.
也许我会在本地存储一些东西，它会在幕后完成这一切。
But then it gives this non-technical person a list of leads.
但随后它给了这个非技术人员一份线索列表。
All I had to do was be like, give me the leads, man.
我所要做的就是，给我线索，伙计。
You know.
你知道。
And then you mentioned enabling them as builders.
然后你提到让他们成为建设者。
I think it then is a window into that because then when they want something, oh, they get curious, right?
我认为这是一个了解这一点的窗口，因为当他们想要某样东西时，哦，他们会感到好奇，对吗？
They'll be like us.
他们会像我们一样。
They're just going to be like, hey, build me a report for this.
他们只会说，嘿，为此给我写一份报告。
Build me a web app for this.
为此我构建一个网络应用程序。
Help me make this easier.
帮我让这件事变得更容易。
**Adam Stacoviak:** Yeah.
**亚当·斯塔科维亚克：** 是的。
You'd be surprised how easy that is, like, help me make it easier is one of those weird ones.
你会惊讶地发现这是多么容易，比如，帮助我让它变得更容易就是那些奇怪的事情之一。
And Claude Code will also auto complete and just let you tab and enter.
Claude Code 也会自动完成，只需按 Tab 键并输入即可。
And I've noticed that those things got more terse.
我注意到这些事情变得更加简洁。
Like, maybe I think if the last one I did was like, that's interesting.
就像，也许我想如果我最后一次做的事情就像这样，那很有趣。
It was like super short.
就像超短的一样。
It was like, "I like it, implement it." What was the completion for them?
就像，“我喜欢它，实施它。”他们的完成是什么？
**Damien Tanner:** "I like it, implement it." I was like, okay, is that how easy it's gotten now to like just spit out a feature that we were just riffing on that you know the problem.
**达米安·坦纳：**“我喜欢它，实施它。”我当时想，好吧，现在是多么容易就喜欢吐出一个我们刚刚重复的功能，你知道问题所在。
You understand the bug we just got over.
你了解我们刚刚解决的错误。
And now your response to me to tell you what to say because you need me the human to get you back in the loop.
现在你对我的回应是告诉你该说什么，因为你需要我这个人来让你回到循环中。
At least in today's REPL is "I like it, implement it." You know what I mean?
至少在今天的 REPL 中是“我喜欢它，实现它”。你知道我的意思？
**Adam Stacoviak:** I found myself just responding with the letter Y.
**Adam Stacoviak：** 我发现自己只是用字母 Y 来回应。
I know a lot of the time it just knows what to do, right?
我知道很多时候它只是知道该怎么做，对吗？
Even if it kind of like is a bit ambiguous, you're kind of like you'll work it out.
即使有点模棱两可，你也会解决这个问题。
**Damien Tanner:** So I think it's very exciting that Anthropic released this Co-Work thing because they've obviously seen that inside Anthropic.
**Damien Tanner：** 所以我认为 Anthropic 发布这个 Co-Work 的东西非常令人兴奋，因为他们显然已经在 Anthropic 内部看到了这一点。
All sorts of people using Claude Code.
各种各样的人都在使用克劳德代码。
And you know, when we think about, okay, someone starts there for non-coding purposes, but stuff is done with code and CLI tools and some MCPs or whatever, APIs.
你知道，当我们想到，好吧，有人从非编码目的开始，但事情是通过代码和 CLI 工具以及一些 MCP 或其他 API 完成的。
And then the user says, well, make me a UI to make this easier.
然后用户说，好吧，给我一个 UI，让这件事变得更容易。
So for instance, I had to review a bunch of draft messages that I wrote.
例如，我必须审查我写的一堆草稿消息。
I was like, okay, this is kind of janky in the terminal.
我当时想，好吧，这在终端里有点卡顿。
Make me a UI to do the review.
给我做一个用户界面来进行审查。
It just did it.
它只是做到了。
And I think this is where software is changing because when the LLM is 10 times faster, I mean, if you use the Groq with a Qwen 10 points, right, they're insanely fast.
我认为这就是软件正在发生变化的地方，因为当 LLM 速度提高 10 倍时，我的意思是，如果您使用带有 Qwen 10 分的 Groq，对吧，它们速度快得惊人。
It's going to be fast.
会很快。
Then if you can have any interface you want within a second, why have static interfaces, right?
那么如果你可以在一秒钟内拥有任何你想要的接口，为什么还要静态接口，对吧？
**Adam Stacoviak:** Yeah, I'm camping out there with you.
**Adam Stacoviak：** 是的，我和你一起露营。
What if everything was just in time?
如果一切都及时的话会怎样？
I think that interface.
我认为是那个界面。
What if I didn't need to share it with you?
如果我不需要与你分享怎么办？
Because you're my teammate, but what if you could do the same thing for you and it solves your problem?
因为你是我的队友，但如果你能为你做同样的事情并且解决你的问题呢？
And you're in your own branch and what you do in your branch, it's like Vegas and it stays there.
你在自己的分行里，你在分行里所做的事情，就像维加斯一样，而且会留在那里。
It doesn't have to be saved anywhere else, right?
它不必保存在其他地方，对吗？
Like just leave it in Vegas, right?
就像把它留在维加斯一样，对吧？
What if in your own branch, in your own little world, as a sales development representative, for example, an SDR who's trying to help the team, help the organization grow and all they need is an interface.
如果在您自己的分支机构中，在您自己的小世界中，作为销售开发代表，例如试图帮助团队、帮助组织成长的 SDR，而他们所需要的只是一个界面，该怎么办？
What if it was just in time for them only?
如果这对他们来说正好是时候呢？
And it didn't matter if it was maintainable.
是否可维护并不重要。
It didn't matter how good the code was.
代码有多好并不重要。
All it mattered was that it solved their problem, get the opportunity and enable them to do what they got to do either to do the job.
重要的是它解决了他们的问题，获得了机会，并使他们能够做他们必须做的事情来完成工作。
And you just take that and multiply or copy and paste it on all the roles that make sense for that just in time.
您只需将其复制或复制并粘贴到所有对此有意义的角色上即可。
What?
什么？
It completely changes the idea of what software.
它彻底改变了软件的想法。
It also completely changes how we interact with the computer and what a computer does and what it is for.
它还彻底改变了我们与计算机交互的方式以及计算机的功能和用途。
I just love this notion that every user can change the computer, can change the software as they're using it as they like it.
我只是喜欢这样的想法：每个用户都可以更换计算机，可以根据自己的喜好更改软件。
**Damien Tanner:** I think that's very essentially everyone's a developer.
**Damien Tanner：** 我认为本质上每个人都是开发人员。
Yeah, I mean, it's the ultimate way to use a computer like all the gates are down, right?
是的，我的意思是，这是使用计算机的终极方式，就像所有的门都关闭了一样，对吧？
There's no geeky prerequisite anymore.
不再有令人讨厌的先决条件了。
If I want software the way I want software so long as I have authentication and authorization, I got the keys to my kingdom I want to make.
如果我想要软件就像我想要软件一样，只要我有身份验证和授权，我就得到了我想要创建的王国的钥匙。
And I think also the agents can preempt, right?
我认为特工也可以抢占先机，对吗？
I haven't tried this yet, but I was thinking of giving it the little sales thing.
我还没有尝试过这个，但我正在考虑给它一些小销售的东西。
We have a little prompt where it says, like, either if a web UI is going to be better for the user to do this, review this, then just do it.
我们有一个小提示，比如，如果 Web UI 更适合用户执行此操作，请查看此操作，然后执行此操作。
So then instead of you asking it, you ask it to do some work and then it comes back and be like, oh, I've made you this UI where I've like displayed it all for you.
因此，你不再要求它，而是要求它做一些工作，然后它回来说，哦，我已经为你制作了这个 UI，我想在其中为你显示所有内容。
Have a look at it.
看看吧。
Let me know if you're happy with it.
如果您对此感到满意，请告诉我。
I mean, this is getting kind of wild this idea, but you, it's kind of how we can think about how we communicate with each other as humans, as employees, right?
我的意思是，这个想法有点疯狂，但是你，这就是我们如何思考我们作为人类、作为员工如何相互沟通，对吗？
We have back and forth conversations.
我们有来回的交谈。
We have email, which is a bit more asynchronous.
我们有电子邮件，它有点异步。
You know, we put up a preview URL or something.
你知道，我们提供了一个预览 URL 之类的。
Like I think all those communication channels can be enabled in the agent you're chatting to and like I haven't like this kind of like product companies have sell, you know, the initial messaging where people solve like digital employees, right?
就像我认为所有这些沟通渠道都可以在你正在聊天的代理中启用，就像我不喜欢公司销售的这种产品，你知道，人们像数字员工一样解决问题的初始消息，对吗？
But something like that's going to happen.
但类似的事情将会发生。
And I don't think it's the exciting bit for me is the human computer interaction, right.
我不认为对我来说最令人兴奋的是人机交互，对吧。
It's like and this is how it's kind of exciting in the context of Layercode and why we love voice is like voice is this OG communication method.
这就是在 Layercode 的背景下令人兴奋的原因，也是我们喜欢语音的原因，就像语音就是这种 OG 通信方法一样。
Whereas humans we've been speaking, we started speaking before we were writing.
人类我们一直在说话，但我们在写作之前就开始说话了。
And it's kind of quite a rich communication medium.
它是一种相当丰富的沟通媒介。
And it's a terrific way, like if your agents can be really multi-medium, whether it's you're doing voice with them, text with them, they create a web UI for you, you interact with the UI with them.
这是一种很棒的方式，就像如果您的代理可以真正实现多媒体一样，无论您是与他们进行语音、文本处理，他们都会为您创建一个 Web UI，您可以与他们进行 UI 交互。
Like there doesn't have to be these strict modes or delineations between those things.
就像这些事物之间不一定有这些严格的模式或界限一样。
**Adam Stacoviak:** Well, let's go there.
**Adam Stacoviak：** 好吧，我们去那里吧。
I didn't take us there yet, but I do want to talk to you about what you're doing with Layercode.
我还没有带我们去那里，但我确实想和您谈谈您正在使用 Layercode 做什么。
I obviously produce a podcast.
我显然制作了一个播客。
So I'm kind of interested in speech to text to some degree because transcripts, right.
所以我在某种程度上对语音到文本感兴趣，因为笔录，对吧。
And then you have the obvious version, which is like you start out with speech, you get something or even a voice prompt.
然后你就有了明显的版本，就像你从语音开始，你得到一些东西，甚至是语音提示。
What exactly is Layercode?
Layercode到底是什么？
And I suppose we've been 51 minutes deep on nerding out on AI essentially.
我想我们已经花了 51 分钟深入研究人工智能。
And not at all on your startup and what you're doing, which was sort of the impetus of even getting back in touch.
完全不是关于你的初创公司和你正在做的事情，这甚至是重新联系的动力。
That's all you had something new you were doing.
这就是你所做的所有新事情。
And I'm like, well, I haven't talked to Damien since he's sponsored the show almost 17 years ago.
我想，好吧，自从达米安 17 年前赞助这个节目以来，我就没有和他说过话了。
It's probably a good time to talk, right?
现在可能是一个谈话的好时机，对吧？
So there you go.
所以就这样吧。
That's how it works out.
事情就是这样的。
Has your excitement and your dopamine hits on the daily or even by minute by minute changed how you feel about your ability with Layercode.
您每天甚至每分钟的兴奋和多巴胺分泌是否改变了您对 Layercode 能力的看法。
And what exactly are you trying to do with it?
你到底想用它做什么？
**Damien Tanner:** \[46:29\] Well, there's, and we've talked a lot about the building of a company and the building of software now.
**Damien Tanner：** \[46:29\] 嗯，有，我们现在已经讨论了很多关于公司建设和软件建设的问题。
And I think founders today have that, it is as important as the thing that they're building, right?
我认为今天的创始人拥有这一点，这与他们正在构建的东西一样重要，对吗？
Because if you just head into your company and operate it like you did a few years ago, using no AI, using all your kind of slow development practices, using our slow sales and marketing practices, you're going to really get left behind.
因为如果你只是像几年前一样进入你的公司并运营它，不使用人工智能，使用所有缓慢的开发实践，使用我们缓慢的销售和营销实践，你真的会被抛在后面。
And so there is a lot to be done in working out and exploring what the company of the future looks like.
因此，在制定和探索未来公司的面貌方面还有很多工作要做。
What the software company of the future looks like.
未来的软件公司是什么样子的。
I'm very excited about the idea that we can build large companies with small teams.
我对我们可以用小团队建立大公司的想法感到非常兴奋。
I think a lot of developers, well, I mean, there is a lot of HR and politics and culture change that happens when teams get truly large and companies get truly large.
我认为很多开发人员，嗯，我的意思是，当团队变得真正庞大、公司变得真正庞大时，就会发生很多人力资源、政治和文化变革。
And this is one of the kind of founding principles when we started our startup was let's see how big we can make this.
这是我们开始创业时的基本原则之一，就是让我们看看我们能把它做得多大。
Yeah.
是的。
We're the small team.
我们是小团队。
And that's very exciting because I think you can move fast and you can keep culture and keep a great culture.
这非常令人兴奋，因为我认为你可以快速行动，你可以保持文化并保持伟大的文化。
And so that's why we invest a lot of our energy into the building of the company.
这就是为什么我们投入大量精力来建设公司。
And what we build and what we provide right now is, and our first product is a voice infrastructure, voice API for real-time building real-time voice AI agents.
我们现在构建和提供的是，我们的第一个产品是语音基础设施，用于实时构建实时语音 AI 代理的语音 API。
And this is currently a pretty hard problem.
目前这是一个相当困难的问题。
We focus a lot on the real-time conversational aspect.
我们非常关注实时对话方面。
And there's a lot of kind of weird problems in that, right?
这里面有很多奇怪的问题，对吧？
Conversations are dynamic things.
对话是动态的事情。
And there's a lot of state changes and interruptions and back channeling and everything that happens.
还有很多状态变化、中断、反向引导以及发生的一切。
And if you're a developer building an agent, it could be your sales agent, it could be a developer of a coding agent.
如果您是构建代理的开发人员，那么它可能是您的销售代理，也可能是编码代理的开发人员。
And you want to add voice AI, there's a bunch of stuff you're going to bump into when you start building that.
如果你想添加语音人工智能，当你开始构建它时，你会遇到很多东西。
And it's a pretty, it's interesting, we kind of see our customers, we can kind of predict where they are in that journey, right, because there's a bunch of problems that you don't kind of preempt and then you just quickly slam into them.
这很漂亮，很有趣，我们可以看到我们的客户，我们可以预测他们在旅程中的位置，对吧，因为有很多问题你无法先发制人，然后你很快就会遇到它们。
And so we've solved a lot of those problems.
所以我们已经解决了很多这样的问题。
And so with Layercode you can then just take our API, plug it into your existing agent backend, so you can use any backend you want.
因此，使用 Layercode，您只需使用我们的 API，将其插入您现有的代理后端，这样您就可以使用您想要的任何后端。
And you can use any agent LLM library you want and any LLM you want.
您可以使用任何您想要的代理法学硕士库和任何您想要的法学硕士。
So the basic example is a Next.js application that uses the Vercel AI SDK.
因此，基本示例是使用 Vercel AI SDK 的 Next.js 应用程序。
We've got Python examples as well.
我们还有 Python 示例。
And you connect up to the Layercode voice layer and put in our browser SDK and then you get a little voice agent microphone button and everything in the web app.
然后您连接到 Layercode 语音层并放入我们的浏览器 SDK，然后您会得到一个小语音代理麦克风按钮以及 Web 应用程序中的所有内容。
We also connect to phone over to layer.
我们还通过层连接到手机。
And then for every turn of the conversation, whenever the user's finished speaking, we ship your backend that transcript.
然后，对于每次对话，每当用户结束讲话时，我们都会向您的后端发送该文字记录。
You call the LLM of your choice, you do your tool calls, everything you need to do to generate a response like you normally do for a text agent.
您致电您选择的法学硕士，进行工具调用，以及生成响应所需的一切，就像您通常为文本代理所做的那样。
Then you start streaming the response tokens back to us.
然后您开始将响应令牌流式传输回给我们。
And then as soon as we get that first word, we start converting that text to speech and start streaming back to the user.
然后，一旦我们得到第一个单词，我们就开始将该文本转换为语音并开始流回给用户。
And so there's a bunch of stuff you have to do to make that really low latency, make that a real time conversation where you're not waiting more than a second or two for the agent to respond.
因此，您必须做很多事情才能实现真正的低延迟，使其成为实时对话，您等待代理响应的时间不会超过一两秒。
So we put a lot of work into refining that.
因此，我们投入了大量的工作来完善这一点。
And there's also a lot of exciting innovation happening in the model space for voice models, whether it's transcription or the text to speech.
语音模型的模型空间中也发生了许多令人兴奋的创新，无论是转录还是文本到语音。
And so we give you the freedom to switch between those models, right, so you can try out some of the different voice models, some that are really really cheap and really you know got really casual voices and some like ElevenLabs, they're a much more expensive but they're very professional clean voices and you can find the right fit for your kind of experience that you want, trade off.
因此，我们让您可以自由地在这些模型之间切换，对吧，这样您就可以尝试一些不同的语音模型，其中一些模型非常非常便宜，而且您知道它们确实具有非常随意的声音，而有些像 ElevenLabs，它们的价格要贵得多，但它们是非常专业的干净声音，您可以找到适合您想要的体验的合适模型，进行权衡。
There's a lot of trade-offs, right, in voice between latency, price, quality, so we let users explore that and find the right fit for their voice agent.
在语音方面，延迟、价格、质量之间存在很多权衡，因此我们让用户探索这一点并找到最适合他们的语音代理。
**Adam Stacoviak:** That is interesting.
**亚当·斯塔科维亚克：** 这很有趣。
So Next.js SDK, streaming, latency, is it, you're meant to be the middleware between implementation and feedback to user.
所以 Next.js SDK、流媒体、延迟，就是这样，你应该成为实现和向用户反馈之间的中间件。
**Damien Tanner:** Yeah, we handle everything related to the voice basically and we let you just handle text like a text chatbot basically.
**Damien Tanner：** 是的，我们基本上处理与语音相关的所有内容，我们让您基本上像文本聊天机器人一样处理文本。
**Damien Tanner:** Yeah, and everything's streaming.
**Damien Tanner：** 是的，一切都在流式传输。
And so it's a very interesting problem to solve because the whole system has to be in real time.
所以这是一个非常有趣的问题需要解决，因为整个系统必须是实时的。
So the whole thing, we call it a pipeline.
所以整个事情，我们称之为管道。
I don't know if that's a great name for it because it's not like an ETL loading pipeline, but the real time agent system, our backend, when you start a new session, it runs on Cloudflare Workers.
我不知道这是否是个好名字，因为它不像 ETL 加载管道，而是实时代理系统，我们的后端，当您启动新会话时，它在 Cloudflare Workers 上运行。
So it's running right near the user who clicked to chat with your agent with voice.
因此，它就在点击与您的代理进行语音聊天的用户附近运行。
And then from that point on everything is streaming.
从那时起，一切都开始流动。
So the microphone input from the user's browser streaming in, that is then getting streamed to the transcription model in real time.
因此，来自用户浏览器的麦克风输入会流入，然后实时流入转录模型。
The transcription model is spitting out partial transcripts.
转录模型正在吐出部分转录本。
We send that partial transcript back to you so you can show what you're saying if you want to show them that.
我们会将部分文字记录发送回给您，以便您可以展示您所说的内容（如果您想向他们展示的话）。
And then the hardest bit in this whole thing is working out when the user is finished speaking.
整个事情中最难的一点是当用户说完话时。
It's so difficult because we pause, we make sounds, we pause and then we start again and conversation is such a dynamic kind of, it's like a game almost, right?
这太困难了，因为我们暂停，我们发出声音，我们暂停，然后我们重新开始，对话是一种动态的，几乎就像一场游戏，对吧？
**Damien Tanner:** So we have to do some clever things, use some other AI models to help you detect when the user ends speaking.
**Damien Tanner：** 所以我们必须做一些聪明的事情，使用其他一些人工智能模型来帮助您检测用户何时结束讲话。
And when we have enough confidence, like there's no certainty here, but we have enough confidence, I think the user finished their thought, then we finalize that transcript, you know, finish transcribing that last word and ship you that whole user utterance, like whether it's a word, a sentence, paragraph the user has spoken.
当我们有足够的信心时，就像这里没有确定性一样，但我们有足够的信心，我认为用户完成了他们的想法，然后我们完成了转录，你知道，完成最后一个单词的转录并向您发送整个用户的话语，比如用户所说的是否是一个单词、一个句子、一个段落。
The reason we have to kind of like, we can't stream at that point, right, we have to like bundle up this user utterance and choose an end, is because LLMs don't take a streaming input.
我们之所以必须这样，我们不能在这一点上进行流式传输，对吧，我们必须将这个用户话语捆绑起来并选择结束，是因为 LLM 不接受流式输入。
I mean, you can stream the input but like you need the complete thing, the complete question to send to the LLM to then make a request to the LLM to then generate any response, right?
我的意思是，你可以流式传输输入，但就像你需要完整的东西一样，完整的问题发送给法学硕士，然后向法学硕士发出请求，然后生成任何响应，对吧？
There is no duplex LLM that like takes input and generates output at the same time.
没有双工法学硕士可以同时接受输入并生成输出。
**Adam Stacoviak:** Technically, what if you constantly wrote to a file locally or wherever the system is and then at some point it just ends and you send a call that sends the end versus packaging it up and sending the whole thing once it's done.
**Adam Stacoviak：** 从技术上讲，如果您不断地在本地或系统所在的任何地方写入文件，然后在某个时刻它刚刚结束，您发送一个发送结束的调用，而不是打包它并在完成后发送整个文件，会怎么样？
Like you incrementally, yeah just line by line, it's like maybe even like, I don't know, I'm not sure how to describe but that's how I think about like what if you constantly wrote to something and you just said okay it's done and what was there was the done thing.
逐渐地像你一样，是的，只是一行一行，就像，我不知道，我不知道如何描述，但这就是我的想法，如果你不断地写一些东西，然后你只是说好吧，它完成了，完成的事情是什么。
**Damien Tanner:** Yeah, so we can do that in terms of like, because we have to, partial transcripts, yeah, so we can, you can stream the partial transcripts and then say okay now it's done, now make the LLM call, then you make the LLM call.
**Damien Tanner：**是的，所以我们可以这样做，因为我们必须这样做，部分成绩单，是的，所以我们可以，你可以流式传输部分成绩单，然后说好吧，现在完成了，现在拨打法学硕士电话，然后你拨打法学硕士电话。
But interesting, text, sending text is actually super fast in the context of, very fast.
但有趣的是，文本发送文本实际上是超级快的，非常快。
And actually the default example, this is crazy, I didn't think this was, this would work until we tried it but it just uses a webhook.
实际上默认的例子，这太疯狂了，我不认为这是这样的，在我们尝试之前这会起作用，但它只使用了一个 webhook。
When the user finishes speaking, the basic example sends your Next.js API route a webhook with the user text.
当用户结束讲话时，基本示例会向您的 Next.js API 路由发送一个包含用户文本的 Webhook。
And turns out the webhook sending, sending webhook with a few sentences in it, that's like, that's fine, that's fast.
结果是 webhook 发送，发送 webhook 里面有几句话，就像，很好，很快。
It's all the other stuff, like then waiting for the LLM to respond.
这是所有其他的事情，比如等待法学硕士的回应。
**Adam Stacoviak:** Yeah, that's actually not the hard part.
**Adam Stacoviak：** 是的，这实际上不是困难的部分。
I mean, you have to be a millisecond or somewhat a few milliseconds but it's not going to be a dramatic shift the way I described it versus how you do it.
我的意思是，你必须是一毫秒或几毫秒，但这不会是我描述的方式与你的操作方式之间的巨大转变。
**Damien Tanner:** Yeah, and we've got a WebSocket endpoint now so we can kind of shave off that HTTP connection and everything but yeah, then the big heavy latency items come in.
**Damien Tanner：** 是的，我们现在有了一个 WebSocket 端点，因此我们可以削减 HTTP 连接和所有内容，但是，是的，然后大的延迟项目就会出现。
So generating an LLM response, most LLMs we use right now, they're optimized, the ones we use in coding agents, they're optimized for intelligence, not really speed.
因此，生成LLM响应，我们现在使用的大多数LLM，它们都经过优化，我们在编码代理中使用的LLM，它们针对智能而不是真正的速度进行了优化。
Then when people optimize for speed, the LLM labs, they tend to optimize for just token throughput.
然后，当人们优化速度时，法学硕士实验室，他们倾向于仅针对令牌吞吐量进行优化。
Very few people optimize for time to first token.
很少有人优化第一个令牌的时间。
And that's all that matters in voice is I give you the user utterance, how long is the user going to have to wait before I can start playing back an agent response to them?
语音中最重要的是我向您提供用户话语，用户需要等待多长时间才能开始播放代理对他们的响应？
And time to first token is that, right, how long before I get the first kind of word or two that I can turn into voice and they can start hearing.
第一个令牌的时间是，对，在我得到第一个或两个可以变成声音并且他们可以开始听到的单词之前需要多长时间。
The only major LLM lab that actually optimizes for this or maintains a low latency of TTFT is Google and Gemini Flash.
唯一真正对此进行优化或保持 TTFT 低延迟的主要 LLM 实验室是 Google 和 Gemini Flash。
OpenAI, most voice agents now doing it this way, we're using GPT-4o or Gemini Flash.
OpenAI，现在大多数语音代理都是这样做的，我们使用 GPT-4o 或 Gemini Flash。
GPT-4o has got some annoying, the OpenAI endpoints have some annoying inconsistencies in latency.
GPT-4o 有一些烦人的地方，OpenAI 端点在延迟方面有一些烦人的不一致。
And that's kind of the killer in voice, right, it's a bad user experience if it works you know the first few turns of the conversation are fast and then suddenly the next turn the agent takes three seconds to respond to you.
这就是语音杀手，对吧，如果它有效，你知道对话的前几轮很快，然后突然下一轮代理需要三秒钟才能回复你，那么这是一种糟糕的用户体验。
Like is the agent wrong?
是不是代理错了？
Is the agent broken?
代理坏了吗？
But then once you get that first token back then you're good because then you can, you send that text to us, you start streaming the text to us and then we can start turning into full sentences.
但是，一旦您获得第一个令牌，您就可以了，因为您可以将该文本发送给我们，开始将文本流式传输给我们，然后我们可以开始将其转换为完整的句子。
And then again we get to this batching problem.
然后我们再次遇到这个批处理问题。
The voice models that do text to voice, again they don't stream in the input.
进行文本到语音转换的语音模型，同样它们不会在输入中流动。
They require a full sentence of input before they can start generating any output because again how you speak, how things are pronounced depends on what comes later.
它们需要完整的句子输入才能开始生成任何输出，因为你说话的方式、事物的发音方式取决于后面发生的事情。
And so you have to then buffer the LLM output into sentences, ship the buffered sentence by sentence to the voice model, and then as soon as we get that first chunk of 20 millisecond audio, we chunk it up into, we stream that straight back down WebSockets from the Cloudflare worker straight into the user's browser, we can start playing the agent response.
因此，您必须将 LLM 输出缓冲到句子中，将缓冲的句子逐句发送到语音模型，然后一旦我们获得第一个 20 毫秒音频块，我们就将其分成块，我们将其从 Cloudflare 工作线程直接从 WebSocket 流回用户的浏览器，我们就可以开始播放代理响应。
**Adam Stacoviak:** You chose TypeScript to do all this?
**Adam Stacoviak：** 你选择 TypeScript 来完成这一切？
Understand we're pretty set on Cloudflare Workers from day one, okay.
请理解，我们从第一天起就对 Cloudflare Workers 做好了准备，好吧。
**Damien Tanner:** And it just solves so many infrastructure problems that you're going to run into later on.
**Damien Tanner：** 它只是解决了您稍后会遇到的许多基础设施问题。
I don't think we'll need a DevOps person ever.
我认为我们永远不需要 DevOps 人员。
Yeah, it's such a, it's interesting, it's such a wonderful platform.
是的，这是一个非常、非常有趣、非常好的平台。
There are constraints you have to build to, right, you're using V8 JavaScript, browser JavaScript in a Cloudflare worker.
您必须构建一些限制，对吧，您在 Cloudflare Worker 中使用 V8 JavaScript、浏览器 JavaScript。
Tons of Node APIs don't work.
大量 Node API 不起作用。
There is a bit of a compatibility layer.
有一点兼容层。
You do have to do things a bit differently.
你确实必须采取一些不同的做法。
But what do you get in return?
但你得到什么回报呢？
Your application runs everywhere at 330 locations around the world.
您的应用程序在全球 330 个地点的任何地方运行。
There is essentially zero cold start.
基本上是零冷启动。
Cloudflare workers start up in the time while the SSL negotiations are happening, the worker has already started.
Cloudflare 工作人员在 SSL 协商发生时启动，工作人员已经启动。
And you have very few limitations to your scaling, extremely high concurrency.
而且您的扩展限制很少，并发性极高。
Every instance is very kind of isolated, that's really important voice as well.
每个实例都是非常孤立的，这也是非常重要的声音。
There's often quite big spikes, like 9 a.m.
通常会有相当大的峰值，比如上午 9 点。
everyone's calling up somewhere that's got a voice agent and asking to kind of book an appointment or something.
每个人都会打电话给有语音代理的地方，要求预约或做其他事情。
You get these big spikes.
你会得到这些大尖峰。
You want to be able to scale and you need to scale very quickly because you don't want people waiting around.
您希望能够扩展，并且需要非常快速地扩展，因为您不希望人们等待。
And if you throw, well if you throw tons of users on the same system and you start kind of overloading it then suddenly people get this problem where the agent starts responding in three seconds instead of one second.
如果你抛出，如果你在同一个系统上抛出大量用户并且你开始使其过载，那么人们会突然遇到这个问题，代理在三秒而不是一秒内开始响应。
And it sounds weird but yeah, Cloudflare gives you an incredible amount of that for no effort.
这听起来很奇怪，但是，是的，Cloudflare 可以毫不费力地为您提供令人难以置信的数量。
And I think compared to kind of Lambda and stuff it's also pretty, like the interface, it's just a HTTP interface to your worker.
我认为与 Lambda 之类的东西相比，它也很漂亮，就像接口一样，它只是你的工作人员的 HTTP 接口。
There's nothing in front and you can do WebSockets very nicely.
前面什么都没有，你可以很好地实现 WebSockets。
And there's this crazy thing called Durable Objects which I think is a bad name—
有一种疯狂的东西叫做“耐用物品”，我认为这是一个坏名字——
**Damien Tanner:** \[60:08\] And it's also kind of a weird piece of technology, but it's a little JavaScript runtime that is persistent basically and has a little SQLite database attached to it.
**Damien Tanner：** \[60:08\] 这也是一种奇怪的技术，但它是一个基本持久的小型 JavaScript 运行时，并且附加了一个小型 SQLite 数据库。
And it is — I don't know what the right word is, it's kind of like, it's not the right word for JavaScript, but it's basically think of it like thread safe.
它是——我不知道正确的词是什么，它有点像，这不是 JavaScript 的正确词，但它基本上被认为是线程安全的。
So you can have it take a bunch of WebSocket connections and do a bunch of SQL writes to its SQLite database it has attached, and you don't have to do any kind of special stuff dealing with concurrency and atomic operations.
因此，您可以让它采用一堆 WebSocket 连接，并对它附加的 SQLite 数据库进行大量 SQL 写入，并且您不必执行任何处理并发和原子操作的特殊操作。
So you know, the simple example is just implement a rate limiter or a counter or something like that.
所以你知道，简单的例子就是实现一个速率限制器或计数器或类似的东西。
You can do very simply in Durable Objects.
您可以在 Durable Objects 中非常简单地完成。
You can have as many Durable Objects as you want.
您可以拥有任意数量的耐用物品。
Each one of them has a SQLite database attached to it.
它们中的每一个都附有一个 SQLite 数据库。
You can have 10 gigabytes per one.
每一个可以有 10 GB。
And you can then kind of do whatever, you can kind of shard however you want, right?
然后你就可以做任何事，你可以随心所欲地进行碎片，对吧？
You could have a Durable Object per customer that tracks something that you need to be done real time.
您可以为每个客户拥有一个持久对象，用于跟踪您需要实时完成的事情。
You could have a Durable Object per chat room.
每个聊天室都可以有一个耐用对象。
As long as you don't kind of — like it does have a set amount of compute, a Durable Object, but you can use it for all sorts of magical things.
只要你不喜欢它确实有一定的计算量，一个持久对象，但你可以将它用于各种神奇的事情。
And I think it's a real underknown thing that Cloudflare has.
我认为 Cloudflare 确实有一个鲜为人知的东西。
Coming from Pusher, it's like the kind of real-time primitive now.
来自 Pusher，现在就像是实时原语。
And a lot of the stuff we'd reach for something like Pusher, Durable Objects — especially when you're building a fully real-time system — is really grateful.
我们对诸如 Pusher、Durable Objects 之类的很多东西——尤其是当你构建一个完全实时的系统时——非常感激。
**Adam Stacoviak:** Yeah.
**亚当·斯塔科维亚克：** 是的。
You chose TypeScript based on Cloudflare Workers, it sounds like, because that gave you three hundred locations across the world, Durable Objects, great ecosystem, no DevOps.
听起来，您选择了基于 Cloudflare Workers 的 TypeScript，因为这为您提供了世界各地 300 个地点、耐用对象、出色的生态系统，但没有 DevOps。
For those who choose Go — or I don't think you choose Rust for this because it's just not the kind of place you put Rust — but Go would compete for the same kind of mind share for you.
对于那些选择 Go 的人来说——或者我认为你不会为此选择 Rust，因为这不是你放置 Rust 的地方——但 Go 会为你争夺同样的思维份额。
How would the system have been different if you chose Go, or can you even think about that?
如果你选择 Go，系统会有什么不同，或者你能考虑一下吗？
**Damien Tanner:** \[62:10\] I haven't actually written any Go, so I don't know if I can give a good comparison.
**Damien Tanner：** \[62:10\] 我实际上还没有写过任何 Go，所以我不知道是否可以给出一个很好的比较。
But from the perspective of what we do have out there — there are similar real-time voice agent platforms in Python.
但从我们现有的技术来看，Python 中也有类似的实时语音代理平台。
And I think because a lot of the people building the models, the voice models, then built coordination systems like Layercode for coordinating the real-time conversations, Python was the language they chose.
我认为因为很多人构建模型、语音模型，然后构建像 Layercode 这样的协调系统来协调实时对话，所以 Python 是他们选择的语言。
And I think what's more important is the patterns rather than the specific languages.
我认为更重要的是模式而不是特定的语言。
And so we actually wrote the first implementation with RxJS, and that has an implementation in most popular languages.
因此，我们实际上使用 RxJS 编写了第一个实现，并且在大多数流行语言中都有实现。
I hadn't used it before, but we chose it because it was for stream processing.
我以前没有使用过它，但我们选择它是因为它用于流处理。
It's not really for real-time systems, but it gives you subjects, channels — these kinds of, it has its own names for these things — but basically it's like a pub-subby kind of thing.
它并不是真正针对实时系统，但它为你提供了主题、频道——这些东西，它有自己的名字——但基本上它就像一个 pub-subby 之类的东西。
And then it's got these kind of functional chaining things where you can then kind of pipe things and filter things and filter messages and split messages and things like that.
然后它有这些功能链接的东西，你可以在其中管道东西、过滤东西、过滤消息、分割消息等等。
And that did allow us to build the first version of this kind of quite dynamic system.
这确实使我们能够构建这种动态系统的第一个版本。
We didn't touch on it, but interruptions is this other really difficult dynamic part where whilst the agent is speaking its response to you, if the user starts speaking again, you then need to decide in real time whether the user is interrupting the agent or are they just going "yeah" and like agreeing with the agent, or are they trying to say "oh stop." How much of the hard problems — we have to still be transcribing audio even when the user is hearing it, and we've got to deal with background noise and everything.
我们没有触及它，但中断是另一个非常困难的动态部分，当代理向您说出其响应时，如果用户再次开始说话，您需要实时决定用户是否正在打断代理，或者他们只是说“是”并同意代理，或者他们试图说“哦停止”。有多少难题——即使用户听到了音频，我们仍然必须转录音频，并且我们必须处理背景噪音和其他一切。
And then when we're confident the user is trying to interrupt the agent, we've then got to do this whole kind of state change where we tear down all of this in-flight LLM request, in-flight voice generation request, and then as quickly as possible start focusing on the user's new question.
然后，当我们确信用户正在尝试中断代理时，我们就必须进行整个状态更改，我们将删除所有正在进行的 LLM 请求、正在进行的语音生成请求，然后尽快开始关注用户的新问题。
And especially if their interruption is really short, like "stop" — suddenly you've got to tear down all the old stuff, transcribe the word "stop," then ship that as a new LLM request to the backend, generate the response, and then get the agent speaking back as quickly as possible.
特别是如果他们的中断时间很短，比如“停止”——突然间你必须拆除所有旧的东西，抄写“停止”这个词，然后将其作为新的 LLM 请求发送到后端，生成响应，然后让代理尽快回复。
And it's all happening down one pipe, as it were, at the end of the day, right?
可以说，这一切都在一天结束时通过一根管道发生，对吗？
It's like audio from the browser microphone and then audio replaying back.
这就像来自浏览器麦克风的音频，然后重播音频。
And we would have bugs like you'd interrupt the agent, but then when it started replying there'd still be a few chunks of 20 millisecond audio from the old response snuck in there, or the old audio would be interleaved with the new audio from the agent back.
我们会遇到一些错误，比如您会打断代理，但当它开始回复时，仍然会有一些来自旧响应的 20 毫秒音频块潜入其中，或者旧音频将与代理返回的新音频交织在一起。
And you're kind of in Audacity or something, some audio editor, trying to work out like what's going — why does it sound like this?
你就像是在 Audacity 之类的，某个音频编辑器，试图弄清楚正在发生的事情 - 为什么听起来像这样？
And you're rearranging bits of audio going, "Okay, the responses are taking turns every 20 milliseconds, it's interleaving the two responses," trying to work out what's going on.
然后你重新排列音频片段，“好吧，响应每 20 毫秒轮流一次，这两个响应交错”，试图弄清楚发生了什么。
Real pain in the bottom, yeah.
底部真的很痛，是的。
**Adam Stacoviak:** When you solve that problem with the interruption, do you focus on the false examples, the true examples?
**Adam Stacoviak：** 当你用中断来解决这个问题时，你会关注错误的例子，真实的例子吗？
So do you like have these — if it is an interruption you can tell it's an interruption by these 17 known cases?
那么您喜欢这些吗？如果是干扰，您可以通过这 17 个已知案例判断这是干扰吗？
Like how do you direct that, the interrupt?
比如你如何指挥中断？
**Damien Tanner:** It really depends on the use case.
**Damien Tanner：** 这实际上取决于用例。
How you configure the voice agent really depends on how the voice agent is being used, right?
如何配置语音代理实际上取决于语音代理的使用方式，对吧？
Like a therapy voice agent needs to behave very differently than a vet appointment booking answering phone agent.
就像治疗语音代理需要与兽医预约接听电话代理的行为截然不同。
**Damien Tanner:** Yeah, there's that.
**达米安·坦纳：** 是的，就是这样。
And when we call that audio environments, that's often an early issue users have.
当我们称之为音频环境时，这通常是用户遇到的早期问题。
It's interesting, they're like, "Well, my users call from cafes and it kind of really misunderstands them." And big problem with audio transcription — it just transcribes any audio it hears, right?
有趣的是，他们会说，“好吧，我的用户从咖啡馆打电话，这确实误解了他们。”音频转录的一个大问题是——它只是转录它听到的任何音频，对吧？
So if someone's talking behind you, the model doesn't quite know that's irrelevant conversation.
因此，如果有人在你背后说话，模型就不太知道这是无关紧要的对话。
It's just transcribing it all.
这只是全部抄写而已。
But if you imagine the therapy voice agent, it needs to actually not respond too quickly to the user and allow the user to have long pondering thoughts, long sentences, big pauses.
但如果你想象一下治疗语音代理，它实际上不需要对用户做出太快的响应，并允许用户有长时间的思考、长句子、大停顿。
Maybe tears, they're crying, or just some sort of human — you know, interrupt, but it's not a true interrupt.
也许是眼泪，他们在哭，或者只是某种人类的声音——你知道，打断，但这不是真正的打断。
It's something that you should maybe even capture and process.
这是你甚至应该捕捉和处理的东西。
And so you can choose a few different levels of interruption, right?
所以你可以选择几种不同级别的中断，对吗？
You can just interrupt when you hear any word.
当你听到任何单词时你可以打断。
By default, we interrupt when we hear any word that's not a filler word, so you filter out things like that.
默认情况下，当我们听到任何不是填充词的单词时，我们会打断，因此您可以过滤掉类似的内容。
And then if you need some more intelligence, you can actually just ship off the partial transcripts to an LLM in real time.
然后，如果您需要更多情报，您实际上可以将部分成绩单实时发送给法学硕士。
So let's say the user's speaking while and starts interrupting the agent — every kind of word you get, or a few words, you fire up a request to Gemini Flash and you say, "Here's the previous thing that the user said, here's what the agent said, here's what the user just said.
假设用户正在说话，并开始打断代理 — 无论您收到什么单词，或者几句话，您都会向 Gemini Flash 发出请求，然后说：“这是用户之前说的内容，这是代理说的内容，这是用户刚刚说的内容。
Respond yes or no, do you think they're interrupting the agent?" And you get that back in about 250-300 milliseconds.
回答“是”或“否”，你认为他们在打扰特工吗？”您会在大约 250-300 毫秒内得到结果。
And you just — as you get new transcripts you can cancel the old ones — you just constantly try and make that request until the user stops speaking.
当你获得新的记录时，你可以取消旧的记录，你只需不断地尝试提出该请求，直到用户停止说话。
Then you get the response from that and then you can kind of make quite an intelligent decision.
然后你会得到回应，然后你就可以做出一个非常明智的决定。
**Adam Stacoviak:** \[68:26\] Well, the first thing I think about there is that Gemini Flash is not local.
**Adam Stacoviak：** \[68:26\] 嗯，我首先想到的是 Gemini Flash 不是本地的。
So you do have to deal with an outage or latency or downtime.
因此，您确实必须处理中断、延迟或停机问题。
Or in Cloudflare's case, most recently, a lot of downtime because of usage — like really heavy usage.
或者就 Cloudflare 的情况而言，最近由于使用而导致大量停机——比如非常大量的使用。
Unless it is — I've had more trepidation with Cloudflare than ever, and I'm like, "Okay cool, I get it." You know, I'm not upset with you because I empathize with how in the world do you scale those services.
除非是这样——我对 Cloudflare 的恐惧比以往任何时候都多，我想，“好吧，酷，我明白了。”你知道，我并不对你感到不安，因为我理解你到底是如何扩展这些服务的。
**Adam Stacoviak:** It's the Ralph effect.
**亚当·斯塔科维亚克：** 这是拉尔夫效应。
And I'm like — so why does your system not allow for a local LLM to be just as smart as Gemini Flash might be to answer that very simple question?
我想——那么为什么你们的系统不允许本地法学硕士像 Gemini Flash 一样聪明地回答这个非常简单的问题呢？
Like an interrupt, it's a pretty easy thing to determine.
就像中断一样，它很容易确定。
**Damien Tanner:** Yeah, yeah.
**达米安·坦纳：** 是的，是的。
I think smaller LLMs can do that.
我认为规模较小的法学硕士可以做到这一点。
Gemini is just incredibly fast, and I think because of their TPU infrastructure they've got an incredibly low TTFT — time to first token — which is the most important thing.
Gemini 的速度快得令人难以置信，我认为由于他们的 TPU 基础设施，他们的 TTFT（第一个代币的时间）非常低，这是最重要的。
But I agree that there are smaller LLMs, and actually I think probably maybe one of the Groq with a qLLaMA is actually might even be a bit faster.
但我同意有更小的法学硕士，实际上我认为也许其中一个带有 qLLaMA 的 Groq 实际上甚至可能更快一点。
We should try that.
我们应该尝试一下。
But you make a point about reliability.
但你提出了关于可靠性的观点。
People really notice it in voice agents when it doesn't work, for sure.
当然，当语音代理不起作用时，人们确实会注意到它。
And especially for businesses relying on it to collect a bunch of calls for them.
特别是对于依靠它来收集大量电话的企业来说。
And so that is one of the other helpful things that platforms like us provide as well.
这也是像我们这样的平台提供的其他有用的东西之一。
**Adam Stacoviak:** Or even just cost.
**Adam Stacoviak：** 或者甚至只是成本。
I imagine over time, cost — I mean, right now you're probably fine with it as you're innovating and maybe you're finding out customer fit, ability, reliability, all those things.
我想随着时间的推移，成本——我的意思是，现在你可能在创新时对此感到满意，也许你正在寻找客户的契合度、能力、可靠性，所有这些东西。
And you're sort of just-in-time building a lot of the stuff and you're maybe okay with the inherent cost of innovation.
你可以及时构建很多东西，并且你可能可以接受创新的固有成本。
But at some point you may flatten a little bit and you're like, "You know what, if we had been running that locally for the last little bit, we just saved 50 grand," you know?
但在某些时候，你可能会变得扁平一点，你会想，“你知道吗，如果我们最后一点在本地运行，我们就节省了 50 英镑，”你知道吗？
I don't know what the number is, but the local model becomes a version of free when you own the hardware and you own the compute and you own the pipe to it, and you can own the SLA latency to it as well.
我不知道这个数字是多少，但是当您拥有硬件、拥有计算、拥有通往它的管道，并且您也可以拥有它的 SLA 延迟时，本地模型就会成为免费版本。
The reliability comes from that.
可靠性由此而来。
**Damien Tanner:** And there's some cool — there's a new transcription model from Nvidia and they've got some voice models as well.
**Damien Tanner：** 还有一些很酷的东西 - Nvidia 有一个新的转录模型，他们也有一些语音模型。
And so there was a great demo of fully open source, like all voice agent platform, that was done with Pipecat — which is the Python coordination agent, open source project that I was mentioning.
因此，有一个很棒的完全开源的演示，就像所有语音代理平台一样，是用 Pipecat 完成的——这是我提到的 Python 协调代理、开源项目。
And they've got a really great pattern.
他们有一个非常好的模式。
They have a plugin pattern for the voice agent, and I think that's the right pattern.
他们有一个语音代理插件模式，我认为这是正确的模式。
And we've adopted a similar — and other frameworks have done that — we've adopted a similar pattern for us.
我们采用了类似的模式——其他框架也这样做了——我们也采用了类似的模式。
When we rebuilt it recently, the important thing is the plugins are independent things that you can test in isolation.
当我们最近重建它时，重要的是插件是独立的东西，您可以单独测试。
That was the biggest problem we had with RxJS — the whole thing was kind of, you know, those mixing kind of audio mixing things with cables going everywhere.
这是我们在 RxJS 方面遇到的最大问题——整件事就是，你知道，那些混合音频的东西，到处都有电缆。
It was kind of like that, right, with RxJS subjects going absolutely everywhere.
有点像那样，对吧，RxJS 主题绝对无处不在。
It was kind of hard — it was hard for us as humans to understand.
这有点难——我们人类很难理解。
It was the kind of code where you come back to a week later and go, "What was happening here?"
一周后你回过头来看看这样的代码，“这里发生了什么？”
And things like, you know, oftentimes we'd end up writing code where the code at the top of the file was actually the thing that happened last in the execution of it.
你知道，通常我们最终会编写代码，其中文件顶部的代码实际上是执行过程中最后发生的事情。
You know, basic stuff like that, just because that's how the RxJS was kind of telling us to do it or kind of guiding us and how we had to initialize things.
你知道，诸如此类的基本内容，只是因为 RxJS 就是这样告诉我们如何去做或引导我们以及我们如何初始化事物的。
But that was one of the key things — we moved to a plugin architecture.
但这是关键的事情之一——我们转向了插件架构。
We went to a very basic — we've got no kind of RxJS-style stream processing plugin.
我们采用了非常基本的方式——我们没有任何 RxJS 风格的流处理插件。
It's just all very simple JavaScript with async iterables, and we just pass a waterfall of messages down through plugins.
这只是非常简单的带有异步迭代的 JavaScript，我们只是通过插件向下传递消息瀑布。
And it's so much better.
而且好多了。
And we can take out a plugin if we need to, and we can unit test a plugin, and we can write integration tests and mock out plugins up and down.
如果需要，我们可以取出一个插件，我们可以对插件进行单元测试，我们可以编写集成测试并上下模拟插件。
And we're about to launch that, and that's just such a game changer.
我们即将推出它，这将改变游戏规则。
And then interestingly, tying back to LLMs, we ended up here because with the first implementation we found it hard as developers to understand the code.
然后有趣的是，回到法学硕士，我们最终来到这里，因为在第一个实现中，我们发现作为开发人员很难理解代码。
We'd run the LLMs — they were hopeless.
我们负责法学硕士——他们毫无希望。
They just could not hold the state of this dynamic, crazy, multi-subject stream system in their head.
他们就是无法将这个动态的、疯狂的、多主题的流媒体系统的状态记在脑子里。
**Adam Stacoviak:** Context was everywhere, right?
**Adam Stacoviak：** 上下文无处不在，对吧？
Like it was all — it was here, it was there.
就像一切一样——它在这里，它在那里。
**Damien Tanner:** Yeah.
**达米安·坦纳：** 是的。
Even if you — I would do things like take the whole file.
即使你——我也会做一些事情，比如拿走整个文件。
I was like, copying and pasting files into ChatGPT Pro being like, "You have — you definitely have all the context here.
我当时想，将文件复制并粘贴到 ChatGPT Pro 中就像是，“你已经 - 你绝对拥有这里的所有上下文。
Fix this problem." And they couldn't solve the problem.
解决这个问题。”他们无法解决问题。
**Damien Tanner:** And part of the problem was that complexity.
**达米安·坦纳：** 问题的一部分在于复杂性。
I mean, not having the ability to test things in isolation then meant we couldn't have a kind of TDD loop, whether it was with the human or with an agent.
我的意思是，如果没有能力单独测试事物，就意味着我们无法拥有某种 TDD 循环，无论是与人类还是与代理一起。
And so — and because we couldn't use agents to add features to this platform, to the core of the platform, it was slowing us down.
因此，因为我们无法使用代理向这个平台、平台的核心添加功能，所以它拖慢了我们的速度。
And so that's when we really started to use coding agents — Claude Code, Codex — like really properly and hard.
因此，从那时起，我们才真正开始使用编码代理——Claude Code、Codex——非常正确且努力。
We were like — I spent like two weeks just in Claude Code and Codex, and the mission was: if I can get the coding agent to write the new version of this — it was kind of not even a refactor, it had to be rewritten, start from scratch, first principles — then it will, by virtue of it writing it, understand it.
我们就像——我在 Claude Code 和 Codex 上花了大约两周的时间，任务是：如果我能让编码代理编写这个的新版本——它甚至不是重构，它必须重写，从头开始，首要原则——然后它会凭借它编写它来理解它。
And then I'll be able to use coding agents to add features.
然后我将能够使用编码代理来添加功能。
And I started with literally the API docs for our public API, because I didn't want to change that, and the API docs of all of the providers and models we implement with — like the speech-to-text and text-to-speech model provider endpoints — and just some ideas about, "I think we should just use a simple waterfall pipe, like pass messages through the plugins."
我从字面上的公共 API 的 API 文档开始，因为我不想更改它，以及我们实现的所有提供程序和模型的 API 文档（例如语音到文本和文本到语音模型提供程序端点）以及一些关于“我认为我们应该使用简单的瀑布管道，例如通过插件传递消息”的想法。
And that experience was really interesting because it felt like molding clay.
那次经历真的很有趣，因为感觉就像捏粘土一样。
Because I did care about — I really cared about how the code looked, because I wanted humans as well as — the agents aren't quite good enough to build this whole thing from a prompt, but I think they will be in a year or two, right?
因为我确实关心——我真的很关心代码的外观，因为我也想要人类——代理还不够好，无法根据提示构建整个事情，但我认为他们会在一两年内做到这一点，对吗？
But it did an okay job, and it needed a lot of reprompting — "refactor this, re-architect this" — but it felt like clay in one sense because, and you mentioned this earlier, you can just write some code and even if it's wrong, you've kind of learned some experience.
但它做得还不错，并且需要大量的重新提示——“重构这个，重新架构这个”——但从某种意义上说，它感觉就像粘土，因为，你之前提到过这一点，你可以只写一些代码，即使它是错误的，你也学到了一些经验。
**Damien Tanner:** I was able to just say, "Write this whole plugin architecture and do it," and it would do it, and I'd be like, "Oh, that seems a bit wrong, that's hard to understand." I was like, "Write it again like this.
**Damien Tanner：** 我可以说，“编写整个插件架构并执行它”，它就会执行，我会说，“哦，这似乎有点错误，这很难理解。”我当时想，“像这样再写一次。
Write it again like this." And I suddenly got that experience of throwing away code because it hadn't taken me weeks and weeks to write this code.
像这样再写一遍。”我突然有了扔掉代码的经历，因为我并没有花费数周的时间来编写这些代码。
**Damien Tanner:** And I was there, just threw it away.
**达米安·坦纳：** 我当时就在那里，只是把它扔掉了。
And you still have your chat session too, so even if you had to scroll back up a little bit, or maybe even copy that out to a file for long-term memory if you needed to, you still have that there as a reference point.
而且你仍然有你的聊天会话，所以即使你必须向后滚动一点，或者甚至可能将其复制到文件中以供长期记忆（如果需要），你仍然可以将其作为参考点。
**Adam Stacoviak:** Yeah.
**亚当·斯塔科维亚克：** 是的。
I find myself doing similar things, which is like just trust the model, throw it away and do it again if you need to.
我发现自己在做类似的事情，就像信任模型，扔掉它，如果需要的话再做一次。
Learn the mistake, go down the wrong road for the learning, and make the prompt better.
学习错误，走错误的学习道路，让提示更好。
**Damien Tanner:** And it did a terrific job.
**达米安·坦纳：** 它做得非常出色。
And then the bit that really got it over the finish line was then I said — I gave it this script that we used to have to do manually to test our voice agent.
然后，真正让它冲过终点线的是我说的——我给了它这个脚本，我们过去必须手动执行该脚本来测试我们的语音代理。
You know, it's like: connect to the voice agent, say this to the voice agent, tell it to tell you a long story, now interrupt the story, you shouldn't hear any leftover audio from the long story — like all these things, there's like 20 different tests you had to do.
你知道，就像：连接到语音代理，对语音代理说这个，告诉它告诉你一个长故事，现在打断故事，你不应该听到长故事中的任何剩余音频 - 就像所有这些事情一样，你必须做大约 20 种不同的测试。
I gave it that script and I was like, "Write the test suite for all of these tests." And then it did.
我给了它那个脚本，然后我想，“为所有这些测试编写测试套件。”然后它就做到了。
And I gave it all these bugs we had in our backlog.
我把我们积压的所有这些错误都给了它。
I was like, "Write tests for this." And I just started doing TDD on our backlog, and it was great.
我当时想，“为此编写测试。”我刚刚开始在我们的积压工作中进行 TDD，这非常棒。
Then I was like, "Write a bunch —" I did like a chaos monkey thing.
然后我想，“写一堆——”我确实喜欢混乱猴子的东西。
I was like, "Write a bunch of tests for like crazy stuff the users could do with the API."
我当时想，“为用户可以使用 API 做的疯狂事情编写一堆测试。”
**Damien Tanner:** Found a bunch of bugs and issues, security issues.
**Damien Tanner：** 发现了一堆错误和问题，安全问题。
And then it kind of — it got it working, got a bunch of unit tests.
然后它就开始工作了，进行了一系列单元测试。
And I was still having to kind of do a bit of manual testing.
而且我仍然需要进行一些手动测试。
And then one day I was like, you know what, I really want — no one's made an integration test thing for voice agents.
然后有一天，我想，你知道吗，我真正想要的——没有人为语音代理做过集成测试。
There are a few observation platforms, observability platforms and eval platforms.
有一些观测平台、可观测平台和评估平台。
So I was like, I just wanted to simulate conversations.
所以我想，我只是想模拟对话。
And it's so — that's part of the magic, is trying something that you're like, "This is a pain in the ass to build," or like, "How is this even going to work?" Well, I just got it to build it.
就是这样——这就是魔法的一部分，就是尝试一些你喜欢的东西，“建造这个东西真是太痛苦了”，或者“这怎么行得通？”好吧，我刚刚得到它来构建它。
And I recorded some WAV files of me saying things, and I gave it to them.
我录了一些我说话的WAV文件，然后给了他们。
I was like, "Make an integration test suite for this and feed the WAV files like you're having a conversation, and check the transcripts you get back." Wow.
我当时想，“为此制作一个集成测试套件，并像正在进行对话一样提供 WAV 文件，然后检查返回的文字记录。”哇。
And it did a great job.
它做得很好。
And then it was actually able to fully simulate those conversations and do all the tests.
然后它实际上能够完全模拟这些对话并进行所有测试。
And then that — I mean, we've got these practices like TDD which are going to hold value, right?
然后，我的意思是，我们已经有了像 TDD 这样的实践，它们将具有价值，对吗？
It was so valuable for the model, for the agent, to be running the test, fixing the test, running the test, fixing the test.
对于模型、代理来说，运行测试、修复测试、运行测试、修复测试非常有价值。
And that feels a bit like magic when you get that working.
当你让它发挥作用时，感觉有点像魔法。
**Adam Stacoviak:** So much to cover in this journey.
**Adam Stacoviak：** 这次旅程要讲的内容太多了。
I'm so glad we had this conversation.
我很高兴我们进行了这次谈话。
I kind of feel like a good place to begin the end — not actually end — is back to this idea that is on your about page.
我觉得这是一个开始结束的好地方——而不是真正的结束——回到你的“关于”页面上的这个想法。
And I just got a reMarkable, because I love to write and I really hate paper, because this thing has Linux on it.
我刚刚得到了一个 reMarkable，因为我喜欢写作，但我真的很讨厌纸，因为这个东西上面有 Linux。
And I wrote an API that I now API to my reMarkable Pro tablet.
我编写了一个 API，现在将其连接到我的 reMarkable Pro 平板电脑上。
So amazing.
太棒了。
I'm loving this.
我很喜欢这个。
**Adam Stacoviak:** I just got it.
**亚当·斯塔科维亚克：** 我刚刚明白了。
I just got it.
我刚拿到。
So like, that's the next thing.
就像，那是接下来的事情。
I'm going to have this — it's a little playground for me, basically.
我要拥有这个——基本上，这对我来说是一个小游乐场。
But it's real time.
但这是实时的。
So if you see me looking over here writing — audience, or even you Damien — I'm not not paying attention.
所以，如果你看到我看着这里写作——观众，甚至你达米安——我并不是没有注意。
I'm writing things down.
我正在把事情写下来。
And the one thing I wrote down earlier from your about page was "the era of the small giant," which you alluded to, but you didn't say those exact words.
我之前在你的“关于”页面上写下的一件事是“小巨人时代”，你提到了这一点，但你没有说出确切的话。
And the reason why I think it might be a good place to begin to end is I want to — I think you might be able to encourage the single developer that maybe in the last couple of months they've just begun to touch and not resist falling into this gravity hole, or however we describe this resistance we've had as developers, loving to read our own code and code review and all the things as humans, and now to not resist as much, or if at all, and just trust the model.
我认为这可能是一个开始和结束的好地方的原因是我想 - 我认为你可能能够鼓励单个开发人员，也许在过去的几个月里，他们刚刚开始接触并且不抗拒落入这个重力洞，或者无论我们如何描述我们作为开发人员所遇到的这种阻力，喜欢阅读我们自己的代码和代码审查以及作为人类的所有事情，现在不要那么抗拒，或者如果有的话，只是相信模型。
To give them this word of encouragement towards, "Hey, you're a single developer," and in your case, Damien, you don't need a DevOps.
为了给他们鼓励的话，“嘿，你是一个单一的开发人员，”达米安，就你的情况而言，你不需要 DevOps。
It's not that they're not valuable or useful, but you chose a model, a way to develop your application, solve your problem, that didn't require a DevOps team.
并不是说它们没有价值或没有用，而是您选择了一种模型，一种开发应用程序、解决问题的方法，并且不需要 DevOps 团队。
Give them that encouragement.
给他们这种鼓励。
What does it mean to be in this era of the small giant?
在这个小巨人时代意味着什么？
**Damien Tanner:** \[80:41\] I think the hardest thing is our own mindset, right?
**Damien Tanner：** \[80:41\] 我认为最难的是我们自己的心态，对吗？
I just found this with coding agents.
我刚刚通过编码代理发现了这个。
You start off putting in things where you kind of have an idea, you know what to expect out of it.
你开始把一些你有想法的东西放进去，你知道从中可以期待什么。
And then you start just putting in stuff that just seems a bit ridiculous and ambitious.
然后你开始添加一些看起来有点荒谬和雄心勃勃的东西。
And oftentimes it fails, but more and more it's working.
有时它会失败，但它越来越有效。
That's a very magical feeling, and it's a very revealing kind of experience.
这是一种非常神奇的感觉，也是一种非常有启发性的体验。
And so I think we can all be more ambitious now.
所以我认为我们现在都可以更加雄心勃勃。
I think we all — and especially as engineers, we know how the whole thing works, right?
我想我们所有人，尤其是作为工程师，我们都知道整个事情是如何运作的，对吧？
There is a lot of power everyone's been given with vibe coding.
Vivi 编码赋予了每个人很多力量。
Being able to vibe code — there are a lot of security issues I think will be solved over time — but as engineers, we have the knowledge to be able to take things fully through, deploy things, scale them, fix the issues that the LLMs can still get stuck on.
能够振动代码——我认为随着时间的推移，很多安全问题都会得到解决——但作为工程师，我们拥有能够完全解决问题、部署东西、扩展它们、解决法学硕士仍然可能遇到的问题的知识。
But we can do so much more now.
但我们现在可以做更多的事情。
We can be so much more ambitious now.
我们现在可以更加雄心勃勃。
And I think the thing that everyone should — every engineer should be doing now is not only trying out Claude Code and Codex and doing something new and fun.
我认为每个人——每个工程师现在应该做的事情不仅仅是尝试 Claude Code 和 Codex 以及做一些新的、有趣的事情。
I mean, the great thing is it's so low risk.
我的意思是，最棒的是它的风险很低。
It's so easy to do that you can build something ridiculous and fun that you've always wanted to do.
这非常容易做到，您可以构建一些您一直想做的荒谬而有趣的东西。
**Damien Tanner:** You can just — and you can build something for a friend, for your wife.
**Damien Tanner：** 你可以——而且你可以为朋友、为你的妻子建造一些东西。
And that's really exciting.
这真的很令人兴奋。
And I think this Ralph Wiggum thing — very kind of basic idea — is give a spec.md, todo.md, just an ambitious task or a long list of tasks in a markdown file, and you run a shell script.
我认为 Ralph Wiggum 的事情——非常基本的想法——就是给出一个 spec.md、todo.md，只是一个雄心勃勃的任务或 Markdown 文件中的一长串任务，然后你运行一个 shell 脚本。
And all it does is it just says to Claude Code, "Do the next bit of work.
它所做的只是对克劳德·科德说：“做下一步工作。
When there's no more work to do, return complete." And the shell script just greps for "complete," and if it hasn't seen that word in some XML tags, "complete," it just calls Claude Code again.
当没有更多工作要做时，就完成返回。” shell 脚本只是 grep 查找“完整”，如果它在某些 XML 标记中没有看到“完整”这个词，它只会再次调用 Claude Code。
And like many of these things, it seems like a terrible idea, it seems ridiculous, but it is also incredible what it can do.
就像许多这样的事情一样，这似乎是一个糟糕的想法，看起来很荒谬，但它的功效也令人难以置信。
And so I think that's probably — to feel what the future is going to be like, I feel like you write down something very ambitious in a markdown file, or transcribe an idea you have that you've been thinking about for a while, and you set a Ralph Wiggum script off on it, and you just go for a long walk or go and have lunch.
所以我认为这可能是——为了感受未来会是什么样子，我觉得你在一个 Markdown 文件中写下了一些非常雄心勃勃的东西，或者转录了你已经思考了一段时间的一个想法，然后你在上面设置了一个 Ralph Wiggum 脚本，然后你就去散步或去吃午饭。
And when you come back — I mean, it's a very exciting feeling.
当你回来时——我的意思是，这是一种非常令人兴奋的感觉。
And as a developer, it's very fun because then you get to go through all this code and be like, "Why did it do it?" And you're like, "Oh, that was pretty smart.
作为一名开发人员，这非常有趣，因为这样你就可以浏览所有这些代码并想，“为什么这样做？”你会说，“哦，那真是太聪明了。
But I didn't like that.
但我不喜欢那样。
Okay, that was quite a good idea.
好吧，这是个好主意。
It messed up this bit." But that's — I just feel like that's a very, very exciting experience.
就这一点就搞砸了。”但那是——我只是觉得这是一次非常非常令人兴奋的经历。
**Adam Stacoviak:** Very cool.
**亚当·斯塔科维亚克：** 非常酷。
I definitely agree with that.
我绝对同意这一点。
I'm looking forward to writing that todo.md or spec.md and just going for that walk.
我期待着编写 todo.md 或 spec.md，然后就去散步。
Because I haven't done it yet.
因为我还没有做到。
I've only peaked at some of the videos and some of the demos, but I haven't tried the Ralph Wiggum loop yet.
我只在一些视频和一些演示中达到了顶峰，但我还没有尝试过 Ralph Wiggum 循环。
**Damien Tanner:** I'm gonna post on X a one-liner as well, because I think you can just then copy and paste the thing.
**Damien Tanner：** 我也会在 X 上发布一句话，因为我认为你可以复制并粘贴该内容。
Well, I feel like with everything, I want to make it more ceremonious.
嗯，我觉得凡事都想变得更有仪式感。
Because I want to — it's not because it needs to be, because I want to know — I want to give myself space to think of something that I think will be challenging for me, even, you know?
因为我想——这不是因为它需要如此，因为我想知道——我想给自己空间去思考一些我认为对我来说具有挑战性的事情，甚至，你知道吗？
And then give it to the thing and go away, like you said, and come back happy.
然后把它交给那东西然后走开，就像你说的，然后高兴地回来。
I want to save space to do that when I can give it full mind share, versus the incremental 20 minutes or 10 minutes or whatever it might be that I have available to give it.
当我可以给予它充分的思想分享时，我想节省空间来做到这一点，而不是增量 20 分钟或 10 分钟或任何我可以给予它的时间。
I kind of want to give it a bit more ceremony, not because it deserves it, because I want to actually do it for myself.
我有点想给它多一点仪式感，不是因为它值得，而是因为我想真正为自己做这件事。
So I'm just in this constant learning scenario.
所以我只是处于这个不断学习的场景中。
It's a pretty wild era to be a developer and to be an enabled developer.
对于一名开发人员和一名有能力的开发人员来说，这是一个非常狂野的时代。
These non-technical folks that may get introduced to a terminal-like thing that's basically just Claude in a directory, really, and ask questions and get a just-in-time interface managed to them only — that's a really, really, really cool world to be in.
这些非技术人员可能会接触到一个类似终端的东西，基本上就是目录中的 Claude，真的，他们会提出问题并获得一个只为他们管理的即时界面——这是一个非常非常酷的世界。
And it doesn't mean that software goes away.
这并不意味着软件会消失。
It just means there's gonna be a heck of a lot more of it out there.
这只是意味着那里将会有更多的东西。
And I do concur that maybe code doesn't matter anymore.
我确实同意也许代码不再重要了。
Maybe it won't in a year.
也许一年后就不会了。
Maybe it won't in six weeks.
也许六周后就不会了。
I don't know how many weeks it'll take.
我不知道需要多少个星期。
Let's truly aim with this.
让我们真正以此为目标。
What's over the horizon for you?
对你来说，未来会发生什么？
What's over the horizon for Layercode?
Layercode 即将迎来什么？
What is coming?
即将发生什么？
**Damien Tanner:** So the show release — next Wednesday you've got a week, given that horizon.
**达米安·坦纳：**所以节目发布——考虑到这一点，下周三你就有一周的时间。
And no one's listening.
而且没有人在听。
It's a week from now.
距离现在已经过去一周了。
**Adam Stacoviak:** What's on the horizon for you that you can give us a peek at?
**Adam Stacoviak：** 您有什么可以让我们看看的吗？
Is there anything?
有什么吗？
**Damien Tanner:** We are working really hard to bring down the cost of voice agents.
**Damien Tanner：** 我们正在努力降低语音代理的成本。
There is a magic number of one dollar an hour for running a voice agent, where suddenly a huge, huge number of use cases open up — whether it's consumer applications, gaming.
运行语音代理的每小时一美元是一个神奇的数字，突然之间就会出现大量的用例——无论是消费应用程序还是游戏。
There are so many places where voice AI will be super valuable, super fun, and isn't implemented yet.
语音人工智能在很多地方都非常有价值、非常有趣，但尚未实现。
And with the choices we made being on Cloudflare, with the system we've built, we're going to be able to bring out the lowest cost platform.
通过我们在 Cloudflare 上做出的选择以及我们构建的系统，我们将能够推出成本最低的平台。
I'm very excited for that.
我对此感到非常兴奋。
And most of all, very excited just to see voice AI everywhere.
最重要的是，看到语音人工智能无处不在，我感到非常兴奋。
Voice AI — voice is just such a wonderful interface, right?
语音人工智能——语音真是一个美妙的界面，对吧？
I find myself dictating all the time to Claude Code, and you can kind of get out your thoughts so much better.
我发现自己一直在向 Claude Code 口授，这样你就可以更好地表达自己的想法。
And I'm excited to see how many applications we can enable adding voice AI into their application.
我很高兴看到我们可以在多少应用程序中添加语音人工智能。
And then we get an insight into the future of voice AI as well, with the companies that are building — a lot of them startups — and they're building some crazy, crazy new things with voice AI on our platform.
然后我们还可以深入了解语音人工智能的未来，以及正在建设的公司（其中很多是初创公司），他们正在我们的平台上利用语音人工智能构建一些疯狂的新事物。
So there's going to be some amazing stuff with voice coming out this year.
所以今年将会有一些令人惊奇的有声作品问世。
**Adam Stacoviak:** What's the sweet spot for Layercode right now that you can invite folks to come and try?
**Adam Stacoviak：** Layercode 现在可以邀请人们来尝试的最佳点是什么？
**Damien Tanner:** Well, the great thing is we've got a CLI — single command you can run — and you'll get a Next.js demo app all connected to the live voice agent.
**Damien Tanner：** 嗯，最棒的是我们有一个 CLI — 您可以运行的单个命令 — 并且您将获得一个全部连接到实时语音代理的 Next.js 演示应用程序。
And you can get a voice agent up and running within a minute.
您可以在一分钟内启动并运行语音代理。
So it's super fun, worth trying.
所以超级有趣，值得一试。
And then from that point, you can use Claude Code, Codex, and just start building from that.
然后从那时起，您可以使用 Claude Code、Codex，然后开始构建。
**Adam Stacoviak:** Well friends, right here at the last minute of the very last question, Damien's internet dropped off or something happened.
**Adam Stacoviak：** 朋友们，就在最后一个问题的最后一刻，Damien 的互联网掉线了或者发生了一些事情。
I'm not sure.
我不知道。
But it was a fun conversation with Damien.
但与达米安的谈话很有趣。
Kind of wild to be talking to somebody 17 years later after being one of the first — if not the first, I'm pretty sure the first — sponsor of this podcast.
17 年后，在成为这个播客的第一个——如果不是第一个，我敢肯定是第一个——赞助商之后，与某人交谈，有点疯狂。
What a wild world it is to be this deep in years and experience and history in software and to just still be enamored by the possibilities.
在软件领域拥有如此深厚的岁月、经验和历史，却仍然对各种可能性着迷，这是一个多么狂野的世界啊。
I hope you enjoyed today's conversation with Damien, and we'll see you next time.
希望您喜欢今天与达米安的谈话，我们下次再见。