Latest / The Pragmatic Engineer / From Chrome DevTools to AI Engineering, with Addy Osmani

Transcript

From Chrome DevTools to AI Engineering, with Addy Osmani · The Pragmatic Engineer

• 0:00
  SPEAKER_01: If you've ever opened Chrome DevTools or optimized a page for Core Web Vitals,
• 0:04
  SPEAKER_01: you've used software built by Addy Osmani.
• 0:06
  SPEAKER_01: Addy spent 14 years at Google,
• 0:08
  SPEAKER_01: most of it on Chrome, going from software engineer to director of engineering.
• 0:12
  SPEAKER_01: And when starting out in tech,
• 0:13
  SPEAKER_01: as a teenager in rural Ireland, he built his own web browser from the ground up.
• 0:17
  SPEAKER_01: Today we talk about the inside story of Chrome DevTools,
• 0:20
  SPEAKER_01: why it became the closest thing Google has to an IDE,
• 0:23
  SPEAKER_01: and the problems that are still unsolved, like memory debugging.
• 0:26
  SPEAKER_01: What becomes different when you become a director at Google,
• 0:28
  SPEAKER_01: and how Addy stayed hands-on building software while building an engineering org
• 0:32
  SPEAKER_01: with more than 50 people.
• 0:33
  SPEAKER_01: How AI is changing software engineering,
• 0:36
  SPEAKER_01: cognitive depth,
• 0:37
  SPEAKER_01: cognitive surrender, loop engineering, and software factories, and many more.
• 0:41
  SPEAKER_01: If you want to hear from someone who has spent decades helping developers understand
• 0:45
  SPEAKER_01: the web and is now thinking deeply about how AI changes software engineering,
• 0:49
  SPEAKER_01: this episode is for you.
• 0:50
  SPEAKER_01: This episode is presented by Antithesis.
• 0:52
  SPEAKER_01: If you work with agents,
• 0:53
  SPEAKER_01: your job is no longer just writing code, it's specifying and testing it.
• 0:57
  SPEAKER_01: And antithesis is the most effective method of verifying agentic code today.
• 1:01
  SPEAKER_01: Before we get into Addy's journey at Google,
• 1:03
  SPEAKER_01: I wanted to talk about a really cool product at Google,
• 1:05
  SPEAKER_01: Google Cloud Run and their recently launched Cloud Run sandboxes.
• 1:09
  SPEAKER_01: When you're building AI applications or AI agents,
• 1:12
  SPEAKER_01: you often want to run untrusted programs like execute some Python code
• 1:15
  SPEAKER_01: the model generated, Or run a headless browser to fetch data from the web.
• 1:19
  SPEAKER_01: Or even execute code submitted by a user.
• 1:21
  SPEAKER_01: But how do you make this fast and secure?
• 1:24
  SPEAKER_01: This is exactly what Cloud Run Sandboxes do.
• 1:27
  SPEAKER_01: Cloud Run Sandboxes are ephemeral, isolated G-Visor environments that spin up extremely fast.
• 1:32
  SPEAKER_01: They were built with security in mind.
• 1:34
  SPEAKER_01: They enforce credential and environment isolation.
• 1:37
  SPEAKER_01: Basically, they have no access to your services environment variables or secrets.
• 1:41
  SPEAKER_01: Sandboxes also operate with lockdown network egress, deny by default, to the internet.
• 1:46
  SPEAKER_01: Accelerate development,
• 1:48
  SPEAKER_01: eliminate infrastructure toil,
• 1:50
  SPEAKER_01: and run untrusted workloads with confidence on Google Cloud Run.
• 1:53
  SPEAKER_01: Try Cloud Run Sandboxes today at cloud.run.
• 1:57
  SPEAKER_01: Adi, it's so nice to have you in person on the podcast.
• 1:59
  SPEAKER_01: Oh, thank you for having me.
• 2:01
  SPEAKER_01: And before we kick off into your career and how you got started,
• 2:05
  SPEAKER_01: I wanted to ask,
• 2:06
  SPEAKER_01: just before we started recording,
• 2:07
  SPEAKER_01: we were talking about how has your day-to-day workflow changed recently a bunch,
• 2:13
  SPEAKER_01: thanks to all these tools?
• 2:15
  SPEAKER_00: So agents have allowed me to take the improbable and turn it into the possible
• 2:20
  SPEAKER_00: in ways that are kind of weird and wonderful every day.
• 2:24
  SPEAKER_00: I manage a lot of my life now using agents.
• 2:26
  SPEAKER_00: And one example just from,
• 2:29
  SPEAKER_00: you know, this week we've got the AI World Fair happening in San Francisco.
• 2:33
  SPEAKER_00: I'm doing a closing keynote a couple of days in.
• 2:36
  SPEAKER_00: And so I wanted to make sure I wasn't repeating any beats
• 2:40
  SPEAKER_00: that other speakers had gone into depth on.
• 2:42
  SPEAKER_00: And I also wanted to make sure there was good connective tissue from my talk to
• 2:47
  SPEAKER_00: a lot of the other sessions that had happened.
• 2:49
  SPEAKER_00: Now, normally in the old days,
• 2:51
  SPEAKER_00: You kind of pray and hope that there was any content from these sessions online.
• 2:56
  SPEAKER_00: And maybe you'd look through the abstracts.
• 2:58
  SPEAKER_00: I was able to fire off a bunch of agents,
• 3:00
  SPEAKER_00: you know,
• 3:01
  SPEAKER_00: go through everything that you can find about the talks from the last couple
• 3:05
  SPEAKER_00: of days, look at the abstracts.
• 3:06
  SPEAKER_00: Any social content, anything around that that can be useful.
• 3:10
  SPEAKER_00: And that was able to help me kind of sculpt what I already wanted to talk about
• 3:15
  SPEAKER_00: into something that I hope is refined and will give people a way to connect
• 3:21
  SPEAKER_00: from other parts of this conference back to,
• 3:23
  SPEAKER_00: you know, the way that I'm going to close it up.
• 3:25
  SPEAKER_00: That for me just feels very empowering.
• 3:28
  SPEAKER_00: You know,
• 3:28
  SPEAKER_00: something that would have taken a very long time if I would have even been able
• 3:31
  SPEAKER_00: to do it at all is now very much within reach.
• 3:34
  SPEAKER_01: And then you mentioned that it feels like,
• 3:36
  SPEAKER_01: and a lot of people tell you,
• 3:37
  SPEAKER_01: like there's kind of like both fun and chaos at the same time right now,
• 3:41
  SPEAKER_01: like everywhere, right?
• 3:42
  SPEAKER_00: Yeah.
• 3:42
  SPEAKER_00: Yeah, absolutely.
• 3:43
  SPEAKER_00: Fun and chaos.
• 3:44
  SPEAKER_00: I think that,
• 3:45
  SPEAKER_00: you know,
• 3:46
  SPEAKER_00: for many of us,
• 3:47
  SPEAKER_00: when you have a lot of ideas or a lot of vision,
• 3:50
  SPEAKER_00: you're often bounded by time or how much can I actually do?
• 3:55
  SPEAKER_00: And in some ways, agents have unchained us.
• 3:58
  SPEAKER_00: And this is one of those reasons why,
• 4:00
  SPEAKER_00: you know, you keep hearing, oh, hey, what are you doing with all of that time?
• 4:04
  SPEAKER_00: Agents have freed up.
• 4:05
  SPEAKER_00: Well, I'm doing more work.
• 4:07
  SPEAKER_00: I think for many of us,
• 4:08
  SPEAKER_00: if we didn't enjoy it,
• 4:08
  SPEAKER_00: we wouldn't be filling that time up with work, but we're having fun with it.
• 4:11
  SPEAKER_00: And so it's fun thriving in that chaos.
• 4:14
  SPEAKER_01: Yeah, but now take me back to the very beginning.
• 4:17
  SPEAKER_01: A lot of us know you and I've gotten to know you through your work at Google,
• 4:21
  SPEAKER_01: through your books, but I'd like to start from even before.
• 4:25
  SPEAKER_01: Where did you start out?
• 4:27
  SPEAKER_01: How did you have your first contact with computers?
• 4:31
  SPEAKER_01: And how did you build a web browser when you were a teenager in high school?
• 4:35
  SPEAKER_00: So I've always been fascinated with understanding how things work.
• 4:40
  SPEAKER_00: And I grew up in rural Ireland,
• 4:44
  SPEAKER_00: which was at times,
• 4:45
  SPEAKER_00: you know, we didn't necessarily have the best internet connectivity.
• 4:48
  SPEAKER_00: This was back in the days of dial-up.
• 4:51
  SPEAKER_00: And so my first contact with computers was, you know, I was probably eight or nine years old.
• 4:58
  SPEAKER_00: We were very fortunate that my dad was able to get us our first desktop machine.
• 5:02
  SPEAKER_00: And, you know,
• 5:03
  SPEAKER_00: I'd play around with apps,
• 5:04
  SPEAKER_00: I'd play around with just like trying to browse the internet.
• 5:07
  SPEAKER_00: And it was always fascinating to me, like, how does any of this work?
• 5:11
  SPEAKER_00: I'm just typing in something into an address bar
• 5:14
  SPEAKER_00: and all this information is just rendering somehow.
• 5:18
  SPEAKER_00: I'm getting back text, photos, videos.
• 5:21
  SPEAKER_00: How does any of this stuff work?
• 5:23
  SPEAKER_00: And so over time, I would build out websites.
• 5:26
  SPEAKER_00: I'd start to get into programming.
• 5:29
  SPEAKER_00: My very first programming language was Pascal.
• 5:32
  SPEAKER_00: So I'm a big fan of the Borland tool suite.
• 5:36
  SPEAKER_00: I learned C++ when I was fairly young.
• 5:40
  SPEAKER_00: And there was one year when I noticed that we had a kind
• 5:45
  SPEAKER_00: of popular national science competition.
• 5:47
  SPEAKER_00: And traditionally,
• 5:49
  SPEAKER_00: that competition was very much about,
• 5:51
  SPEAKER_00: you know, hey,
• 5:52
  SPEAKER_00: do students have interesting breakthroughs or thoughts on physics or chemistry
• 5:56
  SPEAKER_00: or any of those things?
• 5:58
  SPEAKER_00: But the year that I'm talking about was the first year where they actually started
• 6:02
  SPEAKER_00: to really take computing seriously.
• 6:05
  SPEAKER_00: And as I mentioned, I didn't have the best internet connection.
• 6:09
  SPEAKER_00: This was also during the time when,
• 6:10
  SPEAKER_00: especially if you were a teenager,
• 6:14
  SPEAKER_00: you started to get into, you know, learning about downloading stuff.
• 6:18
  SPEAKER_00: And we didn't have fast internet connections back then.
• 6:21
  SPEAKER_00: If you cared about,
• 6:23
  SPEAKER_00: you know, checking out a song, you could be waiting hours for that to download.
• 6:28
  SPEAKER_00: If you cared about trying out a music video,
• 6:31
  SPEAKER_00: man, that could be a night, two days sometimes to download it.
• 6:36
  SPEAKER_00: And so I tried to study how these kind of download managers that were popping up worked.
• 6:43
  SPEAKER_00: And download managers kind of offered this one hook.
• 6:45
  SPEAKER_00: Well, rather than making one connection to a server,
• 6:49
  SPEAKER_00: what if we spawned Multiple threads and made multiple connections to a server.
• 6:54
  SPEAKER_00: And we kind of chunked content.
• 6:56
  SPEAKER_00: You know, it's classical computer science, you know, break down problems into smaller chunks.
• 6:59
  SPEAKER_00: And so that was one of the ways.
• 7:01
  SPEAKER_00: And if the server supported,
• 7:02
  SPEAKER_00: you know,
• 7:04
  SPEAKER_00: chunking,
• 7:05
  SPEAKER_00: you were able to,
• 7:06
  SPEAKER_00: in some cases, actually get your file downloaded a little bit faster.
• 7:10
  SPEAKER_00: And so it dawned on me like, hey, we're using this technique for downloading individual files.
• 7:17
  SPEAKER_00: Has anyone applied this to how we browse the web?
• 7:21
  SPEAKER_00: Yeah.
• 7:22
  SPEAKER_00: And so obviously I couldn't do something complicated before I took my first baby steps.
• 7:29
  SPEAKER_00: And so I thought,
• 7:30
  SPEAKER_00: OK, I'm going to try exploring how you I started to read, you know, specifications.
• 7:35
  SPEAKER_00: I was probably 15 years old when I started this, 15, 16.
• 7:39
  SPEAKER_00: But I started to read specifications, okay, HTML, CSS, JavaScript.
• 7:44
  SPEAKER_00: One of the things that I gained a great deal of respect for,
• 7:47
  SPEAKER_00: and I still have a lot of respect for, is...
• 7:50
  SPEAKER_00: Developers throw all kinds of weird crap at browsers,
• 7:54
  SPEAKER_00: and yet they still render something, right?
• 7:58
  SPEAKER_00: If you ever want an interesting experiment in therapy,
• 8:04
  SPEAKER_00: if you're ever feeling bad about your code,
• 8:07
  SPEAKER_00: open up the dev tools and just browse the web for 10 minutes.
• 8:10
  SPEAKER_00: The number of things that will go wrong and yet you'll still be able
• 8:14
  SPEAKER_00: to probably interact with the site is just wild.
• 8:17
  SPEAKER_00: And I had that.
• 8:18
  SPEAKER_01: And going wrong, you can just look at the warnings and errors, honestly.
• 8:20
  SPEAKER_01: Yeah.
• 8:21
  SPEAKER_01: Just that.
• 8:21
  SPEAKER_00: Yeah.
• 8:22
  SPEAKER_00: And so that was one of the most complicated things when I was trying to build a browser.
• 8:26
  SPEAKER_00: It was like, yeah, you can parse HTML, you can parse documents, you can load up images.
• 8:32
  SPEAKER_00: But as soon as you run into pages that stop following those specs and they take
• 8:38
  SPEAKER_00: a very loose interpretation of what's supported,
• 8:42
  SPEAKER_00: You have to really roll your sleeves up and try to behave the way
• 8:46
  SPEAKER_00: that actual consumer browsers did.
• 8:48
  SPEAKER_00: And so I had my fun building out a browser.
• 8:52
  SPEAKER_00: Adding interactivity and JavaScript support was very difficult.
• 8:59
  SPEAKER_00: Managed to get it working.
• 9:00
  SPEAKER_00: And then I'm a sucker for pain because I decided, well,
• 9:04
  SPEAKER_00: I guess Applets and Flash and, you know, we had Windows Media Player back then.
• 9:11
  SPEAKER_00: So people were like embedding all kinds of interesting content.
• 9:14
  SPEAKER_00: I told myself, well, it's not a complete browser if it doesn't support all these other things.
• 9:18
  SPEAKER_00: And so I added support for them.
• 9:20
  SPEAKER_00: And then I could finally get on to what I actually wanted to work on,
• 9:23
  SPEAKER_00: which was exploring if I could speed up web browsing for this point in time
• 9:29
  SPEAKER_00: when you were kind of constrained by the hardware and bandwidth
• 9:33
  SPEAKER_00: that was available locally.
• 9:35
  SPEAKER_00: Back then,
• 9:36
  SPEAKER_00: this was a personal pain because before I could get a good internet connection,
• 9:41
  SPEAKER_00: I would literally every weekend,
• 9:43
  SPEAKER_00: especially wear cargo pants that had a lot of pockets,
• 9:47
  SPEAKER_00: and I would fill my cargo pants with floppy disks.
• 9:50
  SPEAKER_00: And I would walk down to our local library that just happened to have
• 9:53
  SPEAKER_00: a slightly faster internet connection.
• 9:56
  SPEAKER_00: And I would try to like save as much as I could, then go back home, check it out on my computer.
• 10:02
  SPEAKER_00: And so this was a personal mission for me.
• 10:04
  SPEAKER_00: I really, really wanted a faster internet connection.
• 10:07
  SPEAKER_00: But I finally got to explore this idea.
• 10:10
  SPEAKER_00: It worked.
• 10:10
  SPEAKER_00: And back then, in many cases, there were servers that supported this idea.
• 10:16
  SPEAKER_00: It did make things a little bit faster.
• 10:18
  SPEAKER_00: And so I ended up building something that worked for me.
• 10:24
  SPEAKER_00: I took it to this national science competition.
• 10:28
  SPEAKER_00: I was nobody.
• 10:29
  SPEAKER_00: I am nobody.
• 10:30
  SPEAKER_00: I was nobody.
• 10:30
  SPEAKER_00: I was just this kid.
• 10:31
  SPEAKER_00: And I was kind of half expecting to just leave the competition and go back It was very strange.
• 10:59
  SPEAKER_00: The weekend right after,
• 11:01
  SPEAKER_00: you know, you're a kid, you kind of like want to sleep in on a Sunday morning.
• 11:05
  SPEAKER_00: You don't really have too many people back then like calling your cell phone or whatever.
• 11:11
  SPEAKER_00: And my cell phone is just like not stopping.
• 11:14
  SPEAKER_00: The first call is like from the Wall Street Journal.
• 11:18
  SPEAKER_01: Basically, you kind of like went viral in a time where there was not even Twitter, right?
• 11:22
  SPEAKER_01: There was like none of this just yet.
• 11:25
  SPEAKER_00: Yeah, it's Wall Street Journal, CNN.
• 11:27
  SPEAKER_00: I didn't really understand what was happening, but it was my first taste of that world.
• 11:33
  SPEAKER_00: One of the things that I learned from that experience was...
• 11:37
  SPEAKER_00: I still didn't fully understand everything that I was doing.
• 11:41
  SPEAKER_00: You know, you're a teenager.
• 11:43
  SPEAKER_00: Just because you can build an app that runs on your machine and accomplishes
• 11:47
  SPEAKER_00: a goal doesn't mean that you understand all of those layers behind the scenes.
• 11:51
  SPEAKER_00: And that, I think, kicked off for me a...
• 11:55
  SPEAKER_00: Lifelong thirst for knowledge and understanding how things work.
• 11:59
  SPEAKER_00: In some ways, I can call myself a one-trick pony.
• 12:01
  SPEAKER_00: I care about understanding problems and how to fix them, how they work behind the scenes.
• 12:07
  SPEAKER_00: I would go on to work at startups.
• 12:09
  SPEAKER_00: I worked at AOL at one point.
• 12:11
  SPEAKER_00: Again, continuing this theme of working with browsers.
• 12:15
  SPEAKER_00: When I joined AOL, I had a very...
• 12:18
  SPEAKER_00: AOL moment my first day.
• 12:22
  SPEAKER_00: My manager, who was a very kind guy, said like, hey, yeah, you know, go help the team.
• 12:27
  SPEAKER_00: Just log into the browser, go help the team.
• 12:29
  SPEAKER_00: It's like, okay, cool, I'll do that.
• 12:31
  SPEAKER_00: So I fire up the AOL browser app and I have my work machine.
• 12:37
  SPEAKER_00: This app is loaded up.
• 12:39
  SPEAKER_00: And before I can debug anything, the first thing it asks me for is my credit card.
• 12:43
  SPEAKER_00: I'm like, sorry, what?
• 12:44
  SPEAKER_00: I need to enter in my credit card to even start my work?
• 12:48
  SPEAKER_00: And my manager was busy, so I didn't know if there was some workaround.
• 12:51
  SPEAKER_00: I was like, okay, I guess this is what I need to do to get started with work.
• 12:55
  SPEAKER_00: Wow.
• 12:55
  SPEAKER_00: Different time.
• 12:56
  SPEAKER_00: Very different time.
• 12:58
  SPEAKER_00: But a few years later, I would join Google and I would work on Chrome.
• 13:02
  SPEAKER_00: But something for me that's been very interesting is,
• 13:05
  SPEAKER_00: you know,
• 13:06
  SPEAKER_00: if you treat computing as this onion where you just keep peeling back the layers,
• 13:12
  SPEAKER_00: there's always something interesting behind the scenes.
• 13:16
  SPEAKER_00: And the more of those layers that you can peel back and understand,
• 13:19
  SPEAKER_00: I think in some ways, the better you can optimize for that world.
• 13:24
  SPEAKER_00: You know, there was a time when I maybe only understood the surface of how things render.
• 13:29
  SPEAKER_00: But if you're talking about browsers,
• 13:31
  SPEAKER_00: you know, there is the network, there is compositing, there's the JavaScript engine.
• 13:36
  SPEAKER_00: You go down another layer, there's chips, there's memory, there's GPU.
• 13:41
  SPEAKER_00: And the more you understand about all of these different foundational pieces,
• 13:46
  SPEAKER_00: the better you can then optimize and build something that, you know...
• 13:50
  SPEAKER_00: Conserve people even on constrained environments.
• 13:52
  SPEAKER_00: So if you have a slightly slower phone, well,
• 13:56
  SPEAKER_00: I understand now why the phone is slower and what constraints might require us
• 14:00
  SPEAKER_00: to think slightly differently about what we're building there.
• 14:03
  SPEAKER_00: So I'm always a big fan of encouraging people to understand how things work.
• 14:06
  SPEAKER_01: And then in the spirit of understanding,
• 14:09
  SPEAKER_01: one project that you got involved on early on,
• 14:12
  SPEAKER_01: you know,
• 14:12
  SPEAKER_01: you built your custom browser that did some cool stuff and you understood how
• 14:16
  SPEAKER_01: to render, parse, do some of these things.
• 14:18
  SPEAKER_01: And then you joined into the jQuery project.
• 14:21
  SPEAKER_01: How did that happen?
• 14:22
  SPEAKER_00: Yeah.
• 14:23
  SPEAKER_01: And in jQuery for a while after you joined,
• 14:26
  SPEAKER_01: it became for a while the most used library in the JavaScript ecosystem.
• 14:32
  SPEAKER_01: So basically across the web, there were a few years of that.
• 14:35
  SPEAKER_00: Yeah, I think full kudos goes to John Resig, the creator of jQuery.
• 14:41
  SPEAKER_00: JQuery was really my first contribution to a big community open source project.
• 14:47
  SPEAKER_00: And John was someone that was very welcoming and created an environment
• 14:51
  SPEAKER_00: where people could, you know, learn and become better open source contributors.
• 14:57
  SPEAKER_00: I started off working with the team of people that would deal with triage and issues
• 15:03
  SPEAKER_00: and then moved on to working on blog posts and contributing to code and other ways.
• 15:08
  SPEAKER_00: But as you said,
• 15:11
  SPEAKER_00: it was so widely used that you end up with so many different use cases people have.
• 15:15
  SPEAKER_00: And a lot of the times back then,
• 15:18
  SPEAKER_00: people would have very strong opinions about like,
• 15:20
  SPEAKER_00: hey, this thing should be in the main library in core versus being a plugin.
• 15:25
  SPEAKER_00: And I got a lot of respect for how you effectively work with a community
• 15:31
  SPEAKER_00: while also holding a line in terms of what decisions should be made to optimize
• 15:37
  SPEAKER_00: for long-term maintainability, for example.
• 15:40
  SPEAKER_00: But it was a great experience.
• 15:42
  SPEAKER_00: And that helped me kind of carry those lessons on when I worked on my own open source projects.
• 15:47
  SPEAKER_00: I was very grateful for that opportunity.
• 15:50
  SPEAKER_01: Yeah.
• 15:50
  SPEAKER_01: And one of your popular open source projects back in the day was called TodoMVC.
• 15:54
  SPEAKER_01: Can we talk about what it was and why you started?
• 15:57
  SPEAKER_00: Yeah, absolutely.
• 15:58
  SPEAKER_00: There was a point in time back in the dark ages of JavaScript
• 16:03
  SPEAKER_00: when we didn't have frameworks and we didn't have libraries.
• 16:07
  SPEAKER_00: Over time,
• 16:08
  SPEAKER_00: those things started to pop up and we began to have quite a few of them
• 16:13
  SPEAKER_00: and they all I tried to accomplish,
• 16:15
  SPEAKER_00: in some cases, overlapping goals, sometimes adjacent goals.
• 16:20
  SPEAKER_00: We're talking about Angular, Backbone, YUI, XJS.
• 16:26
  SPEAKER_00: And if you're too young for any of these terms to mean anything, that's also totally okay.
• 16:32
  SPEAKER_00: But there was this burgeoning community of libraries and frameworks
• 16:35
  SPEAKER_00: that were starting to pop up.
• 16:37
  SPEAKER_00: And one thing that I personally struggled with was, well, how do these things differ?
• 16:43
  SPEAKER_00: You know, you can go and you can check out the landing page for any of these projects.
• 16:46
  SPEAKER_00: And they all say, like, yeah, we're going to help you build apps easier.
• 16:52
  SPEAKER_00: But...
• 16:54
  SPEAKER_00: I was very big into education and trying to understand how these things work.
• 16:58
  SPEAKER_00: So I started off by creating basically the same application in every one
• 17:05
  SPEAKER_00: of these frameworks and try to standardize the functionality so that if you were in
• 17:10
  SPEAKER_00: the same position I was and you just wanted to get a sense of,
• 17:13
  SPEAKER_00: okay, well, how does the architecture philosophy change between these things?
• 17:18
  SPEAKER_00: How does the syntax differ?
• 17:19
  SPEAKER_00: If they're telling you to build a component or a piece of UI,
• 17:23
  SPEAKER_00: what is the position they're taking on it versus somebody else?
• 17:27
  SPEAKER_00: And so I got a lot of personal value out of the way that I was building this thing up.
• 17:32
  SPEAKER_00: And so I put it out into the world.
• 17:34
  SPEAKER_00: I had no expectations of it being useful.
• 17:37
  SPEAKER_01: But basically it was you implemented a todo app or the same todo app with
• 17:40
  SPEAKER_01: the different frameworks and you could kind of compare how they differ.
• 17:43
  SPEAKER_00: Yeah, yeah.
• 17:44
  SPEAKER_00: And the idea was I wanted an application.
• 17:46
  SPEAKER_00: And so I put this out into the world.
• 18:09
  SPEAKER_00: I was kind of shocked at how many other developers were running into this exact same challenge.
• 18:16
  SPEAKER_00: And the project quickly took off.
• 18:18
  SPEAKER_00: It started to get a lot of stars back in the day.
• 18:21
  SPEAKER_00: It got thousands and thousands of stars very quickly,
• 18:24
  SPEAKER_00: and I didn't quite know what was happening.
• 18:27
  SPEAKER_00: And before long,
• 18:28
  SPEAKER_00: I had people who were working on new frameworks or new versions
• 18:31
  SPEAKER_00: of frameworks reaching out to me, saying like, hey, This is cool.
• 18:37
  SPEAKER_00: Here's my pull requests with my framework.
• 18:39
  SPEAKER_00: Can you add it?
• 18:40
  SPEAKER_00: Can we work together on standardizing it?
• 18:42
  SPEAKER_00: I met some of my first true open source friends through this project,
• 18:47
  SPEAKER_00: people who are now,
• 18:48
  SPEAKER_00: you know,
• 18:49
  SPEAKER_00: very well established in their own means,
• 18:51
  SPEAKER_00: like Cinder Sorhus, who's written quite a lot of node modules over time.
• 18:55
  SPEAKER_00: This idea of just giving people a simple enough application Ended up becoming
• 19:00
  SPEAKER_00: in some ways a standard for a number of years.
• 19:02
  SPEAKER_00: I began to see that,
• 19:04
  SPEAKER_00: you know,
• 19:05
  SPEAKER_00: if a framework was giving people a tutorial about how to use them,
• 19:08
  SPEAKER_00: they would actually use it to do MVC app as their baseline.
• 19:12
  SPEAKER_00: It's been so many years.
• 19:13
  SPEAKER_00: That was the start of my career in many ways.
• 19:16
  SPEAKER_00: Even this last year,
• 19:17
  SPEAKER_00: I still see labs sometimes like showing off to do MVC apps when they're trying
• 19:22
  SPEAKER_00: to test out features.
• 19:23
  SPEAKER_00: And the longevity of this thing has been very surprising to me.
• 19:28
  SPEAKER_00: Another thing that was surprising was at one point when the project was taking off,
• 19:34
  SPEAKER_00: Apple reached out to me.
• 19:36
  SPEAKER_00: Yeah, Apple reached out to me, specifically the people who are working on Safari and WebKit.
• 19:42
  SPEAKER_00: And they said, you know, hey, we're interested in working on a browser benchmark.
• 19:48
  SPEAKER_00: To help browser vendors understand, like, are they doing a good job at being responsive?
• 19:54
  SPEAKER_00: And responsive here doesn't mean responsive in the mobile sense,
• 19:57
  SPEAKER_00: but responsive in terms of interactivity and are we responding to clicks
• 20:00
  SPEAKER_00: and taps quickly?
• 20:01
  SPEAKER_00: They reached out to me and they said, hey, would you like to collaborate with us on this thing?
• 20:06
  SPEAKER_00: And what that turned out to be...
• 20:09
  SPEAKER_00: Speedometer over the years has become the primary responsiveness benchmark,
• 20:17
  SPEAKER_00: web application benchmark for all browsers.
• 20:20
  SPEAKER_00: And it's continued to be for a very long time.
• 20:22
  SPEAKER_00: Browser vendors now collaborate together on it.
• 20:25
  SPEAKER_00: They've kept it up to date.
• 20:27
  SPEAKER_00: So as new frameworks,
• 20:28
  SPEAKER_00: as new architectural paradigms have come out over the years,
• 20:32
  SPEAKER_00: they've kept updating it.
• 20:34
  SPEAKER_00: And that in many ways is like, Carried that the legacy of that project through to today.
• 20:39
  SPEAKER_00: And I've been just very happy that it's given people value of any kind.
• 20:43
  SPEAKER_01: And you are building stuff on the side.
• 20:45
  SPEAKER_01: You are also working at consultancies, AOL at different startups.
• 20:49
  SPEAKER_01: How did Google come along?
• 20:50
  SPEAKER_00: So Google was an interesting one.
• 20:54
  SPEAKER_00: I remember one of my first longer periods of time spent in the U.S.
• 21:00
  SPEAKER_00: was when I was visiting my wife and her parents out in the Midwest.
• 21:05
  SPEAKER_00: And I was sitting, I remember, in their room watching TV.
• 21:12
  SPEAKER_00: And there's this documentary about Google.
• 21:15
  SPEAKER_00: That came on and they showed like,
• 21:17
  SPEAKER_00: you know,
• 21:17
  SPEAKER_00: engineer,
• 21:18
  SPEAKER_00: early engineers have been working there and why they enjoy the environment.
• 21:22
  SPEAKER_00: And I told myself, you know, I would love to work in a place like that someday.
• 21:29
  SPEAKER_00: I continued to put out free education into the front end world,
• 21:33
  SPEAKER_00: the JavaScript world, web app world over the years.
• 21:35
  SPEAKER_00: And at some point, I guess Google noticed that it was useful to some people.
• 21:42
  SPEAKER_00: And so they reached out.
• 21:43
  SPEAKER_00: And wanted to interview me for a DevRel and Builder role.
• 21:51
  SPEAKER_00: There was some tooling that they were trying to build out at the time
• 21:54
  SPEAKER_00: that they thought could be a good use of some of my skills,
• 21:57
  SPEAKER_00: but also some just general evangelism they wanted to do in the tech community.
• 22:03
  SPEAKER_00: And the stars aligned, just happened to work out, and I ended up working on the Chrome team.
• 22:10
  SPEAKER_01: And then when you joined,
• 22:10
  SPEAKER_01: can you tell us a little bit more about when you joined the Chrome team?
• 22:15
  SPEAKER_01: What was Chrome like?
• 22:16
  SPEAKER_01: What kind of work did you and the team do?
• 22:19
  SPEAKER_01: Because now Chrome is synonym for web browser.
• 22:23
  SPEAKER_01: I know there's other browsers and every now and then,
• 22:27
  SPEAKER_01: of course, they have some market share, but Chrome has largely won the market.
• 22:30
  SPEAKER_01: But back then when you joined, this was not the case just yet, was it?
• 22:34
  SPEAKER_00: I remember back when I joined, uh,
• 22:38
  SPEAKER_00: It was a period when we were very excited about developers bringing their creativity
• 22:46
  SPEAKER_00: to the platform.
• 22:48
  SPEAKER_00: So what can you do to push on the platform and show us both what's possible as well
• 22:53
  SPEAKER_00: as the gaps so that we can potentially help fill those gaps and build better APIs?
• 22:57
  SPEAKER_00: So I remember there was this great Chrome experiment site that we had back in
• 23:01
  SPEAKER_00: the day where we would,
• 23:03
  SPEAKER_00: you know,
• 23:03
  SPEAKER_00: sometimes work with studios or work with developers and just showcase like, hey,
• 23:07
  SPEAKER_00: here's Here's a cool WebGL example that maybe you wouldn't have otherwise come
• 23:11
  SPEAKER_00: across,
• 23:12
  SPEAKER_00: and that served as inspiration for some people to maybe even go and then learn more
• 23:17
  SPEAKER_00: about shaders or different libraries.
• 23:20
  SPEAKER_00: It was also a period of time
• 23:22
  SPEAKER_00: when I would say frontend tooling was still very much heavily evolving.
• 23:28
  SPEAKER_01: We're talking 2012, 2013.
• 23:29
  SPEAKER_00: Yeah, we're talking 2012, 2013.
• 23:32
  SPEAKER_00: This was at a time prior to what I would now call meta frameworks.
• 23:37
  SPEAKER_00: So like Next.js, for example, a meta framework.
• 23:40
  SPEAKER_01: It did not exist.
• 23:41
  SPEAKER_00: It didn't exist.
• 23:42
  SPEAKER_00: So we're going all the way back to a time when we didn't have the best build tools,
• 23:48
  SPEAKER_00: even for front end.
• 23:49
  SPEAKER_01: We didn't have things like ES build even.
• 23:52
  SPEAKER_00: Yeah, we didn't necessarily have well-standardized JavaScript modules in all browsers.
• 23:58
  SPEAKER_00: People were still using AMD and UMD, CommonJS, things like that.
• 24:06
  SPEAKER_00: And, you know, the build tooling and the scaffolding tooling was still very much evolving.
• 24:11
  SPEAKER_00: And so this was the period of time when you went through things like Grunt
• 24:16
  SPEAKER_00: for anyone that,
• 24:17
  SPEAKER_00: you know, maybe we're dating ourselves, but Grunt as a built system.
• 24:21
  SPEAKER_01: And also when you debug the browser, you would use Firebug.
• 24:24
  SPEAKER_01: You would open it in Firefox and then hope that like in IE it would work.
• 24:28
  SPEAKER_01: But if it didn't, there weren't many good debugging tools in IE specifically.
• 24:32
  SPEAKER_01: Later they became better.
• 24:33
  SPEAKER_01: But back there was a time when there was no.
• 24:34
  SPEAKER_00: Yeah.
• 24:35
  SPEAKER_00: And I think that.
• 24:37
  SPEAKER_00: Back in the heyday,
• 24:38
  SPEAKER_00: there were a lot of workarounds people were trying to apply to still have a toolbox
• 24:42
  SPEAKER_00: of some sort before things got much better.
• 24:44
  SPEAKER_00: We put some work into working with the folks who were building out build tools
• 24:51
  SPEAKER_00: and test runners and scaffolding tools.
• 24:53
  SPEAKER_00: We worked on our own contribution called Yeoman back in the day.
• 24:59
  SPEAKER_00: And Yeoman was really about,
• 25:00
  SPEAKER_00: I don't know that I'd call it the first meta framework,
• 25:03
  SPEAKER_00: but I would call it an attempt at trying to bring just a little bit of organization
• 25:10
  SPEAKER_00: to your starting point.
• 25:12
  SPEAKER_00: Yeoman was a scaffolding tool we created where you would get a wizard in your CLI
• 25:18
  SPEAKER_00: and you'd kind of say, well, yeah,
• 25:19
  SPEAKER_00: I'm trying to build this thing and maybe I'm interested in using this UI library
• 25:24
  SPEAKER_00: and this testing library.
• 25:26
  SPEAKER_00: And maybe I'm interested in deploying to this target.
• 25:30
  SPEAKER_00: Now, for folks who are listening in,
• 25:32
  SPEAKER_00: those ideas might now sound very standard and things that you will find in all
• 25:36
  SPEAKER_00: the tools you're regularly using.
• 25:37
  SPEAKER_00: Back then, they didn't exist.
• 25:39
  SPEAKER_00: And I wouldn't be surprised if many of the modules we created back
• 25:42
  SPEAKER_00: then are still being used under the hood for some of your favorite tools.
• 25:46
  SPEAKER_00: So it was very fun getting to be a part of that moment where we were trying
• 25:49
  SPEAKER_00: to figure things out and reduce friction.
• 25:52
  SPEAKER_00: But I will say that,
• 25:53
  SPEAKER_00: you know,
• 25:54
  SPEAKER_00: there was this long period where we kept changing tools,
• 25:56
  SPEAKER_00: what felt like every once in a while, right?
• 25:59
  SPEAKER_00: You went from Grunt to Gulp to Webpack to,
• 26:02
  SPEAKER_00: you know, to Vite, Rollup, all these things kept evolving.
• 26:07
  SPEAKER_00: And I was happy to see the evolution,
• 26:08
  SPEAKER_00: but I'm also happy that things in some ways feel like they've stabilized.
• 26:12
  SPEAKER_01: Yeah, there was, I think it was churn, but I mean, that's when innovation happens.
• 26:17
  SPEAKER_01: Did you work on Google Chrome DevTools?
• 26:20
  SPEAKER_01: How did that start?
• 26:21
  SPEAKER_01: Because I remember in 2012,
• 26:23
  SPEAKER_01: I'm not sure if there was DevTools,
• 26:24
  SPEAKER_01: but again, there was, the state of the art was Firebug.
• 26:27
  SPEAKER_01: It was, I think it was open source.
• 26:29
  SPEAKER_01: It was actually just superior debugging on the web to anything before.
• 26:34
  SPEAKER_01: And I'm not sure at what point,
• 26:35
  SPEAKER_01: but I do remember Chrome DevTools slowly started to emerge,
• 26:38
  SPEAKER_01: and it started to bring a bunch of new stuff,
• 26:40
  SPEAKER_01: like you could do performance monitoring, some of those things.
• 26:42
  SPEAKER_01: Can you tell me from the inside,
• 26:44
  SPEAKER_00: how did it start?
• 26:47
  SPEAKER_01: What you built, how you figured out what to build.
• 26:49
  SPEAKER_00: Yeah.
• 26:50
  SPEAKER_00: So I have to give a shout out to Pavel Feldman,
• 26:53
  SPEAKER_00: who was the tech lead for Chrome DevTools and really played a very large role
• 26:59
  SPEAKER_00: in helping it come to be originally.
• 27:02
  SPEAKER_00: There was this period of time when
• 27:06
  SPEAKER_00: Chrome was trying to figure out how it differentiated its developer tooling story
• 27:11
  SPEAKER_00: from WebKit, where we had the Safari inspector, the WebKit inspector.
• 27:15
  SPEAKER_00: And I think there's a very specific direction that was developer-centric and cared
• 27:21
  SPEAKER_00: about the ecosystem that Pavel and his team were trying to help out with.
• 27:27
  SPEAKER_00: And I noticed that they had a very good relationship talking to not just developer evangelists.
• 27:34
  SPEAKER_00: Really sharp minds like Paul Irish around,
• 27:37
  SPEAKER_00: also working very heavily with the CremDevTools team.
• 27:41
  SPEAKER_00: We would later have folks like Paul Backhouse,
• 27:44
  SPEAKER_00: who is now known for things like Impeccable, the Impeccable skill for design.
• 27:49
  SPEAKER_00: And I feel like one of the nice things about that period
• 27:52
  SPEAKER_00: of time was you had these people who were web developer archetypes and were builders
• 27:58
  SPEAKER_00: on the side, myself, Paul, the Pauls.
• 28:01
  SPEAKER_00: And we would try to bring those insights to the DevTools team
• 28:04
  SPEAKER_00: and help them understand,
• 28:05
  SPEAKER_00: well, here are the areas of friction that we're running into.
• 28:07
  SPEAKER_00: In some cases,
• 28:09
  SPEAKER_00: you can't just build tools to help you out with them because you don't have
• 28:12
  SPEAKER_00: the underlying instrumentation.
• 28:15
  SPEAKER_00: And so I was very happy to see things like performance tooling heavily evolve over the years.
• 28:20
  SPEAKER_00: Like the DevTools performance panel is just an amazing piece of technology.
• 28:25
  SPEAKER_00: The fact that you can just hit record,
• 28:27
  SPEAKER_00: start interacting with your page,
• 28:29
  SPEAKER_00: and you get a flame graph,
• 28:31
  SPEAKER_00: you get very deep tracing about where all the time is being spent.
• 28:35
  SPEAKER_00: And that continued to evolve over time.
• 28:38
  SPEAKER_00: And then we had, you know, really hard problems.
• 28:41
  SPEAKER_00: Some of the hardest problems have been around memory, right?
• 28:45
  SPEAKER_00: I would say sometimes,
• 28:46
  SPEAKER_00: I don't know if it's controversial,
• 28:47
  SPEAKER_00: that very few developers understand memory management.
• 28:52
  SPEAKER_00: And that makes it even harder to debug memory problems.
• 28:56
  SPEAKER_00: And so the state of the art around memory debugging hasn't evolved all that much over the years.
• 29:02
  SPEAKER_00: But it's a hard problem.
• 29:03
  SPEAKER_00: The DevTools team tackled a lot of interesting hard problems.
• 29:06
  SPEAKER_01: Can we talk about a part that You brought in something new,
• 29:11
  SPEAKER_01: because debugging memory,
• 29:12
  SPEAKER_01: just back in the day,
• 29:13
  SPEAKER_01: it's pretty much, I mean,
• 29:14
  SPEAKER_01: if you have a language that has,
• 29:15
  SPEAKER_01: let's say, heap, you can try to visualize what's on there.
• 29:19
  SPEAKER_01: You can attempt and maybe be successful at allocating which variety Variables there are.
• 29:24
  SPEAKER_01: And then you can try to also, I mean, some variables are the easy part.
• 29:29
  SPEAKER_01: There's also stacks.
• 29:31
  SPEAKER_01: And, you know,
• 29:32
  SPEAKER_01: it gets a little bit messy,
• 29:33
  SPEAKER_01: but you basically have a memory and you're typically interested in what is growing.
• 29:39
  SPEAKER_01: And there's a part that I don't know that we got too far on that.
• 29:43
  SPEAKER_01: But you're kind of trying to see, is this getting bigger?
• 29:46
  SPEAKER_01: What are the loops?
• 29:47
  SPEAKER_01: Where is my stack?
• 29:47
  SPEAKER_00: Yeah, absolutely.
• 29:48
  SPEAKER_00: I would say that there are There are a few interesting arcs
• 29:52
  SPEAKER_00: where we were seeing ourselves and developers externally running into certain kinds
• 29:57
  SPEAKER_00: of friction and work with the DevTools team to try evolving some tooling in
• 30:02
  SPEAKER_00: that direction.
• 30:03
  SPEAKER_00: One of the big arcs Yep.
• 30:05
  SPEAKER_00: Yep.
• 30:22
  SPEAKER_00: And you're trying to debug what's happened.
• 30:23
  SPEAKER_00: What part of that code do you actually care about?
• 30:26
  SPEAKER_00: Do you care about the framework code that is powering things behind the scenes?
• 30:31
  SPEAKER_00: Do you care about the plugins or the components sitting on top of it that you haven't written?
• 30:36
  SPEAKER_00: Do you care about the code you yourself have written?
• 30:39
  SPEAKER_00: And so you have all of these very nuanced aspects of debugging that need a solution.
• 30:44
  SPEAKER_00: One of the things that we tried to introduce was just this respect and understanding
• 30:49
  SPEAKER_00: that, yeah, developers are going to be using these different tech stacks.
• 30:52
  SPEAKER_00: You know,
• 30:53
  SPEAKER_00: we had a source maps story sitting there where potentially we can start
• 30:57
  SPEAKER_00: to reason about what's in.
• 30:58
  SPEAKER_01: You can map back to like what part of the code, which is not trivial.
• 31:02
  SPEAKER_00: Exactly, which is not trivial.
• 31:04
  SPEAKER_00: And a lot of kudos to the team because I think we ended up on a source map story
• 31:09
  SPEAKER_00: that really helps you reason well about,
• 31:11
  SPEAKER_00: you know,
• 31:12
  SPEAKER_00: even if you're using a long tool chain of things,
• 31:15
  SPEAKER_00: like if you take a look at any tools that developers for any big site,
• 31:18
  SPEAKER_00: you know,
• 31:18
  SPEAKER_00: whether it's Uber or Netflix or any large Twitter,
• 31:22
  SPEAKER_00: any large site,
• 31:23
  SPEAKER_00: you probably underestimate the complexity and the number of tools
• 31:26
  SPEAKER_00: that you're running at any one time for any one task.
• 31:29
  SPEAKER_00: And being able to still allow people to see, well, hey, here's actually the files
• 31:37
  SPEAKER_00: We
• 31:42
  SPEAKER_00: introduced different kinds of black box views over the years so
• 31:46
  SPEAKER_00: that you could say, well, hey,
• 31:47
  SPEAKER_00: actually,
• 31:48
  SPEAKER_00: I know that I don't care about you telling me there's an issue with,
• 31:52
  SPEAKER_00: for example,
• 31:52
  SPEAKER_00: the React library,
• 31:54
  SPEAKER_00: but I do want you to tell me that there's an issue with the React code that I wrote.
• 31:58
  SPEAKER_00: And so giving you even those toggles, those controls, I think was very powerful for people.
• 32:03
  SPEAKER_00: Mobile was another big moment that changed everything.
• 32:07
  SPEAKER_00: And, you know,
• 32:08
  SPEAKER_00: if you think about mobile today,
• 32:11
  SPEAKER_00: I would say,
• 32:12
  SPEAKER_00: you know,
• 32:13
  SPEAKER_00: there's probably established best practices around the things to test, right?
• 32:16
  SPEAKER_00: Like you want to test out your viewport width, your tap targets.
• 32:21
  SPEAKER_00: Like is, you know, if I'm tapping on something.
• 32:23
  SPEAKER_00: Is it big enough?
• 32:23
  SPEAKER_00: Exactly.
• 32:24
  SPEAKER_01: Is it on screen?
• 32:25
  SPEAKER_00: Exactly.
• 32:26
  SPEAKER_00: You know, there are all these different kinds of sensors even that mobile devices have.
• 32:31
  SPEAKER_00: We didn't have tooling around any of this stuff originally.
• 32:35
  SPEAKER_00: And so we ended up building out a nice device mode in DevTools that would allow you to preview.
• 32:40
  SPEAKER_00: Preview, you know, what your site would look like at different viewport sizes.
• 32:44
  SPEAKER_00: You can very quickly kind of toggle and say,
• 32:46
  SPEAKER_00: yeah, this is what it roughly looks like on an iPhone or a Pixel device.
• 32:51
  SPEAKER_00: And of course,
• 32:52
  SPEAKER_00: you know,
• 32:53
  SPEAKER_00: the absolute best kind of testing would be trying it out on one
• 32:56
  SPEAKER_00: of those accurate devices.
• 32:59
  SPEAKER_00: Even to quickly get a sense of whether you're headed in
• 33:02
  SPEAKER_00: the right direction was very valuable to people.
• 33:05
  SPEAKER_00: And we would evolve that over time as more of those best practices started to establish.
• 33:11
  SPEAKER_00: I guess the web apps growing up,
• 33:13
  SPEAKER_00: so PWAs,
• 33:14
  SPEAKER_00: Progressive Web Apps,
• 33:16
  SPEAKER_00: there was a period of time when people really wanted to make
• 33:22
  SPEAKER_00: the web competitive compared to native.
• 33:25
  SPEAKER_00: And so you think about, well, what are the things that are missing?
• 33:27
  SPEAKER_00: Well, you need a really good story for offline caching,
• 33:32
  SPEAKER_00: push notifications,
• 33:34
  SPEAKER_00: background sync,
• 33:36
  SPEAKER_00: all of these capabilities that we didn't necessarily have a strong story for.
• 33:41
  SPEAKER_00: And because these are non-trivial features,
• 33:43
  SPEAKER_00: you need to have a debugging story around all of them.
• 33:46
  SPEAKER_00: And so we helped build out the application panel so that you can go in and for any
• 33:49
  SPEAKER_00: of these features,
• 33:50
  SPEAKER_00: whether it's debugging service workers or it's debugging your cache or debugging any
• 33:54
  SPEAKER_00: of these things, you're able to do that.
• 33:57
  SPEAKER_00: And so even though the tool set has expanded over time for each of these eras,
• 34:02
  SPEAKER_00: I feel like DevTools has been able to keep up,
• 34:05
  SPEAKER_00: especially as the APIs in the browser has also been evolving over time
• 34:09
  SPEAKER_00: to meet these moments.
• 34:10
  SPEAKER_01: Well, that's interesting because I usually,
• 34:12
  SPEAKER_01: when I look through different companies and their strengths,
• 34:15
  SPEAKER_01: Microsoft is amazing at building IDEs and so is, for example, JetBrains.
• 34:20
  SPEAKER_01: But for Google, I never felt that Google was any good at building IDEs.
• 34:25
  SPEAKER_01: I mean, the kind of debug functionality I'm used to
• 34:40
  SPEAKER_01: Visual Studio have,
• 34:41
  SPEAKER_01: which is breakpoints,
• 34:42
  SPEAKER_01: conditional breakpoints,
• 34:43
  SPEAKER_01: all sorts of so many debug options from as you just a performance memory,
• 34:48
  SPEAKER_01: being able to simulate some of those things.
• 34:50
  SPEAKER_01: So it's very interesting for me to see that it's almost as if I'm not sure
• 34:54
  SPEAKER_01: if this was you,
• 34:55
  SPEAKER_01: your team or Google as a whole, but they realize the browser is very important.
• 34:59
  SPEAKER_01: And so they built like almost like it's almost like an ID inside of it.
• 35:03
  SPEAKER_01: You can you can edit the things in line and I think as engineers or as developers,
• 35:09
  SPEAKER_01: unless you work in front end,
• 35:11
  SPEAKER_01: you never really noticed this,
• 35:12
  SPEAKER_01: but when you do, it's fascinating how it came together.
• 35:15
  SPEAKER_00: Yeah, it's really fascinating.
• 35:17
  SPEAKER_00: And I think that are we in IDE?
• 35:19
  SPEAKER_00: Aren't we in IDE?
• 35:20
  SPEAKER_00: Is that a direction we want to go in was always a hot topic for the team.
• 35:24
  SPEAKER_00: And I think that where things kind of landed was, well,
• 35:27
  SPEAKER_00: we want to meet developers where they're at because you're always going
• 35:30
  SPEAKER_00: to have your favorite editor.
• 35:32
  SPEAKER_00: Now we're talking about You know, your control planes for your agents.
• 35:35
  SPEAKER_00: You're always going to have a different surface, right, that you want to primarily work in.
• 35:39
  SPEAKER_00: And as long as DevTools can meet you where you're at and be useful,
• 35:42
  SPEAKER_00: I think that that's been something the team has tried to do.
• 35:45
  SPEAKER_00: We continued having other eras.
• 35:48
  SPEAKER_00: Kyle became our next tech lead after Pavel and helped us through the era of trying
• 35:54
  SPEAKER_00: to figure out AI is now in the picture.
• 35:57
  SPEAKER_00: And we want to both be able to help humans reason through this massive amount
• 36:02
  SPEAKER_00: of data that the browser generates for you,
• 36:04
  SPEAKER_00: as well as make it possible for you to connect your agent up to Chrome and DevTools
• 36:09
  SPEAKER_00: and be able to have it just automate a lot of these journeys for you.
• 36:13
  SPEAKER_00: And so I think that for the first of those problems,
• 36:17
  SPEAKER_00: I remember anytime I would work with a big site on their performance problems,
• 36:21
  SPEAKER_00: you could easily spend half a day just looking at traces
• 36:25
  SPEAKER_00: before you've even written any fixes at all.
• 36:28
  SPEAKER_00: And now that we have LLMs,
• 36:30
  SPEAKER_00: it's very quick to reason through massive stack traces and actually be able
• 36:35
  SPEAKER_00: to get down to fixes you can make.
• 36:36
  SPEAKER_00: And that's just been really, really wonderful to see happen.
• 36:40
  SPEAKER_01: Addy just described using LMs to go from massive stack choices to working fixes,
• 36:44
  SPEAKER_01: which is a perfect moment to talk about our season sponsor, Sentry.
• 36:48
  SPEAKER_01: You probably already know what Sentry is because you're a developer.
• 36:50
  SPEAKER_01: If not, just ask a dev and they'll tell you.
• 36:52
  SPEAKER_01: I use Sentry to monitor the backend of the Pragmatic Entry for any and all errors.
• 36:56
  SPEAKER_01: Of course, Sentry doesn't only do errors.
• 36:58
  SPEAKER_01: They also have logs,
• 36:59
  SPEAKER_01: replays,
• 37:00
  SPEAKER_01: spans, profiles, metrics, and more because they're all connected by the same trace.
• 37:04
  SPEAKER_01: One new capability Sentry has built that I'm really liking is the ability to fix errors.
• 37:08
  SPEAKER_01: Let me show you.
• 37:09
  SPEAKER_01: Here's the list of errors on my admin backend.
• 37:12
  SPEAKER_01: There's a recent error on auth that I want to check out.
• 37:14
  SPEAKER_01: Let's have Sear run an autofix for us.
• 37:17
  SPEAKER_01: Sear is Sentry's AI debugging tool.
• 37:19
  SPEAKER_01: First, it generates a root cause analysis.
• 37:22
  SPEAKER_01: It's finding some problem with HTTP versus HTTPS URLs.
• 37:27
  SPEAKER_01: Cool.
• 37:27
  SPEAKER_01: Now that we know what's going wrong, Sear can create a plan on how to go about fixing it.
• 37:32
  SPEAKER_01: I could go and edit this plan, but I'm happy with it, so let's create an actual code fix.
• 37:37
  SPEAKER_01: Here's a code fix that Sear generated.
• 37:39
  SPEAKER_01: Assuming it looks good, and in my case it does, let's draft a pull request.
• 37:43
  SPEAKER_01: And boom, the pull request is created, ready to merge.
• 37:47
  SPEAKER_01: What I love about autofix is how Sentry went from showing a list
• 37:50
  SPEAKER_01: of errors inside my application to offering me a fast way to fix it and close
• 37:54
  SPEAKER_01: the loop while I stay in charge of this bug fix the whole time.
• 37:58
  SPEAKER_01: Debugging just got a whole lot faster and a whole lot easier.
• 38:01
  SPEAKER_01: Check out Sentry at sentry.io slash pragmatic and start detecting errors,
• 38:04
  SPEAKER_01: diagnosing the root causes, and fixing issues and regressions today.
• 38:08
  SPEAKER_01: Addy mentioned things that change when we work with alums.
• 38:11
  SPEAKER_01: One thing is for sure.
• 38:12
  SPEAKER_01: If you work with agents, your job is no longer writing code, it's specifying and testing it.
• 38:18
  SPEAKER_01: And this leads us to our presenting sponsor, Antisysys.
• 38:21
  SPEAKER_01: Antisysys is the most effective method of verifying agentic code today.
• 38:24
  SPEAKER_01: Let me explain how it works.
• 38:25
  SPEAKER_01: Antisysys runs your whole system in a hostile simulation.
• 38:28
  SPEAKER_01: By doing so, it finds every bug before your users do.
• 38:32
  SPEAKER_01: And because the simulation is fully deterministic,
• 38:34
  SPEAKER_01: Antisysys doesn't only find bugs,
• 38:36
  SPEAKER_01: it gives you a perfect reproduction of every issue.
• 38:38
  SPEAKER_01: To create such a tool, the Antisysys team needed to invent new kinds of debugging tools as well.
• 38:42
  SPEAKER_01: For example, here's what's called a bug probability graph.
• 38:45
  SPEAKER_01: The x-axis is virtual time and the y-axis is probability.
• 38:49
  SPEAKER_01: As Antisysys runs the hostile simulations,
• 38:51
  SPEAKER_01: it plots timeframes when the bug probability increases,
• 38:55
  SPEAKER_01: which greatly helps with finding the root cause of bugs.
• 38:57
  SPEAKER_01: And Antisysys also has a log visualizer.
• 39:00
  SPEAKER_01: Vertical lines going down represent events branching off from the same state.
• 39:04
  SPEAKER_01: And the purple dots are where the buck happens.
• 39:06
  SPEAKER_01: Antisysys is as good as it gets being able to ship agent-written code.
• 39:09
  SPEAKER_01: It's what teams at Janestreet, Fly.io, and the etcd community use to ship with full confidence.
• 39:14
  SPEAKER_01: Head to antisysys.comstack-pragmatic to learn more.
• 39:17
  SPEAKER_00: And with this, let's get back to Addy and talk about core web vitals.
• 39:21
  SPEAKER_01: And one area that you really pushed,
• 39:24
  SPEAKER_01: you and the team pushed the industry together as core web vitals.
• 39:27
  SPEAKER_01: You know,
• 39:27
  SPEAKER_01: these are a standardized set of metrics to just figure out
• 39:31
  SPEAKER_01: the real world experience,
• 39:32
  SPEAKER_01: the web pages and some of the,
• 39:34
  SPEAKER_01: you know,
• 39:35
  SPEAKER_01: before this, again,
• 39:36
  SPEAKER_01: You would,
• 39:37
  SPEAKER_01: as a developer,
• 39:37
  SPEAKER_01: you would measure like,
• 39:38
  SPEAKER_01: all right, how quick does it render or how quick does it download?
• 39:42
  SPEAKER_01: It was very simple stuff.
• 39:43
  SPEAKER_01: But you introduced things like LCP,
• 39:45
  SPEAKER_01: Largest Contentful Paint, CLS,
• 39:48
  SPEAKER_01: Cumulative Layout Shift,
• 39:49
  SPEAKER_01: FIE, First Input Delay, and then IMP, Interaction to Next Paint.
• 39:54
  SPEAKER_01: Like you were there, like how did the team come up with these things there?
• 39:58
  SPEAKER_01: If you're not a web engineer, it takes a little time to understand them.
• 40:03
  SPEAKER_01: But it does actually explain how users feel.
• 40:08
  SPEAKER_01: I feel you somehow, inside of Google, managed to connect the kind of feel to a number.
• 40:13
  SPEAKER_00: I think that the Chrome team has always had an appreciation for user experience research.
• 40:21
  SPEAKER_00: And again, every time there was a new moment for the web would reconsult that research.
• 40:28
  SPEAKER_00: The way that we used to reason about performance was very much like, hey, is a page loading?
• 40:40
  SPEAKER_00: And what does that even mean?
• 40:41
  SPEAKER_00: For many people, is the page ready?
• 40:44
  SPEAKER_00: But what does ready mean?
• 40:45
  SPEAKER_00: Does that mean that I see it?
• 40:47
  SPEAKER_00: Does it mean that I can click around it and anything actually happens?
• 40:52
  SPEAKER_00: And so I think for a very long time we had this almost nebulous way of thinking
• 40:57
  SPEAKER_00: about page load times.
• 40:59
  SPEAKER_00: And the team felt like it was finally time to come up with
• 41:03
  SPEAKER_00: a more nuanced perspective around how we reason about performance.
• 41:08
  SPEAKER_00: And so if you break it down,
• 41:10
  SPEAKER_00: there are a number of key moments across the user's journey that they care about.
• 41:14
  SPEAKER_00: Is it happening?
• 41:15
  SPEAKER_00: Is it happening?
• 41:16
  SPEAKER_00: Is anything loading?
• 41:18
  SPEAKER_00: Do you see a header?
• 41:19
  SPEAKER_00: Do you see a spinner?
• 41:20
  SPEAKER_00: Do you see anything at all?
• 41:21
  SPEAKER_00: Is there something useful there for you?
• 41:24
  SPEAKER_00: So maybe that's a header image.
• 41:26
  SPEAKER_00: Maybe it's a hero image.
• 41:27
  SPEAKER_00: Maybe it is a hero video.
• 41:29
  SPEAKER_00: Maybe it's like the core piece of content.
• 41:33
  SPEAKER_00: So
• 41:37
  SPEAKER_00: for things like your hero image, you can think about that as your largest contentful paint.
• 41:44
  SPEAKER_00: And that's not going to generalize across every page.
• 41:46
  SPEAKER_00: In some cases, the image may not be the most important thing.
• 41:50
  SPEAKER_00: It might be, you know, the article text.
• 41:52
  SPEAKER_00: There may be cases where, you know, you Want to be able to interact fairly quickly with a page.
• 41:58
  SPEAKER_00: I can remember many times over the years when I might be shopping and whether it's
• 42:04
  SPEAKER_00: on my phone or on my desktop,
• 42:06
  SPEAKER_00: I will click like the add to cart button and just crickets.
• 42:10
  SPEAKER_00: Nothing will happen.
• 42:11
  SPEAKER_01: Because JavaScript did not load or the event handler or maybe
• 42:15
  SPEAKER_01: the event handler was not attached because not all elements finished loading.
• 42:19
  SPEAKER_01: We know as engineers what's happening, but as a user, it's like.
• 42:22
  SPEAKER_00: As a user, you're like, wait, what's happening?
• 42:25
  SPEAKER_01: And this stuff can happen where you just tap, tap, tap,
• 42:28
  SPEAKER_01: the event handler gets attached and now you're adding it like twice or three times,
• 42:32
  SPEAKER_01: but you don't know.
• 42:35
  SPEAKER_00: Humans are shockingly simple.
• 42:38
  SPEAKER_00: If you think about the experience you have with somebody that's just trying to cross
• 42:41
  SPEAKER_00: the street,
• 42:43
  SPEAKER_00: if the light doesn't turn,
• 42:45
  SPEAKER_00: doesn't say they can walk fast enough, they'll just keep hitting that button.
• 42:48
  SPEAKER_00: That's the same experience they have on the internet.
• 42:50
  SPEAKER_00: I think that There were other aspects of user experience
• 42:53
  SPEAKER_00: that I think we acknowledged were actually kind of problematic.
• 42:57
  SPEAKER_00: One big one was over the years, obviously sites tried to monetize as heavily as they could.
• 43:02
  SPEAKER_00: And so you would see not just banner ads,
• 43:05
  SPEAKER_00: but you'd see modals, you'd see all of these things thrown up in front of your face.
• 43:11
  SPEAKER_00: Even if you set aside maybe there's some validity around a business needs
• 43:16
  SPEAKER_00: to monetize, those things shouldn't cause a really bad experience.
• 43:21
  SPEAKER_00: If I'm on a page that has a bunch of ads,
• 43:23
  SPEAKER_00: I shouldn't start reading an article and then suddenly everything gets pushed down,
• 43:27
  SPEAKER_00: right?
• 43:27
  SPEAKER_00: Just because the ad is finally loaded.
• 43:30
  SPEAKER_00: And so that's where cumulative layout shift kind of comes from.
• 43:33
  SPEAKER_00: It's this idea that,
• 43:34
  SPEAKER_00: hey, we should be trying to keep that page stable so the user has a good time.
• 43:39
  SPEAKER_00: There's a lot of iteration around how do we define these metrics in a way
• 43:44
  SPEAKER_00: that captures a few of these different use cases that are very nuanced,
• 43:47
  SPEAKER_00: because the internet is not all that homogenous.
• 43:50
  SPEAKER_00: There are lots of different ways that a person can think about the value of a page
• 43:53
  SPEAKER_00: and what's important.
• 43:55
  SPEAKER_00: And so the team did a lot of experiments,
• 43:57
  SPEAKER_00: experimented with lots of different ways of thinking about these metrics
• 44:01
  SPEAKER_00: and worked very heavily with both the standards community and developers
• 44:05
  SPEAKER_00: to validate like, hey,
• 44:06
  SPEAKER_00: do you actually believe that these things line up with how you would say you think
• 44:10
  SPEAKER_00: about the value of your pages?
• 44:13
  SPEAKER_00: One of the things that I always find fascinating is there are some companies where,
• 44:18
  SPEAKER_00: you know, they have thought from the ground up.
• 44:21
  SPEAKER_00: Like if you start from a blank white screen, what is actually important to the user end to end?
• 44:26
  SPEAKER_00: And then there are many companies where they haven't,
• 44:27
  SPEAKER_00: for whatever reason,
• 44:28
  SPEAKER_00: time or they just didn't think about it, they haven't gone through that journey.
• 44:32
  SPEAKER_00: And so Core Web Vitals allowed them to finally get a more nuanced conversation going
• 44:38
  SPEAKER_00: about like, hey, what's actually important to us?
• 44:40
  SPEAKER_00: How can we make sure that whatever key action the user has to take,
• 44:43
  SPEAKER_00: they can do it pretty quickly and be guaranteed that they're not going to have
• 44:46
  SPEAKER_00: a bad time?
• 44:47
  SPEAKER_01: Now, you spent 14 years inside of Google.
• 44:50
  SPEAKER_01: Most of it was inside a Chrome organization.
• 44:52
  SPEAKER_01: Later, you moved over to Cloud AI and worked with Geno AI as well.
• 44:57
  SPEAKER_01: We've done research before on Google's engineering culture,
• 45:00
  SPEAKER_01: but can you summarize what it felt working there in terms of what,
• 45:05
  SPEAKER_01: and especially comparing to the startups that you were before,
• 45:07
  SPEAKER_01: you also talk with companies now outside of Google,
• 45:11
  SPEAKER_01: what were things that are uniquely Google?
• 45:14
  SPEAKER_00: As part of my Google journey, there was a lot of work that I did on the developer side.
• 45:17
  SPEAKER_00: There's also a lot of work that I did on the consumer side.
• 45:20
  SPEAKER_00: So working on Chrome performance, for example.
• 45:24
  SPEAKER_00: And when you're working on something that goes out to billions and billions
• 45:29
  SPEAKER_00: of users,
• 45:30
  SPEAKER_00: which is the case for many Google products now,
• 45:34
  SPEAKER_00: the way that you think about engineering culture,
• 45:37
  SPEAKER_00: velocity,
• 45:38
  SPEAKER_00: experimentation is very,
• 45:40
  SPEAKER_00: very different,
• 45:41
  SPEAKER_00: I think,
• 45:41
  SPEAKER_00: than sometimes how a startup might approach things,
• 45:44
  SPEAKER_00: especially if you're trying to move very fast.
• 45:46
  SPEAKER_00: When we try to make a change inside a browser that has a global audience with a lot
• 45:51
  SPEAKER_00: of people,
• 45:52
  SPEAKER_00: There's a lot of experimentation that has to happen and a lot of experimentation
• 45:57
  SPEAKER_00: that also requires just like testing out, well, hey,
• 46:01
  SPEAKER_00: does this problem not have one solution,
• 46:03
  SPEAKER_00: but actually a couple of different ones, depending on what market you're in?
• 46:07
  SPEAKER_00: And how do you evaluate success when maybe we have 20 other experiments
• 46:13
  SPEAKER_00: or 100 other experiments happening at the same time?
• 46:16
  SPEAKER_00: And so...
• 46:17
  SPEAKER_00: The A-B testing culture, I would say, was a very big thing.
• 46:21
  SPEAKER_00: And kudos to the Chrome team for having what is now,
• 46:24
  SPEAKER_00: I would say,
• 46:25
  SPEAKER_00: a fairly stable and rigorous process for being able to try those things out in
• 46:29
  SPEAKER_00: the real world.
• 46:30
  SPEAKER_00: I also felt that even though sometimes from
• 46:33
  SPEAKER_00: the outside it didn't necessarily always come across,
• 46:36
  SPEAKER_00: zoomed out at the Google level,
• 46:38
  SPEAKER_00: I did feel like there were many people that cared a lot about developer goodwill
• 46:44
  SPEAKER_00: and developer sentiment.
• 46:47
  SPEAKER_00: You know, a very large company.
• 46:49
  SPEAKER_00: Obviously, it's going to be very challenging to have every group talking to every other group.
• 46:53
  SPEAKER_01: Oh, yeah.
• 46:54
  SPEAKER_01: Impossible.
• 46:55
  SPEAKER_00: We always made best efforts to try getting to a place where we were doing
• 47:00
  SPEAKER_00: the right things for developers as best we could.
• 47:03
  SPEAKER_00: But I was glad to see that sentiment and that level of care for the community and for our users.
• 47:08
  SPEAKER_00: I also appreciated that Google was open to change.
• 47:14
  SPEAKER_00: So I would say if I had to summarize my one big change contribution
• 47:20
  SPEAKER_00: to Chrome's culture, it would be meeting the developers where they're at.
• 47:24
  SPEAKER_00: And that embrace of people are going to use whatever tech they want to use.
• 47:29
  SPEAKER_00: You can't tell people what to use very often.
• 47:32
  SPEAKER_00: They're going to use whatever they want.
• 47:33
  SPEAKER_00: And your job is to help them be successful on your platform and
• 47:38
  SPEAKER_00: to help their users have a great time.
• 47:40
  SPEAKER_00: I think that there were a lot of decisions And so I was very happy to see that happen.
• 47:43
  SPEAKER_00: I would also say that
• 48:08
  SPEAKER_00: Google was very good at allowing different parts of the company
• 48:13
  SPEAKER_00: to share their learnings towards some point of convergence.
• 48:17
  SPEAKER_00: So for example, the Software Engineering at Google book, one of my favorite books.
• 48:22
  SPEAKER_00: I was very happy to see different flavors of that over the years internally at
• 48:27
  SPEAKER_00: the company,
• 48:28
  SPEAKER_00: because you work at such a big company,
• 48:31
  SPEAKER_00: you're always curious, well, what is best practice, right?
• 48:34
  SPEAKER_00: Like, is there a best practice?
• 48:36
  SPEAKER_01: So there were like internal writings of like,
• 48:37
  SPEAKER_01: here's how this org is doing some parts of software engineering or building
• 48:41
  SPEAKER_01: or experimentation or whatever.
• 48:43
  SPEAKER_00: Yeah, one of my favorite things to do was,
• 48:45
  SPEAKER_00: you know,
• 48:46
  SPEAKER_00: I was curious, well,
• 48:47
  SPEAKER_00: my team might have a perspective on testing or user experience,
• 48:52
  SPEAKER_00: but how does the YouTube team think about it?
• 48:55
  SPEAKER_00: And are there parallels?
• 48:57
  SPEAKER_00: Are there things that we could learn from each other?
• 48:59
  SPEAKER_00: And there certainly were,
• 49:00
  SPEAKER_00: you know,
• 49:00
  SPEAKER_00: even looking at how other people think about the world can sometimes lead
• 49:03
  SPEAKER_00: to collaboration opportunities.
• 49:06
  SPEAKER_00: We actually worked with the YouTube team to improve their core vitals at one point.
• 49:11
  SPEAKER_00: And they were excited to see that there were just more refined metrics and ways
• 49:15
  SPEAKER_00: of thinking about experience.
• 49:17
  SPEAKER_01: I mean,
• 49:17
  SPEAKER_01: I guess it's just important to point out that this collaborative nature is not
• 49:21
  SPEAKER_01: a given in all large companies.
• 49:23
  SPEAKER_01: There are some companies,
• 49:24
  SPEAKER_01: don't want to name names right now,
• 49:26
  SPEAKER_01: but where organizations don't feel that they're incentivized to work with each other
• 49:31
  SPEAKER_01: because they might have different goals.
• 49:32
  SPEAKER_01: And it's not that they hate each other.
• 49:34
  SPEAKER_01: They're just like focused on themselves.
• 49:35
  SPEAKER_01: And it can feel a lot more, I guess, political in that sense.
• 49:38
  SPEAKER_01: Yeah.
• 49:38
  SPEAKER_00: We talk a lot about high agency these days.
• 49:43
  SPEAKER_00: And I think that sometimes when you see those collaborations happen,
• 49:47
  SPEAKER_00: it's because there are people with enough agency on both sides that they want
• 49:51
  SPEAKER_00: to make it happen.
• 49:53
  SPEAKER_00: We see the mutual value in collaborating because exploring how to improve
• 49:59
  SPEAKER_00: the user experience for something like YouTube,
• 50:01
  SPEAKER_00: it was extremely nuanced,
• 50:03
  SPEAKER_00: extremely educational, very nuanced, but also took a very long time.
• 50:06
  SPEAKER_00: And we just felt like the value was there.
• 50:09
  SPEAKER_00: I was glad that we could make it happen.
• 50:10
  SPEAKER_01: Can we talk about your specific career path inside of Google?
• 50:14
  SPEAKER_01: So you spent 14 years there, which is a very long tenure.
• 50:17
  SPEAKER_01: And I'm starting to develop a bias for like,
• 50:20
  SPEAKER_01: it's nice to have long tenure somewhere at some point in your career.
• 50:24
  SPEAKER_01: There's a lot of values.
• 50:25
  SPEAKER_01: You were just talking with Simon, the founder of Turbo Puffer, about this earlier.
• 50:30
  SPEAKER_01: What level did you get in?
• 50:32
  SPEAKER_01: How was your career progression?
• 50:34
  SPEAKER_01: At what point did you become a manager?
• 50:36
  SPEAKER_01: And how did you think about things like career, compensation, growing?
• 50:42
  SPEAKER_00: Yeah.
• 50:44
  SPEAKER_00: So I started my Google career back when I was living in the UK, actually.
• 50:50
  SPEAKER_01: So you joined Google UK.
• 50:52
  SPEAKER_00: Yeah, I joined Google UK originally.
• 50:53
  SPEAKER_00: And I believe I joined at a level four.
• 50:57
  SPEAKER_01: Yeah, that was one, the mid-level software engineer.
• 51:00
  SPEAKER_01: Yeah.
• 51:01
  SPEAKER_00: Back then,
• 51:02
  SPEAKER_00: and I was a developer relations engineer,
• 51:05
  SPEAKER_00: so a person that's in DevRel,
• 51:06
  SPEAKER_00: but you're a little bit more focused on, you know, the builder side of things.
• 51:10
  SPEAKER_00: Over the years, I kind of got promoted in that role to like level five and level six.
• 51:17
  SPEAKER_00: I became a manager within DevRel.
• 51:19
  SPEAKER_01: When you were at level six at the staff level.
• 51:21
  SPEAKER_01: Yeah, yeah.
• 51:22
  SPEAKER_00: And then I was was leading part of the DevRel team and At some point,
• 51:29
  SPEAKER_00: maybe five or six years in,
• 51:33
  SPEAKER_00: I started to feel like,
• 51:34
  SPEAKER_00: you know, I loved doing developer relations, but I am very much a builder at heart.
• 51:40
  SPEAKER_00: I love engineering and I love product.
• 51:42
  SPEAKER_00: I love all of it.
• 51:43
  SPEAKER_00: Yeah, I get it.
• 51:44
  SPEAKER_00: I was very curious,
• 51:46
  SPEAKER_00: you know,
• 51:46
  SPEAKER_00: what it would be like to be on the other side of that because I'd been
• 51:51
  SPEAKER_00: in engineering prior to Google.
• 51:52
  SPEAKER_00: I hadn't been, you know, in an official dev rel position prior to that.
• 51:56
  SPEAKER_00: And I was interested in going back down the And so over the years,
• 52:01
  SPEAKER_00: I transitioned back into kind of software engineering and specifically like
• 52:06
  SPEAKER_00: an engineering manager role.
• 52:09
  SPEAKER_00: That gave me the flexibility to both do like engineering work, but also manage teams.
• 52:15
  SPEAKER_01: But you just had a smaller team at that point?
• 52:18
  SPEAKER_00: At the start, had a smaller team and then it grew out.
• 52:24
  SPEAKER_00: I would say the average at one point was probably in the 45s to 50s.
• 52:28
  SPEAKER_00: I think that
• 52:30
  SPEAKER_00: Depending on where you are in your leadership or manager journey,
• 52:34
  SPEAKER_00: you know, success means different things.
• 52:36
  SPEAKER_00: Not success from a career perspective, but just success for the organization.
• 52:40
  SPEAKER_00: Because ultimately what you want to get to is a place where ideally
• 52:45
  SPEAKER_00: the team is almost self-sufficient.
• 52:47
  SPEAKER_00: And I write about this a little bit in my book,
• 52:50
  SPEAKER_00: Leading Effective Engineering Teams,
• 52:52
  SPEAKER_00: but you want to get to a point where Your machine,
• 52:57
  SPEAKER_00: your org is self-sufficient enough that you just need to occasionally tap the blimp,
• 53:03
  SPEAKER_00: make sure that things are working.
• 53:04
  SPEAKER_00: You can course correct if it's not,
• 53:06
  SPEAKER_00: but that frees you up to then focus on the next important sets of problems that
• 53:10
  SPEAKER_00: the org needs to tackle heads on.
• 53:13
  SPEAKER_00: And that allowed me,
• 53:14
  SPEAKER_00: for example,
• 53:15
  SPEAKER_00: to really get deep into thinking about,
• 53:18
  SPEAKER_00: okay, well, model quality is starting to get better.
• 53:22
  SPEAKER_00: What does that mean for developers?
• 53:23
  SPEAKER_00: What does that mean for developer tooling?
• 53:25
  SPEAKER_00: What does it mean for how we think about benchmarks and collaborations
• 53:30
  SPEAKER_00: with third-party vendors and all of these other things that are part
• 53:33
  SPEAKER_00: of developer success?
• 53:35
  SPEAKER_00: And so I was glad that I had that time.
• 53:38
  SPEAKER_00: And then I could take those learnings back to the team and work with them
• 53:41
  SPEAKER_00: to evolve us into this moment
• 53:43
  SPEAKER_00: where we could help developers maximize how useful DevTools can be and DevTools
• 53:48
  SPEAKER_00: and Chrome can be for agents.
• 53:50
  SPEAKER_01: So do I understand correctly that?
• 53:53
  SPEAKER_01: You were an individual contributor,
• 53:55
  SPEAKER_01: you were going up the career ladder,
• 53:57
  SPEAKER_01: which is somewhat expected at a large company like Google with the right mentors and
• 54:02
  SPEAKER_01: the right structure.
• 54:03
  SPEAKER_01: And then when you became a manager and you switched,
• 54:05
  SPEAKER_01: you decided to build a bit more,
• 54:07
  SPEAKER_01: you then Focused on you still are growing and increasing large team in 40 people.
• 54:11
  SPEAKER_01: That's not a small team,
• 54:12
  SPEAKER_01: but you try to help the team fix any issues,
• 54:16
  SPEAKER_01: help them mostly run by themselves so that you would have some time
• 54:19
  SPEAKER_01: to actually do some individual contributor like work.
• 54:23
  SPEAKER_01: So you can keep your hands dirty, but also help the team.
• 54:25
  SPEAKER_01: So it seems like, do I understand that you just prioritize to have that time to build?
• 54:31
  SPEAKER_01: Because of course, when you're a manager, this could easily suck up all of your time.
• 54:34
  SPEAKER_00: Oh yeah, absolutely.
• 54:35
  SPEAKER_00: And I don't want to make small of all the work it takes to get to that point,
• 54:40
  SPEAKER_00: because a lot of management is trying to work towards that point.
• 54:43
  SPEAKER_00: You need to Build out a team structure,
• 54:47
  SPEAKER_00: like in some cases you have managers, managing managers, right, of other teams.
• 54:54
  SPEAKER_00: And we had a global team of people,
• 54:57
  SPEAKER_00: of course,
• 54:57
  SPEAKER_00: that comes with navigating time zones and coordination overhead and communication
• 55:02
  SPEAKER_00: and all those things.
• 55:03
  SPEAKER_00: And so I think that we were fortunate that we were able to get to a place where
• 55:07
  SPEAKER_00: the team was largely pretty effective and we were able to create more of the space.
• 55:11
  SPEAKER_00: And then I take those learnings and I try to help some of my other managers.
• 55:15
  SPEAKER_00: Like, how do you create this space now for you so that you can also help us
• 55:18
  SPEAKER_00: on this journey of modernizing for the AI moment?
• 55:21
  SPEAKER_00: So I went from L6 to L7 to Director in my...
• 55:28
  SPEAKER_01: Is Director L8 or L7?
• 55:30
  SPEAKER_00: Director's L8.
• 55:31
  SPEAKER_01: Oh, wow.
• 55:32
  SPEAKER_01: So that's kind of... Well, congrats.
• 55:35
  SPEAKER_01: It becomes... Every level becomes somewhat harder and harder, as I understand.
• 55:40
  SPEAKER_01: But did you care too much about the actual levels or was it more about the work
• 55:44
  SPEAKER_01: and things just followed?
• 55:45
  SPEAKER_00: I think for a very long time it was about the work,
• 55:48
  SPEAKER_00: but also as you get to a point where you feel like the organization is in
• 55:54
  SPEAKER_00: a healthy place,
• 55:56
  SPEAKER_00: you do start thinking about,
• 55:56
  SPEAKER_00: okay, well, next level of my career, taking on different kinds of problems.
• 56:00
  SPEAKER_01: Or more like the next challenge, right?
• 56:01
  SPEAKER_00: Yeah, the next challenge.
• 56:02
  SPEAKER_00: And so I was very much wanting to go for a director kind of promotion for quite a
• 56:09
  SPEAKER_00: while, and I was working towards that.
• 56:11
  SPEAKER_00: And I think that for anyone that's gone through career changes or promotions,
• 56:15
  SPEAKER_00: you know that you kind of have to be doing the job for a while before you get it.
• 56:19
  SPEAKER_00: Yes.
• 56:20
  SPEAKER_00: What kind of got you where you are is what's going to get you to that next level, right?
• 56:25
  SPEAKER_00: It's a different set of challenges.
• 56:27
  SPEAKER_00: And so I was excited to get to start experiencing those kinds of challenges
• 56:31
  SPEAKER_00: and working more across Google,
• 56:34
  SPEAKER_00: working more with our VP and SVP layers to try figuring out, well, Yeah,
• 56:40
  SPEAKER_00: what is the next couple of years or what does the next year look like for Android,
• 56:44
  SPEAKER_00: for Chrome,
• 56:45
  SPEAKER_00: for different platform teams as we're going through these kind
• 56:48
  SPEAKER_00: of revolutionary moments?
• 56:49
  SPEAKER_00: We're trying to rethink everything.
• 56:50
  SPEAKER_01: I did want to ask because we have a lot of pretty experienced viewers and listeners.
• 56:55
  SPEAKER_01: What is the difference in becoming a director at Google specifically
• 57:00
  SPEAKER_01: because director, it does the first executive level.
• 57:03
  SPEAKER_01: I mean, different companies called different,
• 57:04
  SPEAKER_01: but like it's the first one which it might be included in terms of responsibility,
• 57:11
  SPEAKER_01: the weight on your shoulder because it does feel like that feels in
• 57:14
  SPEAKER_01: the management chain.
• 57:15
  SPEAKER_01: That is the biggest jump at a large company like this.
• 57:19
  SPEAKER_00: I think that a good way to think about it is when I was coming up through the ranks,
• 57:25
  SPEAKER_00: your director was very often your first point of contact,
• 57:29
  SPEAKER_00: as you said, at the executive level.
• 57:31
  SPEAKER_00: They would be the ones who would be keeping you on the And so there
• 57:34
  SPEAKER_00: an increased feeling of accountability at that level.
• 58:04
  SPEAKER_00: You have to pay attention to the details.
• 58:07
  SPEAKER_00: I think that you can't be successful in that role if you're kind of just letting go.
• 58:11
  SPEAKER_00: And when I say like you want ideally to have a self-running org,
• 58:15
  SPEAKER_00: it's not about letting go entirely at all,
• 58:19
  SPEAKER_00: but it's about having enough of a system in place where you get
• 58:22
  SPEAKER_00: the information you need.
• 58:24
  SPEAKER_00: Any decisions,
• 58:25
  SPEAKER_00: any blocks that your teams are running into are surfaced quickly to you
• 58:29
  SPEAKER_00: so you can help them unblock them.
• 58:31
  SPEAKER_00: I think that that's really one of the biggest pieces,
• 58:34
  SPEAKER_00: like making sure that the business goals get done and making sure that people
• 58:40
  SPEAKER_00: who perhaps sometimes don't necessarily understand how to connect
• 58:44
  SPEAKER_00: the tech that's being done back to the business goals,
• 58:47
  SPEAKER_00: like see that through line very clearly.
• 58:51
  SPEAKER_00: I was doing the director role through my time working on Gemini and Cloud AI.
• 58:56
  SPEAKER_00: I was responsible for one of our top goals for the year.
• 59:01
  SPEAKER_00: You're expected to report on that every week or two and be held accountable.
• 59:05
  SPEAKER_00: So you need to make sure that everything happens.
• 59:07
  SPEAKER_00: So it sounds like it's almost like if you're juggling stuff,
• 59:09
  SPEAKER_00: you're given like two extra balls,
• 59:10
  SPEAKER_00: which is like now you both the accountability, communicating upwards with execs.
• 59:22
  SPEAKER_01: Owning the business goals while doing everything else in terms of like running
• 59:26
  SPEAKER_01: a now probably larger team,
• 59:28
  SPEAKER_01: being able to deep dive into the details of keeping yourself to date.
• 59:31
  SPEAKER_01: So, yeah, well,
• 59:32
  SPEAKER_01: I guess it kind of makes sense that there's a trajectory where if
• 59:35
  SPEAKER_01: the longer you work in an organization,
• 59:37
  SPEAKER_01: the more context you'll have, the more ready you often become.
• 59:40
  SPEAKER_00: Absolutely.
• 59:41
  SPEAKER_00: Absolutely.
• 59:41
  SPEAKER_00: And I think an interesting anecdote that I think is worth sharing is that
• 59:46
  SPEAKER_00: And I don't think this was specific to Google.
• 59:48
  SPEAKER_00: One of the things I found most exciting in the last couple of years was seeing
• 59:54
  SPEAKER_00: as model quality has gotten better and harnesses and tools have gotten better,
• 59:59
  SPEAKER_00: how many people that were directors or VPs or SVPs or any
• 1:00:03
  SPEAKER_00: of these levels were actually rolling up their sleeves and trying things out.
• 1:00:08
  SPEAKER_00: And that was awesome to see because every week you could then have conversations
• 1:00:12
  SPEAKER_00: with people like, hey, what did you build at the weekend?
• 1:00:15
  SPEAKER_00: What models are you trying out?
• 1:00:16
  SPEAKER_00: What are you running into friction with?
• 1:00:18
  SPEAKER_00: What workflows are you using?
• 1:00:20
  SPEAKER_00: And that's not something that was happening before.
• 1:00:23
  SPEAKER_00: Execs were very typically focused on big company problems or big work problems.
• 1:00:28
  SPEAKER_00: But that's been changing in the last couple of years.
• 1:00:30
  SPEAKER_01: Which is very nice to answer the next topic,
• 1:00:32
  SPEAKER_01: which is how AI in your observation experience is changing software engineering.
• 1:00:38
  SPEAKER_01: Right before we start talking about one question that comes up to you from a lot
• 1:00:42
  SPEAKER_01: of people and you're also thinking about is this idea of like cognitive surrender.
• 1:00:46
  SPEAKER_01: Yeah.
• 1:00:46
  SPEAKER_01: Let's get into that.
• 1:00:47
  SPEAKER_00: Yeah, so there's two pieces here.
• 1:00:51
  SPEAKER_00: The first is cognitive debt.
• 1:00:52
  SPEAKER_00: So the more that you use AI,
• 1:00:55
  SPEAKER_00: it's sort of the erosion of your ability to have good memory
• 1:00:59
  SPEAKER_00: and have good understanding of the problems that you're working on.
• 1:01:03
  SPEAKER_00: And the natural follow-up to that is cognitive surrender,
• 1:01:05
  SPEAKER_00: which is where you blindly give in to whatever the AI says as your answer.
• 1:01:12
  SPEAKER_00: Its answer becomes your answer.
• 1:01:14
  SPEAKER_00: And so you start to really let go of critical thinking and your ability
• 1:01:19
  SPEAKER_00: to solve problems just goes to the wayside.
• 1:01:22
  SPEAKER_00: I think that that's something we want to avoid because,
• 1:01:25
  SPEAKER_00: you know,
• 1:01:25
  SPEAKER_00: I'm personally,
• 1:01:26
  SPEAKER_00: I'm a big fan of the evolution curve we're seeing with harness engineering
• 1:01:31
  SPEAKER_00: and loop engineering and software factories and all of these things.
• 1:01:34
  SPEAKER_00: I'm very excited about them.
• 1:01:36
  SPEAKER_00: But at the same time,
• 1:01:37
  SPEAKER_00: I think that we still need to understand enough about how things work so that
• 1:01:43
  SPEAKER_00: if something does go wrong,
• 1:01:45
  SPEAKER_00: we're actually able to fix it and not just hope and pray that the agent is able
• 1:01:49
  SPEAKER_00: to figure things out.
• 1:01:50
  SPEAKER_01: And it was about a year ago where you wrote about the importance of
• 1:01:56
  SPEAKER_01: when you're working with an agent,
• 1:01:57
  SPEAKER_01: and this was before they were as capable as today.
• 1:01:59
  SPEAKER_01: But when you're working with an agent, read through, read through what it has, think through.
• 1:02:04
  SPEAKER_01: And then,
• 1:02:04
  SPEAKER_01: you know,
• 1:02:04
  SPEAKER_01: when it generates the code, read through that code, make sure you understand.
• 1:02:07
  SPEAKER_01: So like you're kind of like doing a review.
• 1:02:09
  SPEAKER_01: Now we have a lot more powerful agents.
• 1:02:12
  SPEAKER_01: We can now, some people work like multiple agents.
• 1:02:16
  SPEAKER_01: What is your thinking on the kind of the reading, the going at the same pace of the agent?
• 1:02:22
  SPEAKER_01: And, you know, like,
• 1:02:23
  SPEAKER_01: because there's this friction of like,
• 1:02:24
  SPEAKER_01: it's now so much easier to like not let go because you want to let go
• 1:02:28
  SPEAKER_01: and have cognitive depth.
• 1:02:29
  SPEAKER_01: It's just like they're faster and it's pretty good for the most part.
• 1:02:32
  SPEAKER_00: With many challenges people run into in life,
• 1:02:36
  SPEAKER_00: there's a lack of intentionality around wanting to avoid them.
• 1:02:39
  SPEAKER_00: And this is one of those places where I see this happen quite a lot.
• 1:02:44
  SPEAKER_00: And my thinking on this has changed a little bit.
• 1:02:46
  SPEAKER_00: A year ago,
• 1:02:47
  SPEAKER_00: You know,
• 1:02:48
  SPEAKER_00: maybe you would have,
• 1:02:49
  SPEAKER_00: you know,
• 1:02:50
  SPEAKER_00: like one thinking message from the agent saying, hey,
• 1:02:53
  SPEAKER_00: I'm thinking in the background and you'd expand it and you would see a trajectory
• 1:02:56
  SPEAKER_00: and you'd see the summary of like all the things that are happening.
• 1:02:58
  SPEAKER_01: And it was like in speed where you could follow as well.
• 1:03:01
  SPEAKER_01: It's like every few seconds, something coming.
• 1:03:04
  SPEAKER_00: Yeah.
• 1:03:04
  SPEAKER_00: And now if you're using quad code or codex,
• 1:03:08
  SPEAKER_00: it's very possible that 20 or 30 sub agents have fired.
• 1:03:12
  SPEAKER_00: I am not going to click through 30 of those things to read through their trajectories.
• 1:03:16
  SPEAKER_00: But I do make sure that I do two things.
• 1:03:19
  SPEAKER_00: The first thing I do is I try to make sure that if there is a summary at
• 1:03:23
  SPEAKER_00: the very end, here are all the decisions that were made.
• 1:03:26
  SPEAKER_00: I will read through that end to end.
• 1:03:29
  SPEAKER_00: If there hasn't been, I will prompt for that decision process.
• 1:03:33
  SPEAKER_00: And you have to be careful because you don't want a model to kind of BS you about
• 1:03:37
  SPEAKER_00: the decisions that were made.
• 1:03:38
  SPEAKER_00: Because sometimes it can just make things up, right?
• 1:03:43
  SPEAKER_01: As we know, it's not deliberate necessarily, but it runs out of context window.
• 1:03:46
  SPEAKER_01: Exactly.
• 1:03:47
  SPEAKER_01: There's limitations to these things.
• 1:03:48
  SPEAKER_00: Exactly.
• 1:03:48
  SPEAKER_00: And that goes on to the second thing.
• 1:03:51
  SPEAKER_00: I'm a really big fan of this idea of mutual amplification.
• 1:03:56
  SPEAKER_00: If you are working with an agent,
• 1:04:00
  SPEAKER_00: a coding agent,
• 1:04:01
  SPEAKER_00: there are a lot of things that you can do to make sure that
• 1:04:04
  SPEAKER_00: the agent is getting better every day and you as
• 1:04:06
  SPEAKER_00: an engineer are getting better every day.
• 1:04:08
  SPEAKER_00: There are simple things that can play into that.
• 1:04:10
  SPEAKER_00: Things like even within the session or within this project,
• 1:04:13
  SPEAKER_00: can you log your learnings from the session?
• 1:04:16
  SPEAKER_00: Can you log any decisions that were made,
• 1:04:18
  SPEAKER_00: any friction that you ran into,
• 1:04:21
  SPEAKER_00: anything that you think is unique about how you've approached this problem
• 1:04:24
  SPEAKER_00: that I should just keep in mind?
• 1:04:26
  SPEAKER_00: That's intentionality.
• 1:04:27
  SPEAKER_00: That's like, I want to understand how things work behind the scenes.
• 1:04:32
  SPEAKER_00: And as long as you have that curiosity and that thirst for at least being just
• 1:04:36
  SPEAKER_00: a little bit curious,
• 1:04:38
  SPEAKER_00: I think that you can work with models in a way where you're still preserving
• 1:04:41
  SPEAKER_00: a little bit of your cognitive understanding about how things work.
• 1:04:45
  SPEAKER_01: One new building block that's coming up in Genica Engineering is this idea of loop engineering.
• 1:04:50
  SPEAKER_01: And Peter Steinberger wrote about it.
• 1:04:53
  SPEAKER_01: Boris Czerny wrote about it, about running loops.
• 1:04:56
  SPEAKER_01: A lot of us are trying to figure out what loops exactly are.
• 1:04:58
  SPEAKER_01: You also wrote a post about loops.
• 1:05:02
  SPEAKER_01: What do you think loops are?
• 1:05:04
  SPEAKER_01: How should we think of them?
• 1:05:05
  SPEAKER_01: Or is this just something that is useful for a few people?
• 1:05:09
  SPEAKER_01: Where are you at with that?
• 1:05:10
  SPEAKER_00: A good way to think about,
• 1:05:12
  SPEAKER_00: so loops are part of this journey we are on to effectively create software factories
• 1:05:18
  SPEAKER_00: or, you know, some people.
• 1:05:21
  SPEAKER_01: Software factory meaning like a thing where,
• 1:05:23
  SPEAKER_01: you know,
• 1:05:24
  SPEAKER_01: like it,
• 1:05:25
  SPEAKER_01: you give some instructions,
• 1:05:26
  SPEAKER_01: you're like in a factory,
• 1:05:28
  SPEAKER_01: like I would like to produce a car and then there's a fully automated factory and
• 1:05:33
  SPEAKER_01: the car comes out.
• 1:05:35
  SPEAKER_00: So instead of focusing on purely the prompting,
• 1:05:39
  SPEAKER_00: Towards getting an outcome,
• 1:05:40
  SPEAKER_00: you're building the system that can do the prompting and generate the outcome,
• 1:05:44
  SPEAKER_00: do the testing and verification for you.
• 1:05:47
  SPEAKER_00: And it's effectively the next step of every phase of software evolution is just like
• 1:05:53
  SPEAKER_00: a rising tide of abstractions.
• 1:05:55
  SPEAKER_00: This is the next abstraction.
• 1:05:57
  SPEAKER_00: And it comes with a lot of nuance because I think that if you tell someone,
• 1:06:02
  SPEAKER_00: yeah, create a system that will just do all of your work for you.
• 1:06:06
  SPEAKER_00: Anyone that's been in the industry for a while are going
• 1:06:08
  SPEAKER_00: to have obvious questions like, what about quality?
• 1:06:10
  SPEAKER_00: What are you actually, how are you making sure things aren't going off the rails?
• 1:06:14
  SPEAKER_00: And so I think that you have to be very intentional with,
• 1:06:18
  SPEAKER_00: okay, well, what are the parts of this where you're keeping the human in the loop?
• 1:06:22
  SPEAKER_00: Are you having your system flagged to you that, hey,
• 1:06:26
  SPEAKER_00: there are changes that were touched that actually,
• 1:06:28
  SPEAKER_00: you know,
• 1:06:29
  SPEAKER_00: are hitting a pretty critical part of the system
• 1:06:31
  SPEAKER_00: and you probably do want human review on this.
• 1:06:33
  SPEAKER_00: But simply just having your loops build everything
• 1:06:37
  SPEAKER_00: without having some guardrails around the blast radius,
• 1:06:40
  SPEAKER_00: without having guardrails around how you think about quality,
• 1:06:44
  SPEAKER_00: I think is a recipe for disaster.
• 1:06:45
  SPEAKER_01: I hear the analogy of software factory a lot of places.
• 1:06:48
  SPEAKER_01: And again, and of course, dark factory as well.
• 1:06:50
  SPEAKER_01: Dark factory,
• 1:06:51
  SPEAKER_01: meaning it's a fully owned factory's lights are turned off because
• 1:06:54
  SPEAKER_01: the robots don't need to see and save energy and money.
• 1:06:57
  SPEAKER_01: But one thing that I keep thinking that is off on this analogy is like,
• 1:07:00
  SPEAKER_01: OK, in a factory, you produce a thing.
• 1:07:02
  SPEAKER_01: It could be a car.
• 1:07:02
  SPEAKER_01: It could be a screw.
• 1:07:03
  SPEAKER_01: It could be something.
• 1:07:04
  SPEAKER_01: It's there and it's done.
• 1:07:06
  SPEAKER_01: But with software, specifically SaaS and most software that we do, it's not done.
• 1:07:12
  SPEAKER_01: When it's finished, we release it to production.
• 1:07:14
  SPEAKER_01: And that's where it crashes, the bugs come out.
• 1:07:17
  SPEAKER_01: So I wonder if this whole idea of like, okay,
• 1:07:20
  SPEAKER_01: we'll have a factory that produces It produces the software and it does all
• 1:07:23
  SPEAKER_01: the testing.
• 1:07:24
  SPEAKER_01: If in production it's not connected to how it's running and having that feedback,
• 1:07:29
  SPEAKER_01: you see what I mean?
• 1:07:30
  SPEAKER_01: It's a different type of factory that we're talking about.
• 1:07:34
  SPEAKER_00: So you hit the nail exactly on sort of the next phase of that.
• 1:07:39
  SPEAKER_00: If you can have a system that can sort of decide What needs to get built,
• 1:07:45
  SPEAKER_00: how to verify, how to test and all of those things.
• 1:07:48
  SPEAKER_00: There's nothing stopping you from then connecting that up to your telemetry,
• 1:07:52
  SPEAKER_00: up to your other systems,
• 1:07:54
  SPEAKER_00: up to user feedback, up to any other signals that can help build out the product.
• 1:08:00
  SPEAKER_00: You can connect it up to the product backlog and you can potentially see a world
• 1:08:04
  SPEAKER_00: where you then have this system that has access to all of these different signals
• 1:08:08
  SPEAKER_00: for how the product can be improved to a point
• 1:08:11
  SPEAKER_00: where maybe it even could get proactive.
• 1:08:14
  SPEAKER_01: Yeah, and we're seeing there's so many examples that you can plug it up,
• 1:08:16
  SPEAKER_01: for example,
• 1:08:17
  SPEAKER_01: if using Sentry,
• 1:08:18
  SPEAKER_01: Sentry has automations where like if an error fires in Sentry that is net new,
• 1:08:23
  SPEAKER_01: you could have a hook that kicks off your favorite coding agent where it one shots
• 1:08:28
  SPEAKER_01: a fix and it Yeah, I mean, I think that...
• 1:08:58
  SPEAKER_00: Given how fast things are moving,
• 1:09:00
  SPEAKER_00: we are very likely to see new terminology sprout out every month.
• 1:09:04
  SPEAKER_00: And some of them will be good fits and some of them will continue to require some refinement.
• 1:09:08
  SPEAKER_00: So I could totally see workflow being a better fit than loop.
• 1:09:12
  SPEAKER_00: But from a visual perspective, I personally do see it as a loop.
• 1:09:16
  SPEAKER_00: Workflow also works.
• 1:09:19
  SPEAKER_01: But then can you give me examples of loops that you've used or you have seen people
• 1:09:25
  SPEAKER_01: on your team or people on the university use?
• 1:09:27
  SPEAKER_00: Yeah, so I was just mentioning being able to connect multiple signals up to,
• 1:09:33
  SPEAKER_00: you know, your software factory.
• 1:09:34
  SPEAKER_01: So from production.
• 1:09:35
  SPEAKER_01: From production.
• 1:09:36
  SPEAKER_01: May that be logs or errors or all those things.
• 1:09:39
  SPEAKER_00: Yeah, so I have one app where I allow people to submit issues to it if they run
• 1:09:47
  SPEAKER_00: into any problems.
• 1:09:48
  SPEAKER_00: It's like a bug report.
• 1:09:49
  SPEAKER_01: Yeah, like a bug report.
• 1:09:50
  SPEAKER_00: And historically, I would, you know, manually go through every one.
• 1:09:55
  SPEAKER_00: And whenever I had time and then make a call in terms of like,
• 1:09:58
  SPEAKER_00: okay, well, I only have time to address so-and-so and so.
• 1:10:01
  SPEAKER_00: I can't go through the full backlog.
• 1:10:03
  SPEAKER_00: You can now connect up so many other sources of data.
• 1:10:05
  SPEAKER_00: You can connect up your Google Analytics.
• 1:10:07
  SPEAKER_00: You can connect up,
• 1:10:08
  SPEAKER_00: you know,
• 1:10:09
  SPEAKER_00: if you're deploying to a There are all kinds of logs that you might get
• 1:10:13
  SPEAKER_00: from those sessions as well.
• 1:10:14
  SPEAKER_00: You can connect it up to that.
• 1:10:16
  SPEAKER_00: And then you can end up with a system where it's able to make decisions and prioritization.
• 1:10:20
  SPEAKER_00: And then, of course, do the implementation based on not just one dimension of feedback.
• 1:10:25
  SPEAKER_00: So for example,
• 1:10:26
  SPEAKER_00: if in my product,
• 1:10:28
  SPEAKER_00: it's noticing that there is a particular view that is really,
• 1:10:31
  SPEAKER_00: really slow,
• 1:10:33
  SPEAKER_00: but it now knows that that's happening for users in India,
• 1:10:37
  SPEAKER_00: but that I'm getting a lot of traffic from people in India,
• 1:10:39
  SPEAKER_00: it can influence I
• 1:10:47
  SPEAKER_00: think it still depends if you care about having to go in
• 1:10:52
  SPEAKER_00: and manually do some work to take a look.
• 1:10:54
  SPEAKER_00: Okay, well, you said you improved performance.
• 1:10:56
  SPEAKER_00: What did you actually change?
• 1:10:58
  SPEAKER_00: How much do I have to manually test this thing on these kinds of devices myself?
• 1:11:02
  SPEAKER_00: Because I can tell you to go and do some emulated testing.
• 1:11:05
  SPEAKER_00: I'm sure it'll help.
• 1:11:06
  SPEAKER_00: But for me,
• 1:11:07
  SPEAKER_00: it's just about Being able to make more refined product decisions without having
• 1:11:14
  SPEAKER_00: to sift through all the different signals myself.
• 1:11:16
  SPEAKER_01: I do see more and more people experimenting,
• 1:11:18
  SPEAKER_01: trying to put these things in place again, like from the one-shotting, the bug fix.
• 1:11:23
  SPEAKER_01: There's really no excuse to like not act on errors, on logs.
• 1:11:27
  SPEAKER_01: Open source projects,
• 1:11:29
  SPEAKER_01: popular ones now have things like when people submit an issue,
• 1:11:32
  SPEAKER_01: there's a bot that tries to reproduce it, all of these things.
• 1:11:35
  SPEAKER_01: So I see them as loops.
• 1:11:37
  SPEAKER_01: One question that does come up though is, okay, well, we are,
• 1:11:39
  SPEAKER_01: this is a lot of stuff that software engineers used to do and we didn't have all
• 1:11:42
  SPEAKER_01: the time for it, but we did a lot of it.
• 1:11:45
  SPEAKER_01: And what this means for the future of the profession.
• 1:11:47
  SPEAKER_01: Ryan Dahl,
• 1:11:48
  SPEAKER_01: the creator of Node.js wrote,
• 1:11:50
  SPEAKER_01: and I quote him,
• 1:11:51
  SPEAKER_01: this has been said a thousand times before,
• 1:11:53
  SPEAKER_01: but allowing to have my own voice, the era of humans writing code is over.
• 1:11:57
  SPEAKER_01: Disturbing for those of us who identify as software engineers, but no less true.
• 1:12:00
  SPEAKER_01: That's not to say software engineers don't have work to do,
• 1:12:03
  SPEAKER_01: but writing syntax directly is not it.
• 1:12:05
  SPEAKER_01: And a lot of our time spent,
• 1:12:07
  SPEAKER_01: I remember when I interviewed people at Uber,
• 1:12:09
  SPEAKER_01: I would tell them like, well,
• 1:12:10
  SPEAKER_01: we're going to spend at least 50% writing code,
• 1:12:12
  SPEAKER_01: so we're testing you on writing code.
• 1:12:14
  SPEAKER_01: This is kind of vanishing.
• 1:12:16
  SPEAKER_01: What do you see replacing it?
• 1:12:18
  SPEAKER_01: And what do you see the essence of software engineers,
• 1:12:22
  SPEAKER_01: builders, AI engineers, however you call them, be?
• 1:12:25
  SPEAKER_00: I always go back to what is alpha?
• 1:12:28
  SPEAKER_01: So my definition of
• 1:12:32
  SPEAKER_00: alpha is advantage, right?
• 1:12:33
  SPEAKER_00: So what is the current thing that models are not very good
• 1:12:37
  SPEAKER_01: at doing?
• 1:12:37
  SPEAKER_00: Alpha is going to decay in some way with every model release or every series of model releases.
• 1:12:44
  SPEAKER_00: So it's going to change over time.
• 1:12:46
  SPEAKER_00: So for software engineers,
• 1:12:47
  SPEAKER_00: we very often say that your alpha is in taste in terms of are we building
• 1:12:54
  SPEAKER_00: the right thing?
• 1:12:55
  SPEAKER_00: Where are we putting our energy?
• 1:12:57
  SPEAKER_00: Is the thing that we are building actually good?
• 1:13:00
  SPEAKER_00: And good, you know, sometimes people say, yeah, but an agent can tell you if it's good.
• 1:13:04
  SPEAKER_00: I push back on that.
• 1:13:05
  SPEAKER_00: An agent can tell you if a thing looks correct, if it's matching a spec.
• 1:13:09
  SPEAKER_00: It doesn't necessarily mean it can tell you what's good.
• 1:13:12
  SPEAKER_00: I think that good can mean good from a user experience perspective,
• 1:13:17
  SPEAKER_00: could be delightful,
• 1:13:18
  SPEAKER_00: could be something that a person will actually want to come back to.
• 1:13:21
  SPEAKER_00: And it is still something that is Sufficiently nuanced that I think it's going
• 1:13:26
  SPEAKER_00: to take time for models to actually catch up to a point where they can replace
• 1:13:30
  SPEAKER_00: that fully.
• 1:13:31
  SPEAKER_00: We tell people that judgment, verification, all of these other aspects continue to be important.
• 1:13:36
  SPEAKER_00: And I do believe that.
• 1:13:37
  SPEAKER_00: But even if you follow through and you say, okay,
• 1:13:40
  SPEAKER_00: well, maybe a year or two from now, models will catch up to these different aspects.
• 1:13:46
  SPEAKER_00: We still need engineers to be answerable for these different systems.
• 1:13:51
  SPEAKER_01: Accountable, right?
• 1:13:53
  SPEAKER_00: Yes, accountable, answerable.
• 1:13:55
  SPEAKER_00: And that's something that doesn't just happen overnight.
• 1:13:57
  SPEAKER_00: That happens when you understand a system, people trust you.
• 1:14:01
  SPEAKER_00: And you have that expertise.
• 1:14:02
  SPEAKER_00: An example I've been telling people this week is back when I worked on Chrome,
• 1:14:07
  SPEAKER_00: you know,
• 1:14:07
  SPEAKER_00: Chromium is a massive codebase, is one of the largest codebases in the world.
• 1:14:12
  SPEAKER_00: And it's sufficiently complex that for every key part of that system,
• 1:14:18
  SPEAKER_00: you will have a directory with an owner's file.
• 1:14:22
  SPEAKER_00: And that owner's file is going to contain a small number of people
• 1:14:25
  SPEAKER_00: who are effectively accountable for that part of the system.
• 1:14:28
  SPEAKER_00: They might not have written all of the code for it in the same way
• 1:14:31
  SPEAKER_00: that we may not have written all of the code.
• 1:14:33
  SPEAKER_00: Our agents may have not written some of the code, but they're the person that's on the hook.
• 1:14:38
  SPEAKER_00: For understanding,
• 1:14:40
  SPEAKER_00: for gating,
• 1:14:40
  SPEAKER_00: for making sure that someone is deciding what ships,
• 1:14:44
  SPEAKER_00: what's blocked, what do we defer.
• 1:14:47
  SPEAKER_00: And so I think that that is something that engineers are going to continue to be valuable for.
• 1:14:53
  SPEAKER_00: And that's going to help us to make sure we're building stuff that is stable,
• 1:14:56
  SPEAKER_00: reliable, people can actually, you know, Use it with some confidence.
• 1:15:01
  SPEAKER_01: I do agree with this because I think accountability is some,
• 1:15:03
  SPEAKER_01: that's why so many businesses are working.
• 1:15:08
  SPEAKER_01: That's why lawyers always have a job because the regulation is there
• 1:15:13
  SPEAKER_01: and you can look up all the court And you could understand how
• 1:15:16
  SPEAKER_01: the law is interpreted,
• 1:15:17
  SPEAKER_01: but they've done this and they often take some level of accountability.
• 1:15:21
  SPEAKER_01: In fact,
• 1:15:22
  SPEAKER_01: if they grossly not do their job,
• 1:15:25
  SPEAKER_01: you actually have an option to,
• 1:15:26
  SPEAKER_01: for example, take legal action against a firm if they would have.
• 1:15:32
  SPEAKER_01: Be proven to actually just ignore what they're doing.
• 1:15:35
  SPEAKER_01: And I guess that's a good example where in software and anywhere
• 1:15:39
  SPEAKER_01: where there's value, this will be valuable.
• 1:15:41
  SPEAKER_01: Again, if you're renovating your house, if it's not a big deal, you might do it yourself.
• 1:15:46
  SPEAKER_01: If it's a big deal, you just call a professional.
• 1:15:48
  SPEAKER_00: Yeah, yeah.
• 1:15:49
  SPEAKER_00: And I think there's two related notes to this topic.
• 1:15:53
  SPEAKER_00: Every time that we've made it easier to create software, we've exponentially created more of it.
• 1:15:59
  SPEAKER_00: So the total addressable market for builders.
• 1:16:01
  SPEAKER_00: And it's happening right now.
• 1:16:02
  SPEAKER_01: We're seeing in the stats and iOS app releases, websites, all of that.
• 1:16:07
  SPEAKER_00: Yeah, it's going
• 1:16:07
  SPEAKER_01: through the roof.
• 1:16:08
  SPEAKER_00: And that's not without nuance.
• 1:16:09
  SPEAKER_00: That's not to say,
• 1:16:10
  SPEAKER_00: you know, that every single app that's being created has the same value, right?
• 1:16:16
  SPEAKER_00: We of course have these conversations about like, yes,
• 1:16:19
  SPEAKER_00: if your app is like a prompt away from somebody else copying it,
• 1:16:22
  SPEAKER_00: you know, it's a different world that we live in.
• 1:16:24
  SPEAKER_00: But that still doesn't change the fact that we have a much larger number of people
• 1:16:28
  SPEAKER_00: that can build now.
• 1:16:29
  SPEAKER_00: And that's a lot more potential businesses and startups that could potentially thrive.
• 1:16:33
  SPEAKER_00: I continue to be very excited about the profession from that aspect.
• 1:16:38
  SPEAKER_00: I also think that every point in time in human history when automation or a form
• 1:16:44
  SPEAKER_00: of automation has come into the picture,
• 1:16:46
  SPEAKER_00: we've automated away certain kinds of jobs and then replaced them with other kinds
• 1:16:51
  SPEAKER_00: of jobs.
• 1:16:52
  SPEAKER_00: And so I think a big question for the future is what are those jobs going to be
• 1:16:56
  SPEAKER_00: in this new knowledge economy?
• 1:16:58
  SPEAKER_00: We may not necessarily have exact,
• 1:17:01
  SPEAKER_00: you know,
• 1:17:01
  SPEAKER_00: frames for what they're going to look like just yet,
• 1:17:03
  SPEAKER_00: but I do think those are going to come.
• 1:17:05
  SPEAKER_01: Yeah.
• 1:17:07
  SPEAKER_01: And I wanted to talk to you about your writing as a fellow writer to a fellow writer.
• 1:17:12
  SPEAKER_01: You've been a really prolific writer in terms of books released just in the past few years.
• 1:17:17
  SPEAKER_01: You've written the short book,
• 1:17:19
  SPEAKER_01: Software Engineering the Soft Part, a free book, about 50 pages, a really good read.
• 1:17:24
  SPEAKER_01: You've written Leading Effective Teams two years ago and last year, Vibe Coding.
• 1:17:30
  SPEAKER_01: I wanted to ask,
• 1:17:31
  SPEAKER_01: and on top of this,
• 1:17:32
  SPEAKER_01: you regularly write long form on social media,
• 1:17:35
  SPEAKER_01: LinkedIn, X, your blog, your newsletter.
• 1:17:38
  SPEAKER_01: You write a lot for someone who actually has a full-time job.
• 1:17:41
  SPEAKER_01: And I can tell you, my full-time job often involves writing.
• 1:17:45
  SPEAKER_01: How has your workflow changed in writing when it comes to now,
• 1:17:49
  SPEAKER_01: especially we have AI tools or other tools?
• 1:17:52
  SPEAKER_00: I would say that...
• 1:17:55
  SPEAKER_00: Now that it is very easy for anyone to use an agent to create a body of text,
• 1:18:01
  SPEAKER_00: I think it's more important than ever for us to make sure that
• 1:18:05
  SPEAKER_00: the ideas we're putting out into the world are actually worth people reading.
• 1:18:09
  SPEAKER_00: Because if you're asking somebody to spend 5,
• 1:18:12
  SPEAKER_00: 10, 15 minutes reading a thing, like actually put some effort into it.
• 1:18:16
  SPEAKER_00: My workflow has changed quite a lot in the last couple of years.
• 1:18:20
  SPEAKER_00: I've now published, I think, 18 books.
• 1:18:22
  SPEAKER_00: I've worked with O'Reilly on many, many titles over the years.
• 1:18:26
  SPEAKER_00: I think the agents have helped me the most probably with just being able to reason
• 1:18:30
  SPEAKER_00: about the thoughts in my head.
• 1:18:33
  SPEAKER_00: And especially try to connect those back to how other people are thinking
• 1:18:37
  SPEAKER_00: about related problems.
• 1:18:39
  SPEAKER_00: So on any given week,
• 1:18:41
  SPEAKER_00: we can take loop engineering as one example because I was recently putting together
• 1:18:45
  SPEAKER_00: a piece on that.
• 1:18:46
  SPEAKER_00: When I'm working on a piece I'm always curious,
• 1:18:50
  SPEAKER_00: what are other people thinking that's related to this?
• 1:18:53
  SPEAKER_00: And so I can fire off a ton of deep research agents to go and check out Hacker News
• 1:18:58
  SPEAKER_00: or Twitter or other places and just give me a sense
• 1:19:01
  SPEAKER_00: of what are things people have tried out?
• 1:19:04
  SPEAKER_00: What are things where people have particularly strong opinions either way?
• 1:19:09
  SPEAKER_00: What is considered contentious?
• 1:19:11
  SPEAKER_00: What are people excited about?
• 1:19:13
  SPEAKER_00: And what do they have big questions around?
• 1:19:16
  SPEAKER_00: That's not to say, hey, agents, now write the text for me.
• 1:19:20
  SPEAKER_00: It's about forming a thesis about what people are struggling with
• 1:19:24
  SPEAKER_00: and what educational content could be useful for them around that.
• 1:19:28
  SPEAKER_00: And so agents have been very useful for me in my research.
• 1:19:32
  SPEAKER_00: When it comes to writing itself, this is a very interesting one.
• 1:19:35
  SPEAKER_00: I think that a lot of people struggle with like,
• 1:19:37
  SPEAKER_00: how should we be using agents and these tools these days?
• 1:19:40
  SPEAKER_00: I will very often do two things when I've got an idea for a piece.
• 1:19:44
  SPEAKER_00: I will start to write out a personal kind of handwritten version of a thing.
• 1:19:49
  SPEAKER_00: And I'll also have an agent or different models write out a version of the text as well.
• 1:19:54
  SPEAKER_00: And I'll compare sort of, okay, well,
• 1:19:56
  SPEAKER_00: I started out with a thesis and How did those other agents reason about this thesis?
• 1:20:01
  SPEAKER_00: Did they take it in a very different direction to what I was thinking about?
• 1:20:04
  SPEAKER_00: Or did we all kind of converge on the same thing roughly and there's not really
• 1:20:09
  SPEAKER_00: a lot of value that they're offering me?
• 1:20:11
  SPEAKER_00: Once I actually feel like I've got the ideas then pulled for my piece,
• 1:20:17
  SPEAKER_00: For me, readability is important.
• 1:20:19
  SPEAKER_00: And so even if I've handwritten a thing,
• 1:20:21
  SPEAKER_00: I will often put that through a model to try improving readability.
• 1:20:25
  SPEAKER_00: And that's a hard thing sometimes because I still feel like models are sometimes not
• 1:20:31
  SPEAKER_00: the best at writing human looking,
• 1:20:34
  SPEAKER_00: even if you're editing something, writing human looking text.
• 1:20:38
  SPEAKER_00: I remember the other day I was trying to play around with, hey, can I improve my workflow?
• 1:20:44
  SPEAKER_00: And I feel like I easily wasted three hours of time because no matter what I did,
• 1:20:49
  SPEAKER_00: one of the models I was using continued to generate text
• 1:20:52
  SPEAKER_00: that looked like it had triads and these patterns, you know, of AI written text.
• 1:21:00
  SPEAKER_00: I really struggle with that because it feels like,
• 1:21:02
  SPEAKER_00: you know, is it diminishing returns trying to use these readability tasks?
• 1:21:05
  SPEAKER_01: Specifically on loop engineering,
• 1:21:07
  SPEAKER_01: so Navi,
• 1:21:09
  SPEAKER_01: aka NeatCode,
• 1:21:10
  SPEAKER_01: he did a video where he looked at the loop engineering,
• 1:21:13
  SPEAKER_01: specifically your posts as well.
• 1:21:15
  SPEAKER_01: He was reading it.
• 1:21:15
  SPEAKER_01: He was reading the part automations.
• 1:21:17
  SPEAKER_01: This is the heartbeat.
• 1:21:18
  SPEAKER_01: And he kind of read a few paragraphs and he was saying it felt abstract.
• 1:21:22
  SPEAKER_01: It felt that there were like terms that an AI would have done.
• 1:21:24
  SPEAKER_01: And he said that, well,
• 1:21:26
  SPEAKER_01: either this is AI generated or it might be someone's thoughts,
• 1:21:29
  SPEAKER_01: but then an AI put it out.
• 1:21:32
  SPEAKER_01: And when I also read it in that specifically that loop engineering piece,
• 1:21:36
  SPEAKER_01: like I missed the specifics right now.
• 1:21:38
  SPEAKER_01: We talked about like, all right, here's the things that you have been doing.
• 1:21:42
  SPEAKER_01: And I was wondering on like, how did you write this?
• 1:21:45
  SPEAKER_01: And how do you feel about that?
• 1:21:48
  SPEAKER_01: That specific piece now?
• 1:21:50
  SPEAKER_00: For that piece specifically, so...
• 1:21:52
  SPEAKER_00: I started off with a handwritten piece.
• 1:21:55
  SPEAKER_00: I did a number of editorial passes myself.
• 1:22:00
  SPEAKER_00: I then handed it off to a model to try improving the readability pass.
• 1:22:04
  SPEAKER_00: And that's where I start to struggle because I'm a fan of structured writing.
• 1:22:10
  SPEAKER_00: I'm a big fan of very structured writing.
• 1:22:14
  SPEAKER_00: I remember the kind of writing I was writing 10 years ago, maybe even.
• 1:22:17
  SPEAKER_00: And I remember you were mentioning People who like to write struggle with time.
• 1:22:23
  SPEAKER_00: I would very often write articles in the 15 minutes I had before my next meeting.
• 1:22:28
  SPEAKER_00: And I just try to add more paragraphs in.
• 1:22:30
  SPEAKER_00: It wasn't as structured or as high quality as I'd like.
• 1:22:34
  SPEAKER_00: And so I sometimes struggle with,
• 1:22:37
  SPEAKER_00: are people looking for authenticity even when it's not that structured?
• 1:22:43
  SPEAKER_00: So for example,
• 1:22:45
  SPEAKER_00: The version of loop engineering I started out with,
• 1:22:49
  SPEAKER_00: even after a few iterations,
• 1:22:50
  SPEAKER_00: did it have a good enough line through or thread through the whole thing
• 1:22:56
  SPEAKER_00: that made sense?
• 1:22:58
  SPEAKER_00: Probably not, or at least that's how I felt about it.
• 1:23:01
  SPEAKER_00: But using an agent to try helping rework that, so it did have a clearer line through it.
• 1:23:07
  SPEAKER_00: I felt better about the piece,
• 1:23:10
  SPEAKER_00: but somebody else reading it may have felt like,
• 1:23:11
  SPEAKER_00: okay, well actually I would have felt better if it wasn't.
• 1:23:15
  SPEAKER_01: If it was a myth more raw that you did not feel that good about.
• 1:23:19
  SPEAKER_00: Yeah, yeah.
• 1:23:21
  SPEAKER_00: And you can say the same thing about typos,
• 1:23:25
  SPEAKER_00: about, oh, well, hey, is the article following a consistent structure or beat?
• 1:23:30
  SPEAKER_00: Compared to a final piece.
• 1:23:32
  SPEAKER_00: So that's something I struggle with.
• 1:23:33
  SPEAKER_01: Yeah, because the final piece, don't get me wrong.
• 1:23:36
  SPEAKER_01: When we look at views and comments, a lot of people appreciate it.
• 1:23:39
  SPEAKER_01: And when you read through, again, I'll link it in the show notes below to read it.
• 1:23:43
  SPEAKER_01: It did have a clear top level structure.
• 1:23:46
  SPEAKER_01: To me, it felt that it was maybe more wordy than it needed to be.
• 1:23:51
  SPEAKER_01: And it just lacked the specifics.
• 1:23:53
  SPEAKER_01: But I do see by the other people experimenting with this as well.
• 1:23:57
  SPEAKER_01: I talked with Michael Novati,
• 1:23:58
  SPEAKER_01: who was criticized for a post which he actually worked a lot with,
• 1:24:02
  SPEAKER_01: but it sounded very AI because in the end he did it.
• 1:24:05
  SPEAKER_01: And later he wrote another post which looked a lot better and asked him what he's changed.
• 1:24:08
  SPEAKER_01: He said like, oh,
• 1:24:09
  SPEAKER_01: I'm actually just like tweaking the output a lot more because he's also a big fan
• 1:24:13
  SPEAKER_01: of dumping his thoughts,
• 1:24:15
  SPEAKER_01: getting some help for structure and actually,
• 1:24:18
  SPEAKER_01: you know, like behind the scenes spending a lot of time.
• 1:24:20
  SPEAKER_01: Like, will this be worth reading?
• 1:24:24
  SPEAKER_00: Even with access to better tools these days,
• 1:24:26
  SPEAKER_00: very often if people see an article that I put out,
• 1:24:29
  SPEAKER_00: I very likely spent probably at least three to seven days just trying to work
• 1:24:34
  SPEAKER_00: through it.
• 1:24:35
  SPEAKER_01: Just kind of like brewing the ideas.
• 1:24:38
  SPEAKER_01: Yeah, yeah.
• 1:24:39
  SPEAKER_00: If something comes out very,
• 1:24:40
  SPEAKER_00: very quickly,
• 1:24:41
  SPEAKER_00: it's probably because I had a very clear,
• 1:24:44
  SPEAKER_00: a surprisingly clear vision for what I wanted to say,
• 1:24:47
  SPEAKER_00: but very often it takes a while for something to bake well.
• 1:24:50
  SPEAKER_00: And I do end up going through every line of text very often before publishing it a few times.
• 1:24:58
  SPEAKER_00: And I think that for those of us that are working with tools,
• 1:25:03
  SPEAKER_00: with AI tools,
• 1:25:04
  SPEAKER_00: You start to question, well,
• 1:25:06
  SPEAKER_00: am I being influenced by the way that the models,
• 1:25:09
  SPEAKER_00: because the models are going to,
• 1:25:10
  SPEAKER_00: in some cases, I think, provide a homogenous take on what writing looks like.
• 1:25:14
  SPEAKER_01: Yes.
• 1:25:15
  SPEAKER_00: And you start to feel like, wait, what was my writing style?
• 1:25:18
  SPEAKER_01: You know, you feel you're kind of in this middle right now a little bit.
• 1:25:21
  SPEAKER_00: Yeah, I very much do.
• 1:25:22
  SPEAKER_00: And
• 1:25:25
  SPEAKER_00: You take it to the experimentation phase and maybe there are people who will say,
• 1:25:31
  SPEAKER_00: hey, you should train a custom model on your old writing.
• 1:25:34
  SPEAKER_00: I was a different person.
• 1:25:36
  SPEAKER_00: When I did my old writing and I had a different set of perspectives,
• 1:25:39
  SPEAKER_00: a different set of nuances that I cared about.
• 1:25:42
  SPEAKER_00: And so I would feel a certain way about that person writing these new pieces too.
• 1:25:49
  SPEAKER_00: So I think that we're still learning what the best practices around this are.
• 1:25:54
  SPEAKER_00: And I also,
• 1:25:55
  SPEAKER_00: you know,
• 1:25:55
  SPEAKER_00: I started,
• 1:25:56
  SPEAKER_00: I remember the other week,
• 1:25:58
  SPEAKER_00: I was just curious,
• 1:25:59
  SPEAKER_00: like if people are checking out these posts using pangram or GPT or any
• 1:26:04
  SPEAKER_00: of these things, how does that change my workflow?
• 1:26:06
  SPEAKER_00: And I was just getting very frustrated
• 1:26:08
  SPEAKER_00: because I would literally type out like human sentences or human paragraphs
• 1:26:11
  SPEAKER_00: and I'd paste it into pangram and be like, no, this doesn't look human written.
• 1:26:15
  SPEAKER_01: I'm like, wow.
• 1:26:16
  SPEAKER_00: And that's not to say anything bad about pangram.
• 1:26:18
  SPEAKER_00: That's to say that I don't,
• 1:26:20
  SPEAKER_00: I think that there's opportunity to For tools to help writers flag things and
• 1:26:27
  SPEAKER_00: then help them understand,
• 1:26:28
  SPEAKER_00: okay, well, how do you get back to your human way of writing?
• 1:26:32
  SPEAKER_01: Yeah.
• 1:26:32
  SPEAKER_01: So as closing, you've just closed down 14 years at Google.
• 1:26:36
  SPEAKER_01: You've announced a big decision that you're leaving.
• 1:26:39
  SPEAKER_01: Congratulations.
• 1:26:39
  SPEAKER_01: I know it must have been like a big one to decide on.
• 1:26:43
  SPEAKER_01: What is next for you?
• 1:26:44
  SPEAKER_01: What are you looking at?
• 1:26:47
  SPEAKER_01: What are you excited about?
• 1:26:48
  SPEAKER_00: What I am most excited about right now is helping developers and businesses kind
• 1:26:55
  SPEAKER_00: of meet this next moment of software engineering changing.
• 1:27:00
  SPEAKER_00: I think there are a lot of open questions.
• 1:27:02
  SPEAKER_00: Every single company I talk to has got so many questions about what
• 1:27:04
  SPEAKER_00: the future is going to look like.
• 1:27:05
  SPEAKER_00: But there's also a lot of opportunity in there to help and to figure it out with them.
• 1:27:12
  SPEAKER_00: So I'm excited about that.
• 1:27:14
  SPEAKER_00: I'll be sharing, you know, in the next couple of months what my next thing is.
• 1:27:17
  SPEAKER_00: But I'm definitely going to be staying very much in this space.
• 1:27:21
  SPEAKER_00: And I'm someone that enjoys working with developers, working with the ecosystem.
• 1:27:26
  SPEAKER_00: So I will very much still be staying in a role that allows me to do that.
• 1:27:29
  SPEAKER_01: So right as you're exploring your next career step,
• 1:27:32
  SPEAKER_01: you know, may that be joining another company in an exciting role.
• 1:27:35
  SPEAKER_01: Who knows if you'll do something yourself.
• 1:27:37
  SPEAKER_01: Clearly, you're thinking a lot about your own career.
• 1:27:40
  SPEAKER_01: What advice would you have to someone who has some experience in
• 1:27:43
  SPEAKER_01: the industry working as a software engineer or engineering manager?
• 1:27:46
  SPEAKER_01: And they might be in a similar shoe where they're like,
• 1:27:49
  SPEAKER_01: all right, it's time for me for a change.
• 1:27:50
  SPEAKER_01: I want to set myself up for success looking ahead.
• 1:27:54
  SPEAKER_01: What skills would you advise that they invest in?
• 1:27:57
  SPEAKER_01: What activities, how to think about their network?
• 1:28:01
  SPEAKER_01: What do you think will be important in the next couple of years to stay at
• 1:28:05
  SPEAKER_01: the front, like the meat of the industry?
• 1:28:08
  SPEAKER_00: What we're very likely to see happen next with engineering careers,
• 1:28:12
  SPEAKER_00: as well as product and other roles, is the unbundling of these careers.
• 1:28:17
  SPEAKER_00: Where we begin to see more of these roles converge.
• 1:28:23
  SPEAKER_00: That also has product sense,
• 1:28:25
  SPEAKER_00: the product person that also has engineering sense or UX sense,
• 1:28:28
  SPEAKER_00: the UX person that also cares about product.
• 1:28:31
  SPEAKER_00: So the guidance that I would give people is think beyond just that narrow lens of engineering.
• 1:28:38
  SPEAKER_00: There are many people,
• 1:28:38
  SPEAKER_00: especially if you're a senior,
• 1:28:40
  SPEAKER_00: that have already had to think about these different aspects of success.
• 1:28:45
  SPEAKER_00: If you are not someone that has had a chance to think about,
• 1:28:48
  SPEAKER_00: you know,
• 1:28:50
  SPEAKER_00: Product or technical evangelism or go to marketing or any of these other aspects
• 1:28:56
  SPEAKER_00: that are generally different puzzle pieces, how businesses are successful.
• 1:29:00
  SPEAKER_00: Think about the non-engineering things.
• 1:29:02
  SPEAKER_00: I think there's a lot of value there.
• 1:29:04
  SPEAKER_00: And if you can show employers that you are not just a builder,
• 1:29:09
  SPEAKER_00: but you're someone that can help them as these roles start to become
• 1:29:13
  SPEAKER_00: a little bit fuzzier, I think that you can be successful.
• 1:29:17
  SPEAKER_00: In these times.
• 1:29:18
  SPEAKER_00: Don't just be an engineer.
• 1:29:19
  SPEAKER_01: So it sounds like it's one of your core values.
• 1:29:22
  SPEAKER_01: Go back to being curious.
• 1:29:23
  SPEAKER_01: Learn and see where you can help beyond just building.
• 1:29:27
  SPEAKER_00: Yeah.
• 1:29:27
  SPEAKER_00: Be a lifelong learner.
• 1:29:28
  SPEAKER_00: Be endlessly curious.
• 1:29:30
  SPEAKER_00: And I think that there will be roles for you in the future.
• 1:29:32
  SPEAKER_01: Adi, thank you very much.
• 1:29:33
  SPEAKER_00: Thank you so much.
• 1:29:34
  SPEAKER_00: This was great.
• 1:29:35
  SPEAKER_00: Thank you for having me.
• 1:29:36
  SPEAKER_01: I really enjoyed this chat with Addy and I hope you did as well.
• 1:29:39
  SPEAKER_01: I do feel that Addy's career shows that working hard and always going
• 1:29:42
  SPEAKER_01: a layer deeper pays off over time.
• 1:29:45
  SPEAKER_01: When he was a teenager,
• 1:29:46
  SPEAKER_01: Addy already built a web browser from scratch, which is a massive project.
• 1:29:50
  SPEAKER_01: He never stopped Being curious about web browsers,
• 1:29:52
  SPEAKER_01: then developer tools, and today he brings his same curiosity to AI agents.
• 1:29:57
  SPEAKER_01: A concept I liked that Adi mentioned was this idea of cognitive surrender.
• 1:30:01
  SPEAKER_01: The more capable AI agents become, the easier it is to let them do what they do.
• 1:30:06
  SPEAKER_01: For example, a year back, you could still follow along how an agent worked step by step.
• 1:30:11
  SPEAKER_01: But today,
• 1:30:11
  SPEAKER_01: if you are multiple sub-agents in parallel,
• 1:30:13
  SPEAKER_01: there's no way you'll keep up with every step.
• 1:30:16
  SPEAKER_01: This creates this weird paradox.
• 1:30:18
  SPEAKER_01: AI makes it easier than ever to build software,
• 1:30:21
  SPEAKER_01: but it also makes it easier than ever to lose understanding of the software
• 1:30:25
  SPEAKER_01: that we're building.
• 1:30:26
  SPEAKER_01: Adi had a really good counterpoint to this, which was mutual amplification.
• 1:30:30
  SPEAKER_01: You want to amplify Your own understanding as the agents get better.
• 1:30:34
  SPEAKER_01: So have the agents record decisions, document what it learned and explain unusual choices.
• 1:30:40
  SPEAKER_01: It's just no longer feasible to understand how
• 1:30:42
  SPEAKER_01: or why every single token was generated,
• 1:30:45
  SPEAKER_01: but you want to keep understanding the important decisions that any
• 1:30:48
  SPEAKER_01: of your agents make.
• 1:30:49
  SPEAKER_01: Finally,
• 1:30:49
  SPEAKER_01: I liked our conversation about what happens to software engineers
• 1:30:52
  SPEAKER_01: when writing code is a smaller part of a job.
• 1:30:54
  SPEAKER_01: Hattie's answer is that accountability remains the job.
• 1:30:58
  SPEAKER_01: For example, inside of Chromium, specific software engineers owns parts of the code base.
• 1:31:02
  SPEAKER_01: They obviously have not written every line of code in that part that they own,
• 1:31:06
  SPEAKER_01: but they understand the area,
• 1:31:08
  SPEAKER_01: they decide what matters and what doesn't,
• 1:31:10
  SPEAKER_01: and they are accountable for their part working well.
• 1:31:12
  SPEAKER_01: I think it's reasonable to assume that AI will push this kind of accountability
• 1:31:16
  SPEAKER_01: to be more visible for any and all software engineers.
• 1:31:19
  SPEAKER_01: Do check out the show notes for related to Pragmatic Engineer deep dives
• 1:31:22
  SPEAKER_01: on Google's engineering culture and AI engineering.
• 1:31:25
  SPEAKER_01: If you've enjoyed this podcast,
• 1:31:26
  SPEAKER_01: please do subscribe on your favorite podcast platform and on YouTube.
• 1:31:30
  SPEAKER_01: A big thank you if you also leave a rating on the show.
• 1:31:32
  SPEAKER_01: Appreciate it and see you in the next one.