Software Engineering Is Becoming Factory Engineering — Zach Lloyd, Warp

频道: AI Engineer
视频: https://www.youtube.com/watch?v=tUPPVhBBcoM
原文语言: en
统计: 共 18 轮 · Zach 14 · 观众 2

[0:01] Zach

[music] Okay. Hello everyone. Uh, I'm excited to be here. Uh, my name is Zach Lloyd. Um, today I'm going to be talking about self-improving software factories, the new open-source model, and basically what I think is happening to development. A little bit about me just to begin. So I am a former uh principal engineer from Google. Used to lead engineering on the Google Doc Suite. I've been an engineer now for over 20 years. Long time. I am still uh shipping frequently, but I haven't written a line of code in the last six months. Uh and I'm the founder of a company called Warp. Uh Warp, if you're not familiar, is a open-source agentic development environment. Uh you may know us as a terminal. That is how the company started. We're basically a terminal that has agents built in. Uh we open sourced it a couple months ago and I'm going to talk a little bit about that experience and the motivation for it. It's popular open source project over 60,000 GitHub stars. We've had a couple hundred people contributing. We have over 800,000 active developers who are using warp. And increasingly we are focused not just on the terminal aspect and the interactive aspect of development but more so on how do you automate development. I'm going to talk mostly about that.

好，大家好。很高兴来到这里。我叫 Zach Lloyd。今天我要讲的是自我改进的软件工厂、新的开源模式，以及我眼中软件开发正在经历的变化。先简单介绍一下我自己。我以前是 Google 的 principal engineer（首席工程师），曾带领 Google Docs 套件的工程团队。我当工程师已经 20 多年了，挺久的。我现在依然在频繁地交付，但过去六个月里我一行代码都没写过。我还是一家叫 Warp 的公司的创始人。如果你不熟悉的话，Warp 是一个开源的 agentic 开发环境。你们可能是通过终端知道我们的，公司也确实是从终端起家的——我们基本上就是一个内置了 agent 的终端。我们几个月前把它开源了，待会儿我会聊聊这段经历，以及当初为什么这么做。这是个挺受欢迎的开源项目，GitHub star 超过 60,000 个，已经有几百人参与过贡献。使用 Warp 的活跃开发者超过 800,000 人。而且我们的重心越来越不只放在终端、放在开发中交互的那一面，而是更多地放在：怎么把开发自动化。今天我主要就讲这个。

[1:33] Zach

So the thesis that I have uh is that the discipline of software engineering is going to become something more like factory engineering. And I'll explain what I mean by this in a minute but just keep that in mind. That's that's what I think is going to happen. Um, if you look at development over the past couple years, it's I mean it's crazy how it's changed. We've gone from a world of chat and AI autocomplete cursor co-pilot to the phase that we're in now, which I consider to be mostly interactive agents. So you're sort of sitting at your computer and you are telling cloud code to do something, you're telling warp to do something. And I believe what's going to happen over the next six months, a year, hard to predict the pace, is that we're going to move much more towards a world of automation. But before I get into that, just quick show of hands. How many folks in here are building with agents? Every 100% makes sense. Uh how many how many folks are building typically with multiple agents at one time? So again, almost everyone. How many people are running an agent right now? I'm not offended. I would. Okay, that's totally cool. I would be doing it too. Uh, how many folks are running agents in the cloud out of curiosity?

我的核心论点是：软件工程这门学科，会变得更像工厂工程。这是什么意思我待会儿再解释，大家先把这句话记在心里——这就是我认为将要发生的事。回看过去这两年的开发，变化之大简直疯狂。我们从聊天加 AI 自动补全的世界——Cursor、Copilot 那一套——走到了现在这个阶段，我认为现在主要是交互式 agent 的阶段：你坐在电脑前，让 Claude Code 去做点什么，让 Warp 去做点什么。而我相信，在接下来的六个月到一年里——节奏很难预测——我们会大步迈向一个自动化的世界。不过展开之前，先快速举个手：在座有多少人在用 agent 做开发？所有人，100%，合情合理。有多少人平时会同时开好几个 agent 一起干活？嗯，还是几乎所有人。有多少人此刻就有 agent 在跑？我不会介意的，换我也会。好，完全没问题，换我也这么干。好奇问一下，有多少人是在云端跑 agent 的？

[2:53] Zach

So, that looks like less than half, but still significant. Uh, and how many folks have have set up a system internally to automate the whole software development life cycle? So, everything from like triaging, specking, implementing, reviewing. So, I see some hands. So some people are doing this. So this is what's going to happen. Uh every project of significant size I believe is going to have something like this. Um and it's going to look kind of like this big loop. And everyone is talking about loops. There's nothing that complicated about loops. This loop says a cloud software factory. This loop could literally just say like the software development life cycle. It's the same thing. Um but just to go through this loop, it's like ideas are going to come in at the top. Agents are going to do triage. If something is complicated, they will write a spec. Uh these little blue boxes are where humans step in. Humans will review the spec. Uh agents will do the implementation. A human and agent will review the code. Agents will verify. Human will review the product. You ship and then you monitor and round you go. Uh and this is what software development for better or worse I think is going to end up looking like. So I repeat the thesis which is that if this is what software engineering is going to look like um software engineers are going to be the ones who end up building and managing these factories. [snorts] Now I promised at the beginning and I put in the title of the talk that I was going to talk about open source and so I want to do that for a few minutes. I'm going to take a quick digression. Um, I bring up open source because one of the main reasons that Warp opens sourced was to build uh build a public factory. Um, and so this is a picture of this website we've built called build.warp.dev which shows all of the issues that are flowing through our system and what state they're in, what agents are working on

看起来不到一半，但也相当可观了。那有多少人已经在内部搭了一套系统，把整个软件开发生命周期都自动化了？也就是从分诊（问题进来先判断归谁、怎么处理）、写规格文档（spec）、实现到评审的所有环节。嗯，我看到有人举手了，所以已经有人在这么做了。这就是接下来会发生的事。我相信每个有相当规模的项目都会有这样一套东西，它看起来大概就像这个大循环。现在人人都在谈循环，其实循环没什么复杂的。这个循环上写的是「云端软件工厂」，但其实直接写成「软件开发生命周期」也完全可以，是一回事。我们沿着这个循环走一遍：想法从顶部进来；agent 负责分诊；如果事情比较复杂，agent 会写一份 spec。这些蓝色小框是需要人介入的地方：人来评审 spec；agent 来做实现；人和 agent 一起做代码评审；agent 负责验证；人来评审产品。然后发布、监控，再转下一圈。不管是好是坏，我认为软件开发最终就会是这个样子。所以我再重复一遍论点：如果软件工程将来就是这个样子，那最终负责搭建和管理这些工厂的，就会是软件工程师。我在开头承诺过、演讲标题里也写了要聊开源，所以我想花几分钟讲讲这个，稍微岔开一下话题。我之所以提开源，是因为 Warp 开源的主要原因之一，就是为了建一座公开的工厂。这是我们做的一个网站的截图，叫 build.warp.dev，上面展示了在我们系统里流转的所有 issue、它们各自处于什么状态、有哪些 agent 在处理

[4:51] Zach

them, what contributors are working on them. And it's kind of like a protoactory done at scale. It's not working perfectly, but it is working. And one of the reasons we open sourced was to try to build this. Um, just in general, I think it's interesting to talk about open source in the time of agentic development. This is a really stupid graph, but it's like it just it you get it. It's like it's becoming much cheaper to build software. Um, a correlary of that is that it's becoming trivial to clone software. And so if you are in the software business, and I don't know how many folks in this room are in the software business per se, but it's very hard to build a software business if it's free to build software. It's hard to capture the value, especially if a competitor can clone. And so my big takeaway or big tip for everyone in here is that the first thing you should do is patent your code. I'm kidding. Don't This is a complete joke. [laughter] Don't don't don't do this. Uh my my first tip is obviously you need to have a great product. Uh this has always been the case. Um but I would say a great product probably was never enough. But even now more than ever, if you think that you're going to build a great software business just by building and shipping a great product, you're probably not going to succeed. Uh you need advantages beyond the product. And so those advantages could look like distribution ecosystem. It could be that you have a great brand or a data moat. You might have capital. Um, but if you're a startup, again, I'm coming from the startup world here, you just don't have these advantages. And so, you you still want to break through. Uh, and one of the ways that I suggest doing this is by building in the open. And so, to be clear, it took Warp five years of building closed to sort of make the leap into building in the open. And I'll explain why. But if you build in the open, um it helps build your ecosystem.

它们，以及有哪些贡献者在处理它们。它有点像一个规模化运转的工厂雏形（proto-factory）。运转得并不完美，但确实转起来了。我们开源的原因之一，就是想试着把这个东西建起来。总的来说，我觉得在 agentic 开发的时代聊开源挺有意思的。这张图真的很蠢，但你们懂的：开发软件正变得便宜得多。由此引出的一个推论是：克隆软件正变得轻而易举。所以如果你是做软件生意的——我不知道在座有多少人严格说来是做软件生意的——当开发软件不要钱的时候，要做成一门软件生意就非常难了。价值很难留在自己手里，尤其是竞争对手能直接克隆你的时候。所以我给在座各位的一大心得、一大建议是：你要做的第一件事，就是给你的代码申请专利。开玩笑的。别——这纯属玩笑。（笑）别别别，千万别这么干。我的第一条建议，当然是你得有一个很棒的产品，这一点向来如此。但我想说，光有好产品可能从来都不够；而现在比以往任何时候都更是如此：如果你以为只靠做出并发布一个好产品，就能建成一门出色的软件生意，那你多半不会成功。你需要产品之外的优势。这些优势可能是分发渠道、生态，可能是一个很强的品牌或者数据护城河，也可能是资本。但如果你是创业公司——再说一次，我是站在创业圈的角度说的——你根本没有这些优势。可你还是想突围。我建议的办法之一，就是公开建造（开源着做）。说清楚一点：Warp 是关起门来做了五年，才迈出这一步、转向公开建造的，原因我会解释。但如果你公开建造，它能帮你把生态建起来。

[6:55] Zach

It it can take you from being like hated on hacker news to like tolerated. Uh it can burnish your brand. It creates community. And so there's all these advantages to it. Uh and some of the things that I think have traditionally been a pain um can now be managed. And so like the traditional, you know, pain of open source might be something like you get a lot of noisy issues, you get sloppy PRs, you can end up in code review hell, you can end up having to spend a lot of time verifying changes. And so the solution, it's a kind of a long-winded way of getting to this for open source or at least for Warp in the case of open source. The thing that made us finally decide to do this was that we built a whole set of automations, really a software factory around managing the open-source project. And so, like I said, this is what I think the future is going to look like. I'm going to drill into it a bit just to get a little bit more technical for folks who want to try to build something like this for their own projects. So, what are the components of an effective software factory? uh it's really not that complicated to start or at a high level. You need a set of automations. You need a way of providing context and skills. You need a way of bringing humans in at the correct time.

它能让你从在 Hacker News 上招人恨，变成被人勉强容忍。它能擦亮你的品牌，能凝聚起社区。好处有这么多。而且我认为，一些向来让人头疼的事，现在也能管得住了。开源传统上的痛点大概是：你会收到大量噪音很大的 issue、粗制滥造的 PR，可能陷入代码评审地狱，最后还得花大把时间去验证各种改动。所以解决办法——我绕了一大圈才说到这儿——对开源来说，至少对 Warp 开源这件事来说，最终让我们下定决心这么做的，是我们搭了一整套自动化，其实就是一座围绕开源项目管理的软件工厂。所以就像我说的，我认为未来就会是这个样子。接下来我会稍微深入一点、讲得更技术一些，给那些想在自己项目里试着搭一套类似东西的人参考。那么，一座有效的软件工厂由哪些部分组成？起步阶段，或者说从高层来看，其实没那么复杂。你需要一套自动化；需要一种提供上下文和 skill 的方式；还需要一种在恰当时机把人拉进来的方式。

[8:16] Zach

So sort of like when things get stuck on the factory. And then a really important thing is you need some set of self-improvement capabilities. So think of this as loops. And if you do this right, uh, in the open source world, you can get a, you know, world where agents are helping contributors contribute. They're helping maintainers maintain. And I want to emphasize there's nothing special about open source here. I think every sizable project can benefit from this approach. And I I predict that every every company, every open source project will have at its core a software factory. kind of like the way that CI/CD became just like, oh, of course you have that. Uh maybe I don't know when that happened, 10 years ago. Let's tour the t uh the factory floor for a second here. So, you're not going to look at this. This is too much. Uh the the point of this slide is not to have you read the workflow. It's that the factory floor is basically a graph um of steps where you are defining like okay, how does software get built for my product? And it looks pretty similar for every product. Things come in, they flow through. Um, they get stuck at certain points. Um, and you know, broadly speaking, just to back out a second. So there's the inputs. The inputs are really ideas. Um, the inputs could be coming from your team, they could be coming from your users. Um, the inputs themselves tend to come in through certain channels that you should think about as like your task tracker is an obvious one or Slack, your teams, like your communication channels. They could come directly from like your terminal or IDE. They could come from your monitoring systems, but there's some set of inputs that bring work into the factory.

差不多就是工厂里有东西卡住的时候。另外还有非常重要的一点：你需要一套自我改进的能力，可以把它理解成循环。如果做对了，在开源世界里，你就能实现这样一种局面：agent 帮贡献者做贡献，帮维护者做维护。我想强调，这件事上开源并没有什么特别之处。我认为每个有一定规模的项目都能从这种做法中受益。我预测，每家公司、每个开源项目，核心都会有一座软件工厂——就像当年 CI/CD 变成了「那当然得有」一样。那是什么时候的事来着？我也说不准，大概 10 年前吧。我们来参观一下车间（工厂现场）。这张图你们不会细看的，信息量太大了。这页幻灯片的重点不是让你们读懂这个工作流，而是想说明：车间本质上就是一张由各个步骤组成的图，你在里面定义的是——好，我这个产品的软件到底是怎么造出来的？而且每个产品的这张图都大同小异：东西进来，往下流转，在某些环节卡住。我们先退后一步，从宏观上看。首先是输入，输入其实就是想法。输入可能来自你的团队，也可能来自你的用户。这些输入往往通过一些特定渠道进来，这些渠道值得你好好想一想：任务跟踪工具是最明显的一个，还有 Slack、你们团队的各种沟通渠道。输入也可能直接来自你的终端或 IDE，或者来自你的监控系统。总之，会有一组输入把活儿带进工厂。

[10:03] Zach

There's triage. This is a really important step. So again, I boil it down to something very simple, but like you want an agent that is looking at issues as they come in and just saying, you know, if this is easy and this is unambiguous, just implement it and this is how you can actually get going with a factory. If an issue is hard, uh I recommend having uh an agent that produces specs. Folks in here using spec driven development, show hands, people follow this. Okay, you can do this many different ways, but I think it's very effective. The way that uh we do it at Warp that I recommend is having an agent write what we call a product spec and a tech spec. Product spec describes the product invariance that you're building towards. Techsp spec describes the architecture and the shape of the code. Then you have an implementation agent. This is basically a coding agent that runs somewhere in the cloud. It makes a diff. You can use all sorts of coding agents for this. You have review. This is in many ways the most painful part. Like I expect that people are a little bit tired of reviewing a gentic slop. Uh I would have an agent do code review first and then it becomes over time like a riskmanagement exercise of like when do you bring in humans to do code review. But you want to have a step in here where humans can do it. This is a very important step uh for certain types of apps. The verification step. So this would be things like computer use.

接下来是分诊，这一步非常重要。我还是把它简化成一件很简单的事：你需要一个 agent 盯着新进来的 issue，然后判断——如果这个问题简单、又没有歧义，那就直接实现。想让工厂真正运转起来，就可以从这一步入手。如果 issue 比较难，我建议让一个 agent 来产出规格文档（spec）。在座有谁在用规格驱动开发？举个手。嗯，有人在这么做。好，这件事可以有很多种做法，但我觉得它非常有效。我们在 Warp 的做法——也是我推荐的做法——是让一个 agent 写两份东西，我们管它们叫产品规格（product spec）和技术规格（tech spec）。产品规格描述你要实现的产品不变量（invariants）；技术规格描述架构和代码的大致形态。然后是实现 agent，它基本上就是一个跑在云端某处的编码 agent，负责产出 diff。这一步你可以用各种各样的编码 agent。再往后是评审，这在很多方面都是最痛苦的一环——我估计大家都有点受够了评审 agent 生成的垃圾代码。我会先让一个 agent 做代码评审，之后随着时间推移，这就变成了一道风险管理题：什么时候该把人拉进来做代码评审。但你还是得在这里留一个能让人来评审的环节，对某些类型的应用来说，这一步非常重要。然后是验证环节，这里说的就是像 computer use（让 agent 直接操作电脑界面）这样的手段。

[11:35] Zach

Uh if you're building a a sort of UI, having the computer actually use the code that the agent produced and producing videos and screenshots. CI/CD still use it obviously. Uh and then monitoring. So agents don't stop in your factory when code is shipped. They should observe what's been shipped. Is it crashing? Is it being used? and round and round you go because you take the output of this monitoring step and you feed it back into the top of the factory. Now you could try and build this and um I went to a talk earlier that my friend Adam gave where Uber has built an internal version of this um and it's pretty cool. I would say for most, you know, most organizations, it really depends where you are. You'll be able to build a simple version of this easily, but to build a thing that actually scales is probably like you should probably be focusing on your own product, not building this infrastructure because there's a lot of stuff that you end up wanting. You're not again not supposed to read this. Uh it's just a lot of stuff. If you do build it um or if you buy it, you'll end up with something that looks kind of like this, which is um you're going to have a bunch of ways of getting work into your factory. That's what's at the top here. You're going to have a sort of control plane for figuring out how work gets distributed across your factory floor. You're going to have the actual place where the work happens. And so that's going to be cloud sandboxes.

比如你在做某种 UI，就让电脑真的去操作一遍 agent 写出来的代码，并生成视频和截图。CI/CD 当然照样要用。然后是监控。在你的工厂里，代码发布之后 agent 并不就此停下，它们应该持续观察已经发布出去的东西：有没有崩溃？有没有人在用？然后就这样一圈又一圈地转下去，因为你会把监控这一步的输出，再喂回工厂的最上游。当然，你可以自己试着把这套东西搭起来。我早些时候去听了我朋友 Adam 的演讲，Uber 在内部就搭了一版，挺酷的。不过我想说，对大多数组织来说，这真的要看你处在什么阶段。搭个简单版本很容易，但要搭一个真正能规模化的东西……你大概还是应该专注于自己的产品，而不是去造这套基础设施，因为到头来你会想要的东西实在太多了。这张图同样不是让大家细看的，反正就是东西很多。不管你是自己搭还是直接买，最后都会得到一个差不多长这样的东西。你会有一堆把活儿送进工厂的入口，就是图上最上面这部分。你会有一个类似控制平面的东西，负责决定活儿怎么在整个车间里分派。你还会有真正干活的地方，也就是云端沙箱。

[13:02] Zach

It's going to be figuring out what agent to run. So, what's the harness? What's the model? And then finally, I think this is a really important thing. You're going to want to set up some kind of data plane that sits below your factory. And so, that's something that lets agents remember what they've done, learn, um, improve over time. The factory is not just like a product, it's also a mindset. And this brings me back to the thesis I had at the beginning. You need to measure and improve. So factory, this is where the I don't know, you can stretch this metaphor as far as you want, but like you should be thinking of efficiency. And so that means like how much software did you ship? How much did it cost in terms of human time and token time and you're going to want to measure this and try to improve it over time. A key part of this is creating loops. So, uh, loops are, again, they sound complicated. They're not that complicated. Loops are basically ways of, uh, having agents improve, um, by like observing what they're doing, where they're failing. Um, and so, a common kind of loop that you're going to want to put in your factory is like a skill loop. That means you're going to have your factory agents that are running skills, and then you'll have observer agents that are seeing how those skills are being applied, looking for issues, and trying to improve the skills. So for instance, if you had a code review agent uh and it was leaving comments and a senior engine engineering or team was going and correcting those comments, you'd want an observer agent that would look at that and basically uh improve the code review agent for the next run.

这一层还要决定跑哪个 agent：用什么 harness（包在模型外面、管提示词/工具调用/循环的那层程序）？用什么模型？最后，我觉得这一点非常重要：你会想在工厂底下搭一层数据平面，让 agent 能记住自己做过什么、从中学习，并随着时间不断改进。工厂不只是一个产品，它也是一种思维方式。这就回到了我开场时提出的论点：你需要度量，然后改进。既然是工厂——怎么说呢，这个比喻你想延伸多远都行——你就应该考虑效率。也就是说：你发布了多少软件？在人的时间和 token 上各花了多少成本？你会想把这些度量出来，并随着时间不断改进。这里面的关键一环是构建循环。循环这东西，还是那句话，听起来复杂，其实没那么复杂。循环基本上就是一种让 agent 通过观察自己在做什么、在哪里失败，来不断改进的方式。你会想放进工厂的一种常见循环，就是 skill 循环。意思是，你的工厂 agent 在执行各种 skill，同时还有观察者 agent 在看这些 skill 是怎么被运用的、找出问题，并设法改进这些 skill。举个例子，假如你有一个代码评审 agent，它会留评论，而资深工程师或团队会去纠正这些评论，那你就需要一个观察者 agent 去看这些纠正，基本上就是在下一次运行前把代码评审 agent 改进好。

[14:48] Zach

This is one thought just to leave folks with like what is where does this leave engineers? Um, I think you're going to have to get into this mindset, and I'm trying very hard to get our team into this mindset. It's not always easy that you're not just building the product, but you're building the thing that builds the product. And that's like it's just different. It's more like process engineering or manufacturing or something like that. Um, and you could think like, okay, maybe that's a bummer. Like, is that a bummer? is that uh you know and it depends like it depends what joy you get out of software engineering. If your joy is in writing the code, I think you're everyone in here who is a software engineer is going to be writing less code. But if your joy is in shipping product, like it's never been a better time. And this is actually where I find my joy. It's like I like building and shipping the thing. So everyone in here is going to code less, but they're going to ship more. And that's going to be a trade-off. But if you approach it like you're a a factory engineer, I think you can see like that there's still a really cool set of engineering challenges. Um you could almost think of it as like meta-engineering like how do you engineer your system of agents to be the best possible at engineering that I think is a very compelling and interesting set of challenges to solve.

最后留给大家一个思考：那工程师何去何从？我觉得你得进入这样一种思维方式——我也在非常努力地让我们团队进入这种思维方式，这并不总是容易——那就是：你不只是在造产品，而是在造那个造产品的东西。这就是不一样，它更像流程工程、制造业之类的活儿。你可能会想：好吧，这也许挺让人扫兴的。这到底算不算扫兴？这取决于你从软件工程里得到的乐趣是什么。如果你的乐趣在于写代码，那我觉得在座每一位软件工程师都会写得越来越少。但如果你的乐趣在于发布产品，那现在是前所未有的好时候。这其实也正是我的乐趣所在——我喜欢把东西做出来、发布出去。所以在座每个人代码都会写得更少，但发布得会更多。这会是一种取舍。但如果你以工厂工程师的心态去看待它，我想你会发现，这里仍然有一整套很酷的工程挑战。你几乎可以把它看成一种元工程：怎样设计你的 agent 系统，让它在做工程这件事上做到最好？我认为这是一组非常吸引人、也非常有意思、值得去解决的挑战。

[16:12]

So that's it. Um uh for folks who were interested uh this if you follow the link on this QR code I've set up um a open source GitHub repo where anyone who wants to try building their own factory agents can do it. This uses Warps uh agent platform as part of it. But you honestly you don't have to use it. I'm not trying to like push into our product. But this should give you a good sense of like, okay, if you want to set up uh an agent that does uh triage or an agent that does uh specw writing, how do you actually do that? How do you get from like the theory of uh working with a factory to actually putting it into practice? Um I don't know if we have the capability to do questions in here. I saved a few minutes for questions if anyone has questions. Otherwise, I will I will wrap up. Yes. what you said you don't want to build this also build

Zach： 我要讲的就是这些。有兴趣的朋友可以扫这个二维码、点进链接——我建了一个开源的 GitHub repo，谁想试着搭自己的工厂 agent 都可以拿去用。它有一部分用到了 Warp 的 agent 平台，但说实话你不一定非得用它，我不是想借机推销我们的产品。不过它应该能让你很清楚地了解：比如你想搭一个做分诊的 agent，或者一个写规格文档的 agent，具体该怎么做？怎么从「用工厂干活」的理论，真正落到实践？我不确定这里有没有条件做问答，不过我留了几分钟，谁有问题都可以问。没有的话我就收尾了。请讲。

观众： 你刚才说，你不会想自己搭这个，但又要搭……

[17:10] Zach

it's a great question so I said something that's almost contradictory I think um you should the way you should think of it is like you everyone's going to deploy some sort of factory but then the tuning of the factory the like are these the right skills for my domain is this factory building my product in the right way I still think there's a bunch of interesting engineering challenges And for some places you can build this, but again I I think I think that the you should probably be focusing on building the core product for your company for the most part, but there's a bunch of like tuning and like uh figuring out how to make the factory work for your product that matters. That's a great question. Yes,

好问题。我刚才说的确实有点自相矛盾。我觉得应该这么看：每个人都会部署某种工厂，但接下来要对这座工厂做调校——这些 skill 适不适合我的领域？这座工厂是不是在以正确的方式构建我的产品？我仍然觉得这里面有一堆有意思的工程挑战。有些场合你确实可以自己搭，但还是那句话，我认为大多数情况下你应该专注于打造公司的核心产品；不过，怎么调校工厂、怎么让工厂适配你的产品，这些事情很重要。问得好。请讲。

[17:51] 观众

thank you so much. So if you were a college student right now,

非常感谢。那如果你现在是一名大学生，

[17:55] Zach

yes,

嗯，

[17:56] 观众

graduating and entering the workforce, where would you spend time?

马上要毕业、进入职场，你会把时间花在哪里？

[18:00] Zach

Yeah. So the the question in case people couldn't hear was like if I was a college student graduating and entering the workforce right now. So I think that the most important skills in this new world are adaptability. I think that that's critical thinking. It's like this the speed at which you can learn. I do think I don't know if you're a computer science student, but I still think there's a ton of value in understanding like the underlying systems and architecture and being able to reason and understand the code, understand the specs that agents are written, sorry, are writing. So, I I would focus on on those skills. Um, and like I don't know, we're hiring more people than we've ever hired. There's a lot of kind of like misdirection around like you know people not being hired because of AI. That's not the experience we've had so far. And what I'm looking for are like really adaptable product focused thinkers who can like basically be great problem solving problem solvers uh even as the underlying technology changes. Yeah, I think I have time for one more question. Yes. What about the like so the question was what about the the product taste and like the how do you actually build something useful I think is probably the right like maybe the framing and like uh where do the ideas come from and so I think that um the problem with the factory metaphor even though I'm like leaning into it because I think that's like that there's something to it is that it can kind of sound like uh mechanizing or dehumanizing um and I still think underlying ing all of this, the only thing that matters is like are you building something useful?

好。怕有人没听清，问题大概是：如果我现在是个大学生，马上毕业、要进入职场……我觉得在这个新世界里，最重要的能力是适应力，还有批判性思维，以及你学习的速度。我不知道你是不是学计算机的，但我仍然认为，理解底层的系统和架构、能对代码进行推理和理解、能看懂 agent 写出来的规格文档，这些都有巨大的价值。所以我会专注在这些能力上。另外，怎么说呢，我们现在招的人比以往任何时候都多。外面有很多带偏方向的说法，说什么因为 AI 大家都找不到工作——至少到目前为止，我们的经历不是这样。我在找的是那种适应力很强、以产品为导向的思考者，基本上就是即便底层技术在变，也能出色地解决问题的人。好，我想还有时间再回答一个问题。请讲。那……好，问题是：那产品品味呢？或者说，怎样才能真正做出有用的东西——我觉得这样表述可能更准确——还有，点子从哪儿来？我觉得工厂这个比喻的问题在于——虽然我一直在往这个比喻上靠，因为我觉得它确实说中了点什么——它听起来有点像是在搞机械化，甚至去人性化。而我始终认为，在这一切底下，唯一重要的是：你做的东西到底有没有用？

[19:42] Zach

And if you have like a a factory that is like churning out that no one cares about, it's like what's the point? And I think that human taste, human input, human product sense, um humans like guiding at those touch points where you can't automate stuff is absolutely like essential. And like that's like what I do like I'm trying to figure out what what do customers want, what do people want, what's going to be valuable to them. So I think that's an absolutely key point to it. I think I'm at time so I I have to go. I hope folks uh enjoyed this chat. I'm really grateful for being invited to speak. So thank you all very much.

如果你有一座工厂，一直在批量产出没人在乎的东西，那还有什么意义呢？所以我认为，人的品味、人的输入、人的产品感觉，还有人在那些没法自动化的关键节点上把握方向，都是绝对必不可少的。而这其实就是我自己在做的事：我一直在琢磨客户想要什么、大家想要什么、什么东西对他们真正有价值。所以我认为这是整件事里绝对关键的一点。我时间到了，得下台了。希望大家喜欢今天的分享，非常感谢能受邀来这里演讲。谢谢大家。

[20:34]

[music]

（音乐）