Skip to content
PodSubs
ShowsPeopleGuestsJobsNewsEvents
More
BlogPodCred
Menu
ShowsPeopleGuestsJobsNewsEventsBlogPodCredNetworksSign in
Join nowSign in
  • Shows
  • People
  • Jobs
  • News
  • More
    • Guests
    • Events
    • Blog
    • PodCred
    • Networks
    Join nowSign in

The AI Native Dev - from Copilot today to AI Native Software Development tomorrow

The AI Native Dev - from Copilot today to AI Native Software Development tomorrow artwork

Liz Fong-Jones: 2x the PRs, 1.5x the Incidents

Sep 29, 202650 minAudio

Honeycomb went from 30 to 70 merged pull requests a day in three months. The catch: automated code review, not code generation, became the real bottleneck of software automation. Liz Fong-Jones, Technical Fellow at Honeycomb, explains why incidents still rose 1.5x, how their internal bot Autobot now reviews every PR, and why AI amplifies whatever org you already have. What we cover: - How automated code review lets humans focus on design, not trivial bugs - Using a decision model like Jev to decide which PRs are safe to auto-merge - What makes a codebase ready for AI coding agents - When to trust AI agents with production incidents, and when they're just throwing darts - Why "Claude did it" isn't an excuse, and what ownership means with AI - How open source maintainers can handle a flood of AI slop pull requests Chapters: 00:00:00 - Introduction 00:06:41 - Why AI amplifies dysfunctional engineering orgs 00:10:45 - What makes a codebase AI ready 00:14:01 - Honeycomb's Autobot and automated code review 00:19:06 - Using Jev to decide which PRs are safe to merge 00:26:51 - Trusting AI agents during production incidents 00:30:40 - Least privilege and guardrails for coding agents 00:33:25 - If your name's on it, you own it 00:38:55 - AI slop pull requests and open source 00:45:56 - Will observability engineering survive as a role? Build your software factory, one workflow at a time, with Tessl: https://tessl.co/nlr 🔔 Subscribe for weekly episodes on AI-native development Is your team's review capacity keeping up with your AI coding agents? Tell us in the comments.

Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.

Transcript

From the show. Tap a time to play from there.

SPEAKER_0030 to 70 pull requests in just three months. That's a big jump and a lot for developers to be in control of, let's say.

SPEAKER_01Initially it looked like we were seeing a sublinear increase in outages correlated with it, right? Like our change failure rate appeared initially to be going down, and then it turned out over the long term it averaged out so that, you know, we were shipping twice as many pull requests, and we are seeing, you know, 1.5 times as many incidents. And there is a limit to how many incidents you can ask human to work, right? Like your human code review attention is limited. How do we enable our developers to scale up not just their ability to produce code but also their ability to review code?

SPEAKER_00The AI Native Dev is a podcast for developers and engineering leads at the cutting edge of AI and agentic coding. Join your hosts, Guy Fajani, and me, Simon Maple, every week as we chat with the most exciting voices in AI and tackle the biggest questions facing developers today. This is the AI Native Dev. Yesterday, you were writing code. Today, you're prompting agents. Tomorrow, you'll be running a software factory. Agentic coding is moving fast enough to give anyone whiplash.

SPEAKER_00This June, AI DevCon London sold out. Hundreds of developers, engineering leads, and VPs packed in to hear speakers from Anthropic, OpenAI, Netflix, and GitHub to cut through the hype and get to what actually works. This November, we're bringing it back to New York. Bigger, bolder, and full of people actually building the agentic future. Three days of real talks, real tools, real answers, whether you're directing the agents, building the loops themselves, leading the teams, or setting the strategy.

SPEAKER_00As a podcast listener, you can get 15% off your ticket using promo code POD50. We have so much planned, and we can't wait to have you join us in New York. Hello and welcome to another episode of the AI Native Dev. My name is Simon Maple. I'm the host for this episode, and joining me is uh Liz Fong Jones, Technical Fellow at Honeycomb. A massive welcome to Liz. Hey, how are you going? Hey, doing very well, thank you.

SPEAKER_00And uh I think this is your first time on the AI Native Dev. Um now, Liz, you're a technical fellow at Honeycomb, but you actually started more on the SRE side and then moved into Devra, a little bit into field CTO, and now uh a technical fellow. Tell us a little bit about uh the journey that you that you've been on.

SPEAKER_01Yeah, I think over the course of my career I focused on being a generalist in the field of reliability, and I focused on up-leveling the teams I work with. So I started as an individual contributor, as all the junior devs do. Um, and then I moved to kind of advising Google SRE teams and uh Suite teams on what the best way was to implement reliability practices. And then I took a swing at the engineer manager pendulum and managed the uh big table S-RE team at Google, about 12 people under me uh for a couple of years.

SPEAKER_01And then I realized that, you know, I could have all of the impact in the world working on one specific team, working with one specific set of people, but I really wanted to have a broader impact on the industry because I could see so many people that were struggling to implement SRE practices across their organizations. And I thought, you know, there's a real role to up-level the industry and to help people get more satisfaction and not just have ops be this uh drudge thing, you know? Um so that's really what led me down this path of DevRel and field CTO work is kind of thinking about how do we move the industry forward and what's the best lever to do that.

SPEAKER_01And sometimes the best lever to do that is not you know managing one engineering team.

SPEAKER_00It's funny actually, because when I I also moved from uh developer relations into the field CTO, really enjoyed it actually. It was at sneak. Uh I probably talked more with CISOs and CTOs, and I kind of felt like it's a little bit like a DevRel kind of role, but it's just more leveled up into the into the um into the leadership space. Right, exactly. You're doing leadership coaching, right?

SPEAKER_01Yes. You're working peer-to-peer with other executives who are struggling to implement changes across their org.

SPEAKER_00And that's actually where our similarity ends, because I moved back into DevRel because I kind of miss the developers a little bit more. But tell us a little bit about the the technical fellow.

SPEAKER_01Yeah, so as a technical fellow, I get to do kind of distinguished engineering work across all of our various engineering teams, as well as still continuing to hold on to some of that work to uh evangelize and teach and to write about what we're doing. Really honestly, the kind of writing and appearing on podcasts and kind of being able to be that public face of Honeycomb engineering, so that our engineers can, you know, primarily focus on being heads down, except for right, like I of course nurture the ones who want to speak publicly. But right, like kind of being that ambassador for what are we doing, what are we seeing is really, really helpful, especially given Honeycomb's brand is that we are for forward-thinking engineering teams, right?

SPEAKER_01So kind of helping pilot what does that look like, and being in a position to give people advice where we've already seen what the path looks like.

SPEAKER_00And Honeycomb very openly kind of talked about how this kind of a role it really it really helps uh technical engineers and technical folks uh progress their careers without needing to drop into that slippery, that slippery slope, Darek or a horrible slope, of this management thing. Uh I remember I remember my my my dad, who was uh an engineer, actually electrical engineer, kind of was promoted into a a managerial role many, many, many years ago. And that felt like his promotion. He succeeded because he went into a managerial managerial role.

SPEAKER_00But of course, that's not actually what most engineers are particularly good at or actually want to do.

SPEAKER_01So I think this is a really strong uh way of of of leveling folks up without uh I agree, and also I think it does make uh engineers better engineers to take a turn at management at least once in their careers, even if they don't decide to do it l full full-time, longer term. I think it gives you a level of visibility into how engineering organizations work, how to have impact as a senior engineer. So I I I wouldn't say necessarily that um, you know, I I agree with your premise that being a manager is not the promotion.

SPEAKER_01But also I would say that it shouldn't be something where engineers should, you know, steer away from it and say, oh god, no, I'm never going to do that, right? Like because I think you have a lot to learn from doing it at least once. Yes.

SPEAKER_00Oh, that is so true. That was my experience. I totally agree with that, actually. I think I think the the and I think to today more than ever, you know, the the the personal skills uh or you know of interaction, the communication with AI as well as other people is so important to be able to to vocalize, uh, to vocalize those things. Now, one of the things I love doing, Liz, on on this podcast is finding quotes from people and and and and throwing it back at them and saying, let's chat about this, let's see if this still holds up.

SPEAKER_00Now, one of the things that I actually completely agree with here, actually, so uh it it's you you your line was AI amplifies your existing practices, it makes a dysfunctional org more dysfunctional and a high ownership org faster. Now, let's I I totally agree with that, but let's define what is a dysfunctional org. What are the traits or the things that you would see and say, yes, if you add AI there, it'll actually make you get to that bad state faster. What would you see as those flags?

SPEAKER_01Oh man, I actually prefer to talk about the inverse of that and talk about the traits of the functional orgs um rather than talk about the traits of the dysfunctional orgs, because I think there's just so many different varieties of dysfunction out there that it's hard to enumerate them all. Um, but I I think, you know, let's anchor on what you said about ownership, though. I think ownership is really that primary force that dictates whether an org is uh high or low functioning. And it's the extent to which developers view their contributions as something that they take a sense of pride in, uh that they want to own the life cycle of end-to-end, that they are responsible for, um, and that uh they they are happy to sign their name to.

SPEAKER_01And I think everything else kind of flows out of that because when we talk about reliability practices, an organization that has poor reliability practices likely does not have a strong sense of ownership because otherwise, why would you let broken code ship to production and leave it broken in prod? Right. So we can talk about all the ways that you can leave broken code in prod, but I think it find it fundamentally boils down to are the developers allowed to follow it to production? Can they do so, right? Like without having to go and ask for five sets of permissions, and are they actually following through?

SPEAKER_01Right. So, you know, we hear, I I think this was in the news recently. Um, two Toby Lit Litke, the uh CEO of Shopify, said, you know, 12 months ago, we are now an AI first org, everyone should be using AI. And then literally a week ago, he lamented slop bombs being uh lobbed by engineers at at production and out of their teams. I am like, man, that was kind of a foreseeable consequence if you were telling people to move without ownership and just, you know, use AI and move faster, and you know, who cares about the consequences, and now suddenly they're weeping the consequences, right?

SPEAKER_01So I think you know, ownership of not lobbing slop bombs because you are responsible and accountable for what you ship, right? Like I think I think that's that's the important thing.

SPEAKER_00So so you're saying that the bearing here is more important than the speed in terms of if if you're you will can you will actually accelerate to the destination faster and if you're doing something bad. And and I think the um the important thing is that you're gonna be.

SPEAKER_01And if the and if you are not steering in any particular direction, right? Like, you know, you add rocket you know, rocket fuel to a rocket that has no steering or guidance and just go in circles until it blows up, right?

SPEAKER_02Yeah.

SPEAKER_01I I think that's the classic example of you know of of acceleration without direction. Yes. Yields just going in circles.

SPEAKER_00Yes, and and and I I guess uh you know a a takeaway there is AI is not gonna fix any existing problems that you have. It's gonna magnify them. So if you have a problem, AI won't fix it, you need to fix the problem and then introduce AI to accelerate the uh the the path that you're on. So right.

SPEAKER_01If you're not in alignment about what you should be shipping, then you're just going to ship more random acts of engineering, right? Like that's not good for anyone. If certainly I know that customers have a very limited patience for the amount that they allow their UI to change, right? If the uh Riverside podcast reporting software looked different every time I logged every time I logged in every single week, I would become very frustrated very quickly, right? Like there are limits to how much churn you can introduce, and you have to think consciously about how you're spending that churn.

SPEAKER_00So I I really like the example that you gave about ownership there. Um because I think and I think there's almost like that willingness for employees, for developers to say, actually, yeah, I want to see this through to production. Um beyond ownership, are there other uh other traits of a repo where you would look at something and say, Oh actually, yeah, these people are using these folks, developers are using autonomy well or or uh you know strong patterns and it's actually very easy to add AI in, maybe it's DevOps practices.

SPEAKER_00Are there other things that you can look at a repo and say, this is AI ready?

SPEAKER_01Yeah, so I think one primary thing is AI copies existing patterns that exist in your code base. If you have five different ways of doing something, AI will become very confused and it will create six ways or seven ways in ways of doing it. So I think making sure that you have alignment in your engineering organization about how do you do things, what are the common patterns, as you say, and then making sure to encode for AI and also for your new hires. Where do you find these patterns? How do you use them? And I think you know, take taking your nudge there, right? Like it is important as well to have strong CICD patterns so that you can actually validate things with five minutes of effort and not 60 minutes or three hours of effort, making sure that you have good observability, making sure you have good testability, and not just, you know, empty calorie tests, but actual like real meaningful tests.

SPEAKER_01Right? Again, machines copy, and if they are copying bad practices, then you're going to wind up creating slot bombs. If you are copying good practices, then you are going to have an easier time testing and validating what you're producing. And that you know, starts with testing, starts with high quality comments. And even in our code base where we have relatively high quality comments, we found that AI unfortunately is regressing us to the mean there. We're having like lots of very low low value comments that AI is creating, right?

SPEAKER_01Like, so how are you guarding against AI making your code base worse? How are you actually propagating good patterns around testing, good patterns around observability, kind of making sure that we are engineering things in a way that it's going to be easier to roll them out to production?

SPEAKER_00And and I think we talked about this briefly off-air, but uh the advice that we are kind of like giving here is actually the same advice that we would give pre-AI in terms of what functional looks like, what good looks like. You know, good testing, good reliability, all of those things. This is just good.

SPEAKER_01Because they're telling people to eat their vegetables. It is. Right, and the and the trouble is no one wants to eat their vegetables until they wind up with a vitamin deficiency, right? Like except for the thing is, AI has made it a lot easier to do the eat your vegetables part as long as you tell AI to do it and not just have AI, you know, slop coding a bunch of new features into your code base, right? Like you have a bunch of new engineering bandwidth. How you choose to spend it is up to you. And because the machines never get bored, it's a great thing to do to have them add telemetry to your code base, right?

SPEAKER_01Like to add rich Y events, to write to add attributes, right? Like these are things that we used to have to get tell developers, you know, like like telling them to eat their vegetables or brush their teeth, right? Like now it's something that the robots are actually pretty competent at doing, and they're happy to do it as long as you instruct them to, right? Like, so I think it's both that the necessity of doing it is higher than ever because we're having this increased volume of uh code that we're trying to land. And also the ease of doing it is much better as well.

SPEAKER_00Yeah, no, absolutely. Um so let's talk about a functional um organization. Let's talk about Honeycomb. Let's talk about the honeycomb bot autobot, sorry, uh that um merges pull requests and you know, creates pull requests. Uh I believe that went from 30 pull requests uh merged per day to 70 pull requests merged per day in three months. Is that did I get those numbers right?

SPEAKER_01You got the numbers right, but I think the attribution is wrong. Um so yes, we do have an internal coding bot called Autobot. Um however, the Autobot is producing maybe five of those pull requests per day. So it's not the majority creator of the pull requests, it is the 100% reviewer of those pull requests, and it has gotten so good that our developers are no longer needing to look for trivial bugs in changes, right? So I think you know, when we're talking about increasing your number of pull requests by a factor of two or more, right, like your human code review attention is limited.

SPEAKER_01How do we enable our developers to scale up not just their ability to produce code but also their ability to review code? And I think it really helps there to have a helpful assistant like Autobot, you know, pointing out problems so that the developer doesn't have to be a human linter or a human bug checker.

SPEAKER_00Right. And and this is really interesting because the the speed at which people can write code and and and trying to deliver code is not the problem here. It's the the the problem is the speed at which uh us as humans can validate that the code that is being generated, the pull requests that are coming in, are are valid, are correct, are well tested, and exactly so, right?

SPEAKER_01Like I would argue any real production system should probably not be a dark factory, at least at this time.

SPEAKER_02Yeah.

SPEAKER_01I think there is a need for human oversight, human review, human accountability, as I was talking about, right? Like, you know, how are we making sure that we're feeding back the lessons that we learn? How are we making sure that we are maintaining our standards? And I think those standards have to come from humans, right? Like, I don't I don't think the robots are capable of coming up with enforcing the standards on their own, right? Like we have to, right? Like, just because you have adaptive cruise control in your car doesn't mean that you can fully let go of the wheel, right?

SPEAKER_00Like you still have to pay attention. So can you tell us a little bit how uh the Autobot and I love the t I love the name Autobot. It does sound very transformer-like, so it it it feels like it feels like we've got a lot of power on our side. Um tell us a little bit about how that works under the covers. What why is it so reliable?

SPEAKER_01Yeah, so originally we conceived of Autobots as this mechanism to automate the creation of small kind of bite-sized pull requests. And you know, we developed, we invested a fair amount of time in essentially doing clawed code in a box to work on a single linear ticket. And it still does that, although we're in the process of sunsetting that because it turns out that now it's you know commoditized and now you can have bespoke services that do that in a box for you. Um, but I think at the time when we started this effort in April or May, this was you know phenomenally effective in terms of for the first time having even developers who are not super fluent in clawed code be able to say, you know what?

SPEAKER_01This this ticket looks relatively simple. You know, nothing ventured, nothing gained, right? Like, you know, let's assign that ticket to Autobot and see what pull request it produces, right? Um, so that's that's kind of how Autobot started. Was it was this effort to kind of clear off the lower hanging fruit that doesn't require a developer to supervise and tell the robot consistently and steer it, right? Like, you know, this is the kind of design direction I want this to take. The theory was if you decomposed everything into a linear ticket well enough so that it would be able to, you know, complete the linear ticket on its own, that then your Autobot could take that and turn it into a pull request, and then you could, as a human who requested the Autobot to run, you could go ahead and and review that self-review first, and then after that hand that to your peer reviewer to to review as well.

SPEAKER_01Um so that's how it started. And then we realized that there were a relatively small percentage of these smaller tickets, and also that same functionality could also be used to reproduce kind of in a box the functionality that I think in April or March this year, uh Claude uh Anthropic released this Claude Code Reviews functionality. And it was phenomenally expensive, it was like$20 or$30 per run, and it took like 10 or 20 minutes to run. And we looked at it and we said, actually, we want something like this.

SPEAKER_01Um, but we would prefer that it be that it run within less than two or three minutes, that it costs dollars per pull request and not tens of dollars. Um so we pivoted the Autobots project towards handling reviews because we realized that our human developers were more than capable of creating this mass volume of pull requests anyways, Autobots or not. And that we needed to focus that instead on how do we make the review load over human reviewers uh lighter.

SPEAKER_00And and how does um so obviously, you know, Claude as a as a as an LLM or a general LLM, um, these types of things will always be kind of like very expensive uh and and long to run. Uh in the news this week, so this will tell folks when we recorded it, uh obviously Jev is is making uh a lot of waves right now. It's hitting the it's hitting the headlines uh in most places. Um with with an LLM which is very specific to kind of being able to provide you know yes-no answers or multiple choice, does that how how will that now impact uh places or or you know specific tasks like code review?

SPEAKER_01Yeah, so I think the primary place where we're thinking about deploying JEV right now is classifying pull requests into safe to merge with just the automatic review versus not safe to merge requires a human review. Previously we had been relying on humans to self-identify, and we were doing this uh experiment actually to try to have about 20% of our pull requests um automatically reviewed and landed without having a human review, kind of right, like again, focusing that human attention because if you double the number of pull requests, either you double the amount of more than double the amount of time that you're spending, you know, as a human reviewing, or you have to load shed, you have to figure out what's less important to review and what's more important to review.

SPEAKER_01So previously we'd been doing this experiment of having humans and the reviewers labeling, you know, do I think that this is a pull request that requires high effort to review or not? And you know, now I think we can have Jev do that, right? Like we can have Jev be that gut check of can I trust the reviewer's opinion on whether or not this is safe to land? And if so, go ahead and land it without human intervention, right? So there still is the language model layer doing the code review.

SPEAKER_03Yeah.

SPEAKER_01But I think the classifier is then doing that work of how complex is the code change? Did the reviewer raise any significant concerns? Should I land should I merge or not?

SPEAKER_00Yeah. And I think there are three kind of like key things that are hitting the news here with with Jev. One is the cost, one is the speed, but the other is the confidence score. And I presume it's the c the the the speed and the and the cost are probably the nice to have here, but it's the confidence score, I guess. Right, exactly.

SPEAKER_01If I'm already spending five minutes and ten and and ten dollars in tokens to review to review this pull request, the thing that's actually important here is getting an automated confidence score on can I land this safely, right? Um so yeah, 100% agree. Uh, right, like, but for us, again, this is not that we're intending to spend less time doing code reviews than we did before. It's to focus the time that we're spending doing code reviews on the design patterns and not on trivial bugs and on the more complex PRs and not on the more simple PRs, right? Yeah.

SPEAKER_01If I'm twiddling a single config knob, most of the time that's not a big deal, except for some of the time it actually has this. Potential to bring down production, right? Like, so I think that's that's kind of that that trade-off there, right? Like an eye as a human can of course opt out of automatic code review, right? Like entirely, right? Like and say, hey, this is requires special caution. But honestly, right, like most developers are very conscientious, right? Like at least in a high autonomy org. So we don't want to cause outages in production. So by definition, you know, outages happen when something happens that was unexpected, that we didn't foresee, that we thought it was going to be a simple change and was not, right?

SPEAKER_01Like, so having these additional guardrails, whether it be a language model doing a review or it being Jeb doing a you know sanity check of does this make sense or not to immediately land, right? Like I think those are the levers that we need to do to really go beyond uh beyond 2x. Um because we've hit the sea, like candidly, we have hit the ceiling of how much code we can conceive of and review.

SPEAKER_00And and this is interesting because whenever we hit the ceiling, we always tend to go beyond it uh when we in in a way we kind of like least expect. But um, you know, 30 to 70 pull requests in just three months, that that's like a that's a that's a big jump and a lot for developers to uh uh be in control of, let's say.

SPEAKER_01Um yes, and we definitely initially it looked like we were seeing a sublinear increase in uh in outages correlated with it, right? Like our change failure rate appeared initially to be going down, and then it turned out over the long term it averaged out so that you know we were shipping twice as many pull requests and we are seeing you know 1.5 times as many incidents. And there is a limit to how many incidents you can ask a human to work, right? Like so right, like we we have to start looking at how do we de-risk the other say these other things.

SPEAKER_00So, where where's the line, would you say, between something that's been reviewed and something that's been understood? Because it's almost like, you know, when I deliver a 500-line pull request versus a uh you know, 10-line pull request, one will definitely be scrutinized more than the other. In the same way, if I was to provide you with 500 pull requests versus one, there are going to be many more that just you know go through with uh maybe uh you know reduced visibility from the human. How do we how do we make sure that as humans we don't just become very blasé and and and just you know push pull requests along and actually understand what happens?

SPEAKER_00Is this again another maybe it is the JEV angle of the case?

SPEAKER_01Is it the code review the right place to be having that discussion? Often we find that that is a better place to be talking about it at the project and at the ticket level than at the pull request level. By the times, right, like especially if generating the code is cheap and you could do it five times over, right? Why are we that that attached to the way the specific code works and not to the broader design pattern, right? Like that's the thing that we should be aligning on is is the direction correct and not, you know, is this implementation exactly correct, right? Like language model can help you understand what the individual lines of code do, right?

SPEAKER_01Like, but the broader pattern, that's something that you have to hold in your head, and that we as humans that are supervising these systems need to have a consistent picture of how is this supposed to behave at the macro level.

SPEAKER_00Yeah. Let's let's then take it one step further. Let's say you know there's an outage or some some system fault. We obviously need to um have a look at we well, we need telemetry data and we need observability. Uh now you draw quite a hard distinction here between what telemetry is and what observability is. Uh really data versus the ability to truly understand the system. Yep, data versus understanding 100% every day. Well, what is how does AI change what understanding a system means if a human actually doesn't write that code?

SPEAKER_01I don't think the human has to write the code, and also I don't think the human has to do the the querying by themselves. However, examining the outputs of the queries, that's something that a human has to do to really kind of internalize and understand how did this outage happen, what are the other things that we should be looking at that are similar, how do we prevent this outage from happening again, right? Like so I think having the telemetry data, having it queryable and legible both to the humans and AI, is helpful for then kind of establishing that feedback loop.

SPEAKER_01And I don't think it's just at the moment of outage. I think also in your development cycle, right, you should be having your language models test the telemetry that they're producing by you know querying a dev environment, right? Like to make sure if if I added an attribute, is that attribute present? Do I have the ability to detect if something backlogs, right? If something starts queuing, right? So I think I think the answer is yes and, right? Like I think yes, we have to have telemetry, yes, we have to have the ability to analyze that telemetry, and also it's not just the human's job and it's not just the robot's job, it's a joint responsibility to turn the telemetry data into understanding.

SPEAKER_00Yes, yeah. And and I guess as someone who has a a lot of history in the world of SRE, you talked a little bit about um how you know your opinion on w how people should be using uh Dart factories in production. How much should we be trusting AI to do uh with data in an incident? Would it be lovely to think that we can wake up in the morning and and kind of you know click a button to say, yes, I can see the AI uh agents have identified the problem, they've done all the the background root cause analysis, they've suggested the issue.

SPEAKER_00Uh the sorry, they've suggested the a a solution, they've reviewed it. I just need to review it myself and and push that through. How how close are we to that today? And do you see a world of the case?

SPEAKER_01Again, it depends on how well you are implementing the practices of the last 10 years. Yes. We have had feature flagging for 10 or 15 years, depends on how you know you count Netflix's early stuff. Right. We've had feature flags for 15 for 15 years. If you were implementing feature flags well, then yes, a robot with access to MCP can identify which feature flag uh will solve your problem and can fix it, it can flip the feature flag, and the telemetry will be recorded both for the robot who's diagnosing in real time and for you with a cup of coffee or a diet coke in your hand the the next morning, right?

SPEAKER_01Like if you have that telemetry data recorded and if you have the controllability, right? Like remember, observability and controllability and control theory are duals, right? Like if you have both observability and controllability, you do have the ability to not have to wake up at 2 a.m. Because you can actually go ahead and fix the problem without necessarily even fully understanding it, right? And then to be able to examine what happened after the fact with the kind of you know flight recorder or whatever it is, right? So I think we're pretty close if and only if you have working automatic rollbacks, working uh feature flags, working observability.

SPEAKER_01If you don't have those things, your agents are just guessing and throwing darts at the dartboard, and they might cause more chaos than they actually solve.

SPEAKER_00Yeah.

SPEAKER_01So it depends very heavily on your production maturity practices.

SPEAKER_00And it's not so much your trust in the AI, it's your trust in the system with which the AI environment is running in.

SPEAKER_01Exactly, right? Like our job is to make it so that the tools that the robots have are safe. Yeah. If we're having AI exercise its judgment about whether it's okay to kill these pods, I think that that is a very dangerous thing to give your AI uh agents the ability to kill random pods in production, right? We should be giving them tools to abort rollouts, to revert rollouts, right? Like, so I think you kind of have to make sure that the tools are always safe to use. And that the robots, right, like rather than trusting the robots to decide whether or not to call them.

SPEAKER_00Yeah, structured functionality that they can that they can use.

SPEAKER_01And let's talk about And that's right, like to be fair, this is also true about your most junior developer on your team. Yes. Right? Like, you you know, if you're making it safe for your junior developers that they cannot accidentally cause production outages, right? Like I think that that's great for your d for your robots too.

SPEAKER_00Hey everyone, hope you're enjoying the episode so far. Our team is working really hard behind the scenes to bring you the best guests so we can have the most informative conversations about agentic development. Whether that's talking about the latest tools, the most efficient workflows, or defining best practices. But for whatever reason, many of you have yet to subscribe to the channel. If you're enjoying the podcast and want us to continue to bring you the very best content, please do us a favour and hit that subscribe button. It really does make a difference and lets us continue to improve the quality of our guests and build an even better product for you.

SPEAKER_00Alright, back to the episode. Let's talk about, let's continue this path down trust and safeguarding. Um you described needing things like clawed MD rules, um, MCM MCP mediated access, least privileged systems, all all these things which help uh this safeguarding. Um what what in your opinion have you sin that kind of would be a really good piece of advice that most teams actually don't think about or or you know it's it's great practice, like least least not least privileges is something that we've known for many, many years, decades.

SPEAKER_00What are the things that teams can do um today that is just completely non-negotiable to avoid?

SPEAKER_01I I think the starting point is really hermetic CI and CD, like to have fast and reproducible CI and C D. Um I think that's the foundation of everything. I think the your mention of least privilege is great. Actually, I discovered that on on its own, actually, um Claude has started when working with Amazon profiles to default to using read-only profiles, uh, if it's provided the option to have both a read-only and read-write profile. Um even if the read-write profile is technically available, it will still use read-only just to be safer, like which I think is a great safety practice, right?

SPEAKER_01Like, and you can also enforce that, right? To enforce, you know, hey, commands that use the read-only profile are auto are automatically approved, commands that use the read-write profile must use human approval, right? Like, so I I think for like layers, defense, and depth, I think that those are all really, really great things.

SPEAKER_00And uh and is there you know, anything you think we are overtrusting these days in terms of are there default settings that we should absolutely try and avoid?

SPEAKER_01I think the main thing that we are realizing does not scale is having humans click yes. Um I think that classifiers do a much better job than humans when attention is scarce. Um and I think that, you know, you do have to develop a certain number of repetitions of hitting yes before you start trusting auto mode. And you have to have a certain number of repetitions of you know, seeing automatic code review catch issues that you wouldn't personally have caught before you start caught trusting automatic code review, right?

SPEAKER_01But I think eventually you do realize, yes, I can trust the automated steering, but I'm still going to keep my eyes on the road, right? Like, but that's very different than you know gripping the steering wheel tightly, right? Like, so I I think you know, we have a tendency as human beings to micromanage. We have a tendency to assume that we will always do a better job than the robots, and I think that that is that is the mistake, right? Like I think I think the mistake is overtrusting your ability to make decisions under time pressure and stress. Um and I think that that's a situation where a robot that never gets tired uh will do a better job than you.

SPEAKER_00Yeah. And of course, if something does go wrong, is it the is it the robot's fault or is it the operator's fault? Now, Honeycomb's AI values uh state if your name's on it, you own it. So tell tell us a little bit about how far that extends.

SPEAKER_01I don't think it's about fault. I think it's about whose responsibility is to clean up and to think about how do we harden the system so this doesn't happen again. Right? Uh, you know, if we're talking about um, you know, some kind of failure that leaks out to production, well, number one, ideally, something going wrong should not bring down all of production. We should focus on making the failures smaller in blast radius rather than um rather than trying to prevent them from happening entirely. And then I think in terms of the accountability, right, like the main thing is to is to say, right, like, you know, not you know, the robot did it, you know, it's not my fault, the robot did it, right?

SPEAKER_01Like, you know, Claude did it is not a really great excuse, right? Like instead you have to examine and say, okay, what are my structural biases that caused me to to overtrust in this output, right? Um so actually, there's an example this this past week uh where I was doing some analysis um of a chains that we were rolling out, and I was trying to do the analysis A B tested by uh which shard or which partition ID. And for some reason, uh my AI assistant did not find the telemetry field for partition ID.

SPEAKER_01And then it's confabulated this you know thing about how we need to uh construct uh can construct a new telemetry field for partition ID. I should have rerun the query and and actually typed partition ID to see whether it automatically dropped out. I shouldn't have trusted the AI assistant when it lightly asserted there was no partition ID field, right? But then also, my accountability, I told it, okay, if you're missing the partition ID field, then we need to go and create a pull request to add this add the partition ID field. The field was there all along, right? Like, you know, so I wasted some tokens, I wasted five minutes of a principal engineer's time to review the pull request that would have added a duplicate partition ID fields, right?

SPEAKER_01Like, you know, where you know, you could you could say, you know, you know, blame quad, or you could say, right, like, you know, I should have been more skeptical about this output, like, you know, surely we should have had partition ID. I should have known that we, of course, we had partition ID in there, right? Like, I should have run the query by myself before I trusted this, you know, robot that said, you know, there's no partition ID field, like we need to we, you know, we need we need one. And I was like, right, like, but I signed off on it, right? Like, that's that's my responsibility, right? So I I think that's that's what we mean when we take about take talk about taking ownership.

SPEAKER_01Um I think there are more mundane um things beyond beyond code, right? Like, for instance, don't send someone a slop bomb of, you know, this is you know a 10-page 10-page clawed artifact, right? Like I I I think that that's you know a little bit more more self-explanatory of if your name is signed to it, you should you should stand behind it and you should ideally have spent as much time reading over and producing it as the reader is going to take to read it. Um but I think I think the more interesting thing is as we're talking about here, right? Like, you know, what happens when code that you ship is wrong for whatever reason, right?

SPEAKER_01Like, how are we encapsulating the learning so that Claude doesn't make the mistake over and over and over again, right? Like it's it's us humans that have to figure out how do we more effectively use these tools.

SPEAKER_00And as AI practices, let's say, rather than models, get more uh developed so that we will get to a stage where you know AI can fully build, test, review, and and and deploy changes potentially small, potentially non-complex and maybe non-critical systems. Um at what stage would a human who hasn't done hasn't been involved in any of that, at what stage would a human own that?

SPEAKER_00Would it would it not be fair to say if that at that point Claude's name's on it, let's say, or Codec's names on that, it should own it? And we essentially say we are happy that a very small percentage of these will be wrong, but it's at the bot that effec effectively owns that delivery through to production.

SPEAKER_01Yeah, I think at that point it's the human team that creates the workflow files that guide that loop that are responsible for the quality control and checking of that loop and the tuning of it to make sure that it is more as effective as it's supposed to be. Despite what you might be seeing in the news, there is not actually fully automated recursive self-improvement, right? Like there is always some degree of human guidance involved. So even if robots are coming up with tickets and solving the tickets and pushing them to production and debugging them in production, there is still a person that owns the system prompt for that.

SPEAKER_01There is still the person who is paying for the quota for that, there is still the person that expects results from that, right? And I think that that is where the ownership lies is to go and spot check some of those pull requests every now and then, to do evals, to tune the system prompt, right? Like, I don't think that we are at a point yet where we can say we're just going to go, you know, fully hands-off.

SPEAKER_03Yeah.

SPEAKER_01Sure, if you're down to go fully hands-off, hand me your checkbook, please. I I will I will take your checkbook, right? Like, but as long as humans are paying for it, humans have the right to inspect the results.

SPEAKER_03Yeah.

SPEAKER_01I think that's what it boils down to, right? Like, is there is still a process owner.

unknownYeah.

SPEAKER_01And that process owner is accountable for the results.

SPEAKER_00Yeah.

SPEAKER_01No, nicely said.

SPEAKER_00It's uh it's what what are we recording on the 22nd of September today, Liz? So we're we're kind of giving away a little bit about the behind the scenes here. But on the 22nd of October, Hacktoberfest is right around the corner. Um, now, of course, in years gone by there have always been some problems where you get you know bad human pull requests which have been raised and and mass created uh which have have annoyed maintainers. Now, today's problem, and of course, you know, that that was largely fixed by having an opt-in style of Hacktoberfest, but today, even if you opt in, probably a bigger worry is someone's just gonna come up and provide some AI slop pull request.

SPEAKER_00Um now, one of the things that was kind of partly mentioned previously is that you were considering eliminating external contributions to open source projects because of the kind of floods of pull requests that were very slop-oriented. Um have you made a decision in around that or any experiences recently uh in and around that space?

SPEAKER_01Yeah, so I do think that for security reasons and a variety of reasons uh related to code style, maintainability, I think that maintainers definitely should continue accepting bug reports. Whether maintainers accept pull requests is up to their discretion because it turns out with a well-ecrypt bug report, you can have your agent write a fix for it in your preferred style, right? So why should you trust someone else's agent where it might be just as much work to check the work over as if you had done it yourself? So I think that's kind of my first thought is bug reports always, always valuable as long as they're well formatted that say exactly this is what I expected to happen, this is what actually happened, this is where I think the problem might be, but not necessarily proposing a fix and leaving up to the maintainer's discretion.

SPEAKER_01Um I think the other thing is not relaxing our standards, right? Like we should not have lower standards for AI-created pull requests than human-created pool requests. And also, I've seen efforts both in the academic space as well as in the open source and commercial space to actually require someone to complete a quiz about the work that they've submitted before they actually get a chance to submit it. So if you cannot answer basic questions about the pull requests that you've that you've submitted, you probably shouldn't be submitting it because you have no idea what's going on.

SPEAKER_00Yeah. The I am not a robot button, I suppose, for a pull request.

SPEAKER_01Right, like the the the I am not a robot button, where actually, right, like this is the funny thing. You're using slop to fight slop, right? Like you can have an agent take the pull request and create a quiz about it that you must pass before you can have it submitted, right? Like, and I think right, like you know, yes, as you say, you know, right, like you can triage them with AI, right? Um also a very interesting thing. Um, so my wife works on Google Chrome Security, and one of the things that they're starting to do is they're starting to require that in order to get fast-tracked for your uh security exploit bug, you must provide a working reproducer.

SPEAKER_01You must provide something that provides evidence that you crash a Chrome process. No crasher, no triage, right? Like, because otherwise you would have to deal with all of these slopes. But if you have something that genuinely crashes the browser, right, like that is clearly a sign that you are on to something real and we should go and invest resources and debugging it, right? So so right, like I think that there are heuristics that you can apply to open source contributions. And you know, right, like Linus Torvalds came out in favor of using AI, right? Like Linus Torvald said, you know, I think that AI agents have a valuable role to play.

SPEAKER_01And literally this past week, um, I have a dev box um that's a ARM64 box that has an unconventional hardware configuration, let's let us say. And that uh dev box has a bug that prevents it from booting on Linux 619 and newer. And I was able to, with help, with Claude Fable's help, uh, actually figure out what the bug was, figure out what a pet what a working patch for for it was. And the patch was only six lines, right? Like it's really not that complex of a patch, but I was the first one to run into this situation, and it solved a general problem for like a variety of classes of hardware.

SPEAKER_01So I submitted it upstream and it went through the normal Linux vetting processes. It took over two months to land, but it did eventually land, right? Like I think that's a sign that things are working as intended, right? Like that a genuine patch that is small enough to review, that has good enough justifications, can land regardless of whether it's by you know by humans or not.

SPEAKER_00Yeah. If we uh if we're restricting open source contributions to bugs only, though, versus you know, the the the larger, more directional changes that we might with with uh full features, what what does that mean for open source?

SPEAKER_01Non-maintainers should not be suggesting large directional changes without discussion with the maintainers first, right? Like that is the source of the slop bombs.

SPEAKER_02Yeah.

SPEAKER_01Just because you can do something and send someone a 10,000 line pull request does not mean you should. Talk to humans first and get approval, and then you know, at that point you're proceeding as if you were a trusted maintainer on the inside if you've gotten sign off on your plan.

SPEAKER_00So the path is issue first. Long discussions or if it's obvious short discussions with the maintainers. And from that point, uh you probably have enough credibility just through though through that uh discussion to be able to share uh a pull request. Right, because the maintainer is connects in what you're trying to do. Yeah, excellent, excellent. So so open source has a bright future.

SPEAKER_01I think that it has some structural problems. Um I think there is that question of who is paying for all of those tokens for automatic review and triage, right? So I think that there is the challenge of when you've got a million developers out there who are all paying for a heavily subsidized$20 a month uh open uh open AI or Cloud or Gemini subscription, right? Like you have to prevent those people from denial of servicing your main open source maintainers. And for critical projects like Linux kernel or Kubernetes, right, like the Linux kernel has a uh automatic review bot called Sashiko, and Sashiko is fully paid for by Google, right?

SPEAKER_01Like, which is great. So I think corporate sponsorship helps, but I think that there are smaller uh projects that receive less commercial love that are really, really struggling. And you know, certainly there have been efforts to do outreach to them. For instance, Anthropicus Project Glasswing, which gave access to mythos to a bunch of very security critical projects like curl and openSSL, right? Like, but I I think there's kind of this broader problem of who pays for these tokens and how do we make sure that open source maintainers are resourced and they don't burn out.

SPEAKER_01Yeah, I think that's right, which is the same problem that's always been before. Yeah, I just smell it automatically.

SPEAKER_00It is, it is uh we're we're tripping over all the same problems, right? But at a at a faster rate. Very interesting.

SPEAKER_01And actually, you know, executives have money to spend on it now. That is the difference, right? Like it's previously, you know, telling people yes, you should implement observability, and they're like, budget, what budget? Now it's like you need to implement observability or else your AI effort will fail. Great, here's some money.

SPEAKER_00Let's uh do you know we're a few minutes left. It's been it's been uh wonderful chat. Really, really enjoyed it. But I wanna I wanna end always with the the easiest question, Liz, which is let's talk about what's gonna happen in the next 50 years. Um well maybe not maybe not 50, but let's 50 years, try fifty days. Exactly, right? So so maybe maybe we talk about just two or three years, and let's talk about a role change, or maybe even uh a change that needs to happen in the org around an observability engineer. Do you feel that will still be a role, a standalone role, or a job title in future, or do you think that discipline needs to merge into another role uh that exists today?

SPEAKER_01We've already seen that site reliability engineering, security engineering, observability engineering, these all broadly fall under the platform of platform engineering, as it were, um, right, because they are all cross-functional disciplines that require buy-in of individual development teams, and they do have their own specialized skill set, but broadly speaking, our job is to produce the kind of common standards and tooling that developers need to do their jobs.

SPEAKER_01So I think the great merger into platform engineering is already well underway, right? Like, you know, I mentioned security engineering, accessibility engineering, right, like test engineering, right? Like all these disciplines where, you know, you don't want each developer to have to think about each of these things and be an expert in each of these things, but it is to some extent those developers' job to ensure that their code conforms to our org standards, right? So I think that's basically the the crux of it is observability engineering is not necessarily going to be about building out your own observability platform.

SPEAKER_01There are vendors out there, or if you're sufficiently large scale, sure, there might be an observability tooling team or something. But I think the outreach to developers piece, I think that that is something that broadly gets owned by all of platform engineering, and that platform engineering employs people from a variety of different specialties who all collaborate to bring the expertise to the teams that need them.

SPEAKER_00Yeah, super interesting. And I think, yeah, even back in my days at Sneak, this was a even pre-AI, it it made sense for more and more things to be centralized, particularly around security best practices providing those services. Uh, and I think it it makes sense. Yeah, exactly. Right.

SPEAKER_01Like it's a perfect mapping, right? Like security, observability, um, testing, right? Like all of all reliability. You you don't want each dev to have to be an expert in service level objectives. You want every dev to have service level objectives, though.

SPEAKER_00Yeah, amazing. Um Liz, where can we talked about it a lot, but where can people uh follow up on some of the things that uh that you and Honeycomb have been uh have been doing and talking about?

SPEAKER_01We definitely maintain a very active engineering blog. So if you go to honeycomb.io slash blog, you'll find writing by not just me, um, but also by my colleagues uh uh Charity Majors, uh Christine Yen, and all of Honeycomb Engineering. And you can find me on the internet basically everywhere as Liz the Gray. Wonderful.

SPEAKER_00Uh Liz, it's been an absolute pleasure to chat and uh really and really enjoyed uh going deep in various topics. So uh thank you so so much for your time and uh it's been a pleasure having you on the AI Native Dev. Thank you. Wonderful, and I hope all of our listeners out there enjoyed it just as much as I did. Uh thanks for tuning in and see you on next session. Bye for now. The AI Native Dev is brought to you by Tesla, the package manager for skills and context. Your hosts are Guy Pajani and me, Simon Maple. Our producer is Tom Dowler.

SPEAKER_00The AI Native Dev is not just a podcast, it's a community. And we host monthly meetups at the Tesla offices in central London. Visit Tesla.io forward slash community to learn more. I hope to see you there.

Open the transcript file

Hosts and Guests

Nobody is credited on this episode yet.

Credit the people on this episode

Be the first to rate this episode

More episodes

All episodes
  1. Your Software Factory Needs a Bill of Materials | Daniel Meppiel

    Nov 19, 20261 hr 1 minAudio

    Developers are about to write skills instead of code, and Microsoft's Daniel Meppiel argues the software factory that runs them needs versioning, a bill of materials and signed receipts before enterprises will trust it....

    Credit the people on this episode

  2. Paul Stack: I'll Never Write Infrastructure as Code Again

    Nov 17, 20261 hr 2 minAudio

    Paul Stack helped build Terraform. Now he says he'll never write another line of infrastructure as code, because an agent harness runs his team's production infrastructure instead. Watch all the AI DevCon NYC 2026...

    Credit the people on this episode

  3. Edith Harbaugh: Code Is Cheap. The Last Mile Isn't.

    Nov 10, 202649 minAudio

    Automated software delivery is moving faster than the people who used to approve every release. LaunchDarkly co-founder and CEO Edith Harbaugh tells Guy Podjarny why rollback should be autonomous, why one-shot coding...

    Credit the people on this episode

  4. Maggie Appleton: Agentic Coding Has Outgrown the Text Box

    Nov 3, 202652 minAudio

    Agentic coding has outgrown the text box. Maggie Appleton, staff research engineer at GitHub Next, argues that walls of CLI output and AGENTS.md files serve coding agents far better than the humans steering them. She...

    Credit the people on this episode

  5. Caleb Sima: AI Attackers Move at Machine Speed

    Oct 27, 202655 minAudio

    AI attackers now move at machine speed, while most security teams still move at meeting speed. Former Robinhood CSO Caleb Sima has seen an AI attacker up close, and he argues the only way to keep up is to take humans...

    Credit the people on this episode