# The Making of Devin

Scott Wu, Cognition AI

AI Engineer World's Fair 2024

[Talk page](https://ai.engineer/talks/T7NWjoD_OuY-making-devin) · [Video](https://www.youtube.com/watch?v=T7NWjoD_OuY)

## The Making of Devin

A name-game website, a production search bar, and a shared development machine show how coding agents turn instructions into software—and where human judgment still matters.

Basic familiarity with React state, Git pull requests, and development environments will help with the examples.

### A name game built through feedback

[0:35](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=35s)

Remembering names and faces is hard; a small practice game could help. Preparing for the [AI Engineer World's Fair](https://ai.engineer/worldsfair/2024/schedule) that morning, Scott Wu asked [**Devin**](https://cognition.com/blog/introducing-devin) to build a mobile-friendly website from a TSV containing the event speakers’ names and photographs. Each round should show two different random faces and one person’s name, then ask the player to choose the matching face.

The request starts a development process, not just a code response. Devin has the tools a human engineer would use and first produces a plan. That plan can change as new information or feedback arrives. In the demonstration, Devin creates a directory, starts a React application, reads the TSV, and builds the website.

After some minutes, Devin deploys a first version. It is close, but the photographs still display their names, giving away the answer. Wu acknowledges that he may not have specified the requirement precisely enough. Clicking an answer produces the expected correct-answer feedback, but the interface needs another pass.

![Browser showing World's Fair Name Game, two labeled portraits, the name Derek Bingham, green Correct! feedback, and a small Play Again button.](https://ai.engineer/api/talk-essay-media/2eaa080155b5747316c351f88dc3222e213bcd99d8e604c07a516832bc26fc62)

The World's Fair Name Game displays a correct answer with both photo labels still visible.

Wu supplies that pass in plain English: hide both photograph labels until the player answers, restyle the `Play Again` button, and add a streak counter that returns to zero after a wrong answer. These requests refine both presentation and application state. In React, the requested answer and streak behavior can be expressed with a small state transition:

```jsx
import { useState } from "react";

export function NameGameRound({ faces, target, onNext }) {
  const [answerId, setAnswerId] = useState(null);
  const [streak, setStreak] = useState(0);
  const answered = answerId !== null;

  function choose(face) {
    if (answered) return;
    setAnswerId(face.id);
    setStreak(count => face.id === target.id ? count + 1 : 0);
  }

  function playAgain() {
    setAnswerId(null);
    onNext();
  }

  return (
    <section>
      <h1>Which person is {target.name}?</h1>
      <p>Streak: {streak}</p>
      <div>
        {faces.map(face => (
          <button
            key={face.id}
            disabled={answered}
            onClick={() => choose(face)}
          >
            <img
              src={face.photoUrl}
              alt={answered ? face.name : "Choose this person"}
            />
            {answered && <span>{face.name}</span>}
          </button>
        ))}
      </div>
      {answered && (
        <>
          <p>{answerId === target.id ? "Correct!" : "Incorrect"}</p>
          <button onClick={playAgain}>Play Again</button>
        </>
      )}
    </section>
  );
}
```

Here the parent supplies two distinct faces and a target drawn from that pair; `onNext` supplies the next round while keeping this component mounted. The target name remains visible throughout, while the photograph labels appear only after an answer.

The final deployed version demonstrates those rules. Wu identifies Justine, builds up a streak, then deliberately chooses a wrong answer to show the counter resetting to zero. He says playing the game helped him learn everyone’s names. Wu estimates that the game’s dataset contains approximately 170 World's Fair speakers.

This is a toy application, but its development loop is consequential: describe a desired result, inspect working software, and refine the request. Wu also had Devin build the QR-code website used to share the game. The same tool was already being used inside Cognition to help build Devin itself.

### A search bar in Devin’s own repository

[3:45](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=225s)

The next example moves from a new application to an existing production codebase. Bryce, a Cognition teammate, asks Devin to create a search bar for the Devin sessions list. The task begins with more context than the name game: a prepared machine snapshot provides the repository environment, a **playbook** supplies repository-specific knowledge, and Git tooling lets Devin create a pull request.

After the first pull request, Bryce asks for a magnifying-glass icon and an implementation idiomatic to the project, naming [Phosphor](https://phosphoricons.com/) as an option. The interaction remains conversational, but the artifact under review is now a repository change rather than a standalone deployment.

![Devin's Create Searchbar Component session showing Bryce's icon request and Devin's response beside a shell workspace.](https://ai.engineer/api/talk-essay-media/d79ef8c8dc1c71bdbdbe88580fb32f1fd63a3e1005f8bca83508f0eef245830b)

Bryce requests a magnifying-glass icon, and Devin acknowledges the search-bar revision.

The exchange also exposes a practical limit. Bryce says there is no need to test, while Devin reports trouble with the login process. Wu confirms that the search-bar pull request was merged; this example establishes a reported production contribution, not successful end-to-end verification. He also credits Devin with building API integrations, internal dashboards, and metrics tracking used by the company.

### From a hacker house to an agent

[5:36](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=336s)

Work began in November 2023, roughly seven months before this June 2024 talk, in a hacker house in Burlingame. Several teammates already lived together, each brought experience in AI, and they shared an intention to build a coding agent. The team subsequently moved between hacker houses, including one in New York, renting progressively larger Airbnbs as it grew. At the time of the talk, the plan was to settle in one place.

The product direction starts with a distinction between completing text and deciding what to do. A language model takes a prefix and generates a suffix. Wu uses ChatGPT, question-answering systems, marketing copy, customer support, GitHub Copilot, and Cursor as examples of valuable products built around that interaction. This is his framing of the product landscape at the time of the talk.

**An agent adds autonomous decisions to the generation process.** That creates new possibilities, but also raises the required level of consistency: the system must choose useful actions, not merely provide useful text. Building Devin therefore involves two distinct problems—improving its ability to complete work and designing an interface through which people can direct and understand that work.

### Why code gives agents a useful feedback loop

[7:43](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=463s)

The team’s enthusiasm for teaching AI to code is one motivation, but software engineering also fits the agent pattern unusually well. Much of the job happens outside the act of typing code: inspecting files, running commands, consulting documentation, opening a front end to reproduce a bug, making an edit, and trying again. An agent can participate in that sequence because each step creates information that helps determine the next action.

Consider Wu’s hypothetical assignment: fix one bug in a production system containing thousands of files and hundreds of thousands of lines. Reading the whole system and immediately producing the correct change would be difficult for a human or an AI. The practical route is investigation:

1. Add print statements to expose relevant runtime behavior.
2. Inspect logs and monitoring to see what actually happened.
3. Move between the implicated files to narrow the diagnosis.
4. Run code after a decision and use the result to choose the next step.

**Execution supplies evidence that static inspection alone does not.** The agent can revise its understanding rather than committing to its first guess.

Wu also expects the underlying capabilities to improve quickly. In his assessment, even the name-game demonstration would have been almost unthinkable two years earlier. Looking ahead another two years, he expects better data and training to keep expanding what agents can accomplish.

### Supervision needs more than a chat window

[9:53](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=593s)

The obvious interface models are familiar software and human collaboration. Showing Devin’s computer and commands resembles looking over an intern’s shoulder. But neither analogy fully captures an agent’s needs: parallel work, information gathering, and context management behave differently enough to require their own product decisions.

The resulting feature set extends well beyond shell access, code editing, and web browsing:

- **Session control:** Fork work into another session or roll it back.
- **Team integration:** Connect work to Slack and GitHub.
- **Prepared context:** Supply playbooks and stored machine snapshots.
- **Operational support:** Manage secrets and provide appropriate verification tools.

These controls are part of making the agent usable, alongside improving its ability to write and debug software.

A recently shipped feature at the time made Devin’s machine directly accessible through [VS Code Live Share](https://visualstudio.microsoft.com/services/live-share/). Instead of describing every edit in chat, a human could enter the shared environment, change a few lines, and tell Devin what had changed. Collaboration could therefore alternate between natural-language direction and direct intervention in the files.

### Delegating work asynchronously

[11:52](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=712s)

Cognition’s own workflow had become more asynchronous. Wu describes an engineer with four tasks assigning them to four Devin sessions running in parallel. The engineer then coordinates the work much like an engineering manager. His analogy is “enthusiastic interns”: the agents try hard, but lack knowledge, make mistakes, and ask questions. Parallelism still requires supervision and iteration.

A same-day example makes that workflow concrete. During a Slack discussion about a color change, a teammate can mention `@Devin` and ask it to make the change. Devin produces a pull request; a human merges it. The slide shows the request in the conversation where the work originated, with the relevant interface context attached.

![Slide titled Devin changed our workflow for building Devin, with a Slack thread mentioning Devin, an embedded workspace screenshot, and a Devin system reply.](https://ai.engineer/api/talk-essay-media/367d858e490e7b7f745409cb1f3841dfd7e7ebccc97b2e6f5ae32a3f8ed36d1e)

A Slack thread delegates a Live indicator color change to Devin.

Wu says teammates have made requests from the gym or a car, without their development computer available, and reviewed the code afterward. The change is not simply a different way to enter code: specifying a task and reviewing its implementation no longer have to happen in the same sitting.

### Deciding what to build remains engineering work

[13:16](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=796s)

What does this leave for software engineers? Wu starts with a boundary: **Devin does not decide what should be built.** He divides engineering into two kinds of work that currently occupy the same person’s day.

| Work | Decisions and activities |
|---|---|
| Solution design | Architecture, user flows, details, edge cases |
| Implementation | Debugging, functions, unit tests |

The first establishes the solution to pursue; the second turns that solution into working software. Wu estimates that an average engineer currently spends 10–20% of their time on thinking and solution design and 80–90% on implementation. He presents this as an estimate, not a measured time-use study.

His expectation is that better agents will free engineers to spend more time on the first category. Kubernetes setup, debugging broken APIs, version changes, and migrations are examples of implementation work he hopes to delegate. The remaining role would put more emphasis on understanding problems and designing solutions, combining aspects of a technical architect and a product manager. This is a direction for an early technology, not a claim that those responsibilities have already been automated away.

### Cheaper implementation could mean more software

[15:07](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=907s)

Wu predicts that the job will change while the number of software engineers grows. His historical analogy runs from punch cards to assembly to C: the mechanics of programming changed, yet programming became more widespread. The argument depends on how much useful software remains unbuilt, rather than assuming that today’s workload is fixed.

He describes software as the leading driver of world progress over the preceding 40–50 years, while arguing that its potential remains far from exhausted. Wu estimates that demand for software is substantially more than 10 times current output. Wu projects that engineers could become 5–10 times more effective while the total amount of software engineering increases. These are economic expectations and a productivity forecast, not measured results from the demonstrations. In that view, easier implementation both expands what existing engineers can attempt and lets more people participate.

### Access and executable verification

[16:27](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=987s)

The first audience question is practical: how can people get access? At the time of the talk, Cognition was admitting more users each week and expanding its enterprise customer rollout, but still had substantial waitlists. Wu gives no firm access date.

The next question asks how Devin checks generated code and whether it can actually run the application. In Cognition’s repository, Wu explains, Devin receives an instantiated machine configured to run the development environment, server, and front end. For a debugging task, it can open the application, reproduce the reported problem, debug it, and try again. When the audience member characterizes the environment as fully executable, Wu confirms it. The verification mechanism is access to the running system and its behavior, not just another reading of the generated code.

### How do junior engineers learn?

[17:34](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1054s)

Automating simpler tasks raises a different concern: those tasks are also how interns and junior engineers learn. Asked what happens to that training path, Wu expects demand to rise with supply and the training process to change.

His answer centers on what makes an engineer strong. Typing speed is less important than understanding a problem, knowing alternative architectures, and recognizing edge cases. He expects junior engineers to practice those fundamentals earlier as agents take on more implementation. That identifies the skills he believes will remain valuable, though it does not supply a replacement curriculum for learning them.

### Progress has to come across the stack

[18:42](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1122s)

The final question asks for the biggest challenges to realizing this future. Wu’s answer spans speed, consistency, access, integrations, and product UX. No single capability improvement resolves all of them: an agent must do useful work reliably, fit the systems around it, and give people workable ways to collaborate.

He expects progress from complementary sources—new hardware, stronger foundation models, and agentic research—with many optimizations improving different parts of the stack. His optimism is about their combined effect. A better coding agent will not arrive through one small breakthrough; it will emerge as the execution environment, underlying capabilities, and collaboration product improve together.

## Resources

- [Introducing Devin](https://cognition.com/blog/introducing-devin) — Scott Wu's original announcement explains Devin's tools, planning, collaboration, and early demonstrations.
- [Devin's 2024 release notes](https://docs.devin.ai/release-notes/2024) — A dated record of Devin's early playbooks, snapshots, Slack integration, and shared-machine controls.
- [Phosphor Icons](https://phosphoricons.com/) — An icon family for interfaces, including the kind of search icon discussed in the production demo.
- [Visual Studio Live Share](https://visualstudio.microsoft.com/services/live-share/) — Microsoft's collaborative development tool supports shared editing, debugging, terminals, and servers.
- [Devin's general availability announcement](https://cognition.com/blog/devin-generally-available) — The December 2024 announcement records Devin's expansion beyond its early-access rollout.

## Slides

### Presenting sponsor: Microsoft

Microsoft is the presenting sponsor.

[0:05](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=5s) [Microsoft logo beneath the presenting sponsor heading.](https://assets.ai.engineer/sites/aiecode2025/sha256/5d3d51b7f4395ac7638521872389073b482489fa8b12ec0e10957e6f0474a758.webp)

PRESENTING SPONSOR

Microsoft

### Innovation and platinum sponsors

AWS is the innovation sponsor; MongoDB, Google Cloud, and Neo4j are platinum sponsors.

[0:10](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=10s) [AWS is the innovation sponsor; MongoDB, Google Cloud, and Neo4j are platinum sponsors.](https://assets.ai.engineer/sites/aiecode2025/sha256/09962715b0419e10411edab1add3d7c5968958c129dfabbc35abaa9b3b5d4f8e.webp)

INNOVATION SPONSOR
aws

PLATINUM SPONSORS
MongoDB®
Google Cloud
neo4j

### The Making of Devin

Scott Wu introduces the early making of Devin and a look at the wider space and what comes next.

[0:15](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=15s) [Title slide for The Making of Devin, presented by Scott Wu, CEO of Cognition AI.](https://assets.ai.engineer/sites/aiecode2025/sha256/5f4074c745758c847a211d57340a1ef60c15a89354277790f6176d4359d41bce.webp)

The Making of Devin

Scott Wu
CEO, Cognition AI

### Devin plans the name game

Devin lays out steps for a game that asks players to match a name to one of two images. It also asks whether to embed the TSV data or fetch it from a server, and invites design preferences.

[1:12](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=72s) [Devin’s workspace shows a conversation about the name game alongside its initial project plan.](https://assets.ai.engineer/sites/aiecode2025/sha256/2e31a73f47fc5bcba992260ca45c710500f494993491f98e456f67b718b2ca12.webp)

Build Name Game Website

Devin 7:00 AM
Got it, I'll start working on the "World's Fair Name Game" website. It will display two images and a name, and users will guess which image matches the name. I'll make sure it's user-friendly on both desktop and mobile.

Devin 7:01 AM
I'm currently setting up the project structure and will soon start on the initial development of the game. I noticed the data is provided in a TSV file; should I use this data directly embedded into the website, or do you want the images and names to be fetched from a server dynamically?

Also, are there any specific design preferences or color schemes you'd like me to follow for the website? If I don't hear back, I'll proceed with a clean and modern design that's visually appealing and user-friendly.

Created project directory "name-game-website".

Devin is awaiting your response. Or type 'EXIT' to end the session.
Session will end automatically in 24.0 hours.

Devin's Workspace
Shell  Browser  Editor  Planner

Current Focus: Set up a new directory for the project to organize files.

Plan:
• Set up a new directory for the project to organize files.
• Initialize a simple vanilla React application with Chakra UI for styling.
• Create the game logic to display two images and a name, and handle user interactions for guessing.
• Design the UI to be mobile-friendly and ensure text and images are large and easy to interact with.
• Test the application locally to ensure it works correctly on both desktop and mobile.
• Deploy the application to Netlify and ensure it is accessible online.

Interface text:
Google Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 27  2:42 PM
AI Dot Engineer Talk - Go[illegible]
Devin (the Developer)
React App
React App
React App
Devin (the Developer)
Devin (the Developer)
preview.devin.ai/devin/a0b9cdb9c1734d9387b69c460d796e43?ts=1719499426406
Following
Send a message
Live
Share your feedback!

### Name game progress

The replayed planner focuses on initializing React, while the activity log lists later work from TSV parsing to a reported Netlify deployment.

[1:40](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=100s) [A progress summary appears beside the planner, which shows the project directory step checked.](https://assets.ai.engineer/sites/aiecode2025/sha256/d7861407ccf2de68ebdee438bcd7dfab50169d7885655b55eb8664c4abe625e7.webp)

Build Name Game Website

7:01 AM
✓ Created project directory "name-game-website".
✓ Initialized a simple vanilla React application with Chakra UI for styling.
✓ Parsed TSV data and generated data.json file.
✓ Edited App.js to integrate data from data.json and ensure mobile-friendly design.
✓ Addressed warnings related to the `useEffect` hook in App.js.
✓ Resolved infinite loop error in `useEffect` hook by adjusting state update logic.
✓ Verified game functionality and UI alignment through browser interaction and screenshots.

Devin 7:35 AM
The "World's Fair Name Game" has been successfully deployed to Netlify. You can access the game at the following URL: http://shimmering-horse- [remainder not visible]

Devin is awaiting your response. Or type 'EXIT' to end the session.
Session will end automatically in 24.0 hours.

Send a message

Devin's Workspace
Following
Shell  Browser  Editor  Planner

Current Focus: Initialize a simple vanilla React application with Chakra UI for styling.

Plan:
☑ Set up a new directory for the project to organize files.
☐ Initialize a simple vanilla React application with Chakra UI for styling.
☐ Create the game logic to display two images and a name, and handle user interactions for guessing.
☐ Design the UI to be mobile-friendly and ensure text and images are large and easy to interact with.
☐ Test the application locally to ensure it works correctly on both desktop and mobile.

Live
Share your feedback!

Interface text:
Google Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 27 2:42 PM
AI Dot Engineer Talk - Go[illegible]  Devin (the Developer)  React App  React App  React App  Devin (the Developer)  Devin (the Developer)
preview.devin.ai/devin/[redacted]
Arc
Google Chrome
Cursor 0.33.1-arm64
Screenshot [illegible]

### Planner progress

In the planner replay, setup and TSV integration are checked, while mobile-friendly design is the current focus. The activity log alongside it reports later fixes and a Netlify deployment.

[1:51](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=111s) [The planner shows setup and data integration checked, with mobile-friendly design as the current focus.](https://assets.ai.engineer/sites/aiecode2025/sha256/54c89c33fb5af6e170b694f7be49e7665b3c98e7c8fdf51c6d7acf6e1ffa8f9f.webp)

Build Name Game Website

Created project directory "name-game-website".
7:03 AM Initialized a simple vanilla React application with Chakra UI for styling.
7:06 AM Parsed TSV data and generated data.json file.
Edited App.js to integrate data from data.json and ensure mobile-friendly design.
Addressed warnings related to the `useEffect` hook in App.js.
Resolved infinite loop error in `useEffect` hook by adjusting state update logic.
Verified game functionality and UI alignment through browser interaction and screenshots.

Devin 7:35 AM
The "World's Fair Name Game" has been successfully deployed to Netlify. You can access the game at the following URL: http://shimmering-horse-[illegible]

Devin is awaiting your response. Or type 'EXIT' to end the session.
Session will end automatically in 24.0 hours.

Devin's Workspace

Current Focus: Design the UI to be mobile-friendly and ensure text and images are large and easy to interact with.

Plan:
☑ Set up a new directory, initialize a vanilla React application, and install Chakra UI for styling.
☑ Parse the TSV data and integrate it into the React application.
☐ Design the UI to be mobile-friendly and ensure text and images are large and easy to interact with.
☐ Test the application locally to ensure it works correctly on both desktop and mobile.
☐ Deploy the application to Netlify and ensure it is accessible online.

Interface text:
Google Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 27 2:42 PM
AI Dot Engineer Talk - Go[illegible]  Devin (the Developer)  React App  React App  React App  Devin (the Developer)  Devin (the Developer)
preview.devin.ai/devin/a0b9cdb9c1734d9387b69c460d796e43?ts=1719499426406
Following
Shell  Browser  Editor  Planner
Send a message
Live
Share your feedback!

### Name game source data

Devin inspects the TSV of names, companies, and image URLs while building the game. The progress log records parsing the data, integrating it into the app, and deploying a first version.

[1:53](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=113s) [The editor displays a table of names, companies, and image URL fields beside the project progress summary.](https://assets.ai.engineer/sites/aiecode2025/sha256/e81fdc0bf88f428142928c792db6d5b327edad693e6ac7e0ffc59702161e597d.webp)

Build Name Game Website

Created project directory "name-game-website".
Initialized a simple vanilla React application with Chakra UI for styling.
7:06 AM  Parsed TSV data and generated data.json file.
Edited App.js to integrate data from data.json and ensure mobile-friendly design.
Addressed warnings related to the `useEffect` hook in App.js.
Resolved infinite loop error in `useEffect` hook by adjusting state update logic.
Verified game functionality and UI alignment through browser interaction and screenshots.

Devin  7:35 AM
The "World's Fair Name Game" has been successfully deployed to Netlify. You can access the game at the following URL: http://shimmering-horse-[illegible]

Devin is awaiting your response. Or type 'EXIT' to end the session.
Session will end automatically in 24.0 hours.

Devin's Workspace
Following
Shell  Browser  Editor  Planner
worldsfair.tsv  App.js
home > ubuntu > name-game-website > src > worldsfair.tsv

Name  Company  Image URL
Chris Lattner  Modular  https://aie-cms-uploads.s3.us-west-1.[illegible]
Justine Tunney  Mozilla  https://aie-cms-uploads.s3.us-west-1.[illegible]
Thomas Dohmke  GitHub  https://aie-cms-uploads.s3.us-west-1.[illegible]
Alex Albert  Anthropic  https://aie-cms-uploads.s3.us-west-1.[illegible]
Lin Qiao  Fireworks  https://aie-cms-uploads.s3.us-west-1.[illegible]
Romain Huet  OpenAI  https://aie-cms-uploads.s3.us-west-1.[illegible]
Simon Willison  Independent  https://aie-cms-uploads.s3.us-[illegible]
Scott Wu  Cognition (Devin)  https://aie-cms-uploads.s3.us-[illegible]
Stefania Druga  Google  https://aie-cms-uploads.s3.us-west-1.[illegible]
Daniel Han  Unsloth  https://aie-cms-uploads.s3.us-west-1.[illegible]
Dylan Patel  SemiAnalysis  https://aie-cms-uploads.s3.us-[illegible]
Keelin McDonell  Google  https://aie-cms-uploads.s3.us-west-1.[illegible]
Devendra Chaplot  Mistral  https://aie-cms-uploads.s3.us-[illegible]
Sandra Kublik  Cohere  https://aie-cms-uploads.s3.us-west-1.[illegible]
Vivek Muppalla  Cohere  https://aie-cms-uploads.s3.us-west-1.[illegible]
Cheng Lou  Midjourney  https://aie-cms-uploads.s3.us-west-1.[illegible]
Lukas Biewald  Weights & Biases  https://aie-cms-uploads.s3.us-[illegible]
Shelby Heinecke  Salesforce  https://aie-cms-uploads.s3.us-[illegible]
Harrison Chase  LangChain  https://aie-cms-uploads.s3.us-[illegible]
Jason Liu  Independent  https://aie-cms-uploads.s3.us-[illegible]
Ben Hylak  Dawn Analytics  https://aie-cms-uploads.s3.us-[illegible]

Interface text:
Google Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 27  2:42 PM
AI Dot Engineer Talk - Go[illegible]  Devin (the Developer)  React App  React App  React App  Devin (the Developer)  Devin (the Developer)
preview.devin.ai/devin/a0b9cdb9c1734d9387b69c460d796e43?ts=1719499426406
Send a message
Live
Share your feedback!
Arc  Google Chrome  Cursor 0.33.1-arm64

### Initial name game

The first version marks Derek Bingham’s answer correct, but still shows both names. The speaker asks Devin to hide them until an answer is clicked and restyle the Play Again button.

[2:04](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=124s) [The name game shows two portraits, their names and a correct answer.](https://assets.ai.engineer/sites/aiecode2025/sha256/b1ad6d59773ad134aef09a3e585d6354d15074d796049dfbc9b14fda3678aa29.webp)

World's Fair Name Game

Derek Bingham at AWS
Jason Liu at Independent

Derek Bingham
Correct!
Play Again

Interface text:
Google Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 27 2:43 PM
AI Dot Engineer Talk
Devin (the Developer)
React App
shimmering-horse-412e5a.netlify.app
Arc
Google Chrome
Cursor 0.33.1-arm64

### Requesting a streak counter

Scott asks Devin to count consecutive correct guesses and reset the streak to zero after a wrong answer. Devin says it will implement the change.

[2:34](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=154s) [A Devin conversation requests a counter for consecutive correct answers that resets after a wrong answer.](https://assets.ai.engineer/sites/aiecode2025/sha256/9c981adb36a9fad99ceba30842a5716574b70fc5ead78e86307fd74a68ba3212.webp)

Build Name Game Website

in-place with the command `deploy_netlify build_dir [token]`.

If you have any further requests or need additional changes, feel free to let me know!

Communicated progress and provided the Netlify site token to the user.

You 7:52 AM
Amazing! Now can you add a streak counter that keeps track of how many I got right in a row and resets to 0 when I get one wrong?

Devin 7:52 AM
Absolutely, Scott! Adding a streak counter sounds like a great feature to enhance the game experience. I'll get started on implementing this feature so that it keeps track of the correct guesses in a row and resets when a guess is incorrect. I'll update you once I have made progress on this.

Devin is awaiting your response. Or type 'EXIT' to end the session.
Session will end automatically in 24.0 hours.

World's Fair Name Game
Fryderyk Wiatrowski
Play Again

Interface text:
Devin's Workspace
Following
Shell  Browser  Editor  Planner
http://localhost:3000/
Devin's view  Interactive
Live
Send a message
Share your feedback!
Google Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 27 2:43 PM

### Correct answer and streak

The name game reveals both identities after a guess: Justine Tunney is the correct choice, and the streak reaches 1.

[2:45](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=165s) [The updated name game shows a correct answer and a streak of one.](https://assets.ai.engineer/sites/aiecode2025/sha256/03214eae8cc8320bf76989f97dfbf3dca2ae44058c6893f3cc1197a82d7ea720.webp)

World's Fair Name Game

Justine Tunney
Streak: 1

Chris Rec at WhyHow.AI
Justine Tunney at Mozilla

Correct!
Play Again

Interface text:
Google Chrome
File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 27  2:43 PM
AI Dot Engineer [illegible]
Devin (the Devel[illegible]
React App
gleeful-pavlova-156cd3.netlify.app
Arc
Google Chrome
Cursor 0.33.1-arm64

### Incorrect answer resets the streak

The presenter deliberately chooses the wrong person. The game reveals Chang She as the correct answer and resets the streak to zero.

[2:56](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=176s) [The game displays an incorrect answer, reveals the correct person and shows a streak of zero.](https://assets.ai.engineer/sites/aiecode2025/sha256/9577cbd4da2434d162bcec2b418f75c92a4d1ad62d484341d8e048f7dbd0bbc9.webp)

World's Fair Name Game

Chang She
Streak: 0

Chang She at LanceDB
Dominik Kundel at Twilio

Incorrect! It was Chang She at LanceDB

Play Again

Interface text:
Google Chrome
File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 27 2:44 PM
gleeful-pavlova-156cd3.netlify.app

### Play the name game

The QR code and short link invite the audience to play a game featuring the World's Fair speakers. The speaker estimates there were about 170 speakers at the fair that week.

[3:06](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=186s) [A large QR code and a short link invite the audience to play the name game.](https://assets.ai.engineer/sites/aiecode2025/sha256/db49e5f2575dcead8a2f485186a398f84ce7889237376730b109c90f674b72d6.webp)

https://tinyurl.com/worldfair-name-game

Interface text:
Google Chrome
File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 27 2:44 PM
leafy-douhua-9a49ec.netlify.app
React App
Arc

### How We Started

The team started in a Burlingame hacker house to build a coding agent, then moved between houses as it grew. Photos show the team working together at home and posing outdoors.

[5:28](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=328s) [Two photographs show people working together in a home and posing outdoors.](https://assets.ai.engineer/sites/aiecode2025/sha256/df41633bdd34563bfb1d89c0fb090adee32136055b32e23ae5927f896980cd11.webp)

How We Started

### Why We Built Devin

Devin targets a next wave of autonomous decision makers after text completion. Building it poses both a capabilities challenge and a new agent UX design problem.

[6:15](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=375s) [A slide contrasts text completion with autonomous agents and describes the capabilities and product design challenges of building Devin.](https://assets.ai.engineer/sites/aiecode2025/sha256/5c18c279f260c88c875da951f687403672c65b878952c360df0a089462d352ee.webp)

Why We Built Devin

• First wave of GenAI products: Text completion
• Next wave: autonomous decision makers (agents)
• Building Devin requires solving both a deep capabilities problem and a novel product design problem.

### Why We Built Devin

Software engineering suits agents: debugging involves inspecting files, running commands, editing and trying again. Code feedback supports iteration, while model agentic capabilities are rapidly improving.

[7:41](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=461s) [Slide lists agentic workflows, code feedback, and improving model capabilities as reasons to focus on coding.](https://assets.ai.engineer/sites/aiecode2025/sha256/b3844e177009703c42d8df2ede89940e96cc9affd45b9e7f8c7d92b7471c3f5d.webp)

Why We Built Devin

• Why code?

• Agents in code are exciting for 3 reasons
  ○ SWE lends naturally to an agentic workflow
  ○ Ability to iterate with code feedback is crucial
  ○ Model agentic capabilities are rapidly improving.

### Devin task interface

Devin’s landing screen invites a coding task. The speaker frames agent UX as a deeper product problem: agents handle parallel work, information gathering, and context differently from people or conventional software.

[9:53](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=593s) [Devin landing screen introduces the software engineer agent and provides a field for a coding task.](https://assets.ai.engineer/sites/aiecode2025/sha256/6bec7f8ba534ec464fb5205d4cb22f9a115253bb57214d50c945304a0c2044db.webp)

Hey there! I'm Devin and I'm a software engineer.

Enter a coding task below to get started.

Give Devin a task to work on...

Interface text:
Devin
Devin
About us
Request access
Login

### Building Agentic Products

Devin’s brain and planner sit among interfaces, tools and resources. Product features include session controls, verification tools and teams of Devins.

[10:38](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=638s) [Diagram places Devin's brain and planner among product features, interfaces, tools, and resources.](https://assets.ai.engineer/sites/aiecode2025/sha256/4bf542d0ed606d0918f22d35816e4cb8375798f9b900eec5d7d013f654e626d1.webp)

Building Agentic Products

Product Features
Fork, Rollback and Resume
Interactive Browser, Shell, Editor
Tools to verify Devin’s Work
Teams of Devins

User Interfaces & Communications
Integrations: Slack, Github, etc
Mobile
Desktop

Devin’s Brain and Planner

Devin’s Tools
Shell
Editor
Browser

Devin’s Resources
Knowledge / Memory
Playbooks
Machine Snapshots
Secrets

### Building Agentic Products: Code Editor

A newly shipped feature lets users work in Devin’s machine through VS Code Live Share, edit code, and discuss changes with Devin. The editor shows a website component.

[11:29](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=689s) [Slide shows a code editor open to a website component during a Devin demonstration.](https://assets.ai.engineer/sites/aiecode2025/sha256/2454b44574c973a4e2abc4cb3fa33a56bad9e111b9a87e50de42be307714de29.webp)

Building Agentic Products

<script setup lang="ts">
</script>

<template>
  <header class="bg-[url('https://flowbite.s3.amazonaws.com/blocks/marketing-ui/articles/background.png')] w-full h-[460px] xl:h-[537px] bg-no-repeat bg-cover bg-center bg-blend-darken relative">
    <div class="absolute top-0 left-0 w-full h-full bg-black bg-opacity-50"></div>
    <div class="absolute top-20 left-1/2 px-4 mx-auto w-full max-w-screen-xl -translate-x-1/2 xl:top-1/2 xl:-translate-y-1/2 xl:px-0">
      <nav class="flex justify-between items-center">
        <a href="#" class="text-white text-2xl font-bold">NewsDaily</a>
        <ul class="flex space-x-4">
          <li><a href="#" class="text-white hover:underline">Software</a></li>
          <li><a href="#" class="text-white hover:underline">Pricing</a></li>
          <li><a href="#" class="text-white hover:underline">Resources</a></li>
        </ul>
        <div class="relative">
          <input type="text" class="px-4 py-2 rounded-full" placeholder="Search...">
        </div>
      </nav>
    </div>
  </header>
  <ul>
    <li>
      <a href="#" class="block py-2 pr-4 pl-3 border-b border-gray-100 text-primary-600 hover:bg-gray-50 lg:hover:bg-transparent lg:border-0 lg:hover:text-primary-600 lg:p-0 dark:text-primary-500 lg:dark:hover:text-primary-500 dark:hover:bg-gray-700 dark:hover:text-primary-500 lg:dark:hover:bg-transparent dark:border-gray-700" aria-current="page">Home</a>
    </li>
    <li>
      <a href="#" class="block py-2 pr-4 pl-3 text-gray-700 border-b border-gray-100 hover:bg-gray-50 lg:hover:bg-transparent lg:border-0 lg:hover:text-primary-600 lg:p-0 dark:text-gray-400 lg:dark:hover:text-primary-500 dark:hover:bg-gray-700 dark:hover:text-primary-500 lg:dark:hover:bg-transparent dark:border-gray-700">Features</a>
    </li>
    <li>
      <a href="#" class="block py-2 pr-4 pl-3 text-gray-700 border-b border-gray-100 hover:bg-gray-50 lg:hover:bg-transparent lg:border-0 lg:hover:text-primary-600 lg:p-0 dark:text-gray-400 lg:dark:hover:text-primary-500 dark:hover:bg-gray-700 dark:hover:text-primary-500 lg:dark:hover:bg-transparent dark:border-gray-700">Marketplace</a>
    </li>
    <li>
      <button type="button" id="dropdown-button" data-dropdown-toggle="dropdown" class="flex justify-between items-center py-2 pr-4 pl-3 w-full font-medium text-gray-700 border-b border-gray-100 lg:w-auto hover:bg-gray-50 lg:hover:bg-transparent lg:border-0 lg:hover:text-primary-600 lg:p-0 dark:text-gray-400 lg:dark:hover:text-primary-500 dark:hover:bg-gray-700 dark:hover:text-primary-500 lg:dark:hover:bg-transparent dark:border-gray-700">Company <svg class="ml-1 w-5 h-5 lg:w-4 lg:h-4" [illegible]

Interface text:
ubuntu
EXPLORER
UBUNTU
App.vue
NewsDaily > vite-flowbite-setup-zip-for-devin > src > App.vue
OUTLINE
TIMELINE
feature/responsive-design
Ln 1, Col 1
Spaces: 4
UTF-8
LF
Plain Text
Layout: U.S.
9

## Full transcript

[0:00](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=0s) [upbeat music] I'm Scott from Cognition AI, and I'm gonna tell you guys a little bit about, um, you know, the, the, the early makings of Devin.

[0:20](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=20s) We're still super, super early on, and, and also a little bit about kind of the space as a whole and, and what's coming next. Um, and I thought it'd be nice to, to start with a demo first.

[0:29](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=29s) Um, uh, it sounds like some of you guys have, have already seen some of the videos, but I brought a nice custom one here for the World's Fair today.

[0:35](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=35s) Um, so I'll just show that quickly. And here, I basically said, "Hey, Devin..." This was this morning, by the way. This was a huge scramble. I, I said, "Hey, Devin, uh, I want you to build a mobile-friendly website to play the name game."

[0:47](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=47s) So I have a lot of trouble memorizing names and faces. I don't know about you guys. Um, but I basically just said, you know, "Here's a, here's a TSV file of a bunch of names and faces."

[0:57](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=57s) These are all the speakers, uh, 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," right?

[1:08](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=68s) And I gave kind of a few instructions on how the game should work.

[1:12](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=72s) And so Devin is a fully autonomous software engineer, and what that means is Devin has access to all the same tools that a human software engineer would have when it was building-- w-when, when they were building something like this.

[1:23](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=83s) And so the first thing that Devin's gonna do is Devin's gonna make a plan. Um, and you can see here, you know, kind of a basic plan coming out.

[1:30](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=90s) Um, one of the interesting things about this is the plan changes a lot over time, and so, you know, as you get new information or new feedback, you update your plan accordingly with that too.

[1:40](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=100s) After that, Devin's basically just running this the same way that a human would. And so if you can take a look, you know, Devin makes a new directory for the name game website, starts a new React app, you know, all, all the same primitives.

[1:50](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=110s) Um, works on building it out and building the code. You know, reads the TSV file to take a look, uh, at what's going on here. Um, and is just kinda generally working through it and jumping through.

[2:00](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=120s) Um, it comes out and deploys this first version after, after some minutes, and I'll just pull this up quickly. So that's what this looks like. Um, it's, it's close, but not quite there, right?

[2:09](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=129s) I mean, it shows the-- It's still showing the names, and I think maybe I didn't quite specify that exactly. Um, but, you know, you can click, uh, the name and it got that correct.

[2:17](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=137s) Um, and so I just went ahead and just gave it some more feen- feedback in plain English. And so I said, "Hey, you know, can you hide the two names until I click on the answer?

[2:24](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=144s) And also, can you properly restyle the Play Again button?" It's like, you know, somehow it's a, it's a little off on this page. Um, and I kept going, uh, and just, just kinda gave it more and more feedback over time.

[2:34](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=154s) And I also asked it, "Hey, can you add a streak counter as well? You know, can you, can you keep track of how many I got correct and, you know, reset to zero?"

[2:41](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=161s) Um, you know, a few of these other things. Um, and the website it ultimately deployed, uh, was this one right here. And so this is Justine, for example. Keeps track of my streak, and you can see it's kind of, uh, ramping it up.

[2:53](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=173s) And so, you know, if I were to, for example, um,

[2:57](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=177s) if I got this one wrong on purpose, then you would see the streak would reset to zero, you know, and it would go on. And so I actually played this game and, and learned the names of everyone, which was, which was super helpful, by the way. [laughs]

[3:07](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=187s) And, uh, you know, you guys can play it too. It's, uh, it's right here if you wanna try it out. This has all the speakers. I think it was something like a hundred and seventy speakers here at the, at the World's Fair, um, this week.

[3:16](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=196s) So, you know, this is kind of a cool example. Um, but, you know, I, I, I wanna highlight how different the world is if software engineering is just this easy, you know, if you can just explain exactly what you want in plain English, um, and, and get that out.

[3:30](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=210s) Um, and so, you know, this is obviously kind of a toy use case and it, it's, it's perhaps useful, but we use Devin all the time ourselves when we're building Devin, actually.

[3:38](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=218s) Um, and by the way, I, obviously, I, I didn't make this website myself. I just said, "Hey, can you g- build me this website with the QR code and whatever?"

[3:45](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=225s) Uh, and Devin built that too. But, um, you know, here, here's a, here's a quick example of Devin, uh, that we're using ourselves in production. And so, you know, if you take a quick look here, for example, there's this whole search bar and, um, there's all the sessions, and you can search across sessions, right?

[4:00](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=240s) Uh, Devin actually made that in the Devin repository. Um, 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?

[4:09](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=249s) Here's what I need you to do." Um, and so there's a few features about this in particular that are obviously, um, tuned for working in a production codebase. You can see here that Devin started from a snapshot, so th- we have a machine instance loaded where it's cloned from.

[4:23](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=263s) It has a playbook, so it knows, like, a lot of the details about our repositories. 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.

[4:34](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=274s) And so I'll just kinda go through this quickly. So yeah, Devin says, "Absolutely." You know, makes the first pull request. Bryce continues, and again, you're, you're just giving feedback in plain English, right?

[4:42](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=282s) And you say, "Hey, this is a great start. You know, now could you, could you add a magnifying glass, um, and make it idiomatic? You know, use Phosphor or luc- you know, it's up to you," right?

[4:51](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=291s) Uh, and Devin says, "Yeah, sure, I'll build that." Um, Bryce says, "Oh, by the way, no need to test, you know, I trust you." Um, mmm, and Devin says, "By the way, I'm dealing with a bit of an issue with the login process."

[5:01](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=301s) You know, it's just like you're working with, with another engineer, right? And Devin s- and Bryce says, uh, "Okay, bro." Uh, and you know, it kind of builds it all and gets the PR, and this PR was actually merged, and this is, you know, the search bar, right?

[5:13](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=313s) And similarly, you know, a lot of the API integrations that Devin has were built by Devin. You know, a lot of our own internal dashboards and metrics tracking within Devin were actually also built by Devin.

[5:24](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=324s) Um, and it's been kind of a, kind of a fun one to see, like, Devin building the company with the company as well. Um, so cool. Yeah. I, I wanna talk a little bit about, you know, our journey so far and, and about what's happening in the space as well.

[5:36](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=336s) And so, um, you know, we got started back in November, um, so it's been about seven months now. Um, it's kind of funny. We started in a hacker house in Burlingame, uh, and it was basically just a lot of us had already, like, lived together at that point.

[5:49](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=349s) You know, we'd all had our own journeys in AI, and 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.

[5:57](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=357s) Um, and then that hacker house in the [REDACTED:location]. After that, there was another hacker house in New York. Then there was another hacker house in the [REDACTED:location].

[6:03](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=363s) So we were actually-- we, we've been going back and forth between New York and the [REDACTED:location] for Basically the last seven months. I think at this point we are now gonna, like, settle in the [REDACTED:location], but it's been going back and forth and getting, like, a slightly bigger Airbnb each time because the team also gets a little

[6:15](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=375s) bit bigger. Um, but you know, why, why Devin in particular?

[6:20](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=380s) Um, and, you know, this is, this is a, um, particular question that I, that I'm really passionate about, which is, you know, language models have been pretty big. I, I think that's, that's fair to say.

[6:30](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=390s) Um, and you know, the first wave of generative AI is what I generally call these text completion products, right? And you know, that makes a lot of natural sense if you think about it, that obviously the interface of a language model is text completion, right?

[6:42](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=402s) You give it a prefix, and it completes the suffix from there. And so if you think about ChatGPT, if you think about a lot of these Q&A products, if you think about, you know, writing marketing copy or answering customer support or even GitHub Copilot and Cursor and, and products like that, you know, obviously very...

[6:59](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=419s) You know, a lot of these are really great products and, and, and very natural use case where you have the prefix so far and you're asking the models to complete what's next in the suffix, right?

[7:06](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=426s) And it does that for you, and that's a tool that's useful, right? 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.

[7:17](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=437s) Um, and obviously, you know, that's typically referred to in our space as agents, right? And you know, there's, there's all sorts of new things that you unlock, right? There's a, there's a lot higher bar of consistency that you require, but there's new things that you unlock with that.

[7:29](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=449s) Um, and so it's, it's been an interesting one because it's, it's both a very deep core capabilities question of getting Devin to, to solve these, but also a pretty interesting product design problem because I think the, the UX of agents is, is something that's extremely new.

[7:43](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=463s) Um, and then why code in particular? You know, a few different things. Obviously, we're all coding nerds as well. You know, we're all engineers, and so the idea of teaching AI to code is, is, you know, one of the coolest things [chuckles] that we could think of.

[7:55](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=475s) But beyond that, I think there's a few particular reasons that code with agents works especially well. You know, one is that obviously there's so much more to being a software engineer than typing the code, right?

[8:06](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=486s) A, a lot of the work that you're gonna do is, you know, you're gonna be looking into a bug, you're gonna be looking at the different files of the codebase.

[8:13](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=493s) Maybe you're gonna be running this or that command. Maybe you're gonna be pulling up documentation. Maybe you're gonna run the front end yourself to, to reproduce the bug. You know, you look at this thing, you make it-- make this edit, you try it again.

[8:23](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=503s) Um, all, all of this work here obviously is... You know, that's what software engineering is, right? More so than just, uh, than just typing the code in the file, um, which leads very naturally to an agentic workflow.

[8:34](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=514s) You know, another part which I think is closely related is the ability to iterate with code feedback. Um, and so what I mean by that is, you know, if you were given an entire production codebase and you were told, "Hey, this has this one bug.

[8:46](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=526s) I need you to fix it. Here's the bug." Um, you know, and, and it's-- let's say it's, like, thousands of files and, you know, hundreds of thousands of lines of code.

[8:55](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=535s) I mean, it'd be pretty tough, honestly, for most humans. It's also gonna be quite tough for AIs as well. And obviously, the way that we do this in practice is, you know, you, you, you go and add print statements.

[9:06](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=546s) You pull up the logs. You check the monitoring. You know, you, you jump back and forth between different files. You try and diagnose it, right? Each of these things that you're doing, you know, you're, you're making a decision, and then you're running actual code to find out what happened.

[9:18](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=558s) And from that, you're, you're able to iterate, and it just gives you a much cleaner path to solve the problem in front of you. Um, and similarly, you know, that, that kind of lends very well to agents.

[9:26](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=566s) And the last thing I just wanna mention is, you know, how fast model agentic capabilities are improving. Um, and so, you know, two years ago, like, even something as simple as, as this name game demo, I think would've been almost unthinkable.

[9:39](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=579s) Um, and you know, you think about where things are going and where things are gonna be two years from now, I, I think there's a lot of, you know, the data, the, the, the right training and so on that's, that's really, really rapidly improving in the space.

[9:53](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=593s) Um, and then, you know, again, beyond the capabilities problem, there's actually a really deep UX problem as well. Uh, and at a high level, you know, I think what's kinda 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

[10:08](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=608s) 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.

[10:19](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=619s) You know, 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.

[10:26](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=626s) You know, there's a lot of nuances and details of parallel work, information gathering, how it manages context, um, et cetera, et cetera, that are super, super different. And it's actually a quite deep problem from a product perspective as well.

[10:39](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=639s) And just to give you guys a bit of a sense of that, like, here's just a kind of, uh, a short list of some of the features that we've built into the product.

[10:46](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=646s) And so, you know, obviously there's 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.

[10:55](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=655s) You know, being able to handle integrations with Slack and GitHub. Being able to handle playbooks, to, to store machine snapshots, to keep track of secrets. You know, to be able to work with the right tools for verification.

[11:05](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=665s) 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 gonna see actually a lot more iteration with that over time, and I just wanted to show kind of, uh, a new feature which we just recently

[11:21](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=681s) shipped, which is the ability to use Devin's machine. Um, which is kind of-- a-again, it's, it's the kind of thing that's not always, uh... There, there's not necessarily a, a very close parallel in, uh, you know, in, in the software that we have today, right?

[11:35](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=695s) But the ability to just have a VS Code Live Share in Devin's machine and, you know, if you wanna collaborate with Devin and say, "Hey. Oh, there's this, these couple lines," like, you know, "You should make this edit.

[11:44](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=704s) I went ahead and did that edit for you," and you can just talk with Devin and do that, right? Um, so there's a lot more room to go and a lot to iterate on in the space.

[11:52](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=712s) Um- One of the thing, uh, of the things I wanted to mention too is just how much, you know, we've seen it changing our own workflow. Um, so you, 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.

[12:05](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=725s) Uh, one of the cool kind of features of Devin, I'd say, is, you know, if as an engineer you're, you're working on, let's say, four different tasks today, you know, you just give one to Devin number one, you give the second one to Devin number two, the third one to Devin number three.

[12:17](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=737s) You have four Devins that are all running in parallel, and it's kind of turning every engineer into an engineering manager is almost how I describe it. You know, I think the Devins are very, like, enthusiastic interns [laughs] is how...

[12:28](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=748s) What I'd say. I mean, they, they try very hard. You know, they're, they're... Obviously, they don't know everything. They get little things wrong. They ask a lot of questions, but, you know, you're kind of working with each of them and, and having them iterate.

[12:37](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=757s) And so here's just kind of a fun example. I mean, this is literally from, from earlier today. But, you know, we were talking about some particular feature and about what we wanted to build.

[12:46](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=766s) In this case, it was a pretty simple thing of changing the color, but it's just as simple as just saying in Slack, in the conversation, "Hey, [REDACTED:username], can you just change this thing?"

[12:53](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=773s) And then Devin goes and makes a PR, and then you hit merge, you know? And so, um, you know, we've had a lot of occasions where we're, you know, in the gym or in the car or something, and now you can actually write code 'cause, you know, you can tell Devin exactly what you want Devin to do.

[13:05](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=785s) Um, you just don't have your whole computer with you and can't type everything, but, you know, being able to just kind of describe what you want to Devin and then being able to review the code afterward, um, actually works really well.

[13:16](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=796s) So what's next? Um, you know, I, I, I think this is a really important question. Uh, and [laughs] obviously, I think the technology's extremely early today. Um, but, you know, where do these things go in a few years?

[13:26](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=806s) And also, what happens with software engineering? I think there's, there's been a lot of uncertainty about that question. And, you know, as we're using Devin more and more, 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

[13:42](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=822s) to build, you know? And there's this core part of software engineering, the way I describe it is like software engineers everywhere, you know, are, are doing really two jobs at once, right?

[13:50](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=830s) And the first job is basically problem-solving with code. You know, you, you're, you're given a problem, and you're breaking down exactly what is the solution you're gonna build. You know, what is the architecture that you're gonna use?

[14:01](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=841s) 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

[14:18](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=858s) of something that you know you want to do, right? And, you know, I think right now the average software engineer is probably spending like 10 or 20% of the time on that first thinking part, and they're spending 80 or 90% of the time on that implementation part.

[14:30](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=870s) And, you know, what we really see is

[14:33](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=873s) Devin actually just frees you up to do more of the first part, you know? And I, I think the future of Devin, again, it's very, very early, but I think as Devin gets better, we're gonna see more of that, where Devin just frees up the implementation for you, where you don't have to go figure out how to

[14:45](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=885s) set up Kubernetes. You know, you don't have to go, like, debug all these, like, APIs that are broken. You know, you don't have to go, like, 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?

[14:57](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=897s) But you actually are spending all your time on figuring out how to solve the problems in front of you. You know, it's, it's a little more like, um, a mix between, you know, a technical architect and a product manager almost, right?

[15:07](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=907s) And so, you know, I, I think software engineering, the job that we call software engineering, is gonna change. But I think practically, like, there's actually gonna be way more software engineers than ever, you know?

[15:17](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=917s) And, and I, I think there's a lot of precedent for that too, you know. Programming back then, you know, used to mean punch cards, and then after that, it used to mean assembly.

[15:26](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=926s) And, you know, and then after that, it used to mean C, right? And, you know, as these things have gone on, I mean, most people aren't using punch cards anymore.

[15:33](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=933s) But there's actually way more programmers than before, right? And, and I think one of the things that's, um, easy to underestimate is just how much more code there is to write.

[15:42](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=942s) Um, and you know, it's, it's, 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.

[15:52](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=952s) 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. Um, and so, you know, I, I think what happens is we, we get to open up the power of software engineering to a lot more people, and every single software engineer gets

[16:08](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=968s) to be 5 or 10X more effective. But we actually do a lot more software engineering. Um, cool. Yeah, so, so that's all I had. Uh, but yeah, we'd love to open the floor if there's any questions. [audience applauds]

[16:25](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=985s) Yeah, right here in the front.

[16:27](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=987s) Oh, I'll shout out. Okay. Yeah. Well, thanks again. This is great. Uh, blew my mind, like, eight times. [laughs] So, um, how do we get access? Like, to me now [laughs]

[16:36](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=996s) Great question. Great question. So [laughs] so we've been ramping up access. Um, every, every week we've been letting on more and more people. We've also been sizing up with our enterprise customers.

[16:45](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1005s) We have a lot of wait lists to get through [laughs], so we're, we're, we're doing it as fast as we can. Um, but, but we, we'd love to get you guys access as soon as possible.

[16:52](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1012s) Thank you.

[16:53](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1013s) Yeah. Yeah. Um, all the way in the back over there. Yeah, in the red.

[16:59](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1019s) Hey. Uh, so I'm just wondering how much... Like, does Devin have access for running the code whilst in the back end? Like, how are you doing that analysis for correctness for the code in, like, the generation stage?

[17:09](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1029s) 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.

[17:18](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1038s) And so if it's... If you're asking it, "Hey, I need you to debug this particular thing," it'll just pull it up itself and then, you know, reproduce it, and then it'll debug it and try it again.

[17:26](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1046s) Yeah.

[17:26](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1046s) Cool. So it's, like, fully executable.

[17:28](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1048s) Exactly. Yeah. Yeah. Yeah. Any other questions? Right here.

[17:34](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1054s) So with all the simpler tasks potentially being solved by Devin software, how do we not forget about all the juniors, interns that don't know how to code yet? [laughs]

[17:48](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1068s) Yeah.

[17:49](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1069s) It would be good for you to repeat the question.

[17:51](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1071s) Oh, of course. Yeah. So, sorry. So, so someone asked, um, you know, with all of these simpler tasks getting solved, um, what happens to, you know, all the junior engineers or the interns who, who obviously need to learn how to code?

[18:02](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1082s) You know, I, I, 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 gonna change a little bit.

[18:11](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1091s) But, you know, I think a lot of these core fundamentals of, you know, if you think of someone as when you say someone's a really great engineer, typically it do- you don't mean that they type really fast, although maybe they do that too, right?

[18:21](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1101s) You typically mean that they, they have a really great understanding of problems. You know, they know all the different architectures. They never miss an edge case, stuff like that, right?

[18:28](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1108s) And so those are the fundamentals that I think are always gonna matter, and I think, um, basically I think interns or junior engineers are going to get more exposed to getting to use those fundamentals earlier and earlier.

[18:42](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1122s) Yeah. What do you think are the biggest open technical challenges you have to realize this vision of a future SWE? Yeah. Okay. So someone asked what are, what are the, the biggest challenges to realizing the vision of a future SWE?

[18:54](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1134s) You know, there's a lot. [laughs] Um, I mean, it's, it's basically everything as you can ima- I mean, there's speed, there's consistency, there's access, there's integrations, there's the right product UX.

[19:07](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1147s) Um, you know, and I think all of these things ... W- one of the cool things I think is just how much of a rising tide there is everywhere.

[19:13](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1153s) And so, you know, o- obviously we're, we're gonna do our best work on it, but, you know, every, every new hardware release is, is amazing for it. You know, e- every, every new foundation model that comes out is amazing, you know, every new piece of agentic research.

[19:25](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1165s) And I think this is the kind of thing where, um, 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.

[19:35](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1175s) Um, but, uh, yeah, it, it won't just be one small thing. But I, I think it'll be, it'll be pretty fast.

[19:41](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1181s) And that's all the time we had, so thank you so much.

[19:44](https://www.youtube.com/watch?v=T7NWjoD_OuY&t=1184s) Thank you guys so much. [outro music]
