# Is Spec-Driven Development Already Dead

URL: https://securitytable.ai/is-spec-driven-development-already-dead/
Published: 2026-07-15
Duration: 2509 seconds
Season: 4
Episode: 15
Hosts: Chris Romeo, Izar Tarandach, Matt Coles

## Show notes and chapters

Can a detailed specification make AI-generated software reliable, or does it simply move the ambiguity somewhere else? Chris Romeo, Izar Tarandach, and Matt Coles revisit spec-driven development and the promise that an agent can turn written intent into a correct implementation. They debate why earlier approaches struggled, whether natural language is enough, and how tests can fail when the same AI writes both the code and its checks. The conversation explores bounded models, the Phoenix idea of regenerating disposable code, and the choice between patching a defect and rebuilding from the specification. The security question remains: if an architectural flaw survives in the spec, what stops every new implementation from reproducing it?

Mentioned in this Episode:  
➜ [React](https://react.dev/)

Chapters:  
00:00:00 - Intro: travel and movie reviews  
00:07:23 - What is spec-driven development?  
00:12:46 - Repeatability and implementation variation  
00:14:50 - How do you verify generated code?  
00:16:10 - Test-driven development and weak AI tests  
00:20:07 - Engineering discipline and historical specs  
00:24:36 - Bounding a model for a specific ecosystem  
00:27:37 - Is spec-driven development already dead?  
00:28:27 - Ephemeral code and the Phoenix idea  
00:29:12 - Patch the bug or regenerate the application?  
00:32:43 - Who is the better developer?  
00:33:54 - What you want versus what you asked for  
00:40:05 - Final thoughts

Follow AI Security Table:

➜ Home: [https://securitytable.ai/](https://securitytable.ai/)

➜ X: [https://x.com/AISecurityTable](https://x.com/AISecurityTable)

➜ LinkedIn: [https://www.linkedin.com/company/ai-security-table/](https://www.linkedin.com/company/ai-security-table/)

➜ YouTube: [https://www.youtube.com/@AISecurityTable](https://www.youtube.com/@AISecurityTable)

## Transcript

**Chris Romeo (0:09)**: Hey folks, welcome to the original, not to be confused with any cheap imitations, of the Security Table Podcast. My name is Chris Romeo, joined as always by Matthew Coles and Izar Tarandash. And they are elated, ecstatic to be here. They're literally jumping around in their video screens.

**Izar Tarandach (0:34)**: Look, I survived to and fro with Air Serbia and, uh, it was an experience. I went to Belgrade and I'm back here to report.

**Chris Romeo (0:47)**: Mm-hmm. You're not our, I guess you're not our traveling correspondent anymore then.

**Izar Tarandach (0:51)**: Yeah. No, I went to Vienna by way of Belgrade and I'm never doing that again.

**Chris Romeo (0:58)**: Belgrade. Where's Belgrade?

**Matt Coles (1:01)**: He got Belgraded.

**Izar Tarandach (1:03)**: Okay. So yeah.

**Chris Romeo (1:04)**: Where is Belgrade? I'm honestly curious.

**Izar Tarandach (1:07)**: It's 2 hours after Vienna. So you come from New York, you pass Vienna, you continue 2 hours and then you come back.

**Chris Romeo (1:14)**: So I have an international travel policy. I never fly over my destination. While traveling?

**Izar Tarandach (1:21)**: Let's just put it like this, uh, self-funding. So I said, you know what, let me save a night at the hotel.

**Matt Coles (1:30)**: And that's the end of that right there.

**Izar Tarandach (1:31)**: And yeah, let, let's stop there. It's not a place to—

**Chris Romeo (1:33)**: So you slept in the Belgrade airport is what you're saying?

**Izar Tarandach (1:36)**: No, no, no, no, no, no, no. But let, let, let's just say that, uh, the lounge was very Do you know that song Nikita? From like that you have like the overview of Checkpoint Charlie and all those like, that's the way it felt.

**Chris Romeo (2:05)**: Took a while to get your bill.

**Izar Tarandach (2:06)**: So you're saying I was afraid I was going to be taken into a trip on a ladder and lose my next connection or something. I've been watching too many movies.

**Chris Romeo (2:19)**: Yeah, probably have.

**Matt Coles (2:20)**: Yeah.

**Chris Romeo (2:21)**: I'm still trying to figure out where Belgrade is. Never even heard of this place.

**Izar Tarandach (2:26)**: Let's just put it like this. My seat, the audiovisual.

**Chris Romeo (2:34)**: Yeah. Oh, I know where you are. Okay. Wow. That was the opportunistic path.

**Izar Tarandach (2:41)**: Yeah. The audiovisual thing.

**Matt Coles (2:44)**: AKA the cheap way.

**Izar Tarandach (2:45)**: The audiovisual. Thing of the, the, the plane had an RJ45 connector slot in it.

**Matt Coles (2:53)**: For an in, not an out.

**Izar Tarandach (2:54)**: For an in. For an in. Yeah. So yeah, folks, glad to be here.

**Matt Coles (3:03)**: He made it.

**Chris Romeo (3:03)**: So yeah, I think you need a new travel agent.

**Matt Coles (3:06)**: For those, for those who might be listening, for those who might be listening, if you're in Belgrade, please check in. We'd be curious.

**Izar Tarandach (3:14)**: Yeah, I mean, and we love you.

**Chris Romeo (3:15)**: I don't know why you didn't go through Kyrgyzstan.

**Izar Tarandach (3:19)**: I couldn't. I don't think that any of my passports works there.

**Chris Romeo (3:23)**: Okay. Gotcha.

**Izar Tarandach (3:26)**: But, uh, no, to, to, to be honest, it, it was a very nice, uh, uh, trip and, and no, no words.

**Chris Romeo (3:34)**: Okay.

**Izar Tarandach (3:35)**: Words. The Air Serbia, the, the Air Serbia, uh, app. Could be vastly improved.

**Chris Romeo (3:43)**: You can say that for almost every airline app though.

**Izar Tarandach (3:46)**: There's really no, no, no, no. There, there are some, there are some that you can actually like until 30 seconds before you board the plane, you can still try and change your, your, your seat.

**Chris Romeo (3:56)**: Yeah.

**Izar Tarandach (3:59)**: Air Serbia says no seat for you.

**Chris Romeo (4:07)**: All right?

**Izar Tarandach (4:08)**: Did you have option— You fly me or you don't fly!

**Matt Coles (4:11)**: Didn't do any security analysis on the app too though.

**Izar Tarandach (4:14)**: Oh no, no, no, no, I was very well behaved traveler. Very well behave.

**Chris Romeo (4:22)**: How long was flight path? Just curious now over 30 hours.

**Izar Tarandach (4:28)**: Let we see uh, 2001 Odyssey In Space, ah... The Hobbit, The Desolation of Smaug, something like 11 hours measured in, in movies.

**Matt Coles (4:39)**: Is that what you're saying?

**Izar Tarandach (4:41)**: Something like 11 hours. Yeah.

**Chris Romeo (4:43)**: Interesting view into the mind of Isar here by the movie choices.

**Matt Coles (4:47)**: Or was that what was the new ones?

**Chris Romeo (4:50)**: What's the newest? 2001: A Space Odyssey, new release.

**Izar Tarandach (4:57)**: I was basically entertained by something as old as me.

**Chris Romeo (5:01)**: Well, I was recently on an airplane as well, on, and the airline that, uh, I was flying on, I was able to watch Hail Mary, new sci-fi.

**Izar Tarandach (5:09)**: Mm-hmm.

**Chris Romeo (5:09)**: Yeah. Pretty good. I read the book. The book is obviously better, which is always the case for everything, but still, well, pretty well done. Only fell asleep for about 30 minutes in the middle of it.

**Izar Tarandach (5:22)**: So it's, it's, it's worth it. Have a lot of popcorn at hand. It's, it's worth it.

**Chris Romeo (5:28)**: Yeah.

**Izar Tarandach (5:29)**: Very different from The Martian, but, uh, like The Martian, you have this illusion that it could actually happen.

**Chris Romeo (5:35)**: Yeah.

**Izar Tarandach (5:35)**: The other one, it's kind of like, so it's like Interstellar then? No, because nobody's trying to explain physics to you. But, uh, it's, it's, it's very easy to poke holes at, and it's very easy to not care about the fact that you are poking holes at. It's Interstellar with the Disney treatment, I think.

**Chris Romeo (5:57)**: Interesting.

**Matt Coles (5:58)**: Okay.

**Izar Tarandach (5:59)**: Like you finish, you finish the movie thinking, where can I get a plush toy of the alien?

**Matt Coles (6:08)**: Okay. So true. So, so kind of like Contact.

**Izar Tarandach (6:13)**: Wait, Contact is the one with— Jodie Foster.

**Matt Coles (6:15)**: Jodie Foster.

**Chris Romeo (6:16)**: Oh yeah.

**Izar Tarandach (6:18)**: Definitely. Totally.

**Chris Romeo (6:21)**: Okay.

**Izar Tarandach (6:21)**: Oh, off the Alien.

**Chris Romeo (6:22)**: No, we're going to, we're going to wrap up the movie review segment of the Security Table and move on to the spec-driven development segment.

**Izar Tarandach (6:32)**: Yeah.

**Chris Romeo (6:32)**: Which that, I mean, if we don't win an award for that transition that I just did there, there should be an award for that because, you know, look, it's a movie in itself, right?

**Matt Coles (6:44)**: Independence Day could have been one aspect of development alone.

**Chris Romeo (6:48)**: You said Independence Day?

**Matt Coles (6:50)**: I did.

**Chris Romeo (6:51)**: Dude, don't even tell me this.

**Izar Tarandach (6:53)**: Which I could have watched actually, but it was too short for my trip.

**Matt Coles (7:00)**: At least it wasn't Martian Attacks.

**Chris Romeo (7:02)**: Mars Attacks.

**Matt Coles (7:04)**: Oh, Mars Attacks.

**Chris Romeo (7:04)**: You're right. That's classic. That's a classic. That is so good. Yeah, we need to— And I went hoping for Minions and Monsters. Those were invented far too many decades after your plane was constructed.

**Izar Tarandach (7:23)**: Yeah.

**Chris Romeo (7:24)**: Okay, Matt, what is spec-driven development? I feel like I've been living under a rock and I don't know what this means.

**Matt Coles (7:32)**: I'm going to probably piss off a lot of people by saying this, but it's bringing back software development to the old days when we used to write specs and then code to it.

**Izar Tarandach (7:43)**: Oh boy, boo!

**Matt Coles (7:44)**: It's the newfangled software engineering paradigm where you write a specification and then you get the AI to implement it for you as opposed to writing a specification and getting the human to implement it for you.

**Chris Romeo (7:58)**: So wait, isn't that what people are supposed to be doing now? Like what are, or are people, I'm very confused. Are people just going to their Claude prompt and saying, do my work for me? And I'll see you after lunch.

**Matt Coles (8:11)**: Pretty much.

**Izar Tarandach (8:13)**: No mistakes.

**Matt Coles (8:14)**: No mistakes. Yes.

**Chris Romeo (8:15)**: You gotta specify no mistakes.

**Izar Tarandach (8:17)**: No mistakes.

**Matt Coles (8:18)**: We need to, we need to find that cartoon that somebody put out. I think they put it out on Reddit about, we're gonna be able to, with Spectrum Development, we're gonna be able to create this description of the system that we want in perfect detail, and then we're gonna get a perfect representation of it. We used to call that code.

**Chris Romeo (8:34)**: Yeah, exactly.

**Matt Coles (8:36)**: I'm sure I didn't do it justice, but that's what he was saying.

**Chris Romeo (8:39)**: There's no world where code was ever a perfect representation.

**Matt Coles (8:43)**: No, no. And there's so many ways of representing things wrong.

**Izar Tarandach (8:47)**: Code was always the perfect representation. The thing is that the code that you got to might not represent the thing you wanted it to represent. But code was always the perfect representation.

**Chris Romeo (8:59)**: Words mean things. The word "perfect" means what?

**Izar Tarandach (9:02)**: Okay, without flaw—

**Chris Romeo (9:04)**: Whatever is running.

**Izar Tarandach (9:07)**: Okay. Whatever is running is running because there is code saying this thing runs this way.

**Matt Coles (9:14)**: Right.

**Izar Tarandach (9:14)**: So the code was always the perfect representation of whatever was running.

**Chris Romeo (9:18)**: Yeah.

**Izar Tarandach (9:19)**: Yeah.

**Chris Romeo (9:19)**: I see where you're going.

**Izar Tarandach (9:20)**: But in your head, you have a system that has its own perfect representation in your head. And what was always missing was the bridge between the perfect in your head, the Platonic idea of the shape of a thing and the code that ended up being the perfect representation of whatever is running.

**Chris Romeo (9:42)**: Gotcha. So yeah, okay. I'm with you now.

**Izar Tarandach (9:44)**: Now to bridge back with our, with our, with the way that we moved from one thing to another. I think that this spec-driven thing is basically somebody wrote a book, somebody read, read the book, wrote a script of the movie, and people are watching the movie and saying, oh, this doesn't look like the book. Because the book always has more details, the book is always more involved, the book is always deeper, and the scripted presentation is always, we got 2 hours and we shouldn't be boring people, so let's put some explosions in there.

**Matt Coles (10:19)**: I mean, so Spec-Driven Development basically is you tell, you describe what you want, and there's varying degrees of specificity, of course, right? You could say, I want a front end to take input and do something with it and make output. Or I want a system that is written in Python and hosted by a React script using this library and that library, and it takes input and it does kind of canalization and input validation and some other stuff, and then it does some math in the backend and then it writes to disk. And expand on those for detail. And the AI, you ask the AI to interpret that in a way that of course AI interprets that and does that iteratively and then generates a set of tasks to do and goes off and spins off that work. And eventually you end up with a thing, hopefully.

**Izar Tarandach (11:24)**: So basically it is, let's take vibe coding, Let's take the vibe out of it, and we are left with coding.

**Matt Coles (11:35)**: It makes every developer an architect. Actually, not even, uh, not, not quite an architect, right? Because they're in part an architect, but it also in part, I don't want to say a technical writer because technical writers do something different, but it makes them write down what they intend to do before they do it.

**Izar Tarandach (11:58)**: It sounds like it is the embodiment of English is the new coding language.

**Matt Coles (12:06)**: Yeah, that's, that's, that's the thing. I, I don't, I don't understand that at all because people have been using non— people can use non-English for AI code, for AI work, because AI understands all of the languages. You're not bound to English.

**Izar Tarandach (12:21)**: Yeah, but I think that they're just placeholder of English 'cause—

**Matt Coles (12:26)**: So language is the new programming language?

**Izar Tarandach (12:30)**: Yeah, exactly. Natural language is the new programming language.

**Chris Romeo (12:33)**: Great, I gotta learn another language? I gotta be able to speak another language?

**Matt Coles (12:36)**: You have to be able to speak naturally.

**Izar Tarandach (12:38)**: Hey, my son is already doing dual language Chinese. No judgment here.

**Matt Coles (12:42)**: You don't even have to understand it to do it apparently.

**Izar Tarandach (12:44)**: True.

**Chris Romeo (12:46)**: So I'm still trying to understand, like, what do I get out of this thing?

**Matt Coles (12:51)**: You don't get—

**Chris Romeo (12:51)**: why am I wasting my time? It's because it's not repeatable, right? It is. It is.

**Izar Tarandach (12:57)**: It tries to.

**Chris Romeo (12:59)**: Yeah, but LLMs aren't repeatable. So I can't get—

**Matt Coles (13:01)**: that's true.

**Chris Romeo (13:02)**: I'm going to get a different result even though I start with the same source document. It's never going to give me the same thing 2 times in a row though, right? Correct.

**Matt Coles (13:09)**: So if you write a spec, you'll get an infinite series of possible outcomes. By the way, you know what that used to look like? You had human developers with a spec and infinite possible outcomes.

**Izar Tarandach (13:22)**: I'm going to have to push back on that one.

**Matt Coles (13:25)**: Okay, please do, because I would like to know if you have two developers who automatically code the same.

**Izar Tarandach (13:30)**: You are getting the possibility of an infinite amount of outcomes, but because the outcome is bounded to a programming language and you only have so many variations that are valid syntax, and the AI has been trained on valid syntax, then you're taking an infinite and you're applying a very—

**Matt Coles (13:54)**: I was saying infinitely metaphorically here because in the broader sense, right? Because if you have 10,000 developers, you'll get 10,000 implementations.

**Izar Tarandach (14:03)**: If you're being metaphorical, then yeah, definitely. But it's just that people have been banding the word infinite lately. Around—

**Chris Romeo (14:09)**: sorry, when you say—

**Matt Coles (14:10)**: I'll be better about my, my boundaries.

**Chris Romeo (14:13)**: Yeah. When you say infinite, there are 10% on either side of the solution that developers have come up with, which are just ludicrous. But yet an LLM may create a ludicrous solution. Oh yeah.

**Izar Tarandach (14:27)**: 'Cause my next segment—

**Chris Romeo (14:28)**: it may recreate all the libraries that it thinks it needs. It may create 5 times the code it needs to sort something.

**Matt Coles (14:36)**: You may tell it to use Python and it'll go off and implement in Ada because it decides otherwise.

**Chris Romeo (14:42)**: Yeah.

**Izar Tarandach (14:42)**: And do not forget that just because it's ludicrous does not mean it hasn't been released.

**Chris Romeo (14:49)**: True.

**Matt Coles (14:50)**: And on top of that, so the other, I guess the other paradigm here is not just you do spec-driven development, but then you tack onto it, you know, how are you gonna verify that what comes out is correct. So you need a correctness check. So you have to implement some sort of testing process as well, right? Because you just have— if you just do speculative development, you're not guaranteed to get something functioning. You're not guaranteed to get something that matches or aligns to your spec. And now you may not get anything that's correct.

**Chris Romeo (15:24)**: I need DAST to check it, what you're saying.

**Matt Coles (15:27)**: AI is the new DAST. That's what you're saying, to check itself.

**Chris Romeo (15:31)**: Keep sending in. Okay. So, so now you're introducing some new piece here though, Matt. You're saying that spec-driven development creates some code and we need something to check the output of the spec-driven development. Is that— and I hate to be the category of things that we've had in the past, SAST, DAST, IS-RASP, SCA, functional tests, unit tests.

**Matt Coles (15:56)**: I mean, we're not talking necessarily security here. Because the spec is not necessarily just a security spec. In fact, if you're lucky, there's a security spec that goes along with it, right?

**Chris Romeo (16:08)**: Do you—

**Matt Coles (16:08)**: or the security as part of the spec, because—

**Chris Romeo (16:10)**: do you employ test-driven development in conjunction with spec-driven development to have it create your tests first?

**Matt Coles (16:17)**: It seems like that's an ideal case. That's a better case than having a test plan implemented after the fact.

**Izar Tarandach (16:25)**: But how many times have you guys seen AIs writing tests that it's basically our return true.

**Chris Romeo (16:32)**: And that's how I write tests too.

**Izar Tarandach (16:35)**: And then it comes and says, I tried everything. And you say, did you? Did you really? Uh, no, you were right.

**Matt Coles (16:40)**: Oh no, you're right. I, yeah, I missed that.

**Chris Romeo (16:44)**: Of course, just like a human.

**Izar Tarandach (16:47)**: No, the worst is I'm so happy you pushed back on that. Oh, are you? Cool.

**Chris Romeo (16:51)**: Yeah. Why didn't you just do it right the first time? Yeah.

**Izar Tarandach (16:54)**: No mistakes.

**Matt Coles (16:56)**: So, and I hate to be that naysayer of, you know, everything AI is new, but really spec-driven development is just bringing us back to old spec-driven development.

**Izar Tarandach (17:07)**: Good times.

**Matt Coles (17:09)**: And it's not necessarily a bad thing because of rapid iteration, right? You can say, I have the spec and I write, it creates something and then, oh, that's not right. And I update the spec.

**Chris Romeo (17:18)**: Yeah, but the challenge in previous—

**Matt Coles (17:19)**: And then redo it.

**Chris Romeo (17:21)**: Spec-driven development is that people didn't really follow the spec. They wrote the spec because they had to have it. I'm just thinking about my history in large corporate environments. You had to have a number of spec documents as part of the product lifecycle because you had to follow them.

**Matt Coles (17:39)**: There was nothing that said, well, you, you were supposed to have, that was the whole like thing about doing ISO, right? Was you have specs that match what you actually write. So you get, you get, you get, if you define it up front and you follow the spec, you get what you end up at the end. And you can do formal verification and all that sort of stuff.

**Chris Romeo (17:55)**: Nobody ever does that.

**Matt Coles (17:55)**: And it never worked. So what we're really doing here is we're bringing it back to 1950s engineering process with AI.

**Izar Tarandach (18:05)**: Yes, but—

**Matt Coles (18:07)**: Hey, we've hit the pinnacle. If that's true, we've hit the pinnacle. But we as engineers, we as engineers define what we want in a precise way, fairly precise way. But that's the thing. We get the LLM to almost implement that in a precise way, and we can verify that. Well, I would say without the almost, but of course, because it has variability, it's no guarantee. But we're getting better because we can iterate on it faster. So really, we've met the pinnacle of engineering practice.

**Chris Romeo (18:39)**: All right, I'm retiring then.

**Izar Tarandach (18:40)**: What do we have?

**Chris Romeo (18:41)**: Oh, whoa, I'm back.

**Izar Tarandach (18:45)**: Remember those times that we We went to, to try to model something and we got the Eureka moment where the architect would, would, would tell us about the spec and how the thing works. And then the junior developer would raise its hand and say, ah, you know what? When we were implementing the thing, we found out that the spec didn't really know what it was talking about because the things that it asked us to implement actually work in a completely different way. So we had to sort of like. The, it accepts the input, it puts out the output, but inside it's completely different. I mean, we all had that experience repeated.

**Matt Coles (19:21)**: So this is, so what you're saying is we've met the, we've met the potential of 1950s engineering practice with all of the problems of the engineering practice.

**Chris Romeo (19:31)**: Well, not really though, because the AI is gonna, it's going to attempt to follow what the spec says.

**Matt Coles (19:37)**: Right.

**Chris Romeo (19:38)**: Or it should tell you, it should give you some feedback to say, this is complete nonsense. This can't be.

**Matt Coles (19:44)**: It won't though. It won't because it wants to appease you. So it's going to try and follow the spec, you know, verbatim.

**Izar Tarandach (19:50)**: It will gladly build a car with the wheels on the roof. But before we actually, we actually, uh, kick it to the curb, I, I want to remind people that what was done in the '50s took, took a bunch of men to the moon and back. Including some very bad things that happened one way or another.

**Matt Coles (20:19)**: So because the specs couldn't account for everything.

**Izar Tarandach (20:21)**: Yeah. But something there worked. Perhaps it didn't work at the cloud speed, but right.

**Matt Coles (20:31)**: That was the, that's the key part, right? It worked at engineering speed where you had rigid, where you had. I mean, if you— aspect-driven development may not work for hardware engineering because of the rigidness and the—

**Izar Tarandach (20:48)**: the rigidness of what?

**Matt Coles (20:50)**: We, we, things worked because people spent time refining the specification, doing the R&D and being rigid about it. Did what I do implement the spec and does the spec address the concerns that I have for when I put this into production. Whereas somewhere along the way, like in the '80s, we like make it work and ship it.

**Izar Tarandach (21:14)**: But wait, wait, wait, wait, wait. Wouldn't—

**Matt Coles (21:17)**: sometimes it was just ship it. Don't even make it work. Just ship it.

**Izar Tarandach (21:20)**: Right. But wouldn't being rigid make it, sorry, easier for an AI to, to implement it because it's giving more guardrails?

**Matt Coles (21:31)**: You mean implement, have a coding convention and a standard and have it only implemented that?

**Izar Tarandach (21:38)**: That I found that it doesn't always work that way. But what about having the wiggle space, which I'm using here as a technical term, the wiggle space.

**Matt Coles (21:53)**: Wiggle space, very technical.

**Izar Tarandach (21:58)**: I'm going to call it the movement variation field, aka the wiggle space, uh, that the AI would have to implement that spec, right? Assuming that I'm not talking about some generic AI, but assuming that you get to a model that you actually get trained with bits and pieces of code that are restricted in the same way. So it doesn't know about all possible Python libraries out there, but it knows that if it has to put two numbers together, then there's only two ways that you can write a equals b plus c or a equals c plus b. So, well, of course you can do all kinds of other tricks, but let's stick to that. Wouldn't making the model limited to the universe that that spec knows about. Create a pipeline that leads from spec to more provable and reliable code.

**Matt Coles (23:06)**: Maybe, but let me ask you this. At what point does it make it— what, at what point would it be just easier to have a code generator where you define the model and have it generate code deterministically against that model precisely each time?

**Izar Tarandach (23:23)**: That's a damn good question. Because we know that for hardware, this is for chips, right? At some point they moved to that approach. You had a very descriptive language, but very bounded, very rigorous.

**Matt Coles (23:37)**: Do you remember UML?

**Izar Tarandach (23:39)**: Oh my God. I try to forget it every day.

**Matt Coles (23:42)**: But you remember what UML was supposed to have done?

**Chris Romeo (23:45)**: No.

**Izar Tarandach (23:45)**: Databases, right?

**Matt Coles (23:47)**: Well, uh, no, classes, classes, classes.

**Izar Tarandach (23:50)**: Yeah, yeah, yeah, yeah.

**Matt Coles (23:51)**: And, and code generation, right?

**Izar Tarandach (23:54)**: Yes. Oh my God. I had forgotten all about that. Thank God. But now I remember and now I have to forget it again.

**Matt Coles (24:00)**: So, so, but at some point, if you train a model and refine it to bound its outcomes, at some point you're going to reach a, reach a well, whatever, on a curve, I don't know, whatever that is, where plateau or whatever, where you, where it may just be easier to do one of these model generation things deterministically, like we, like was promised back in the, in the '80s. You would think. A lot of crap came out of the '80s. I mean, come on, don't be making fun of the '80s.

**Izar Tarandach (24:30)**: The '80s were good. The '80s were fun. I remember the '80s fondly.

**Chris Romeo (24:36)**: So, Izar, back to your example though, Early in your, that, that previous example, you were talking about what sounded like a custom model for that particular spec. Isn't that just, doesn't that just throw the idea completely out the window? Because how are you going to generate a custom model specific to each code spec you're trying to generate?

**Izar Tarandach (24:59)**: No, no, not to each code spec, not to each code spec, but chances are that people using those specs live in a certain.

**Chris Romeo (25:07)**: Ecosystem.

**Izar Tarandach (25:08)**: Ecosystem.

**Matt Coles (25:10)**: And so you have a spec, you want a spec to generate a React front end. You may only train it on web security and how, and user experience and interface design and React JavaScript.

**Izar Tarandach (25:23)**: Yeah.

**Chris Romeo (25:24)**: And then you bound it somehow with a guardrail that says don't create anything other than a React. We don't create anything else.

**Matt Coles (25:31)**: That's the guardrail. The model can't because it only knows those topics.

**Chris Romeo (25:34)**: I see.

**Izar Tarandach (25:35)**: Yeah.

**Matt Coles (25:35)**: You're limiting its knowledge.

**Chris Romeo (25:36)**: But isn't that, isn't that computationally expensive to create that mo— that custom model and update it and maintain it.

**Izar Tarandach (25:44)**: It's actually, I don't think, I think the creation is the creation of the corpus of data that you would use to train that.

**Matt Coles (25:50)**: And in fact, I think there are techniques, I think there are techniques that are reliable for taking models and removing content from them. So in theory, you could take a public model, like a, you know, a 20B public model and remove everything that you don't need. But in doing so, is it really efficient to do that? I mean, I guess if you're gonna create, that's what I'm asking. If you're gonna, if you're gonna create a number of these interfaces, but if you're doing just one, is, is it, is it worth it?

**Chris Romeo (26:23)**: I mean, who does anything at the scale of one though?

**Izar Tarandach (26:26)**: No, it's like doing a lobotomy. It's, it's like doing a lobotomy just to get a person to be able to do one task.

**Chris Romeo (26:33)**: Right.

**Matt Coles (26:34)**: So that would be your web front end, you know, model. And then you'd have a mid-tier model and you'd have a database layer model.

**Chris Romeo (26:40)**: And then you'd have a— Hey, idea for a new company. Name: Lobotomy.

**Matt Coles (26:43)**: Oh, Lobotomy.

**Izar Tarandach (26:44)**: Yeah.

**Chris Romeo (26:44)**: Lobotomy.com. Love it.

**Izar Tarandach (26:48)**: Lobotomizerus.

**Chris Romeo (26:51)**: We'll take a model and we'll strip it down to make it only do one thing.

**Izar Tarandach (26:56)**: Yeah, come with a brain labeled as back.

**Chris Romeo (27:00)**: That's good marketing right there.

**Izar Tarandach (27:02)**: Right?

**Matt Coles (27:03)**: You heard it here first, folks.

**Chris Romeo (27:04)**: Uh-huh. Trademark patent pending. Yeah.

**Izar Tarandach (27:09)**: And paper bunny is— but anyway.

**Matt Coles (27:14)**: Plushies coming soon.

**Izar Tarandach (27:15)**: Plushies coming soon, exactly, of Jodie Foster.

**Chris Romeo (27:18)**: So are you prescribing a world where people use this? Forever, like, let's just say you have a mid-sized company, you've got 250 developers on staff. Is this something that you try to roll out across the entire engineering organization?

**Izar Tarandach (27:34)**: Or like, what do we do with this thing at the end of the day? But let's just open a parenthesis for a second. There is a growing body of people who are already saying that Spec-Driven Development is dead.

**Chris Romeo (27:47)**: Yeah. Great. Something else is dead. Everything's dead.

**Izar Tarandach (27:50)**: It's a non-zero number of people who are saying that.

**Matt Coles (27:55)**: Yep. It's something, there's fact-based, it's write facts, don't write specs, write facts. No, that's not it. That's a different thing. Context engineering is dead also, I think, right? So there's, AI is moving so fast that it's impossible to know these days.

**Chris Romeo (28:13)**: So basically everything's dead. How do we know it's alive? Is there a—

**Matt Coles (28:18)**: It's Schrödinger.

**Izar Tarandach (28:20)**: It's dead and not dead at the same time.

**Chris Romeo (28:22)**: That's an interesting idea.

**Izar Tarandach (28:27)**: But actually going down on the article here, we get to spec-driven development was really hard to communicate to regular developers. What Chad did really well is ground the story in code. Saying that the only difference is that this code is no longer permanent. It's ephemeral and it can always be regenerated from other artifacts. To say that I'm completely lost.

**Matt Coles (28:56)**: I mean, I mean, so, I mean, all right, let's think about this now. Bring, bring it back to the, to the classical engineering approach of you have Spectre in development, you have a spec, you have a spec. That drives development, Spectrum development, and then you find a bug. What do you do?

**Chris Romeo (29:19)**: So it's a regen.

**Matt Coles (29:20)**: Well, that's the question. So do you—

**Izar Tarandach (29:22)**: Open a ticket.

**Matt Coles (29:23)**: Do you patch the bug or do you reconstruct the application and hope that it doesn't have the bug? Now, I, it's an interesting question. If you can write the code fast, if you can write code, bespoke code faster than finding and fixing a bug, which of course may be an architectural flaw, right? And by the way, if it is an architectural flaw, you really need to update the spec because the spec was wrong or imprecise, or there weren't enough guardrails with that spec to implement a proper architecture. But if you have a bug, Is it more efficient to just regenerate the code or to patch the bug?

**Izar Tarandach (30:09)**: But wait, if you patch the bug, you're going to have to regenerate. No, wait, regenerate the code from scratch.

**Matt Coles (30:14)**: Rewrite the code from scratch.

**Chris Romeo (30:15)**: From scratch. Have the AI just try again, but then it's going to create a different bug.

**Matt Coles (30:19)**: It's going to, right, exactly. Right.

**Izar Tarandach (30:22)**: So why do we let people like this close to computers? Why?

**Matt Coles (30:26)**: Why?

**Chris Romeo (30:26)**: Why?

**Matt Coles (30:27)**: Because you have people who don't have computer science degree.

**Izar Tarandach (30:29)**: Why?

**Matt Coles (30:29)**: Because of the democratization of computer science now, right? So this is the whole notion of AI now allows people who don't have engineering backgrounds to do engineering work. It's like having them do security work when they had DevSecOps. Remember, we gave engineers the authority and responsibility without the capability to do security.

**Izar Tarandach (30:51)**: Hey, here's a scalpel, go do neurosurgery.

**Chris Romeo (30:56)**: So you got YouTube these days, you can do neurosurgery, just watch a YouTube video. Yeah.

**Matt Coles (31:01)**: And stay in a holiday.

**Izar Tarandach (31:01)**: Yeah, but only once.

**Matt Coles (31:05)**: Well, your patient will only need it once. Yeah.

**Izar Tarandach (31:08)**: I suggest that people try it on themselves first.

**Chris Romeo (31:10)**: That's true. And that's lobotomy.com. Try that yourself first. All right. So are we in favor of spec-driven development? Are we against it? Or do we just not know?

**Matt Coles (31:20)**: I, it depends if you consider what's he— what are, what, what should you do with all those engineers out there? What is their role? Is their role writing specs?

**Chris Romeo (31:32)**: I think so.

**Matt Coles (31:34)**: Because that's what we're talking about here, right? Developers write specs.

**Chris Romeo (31:37)**: I think so. I think from what I've been talking to some engineering folks who are using AI, it's, I will say it's scale right now. Like they're really using AI to generate code. This is the model that I've heard that high-efficient organizations are going to is really focusing on documenting the spec correctly and then letting the AI agents do their magic.

**Matt Coles (31:59)**: Yeah.

**Chris Romeo (32:00)**: Versus trying to marry the two together in a collaborative approach.

**Matt Coles (32:05)**: Right. So question, does anyone remember during the Agile craze of the 2000s, I suppose, when somebody, I don't know who it was, said the code is the documentation.

**Chris Romeo (32:21)**: Oh God.

**Matt Coles (32:24)**: And now you have developers, those same developers, probably those same engineers saying, hey, I'm gonna write documentation for a living.

**Izar Tarandach (32:32)**: I was in the team that said that if it was hard to write, it should be hard to read.

**Matt Coles (32:38)**: Well, in this case, it would be impossible. In this case, it would be impossible to write because you're not writing it.

**Chris Romeo (32:43)**: So look, yeah. So I guess that, that, that brand, I'm gonna, I'm gonna even, I'm gonna, I'm gonna raise you 25 philosophical points. And say, who's a better developer, AI agent or human developer? Because that answers your ultimate question. If the AI agent is better at taking the spec and turning it into functioning code and creates less bugs and less security vulns than the human does, then yes, the engineer becomes a spec document writer. If not, maybe it's the opposite way around, but that's the philosophical question we have to figure out.

**Matt Coles (33:18)**: Well, and I think the answer is an interesting, it's an interesting answer. How many times, how many iterations does it take the human developer to be perfect or precise enough compared to the AI who can just spit out an infinite series?

**Chris Romeo (33:35)**: You, you're using the word perfect again, so I'm gonna say infinite to both answers.

**Matt Coles (33:39)**: So, uh, let me, let me, I, I, I used, I used infinite before incorrectly. I used perfect incorrect, incorrectly now sufficiently correct.

**Izar Tarandach (33:49)**: I am going to push back on both. I'm going to say that first question here is, which one of them is better at giving you what you want, not what you asked for? Back in the ice ages, that means 4 months ago. You would give a, air quotes, spec to an AI and it would gladly go and build that car with the wheels on the roof.

**Matt Coles (34:23)**: Mm-hmm.

**Izar Tarandach (34:24)**: Right. Nowadays, it's going to stop and say, wait, I see that the wheels are on the roof. Are we building an inverted car? Would you like to, uh, invert the wheel as well? Uh, do you have the right idea? Do you want to ask, uh, somebody before we do this? So the, the AI is, is offering a level of intuition of what the stupid thing that you asked for actually needs to be that wasn't there in the beginning. And developers always did this to certain degrees of pushback.

**Matt Coles (35:05)**: So you had spec, you had spec reviews and those spec reviews, you would reveal I, because it was, but at that time, remember the specs were not written by developers. They were written by product owners or product managers, or they were written by architects who in theory were completely removed from the actual engineering function. Right. And, and so you want us to build this self-floating, self-driving thing that looks like a hoverboard.

**Chris Romeo (35:37)**: Sure.

**Matt Coles (35:38)**: Do you have advanced physics I can use?

**Izar Tarandach (35:40)**: So that's the thing that the developer always, mostly always brought in the WTF filter. They were able to read what was being asked and say, this is not how these things work.

**Matt Coles (35:54)**: Or I could build this once and then, right?

**Izar Tarandach (35:58)**: The AI is only beginning to bring the thing in.

**Chris Romeo (36:01)**: So who's better? The AI agent or the human developer?

**Matt Coles (36:05)**: Describe better. What's your, what's your measure of better?

**Chris Romeo (36:08)**: Uh, sufficiently correct. So again, creating sufficiently correct output.

**Izar Tarandach (36:11)**: So again, I, I, I go back to my point. What, what is better? Something that does what you asked for or something that does what you wanted?

**Chris Romeo (36:20)**: It should, uh, it should understand what I want based on what I ask.

**Izar Tarandach (36:23)**: Then I would say it's still a person, but the AI's coming up with some very interesting ways of asking you Hey, is this what you actually want?

**Chris Romeo (36:33)**: So I got good news for all of us. Uh, we're now qualified as AI philosophers so we can apply at Anthropic and make like $2.5 million a year as AI philosophers.

**Matt Coles (36:45)**: Yes.

**Izar Tarandach (36:50)**: But, uh, the, the, just to, to go back to this, uh, uh, to this article here. We didn't touch on two things. First of all, the whole offer here is an open-source specification language that uses structured human-readable documents as the single source of truth for how software should be built and behave.

**Matt Coles (37:16)**: That's, uh, we're talking about, uh, something from GitHub by any chance?

**Izar Tarandach (37:21)**: Uh, no, something about the person who wrote the style. And so it's not only that you're going to write the spec, but hey, there's a spec to how you write the spec, right?

**Matt Coles (37:35)**: So everyone has conventions.

**Izar Tarandach (37:38)**: Yeah, but those conventions, they are in there so that things become repeatable and things become parsable. So it's not just about sitting down and writing a spec. There's just a method to the madness.

**Matt Coles (37:52)**: It always should have been a method to madness though, right? Yeah.

**Izar Tarandach (37:57)**: The thing that really bothers me about this whole thing is this whole discussion of fix the bug or regenerate the whole thing. And they use the analogy of the Phoenix, right? The code is like Phoenix. It gets regenerated every time that it's needed. So you don't have to worry about the code. You only have to worry about the spec.

**Matt Coles (38:18)**: The only downside to that is the Phoenix is a clone.

**Izar Tarandach (38:23)**: That, that, no, that, that's the thing. It's not the only, it's not the only one.

**Chris Romeo (38:27)**: It's not a perfect analogy.

**Izar Tarandach (38:28)**: No, no, no.

**Chris Romeo (38:29)**: It's not a perfect analogy. But I mean, one of the examples that I'm just reading here.

**Matt Coles (38:32)**: It's not a good analogy.

**Chris Romeo (38:33)**: One of, but listen to one of the examples they give.

**Izar Tarandach (38:35)**: It's a very bad analogy.

**Chris Romeo (38:36)**: This is, this is a really powerful use case for what, for this technology. Um, using Codeplane to build and maintain integrations with external data providers. When an external API changes and breaks an integration. Codeplane can often fix it by regenerating from the same unchanged spec because the spec encoded intent on implementation, meaning it's reading an API, it, it'll go read the external API spec and then adjust and then build a new version of the integration that understands whatever they changed on the API. So like, that's, that's a, that's an obvious win for this type of tech.

**Izar Tarandach (39:10)**: No.

**Matt Coles (39:10)**: And, but, and by the way, that required, that requires modular development. You need a modular architecture to be able to plug in new APIs without reconstructing the whole rest of the system. So there's a developer, so there's an architecture paradigm that has to have been followed originally.

**Chris Romeo (39:26)**: These are saying no to this. I'm curious.

**Izar Tarandach (39:28)**: Did you just invent a way for my system to be influenced by the bugs of other systems? Somebody created an API that doesn't have authorization authentication. All of a sudden, my system is going to wake up one day, look at it, say, Oh, look, the API changed. I should recompile myself and forget about that authorization authentication thing because the API doesn't use it.

**Matt Coles (39:48)**: Pretty much.

**Chris Romeo (39:48)**: Yeah. I mean, security doesn't really exist in an AI-generated world.

**Matt Coles (39:52)**: So unless you intend it, he's about to explode.

**Izar Tarandach (39:58)**: I am very bothered. I am very bothered. I may need a plush animal of an alien. Yeah.

**Chris Romeo (40:05)**: All right. Well, we're just about out of time here.

**Izar Tarandach (40:07)**: Any final thoughts on, uh, Meteor 2026, because clearly we can't go anywhere else.

**Chris Romeo (40:17)**: Oh, coming all the way back around. I mean, the movie Hail Mary.

**Izar Tarandach (40:21)**: Crap, man.

**Chris Romeo (40:21)**: It was about solving a problem like a meteor.

**Izar Tarandach (40:24)**: Let's not try to save it. Let's just let things take their course.

**Chris Romeo (40:29)**: I mean, that's one outcome for humanity.

**Izar Tarandach (40:31)**: We got there. It's like we deserve it. I mean, we asking for it. Come on.

**Matt Coles (40:41)**: All right, now we, now we can't apply to Anthropic.

**Chris Romeo (40:46)**: He just got disqualified.

**Izar Tarandach (40:48)**: OpenAI, here we are.

**Chris Romeo (40:50)**: Call us.

**Matt Coles (40:51)**: No, it'd be my—

**Chris Romeo (40:54)**: I think that's enough madcap fun philosophy something else. I can't even describe what just happened here.

**Matt Coles (41:02)**: But she's en route.

**Chris Romeo (41:06)**: Yeah, it was, it was a good journey that went somewhere. And if somebody's listening could figure out where that was, just shoot us a nice email.

**Matt Coles (41:13)**: So we went from Hail— we went from Project Hail Mary to Interstellar, in truth.

**Chris Romeo (41:16)**: That's a good title. It's good. We should make our own movie called that, Hail Mary to Interstellar. All right, well, tune in again soon for another example of madcap funnery, philosophical hijinks. And breaking social constructs. I don't know, I'm out of ideas. Thanks for listening, folks.
