Skip to content
Linkdrop
Links

S03E01 · Mechanics Behind Product Engineering: MEGA lesson video by Kent C. Dodds

Kent C. Dodds explains how product engineers choose what to build, measure user outcomes rather than output, and use agents to free up attention. He illustrates the ideas with Gmail, Instagram, WhatsApp, and the web platform.

videoKent C. Dodds · hq.mega.dev · Saved Nov 19, 2026

mega course, product engineering, coding agents, product design, ai developer productivity

Transcript of the lesson video for S03E01 of the MEGA.dev course, by Kent C. Dodds. Agenda: Shift · Ownership · Judgment · Systems Thinking · Leverage. The video plays on the lesson page in MEGA Student HQ (needs a login).

0:05 Gmail showed up with so much storage, you never had to delete email again and search to find any of it. That wasn't a coding problem, it was a decision about what people could do, and that is product engineering. And it's a different job from just closing tickets. Gmail is actually a really great example of product engineering. If you were around back in, like, 2004 when Gmail was a thing, you might remember their landing page. It honestly was, uh, it's still iconic, um, where it's obviously very simple, like this is 2004 after all. Uh, but here it just lists the things that you get or that you kind of become when you are a user of Gmail.

You search. You're not a, a sorting person, you are a, uh, somebody who can just use Google Search to find exactly what you're looking for. You don't throw away anything. And I remember watching this ticker and just thinking, "Holy smokes, 2.6 gigabytes of storage and it's going up all the time? Oh my goodness, that's wild." You never need to delete another email message. This was a big problem at the time. Everybody was trying to like, "Oh, I've got, my email is full. I've got to make sure I delete everything." I never delete anything anymore, and I don't worry about having to find it because search is so good. Uh, it keep it all in context.

They, they actually introduced, introduced the idea of having threads and conversations and no pop-up ads and all of that too. They really understood what this product was all about, what people actually wanted, uh, and I think that's really powerful. And then Instagram is another great example of this. So Instagram actually started out as another app called Burbn. And, uh, in Burbn, it's kind of like a Foursquare clone. So you, um, are able to, like, go to a place and you check in, you say, "Hey, I'm at, you know, this coffee shop," whatever, here, take a picture and, uh, share that there and, and maybe give it a rating and stuff like that. And, um, as they were looking at the user metrics and talking to their users, they found out that people weren't actually using a lot of the features of the app.

And I think for you and me, we would see that and be like, "Okay, well, why aren't they using those features? How can we make those features more attractive?" But instead, what Kevin and, and the team did was they said, "You know what? Let's just get rid of everything else. They're only using the photo sharing thing, so let's just turn this into a photo sharing app." And that worked. It worked really well. Uh, it's share a photo. That's the app. That's the whole thing. Uh, so it, it is a product decision that has technical consequences, things that you have to think about technically. In the Gmail case, it's about what features we want to add and how we want to organize things.

And in the Instagram case, it's about what do we want to cut. So it's not just a simple, like, let's add all of the features or whatever. You have to be very mindful about the things that you're adding to your products, and you have to have some product cons- uh, restraint, because as powerful as it is that you can just build any idea that you have, you really have to be thoughtful about what ideas. And we're going to talk about that, but before we get into that, let's talk about a couple more examples. So WhatsApp is another good example of product engineering, where everybody else was adding games and ads and all sorts of things to their application, and Jan Koum was very specific, and they even wrote a blog post about this saying, "No, we've got to say no to those sorts of things.

We are going to keep it simple. This is just about messaging people." And that worked out pretty well for Jan Koum and, uh, and crew. And then, of course, even the web platform itself. This was a product decision to make it a primitive that everybody could build on rather than a bespoke and ad hoc or a, um,

3:51 uh, specific to his own organization, a vendor-specific closed proprietary tool. And the result of that, obviously, is all of us, what we're doing here, building on this web platform. And so even if you're building something in, um, that you think, "Okay, well, maybe this could be open source," making that decision between open source and closed source, that is a product decision. This is actually a- another decision that I made recently with my own product, deciding whether it should be open source or closed source. And, uh, Sentry, also another good example of an open source product, and that has actual implications with how you build the software to make sure that it can be a reliable, open source piece of software.

So these product decisions that have product consequences will also have pr- consequences in the way that it's built. And so this isn't about, okay, now everybody is a PM and we're all making, uh, managerial product decisions, whatever. This is about the fact that agents are now becoming the ticket takers for us, and we have to elevate ourselves to leverage those agents the very best that we possibly can. So agents take the tickets, and you humans own what should be built, and you're going to be collaborating with these product managers a lot more than you used to. So these product decisions are about changing things about the user, changing what the user can do, cutting what shouldn't exist, and building primitives.

Those are the keys for what product engineers actually do. So one of the real reasons why this matters so much is you might be thinking, "Oh, well, Kent, I've got agents and I, I've, you know, got subsidized credits on, on my Harness or whatever, and so I don't have to worry about token spend. I'll just build everything. I'll just, you know, we, we can build anything and everything now. Like, let's have big ambition." But even though your, uh, agent is able to produce so much output, does not mean... That, that does not equate to your user's attention. There was that paper that kickstarted all of this stuff from Google that was titled "Attention Is All You Need," that really made LLMs, like, really feasible and kind of is the basis for everything now.

Well, attention kind of is all you need. It's not just intention, it's also trust. Uh, we can talk about that too, but attention is limited. It's finite. You don't have the ability to just build every possible feature that users could want because their attention is only limited. And so you have to be really intentional about the parts of the output that you're going to be, uh, leading into the user's attention. You're going to have to focus on the outcomes. So attention or output is nearly free. Attention is not. You need to spend it where the work is worth it. Uh, and here I have a, uh, YouTube channel, uh, Better With Kent is kind of this series that I'm doing, and you'll see me, uh, quoting this and, and, uh, Become an Epic Product Engineer, uh, quite a lot.

But, uh, I had a, a thought on here talking about, uh, loop engineering. I said, "You're trading compute for attention, and that actually is a really valuable thing if compute is doing something valuable." So in this case, uh, the idea is that you get your agents to do the things that are taking your attention so that you can focus that attention on the more high-leverage things. And so this is why building out loops or whatever it is, however you, um, elevate yourself and take the things that you're doing and give it to the agents so that you can have more attention to focus on what you want your attentions, your users to focus their attention on.

When you do that, then you're able to make better decisions. So that begs the question, what is it that product engineers actually measure? Are we measuring output or are we measuring outcome? And you got to be focused on the outcome. So let me give you a couple of examples. First, uh, if somebody is measuring output, then that's like a really quantitative thing that you can measure, and this is why it's very easy to measure output. Lines of code merged or number of tickets closed. I'll tell you what, I can put an agent and build out like millions upon millions of lines of code really easily and really fast and, and have that actually work and turn into an actual product, be an actual thing.

And we can also have agents open up a bunch of tickets and close them all. So like we can game that system really easily. But the output doesn't necessarily mean that there's value there. And so a product engineer measures their success by whether the job gets done. And to be able to do that, you have to understand the job. Uh, so the outcome becomes the thing that we're measuring our success on. So this is a really great, uh, quote from... This is the Become an Epic Product Engineer podcast, episode two from Wayne Allen. He said, "I would argue that building the thing right, which is what we engineers like to do, is actually downstream of building the right thing."

And for a really long time, we were able to just focus on building the thing right by, like, putting all the right abstractions in place and thinking about caching and the data model and, and all that. And I, I think that you still should have that as, like, really important concept in the system that you design. That's very important, even though if you're not actually necessarily building the specifics of the implementation there. But we were just so focused on those implementation details that, uh, we never had to really worry about whether we were building the right thing. We just think, "Oh, let's build the thing right, and, uh, we'll let the product managers handle whether we're building the right thing."

Well, um, even back then, it was important for you to be very mindful of whether you're building the right thing anyway, because teams, uh, at a big organization that are not building the right thing are the teams that are going to get let go in the event of a layoff. "Wow, well, this team's not really working on anything all that valuable anyway, so goodbye." Uh, you do not want to be on the team that's not building the right thing, whether it's before AI and certainly after. So building the thing right is downstream of building the right thing. Uh, another video from Better With Kent, the worst metric is percentage of code generated by AI.

And honestly, the worst metric is code written. Like, that's just not a good metric. It's a quantitative one, and so it's one that we can easily talk about. I can say, "Yeah, I built a project, project that's over a million lines of code by myself this year." Wow, okay, that does say something, but it's not a good metric, uh, for outcome. So what actually measure, matters is the product that is generated and solving users' problems. So whether or not the product is generated by AI or by a person, it doesn't matter. It's the outcome that is actually valuable there. And now it, uh, comes down to how much effort and how much, uh, cost is going into producing this value and making sure that the value is worth more than the input.

Um, and that's, that's the entire question, right? But, uh, and using AI can often actually drastically reduce the cost of things if you do it properly. But, um, the important thing here is, is to focus on the output and the outcome for the user, not, uh, sorry, the outcome for the user, not the output. Uh, here's another example. If I say, "Okay, I need to go drive to the airport. I'm going to get into my car, and I'm going to, uh, take every turn and all of that." And that's a very imperative way to get myself to the airport. But then full self-driving came out, and I just go into my car, I say, "Airport, please," and it takes me to the airport, and I don't have to think about it.

And in fact, it's a lot easier if the less I think about it, because if I'm very intentional, I'm sitting in my driver's seat of my Tesla, and I'm like, "I wouldn't have changed lanes there, and now I'm going to take over," and now it becomes this whole thing that I have to manage. Um, whereas if I just kind of let it go and say, "You know what? We're going to get there eventually, and it's fine," now I can relax. I can, uh, listen to some nice soft music, or I can listen to a podcast or whatever and have a much more enjoyable experience, and I don't have to care so much about how we get there necessarily.

So as long as I have, um, trust in a system which has earned that trust, then, um, I can end up with a much happier experience. A very similar situation to, um, building for an outcome. You're, um, not so meticulous about every single thing being done the way you would exactly do it. You're not so imperative about how things are done. You build up a system that you can sufficiently trust to do it a way that is good, and then you trust that system so that you can be elevated to a higher level of, uh, architecting and, and, um, deriving that product outcome that you're going for. Another example, uh, a Discord connection that works.

Okay, so you've got a ticket. You got to implement Discord connection, like sign in with Discord or sign in with the Slack or whatever it is. So- The, the person who's focused on output is going to implement the sign-in with Discord, but somebody who's focused on outcome might be talking with the product manager or talking with the users and understand that sign-in with Discord is like one of many sign-in mechanisms that you're going to be implementing in the future. And so you might think, "Oh, maybe let's take a step back and build out a system that makes it easy for us to add and swap out the different authentication methods that we're going to have in here."

Or even if it's broader, more than just authentication, it's connecting data sources, building out a system that can handle all of those. And this is exactly what I've done in my product, where, uh, instead of saying, "Okay, well, we've got to connect to a million different data sources, just literally anything that the user could possibly connect to, and so I guess we'll just build a provider for every single one of those." Now, instead, we built out a generic system, and now I can easily add providers in production as, as, uh, data rather than having it all be bespoke code. And this ends up being a much easier system for me as the operator of the site to manage, but also a much more powerful system, a much better outcome, uh, for me to build as the engineer who's building this.

And getting to that outcome is where AI helps a lot, because AI can handle the output, and you can focus your attention on the outcomes. So here's an example, real, uh, example from my own work. So I have this, these ADRs. These are architectural decision records. So ADR 54 rules out vendor-specific platform logic, so kind of that Discord example. So I noticed that, uh, an agent was working on something called a Strava hub and a Meta hub, and I was like, "Whoa, whoa, whoa. No, no, no. We do not do that. This is a principle, and so I'm going to record this as an ADR." And so, uh, I said, "Nope, this is not the way we do this.

Now we're going to say that our web hook system is a generic sys- subscription challenge." Now, there are a variety of ways that you can have a web hook, uh, authenticate itself with the, the service that's going to be calling the web hook, and I said, "We want to build ours in a generic way so we don't have to have a Strava hub and a Meta hub and a GitHub hub and whatever else." Uh, and so we add this no vendor-specific platform logic invariant, uh, which ends up being, uh, a documentation in the code as well as actually changing the code. So that's what's going on here, is not only adding the ADR, but also changing the code so that it can be generic.

And you can feel free to take a look at this, and we're going to talk about how my pull requests work and all, all of that, uh, in my product. But this is one of the things that you do as a product engineer, is you think about what are the invariants? What are the things that we're going to make sure do not enter the code base so that when the next agent shows up and it thinks, "You know what? We need to add a Discord hub to this thing," it's going to find that documentation and say, "Oh, no, we do this a generic way. Great, let me take this a different direction." And that comes down to being the product engineer who is thinking about the outcomes and understanding the whole system as a whole, rather than just a ticket taker who takes the assignment, implements it, and moves on.

And speaking of that, there's something that, uh, an agent can help you with, but it can't actually replace in you, uh, that makes you an actual product engineer, and that is ownership. Who gets the 2:00 a.m. call? Well, actually, hopefully your agent is already working on it by the time you are waking up. So you wire your agent up with your PagerDuty or whatever, so your agent can start looking into things, and then it can tell you, "Okay, here's what's going on." But at the end of the day, you are responsible for this. And, like, even though the agent, um, can wake up, it's not the owner. It's not the, uh, responsible party, the-- not the person who's responsible for the code.

So, uh, Rita, uh, over at Cloudflare was on "Become an Epic Product Engineer," and she said, "The thing that I like to remind my product team, who feel so empowered by AI, it does feel like you have superpowers, but at the end of the day, you're not the one holding the pager, the product, uh, manager. When stuff breaks in production, no one's calling you, product manager, at 2:00 a.m. If you're going to be committing code to production, you're then accountable for that code and need to really own it." Now, we aren't necessarily totally respon- or, or, uh, writing all of the code that we're shipping now. And in fact, I'm not writing any of the code I'm shipping right now, but I do feel a great deal of ownership over that code.

If it fails, it's on me. So this is my responsibility. I'm going to make this happen, and if it fails, it's on me. That is the attitude that a product engineer has, and if you have, uh, a different one, then you're really not any better than the agent who's just taking tickets, and the agent can wake up at 2:00 a.m. Like, that's not a, a hard thing for an agent to do. So that is an important thing for you to keep in mind as you are building out this, these agentic systems and, and this code is on autopilot and everything. You are still responsible for that code, and, uh, if you're not going to take that responsibility and, and make sure that things that get into production are quality, then there's somebody else who probably will.

So, uh, one of the nice things about this, it's not just about saying, "Okay, well, who are we going to call at 2:00 in the morning?" Uh, you know, there-- it's a little bit more to that. Uh, what it's about is that when you know that you are responsible, when you take that ownership, you're going to be a lot more mindful and a lot more careful about the way that you build things. You're going to be adding feature flags, and you're going to be talking about disaster recovery, and you're going to be talking about review and validation and verification and all of that stuff. That's what ownership does to you as the implementer or the one responsible for the, the agents that are implementing software in your system.

So ownership is a key piece of what makes a good product engineer. So- Knowing it's you changes how you ship. Uh, double-check the recovery plan. You're, you're on the hook for all of that. In another Better With Kent, I say, "Ownership and accountability and responsibility, that's the sort of thing that you offer as a human developer in this ecosystem now." So you do have things that the agent doesn't have. This is uniquely human, and this is something that you can offer as, uh, an engineer in the world now. And this is actually one of the things that I really, really love about agents, is finding that next rung on the ladder where I can raise up to a new level of leverage with agents.

So a lot of people are saying, "Oh, no, my agent is going to take my job." And I'm saying, "Give it. Like, please take my job. I don't want to do the things I'm doing now. I want to have, like, 50 agents doing all of those things so I can go up to the next layer of abstraction and have much more leverage." So the things I'm having agents do for me today are the things I was doing myself months ago. And so what you're trying to do is take the things that you're doing today and figure out, how can I push that down to the agent in a way that's reliable and safe and, uh, trustful, [chuckles] and, and so that way I can move up to the next layer of abstraction.

Let me give you an example of what I mean by leverage. So I've got this skill in my repositories called, uh, Review and Recommend. What this tells the agent to do is, first, I want you to gather as much context as necessary. So go to Sentry or, or go to our production system, what- whatever, uh, gather uses- usage data, whatever. So you got to make sure that you have that data and connect it to the agent. And also look at issues and code and git history, everything, and use that to help us make this decision. And then I want you to come up with some options of, like, actual things in, in numbered order.

I want you to tell me what is the effort, uh, how much effort is this going to take? Now, agents are, like, historically very bad at saying, like, they'll say, "Oh, this will take three weeks." And I'm like, "No, no, no. This is taking, like, one hour." [chuckles] But, but, uh, it helps to say, like, "This is easy, medium, hard," uh, especially when you're comparing the options. And then also, uh, is this a one-way door or a two-way door? A one-way door being like, once you go through this, it'll be very difficult to come back out because all of a sudden, all of the users are using that feature, and now you have to migrate them off, and maybe that's really a hard thing to do or whatever.

A two-way door being something that's just a lot easier for you to, uh, to revert. Like, oh, you changed some text on the homepage that, uh, gave some sort of instruction. Okay, you can just remove that, and that, uh, works just fine. So here are some example options. You can patch the system or fix the shared component or change the data model. Oh, okay, that's a one-way, uh, door. That's a lot harder to do, but maybe it's, it could be that that's the right thing to do. And then once you've got your options, I also ask it to recommend one of the options because the agent has all the context, and it's pretty good at making a recommendation, and I'll take that under advisement.

Okay, so it's going to recommend fix the shared component. Great. But then I tell it to tell me what the right fix is. If it thinks, "Okay, here's what I recommend based on the current, like, my understanding, my context, my whatever, of the current state of the world." But actually, if, you know, if all else were equal, this other option would actually be the right thing. And if, sometimes the agent will say, "Oh, yeah, that, that recommended fix is the right fix," and that's fine. Other times, it will say, "No, no, that recommended fix is not the right fix. If I were doing this the right way, I would do it this way." And then I explain, I tell it, "Hey, if, if the recommended fix is different, then tell me why.

Why are those different? Why do you think that... Why are you not recommending the right fix?" And that helps me a lot understanding. And here, maybe the agent says, "Well, it's the right fix, but it's a one-way door, and it's really hard. Uh, that's your call, not mine," whatever. And of course, the final decision is, of course, your call. Um, but, uh, having that explicitly laid out helps frame these options a lot better. And of course, sometimes the agent doesn't come up with the proper option, and that's where your experience as a software engineer really shines, is seeing these options and saying, "You know what? There's a fourth option in there." And then, uh, you are the one who's choosing, choosing.

So it's just waiting for you to choose, and you say, "Okay, I'll go with this one." And once you've got that system in place, you say, "Go," and the agent goes off and builds it. And that's what we're going to be talking about in my week. So here's an example, actual example of a conversation that I had with Cole, my coding Grok bot. Uh, so I said, "Hey, agents need to run their code against their Cody stuff, and right now, every run happens on our hosted servers. That's expensive for us. It costs a fifth of a penny every time somebody generates unique code and sends it to our servers, and then we evaluate it in our sandboxes."

Like, so it is, I mean, that doesn't seem like a lot, but when you get, like, hundreds or thousands of these per user, then yeah, that can be a lot. So I say, "That's expensive for us and adds a round trip to every call. I want to cut those costs by running even more of the work on the user's own machine without giving up security secrets." Um, and so, like, secrets shouldn't leave the, uh, the cloud. They stay up there so that we are proxying for those. Where should the code actually run? Okay. And so then Cole says, "Okay, well, you got a couple options here." And Cole is following this, uh, recommend and review and, uh, or review and recommend skill.

And he says, "Okay, hosted execute only. All code runs on our cloud. Easy," and that's what we were doing already, "but every run is round trip, and it's hard to debug." Yep. Um, uh, mock lane. So code runs locally against fake services. It's fast, but it lies about production, so not a good option there. And these are actual options. I know that I've, I've got this whole, like, slide thing, but these are the options that it gave me. Local isolate and cloud- ... capability proxy. Okay, computer or compute runs locally on the user's machine, and secrets and IO stay in the cloud behind a proxy. That's hard, and it's a close to a one-way door.

It's not quite, uh, but you get agents that are long-running, and they get used to that, and then we revert it, then they'd have to adapt to that. I wouldn't say that this is quite a one-way door. This is like a new thing, but there are ways that we can make this even more of a two-way door. Uh, and then full local Kodi, um, and it's saying, "Don't do this. It's a second copy of the platform to keep in sync." And, uh, yeah, we didn't go that direction. We, well, we kind of did. We, there is a hosted Kodi, uh, but, uh, the product offering is not this. And then it said, "Hey, build three, but gate it."

So that's another option is, um, behind a parity test before agents can use it. Okay, so maybe like a feature flag or something. So right now it's saying, "Hey, I recommend five long-term. Let's go with three." And I said, "You know what? I don't want to gate it. Just go straight on to three. Let's do this thing." Um, and, uh, rather than gating it, we are going to do a feature flag. So a proper feature flag anyway, so people can play around with it and experiment and break, uh, break things, whatever. And then Cole's like, "Great, I'll go do that." And it did, and it nailed it, and it was awesome. And, and this is actually the primary way that people are using Kodi now, is through the CLI and running on their local machine.

So what I think is interesting about this is that I'm not delegating or, or, uh, giving up my decision-making to the agent. That's really important. I am still the one making the decisions here, uh, and insofar as they are product decisions. I have delegated the decision-making for a ton of things, and this is actually something that you do as an engineer all the time. This industry has always been doing this. We delegate our decisions to the people working under us, you know, metaphorically speaking. They're not actually under us. [laughs] But, uh, you, you get a raise, and now boom, now you're the team lead, and now you've got these other engineers that are working under you, and they open a pull request.

Uh, they're doing it in a way that you wouldn't quite do it, but it works okay, so you just let it through. And then you go up to a-another layer of abstraction, and now all, all the way up to like a, a, a technical fellow or whatever, and now you're like the architect of all of these different systems, and boy, you do not understand what's going on in every system at a deep level. You just can't. Nobody can do that for any significant piece of software. And so, uh, we are constantly just going up this abstraction ladder, and just because we don't understand what necessarily everything that's going on under the hood does not mean that we can delegate the most important decisions.

So yes, we delegate some of those decisions that, and that is perfectly fine, and it's working. The models are getting better all the time anyway, but we don't delegate the really important ones like product decisions and long-term, uh, architectural vision for, uh, where we are going to go. So having recommendations and a right fix and all of that, that just helps me make the right choice. Most of the time, I do end up going with the recommendations, and I expect that that will continue to, uh, be the case where they continue to get better. But, uh, I am still the one who is making those decisions. It is my product vision that we're following, or, or if I'm in a big organization, it is the product vision of the team that we are following, and that is what dist-distinguishes us from the other, uh, company that is just saying yes to everything the AI says.

So for this week, we are going to be talking about the way that you can get your, your system in a place where you can trust it enough that you can move up that layer of leverage. We're going to talk about three things that you have to do this. This is three phases in sequence. So first, you've got to make sure that you get quality in. The, the code that is generated by the agents in the first place is quality code. So how do you do that? We're going to talk about that. Then if somehow the agent makes bad quality code, there's a problem in the way that it's being implemented, then you have to have a way to catch that before it goes to production.

And so we're going to talk about how to catch that, uh, as part of the review and verification process. And then finally, if your, uh, catching process does not actually catch the problem and it ends up in production, we need to talk about how you contain that. So you reduce the amount of blast radius, um, so that it doesn't affect, uh, things negatively. You don't have, uh, a production outage or, or like data loss or whatever. So we're going to talk about these three steps so that you can get yourself out of that implementation pipeline into a higher level of abstraction so that you can start taking the product vision and converting it into a system that can serve all of the product decisions and changes and everything that are going to be happening into the future.

And once you have that, then you can do the coolest things. You can plug in all sorts of data sources to come into your system and have it run on autopilot, and it's amazing. So the agents are actually really good at identifying when, uh, something actually needs a product call or there's an architectural decision that needs to be made, or this is a one-way door, so we need to make sure we talk about this, uh, or this is a feature we're going to discuss about that. But once you have all of those things plugged in, then your code base is just running and constantly improving, and it's fabulous. But you have to have these in place first.

Otherwise, you'll end up with slop in production, which none of us wants. So you are here to make product and architectural calls. So what does that mean? If we're going to compare the product engineer from the ticket taker, how are they different? And, and what are you going to become by the time you get through all of the exercises and everything that we're going to be doing this week? Well- The ticket taker starts from the ticket. That's just what they're thinking about. They're looking very tunnel vision at, like, what the job is that they need to do so that they can move on to the next ticket. But the product engineer is thinking about the outcome the user needs, the job to be done.

What, why did the job hire our product in the first place, and how can I help them get from A to B faster, more efficiently, whatever? And this means that you, as the engineer who's building it, might come up with ideas that are novel because you're in the system. And this is, like, that's where Gmail came from. Uh, all of these, uh, decisions that are made by engineers because they understand the technology underneath the hood. The ticket taker decides that we're done when the ticket's closed. Close a ticket, boom, move on to the next ticket. The product engineer is much more concerned about the outcome. The job is done when the job is done, and so understanding what that job is.

So it, it... And that means that once you have closed the ticket, that ticket is not closed because the job is not necessarily done. Are users actually using it? Are they hiring this feature to complete that job? And so with that mindset, you're going to be putting things into the design of your, uh, implementation that will help you answer that question, is the job done? Uh, a ticket taker will not do that. Agents write the code. That's, that's what an agent does for me as a ticket taker, and I'm slowly realizing as a ticket taker that, um, I'm just taking what's in Jira and giving it to my agent. It does a thing, and then I commit and push that, and that's like, that's all I do.

That job is, um, is sunsetting. Um, the product engineer uses agents to gather context and make a decision based on that context, and then builds out a system so that they can spend more of their time making those kinds of product decisions and less of their time just taking tickets. At 2:00 a.m., the ticket taker is hoping that somebody else, uh, calls, [chuckles] but the product engineer feels ownership, and that means that the product engineer is going to put things in place to make sure that they don't get a call at 2:00 a.m. And as far as the user's attention is concerned, the ticket taker, they're not... Honestly, they're not even thinking about the user's attention.

They're just thinking about this ticket, and they're just letting those, uh, tickets come in, and they're implementing one at a time. Before they know it, they're going to be replaced by the agent that is even better at that than they are. Product engineers are thinking about, okay, how can we design this feature in such a way that, um, it doesn't require more of the user's attention, hopefully requires less of the user's attention, and can delight the user and anticipate the user's needs? So u- understanding that user's attention is limited and being able to solve their problem while, uh, requiring less of their attention, that's actually a huge advantage. And that's what I want you to become during this week.

I want you to become a product engineer, somebody who's focused on outcomes, not just output. I want you to think about what you can do to change what your users can do. Thank you so much for your attention.