>> Okay. Yeah, I'm Scott from Cognition AI. I'm going to tell you guys a little bit about the early makings of Devin. We're still super, super early on. And also a little bit about kind of the space as a whole and what's coming next. I thought it would be nice to start

好的。嗯，我是來自 Cognition AI 的 Scott。我將向大家介紹一下 Devin 的早期製作。我們還處於非常非常早期的階段。還有關於整個領域的一些情況以及接下來會發生什麼。我覺得從這裡開始會很好。

with a demo first. It sounds like some of you guys have already seen some of the videos, but I brought a nice custom one here for the World's Fair today. So I'll just show that quickly. And here I basically said, hey, Devin, this is this morning, by the way. This is a huge scramble. I said, hey, Devin, I want you to

首先進行示範。聽起來你們有些人已經看過一些影片了，但我今天為世界博覽會帶來了一個很棒的定制影片。所以我會快速展示一下。這裡我基本上說，嘿，Devin，這是今天早上，順便說一下。這是一個巨大的緊急情況。我說，嘿，Devin，我希望你能...

build a mobile-friendly website to play the name game. So I have a lot of trouble memorizing

建立一個適合行動裝置的網站來玩名字遊戲。所以我在記憶方面有很多困難

names and faces. I don't know about you guys. But I basically just said, you know, here's a TSV file of a bunch of names and faces. These are all the speakers here at the World's Fair this week. And I said, can you set up the game so that you show two different random faces and then show the names of one of them and have me guess which one is which. And I gave kind of a few instructions on how the game should work. And so Devin is a fully autonomous software engineer. And what that means is Devin has

名字和臉孔。我不知道你們怎麼想的。但我基本上只是說，你知道，這裡有一個包含一堆名字和臉孔的 TSV 檔案。這些都是本週在世界博覽會上的演講者。我說，你能不能設置一個遊戲，顯示兩個不同的隨機臉孔，然後顯示其中一個的名字，讓我猜哪個是誰。我給了一些關於遊戲應該如何運作的指示。所以 Devin 是一個完全自主的軟體工程師。這意味著 Devin 具有

access to all the same tools that a human software engineer would have when they were

當他們擁有與人類軟體工程師相同的所有工具時

building something like this. So the first thing that Devin is going to do is Devin is going to make a plan. And you can see here kind of a basic plan coming out. One of the

建造這樣的東西。所以德文要做的第一件事就是制定一個計劃。你可以在這裡看到一個基本的計劃出來了。其中一個

interesting things about this is the plan changes a lot over time. And so as you get new information or new feedback, you update your plan accordingly with that, too.

有趣的是，這個計劃會隨著時間不斷變化。因此，當你獲得新的資訊或反饋時，你也會相應地更新你的計劃。

After that, Devin's basically just running this the same way that a human would. So if

之後，Devin 基本上只是以人類的方式運行這個。 所以如果

you can take a look, Devin makes a new directory for the name game website, starts a new React app, all the same primitives, works on building it out and building the code, reads the TSV

你可以看看，Devin 為 name game 網站創建了一個新的目錄，開始了一個新的 React 應用，所有相同的基本元素，致力於構建它和編寫代碼，閱讀 TSV。

file to take a look at what's going on here. And it's just kind of generally working through

檔案來看看這裡發生了什麼。這只是一般性的處理過程

it and jumping through. It comes out and deploys this first version after some minutes. And

它跳過來跳過去。幾分鐘後，它出來並部署了這個第一版本。

I'll just pull this up quickly. So that's what this looks like. It's closed but not

我會很快把這個拉起來。這就是它的樣子。它是關閉的，但不是

quite there; right? I mean, it shows that it's still showing the names. And I think maybe I didn't quite specify that exactly. But, you know, you can click the name and

還沒完全到位；對吧？我的意思是，它顯示它仍然在顯示名字。我想也許我沒有完全具體說明。但，你知道，你可以點擊名字然後

got that correct. And so I just went ahead and just gave it some more feedback in plain

明白了。所以我就直接給了它一些更直接的反饋。

English. And so I said, hey, can you hide the two names until I click on the answer?

所以我說，嘿，你能不能在我點擊答案之前隱藏這兩個名字？

And also can you probably restyle the play again button? It's like somehow it's a little

而且你能重新設計一下播放按鈕嗎？好像有點...

off on this page. And I kept going and just kind of gave it more and more feedback over

在這一頁上關閉。我繼續前進，不斷給予更多的反饋。

time. And I also asked it, hey, can you add a streak counter as well? Can you keep track

時間。我還問它，嘿，你能加一個連續計數器嗎？你能跟蹤

of how many I got correct and reset to zero? A few of these other things. And the website

我答對了多少並重置為零？這些其他事情中的一些。還有這個網站

it ultimately deployed was this one right here. And so this is Just Ian, for example.

它最終部署的就是這個。所以這就是 Just Ian，舉個例子。

Keeps track of my streak. You can see it's kind of ramping it up. And so if I were to,

記錄我的連續天數。你可以看到它有點在增加。所以如果我是要，

for example, if I got this one wrong on purpose, then you would see the streak would reset

例如，如果我故意答錯這題，那麼你會看到連勝紀錄會重置。

to zero and go on. And so I actually played this game and learned the names of everyone,

歸零並繼續。所以我實際上玩了這個遊戲，並學會了每個人的名字，

which was super helpful, by the way. And you guys can play it, too. It's right here if you want to try it out. This has all the speakers. I think it was something like 170 speakers

順便說一下，這真的非常有幫助。而且你們也可以玩。就在這裡，如果你們想試試看的話。這裡有所有的講者。我想大概有 170 位講者。

here at the World's Fair this week. So this is kind of a cool example. But I want to highlight how different the world is if software engineering is just this

這週在世界博覽會上。所以這是一個很酷的例子。但我想強調，如果軟體工程只是這樣，世界會有多麼不同。

easy. If you can just explain exactly what you want in plain English and get that out.

簡單。如果你能用簡單的英文解釋清楚你想要的東西並表達出來。

And so this is obviously kind of a toy use case and it's perhaps useful, but we use Devin all the time ourselves when we're building Devin, actually. And by the way, obviously I didn't make this website myself. I just said, hey, can you build me this website with the QR code and whatever, and Devin built that, too. But here's a quick example of Devin that we're using ourselves in production. And so if you

所以這顯然是一個玩具用例，可能有些用處，但我們在構建 Devin 時自己也一直在使用 Devin。順便說一下，顯然這個網站不是我自己做的。我只是說，嘿，你能不能幫我建一個帶有 QR 碼和其他功能的網站，然後 Devin 也做到了。但這裡有一個我們在生產中自己使用 Devin 的簡單例子。所以如果你

take a quick look here, for example, there's this whole search bar and there's all the sessions and you can search across sessions; right? Devin actually made that in the Devin

舉個例子，快速看一下這裡，有整個搜尋欄，還有所有的會議，你可以在會議中搜尋；對吧？這其實是 Devin 在 Devin 製作的。

repository. You can see here Bryce is on our team and Bryce was asking, hey, Devin, can you go into the Devin sessions list, create a search bar component, here's what I need you to do. And so there's a few features about this in particular that are obviously tuned for working in a production code base. You can see here

儲存庫。你可以看到這裡 Bryce 是我們團隊的一員，Bryce 問 Devin：「嘿，Devin，你能不能進入 Devin 會議列表，創建一個搜索欄組件，這是我需要你做的。」所以這裡有一些特別的功能，顯然是為了在生產代碼庫中工作而調整的。你可以看到這裡

that Devin started from a snapshot. So we have a machine instance loaded where it's cloned from. It has a playbook so it knows a lot of the details about our repositories.

Devin 是從一個快照開始的。所以我們有一個機器實例，它是從那裡克隆出來的。它有一個 playbook，所以它知道很多關於我們儲存庫的細節。

And then it's also just able to generally work within our Git environment. So you'll see it just make a PR and interact with all those same tools.

然後它也能夠在我們的 Git 環境中正常運作。所以你會看到它創建 PR 並與所有相同的工具互動。

And so I'll just kind of go through this quickly. Devin says absolutely. Makes the first pull

所以我會快速地講過這部分。Devin 說絕對沒問題。完成了第一次拉動。

request. Bryce continues. And again, you're just giving feedback in plain English; right?

請求。Bryce 繼續。而且再次強調，你只是用簡單的英文給予反饋，對吧？

And you say, hey, this is a great start. Now could you add a magnifying glass and make it idiomatic, use FOSS for a loose seat. It's up to you; right? And Devin says, yeah, sure,

然後你說，嘿，這是一個很好的開始。現在你可以加上一個放大鏡，並使其更具成語性，使用 FOSS 來固定鬆動的座位。這取決於你；對吧？然後 Devin 說，沒問題，當然可以。

I'll build that. And Bryce says, oh, by the way, no need to test. I trust you. And Devin

我會建造那個。然後布萊斯說，對了，不需要測試。我相信你。還有德文

says, by the way, I'm dealing with a bit of an issue with the login process. It's just like you're working with another engineer; right? And Bryce says, okay, bro.

順便說一下，我在處理登入過程中的一些問題。就像你在和另一位工程師合作一樣；對吧？然後 Bryce 說，好，兄弟。

And it kind of builds it all and gets the PR. And this PR was actually merged and this is the search bar; right? And similarly, a lot of the API integrations that Devin has

而且它會把所有東西都建構起來並獲得 PR。而這個 PR 實際上已經合併了，這就是搜尋欄；對吧？同樣地，Devin 的許多 API 整合也是如此。

were built by Devin. A lot of our own internal dashboards and metrics tracking within Devin were actually also built by Devin. And it's been kind of a fun one to see Devin building the company with the company as well. So, cool. Yeah, I want to talk a little bit about our journey so far and about what's happening in the space as well. And so we got started back in November. So it's been about seven months now. It's kind of funny. We started in a hacker house in Burlingame. And it was basically just a lot of us had already lived together at that point. We had all had our own journeys in AI. We just knew that we wanted to build something together. And we obviously knew that we wanted to do something in code and build a coding agent. And then that hacker house in the Bay Area. After that, there was another hacker house in New York. Then there was another hacker house in the Bay Area. So we've been going back and forth between New York and the Bay for basically the last seven months. I think at this point we are now going to settle in the Bay. But it's been

由 Devin 建造的。我們內部的許多儀表板和指標追蹤系統其實也是由 Devin 建造的。看到 Devin 與公司一起建設公司，這是一件有趣的事。所以，很酷。是的，我想談談我們到目前為止的旅程以及這個領域正在發生的事情。我們是在去年十一月開始的。到現在大約七個月了。有點有趣的是，我們在 Burlingame 的一個駭客屋開始。基本上，那時我們中的很多人已經住在一起了。我們都有各自的 AI 旅程。我們只是知道我們想一起建造一些東西。我們顯然知道我們想在編碼方面做些什麼，並建立一個編碼代理。然後是在灣區的那個駭客屋。之後，在紐約又有一個駭客屋。然後在灣區又有一個駭客屋。所以在過去的七個月裡，我們基本上在紐約和灣區之間來回奔波。我想在這個時候我們會定居在灣區。但這一直是

going back and forth and getting a slightly bigger Airbnb each time because the team also gets a little bit bigger. But, you know, why Devin in particular? And, you know, this is

來來回回，每次租一個稍微大一點的 Airbnb，因為團隊也在逐漸擴大。但是，你知道，為什麼特別選擇德文？你知道，這是

a particular question that I'm really passionate about, which is, you know, language models have been pretty big. I think that's fair to say. And, you know, the first wave of generative AI is what I generally call these text completion products. And that makes a lot of natural

有一個我非常熱衷的問題，就是，你知道，語言模型已經變得相當重要。我認為這是公平的說法。而且，你知道，第一波生成式 AI 是我通常稱之為這些文本補全產品的東西。這使得很多自然

sense if you think about it that obviously the interface of a language model is text completion. You give it a prefix and it completes the suffix from there. If you think about chat GPT, if you think about a lot of these Q&A products, if you think about writing marketing copy or answering customer support or even GitHub copilot and cursor and products like that, obviously a lot of these are really great products and very natural use case where you have the prefix so far and you're asking the model to complete what's next in the suffix. And it does that for you. And that's a tool that's useful. And I think we're entering this new wave where, you know, we're going beyond that and actually introducing some amount of autonomous decision making. And obviously, you know, that's typically referred to in our space as agents. And, you know, there's all sorts of new things that you unlock. There's a lot higher bar of consistency that you require. But there's new things that you unlock with that. And so it's been an interesting one because it's both a very deep core capabilities

如果你仔細想想，語言模型的介面顯然是文本補全。你給它一個前綴，它就從那裡補全後綴。如果你想到 chat GPT，如果你想到很多這些問答產品，如果你想到撰寫行銷文案或回答客戶支持，甚至是 GitHub copilot 和 cursor 這類產品，顯然這些都是非常出色的產品，而且在你有前綴的情況下，讓模型補全後面的內容是一個非常自然的使用案例。而且它為你完成了這個任務，這是一個非常有用的工具。我認為我們正在進入一個新的浪潮，我們不僅僅停留在這裡，還引入了一些自主決策的能力。顯然，在我們這個領域，這通常被稱為代理。你知道，這解鎖了各種新事物。你需要更高的一致性標準，但這也解鎖了新的可能性。因此，這是一個有趣的領域，因為它既有非常深厚的核心能力。

question of getting Devin to solve these, but also a pretty interesting product design

讓 Devin 解決這些問題的問題，但也是一個相當有趣的產品設計

problem because I think the UX of agents is something that's extremely new. And then why code in particular? A few different things. Obviously we're all coding nerds as well. We're all engineers. And so the idea of teaching AI to code is one of the coolest things that we can think of. But beyond that, I think there's a few particular reasons that

問題是因為我認為代理的用戶體驗是非常新的東西。那麼為什麼特別是編碼呢？有幾個不同的原因。顯然，我們都是編碼迷。我們都是工程師。所以教 AI 編碼的想法是我們能想到的最酷的事情之一。但除此之外，我認為還有一些特別的原因。

code with agents works especially well. One is that obviously there's so much more to it being a software engineer than typing the code. A lot of the work that you're going

使用代理程式編碼特別有效。一個原因顯而易見，成為一名軟體工程師遠不止於輸入程式碼。你所進行的許多工作

to do is, you know, you're going to be looking into a bug. You're going to be looking at the different files of the code base. Maybe you're going to be running this or that command. Maybe you're going to be pulling up documentation. Maybe you're going to run the frontend yourself to reproduce the bug. You look at this thing. You make this edit. You try it again. All

你要做的是，你知道，你會去查看一個 bug。你會查看代碼庫中的不同文件。也許你會運行這個或那個命令。也許你會調出文件。也許你會自己運行前端來重現這個 bug。你查看這個東西。你進行這個編輯。你再試一次。所有的

of this work here obviously is, you know, that's what software engineering is, right? More so than just typing the code in the file, which leads very naturally to an agentic workflow Another part which I think is closely related is the ability to iterate with code feedback. What I mean by that is, you know, if you were given an entire production code base and you were told, hey, this has this one bug. I need you to fix it. Here's the bug. You know, and let's say it's like thousands of files and hundreds of thousands of lines of code. I mean, it would be pretty tough, honestly, for most humans. It's also going to be quite tough for AIs as well. And obviously the way that we do this in practice is, you know, you go and add print statements. You pull up the logs. You check the monitoring. You jump back and forth between different files. You try and diagnose it. Each of these things that you're doing, you're making a decision and then you're running actual code to find out what happened. And from that, you're able to iterate. And it just gives you a much cleaner path to solve the problem in front of you. And similarly, you know, that kind of lends very well to agents. And the last thing I just want to mention is how fast model agentic capabilities are improving. And so, you know, two years ago, like even something as simple as this name game demo, I think, would have been almost unthinkable. And, you know, you think about where things are going and where things are going to be two years from now. I think there's a lot of, you know, the data, the right training and so on, that's really, really rapidly improving in the space. And then, you know, again, beyond the capabilities problem, there's actually a really deep UX problem as well. And at a high level, I think

這裡的工作顯然是，你知道，這就是軟體工程，對吧？不僅僅是將代碼輸入文件，這非常自然地引導到一個代理工作流程。我認為另一個密切相關的部分是能夠通過代碼反饋進行迭代。我的意思是，如果你被給予一個完整的生產代碼庫，並被告知，嘿，這裡有一個錯誤。我需要你修復它。這是錯誤所在。你知道，假設它有成千上萬的文件和數十萬行代碼。老實說，對大多數人來說，這會非常困難。對 AI 來說也會相當困難。顯然，我們在實踐中這樣做的方式是，你知道，你會添加打印語句。你會查看日誌。你會檢查監控。你會在不同的文件之間來回跳轉。你會嘗試診斷它。你所做的每一件事，你都在做一個決定，然後運行實際的代碼來找出發生了什麼。通過這樣做，你能夠進行迭代。這給你提供了一條更清晰的路徑來解決眼前的問題。同樣地，你知道，這非常適合代理。而我最後想提到的是模型代理能力的快速提升。所以，你知道，兩年前，即使是像這個名字遊戲演示這樣簡單的東西，我認為也是幾乎不可想像的。你知道，當你想到事情的發展方向以及兩年後的情況時，我認為有很多數據、正確的訓練等等，這些在這個領域正在非常迅速地改進。然後，你知道，除了能力問題之外，其實還有一個非常深刻的用戶體驗問題。從高層次來看，我認為

what's kind of happening here is when we're building agents, and I think all of us in the space are quite new to agents, you know, the immediate first things I think to map to are, you know, how we use software today and also how we talk with other humans, right? And so, you know, I mean, even a lot of the features in Devin are essentially looking over your own intern's shoulder. You can see their computer and you can see what commands they're running and things like that. The thing is, I think an agent is actually pretty different from both. There's a lot of nuances and details of parallel work, information gathering, how it manages context, et cetera, et cetera, that are super, super different. And it's actually a quite deep problem from a product perspective as well. And just to give you guys a bit of a sense of that, like here's just kind of a short list of some of the features that we've built into the product. And so, you know, obviously there's Devin

這裡發生的事情是，當我們在構建代理時，我認為我們所有人在這個領域對代理都相當陌生，你知道，我首先想到的是，我們今天如何使用軟體以及我們如何與其他人類交流，對吧？所以，你知道，我的意思是，甚至 Devin 中的許多功能基本上都是在看著你自己的實習生的肩膀。你可以看到他們的電腦，看到他們運行的命令等等。問題是，我認為代理實際上與這兩者都非常不同。並行工作、信息收集、上下文管理等方面有很多細微差別和細節，這些都非常非常不同。從產品的角度來看，這實際上是一個相當深奧的問題。為了讓你們有點了解這一點，這裡列出了一些我們在產品中構建的一些功能。所以，你知道，顯然有 Devin。

being able to use the shell, you know, edit code, browse the web, but there's all these other things, right? You know, being able to fork and roll back sessions, you know, being able to handle integrations with Slack and GitHub, being able to handle playbooks, to store machine snapshots, to keep track of secrets, you know, to be able to work with the right tools for verification. You know, all of this is part of the actual product iteration, right, which is, you know, on its own I think already an incredibly, incredibly dense problem. And I think honestly we're going to see actually a lot more iteration with that over time. And I just wanted to show kind of a new feature which we just recently

能夠使用 shell，你知道，編輯代碼，瀏覽網頁，但還有這些其他的事情，對吧？你知道，能夠 fork 和回滾會話，能夠處理與 Slack 和 GitHub 的整合，能夠處理 playbooks，存儲機器快照，跟踪機密，能夠使用正確的工具進行驗證。你知道，所有這些都是實際產品迭代的一部分，對吧，我認為這本身已經是一個非常非常複雜的問題。而且我認為，說實話，隨著時間的推移，我們實際上會看到更多的迭代。我只是想展示一個我們最近推出的新功能。

shipped, which is the ability to use Devin's machine, which is kind of� again, it's the

運送，這是使用 Devin 的機器的能力，這有點像是... 再次，這是

kind of thing that's not always� there's not necessarily a very close parallel in,

這種事情並不總是……不一定有非常密切的對應。

you know, in the software that we have today, right? But the ability to just have a VS code live share in Devin's machine and, you know, if you want to collaborate with Devin and say, hey, oh, there's these couple lines, like, you know, you should make this edit.

你知道，在我們今天使用的軟體中，對吧？但是能夠在 Devin 的機器上進行 VS code live share，如果你想與 Devin 合作，並說，嘿，哦，這裡有幾行，你知道，你應該做這個編輯。

I went ahead and did that edit for you and you can just talk with Devin and do that,

我已經幫你做了那個編輯，你可以直接跟 Devin 談談並完成那件事。

right? So there's a lot more room to go and a lot to iterate on in the space. One of the things I wanted to mention, too, is just how much, you know, we've seen it changing our own workflow. So you guys saw like a simple example of Devin building the search bar. But, you know, we actually handle tasks in a much more async way now. One of

對吧？所以在這個領域還有很多發展空間和改進的餘地。我也想提到的一件事是，我們看到它改變了我們自己的工作流程。你們看到 Devin 建立搜尋欄的簡單例子，但其實我們現在處理任務的方式更加非同步了。其中一個

the cool kind of features of Devin, I'd say, is, you know, if as an engineer you're working on, let's say, four different tasks today, you know, you just give one to Devin number

我會說，Devin 的一個很酷的功能是，如果你今天作為工程師在處理四個不同的任務，你只需要把其中一個交給 Devin。

one, you give the second one to Devin number two, third one to Devin number three. You have four Devins running in parallel. It's turning every engineer into an engineering manager is how I describe it. I think Devins are very, like, enthusiastic interns is what I would say. They try very hard. Obviously they don't know everything. They get little things wrong. They ask a lot of questions. But you're kind of working with each of them and having them iterate. So here's just kind of a fun example. I mean, this is literally from earlier today. But, you know, we were talking about some particular feature and about what we wanted to build. In this case it was a pretty simple thing of changing the color. But it's just as simple as saying in Slack in the conversation, hey, @Devin, can you just change this thing? And then Devin goes and makes a PR and you hit merge. We've had a lot of occasions where we're in the gym or in the car or something. And now you can actually write code. You can tell Devin exactly what you want Devin to do. You just don't have your whole computer with you and can't type everything. But being able to describe what you want to Devin and review the code afterward actually works really well. So what's next? You know, I think this is a really important question. And obviously I think the technology is extremely early today. But where do these things go in a few years and also what happens with software engineering? I think there's been a lot of

第一個，你給第二個 Devin，第三個給第三個 Devin。你有四個 Devin 同時運行。我形容這就像是把每個工程師變成工程經理。我認為 Devin 很像是充滿熱情的實習生。他們非常努力。顯然他們並不知道所有事情。他們會犯一些小錯誤。他們問很多問題。但你會和每個人一起工作，讓他們不斷迭代。這裡有一個有趣的例子。我是說，這真的是今天早些時候發生的。我們在討論一些特定的功能以及我們想要構建的東西。在這種情況下，這是一個相當簡單的改變顏色的事情。但就像在 Slack 的對話中說，嘿，@Devin，你能不能改變這個東西？然後 Devin 去做一個 PR，你點擊合併。我們有很多次在健身房或車裡的情況。現在你實際上可以寫代碼。你可以告訴 Devin 你想讓他做什麼。你只是沒有整台電腦在身邊，不能打字。但能夠描述你想要什麼給 Devin 並在之後審查代碼實際上效果很好。那麼接下來呢？我認為這是一個非常重要的問題。顯然，我認為這項技術今天還非常早期。但在幾年後這些東西會走向何方，軟體工程又會發生什麼？我認為有很多

uncertainty about that question. And, you know, as we're using Devin more and more,

對於這個問題的不確定性。而且，你知道，隨著我們越來越多地使用 Devin，

I think one of the big things that we see actually is this is kind of obvious perhaps, but Devin is not the one that decides what to do or what to build. And there's this core part of software engineering, the way I describe it, it's like software engineers everywhere are doing really two jobs at once. And the first job is basically problem solving with code. You know, you're given a problem and you're breaking down exactly what is the solution you're going to build. What is the architecture that you're going to use? What are all the flows and the details and the edge cases that might come up and kind of architecting your exact solution. And then the second part is once you have that, you know, you're dealing with debugging or implementing different functions or writing unit tests or all of the other things that kind of go into this implementation of something that you know you want to do. And I think right now the average software engineer is probably spending like 10 or 20% of the time on that first thinking part and spending 80 or 90% of the time on that implementation part. And what we really see is Devin actually just frees you up to do more of the first part. And I think the future of Devin, again, it's very, very early, but I think as Devin gets better, we're going to see more of that where Devin just frees up the implementation for you where you don't have to go figure out how to set up Kubernetes. You don't have to go debug all these APIs that are broken. You don't have to go deal with version changes or migrations or all of these other things that, you know, take up a lot of time in software engineering, right? But you actually are spending all your time on figuring out how to solve the problems in front of you. It's a little more like a mix between, you know, a technical architect and a product manager almost, right? And so, you know, I think software engineering, the job that we call software engineering is going to change. But I think practically like there's actually going to be way more software engineers than ever. And I think there's a lot of precedent for that, too. Programming back then used to mean punch cards. And then after that, it used to mean assembly. And then after that, it used to mean C. And as these things have gone on, I mean, most people aren't using punch cards anymore. But there's actually way more programmers than before. And I think one of the things that's easy to underestimate is just how much more code there is to write. And, you know, it's funny to think about, I think, because obviously we all love software here in this room. I would say I think software has been the number one driver of progress in the world in the last 40 or 50 years. And yet despite that, I think, you know, our demand for software to be built is actually probably a lot more than 10X what we're currently getting. And so, you know, I think what happens is we get to open up the power of software engineering to a lot more people. And every single software engineer gets to be 5 or 10X more effective. But we actually do a lot more software engineering. Cool. Yeah. So that's all I had. But, yeah, we'd love to open the floor if there's any questions. [ Applause ] Yeah, right here in the front. >> Thanks, Gareth. This is great. I'm a Google admin. How do we get access? >> Great question. Great question. So we've been ramping up access. Every week we've been letting on more and more people. We've also been sizing up with our enterprise customers. We have a lot of wait lists to get through. So we're doing it as fast as we can. But we'd love to get you guys access as soon as possible. Yeah. Yeah. All the way in the back over there. Yeah. In the red. >> Hey, I'm just wondering how much like does Devin have access for running the code all in the back end? Like how are you doing the analysis for bread and code to generate? >> Yeah, exactly. So in our code base, for example, Devin has all the setup that it needs. It has a machine that's basically instantiated where it can run the dev environment, it can run the server, it can run the front end. And so if you're asking it, hey, I need you to debug this particular thing, it will just pull it up itself and then reproduce it and then it will debug it and try it again. Yeah. Exactly. Yeah. Yeah. Yeah. Any other questions? Right here. >> So with all the things that are done, how do we know how to do it? >> Of course. Yeah. So someone asked, you know, with all of these simpler tasks getting solved, what happens to, you know, all the junior engineers or the interns who obviously need to learn how to code? I think what happens, honestly, is I think that demand is going to just keep rising with supply. And I think the training process is going to change a little bit. But I think a lot of these core fundamentals, if you think of someone as when you say someone is a really great engineer, typically you don't mean that they type really fast, although maybe they do that, too. You typically mean that they have a really great understanding of problems, they know all the different architectures, they never miss an edge case, stuff like that. So those are the fundamentals that I think are always going to matter. And I think basically I think interns or junior engineers are going to get more exposed to getting to use those fundamentals earlier and earlier. Yeah. Yeah. Okay. So someone asked what are the biggest challenges to realizing the vision of a future suite? You know, there's a lot. I mean, it's basically everything, as you can imagine. I mean, there's speed, there's consistency, there's access, there's integrations, there's the right product UX. And I think all of these things one of the cool things I think is just how much of a rising tide there is everywhere. And so, you know, obviously we're going to do our best work on it, but every new hardware release is amazing for it. Every new foundation model that comes out is amazing. Every new piece of agentic research. And I think this is the kind of thing where I think there will be a lot of different optimizations that come in different parts of the stack that make this agentic flow better and better and better. But, yeah, it won't just be one small thing, but I think it will be pretty fast. That's all the time we had. So thank you so much. Thank you guys so much. [Applause] >> Great talk. Thank you. >> Thank you. .

我認為其實我們看到的一個大問題，這可能很明顯，但Devin並不是決定該做什麼或該構建什麼的人。在軟體工程的核心部分，我的描述是，軟體工程師無論在哪裡，其實都在同時做兩份工作。第一份工作基本上是用程式碼解決問題。你知道，你會得到一個問題，然後精確地分解出你將構建的解決方案是什麼。你將使用什麼架構？所有的流程和細節以及可能出現的邊緣情況是什麼，並設計出你的精確解決方案。然後第二部分是，一旦你有了這些，你知道，你將處理除錯或實現不同的功能或撰寫單元測試，或者所有其他涉及到你知道你想做的事的實現過程中的事情。我認為現在普通的軟體工程師可能花10%或20%的時間在第一個思考部分，而花80%或90%的時間在實現部分。我們真正看到的是，Devin實際上讓你有更多時間做第一部分。我認為Devin的未來，當然現在還非常早期，但我認為隨著Devin的改進，我們會看到更多這種情況，Devin讓你不必去設置Kubernetes，不必去除錯那些故障的API，不必處理版本變更或遷移，或者那些在軟體工程中佔用大量時間的其他事情，而你實際上會花所有時間在解決面前的問題上。這有點像技術架構師和產品經理的混合體。所以，我認為我們稱之為軟體工程的工作會改變。但實際上我認為會有比以往更多的軟體工程師。我認為這方面有很多先例。以前編程意味著穿孔卡片，然後是匯編，再後來是C語言。隨著這些技術的發展，大多數人不再使用穿孔卡片，但實際上程序員的數量比以前多得多。我認為容易被低估的一點是需要編寫的程式碼實際上多得多。這很有趣，因為我們在場的所有人都熱愛軟體。我認為軟體是過去40或50年來世界進步的首要驅動力。儘管如此，我認為我們對軟體的需求實際上可能比現在多10倍。所以，我認為我們能讓更多人接觸到軟體工程的力量，每個軟體工程師都能提高5到10倍的效率。但我們實際上會做更多的軟體工程。很酷。所以這就是我所有要說的。但我願意開放討論，如果有任何問題。[掌聲]這邊前排。

謝謝，Gareth。這很棒。我是一名Google管理員。我們如何獲得訪問權？ 好問題。好問題。我們一直在加快訪問權限的發放。每週我們都會讓越來越多的人加入。我們也在擴大與企業客戶的合作。我們有很多等待名單，所以我們盡可能快地處理。但我們很樂意儘快讓你們獲得訪問權限。是的。那邊後排，穿紅色衣服的那位。 嘿，我只是想問，Devin在後端運行程式碼的訪問權限是怎麼樣的？你們是怎麼做程式碼生成分析的？ 是的，沒錯。所以在我們的程式碼庫中，Devin擁有所有需要的設置。它有一台基本上啟動的機器，可以運行開發環境，運行服務器，運行前端。所以如果你問它「嘿，我需要你除錯這個特定問題」，它會自己調用它，然後重現問題，然後進行除錯並再試一次。是的，沒錯。是的。還有其他問題嗎？這邊。 所以所有事情都完成後，我們怎麼知道該怎麼做？ 當然。是的。有人問，隨著所有這些簡單任務的解決，對於需要學習編程的初級工程師或實習生來說會發生什麼？我認為，坦白說，我認為需求將繼續隨供應增加。我認為培訓過程會有所改變。但我認為很多這些核心基礎，如果你說某人是一個非常優秀的工程師，通常你不是說他們打字速度很快，儘管他們可能也很快。通常你是指他們對問題有很好的理解，他們知道所有不同的架構，他們從不錯過任何邊緣情況等等。所以這些是我認為始終重要的基礎。我認為實習生或初級工程師將更早地接觸到使用這些基礎知識的機會。是的。好的。有人問實現未來願景的最大挑戰是什麼？你知道，有很多，基本上是所有事情。速度、一致性、訪問權限、集成、正確的產品用戶體驗。我認為所有這些事情，我認為令人興奮的是，各個方面都有一種上升的趨勢。所以，顯然我們會盡力而為，但每次新的硬體發布都對其有益。每次新的基礎模型發布都對其有益。每次新的智能代理研究發布都對其有益。我認為這是一種情況，我認為不同部分的堆疊中會有很多不同的優化，使這個智能代理流程變得越來越好。但不會只是一個小的改進，我認為進步會很快。時間到了。所以非常感謝。非常感謝大家。[掌聲]