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

Dexter Horthy: Why We Stopped Trusting AI to Write the Plan

Sep 22, 202656 minAudio

HumanLayer CEO Dexter Horthy on why his team's bet on spec driven development nearly wrecked their own codebase, and what changed his mind about reviewing AI-written code. Dexter walks through the "YOLO pull request" experiment that ran for months before the codebase became unusable, the "dumb zone" that limits how much context you can hand a model, and why he now believes there will always be alpha in reviewing something. What we cover: - How HumanLayer's "read the plan, skip the code" experiment quietly broke their own codebase - Why context windows have a "dumb zone," and what that means for context engineering - Sean Grove's idea that specs, not code, are becoming the durable artifact - Building overnight agents that review and fix code before a human ever sees it - Why treating software development like a factory changes how bugs compound - What Dexter thinks his advice on reviewing AI-written code will look like in 12 months Chapters: 00:00:00 - Introduction 00:02:15 - Meet Dexter Horthy, CEO of HumanLayer 00:06:03 - The "dumb zone": why more context makes models dumber 00:06:40 - Sean Grove's "the spec is the new code" 00:09:22 - The YOLO pull-request experiment that broke their codebase 00:11:09 - Letting the model own the architecture 00:17:03 - Planning as expected-pain management 00:28:15 - Slop Code Bench and the maintainability oracle problem 00:37:59 - Why software factories aren't like car factories 00:42:49 - "There will always be alpha in reviewing something" Build your software factory, one workflow at a time, with Tessl: https://tessl.co/4ep 🔔 Subscribe for weekly episodes on AI-native development Where do you land on the determinism-to-adaptability slider - plan tightly, or let the agent run? 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_01We wanted to be living in the future, and so we said, Cool, let's try this. We'll just have pull requests but like we'll just say, like, cool, if you read the plan, like the code's not as important. Yeah, we did this experiment. We ran this for like four or five months before we realized, like, oh, this code base is actually unusable now. Like it became slower and slower. The change over here caused a progression over here, and then we decided, no, this is bad. And then we literally rebuilt the whole product from scratch. And the first two weeks of that, like co-founder Kyle was literally in VS Code, typing every, not even cursor, like typing every character by hand to plumb out the data architecture for the new version.

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, Sky Fajani, and me, Simon Mayfor, 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.

SPEAKER_00This June, AI Devon London still helps hundreds of developers, engineering leads, and VPs packed in to hear speakers for my topic. OpenAI, Netflix, and GitHub. Through the hype, and guess what actually works? This November, we're bringing it back to New York. Big up holder full of people actually building the agency 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_00Our early bird pricing ends on September 30th, so make sure you lock in your place before prices increase. As 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.

SPEAKER_03Hello everyone, welcome back to the AI Native Dev. Thanks for tuning in. Today we have a really fun conversation about software factories and how to do them or not do them, and you know, how did we think and we didn't think and all that, and to sort of dig into the timeline and sort of really kind of informed opinions about this, we have Dex Horthy, who is the CEO and co-founder of Human Layer. Hi, Dex. Thanks for tuning in here. Stoked to be here. Uh Dex, you've you've done a lot of super interesting things beyond Human Layer on it, but I think there were these sort of uh 12 factor uh agents that you wrote before trying to kind of codify and explain, you know, how do we how should we build agents on it?

SPEAKER_03Today I think you're sort of starting to refer to like 12 factor factories uh on it. Oh, you got that already? Well, we just sort of know that you've done it. I actually don't know much. Maybe we'll dig into that a little bit on it. Uh and uh and I think also what's sort of super interesting is that you've been sharing kind of strong opinions loosely held a little bit, or maybe like uh changing over time. Maybe they were strongly held but pried out of your hands uh uh over time on it, which uh which I think makes for sort of just sort of good insights and conversations to have.

SPEAKER_03Um so uh thanks for tuning in, and maybe I'll I'll kind of dig into it uh straight away, which is um you've you've sort of changed your mind uh substantially and declaratively around kind of the way to do agentic development of it, uh you know, really around specifically kind of lights off development, right, versus uh versus not. So what happened there? Like what did you believe before and what's the uh what's the uh turnabout?

SPEAKER_01Yeah, I mean the the journey kind of starts around you know uh around when Opus 4 came out. Um and when they launched Opus 4, they also launched the Claude Agent SDK, which means you could use it was it had a very small interface at that point. Right now the Claude CLI is basically like the JVM of agentic coding. It's got like 200 flags on it. Yeah, it's a freaking battleship. Um but uh but it was the first time you could use Claude like small agentic loops as part of a broader, more deterministic piece of software.

SPEAKER_01So we were building like terminal multiplexers for Claude Code of like, hey, what would it look like to build a TUI where you can manage a bunch of sessions in parallel, or like manage, see and get an inbox of like what are all the approvals waiting on you and things like that. And we spent a lot of time trying to get how do how do we get these agents to work for longer? Um, it's very interesting. The the biggest change between summer of 2025 and now is actually like the planning metagame. Um, I don't think a lot of people realize this.

SPEAKER_01A lot of people just write plans because they put plan mode in the thing or they've read something online and they found some skills and hey, we're gonna make a plan. Um, and I think depending on where you are in your journey and like the how the models have changed, I in retrospect I realized that like writing a plan file in the summer in like July of 2025, the number one most high-leverage thing that that got you was it was a really reliable way to get a model to work for longer.

unknownYeah.

SPEAKER_01It was like, okay, we're gonna do everything on this plan.

SPEAKER_03And to kind of follow instructions, I think, a little bit at the time, right? It was uh well, it didn't always follow instructions, but you had uh you also had things like uh spec kit, for instance, who that was trying to like really micromanage uh the uh the agent and sort of like say, okay, not only is this the plan, but at any time, just come back to me at the end of this step and I will spit out the precise set of additional plans that you're gonna do. Uh but I think it got them uh yeah, it got them to sort of kept kept things a little bit on track, or at least more than it was if you didn't plan.

SPEAKER_01And it it was a way to like also like make the work a little resumable, right? It was it was it it was the first version of like first the compaction of intent of like, hey, I'm gonna take this whole thing that I want to build, which could be specified as like every line of code I want to write, yeah, or you could put it into this file as a couple hundred lines of markdown, it's like here's what we're gonna do. And then you could keep that up to date with what was done, what changed, and so you could resume from a clean context window later, which again, also in July of 2025, like the models were not that good at long context. I coined this term called the dumb zone or whatever it was, which at that time was around 100,000 tokens.

SPEAKER_01If you went over a hundred thousand tokens, you got way worse results. Obviously, that number's higher now.

SPEAKER_03Yeah. Although there is probably still a dumb zone, like there's still a there's still a spot in which like I still like I reuse that term on it, and I feel like it has uh it has an element of like you know, like too much focus is no focus, right? You know, when you have sort of too much information in it, then finding the area of attention is still something where if you're intentional about it, by yeah, yourself making the decisions around what's in the context window and what's not, then you can you're more likely to achieve the goal that you're trying to achieve.

SPEAKER_01Yeah. So anyways, getting back to like our journey is like we had just come away from um Sean Grove had given this really interesting talk. I recommend watching it. He was a researcher at OpenAI at the time, and he was talking about basically like the spec is the new code. Um, and this idea that like the way we think about assembly now is the way we're gonna think about code in the future, and the spec will be the thing that is verifiable and executable and compiles into code. Yeah. And that like checking in the code, uh, he made this he has this really good analogy of like, hey, you write a bunch of Java code and then you compile the the jar, right?

SPEAKER_01And the jar goes into production or whatever, whatever your compiled asset is, right? And then you commit the code to the repo. It says in the future, like you'll basically just commit the specs. Um, but right now, all of the interesting stuff from how people were using coding agents in June of 2025 was basically you send a bunch of prompts and then you get your result out, and then you commit that, and then you push that, and that becomes part of production. Yeah, but like that all of the interesting, useful, more high-leverage stuff is actually all the prompts you sent in that conversation that should be recorded somehow, and that like having a long chat with an agent and then throwing away the chat and shipping the code is gonna be the new version of like what if we uh wrote you know a bunch of Java code and then compiled the jar and checked in the compiled jar and threw away the code that we wrote.

SPEAKER_01Right.

SPEAKER_03Yeah, yeah. I think I mean I I very much kind of uh remember that it needs to be sort of held uh frankly, like this conversation is not just sort of past tense, right? Like I think today there's a lot to be claimed, and I know this is very much kind of in your world, which is like those are the very artifacts that you're supposed to be reviewing and discussing and preserving on at the uh uh uh at the time. But I I think so so so you were like touting, okay, we want to do like uh uh context engineering and kind of capture all of these sort of intents on it, but I guess what was the what was the advocacy then like at the time when you were guiding people to say, hey, be amazing with sort of agentic development?

SPEAKER_03Like what is it that that you should do? Uh and I'm and I'm interested because like I I know that you kind of went from like almost it feels like you went from like a context engineering kind of advocate to to almost like uh you know an antagonist to the uh to the group on it, that it's like a little bit more like you really need to be uh uh more more defined and more reviewing, and I've heard you say now that you should review the code for now. So I guess what's the what has changed?

SPEAKER_01Yeah, I mean this thing happens with models as new models come out and get smarter, you you never know when the singularity is, and the only way to like stay ahead is like try to live in the future. And so I said, Okay, this is a thing people are saying might work, and people in the lab, you know, I think there was a thing that was happening last year a lot where it's just like, oh the labs have way more alpha than any of us, so if they say this is a thing you should do, then you should go do it. Um and so the OpenAI said, Oh, this is working for us, then uh then we wanted to try it. We wanted we wanted to be living in the future, and so we said, Cool, let's try this, let's try like we'll still have pull requests, but like we'll just say, like, cool, if you read the plan, like the code's not as important.

SPEAKER_01Um, ton of ton of issues with that. Uh, first of all, the plans contained all of the code that was gonna be written. Uh, and so you would read this plan of every single every single it was like literally like inline diffs. Yeah. Read the plan, and then you would go uh you would go write the code, and then if you didn't read the code, you would basically if you wanted to also review the code because there was drift, or you you know, you were larger, we were three-person startups, so we could have this kind of option. We were pre-product market fit, it's like, okay, go, go, go, go, go, go. Um, but we kind of recommended this to some larger teams, even teams with like 50 developers, then they would say, Yeah, we were hit the plans, and then the person went and did the implementation, and then the implementation would drift, and so they would have to review the code too.

SPEAKER_01They weren't ready to let go of reviewing the code, which uh good for them. Uh, but it was actually they were actually doing more work, they were reviewing basically the same, almost the same shape of code twice.

SPEAKER_03Yeah, depending on the sort of the uh like the detail level of the sort of the spec, but either way, the and combined with like some sort of sense of discomfort because now you're reviewing someone else's code, and so you're kind of uh familiarity and control over it, uh it's oftentimes like harder to apply your opinions uh when editing than it is when you kind of write it in the first place.

SPEAKER_01Right. Once yeah, once once the code is written, you're kind of committed to a path, and it's like much more work to change it to the point where sometimes it just makes sense to throughout the implementation, like drop a new prompt in or a new or redo your plan and then and then go again. Um but uh yeah, we did this experiment, we ran this for like four or five months before we realized like, oh, this is this code base is actually unusable now. Like it became slower and slower. There was like every single change caused, you know, change over here caused a regression over here. I think this is also one of the things we were like, what if we let the model own the system architecture too?

SPEAKER_01Like human in the loop reviewing it. It was like, hey, how would you solve this? Well, well, I'd make a Golang daemon and then I would use a Unix socket, and then I would connect these things, and then when we run the MCP, we ended up with this like system of like six different services where you have like a desktop app that talks to a socket over Rust, and then that that's like a Golang daemon on the back end, which then launches and manages Claude code sessions, which then launch MCP servers to handle the approval system, and then those MCP servers call back to the like front end and like put things in a SQLite database via Unix socket, and then that shows in the U and the user approves something that goes back to the MCP, back to Claude, back to the Golang daemon, and back to the UI.

SPEAKER_01It was just like this incredibly complex system that the models developed uh if you if you let them decide how it should be architected.

SPEAKER_03How much is that though? Uh how much is it that the models don't know how to do it versus you just sort of saying like, hey, figure out an architecture? Like how much of that can be prompted? And I know we're sort of still in a little bit of like a past tense, so maybe some of this like we need to talk about like a current perspective on it. But I think there's a difference between saying, hey, models can't architect and models can't architect yet, or they can't architect if you don't give them enough guidance.

SPEAKER_01Yeah, and I I think I think like fast fast forwarding a little bit, so like we ran this experiment and then we decided no, this is bad, and then we literally rebuilt the whole product from scratch, and the first two weeks of that, my co-founder Kyle was literally in VS Code, typing every not even cursor, like typing every character by hand to plumb out the data architecture for the new version. Yeah, exactly. Um But I'm really glad like those those patterns have stayed really, really solid, and like especially if you're starting a new project, the decisions you make early on just constantly cascade into the future.

SPEAKER_01And we've we've changed some basic things, but the core ideas behind it are still really strong, and we built on like Electric SQL and durable streams and have this kind of unidirectional data flow uh where like clients don't have to like there's no signaling logic from the back end and there's no like signal receiving logic on the front end that's all just handled by the sync engine, uh, which which was a much better way to do it. And I think any any piece of software built today should use like a real-time sync database where clients can just like connect and and get updates live.

SPEAKER_01Um but uh anyway, so we we basically were like, okay, we need to read the code, we need to understand the architecture, and then also like there's so many slot patterns that get in and that these models will left unattended, will create a system. I don't know, there was this thing, I think it was Donald Knuth or one of these like OG like C language guys had this had this uh had this sort of uh principle that was like uh in order to debug code, you need to be like much smarter than you were when you wrote it.

SPEAKER_01And so if you write code that is like the smartest code, the most clever thing that you can come up with, you are by definition not smart enough to debug it. And so the thing you're building always has to be more simple than than than than your actual peak uh peak intelligence, uh, which I don't know, I think just in the news last week was like Steve Yege, who spent the last year running around every podcast on the internet and saying, like, hey, uh, and I love Steve. Steve's a fucking brilliant guy, uh, a huge fan. Uh, but I am gonna call him out for going running around the internet and telling everybody, hey, if you're still trying to read the code, you're not gonna make it, and uh like just let the models cook kind of thing.

SPEAKER_01Uh and then last week kind of said, Yeah, I used Fable to build this thing, and Fable made a system so complicated that it itself could not debug it, and you really have to keep an eye on these things and like understand the system you're building.

SPEAKER_03So, so the sort of the counterargument to this, like I I I I kind of understand and I I relate, and we sort of still have like a Tesla as we sort of build, and we are sort of a team of sort of 20 odd people on the engineering side. So, you know, we do need some sort of supervision by the way, like still compliance systems require kind of a name to every sort of code review and all that. So we have a lot of like um uh AI-assisted code review, and some changes are allowed to sort of go autonomously, and there's some supervision of complexity, et cetera, et cetera. Uh so I wouldn't sort of say, hey, entirely lights off.

SPEAKER_03But I think the the counter argument to reviewing the code is is that you're stuck. That you know, when you when you uh review the code and you apply uh a change, right? Or you sort of you know give more specific instructions or open VS Code and actually kind of handcraft you know some sort of portion of it, then what you're not doing is you are not building a mechanism or a system or an automation that enables the creation of code that is that is to your preferences, right? That is, you know, when you talk about those specs, like I I always think of specs as this kind of this slider uh between determinism and adaptability.

SPEAKER_03You know, it's sort of like how many degrees of freedom do you want to give the uh the the LLM, the agent, uh, to to build with, like these are the decisions that you have made, and and within those you should be allowed to play, or like where you're enabling the agent to play, and you need to define the sort of the outcomes that you want to see out of it, and you should be comfortable with sort of not caring as long as the outcomes are are achieved. Uh and so if you're if you're kind of building towards that, um you would um like to achieve that result, you have to codify your intent.

SPEAKER_03And the way that you would do that is not by reviewing the code, but rather by continuously interacting uh with the system.

SPEAKER_01There's like a balance to it, like this idea of like plan before you build, like the only reason to do planning or alignment or whatever it is, whether it's you and the model or you and the model and your team, is like because you have this factory, and this is pre-AI, right? But there's all these pieces, and I've I've talked about this before, so I'm not gonna go in depth on this, but you have people making stuff, and then someone builds it, and then you have a review thing, uh, and then you have a rollout and you have monitoring and you have all this stuff. But basically, this idea here is like what people learned 30, 40, 50 years ago is that this build step is like can take hours or days, and the review step can also take hours or days.

SPEAKER_01And so we as humans before AI, we're like, okay, we're gonna talk about the architecture, we're gonna do the sprint planning thing, we're gonna align with everybody on the team to make sure that this is at least directionally correct, in the hopes that we can decrease the chance of rework and reduce the review time. Uh, because if we talked about it ahead of time, and we've all done this, everyone's read a perfect PR where they're like, yeah, we talked about this for an hour, and now this thing is a thousand or two thousand lines of code, but I I it's it's following our patterns and everything is correct, so it's easy to review. When people say we are drowning in PRs, we have too many PRs. My pushback is like, no, you don't have too many PRs, you have too many bad PRs because you're letting people turn off their brains uh when they're coding.

SPEAKER_01Um, and so like the the other side of this though is like you don't want to overplan, right? So like I can YOLO a two-sentence prompt and there's a 50% chance I'll have to rework it. I when I say rework, I mean like I'm gonna go back and forth with the model a couple more times. Please don't YOLO a two-sentence prompt and not read the code and send it to someone else to review. I'm assuming you're gonna actually repolish it. Um or you could like hand write a detailed spec. You could sit there at a meeting and spend a bunch of time and spend five five hours writing a spec. And maybe now there's a 10% chance. You may still have to change some stuff, but um but like it's it's less.

SPEAKER_01Or you could do the extreme of like write all the code by hand, uh, and then there, well, there's a zero percent chance you'd have to rework it because of something the agent got wrong because you wrote it. You may still have to rework it that we've had code review for you know 30, 40 years, but um it's it's you're not gonna have to change it because of something the agent because you left the agent some uh some some leeway to uh to to make decisions on some of the smaller details. And I I think about this in terms of expected pain. Like, what is the chance you'll have to change uh something later and how painful is that?

SPEAKER_01Like I never argue with a model about like how what color a button is gonna be, or something like that, because I know that if it's not the color I like, I'll just send one prompt and it will fix it. But if like the database schema is wrong, then we're probably gonna have to throw it out and restart over. And so I want to get aligned on that first.

SPEAKER_02Yeah.

SPEAKER_01And so the idea is like you have to build this intuition of like based on the size of the thing and the complexity of the code base and how good the code is today, and how many bad patterns are in there that the model might follow. Like, where do you want to land on this curve? And that's that's what I think about like today. Planning is all about leverage. How do you find the sweet spot for the task? And you're gonna get wrong sometimes, that's why I say like get a lot of reps. But this is this is kind of how I think I think I think it's similar to what you said, but just kind of visualized in terms of like what are plans for um is to is to kind of at every stage of your human layer.

SPEAKER_01We have a bunch of different planning workflows. We have like just do a design doc and then go ship it. We have like design and then the order we're gonna do it. We have like a PRD flow that's like three or four stages, but depending on the size of the feature, yeah, you want to have one or more stages where you are just like slicing off 50% of the potential bad outcomes. You're narrowing the outcome space in a way that is like a good use of your time.

SPEAKER_03Yeah. I think um, well, I have a whole bunch of like uh thoughts on it. Like I think you know, direction we're sort of aligned on it, like you have to control a little bit the uh or you have to decide what you want to control for and what do you not want to control for on it. Um one uh I have a set of questions here. One is like how much of that planning uh is around kind of guiding the decisions versus expressing your intent? Because I think when you're when you're when you're planning, you say, well, I want the architecture to be like that. And implicitly it's well, because I want to make sure that it you know scales cheaply.

SPEAKER_03I want to make sure that it is you know resilient to like uh additional kind of uh whatever data fields on it, you know, whatever it is. Um but you don't say that. You sort of say, I want the architecture to be like that. Uh, and so you're you're you're sort of limiting to your own creativity of how you would implement, but you actually never capture your your kind of actual intent of why is it? It's one of these, you know, ask why 17 times uh to to get to it. So I guess when you're when you're going through that planning, how much are you trying to extract and do you separate the uh what do you want to achieve versus how the implementation should look?

SPEAKER_01I mean, I think there's a reason why Matt Pocock's skills and specifically like the grill me skill has uh the most it's in like the top twenty five stars on any GitHub repo of all time, and it's like the top. Three stars on GitHub for repos that like mostly just contain skills is because like people are bad at specifying their intent. And uh and I think the the a good AI assisting assisted planning process involves like having the model get enough context to understand what's going on and enabling a user, the fastest way to get a good description of your intent is to just like off the cuff say kind of what you want.

SPEAKER_01I'll turn on voice mode and I'll ramble for 60 seconds, and the things I know I want, like, oh okay, we're gonna this has to scale to end users, or this cannot use this pass that has to use this, like it has to use Redis and not the Postgres database because I know the speed like anything you know you should specify. But the the the onus of like, hey, I need to sit there and just like think for six hours and decide exactly what I want, can it's it's much easier and much faster to be able to take a very rough, like large, unspecified thing, under specified thing, and use AI to you know relentlessly interview the user as as to hey look, here's what you asked for, like here's some alternatives, are you sure you don't want these?

SPEAKER_01Or like, hey, you asked for this, but there's a ton of open questions there, like here's what I think they are, and like walking down that decision tree. Yeah.

SPEAKER_03So I think when you're when you're so I I think we're in agreement over there that you you like it's hard to extract sort of things out of it. But when you when you think about like reviewing the code and uh and the likes, I guess what I what I struggle with a bit is this uh okay, like if you extracted the intent correctly and you have defined your kind of verifications correctly, right? You you know what you're looking for, which are are are both big ifs, they're both hard to do uh on it. Do you still need it? Like the models are getting pretty good, you know.

SPEAKER_03Let's put aside, you know, that is hard to do, let's put costs aside for a sec, right? Like let's assume you can kind of iterate and you can define because you've defined what good looks like on it. Like, do do you think like is it uh what's the limitation over here? Is it is it actual like models are just not good enough uh yet, in your view, or is it uh an I don't know if you have like a guess as to like when would they be? Uh or is it uh or is it more uh or is it something else, you know, that it's like uh that that is sort of that that like that causes you not to sort of say like what you really need to do is like invest in the capturing of the intent and the verifiers, and instead you're saying you should review the code.

SPEAKER_01I I there's like this there was this post from the Haskell community like six months ago that was like a sufficiently detailed spec is code. It's indistinguishable. Yeah.

SPEAKER_03But those are like they are implementation specs. Like these are they're talking about cases in which I am dictating an algorithm to you, right? Yeah.

SPEAKER_01And so yeah, if you give I mean the the the reason why I think specs are so powerful and people maybe get a little bit like one-shotted by a good spec with verification is like if you give the model a good way to get feedback on what it's doing, uh, and to like a hail climb against some objective that it itself can measure, whether it's qualitative or quantitative, yeah, um it will move mountains for you. And it's a again, just like plans were a great way to get a model to work unattended for longer. A good spec and good, we call it like back pressure, right? Is how do you give the model the ability to get feedback on what it did without a human having to do that part?

SPEAKER_01Yeah. Um, you can get a lot more done and you can do more in parallel because that thing's gonna go work for two hours and go kick off another one. Right.

SPEAKER_03I think the so I think I I I think that I'm entirely aligned with. So like I think the difficulty as I interpret what you've sort of said, and sort of maybe like a bit of like uh to my sort of self-view over here as well, which is like in a perfect world, you'd be able to express intent very well, and you'd be able to express uh your verifiers, right? Of like how is it that you would verify that it's right very well. And when you do, you don't need to review the code. Like if you're if you're able to do that, then you will achieve uh something in which you can allow autonomy, right? Like what is the level in which you'll allow like what do you need to see to be able to allow autonomy?

SPEAKER_01Yeah, um, I mean I I think it's a great way to kind of like prototype and understand what's possible. Like I'm working right now on just a little experiment, and I don't actually think this is like a good there are I I'm working on a like code search harness basically. Um and I know like Tejus at Morph LM built a custom model just optimized for code search um called warp prep. But what I have been working on is like a code search harness for Jev. Um so like can you get Jeb to select the next correct action?

SPEAKER_01Like basically using Jeb's classifiers as tool calls of like cool, next I want to read this file, or the final answer of like, hey, yeah, now we have enough context to answer the question or whatever it is. And the problem is Jeb only has a 32k or 64k like input context window. I forgot, I think 64k is some asterisk on it. Um but um that means that you cannot put an entire code base in there, right? Uh, or you cannot say here's all the information we have so far, and so you have to get really creative about how do you split things up and how do you merge them back together, and so I'm kind of taking like an evolutionary algorithm sort of approach of like, hey, cool, go do a bunch of subagents, have them try different things, try them hill climb different dimensions of the Pareto frontier for cost and speed and accuracy and 45 different code search evals right now and more coming.

SPEAKER_01Um I'm not reading any of that code. Um and if it actually works and if seems good, then I will probably like take the like root of it and be like, cool, like explain this algorithm to me, turn that into a spec, and then re-implement that with actual like clean architecture, because there's just slop everywhere right now. Like the code is just like doing all this crazy regex matching and splitting, and uh so I I think I think not reading the code in order to prove what's possible and to prototype is is very feasible, but I mean I think everyone says, I don't know, there was this thing that people said in like the Sonnet 3.5 Opus 4 kind of days, which was like, yeah, sure, the code is slot, but I'm not gonna read it because like by the time I need to fix it, that'll be GPT-7's problem.

SPEAKER_01And the challenge is like, folks, we're at GPT-6, and every really good builder I know has mentioned that like like you know, Astra got much better at computer use, it got much better at video game slot, it got much better at Blender, but it didn't actually get that much better at writing code that is maintainable. Um, and I think this is because uh to train a model at something, you need RL environments for it. Uh and to have a good an RL environment, you need a Oracle. You need a thing that can verify whether the product meets the needs of the user.

SPEAKER_01And maintainability, you don't find out something is unmaintainable until two months later. Uh there's no fast oracle for software maintainability. Um, I think is uh I was riffing about this with Addy Osmani, who was at Google for a while, um, and that was kind of his take. It's like, yeah, maintainability has no fast oracle, and it doesn't seem like there was this benchmark. Have you heard of slop code bench? I'll give you the very high, very high level, which is like you give a model a code base, you give it a challenge, you say, hey, go go write this feature, and then you have the code base, and then you say, Cool, now go write this feature, and it has to inherit its code base at every step.

SPEAKER_01And it's like, now go write this feature, and like basically what the benchmark shows is one, it's very undersaturated. Like, I think GPT-5.5 in May got a 14.8%. Uh, and they're getting ready to publish the results for Astra. Uh, I think uh I was helping them run it with some inference and stuff, but like um it's not my benchmark, by the way. This is like our lab out of University of Wisconsin. Uh but we've been like, you know, providing providing runs and doing stuff like this. And Astra got in the first run we did was like 16.3%.

SPEAKER_01So like the models are getting better in this dimension of like, can they maintain a code base over time? But not as fast as everyone thinks. Like I said, we said GPT-7 would solve all of this. We're GPT-6 and like we are getting we are RLing and hill climbing in other domains, but like the frontier of like model maintaining code base over time does not appear to be getting better that quickly.

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_03Alright, back to the episode. I love this conversation, I think about this all the time. Uh I feel like the counter-argument to an extent is sort of this notion of sort of of maintenance agents, right? And I I think in general, like through the TESL journey, right, we started talking about sort of spec-centric software development, spec-driven software development, and then we moved into this sort of context and skills. Uh and to me, the the sort of the premise of that evolution was that uh is maybe the acceptance that when you think about an amazing developer on your team, uh they're not amazing just because they know what you are building, but also because they understand how you are building.

SPEAKER_03And really, to me, context is sort of the breadth of it, right? I think like you look at skills, for instance, they will have, I think, three primary categories. They will have uh uh specs, which are more about like how does your product or another product work on it so they can build it. They will have um um uh uh uh workflows around how do you want to sort of perform you know some action on it, and then they will have opinions, they will have policies, best practices, and like choices where it's not necessarily correct or incorrect, but it's just your choice. We got in the room and we agreed this is our security policy, right?

SPEAKER_03This is our sort of uh uh balancing act.

SPEAKER_01Or we say I I don't know, we had a couple of these at Sprout Social my first when my first gig out of college, and it they they called they just had a list of things. It was like, do not wrap APIs in other APIs. Exactly. Like minimize code's traversal depth. And uh my boss at the time, this guy Alan, crazy smart dude, he had this thing of like three, he called it three copies press hard. Is like at the top of your endpoint, you always have like a okay, log a thing and then send a metric and then do another thing. And every engineer wants to like collapse those into a function, like an abstraction, like send metrics.

SPEAKER_01And his take is just like, no, just duplicate the three lines of code everywhere because as soon as you put an abstraction over it, it ends up like leaking a bunch of stuff and it becomes very complex and it gets a bunch of responsibilities. Just call the three different methods in line. And this is what you do when you go to the car shop or the car mechanic, right? You you you they say three copies, press hard. You write down, you sign the thing, and then one goes to management and one goes to one goes to processing and one one you keep, uh, and they've just figured this out that it's like, no, we're not gonna take one thing and then like make copies of it or whatever.

SPEAKER_01It's just like, yeah, it seems a little weird and archaic, and like, okay, you could be smarter about it. Anyways, yeah, these are the kinds of opinions that like are very hard. This taste that engineers have over five, ten, twenty years. Yeah. We haven't figured out how to put that in a model yet. We just haven't figured out how to give models that that taste.

SPEAKER_03So I guess uh I guess what I'm asking is okay, so you can't put that in a model, and and I don't know if they ever will, because like models almost by definition, they are generic intelligence. The one you use and the one I use are the same. Uh and so even if they are or less smart, they're they're they're the same opinion. You know, they will uh they will run, you know, design is probably the easiest examples of that, you know, like like you might like dark mode or you might hate dark mode, right? Like, you know, you might sort of choose that. And so uh but but you can't put it into the model, but you can put it into context. And so you can define, and if you've captured that, and that to me is another planning aspect, right?

SPEAKER_03Like you've planned how you want to build, and now you can run a whole bunch of uh maintenance agents that would run on that code base that would review code that was created by an implementer agent uh who took in more like uh feature requirements, right? Like sort of requests on it and will ensure, and you codify your taste, your preferences. I guess why isn't that the way to achieve uh a non or a low slop code uh and kind of invest in that path versus reviewing the code?

SPEAKER_01Yeah, I mean I I could see I could see a world where I mean the the way this usually starts is people just add a hundred end up adding one after another after another of like bullet points into their cloud empty or their agents empty, of like always do this and never do this, and then you end up with a bunch of instructions and like most of them don't get followed because it's too much context. And so, like, yeah, you could probably I mean, so we do this thing internally at Human Layer where we have uh deterministic detectors for some of them deterministic, some of them are non-deterministic, but very simple of like we don't like this pattern, the desired end state looks like this.

SPEAKER_01Yeah, uh, there's a bunch of code that looks like that. Yeah, uh whether it's like React Doctor deterministically pulling warnings out or ox aux lint pulling warnings out. It's like every night we have four or five different um people call them agents. It's the same harness with a different user message, basically. Right. Five agents if you if you if you must.

SPEAKER_03Five sort of uh skill-powered workflows or sort of uh prompt power workflows.

SPEAKER_01Exactly. And they run on crons and GitHub actions, and every morning we wake up to five pull requests that make our code base a little bit better along some dimension. Yeah. Um I think the challenge is like you have to know exactly like you said, you have to know exactly what you want. You have to codify all of your opinions somewhere. You probably can't be in your agent's MD. Maybe you can put them in a skill or you can break them up into a set of skills, but the the more opinions you have, the more clever you have to be. This is context engineering. This is always the thing, is like the more clever you have to be about like splitting them up and parallelizing and kind of like orchestrating multiple different things to go do this.

SPEAKER_01Yeah.

SPEAKER_03So I get the point around sort of the need to uh review the codes today because of the limitations. And as I mentioned in TESL, we still sort of review the code. Uh but to an extent, the sort of the bet that we're making in our own internal software factory uh is that really it's all about extracting correctness out of observations. Uh and so what we do is we take today maybe some amount of sort of a risk or burden uh that really forces the process of not writing uh the code and sort of reviewing the code, and then you interact with the systems.

SPEAKER_03There's exceptions to that, there's asterisks next to it, but by default, it has to be kind of a feedback that you provide about what is wrong, you know, as part of pull requests, as part of uh systems, uh, and sort of these sort of continuously uh improving skill-powered workflows, so like these feedback loops that uh that really uh help feedback into the system. And I think there's a good case to be made that today we are uh maybe making more effort in sort of uh in sort of investing and honing those skills uh on the on the sort of the the bet, which is always TBD, uh that it will uh it will uh set us up better, and we're sort of seeing some compounding speed out of that.

SPEAKER_03So I I don't know how uh how you think about that. Uh and and how does that align or conflict with like reviewing the code?

SPEAKER_01Yeah, I mean we are very bullish on this compounding thing. I I think probably like the anti-pattern I see in a lot of orgs, and most of them are probably larger than yours or mine, is is someone gets excited and they say, I'm gonna build the software factory. And they kind of throw everything out and they say, Cool, let me design this whole thing from scratch, and it's gonna have this compounding thing, and we will never have to read the code and whatever it is. And like I think that's uh like any piece of software, the big design up front is like is always gonna lose to the like iterate fast and get 1% better every single day, or what even 1% better every single week.

SPEAKER_01So I think like the idea of having having a process thing is is like you cannot afford to put slop code in your code base because every every time you let bad code in, you are making the entire system worse. People talk about software yeah, people talk about software factories, but the the the there is a big difference between a traditional factory and a software factory, and that like in a factory, if a car comes out of the end of the line and it's bad, like that's cool. Whoever was gonna buy that car or whatever is gonna is gonna deal with it.

SPEAKER_01But like if you ship bad code in your software factory, it degrades every future piece of work that goes through that factory because there's more bad patterns for the model to see. So, like you do want to continually be making progress towards the you have to want to have some ramp where you can make the factory better every single day or every single week. Um, but it's like the the number one priority is like stop the stop the bleeding or or stop the you know, close the windows on the house before you turn on the air conditioning.

SPEAKER_01Yeah. Exactly. Um but no, this idea of like cool, you know, we have humans in the loop whose job it is to make sure that the code is good and that nothing goes into prod or into the code base that is like going to make the quality worse and going to make future quality worse because the agent will see that and think it's okay. Um, but a byproduct, the kind of like exhaust of that process is you get a ton of like real examples that you can use to feed improving the factory and make it a little bit better. Like anytime a human has to put a comment on an agent written PR and say, hey, this is wrong, we don't do it this way.

SPEAKER_01Agent goes and fix it, it's fine. You need to be like siphoning that off. Every time someone sends, even in a prompt, you should be reviewing the session traces, maybe not reading them verbatim, but analyzing the session traces of everyone on your team and saying, where are people getting frustrated? Where are they telling the model they did something wrong, and then figuring out how to improve the entire system, whether it's the base skills, whether it's the code review skill, whether whatever it is, um, so that you know, if you're not getting better, then you're getting worse. And so, yes, I 100% agree on this idea of compounding engineering or or or whatever you want to call it, of you you do always want to be working on the thing that builds the thing.

SPEAKER_01And if you do a good job of this, then you're sliding scale of like you're spending less and less time actually reviewing individual code and more and more time doing things that are going to improve. You're you're basically shifting from like caring about your position to caring about your velocity. Yeah, yeah, from kind of building the car to building the factory, right?

SPEAKER_03You're sort of uh producing that. And how uh so so that's a really good point, though. I think one takeaway from what you're saying is like yes, you should improve the sort of the context eventually that guides the factory and their production, but you should also remember that uh one of the primary, if not the primary context that eventually guides the factory is the actual existing code base. And so if that code base is full of slop, then uh then the reality is that that will be a pattern because the agents somewhat legitimately default to mimicking the uh the uh the patterns that they see that they see within the code.

SPEAKER_03Uh and so if you if you let that go kind of sideways too much, and it's it's sort of a counter a counter view to to uh to saying that tech debt is deflationary and that uh you can accumulate debt today. I mean that would maybe be true if literally every pull request uh that you're creating, you don't take in any code, you just sort of produce it uh from scratch. Uh but that is not realistic because you don't actually have that uh so really good point. Maybe so, going a little bit more future looking uh a little bit and and thinking about what are the artifacts that might stick around.

SPEAKER_03So, like how long do you think code will still be the source of truth? Like we're talking about rebuilding, replacing, editing increasingly, but we still end up kind of capturing the actual decisions uh in the code. Do you foresee that two years from now that is that is still the case? Or do you think new artifacts emerge that are the primary and the code is more like the bytecode that you've produced?

SPEAKER_01Right. Um yeah, I don't I don't want to predict the timeline. I think a lot of people's predictions have been either way too way too conservative or way too liberal. And um, you know, our job is work with a lot of work with you know, Fortune 500 companies, publicly traded companies, you know, large private companies, and like the lot the the the the reason why they love working with us is because we're like cool, like do not mortgage your code base for the future. Like, yes, like there may be like a 1% chance that you miss out on you know some crazy, crazy upside.

SPEAKER_01Um, but we are going to let you move as fast as possible without uh without giving up control or giving up taste. I was at a dinner in San Francisco probably six weeks ago, and um, you know, we were talking about software factories and loops engineering or whatever we were calling it back then, and this question was like, cool, raise your hand if AI is writing 100% of your code. Like everybody, hand up. Raise your hand if you're still reading the code, and it was like 50% of the people. The other 50% have been like, no, I made 70 Linter rules custom by hand, and I I caught every single anti-pattern, or whatever whatever, whatever your approach is that gives you the confidence to ship it.

SPEAKER_01Uh, but then the question came is like, how long until we don't review the code? And I was like, uh maybe one, two years, it's possible that that could be the case. Um, and then there was a really interesting question. I was like, Do you ever think there will be a time when you don't review anything at all? And uh one of the founders there, um who is a veteran of a lot of this stuff, kind of said one of the most interesting things that I think about almost every day now, which is like there will probably always be alpha in reviewing something.

SPEAKER_01We don't know what it is. Uh I can't say what it's gonna be. It's probably gonna change over the next two years. But if you don't review anything, then you're just letting the AI cook and then you're gonna get the Same product, the same email, the same company that everybody else gets. And so there has there will always be something if you want to rise above the median and not just be I think I think like the the generic like token farm of just like hey look yeah we spent tokens and we create value is like very undifferentiated.

SPEAKER_01So I think I think there will always be a place for smart, creative, thoughtful, caring humans to be reviewing something. For now, I think it's still the code, but eventually it might be something else. I don't know when or what it's gonna look like. But there will always be something to review, and there will always be a thing that you can add to the add to the picture.

SPEAKER_03Yeah. Yeah, I think we're sort of seeing a lot of that with the with like a claude presentations. You know, for a while, like uh, you know, everybody was amazed by how how how great it was that Claude like at the breakthrough of like it was creating these good looking presentations, and now every single presentation looks like a claude presentation, and you uh you just sort of yearn for for something that looks a little bit different. Uh but how um uh so so I I agree with that. I I think uh I think you have to differentiate, you have to capture those. I I do muse though about uh a better way to capture preferences, and I uh I think a lot about sort of outsourcing, right?

SPEAKER_03You have a lot of like great companies that have sort of outsourced their whether it's their sort of uh uh sort of software stacks, or even more so like a lot of manufacturing companies, that they don't actually manufacture everything, they design the thing that will be manufactured, someone else is producing it, uh, and so they they really kind of define the outcomes, but they work with these entities. Um I guess does that analogy kind of resonate with you, which is like create artifacts that document preferences, opinions, taste, uh and and for the most part outsource implementation to the agents?

SPEAKER_01Yeah, so two things. Yeah, I think I think um absolutely like people say, oh, the the new moat is taste. I think that's really blurry, but like I do think it's safe to say like the moat you can have is understanding the problem better than anyone else, like knowing what features to ask the factory for, understanding your customers better than anyone else is incredibly valuable still, and that's again that's that's where you're you you can context engineer the agent in a way that none of your competitors can if you understand the problem better.

SPEAKER_03I am ambivalent about taste. Like part of me feels that taste is just a preference that you haven't bothered writing down. Uh, you know, it's just uh like a I'll know it when I see it uh type thing is is um uh is something that just okay, like get the agent to see it often enough uh and it will capture it. Uh it's still it still is a differentiator, like it is still the case that if your written down taste is better than my written down taste uh for some purpose, uh and so for those purposes your product or your output will be better than mine.

SPEAKER_03Uh and so there's still there's still value in it. I still think taste should be codified, and I think still it is I still think that it is the differentiator. Uh but it is uh it's not this elusive human versus AI difference. It's just a it's just a choice, uh choice piece.

SPEAKER_01Um Well, what what about you, man? Like what do what do you think the future of reviewing things or building or factories? Like what what what spicy takes do you have or or mild takes? I don't know. Like I think there's there's there's the market for spicy takes is way too frothy right now, and I actually love a more middle of the road of like, look, yes, I think this is directionally correct, but actually like it's not as crazy as everyone says it is because everyone is incentivized to you know engagement farm on the internet, and you can actually you get paid money if you get people excited about something, regardless of whether it's true or not.

SPEAKER_01But what are your spicy or or otherwise takes on like where this is going?

SPEAKER_03I I've got a fairly kind of uh uh skilled or context-centric view of the of the world. Like I I think the fact that like I think software engineering is a creative uh profession. Like you are creating software, uh, and the fact that it has engineering in the name is a mistake of history. Like it just happens to be that you had to be an engineer, you have to be an engineer to be able to create those. Uh and really what we want is to be able to capture taste and preferences uh and and and balances. Uh and I think those will be the kind of units of code, if you will, uh that you are that you are building.

SPEAKER_03I thought this is my definition of what uh secure is, of what good design is, of what, you know, even the specifics of subscreen, like you can still get granular or not in terms of its preference. Uh and even some elements of like how controlling you are, whatever, whether you're Apple and like you want to design everything down to the sort of the last bit uh and and gram, or whether you're sort of fine with some more sort of generic OEM component in there. Um and so those are your choices, and those units will still be developed in the sense that you still need to know that uh uh which ones you are using and which ones depends on what.

SPEAKER_03And you still need evals and tests to be able to know that when you modify them, they do not regress, and you still need to observe them and sort of see how they work and de-duplicate them and align them when you have multiple team members creating them. And so, like I I guess my belief is that software development would revolve around skills and that the role of code will be will diminish uh over time, that it has to be sort of duplicate. I don't know when it goes away, it's more about uh we've referred to at the beginning of uh TESL, we've had the sort of the notion of a spec and a shadow spec.

SPEAKER_03You know, sort of the spec being the thing that you create and the sort of shadow spec being the capturing of the LLM's decisions. What is the difference between a shadow spec and code? I I don't know. It's like degrees of freedom uh for it. Um and and today you you already do that, right? You already use you know Java and you're delegating garbage collection, and it happens in different ways on different systems, and you don't care because you trust that it is good enough. Uh and so uh so I think it's sort of going into that world. And the the conversation we have right now is really about what is the journey uh towards it, right?

SPEAKER_03You know, what uh and what should you build today so you're not you know left stranded for tomorrow, but that still actually gets you somewhere today, that balance has been tough. Uh yeah.

SPEAKER_01And so I I won't I won't say software engineer, or maybe I'll just say builder, but like as a builder, as a person who wants to create things of value, I think right now your your two biggest bottlenecks are how do I let the model pull as as efficiently and easily and like mentally like pleasant for me, the human, how do I enable the model to brain drain me as quickly as possible on all the things that are my tastes and preferences and things. And then I think I think we're in alignment there. And then if you're if you're still reading the code, there's like a a corollary of what is the fastest, most efficient, most visually effective way for a model to tell me what it has done.

SPEAKER_01Like, yeah, maybe I might not read every line of code. Um, but uh between if I'm reading every line of code now, and someday I'm reading a spec, like between there, there will be, you know, laddering up of like, cool, don't tell me the code, but give me things, give me something that is, you know, 50% faster or 80% faster than reading every line of code that gives me almost as much confidence or almost as much understanding. How can you what are the like patterns where we can leverage how do humans think and understand things to both get that into the model's context as quickly as possible, and then let the model context engineer the human of like what's the fastest way that I can explain to this person what has been done so they can be competent that it works?

SPEAKER_03Yeah, yeah, no, that's uh that's well said. So maybe one last question, a bit along those veins. Um I think the the advice you give today is different than the advice you gave 12 months ago, right? Sort of seeing the the evolution of the surrounding. Um what's your bet on what aspects of your advice will change 12 months from now?

SPEAKER_01Yeah, uh that's a great question. And yeah, there are some things that we got right almost almost 18 months ago that I have not changed, right? Like the context engineering thing I think will always be true. Yeah, first principle. As long as we're using as long as we're using transformer-based LLMs, that's just like the math of how they work, and you will get better quality if you use less context, so you'll always be able to like engineer things to get engineer things to get better results. Um what will change in the next 12 months? I think I spent a lot of time thinking about infrastructure.

SPEAKER_01Um I think the entire software factory, this isn't gonna be like AI advice, but I think the like entire software factory stack will decompose into good interfaces and open components, kind of like what we saw happen in the Kubernetes world in the last like you know, 10 the last decade of like basically like the more open and portable you can make these ideas, the more likely they are to get broad adoption. Uh, and you need a certain amount of momentum to actually become the default solution, just like what happened to VMware, just like what happened with AWS, what happened with Kubernetes.

SPEAKER_01Um and so I I think a lot of these like walled garden, like you can build a software factory entirely on Claude. You can use Cloud Code as the harness, you can use Claude Automations as your orchestrator, you can use Claude, like a managed code sandboxes, manage agent, whatever they call it, as your runtime environment. Uh, and you can kind of do this whole verticalized stack. And I just I I think that the advice I will keep giving people today is like I think DevTools and DevTools stacks are probably gonna stay or become even more open, open source, open protocols, whatever it is.

SPEAKER_01Um and so I would I would encourage people to prepare for that. And uh you can build anything now. Uh don't uh don't totally know about on the code, especially if you're building critical systems.

SPEAKER_03Amen to that in terms of the sort of the open composable systems. I had uh um early on on the podcast, we had uh Matt from uh Netlify, the founder of Netlify, and he uh and he was kind of making this passionate case which I relate to, which is that the web like had elements of it that were sort of closed, uh eventually the sort of the open web won, and I think we're all better off for it. And I think similarly in the kind of the world of agents, the closed ecosystems are very tempting uh because they they naturally align and all the different pieces kind of come together on it, but sort of this belief that eventually open and composable leads to greater innovation uh and greater flexibility for organizations, I think this composability will uh will win over.

SPEAKER_03The ordering that's uh that's a whole different bully.

SPEAKER_01Yeah, what what's what which chips are gonna fall in what order or dominoes, I suppose, and uh yeah, how how much of how much of a lead do these sort of frontier, the factories, the devons, the open AI, the anthropics of the world, how much of a lead do they actually have? Uh and how how it's like for them, it's like they are they're going to war every single day because I I think that open is catching up faster than anyone is ready to notice yet.

SPEAKER_03Dex, thanks a lot for the great conversation here. Super, super fun. And you know, deep insights. Also, thanks in general for like sharing the the whole journey here and the learnings and the practices along the way on it. I think we we learn as a community, and uh you're definitely sort of a chief amongst the educators over there, and that uh is much appreciated.

SPEAKER_01Oh, and thank you, man. I'm a huge fan of you and the team, and you guys were super early to this game, and you have, I mean, Patrick Dubois has like been a fanboy of his since he invented DevOps days in like 2009 or whatever. So you guys clearly have a really good squad, and like I'm excited to see what you guys are cooking.

SPEAKER_03Thanks, and thanks everyone for tuning in, and I hope you join us for the next one.

SPEAKER_00The 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. The 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