RoboBun Ships While You Sleep

"Please welcome to the stage the head of Claude Code at Anthropic, Boris Cherny, and the creator of Bun at Anthropic, Jarred Sumner."

"有请上台:Anthropic Claude Code 负责人 Boris Cherny,以及 Bun 的作者、现就职于 Anthropic 的 Jarred Sumner。"

"All right. So this is a developer conference. We're going to do a little bit of talking, but mostly we're just going to be coding. This is for the developers in the room."

"好,这是一场开发者大会。我们会聊一点,但主要就是现场写代码——这是给在座各位开发者的。"

"I'm going to start by talking a little bit about how Bun uses Claude Code to build and maintain Bun, and how our setup works — because it's a slightly more advanced setup than what's common today."

"我先讲讲 Bun 是怎么用 Claude Code 来开发和维护自己的,以及我们这套配置是怎么跑的——因为它比今天大家普遍的用法要更进阶一些。"

"But first I'm going to get a few agents running to just fix some GitHub issues."

"不过我先起几个 agent,让它们去顺手修几个 GitHub issue。"

"This is classic Jarred — doing work during a talk."

"这就很 Jarred 了——演讲的同时还在干活。"

"So in Bun's repo, every time somebody submits an issue, we have a Claude bot automatically run and try to reproduce the issue."

"在 Bun 的仓库里,每次有人提一个 issue,我们就有一个 Claude bot 自动跑起来,去尝试复现这个问题。"

"You can see this person has these side effects — this is one of the most recent issues. And we can see that RoboBun, which is our bot, went and managed to reproduce the issue, and submitted a PR automatically."

"你看这个人报的是一堆副作用问题——这是最近的 issue 之一。可以看到 RoboBun,也就是我们的 bot,跑过去成功复现了这个问题,然后自动提了一个 PR。"

"And this PR has tests — it's one of the actual hard requirements before it can submit a PR."

"而且这个 PR 是带测试的——这是它提 PR 之前必须满足的硬性条件之一。"

"So the challenge here is: does this code look correct? One of the things we do to check that is — does the test fail in the previous version of Bun, and pass in this debug branch? The bot actually can't submit a PR without that being the case."

"所以这里的难点是:这段代码看起来对不对?我们检查的一个办法是——这个测试在旧版本的 Bun 上是不是 fail、在这个 debug 分支上是不是 pass?不满足这一点,bot 根本提不了 PR。"

"So this is — every single issue that goes up in the Bun issue tracker, you have RoboBun automatically try to reproduce it before anyone even looks at it."

"所以就是这样:Bun issue tracker 里每提上来一条 issue,RoboBun 都会在任何人去看它之前,先自动尝试复现一遍。"

"Yeah, and this saves a lot of time, because we have so many open GitHub issues. It really moves the challenge from just fixing and debugging the issue, to: is this the right thing to merge? Is this the right fix? How good is it?"

"对,这能省下大量时间,因为我们 open 的 GitHub issue 实在太多了。它把难点从'修 bug、调 bug'本身,挪到了:这东西该不该 merge?这个修法对不对?它质量有多好?"

"Right — is it doing 100% of yours, or is it like 10%? We can go to Insights, then Contributors, and if we go to the last three months — and this is specifically to main —"

"对——它干的是你 100% 的活,还是只有 10%?我们可以点进 Insights → Contributors,看最近三个月——而且这是只统计合进 main 的——"

"— we can see that RoboBun is now a bigger contributor to Bun than I am. [laughter] And that's with not merging all of its PRs, for sure."

"——可以看到,RoboBun 现在给 Bun 的贡献量已经比我还多了。[笑] 而且这还是在没把它的 PR 全 merge 进去的前提下。"

"You can see we have a lot of PRs open right now. The challenge is really: how do we know we can merge the PR? And that's the tests."

"你看,我们现在还 open 着一大堆 PR。真正的难点其实是:我们怎么确定这个 PR 能 merge?答案就是测试。"

"The other thing that's really interesting about this is we have automatic code review bots that run, and then they go back and forth."

"这套东西还有一点特别有意思:我们有自动的过码(code review)bot 在跑,然后它们之间会来回拉扯。"

"So Code Rabbit leaves a comment, then RoboBun leaves a comment, and they go back and forth — and Code Rabbit did the… [laughter] I love this. And it also marks the comments as resolved when it's done."

"CodeRabbit 留一条评论,RoboBun 回一条评论,两边就这么来回……然后 CodeRabbit 还……[笑] 我太喜欢这个了。而且搞定之后它会自动把评论标成 resolved。"

"You can see they actually went a lot — there's like 30 comments or something here."

"你看,它俩来回了好多轮——这里大概有 30 条评论吧。"

"So you're using a combination of agents. This is code review — this is Claude code review, and then also Code Rabbit, and you're using them together."

"所以你是把好几个 agent 组合着用。这一层是过码——Claude 的过码,再加上 CodeRabbit,两个一起用。"

"Yeah. Basically Code Rabbit is good for stylistic issues, and for making sure it follows the CLAUDE.md."

"对。基本上 CodeRabbit 擅长风格类的问题,以及确保代码遵守 CLAUDE.md 的约定。"

"And the Claude code review is really good at: here's this really subtle edge case that would've taken me 30 minutes of reading all the code, with all the context, to figure out."

"而 Claude 的过码真正擅长的是:'这里有个特别隐蔽的边界情况'——这种我自己得把所有代码、所有上下文都读一遍、花上 30 分钟才能搞明白的东西。"

"So it's really good at surfacing bugs that you need the full context to really understand."

"所以它特别擅长把那种'必须有全局上下文才看得懂'的 bug 给挑出来。"

"And it's really hard to actually have all this automation without code review that's in the loop with Claude there replying — and replying is very performative, but at fixing things."

"而且说实话,要让这整套自动化跑起来,就离不开一个'在回路里'的过码环节、有 Claude 在那儿回应——它回应起来很有'表演感',但关键是它真在修东西。"

"That's a big part of what used to take so much time. Why PRs would take so long to merge is: you'd have to check out the branch locally, fix a lint error, run the linter locally, then push it back up. There's all this switching cost that's constantly there."

"这正是过去最耗时间的一块。以前 PR 之所以迟迟 merge 不了,是因为你得把分支 checkout 到本地、修一个 lint 报错、在本地跑一遍 linter、再 push 回去——这中间一直有大量的切换成本。"

"So I think this is an especially good use case for LLMs, because otherwise it just takes up so much time to ship."

"所以我觉得这是 LLM 一个特别合适的场景,因为不这么干的话,光是把东西发出去就要耗掉太多时间。"

"And I guess especially for the Bun codebase, because it's systems code — it's very easy to repro an issue and then see if it's fixed, which is back to this verification loop we were talking about."

"而且 Bun 这套代码尤其合适吧,因为它是系统级代码——复现一个问题、再看它修没修好,都特别容易,这又回到我们刚才说的那个验证回路上了。"

"Yeah. It's all systems code, so it's really like a test case on a particular architecture, and you can essentially repro or verify anything."

"对。它全是系统级代码,所以本质上就是某个架构上的一个测试用例,基本上你想复现什么、验证什么都行。"

"One thing that makes it easier in Bun's codebase is that it's a CLI tool — we don't need to run a browser to test things. But you could also set something up to take a screenshot or record a video. In Bun's case we don't need that, at least not yet."

"Bun 这套代码还有一点让它更省事:它是个 CLI 工具——测东西不用起浏览器。当然你也可以配个东西去截图、录视频。Bun 这边暂时不需要,至少现在还不用。"

"This is specifically for Bun, but the more generalizable thing — because most products aren't open source — is that instead of an issue, maybe the starting point is a customer support ticket."

"这套是专门给 Bun 的,但更能推广的一点是——因为大多数产品并不开源——也许起点不是一条 issue,而是一张客服工单。"

"You could imagine automatically passing customer support tickets to a Claude bot, which goes and reproduces the issue, submits a PR, and then has code review go back and forth. That's where, for a lot of companies, it becomes a lot more impactful — because it saves so much developer time."

"你可以想象:把客服工单自动丢给一个 Claude bot,它去复现问题、提 PR,然后让过码 bot 来回过几轮。对很多公司来说,真正发挥威力的就是这一块——因为它能省下太多工程师的时间。"

"We should think of some kind of name for this pattern. It's like adversarial code review or something."

"我们真该给这个模式起个名字。有点像'对抗式过码'(adversarial code review)之类的。"

"Yeah, I don't know. [laughs]"

"哈哈,不好说。"

"There are a few other things about this. If you just do this, then it doesn't quite work. The very first step you need is to make sure the development environment is set up."

"这套东西还有几个点。光是照搬上面那套,其实跑不太起来。你需要的第一步,是先把开发环境配好。"

"This has been talked about before, but CLAUDE.md is very important — otherwise it's just going to submit PRs that don't quite make sense for you to merge."

"这点之前也有人讲过,但 CLAUDE.md 真的很关键——不然它提上来的 PR 就会是那种'你根本没法 merge'的东西。"

"So in Bun's codebase we very much emphasize that it runs this special command to do the build. This both builds and runs the command — it forwards the arguments."

"所以在 Bun 的代码里,我们特别强调要用一条专门的命令来做 build。这条命令既负责编译、又负责执行——它会把参数透传过去。"

"Because one confusing thing is, since Bun has to be compiled, you want to make sure it's running the actual changes and not a stale debug build."

"因为有个容易踩坑的点:Bun 是要编译的,你得确保它跑的是你这次真正改过的代码,而不是一个过期的 debug build。"

"We also go into a lot of detail about how to run tests, how to write tests, where to put the test, and a lot of 'here are all the issues we've run into previously.'"

"我们还写得很细:测试怎么跑、怎么写、放在哪,以及一大堆'我们以前踩过的坑都在这'。"

"Basically the pattern is: every time you find yourself repeating something, it should probably go in CLAUDE.md."

"基本上规律就是:每当你发现自己在重复说同一件事,它大概率就该写进 CLAUDE.md。"

"Because the question now is: how do you make it maintainable to have lots of Claudes running all the time? To do that, it needs to be written down. It needs to be documented."

"因为现在的问题变成了:你怎么让'一大堆 Claude 一直在跑'这件事是可维护的?要做到这点,它就得被写下来、被文档化。"

"A really small detail: we make it print the error message before the less informative conditions, just to make sure Claude actually sees the error message."

"一个很小的细节:我们让它把错误信息打印在那些'信息量更低的判断'之前,就为了确保 Claude 真的能看到这条错误信息。"

"So this is sort of like — you have Claude write a test, and then the test is bad, or something about it doesn't work, and you see this repeated once or twice."

"所以这有点像——你让 Claude 写个测试,结果测试写得不好,或者某个地方就是不对,然后你发现这种情况重复出现了一两次。"

"And then you just tell Claude, 'add it to the CLAUDE.md,' so that every time in the future when you write a test, you do it correctly the first time."

"于是你就直接跟 Claude 说'把这条加进 CLAUDE.md',这样以后每次写测试,第一遍就能写对。"

"Yeah. So this is like compound engineering — it's kind of this."

"对。这就有点像所谓的 compound engineering(复利式工程)——大概就是这个意思。"

"It's also helpful to give it an overview of where all the folders are, how the code is laid out, and about dependencies."

"另外,给它一份概览也很有用:所有目录在哪、代码是怎么组织的、依赖是什么情况。"

"Another thing I think is interesting is making sure it can read your CI errors and build logs."

"还有一点我觉得挺有意思:确保它能读到你的 CI 报错和 build 日志。"

"You want to set up the agent to do the full loop — writing the code, testing that the code works, checking CI, monitoring CI, and reading all the errors — so that by the time it gets to a person, everything is set up."

"你要把这个 agent 配成能跑完整个回路——写代码、测代码能不能跑通、查 CI、盯着 CI、把所有报错都读一遍——这样等它交到人手上时,一切都已经就绪了。"

"The ideal is that you read the code and you have very clear indications that you can be high-confidence to merge it. And the only way for that to be true is if it's set up for success."

"理想状态是:你读一遍代码,就能有非常明确的信号,让你有底气高置信地 merge。而要做到这一点,唯一的办法就是事先把它'配置成能成功'。"

"It's interesting. I remember when we first met, you were talking about your vision of everyone being able to run hundreds of agents in parallel, and how that would work. And I feel like I didn't really get it at the time."

"挺有意思的。我记得我们刚认识那会儿,你就在讲你的设想:每个人都能并行跑几百个 agent,以及那会是什么样子。说实话,我当时没太 get 到。"

"Although now, every single night, I'm running hundreds of agents. And I feel like now I'm finally there. But this is a thing you've been thinking about for a long time."

"可现在呢,我每天晚上都在跑几百个 agent。我感觉自己总算到那个状态了。而这件事,你已经琢磨了很久了。"

"So it feels like this is sort of the setup in order to scale up agents way more — you need the self-verification so that agents can run autonomously."

"所以感觉这套配置,正是把 agent 规模再往上拉的前提——你必须有自验证能力,agent 才能自主地跑。"

"Yeah. This has gone through many iterations in Bun's codebase. We previously just had a Discord bot where I could @-mention the bot and it would spin up a container."

"对。这套东西在 Bun 的代码里迭代了很多版。一开始我们就是个 Discord bot,我 @ 一下它,它就起一个容器。"

"It didn't have the CI stuff, it didn't have the code review stuff. And it's so much better now, especially with Opus 4.7. All this stuff is getting so much better."

"那时候它没有 CI 那一块,也没有过码那一块。现在好太多了,尤其是有了 Opus 4.7。这一整套都在变得越来越好。"

"Oh yeah, we can also check on how it's going. It looks like it created a PR — the first one. And it wrote tests."

"对了,我们也可以看看刚才那几个跑得怎么样。看起来它已经开了一个 PR——第一个。而且写了测试。"

"So maybe while we look at this — I'm curious, just to get a show of hands from people in the room."

"那趁我们看这个的工夫——我挺好奇的,想让在座各位举个手。"

"As you think about your development process, raise your hand if it looks something like this: you have a bunch of terminal windows or desktop tabs and you're pasting in issues. Okay — so that's maybe half of people."

"想想你自己的开发流程,如果它长这样的话请举手:你开着一堆终端窗口或者桌面标签页,在里头一条条粘 issue。好——大概一半人。"

"And what if it looks more like RoboBun, where it's closing the loop a little more? … It's the next level of abstraction — starting to get there."

"那如果更像 RoboBun 这样、把回路闭合得更彻底一点呢?……嗯,这是下一层抽象——大家开始往那边走了。"

"Yeah, I think it's not surprising, because model capabilities are just getting there. I think 4.7 is the first model where it's really felt like it's able to do this."

"对,我觉得这不奇怪,因为模型能力刚好到了这个点。我觉得 4.7 是第一个让人真切感到'它能干这个'的模型。"

"In the past, maybe you could do it with a bunch of scaffolding — you just throw a bunch of tokens at it and it kind of works. But now it's efficient enough that you can actually do this day-to-day."

"以前你或许靠堆一大堆脚手架也能凑合做——就是往里灌一堆 token,它勉强能跑。但现在它效率足够高,你真的可以拿来当日常用了。"

"Let's see — so the first PR is there. Let's see if it did any others. Okay, it did two PRs. This looks very plausible."

"我们看看——第一个 PR 出来了。再看看它有没有干别的。好,它提了两个 PR。这个看起来挺像样的。"

"It's cool. And this before/after — do you tell it to do that, or sometimes it just does it?"

"挺酷的。这个 before/after 的对照——是你让它这么做的,还是它有时候自己就做了?"

"It's pretty good about knowing when it should do that — like when it's a string-formatting thing. It also kept Bun's style of the label, which is good, because Node's style is slightly different."

"它挺会判断什么时候该这么做的——比如涉及字符串格式化的时候。而且它还沿用了 Bun 风格的那个 label,这点不错,因为 Node 的风格跟它略有不同。"

"Let's see, does this change look good? Mostly what I'm thinking right now is — it did this, and this is good, because you don't want to write one byte at a time, you want to write in chunks."

"我看看,这个改动行不行?我现在主要在想的是——它这么写了,这点不错,因为你不会想一次只写一个字节,你想成块地写。"

"And then it used saturation to… but I don't like that, or it shouldn't have to do that. Does anyone here actually know Zig? [laughs]"

"然后它用了 saturation(饱和处理)来……但我不太喜欢那样,或者说它本来不该需要这么干。在座有人是真懂 Zig 的吗?[笑]"

"Looking at this code, you can see it followed the patterns from the CLAUDE.md — await using, and that pattern of resolving all the promises at the same time."

"看这段代码,你能看出它照着 CLAUDE.md 里的模式来写——await using,还有那种'把所有 promise 同时 resolve'的写法。"

"So what's your workflow when you see something like this — are you usually going in and commenting, or are you just going to wait for code review to come in and drop a comment?"

"那你看到这种东西时的工作流是怎样的——你一般会自己进去留言,还是干脆等过码 bot 进来留评论?"

"Usually it depends on how complicated it is. In this case, this one is actually pretty simple — I feel pretty high confidence that if the tests pass, I'd probably merge this."

"一般看它有多复杂。这一个其实挺简单的——我有挺高的把握:只要测试过了,我大概就会 merge。"

"But I'd still wait for the code review — at least for the Claude code review one to run — just in case. Because what I really like about that is it'll find things that aren't in the diff, that come from tracing the control flow."

"但我还是会等过码——至少等 Claude 那个过码跑完——以防万一。因为我特别喜欢它的一点是:它能发现 diff 里看不到的问题,那些是顺着控制流追出来的。"

"Which is what you want when it's a human reviewing it — somebody who has a lot of context, who can think: what are all the edge cases this might run into?"

"这正是人来 review 时你想要的——一个有大量上下文的人,能去想:这玩意儿可能撞上哪些边界情况?"

"And the signal-to-noise ratio is pretty good — maybe like 10% of the time it's wrong. For how that used to be with other code review products we've tried, it was basically: you had to ignore most of what it said. It's pretty cool."

"而且它的信噪比相当好——大概只有 10% 的时候是错的。对比我们试过的其他过码产品,以前基本上是:它说的话你大部分都得忽略。现在这个挺酷的。"

"How long has something like this worked? Is it a latest-model thing? Or have you had RoboBun — this automated repro, automated fixing, this whole pipeline — how long has that actually been possible?"

"这种东西能用多久了?是最新模型才有的吗?还是说 RoboBun——这套自动复现、自动修复、整条流水线——其实已经能跑挺久了?"

"We can probably see this in a chart somewhere. That's kind of a lot of commits — but that might not be on main, that might be the Rust thing."

"这个大概能在某张图里看出来。这提交量挺多的——不过那可能不是 main 上的,那可能是 Rust 那摊事。"

"Yeah, I heard Bun is going to be written in Rust soon. Is that…?"

"对,我听说 Bun 不久之后要用 Rust 重写。是真的吗……?"

"I don't know. I just have a Claude running, and we'll see what happens. [laughs]"

"我也不知道。我就是挂了个 Claude 在跑,看看会发生什么。[笑]"

"But you can see the volume of commits there — it's kind of lower, and then it's definitely gotten up a lot."

"但你能看到那边的提交量——前期偏低,后来明显涨了一大截。"

"Now really the bottleneck is: do I feel good about merging this? Am I confident that its changes are correct? And that's new — because it used to be the code wasn't good enough."

"现在真正的瓶颈是:我敢不敢放心地 merge 这个?我有没有把握它的改动是对的?这是个新现象——因为以前的瓶颈是代码本身还不够好。"

"What do you think is left? Is there a missing tool, or a missing model capability or version, for you to feel like RoboBun can fully close the loop — issue comes in, and then the fix goes out automatically?"

"你觉得还差什么?是缺某个工具,还是缺某种模型能力、某个模型版本,才能让你觉得 RoboBun 可以彻底闭环——issue 一进来,修复就自动发出去?"

"I think it needs a little bit more. It takes a lot of time to verify the changes are correct. This was kind of already true when it's a person pushing up a PR."

"我觉得还差一点。验证改动是否正确,本身就很花时间。其实这一点在'是人来提 PR'的时候就已经成立了。"

"The challenge is: how do we communicate sufficient proof that the changes are correct? Or make it easier to roll things back. Those are kind of the two directions."

"难点在于:我们怎么把'改动是对的'这件事的足够证据传达出来?或者,怎么让回滚更容易。大致就是这两个方向。"

"But for the majority of simple issues, we should probably be pressing merge a lot more. And the bottleneck now is actually CI — making sure all the test stuff works."

"但对大多数简单的 issue,我们其实应该更频繁地按 merge 才对。而现在的瓶颈,反倒成了 CI——确保所有测试那一套都正常跑通。"

"But I think it's basically there. The large projects are still non-trivial, but I've been doing some pretty large PRs lately with Claude — mostly with Claude Code, not as much with RoboBun."

"但我觉得基本上到位了。大项目当然还是不轻松,不过我最近用 Claude 做了一些挺大的 PR——主要是用 Claude Code,RoboBun 用得没那么多。"

"Like we recently added support for a built-in image processing library to Bun. I could probably pull up the PR — and that was Claude. We also did a bunch of follow-up PRs."

"比如我们最近给 Bun 加了一个内置的图像处理库。我大概能把那个 PR 调出来——那就是 Claude 做的。后续我们还跟着做了一堆补丁 PR。"

"It's interesting, because when I look at different people using Claude Code, everyone is at a different level of sophistication or adoption."

"挺有意思的,因为我看不同的人用 Claude Code,大家所处的成熟度、采用程度都很不一样。"

"For me the hardest thing is the model changes very often, so I have to constantly retune and recalibrate to what it can do. As an engineer it's hard, because it's a very weird technology — it's the first technology I've used that's like that."

"对我来说最难的是模型变得很频繁,所以我得不断重新调校、重新校准它的能力边界。作为工程师这挺别扭的,因为它是一种很怪的技术——是我用过的第一个这种技术。"

"And I sort of feel like the way you do it is actually ahead of how the Claude Code team does it for Claude Code itself. The way the Claude Code team does it is very automated — but this is even further ahead, almost like full liftoff, fully closed loop."

"而且我隐隐觉得,你这套玩法其实比 Claude Code 团队自己开发 Claude Code 的方式还要靠前。Claude Code 团队的方式已经很自动化了——但你这个更超前一步,几乎是'完全起飞'、彻底闭环了。"

"Like in the last two weeks we've added an HTTP/3 server to Bun. There's a PR for an HTTP/2 server. There's fetch support for HTTP/3 and HTTP/2. There's this image processing API."

"就拿过去两周来说,我们给 Bun 加了一个 HTTP/3 服务器。还有一个 HTTP/2 服务器的 PR。还有给 fetch 加上 HTTP/3 和 HTTP/2 的支持。还有这个图像处理 API。"

"There's the ongoing Rust rewrite, which may not ship — that's the most ambitious one I've done so far. And 'done' is too strong a word, because it's very much not done."

"还有正在进行的 Rust 重写,这个不一定会发布——那是我目前为止做过最有野心的一个。而且'做过'这个词都太重了,因为它远没完成。"

"And even something like this — this is a benchmark. So Claude ran this benchmark for you?"

"甚至像这种——这是个 benchmark。所以这个 benchmark 是 Claude 帮你跑的?"

"Yeah, Claude ran this benchmark. This ran on a separate Linux box. And I was like, 'make it faster than sharp,' and that's basically what it did."

"对,这个 benchmark 是 Claude 跑的。它是在一台单独的 Linux 机器上跑的。我就跟它说'把它做得比 sharp 还快',然后它基本上就做到了。"

"I gave it a few ideas, like 'you could read this code in JavaScriptCore to figure out how to avoid cloning the typed array when it's not strictly necessary.' But then it went and did it and figured it out."

"我给了它几个思路,比如'你可以去读 JavaScriptCore 里这段代码,搞清楚在非必要时怎么避免克隆 typed array'。然后它就真的去做、自己琢磨出来了。"

"It's pretty crazy, honestly, because none of this would have worked several months ago."

"说实话挺疯的,因为这些东西放在几个月前根本跑不通。"

"Yeah. I feel like within Anthropic, within an AI lab, you call this kind of thing hill climbing. The idea is that if you give the model some sort of metric and a way to verify its result, you can just make it iterate and keep going until it hits that metric."

"对。我感觉在 Anthropic 内部、在一个 AI 实验室里,这种事我们叫 hill climbing(爬山)。意思是:只要你给模型一个指标、再给它一种验证结果的方式,你就能让它不停迭代、一直往前,直到撞到那个指标为止。"

"And this is something 4.7 is uniquely good at. I think it's really underutilized, because it's the first model that's actually very good at that."

"而这正是 4.7 格外擅长的一件事。我觉得它被严重低估了,因为它是第一个真正很擅长这个的模型。"

"If you just give it a target, a way to improve the performance, and a way to measure, it'll just keep going until it's done — if you let it go in auto mode."

"只要你给它一个目标、一条提升性能的路子、再加一种测量手段,它就会一直干到完成为止——前提是你让它在 auto mode 里放手跑。"

"Yeah. And this is another case where the code review comments were really helpful — because in this PR there are like 100 comments or something, and it's just going and fixing everything."

"对。这又是一个过码评论帮了大忙的例子——因为这个 PR 里有差不多 100 条评论,而它就一条条去把所有问题都修掉。"

"It goes on for a while, and in the meantime you're just working on something else. This was not the thing I was 100% focused on — I was maybe 10% focused on this. I was doing like five things at once."

"它会持续修挺久,而这段时间你就去忙别的。这事我当时根本没全神贯注——大概只分了 10% 的注意力在上面。我是同时在干五件事。"

"And this definitely wasn't possible six months ago. Three months ago — this is very recent that this is doable."

"这个在六个月前是绝对做不到的。三个月前也不行——能做成这事是非常近期才有的。"

"Okay, so how are our sessions doing? We have one PR there. There's almost another PR coming up, it looks like, pretty soon. This one should be the trickiest one."

"好,我们那几个会话跑得怎么样了?这儿有一个 PR。看样子马上又要冒出来一个 PR 了。这一个应该是最棘手的。"

"It mostly looks good — or it looks plausible based on these changes. I wouldn't exactly do it this way; I think we need a better, more optimized way to do this, because that's a lot of checks."

"大体上看着不错——或者说从这些改动看是像那么回事的。我自己不会完全这么写;我觉得我们需要一种更好、更优化的做法,因为这里要做的检查太多了。"

"And looking at your setup here — you mostly use the CLI?"

"看你这套配置——你主要是用 CLI?"

"Yeah."

"对。"

"And do you always use auto mode for permissions?"

"权限那块,你一直都用 auto mode?"

"Auto? Yeah. And before that I used --dangerously-skip-permissions."

"auto?对。在那之前我用的是 --dangerously-skip-permissions(危险地跳过权限)。"

"[laughter] No — you guys can delete stuff if you do that. I think I'm not supposed to recommend that."

"[笑] 别——你们这么干是会把东西删掉的。我应该是不该推荐那个的。"

"But it's just not fun to wait for Claude to press approve, because then you go off and do something else, and it's just been sitting there."

"但等 Claude 那边按'同意'实在太难受了,因为你一转头去干别的,回来发现它就一直干等在那儿。"

"So that's why auto mode is really good — it's actually a real way to fix that, instead of just trusting [blindly]."

"所以 auto mode 才特别好——它是真正解决这个问题的办法,而不是靠你去盲目信任。"

"And I also noticed the input — the little composer — is stuck to the bottom of the screen. So you're using no-flicker mode."

"我还注意到那个输入框——那个小 composer——是固定贴在屏幕底部的。所以你开了 no-flicker(无闪烁)模式。"

"Yeah, I'm using no-flicker. Honestly, I think we should just make that the default, because it's so much better."

"对,我用的是 no-flicker。说真的,我觉得干脆把它设成默认得了,因为体验好太多了。"

"You can see I can scroll really fast — you could scroll fast before, but sometimes there'd be a flicker, and now there's not."

"你看我能滚得飞快——以前也能滚得快,但偶尔会闪一下,现在不会了。"

"Have folks tried no-flicker mode for Claude? … A few people. So we launched it on April Fools — so you can imagine, [laughter] in hindsight it came across as a joke a little bit."

"在座有人试过 Claude 的 no-flicker 模式吗?……几个人。我们是在愚人节那天发布它的——所以你能想象,[笑] 事后看,它确实有点像个玩笑。"

"But if you actually use Claude Code, no-flicker equals one Claude. So just set that environment variable."

"但如果你真在用 Claude Code,no-flicker 等于多一个 Claude(意思是体验上的净赚)。所以把那个环境变量设上就行。"

"We totally rewrote the renderer that's running in the CLI, so it's using virtualized scrolling and virtualized selection. What this means is constant memory usage, constant CPU usage —"

"我们把 CLI 里跑的那个渲染器彻底重写了一遍,现在它用的是虚拟化滚动、虚拟化选区。这意味着内存占用恒定、CPU 占用恒定——"

"— and also some nice stuff, like if Jarred types, he can actually click around the composer. So mouse events work, which is pretty crazy for a terminal."

"——还附带一些好东西,比如 Jarred 打字的时候,他真的能在 composer 里点来点去。也就是说鼠标事件是生效的——这对一个终端来说挺离谱的。"

"So I'm also just having it monitor the PR. You can see it ran some commands, and then it's going to go to sleep for 20 minutes and wake back up. 20 minutes is probably a little too long, but it's okay."

"我还顺手让它盯着这个 PR。你看它跑了几条命令,然后它准备睡 20 分钟、到点再醒过来。20 分钟可能稍微久了点,不过无所谓。"

"And what's that — is that using like a loop or something?"

"那是啥——它是在用某种循环吗?"

"I think so. And let's see how else it's doing — the other ones are still… apparently it fixed an extra bug as well."

"应该是。再看看它别的进展——其他那几个还在……看样子它还顺手多修了一个 bug。"

"Okay, so it's been what — like 25 minutes, and we got one? How many PRs have we gotten? Three PRs. That's not bad."

"好,这才过了——大概 25 分钟,我们就拿到一个?一共出了几个 PR 了?三个 PR。还不赖。"

"Yeah. And I think we'll get a fourth one once it finishes running the tests. In the meantime, RoboBun is still running and generating even more PRs — every time somebody submits an issue, it tries to reproduce it."

"对。等它把测试跑完,我觉得还会有第四个。与此同时,RoboBun 还在跑、还在生成更多 PR——每次有人提 issue,它就去试着复现。"

"I kind of feel like the way Claude Code makes you think is: every time there's a new bottleneck, you have to automate that bottleneck, and then there's always some other bottleneck after, and you move on to that."

"我有种感觉,Claude Code 会把你的思维方式改成这样:每出现一个新瓶颈,你就得去把那个瓶颈自动化,然后后面总会又冒出另一个瓶颈,你再接着去解它。"

"It started — writing code was the bottleneck, and now it's no longer the bottleneck. Then verification and running tests was the bottleneck, and now it's no longer the bottleneck. And now there's like a deeper layer of verification. Maybe that's it."

"一开始——写代码是瓶颈,现在它不再是瓶颈了。然后验证和跑测试是瓶颈,现在也不再是了。而现在,出现了一层更深的验证。也许就是它了。"

"What do you think are the bottlenecks remaining?"

"你觉得还剩哪些瓶颈?"

"It's definitely this deeper layer of verification. And I feel like the bottleneck after that is going to be planning — like what should we do, what should we not do, and what is the right way to fix this."

"肯定是这层更深的验证。而我觉得再往后的瓶颈会是规划(planning)——比如什么该做、什么不该做,以及这事到底怎么修才对。"

"Ideally Claude would be smart enough, or we could trust Claude enough, to merge the PRs by itself. In certain projects you could probably do that, and just have it be completely automatic. Bun is not yet there."

"理想情况下,Claude 会聪明到、或者我们会信任它到——它能自己把 PR merge 了。在某些项目里你大概已经能这么干、让它彻底自动化。但 Bun 还没到那一步。"

"But it'd be really cool if we had the tooling for us to feel confident enough to do that."

"不过要是我们有那种工具、让我们有足够底气这么做,那会很酷。"

"So right now RoboBun doesn't build features? It doesn't do feature requests yet?"

"所以现在 RoboBun 不做功能开发?它还不接 feature request?"

"That's true. It doesn't do feature requests, but we do also use it sometimes. We can @-mention it in either Discord or Slack and it'll try to implement the feature."

"是的。它不接 feature request,但我们偶尔也会用它来干。我们可以在 Discord 或 Slack 里 @ 它,它就会去试着把那个功能实现出来。"

"Sometimes when people are like 'hey, Bun is missing this thing,' I just @-mention the bot, and maybe an hour later there's a PR. A bunch of times somebody's tweeted at me 'can you fix this bug?' — and that's basically what I do, and then I reply with a link to the PR. Should we add a RoboBun account on Twitter?"

"有时候有人说'欸,Bun 缺这个功能',我就直接 @ 一下 bot,可能一小时后就有个 PR 了。好多次有人在 Twitter 上 @ 我'你能修下这个 bug 吗?'——我基本上就这么干,然后回他一个 PR 链接。我们是不是该给 RoboBun 开个 Twitter 账号?"

"And I think it can do feature requests, but I'm hesitant for it to implement literally everything anybody asks for in a GitHub issue, because that's kind of a lot."

"我觉得它是能做 feature request 的,但我有点犹豫要不要让它把 GitHub issue 里任何人提的东西照单全收地实现出来,因为那量太大了。"

"In some ways it's kind of crazy to put something like an image processing library inside Bun — but we talk about engineering taste, and there's an element of taste that goes into that."

"某种意义上,把图像处理库这种东西塞进 Bun 里挺疯的——但我们常说工程品味(engineering taste),这里面是有品味成分的。"

"You felt like that's a good idea, and we're not sure yet if Claude is at the point where it would also think this is a good idea. But at some point in the future it'll get there — maybe it's starting to."

"是你觉得这是个好主意,而我们还不确定 Claude 是否到了'它也会觉得这是个好主意'的程度。但将来某个时候它会到的——也许已经开始了。"

"And I do think PRs become suggestions. Not merging a PR used to be like — you feel bad if you don't merge a coworker's PR, because they put work into it. But you don't have to feel bad when it's Claude."

"而且我确实觉得,PR 会变成一种'建议'。以前不 merge 一个 PR 是会有心理负担的——同事提的 PR 你不合,会过意不去,因为人家花了功夫。但换成是 Claude,你就不必有这种负担。"

"So if the PR is wrong, or for whatever reason, you can just not merge it. But it does mean the bar for what you merge — with people, you don't want them to feel bad about their lost work. So in some ways it actually ends up raising the bar for what you decide to merge."

"所以 PR 要是错了,或者出于任何别的原因,你直接不合就是了。但这也意味着 merge 的门槛——跟人合作时,你不想让人因为白干一场而难受;而在这里,反倒最终把你决定 merge 的标准抬高了。"

"Yeah, it's interesting how, as the bottlenecks move, the dynamics change a little bit. It's sort of like having to trust each other, having to trust people on the team — that changes a little. Now it's a little more about: do we have the right automation, and do we trust automation as a group?"

"对,有意思的是,随着瓶颈不断移动,团队里的相处方式也会跟着变一点。它有点像'要彼此信任、要信任团队里的人'——这件事变了点味道。现在更多是在问:我们有没有对的自动化?我们作为一个团队,信不信得过这套自动化?"

"So I think we're almost at time. Is there maybe one last thing we want to show people, where we can check in on the progress we've made?"

"时间差不多了。要不要最后再给大家看一样东西,顺便看看我们刚才的进展?"

"It's still going — one last one, onto that fourth PR, and it's going back and forth, like found a bug and then fixed a bug. Looks like it's about to submit the PR now."

"它还在跑——最后一个,正在弄第四个 PR,来回拉扯,像是发现一个 bug、又修一个 bug。看样子马上就要提 PR 了。"

"Okay, let's wait for this one. Love to have one more."

"好,我们等这个。要是能再多一个就好了。"

"This is the cool thing about auto mode — in auto mode I can let Claude run for hours and hours at a time. I run it almost every night; I'll just have a bunch of Claudes running in auto mode."

"这就是 auto mode 最酷的地方——在 auto mode 里,我能让 Claude 一口气连跑好几个小时。我几乎每晚都跑;就挂一堆 Claude 在 auto mode 里跑着。"

"Before this, it just didn't work, because it always got stuck at some kind of permission request. And that was crazy."

"在这之前,这套根本跑不起来,因为它老是卡在某个权限确认上。那真的很抓狂。"

"Like this entire thing was one prompt, and that just ran for 30 minutes. This is all I said."

"你看,这一整套就只是一句 prompt,然后它自己跑了 30 分钟。我就说了这么一句话。"

"Okay, so it's pushing — it's about to submit the PR."

"好,它在 push 了——马上要提 PR 了。"

"That sounds like the right fix, too. This has been an issue that's been open for a long time."

"而且这听起来确实是对的修法。这个 issue 已经 open 很久了。"

"Okay, and we got a PR. We can go to this issue and see how many upvotes it has. 20. Yeah, it's kind of a lot."

"好,PR 出来了。我们点进这个 issue,看看它有多少个赞。20 个。嗯,挺多的。"

"Cool. Maybe we can pause there. But to me, this is just such a cool vision of where engineering is going, I think, for everyone in this room."

"酷。我们就停在这儿吧。但对我来说,这正是工程未来走向的一幅特别酷的图景——我觉得对在座每个人都是。"

"We're going to see this first — we're going to have to figure it out first, and then everyone else is going to have to figure this out too. Like we were talking about this morning, [I'm] just excited to be on this journey together."

"我们会最先看到它——我们得先把它搞明白,然后其他所有人也都得把这事搞明白。就像我们今早聊的,我特别高兴能一起踏上这段旅程。"

"And you can see, we haven't figured everything out yet. But the mode we're in is just constantly experimenting, constantly trying to see what the next bottleneck is, so we can solve it."

"而且你也看到了,我们还没把一切都搞定。但我们现在的状态就是:不停地试、不停地去看下一个瓶颈在哪,好把它解掉。"

"It's very exciting. This is so cool — like, this stuff. [applause]"

"非常令人兴奋。这太酷了——就这些东西。[掌声]"