Skip to content
Linkdrop
Links

S03E05 · Products That Learn After Release: MEGA lesson video by Kent C. Dodds

Kent C. Dodds explains how agents can surface friction, fix recurring problems, and clean up obsolete code so a software product keeps improving after release. He describes friction logs, automated sweeps, and a weekly legacy reaper, and credits Joyce with the friction-log idea.

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

mega course, software factories, coding agents, agent-generated pull requests, software maintainability

Transcript of the lesson video for S03E05 of the MEGA.dev course, by Kent C. Dodds. Agenda: Signals · Observation · Synthesis · Decisions · Feedback Loops. The video plays on the lesson page in MEGA Student HQ (needs a login).

0:05 Once the three pillars are in place, then the factory can run on its own inputs. So my agents complain and clean up after themselves, tend to docs and tests, and fix whatever Sentry and users report are bugs, and what reaches me is the actual product calls. That is how a product keeps learning after release. So here are the three steps again. We got quality in, agents make good code in the first place, then we catch issues that inevitably come up in the pull request, and then we contain the problems that might make it into production with feature flags and the good backups and all of that. And once you have this, this is your software factory at work.

Now you can just plug in all sorts of inputs that can run on their own and improve the software for you, and all that's left for you to do is make product and architectural calls. And the first input is the agents themselves. Make the agents complain. Here's the weird and interesting thing about agents. They are happy to find a workaround, and you're never going to hear about it. They're not going to tell you about it. Now, if you're watching the agent and you're seeing it do stuff, you're like, "Whoa, whoa, whoa. Why are you doing that?" "Oh, well, it's because the server fell over, so I was just going to do this other thing."

You're like, "No, wait. Like, fix the server." But once you get into this place where you're just, like, iterating so fast, you're not watching the agents. You could have dozens of agents running all at once. You might not even know it. And so you don't want to have to be watching and making sure that the agents are doing the right things, but they're not going to complain about it to you unless you tell them to. And so this is why I have agents file friction in, in a single standardized format so that we can, uh, improve on the code base itself, and it kind of turns into a self-driving code base that, uh, im- improves as it grows.

So here's my, um, issue template for friction. So it's what happened, what you wanted, how to reproduce, what it cost, not necessarily just in tokens, but in time and everything else, your preliminary, uh, investigation, and any relevant files. And with that, I also have, uh, the documentation on what the friction log is and how to use it, and the fact that we have a daily sweep. So here's an example, the verification tool that was written by its users. So, uh, we've got this, uh, a bunch of friction issues referencing the Control Cody CLI, which we've talked about before. This entire CLI was built by these friction issues. One agent said, "Well, I had a hard time logging in.

That was kind of a friction thing that, like, it happened every time I'm opening these pull requests. I, I gotta, like, go through the login process." And so, um, uh, friction was logged, and then an agent came through and fixed that friction by adding a login feature to the Control Cody, or checking the health of a particular commit, or interacting with a preview, or browsing to a, a particular page in a preview, or whatever. And all of these different pieces making it easier for the agents to, uh, to actually contribute to the code base. Now, I very intentionally don't sidetrack the agent to go and solve its own problems as it's working, because I want the agent to be focused on what it's actually trying to do.

And so the way that I do this is at the end of the ship PR process, once it's already shipped to productions, everything's looking good, then I tell the agent, "Hey, look back at your conversation and think about, like, things that, uh, were maybe suboptimal, that could be done better next time. What are the friction points that you had?" And that's all the documentation explains how to, to file those friction issues, and then that turns into largely the, the CLI, but many other things as well. So here's a specific example of one of those friction issues. So we've got CodyBot opened up. Uh, what happened here? We've got some issue with the Control Cody CLI, uh, redoing sign up and log in and OAuth every call.

That seems inefficient. The, that was some friction. It costs seconds per agent, uh, verification calls on previews, multiple, uh, multiplies across ship PR loops, and so we're going to fix that. And so we had an agent that, uh, swept through and fixed, uh, looks like in this case, three pull requests or, or three issues that were friction issues all in one pull request. And so we added the cookie file, we added attribute, um, CLI flag, and we added the unexport unused entitlement barrels [chuckles] and delete. And so, like, all of these friction issues fixed all at once, and so future agents don't have to deal with that. And here's how that actually works. So the friction log package inside of Cody that I have, uh, just has a cron job that runs every single day at, like, 3:00 in the morning, and it goes through deterministically finding the issues that were created, uh, that, um, don't have, like, the needs/can't label on them.

And if there are any, then it's going to spin up a new Cursor Cloud agent, hand that Cursor Cloud agent the context from all of those issues, and ask it to evaluate, uh, whether this is something that it can actually solve itself. And if it is, then it will just go and solve it with a pull request, and if it's not, then it's going to add- A comment that explains, like, why it can't just fix it itself and add the needs Kent, uh, label on that issue so that it's not picked up in the future. And then I can come around, uh, and make those product or architectural decisions that need to be made.

This is actually an idea I got from Joyce on my podcast, Become an Epic Product Engineer, uh, and she was actually talking about humans doing this, and I recommend this too. She said, "The friction log is essentially a running list of all the things that are painful. They're paper cuts when you're using the experience." And so, like, this, this is something she recommended that, like, as you're using different apps and different things, like, write down the friction you're experiencing, and that will help you develop better product sense. But I, I thought about this, and I'm like, "Oh, I think that agents could probably do a similar thing." So thank you, Joyce, for this idea, and I recommend it right out to you.

All right, so now let's talk about cleanup, because agents really love to write code. They don't really love to delete it. They love adding fallbacks and all of this stuff. So you actually have to make things clean up on purpose. And so this is a part of my ship PR process. It's a part of the, uh, like, my standard documentation for all my agents is if they run into some sort of migration that they're doing or whatever, they need to clean up, and they need to, um, like, if they can't clean up the code right now, then they need to file an issue that explains what cleanup needs to happen and in what scenario it will be okay to actually run that cleanup.

So here's an example of a cleanup issue. So leftover unattached job rows and create job after fleet empty. So what happened here was we, we had this ability in Kodi for you to say, "Hey, like, just ad hoc job. Here's some code. Run this code tomorrow at 3:30," whatever. Uh, and then I realized, you know, we have Cloudflare workflows. Those can be used to do the exact same thing. So we've got some primitive overlap here. I don't like primitive overlap, uh, so let's, like, combine them or eliminate it or whatever. And so we could have said, "Oh, yeah, ad hoc jobs are just workflows now." But now you, like, agents can make their own workflows through this other API.

So, like, this ad hoc job thing that we had before just doesn't make any sense at all. And so we need to get rid of it. But unfortunately, there were some jobs that people had scheduled that we couldn't just delete all of this functionality, otherwise their jobs wouldn't work. And so, like, we can manually migrate them, or we can help them, uh, move or something, but we've got to have some mechanism for getting, like, that moved over. And I decided, well, let's, let's just, like, hide it from the interface so nobody can actually use this feature anymore, so they're not scheduling future jobs, and then in the future, we'll just remove it. And so that's what this cleanup issue was all about.

And as a part of this cleanup issue, uh, we have this ready when and how to verify, and this, like, we need to make sure that there is nothing left. And then every week, I have this legacy reaper that goes through these cleanup issues. We'll talk about the legacy reaper later, but it goes through the cleanup issue, uh, for all of the issues, and it's going to look at that verification step, and it's going to say, "Okay, great. Let me run that." And, um, every week it's going to say, "Well, here's what we've got left. I recommend we do not drop this yet." And eventually, we got down to, okay, how are we going to ever get rid of this thing?

And finally, we were able to, um, say, "Okay, we've got six left over. Let's figure out a way to get those off and moved over to something else," uh, because some, like, we're eventually just never going to get rid of this thing. And so we manually moved that over, and we're finally able to get that deleted. But these cleanup issues are just so valuable. It's exciting to watch the lines of code in your code base grow and like, "Wow, I'm managing a pretty cool and big code base." But as exciting as that is, it's actually not that great because you have to man- maintain that whole thing, or your agents do, and it makes your tests take longer.

It makes everything worse. So you do not want, like, even though the agent is doing a great job managing everything, whatever, you don't want to just keep old cruft around. And so you should be actively looking for opportunities to clean up, and that should be a part of the, your modus operandi or your MO for operating with your agents is finding ways to proactively clean things up. And the way that the cleanup happens, uh, like I said, is with this, uh, reaper. I call it the legacy reaper, uh, and it's kind of fun. But, but yeah, so it runs every week, uh, Monday mornings at like 3:00 AM my time, uh, from a, a Kodi package, and it's, uh, it's going to go through all the cleanup issues, but it also does like a deep audit on the entire code base and just finds things that could be deleted.

So here's an example of the issue that's created from a legacy reaper. Uh, it does an analysis only. It doesn't make any code changes, and it's going to just go through everything and just list out what it, um, what it found in its reaping, uh, whether that be cleanup issues or, like, we've got some data that no longer needs to be stored in the database, or we've got code, like, that's going through different code paths, or we've got primitives that need to be overlapped or whatever. And then I can go through this and talk with an agent about those findings. And in some cases, uh, the agent is like, "This is so obviously something we can just get rid of.

It's not a product call. This was just like a way we used to do it. We no longer need it," or, "The cleanup issue is done, so we can just delete that now. Hooray." Uh, all of that, whatever the case may be. Uh, it can be proactive, but if it finds a product decision or an architectural decision that needs to be made, then it's going to leave that one for me. And here's actually the other really cool thing is that it doesn't just, like, give up and say, "Oh, well, just leave everything to Kent." If it is not sure whether something is actively used and whether it's safe to remove, then the legacy reaper will also measure, and then it can delete.

So here's an example where we had this, uh, privacy safe packages.invoke, uh, migration. This is an old way that we used to, uh, invoke different packages. We don't do this anymore. Uh, and so it wasn't sure whether it was safe to remove this, and so what it did was it added this telemetry, And so then it could measure that, uh, over time and just see, okay, well, how are things looking? It looks like it's actually being used, and so... Or maybe it's not being used or whatever. Uh, but having some metrics in place that the agent just decided to add, uh, or actually I told it that, that that's what it should do. If it's not sure, just add some instrumentation so that we can become sure.

Uh, but that allows you to, uh, be confident in your ability to remove something. So you should be instrumenting your code like crazy, and, um, that helps you make data-driven decisions. And that allowed me to remove this particular feature and delete a whole bunch of tests or, like, yeah, tests, but also implementation code and everything else. So, uh, the Legacy Reaper has actually really paid for itself in being able to get rid of old stuff, and having it instrument stuff so that we can be confident in what we're removing is really valuable and saves a lot of my time. So I can get back to just focusing on, uh, the product decisions that we need to make.

Like, I, I did decide, yeah, let's get rid of that API, and then I'm able to just leave that to the agents because they're following this Legacy Re- Reaper process. And here's another thing that I plug into this flywheel, uh, that is documentation. So agents, they actually do pretty good at writing documentation, uh, for the most part, but a lot of the time, they really like to write documentation as if it's a change log. This happens all the time. It's so irritating to me. So I eventually made a, uh, cron job that, uh, goes through and updates all of the documentation to, uh, that was changed in the last 24 hours to, uh, delete anything that is, like, not relevant or, or not useful, uh, or, like, "I wouldn't have thought that if you hadn't mentioned it."

Uh, and so that, that sort of thing. We want everything to be written in present tense, drop any leftover, um, like rollout phrasing, things that, like, "Well, we used to do it this way, and now we don't." Uh, like, I hate that. It's so irritating. Uh, and I've been doing this every day for months, and it's awesome. So, uh, we end up, uh, dropping leftover phrasing here, and in this one, uh, like, we... You can see, like, we just do this every day, and there's actively useful things that, uh, we're able to remove from our documentation. And this applies not only to, like, product documentation that my users are consuming and their agents, but also to internal documentation, like how things actually are structured.

And sometimes it will find that there's some architectural document that describes one way that this works, and then, oh, actually, that's not how it works. And so it will fix that architectural documentation. Uh, that's useful. Like, you might say, "Well, Kent, why don't you just make them do the right thing in the first place?" Uh, I find that this is a lot easier, and this will ultimately catch more things because an agent might say, "Well, yeah, I documented that," not without realizing that it's actually documented over here, and it should have updated this documentation instead of writing this new one. And so having an agent that just goes through and documents or, like, does, like, a holistic view of the documentation of the project has been really helpful for me.

And another piece of cleanup that I have the agents do every night is cleaning up the tests. Yes, uh, the agents love to write tests, and many of their tests are really, really bad. Uh, and so every morning, I wake up to an agent that has deleted just a bunch of tests in my codebase. Sometimes I will actually have an agent go and do just, like, a full-on, like, delete. I want hundreds of thousands of lines of tests deleted without removing any use case coverage. But my nightly agent just looks at the last 24 hours, and it's like, "Okay, what, what of these tests are just, like, pinning what's in the UI?" So it'll say, like, I, I'll say, "Make me a UI page that describes this feature."

And then it will write a test that says, "This is in the UI, in, in the document." And it's just, like, literally, if it renders, then that's going to appear. Like, I don't know what, what is the logic you're testing here? You're, like, testing the framework. I don't... Um, it's super annoying. And so, uh, having an agent go through and just be like, "Well, here are our principles," and the agents don't always follow those. And so having one that just goes through and deletes that stuff keeps your tests in, like, tight, in ship shape. And so, uh, like, bad patterns don't, uh, go across the entire codebase, and you're able to end up with tests that are a lot better.

They run faster, um, they break less often, uh, they're easier to refactor with, all of that. They're following the testing principles. And I do have a testing principles document inside of Kodi that, uh, describes the way that I like to test, the way I think about tests. And so you should have something like that in your codebase as well. So here we see, like, this was, uh, two weeks ago. We removed a whole bunch of lines from this one, removed a lot of lines here, and then we, uh, removed a bunch of lines here. So I wake up every morning with hundreds of lines of tests just completely dropped because agents... Like, the, the thing is, the agent is like, "Well, uh, if, if you want me to remove that, I'm going to write a test first to make sure that it doesn't appear.

That test will fail, and then I'll go and delete it, and now the test passes. Hooray." And then it just leaves it there. And it's one of those things where it's like, "I wouldn't have thought that if you hadn't mentioned it, but now that you do, I am distracted by that." And that's just, like, annoying. And so, uh, getting agents to just remove those types of tests is valuable. Now, again, if you could figure out how to get the agent to just do it the right way in the first place, that's great, but it is kind of nice for the agent's workflow to be like, "Oh, you want me to delete that? Great. Let me make sure, like, I'll update this test that it's gone.

Okay, test is failing. Great. Let me delete it. Awesome." And it just forgets to go and, and delete the assertion. And, um, I've done that before, uh, and it's not great. So just having an agent that goes through and does a sweep every day has worked out really well for me. So the friction, the cleanup, the legacy reaper, and the nightly pass and docs and tests, all of that you can absolutely do, and I recommend that you do these things. I use Kodi for those things, but you do not have to. You could use GitHub actions for this stuff. But it's really valuable for you to have those in place so that your agents are constantly, uh, working inside of this flywheel, uh, and autopilot of your code base so that it's constantly improving.

Uh, it's awesome. So these loops, uh, loops are running inside the factory. Then we need to talk now about things that come from outside the factory. I'm really excited about this part too. And the first part of this is actually dogfooding. You should be dogfooding your product, and if you can get your agent to dogfood your product, that is gold because then the agents can report friction that they experience on the outside. So like you got agents reporting friction from the inside of working inside the code base, but if you can dogfood, now the agents can report friction from the outside. Like, this was a hard thing to use. So if you're building something that is consumable by agents, which you should probably be doing, then you have your agents using that all the time and, um, run into problems and file friction issues for those as well.

And so here's an example of, uh, a situation where my agents ran into something. So, uh, with Kodi, you have the MCP server, but you also have the CLI, and an agent can use the MCP server to bootstrap the CLI, so you don't have to, like, go through the manual login process. It's pretty cool. But, uh, uh, I had it initially implemented that so you could only have 50 active API tokens, and they expire after a while. But it turns out that when you've got a whole bunch of agents running, uh, all at once, that eventually you're going to run out of those active tokens. And so this happened, uh, and it made it so that my agents couldn't use the CLI anymore like I wanted them to.

And so, uh, this is dogfooding. The agent was using it, ran into a problem, filed a, a friction issue, and then the agents were able to say, "Hey, whoa, whoa. This is actually, uh, cool." It skipped this one. Uh, we're going to talk about some of the product decisions here, um, but yeah, it skipped this one and decided that it wanted to, or, like, didn't want to just solve this by itself. It had, like, a recommended fix but wanted to wait for me, uh, to fix that one. So dogfood your stuff. In fact, uh, Joyce, uh, on the podcast as well had a really great, uh, thought on this. She said, "Another practice that is maybe a little bit lighter weight is actually just dogfooding."

So this was one of her tips at the end of the episode. And then you need to have observability in your product. Absolutely. Like, of course, I probably should have mentioned that in the last, uh, lesson, but it almost feels like a given at this point. You absolutely should have observability in there. That- that's logs, uh, but also errors in particular. And so Sentry has a product called SEER, which is like their AI product that, uh, takes the error logs and comes up with the root cause analysis. It's fabulous. It's so, so good. Uh, this is not a, a Sentry ad, although my one wheel in the, uh, back of here is a Sentry-branded one wheel, which is so rad.

Um, but, uh, but yeah, so Sentry is awesome. I'm not sponsored by Sentry to, uh, tell you any of this stuff. But, uh, having some mechanism for, uh, getting errors from your users', uh, experience using your thing can be absolutely plugged into this software factory. And so here are a couple examples from my experience. So I had, um, this type error, this exports package app runtime bridge is not a function. Okay. Uh, undefined is not a function, right? Like, those are good old days. Uh, and so as a part of this, it has the root cause analysis from SEER, and, um, that ultimately ended up in a pull request. Uh, and so I, as a, uh, part of this, I have Kodi that receives the webhook, and then Kodi will send that out to an agent, and it also, uh, mentions it inside of Discord for me to, uh, see what's going on and have some visibility into this, uh, from the comfort of my phone and my Discord.

And it also keeps it up to date as well, so it tells me when that has actually fixed and the issue and the PR that are related to that, which I think is pretty cool. And, um, this is the pull request that was ultimately, um, created and merged. Uh, it was actually fixing, um, this, uh, Sentry issue, issue that, uh, came from SEER with the root cause analysis. The SEER root cause analysis is super awesome too because I can take all that context and put it into a Cursor Cloud agent or a Devin agent or whatever, and that will, um, have the context necessary to, uh, fix and triage the problem. If it does end up being a product decision or something like that, that's, that's pretty rare coming from your observability or your error handling.

Like, if there's an error, you probably want to fix it. Uh, but it does happen. Uh, in fact, just tonight, uh, that happened where it was, um, Sentry had found what it thought were, uh, some suboptimal queries that were going on, and it turned out that those weren't necessarily suboptimal. It was just the way that it needed to be. So I just said, "No, we're not going to do anything with that one. Just ignore that unless it, it starts being a real problem. Then we can look at it a little bit differently." Um, but, uh, yeah. So sometimes product decisions or architectural decisions come into play, but often these are the sorts of things that are just fixed, and it's super nice to not have to worry about that process.

Like, I don't even get emails about it anymore. It just goes through the pipeline into an agent, and then, um, it ends up in production. Uh, one thing that I should mention here too is that the errors can be user-generated, right? A user could literally in their terminal or in the console of the browser say, "Throw new error," and then prompt inject, right? And so you do have to be careful about that, but the way that I have mine set up is that it treats that, uh, content as data, not as instructions, and it does a pretty good job of that. There's maybe somebody who's like crazy smart and could figure out a way to prompt inject.

these agents, but they're pretty good at this stuff now. And so I'm feeling, uh, pretty reasonably good about things that are, um, happening inside of the code base. Uh, and on top of that, I've got the AI reviewers that are going to catch security holes and, and those sorts of problems anyway, and so they're going to stop things if they become a problem. And I've got to mention also that I have observability within Kodi itself. So you've got all these Kodi packages that are evaluating code inside of Kodi. Well, uh, if there's an error in there, I want to get that package fixed as well. And so, uh, it's the exact same sort of thing that I have with Sentry, though there's not like a root cause analysis, but there's an error that ends up in a Discord message for me and also in, uh, actually one of my Grok bots get- gets this, and it will, um, fix whatever is wrong with the package.

And so, like, you can just close these loops all over the place. It's fantastic. You absolutely need to get those different signals plugged into your software factory. And I- I've mentioned that this is coming from Kodi, so I've got two packages for this. This is Sentry Triage, goes from Sentry to GrokBot, and my Kodi Issue Triage goes, uh, from Kodi to GrokBot. Um, but you can absolutely do this without Kodi. I'm not trying to sell you on Kodi. I think that it's great, that's why I built it, but you can use anything. You can have a, a script, you can, um, build your own little app that integrates with these things. And in fact, Sentry even has a built-in mechanism for you to take the root cause analysis and stick it into a cursor code agent.

That's like a built-in feature. There are some things that I add on top of that that I like, uh, by using Kodi, but you absolutely do not have to use Kodi to do any of this. Oh, and one other thing. This is what probably my favorite one, uh, is feedback from users. So this, well, this is one where you probably have to be a lot more careful about prompt injection because this is like direct, uh, feedback. And it's not just prompt injection, but also product prompt injection. Like, uh, feedback from users, you don't necessarily want to ship every piece. Uh, and so, uh, I get-- when, when I get feedback, that goes through the Kodi pipeline, it goes into Discord and, and everything.

Uh, and, and, uh, the Kodi platform has its own mechanism for feedback. You can literally just say, send, uh, like to your agent, "Send Kodi feedback on this thing," and your agent will, like, put up a feedback report for you to approve and send it. Uh, and then that goes into the Kodi pipeline for getting fixed and stuff. But, uh, uh, having some mechanism for feedback for your product from your users, super valuable, and hooking that right up to your agents is awesome. Uh, you just need to make sure that, like, your agents understand that product decisions are yours. And, um, this happens a lot. Like, I, I mentioned with Sentry, sometimes I get those product decisions or architectural decisions where the agent will stop and will ping me about that.

But most of the time, I don't really have to worry about that. When it comes to feedback, I get pinged a lot, um, because of, like, for ideas in particular. Now, sometimes people will report bugs or, like, something is confusing or, like, wording and, you know, links are pointing in the wrong place or whatever. Those things, they just churn right through the factory. I don't have to look at them at all. But I do, uh, get feedback quite often. What's really cool, though, is if somebody says, "Oh, I hit this bug," like, "This connecting to the MCP server wasn't working," and here's, like, the agent that they're talking to has all of the context.

So it's so awesome. The agent can provide all the, like, "I hit this endpoint, and then I got this error," and whatever. And so my agent is able to just pick that up and be like, "Fix it," and it's out and published. I, I just looked today, the average is like an hour and a half, um, where somebody sends some feedback, and it gets worked on and fixed and published in an hour and a half by average. Like, that's wild. It's super, super cool. So here's an example of what that looks like on Discord. Uh, I'll get, uh, some Kodi platform feedback. The category here is this, uh, suggestion, and here are the summary request.

Longer, uh, request timeouts for AI model calls. So some people are, are making calls to AI models from their Kodi packages, and they want to have longer, uh, request timeouts because it takes a while sometimes. Uh, and so in this case, I actually needed to jump in and it asked my opinion inside of GrokBot, and I answered, and we delivered something awesome for the user. So I, I get these kinds of things all the time. Uh, I, I think actually I did measure it today. It was 53 in the last three weeks, uh, and I expect that number to increase. And in fact, it does increase naturally as you ship new features, you're going to get more feedback on those features, and so you just have to be aware of that.

But one, one thing that's really valuable here with actually with all of these, whether it's, uh, Sentry issues or feedback or whatever, having all of those go to the same agent that's, like, responsible for that is really useful because that agent then kind of has a record of all of the feedback that it's getting. Like, "People keep on talking about this. This is probably a problem. We should flag this," or, um, "This is, this issue keeps on coming up." So you probably don't want to just send it to an individual agent, uh, for each one of the issues, but instead sending it to, uh, an agent, this is what I do, you send it to a single agent that, uh, has that history, and that's part of what is useful in whatever automation that you build.

If you can put like a JEV model in there or something like that, that, that classifies it relative to the other issues that you have in there so that you can kind of group these things, uh, that makes it a lot more consumable for both you as well as the agent that's trying to work on this. So yeah, you want to put your feedback into that signal pipeline as well. So once you have all of these different things piped into this, you know, pipeline of shipping software, what's left for you? Well, I've talked about this a lot, that agents will flag things when they run into problems for, like, that need my decision. And I mentioned this one specifically where the agents, um, ran out of the 50 active API tokens, and so it flagged it for me.

It's like, "I, I'm going to skip this one. I have a recommendation. This is what I would do, but it kind of feels like a product decision. So, uh, here's all the details. Uh, here's the link to the agent that was doing the daily friction sweep. Um, so what do you want to do about this?" And then I had a conversation with an agent and decided, okay, this is the probab- probably the right direction to go and whatever, and we ultimately, uh, increased the cap and, and changed a couple of things. And in fact, this is one example where the agent gave me a recommendation, and I did not follow that agent's recommendation. Uh, and so this is- Like the, the human thing, the thing that you get to do because you're the one driving, um, the implementation of the product, or if you're on a big team, then, uh, you're working together on this vision for what the product needs to be, and so you're going to be making these kinds of decisions.

And, uh, and so as long as you are instructing the agents in that automation, uh, to tell them, "Hey, when there's a product decision here, if it's affecting these primitives that we have set up or, or it's a, a change to the architectural decision records that we have in the code base," like all of those first, um, things that we talked about at the beginning of this week, if you have those in place, then the agents will know what counts as a product decision and what should not be accounted as a product decision and what it can just do on its own. And, um, that makes you feel a lot more confident that agents can just work without you.

And that's what you can do when you've got these three pillars all established in your code base. It's amazing, and it feels so awesome to be able to just focus your attention on the thing that is uniquely human, which is making product decisions and architectural decisions. So you get quality in, catch mistakes, and limit or contain the mistakes if they do make it into production, and then it signals in, and the only decisions that come to you are the ones that actually matter as far as the outcome. And of course, like that, that's like all the problems and... But like once you have this, then you can start making like new product features and start having conversations with the agents and your team about like, "What is the vision for this?

How do we evolve this system to get to that vision?" And it's just awesome. Uh, that's the, the unique value here that you offer is not in implementing the code. We all know that. But you do need to make sure that the system is set up so that agents are effective at implementing the code, uh, efficient, cost-effective, like all of that. And once you have that, then it's just judgment and care. That's, that's your moat. It's having the right judgment, having the right product vision, and so that like you send the agents off to build the right thing. You can't build all of the things, and so you have to have a decision. Like somebody's got to make that choice.

You could just hand, like defer it all to the agent, but if everybody's doing that, then we're all going to be at this level playing field. You've got to be a step above. And by having it so the agent can focus on the implementation side and you can focus on the broader vision for the product and the architecture, then, uh, you're in a much better place because your mind is free to think about those higher leverage things. So I hope that you really enjoyed my week of Mega Dotdev. Thank you so much. Uh, I hope that this helps you to, uh, get quality in and catch issues and limit the blast radius so that you can have this awesome flywheel of a software factory and focus on making products that have a positive outcome for your users.

Thank you so much for your attention.