Latest / DevQuestions with Tim Corey / 316. I Dislike Spec Driven Development - Here Is Why

Transcript

316. I Dislike Spec Driven Development - Here Is Why · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: I think that spec-driven development is terrible.
• 0:03
  SPEAKER_01: I don't want any part of it.
• 0:06
  SPEAKER_01: But this isn't about bashing a way of doing software development.
• 0:09
  SPEAKER_01: I think it's important to understand why I disagree with spec-driven development, since development with AI is going more towards spec-driven development.
• 0:18
  SPEAKER_01: So let's talk about it in today's episode of DevQuestions.
• 0:29
  SPEAKER_00: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:33
  SPEAKER_01: Software development is more than just writing code.
• 0:36
  SPEAKER_01: So let's talk about the rest of it.
• 0:37
  SPEAKER_01: Specifically, let's talk about spec-driven development.
• 0:41
  SPEAKER_01: Now, we're going to start off with what is spec-driven development?
• 0:45
  SPEAKER_01: Well, it's writing a detailed specification, that's the spec, about what the system should do before you implement it.
• 0:53
  SPEAKER_01: So you're building an application and you say, here is exactly how it should work.
• 0:58
  SPEAKER_01: The spec becomes the source of truth.
• 1:01
  SPEAKER_01: This is what the app does.
• 1:03
  SPEAKER_01: Now that spec can include API contracts, business rules, data models, the behavior of the app, the outcomes the app should have, et cetera.
• 1:15
  SPEAKER_01: So that's what the spec-driven development is.
• 1:18
  SPEAKER_01: And it turns a good idea into a management exercise.
• 1:23
  SPEAKER_01: And that's the problem.
• 1:25
  SPEAKER_01: So now this is currently gaining popularity because of AI.
• 1:29
  SPEAKER_01: We think about it, one of the first things that happened when we got LLMs is we started asking the LLM to do something.
• 1:37
  SPEAKER_01: And it was at first, you know, hilariously wrong, and it started getting better and better until it's, you know, it's pretty good.
• 1:43
  SPEAKER_01: And one of the things you'll see is that whenever you get a bad output from AI, people will tell you, well, you're holding it wrong, right?
• 1:51
  SPEAKER_01: You're prompting it wrong.
• 1:52
  SPEAKER_01: Um, you need to have a better prompt.
• 1:54
  SPEAKER_01: And so there's whole schools of thought around how do you craft the perfect prompt?
• 2:00
  SPEAKER_01: And there's even tools out there to aid in that prompt, you know, where you can have a tool that says, okay, here's how to write good C sharp.net 10 code.
• 2:10
  SPEAKER_01: And here's how to write, you know, good code for our business, and here's our business rules, and all this stuff.
• 2:16
  SPEAKER_01: And then you create this really detailed prompt.
• 2:21
  SPEAKER_01: And sometimes that works, and sometimes you still don't get a good enough result.
• 2:26
  SPEAKER_01: And now we're we have things like loops where we're letting an AI just do its work in the background and figure out what to do next.
• 2:34
  SPEAKER_01: And so we're starting to give it detailed specifications and say, okay, here's your specification, and let the loop just iterate over that and figure out how to design it and then pull off pieces and build that piece and test that piece and so on.
• 2:49
  SPEAKER_01: But the thing is, the more specific we get, the better the output should be, at least.
• 2:57
  SPEAKER_01: So the English language really isn't precise.
• 3:01
  SPEAKER_01: So we need to be more precise, and that takes you know, restating the solution.
• 3:07
  SPEAKER_01: Sometimes it means sometimes using precise language, et cetera, in order to get the right conclusion for us.
• 3:14
  SPEAKER_01: All right.
• 3:15
  SPEAKER_01: So that's where we start to kind of spin out a spec.
• 3:21
  SPEAKER_01: That's where we start to say, this is the specification for my app.
• 3:26
  SPEAKER_01: And the more precise we can get, the more easily an AI can look at that and say, you want a calculator that can add two plus two and get four.
• 3:37
  SPEAKER_01: Let's check to see if the current thing I built can do that.
• 3:41
  SPEAKER_01: You know, and you start having more and more of these things that tell it exactly how it should work.
• 3:47
  SPEAKER_01: Hopefully, the the um the more specific you can get, the more um impressive the output can be.
• 3:58
  SPEAKER_01: So let's take this thought process to its logical conclusion.
• 4:05
  SPEAKER_01: So let's let's think about spec-driven development.
• 4:07
  SPEAKER_01: Think about how do we get the most precise, most rigid, making sure that yes, we have a non-deterministic AI, but we want to almost lock it into determinism, right?
• 4:19
  SPEAKER_01: We want to say, this is exactly how I want it to work.
• 4:22
  SPEAKER_01: How do we do that precise enough so that we always get the right thing out?
• 4:30
  SPEAKER_01: So that the thing we have in our brains actually gets built by the AI.
• 4:35
  SPEAKER_01: Because if we can do that, then what we can do is we could actually have the AI build applications because it can give us exactly what we're looking for.
• 4:46
  SPEAKER_01: So let's let's kind of design this system at the end conclusion, right?
• 4:52
  SPEAKER_01: Let's the logical conclusion of this spectrum in development.
• 4:55
  SPEAKER_01: So we're gonna need precise structures and exact symbols to make our specs less ambiguous.
• 5:03
  SPEAKER_01: You know, English is very imprecise.
• 5:05
  SPEAKER_01: So let's use specific words and make sure that we do things in a certain way and have some symbols in there so you can say, okay, if you think about um anytime you've seen people talk about um like the cloud and Azure or anything else, they have these symbols, like the database symbol, it's a it's a certain symbol, and we have a server symbol and a web server symbol, and you know, all these different symbols that make it very clear what we're thinking.
• 5:31
  SPEAKER_01: Well, we can have these symbols and we can make sure that we have specific uh words that we use for certain things.
• 5:38
  SPEAKER_01: That way we're very precise and it's not um ambiguous what we're looking for.
• 5:45
  SPEAKER_01: And then you know, if if we got to that level where we've got these precise structures and exact symbols that make our spec unambiguous, very clear, well then we could do is actually have an AI take that that um that spec and have an automated system that takes a spec and turns it into code directly.
• 6:08
  SPEAKER_01: Like it could be really clear, it could almost be like one-to-one where it takes our spec and turns it into code, which what do we end up with?
• 6:19
  SPEAKER_01: We end up with a programming language, right?
• 6:22
  SPEAKER_01: That's exactly what a programming language is, because we don't write things in ones and zeros, which is what you know the eventual outcome is going to be for our code.
• 6:35
  SPEAKER_01: What we do is we write in C sharp, where we say things like if and for and use English words that represent an idea and they're precise.
• 6:46
  SPEAKER_01: So that when I say four, you know, i equals zero, i is less than 10, i plus plus, then what I'm doing is saying specifically, I want a variable called i.
• 6:58
  SPEAKER_01: I want it to be initialized at the with zero in it.
• 7:02
  SPEAKER_01: I want to loop over this loop until we get to, you know, not once we hit 10, we're done.
• 7:11
  SPEAKER_01: And I want to increment i by one every time.
• 7:14
  SPEAKER_01: We're being very, very specific, which is what a specification is.
• 7:20
  SPEAKER_01: How specific do you want to get?
• 7:21
  SPEAKER_01: Now, this is the crazy end solution of spec, but that's really where we're headed, right?
• 7:28
  SPEAKER_01: And you know, if we had an automated way for the AI to take that spec and turn it into code directly, well, that's just what C sharp is or other languages, where we're creating the spec, which is code, and then it takes that spec and it turns it into a compiled code that can then be executed.
• 7:49
  SPEAKER_01: And it's so specific that it can't be interpreted a different way.
• 7:54
  SPEAKER_01: It's very specific.
• 7:55
  SPEAKER_01: It's not not as English, where there could be a variance in how we're thinking about things.
• 8:01
  SPEAKER_01: You know, my my favorite uh or least favorite word in the English language probably is bi-weekly.
• 8:08
  SPEAKER_01: What does that mean?
• 8:10
  SPEAKER_01: Does it mean every two weeks or twice a week?
• 8:13
  SPEAKER_01: And the answer is yes.
• 8:15
  SPEAKER_01: That's frustrating me, that's it's not specific enough.
• 8:19
  SPEAKER_01: But if you're specific enough, you'd say twice a week.
• 8:23
  SPEAKER_01: You know, um, that's more specific.
• 8:25
  SPEAKER_01: That's what code is, is a very specific way of doing things.
• 8:29
  SPEAKER_01: So the logical end conclusion for spectrum development is just to write code.
• 8:35
  SPEAKER_01: So it's easy to cop in a way to solve a problem.
• 8:39
  SPEAKER_01: And that's what, you know, we first start off, we had this idea of we want to be more precise in how we specify what the app should do.
• 8:48
  SPEAKER_01: Because when your manager comes to you and says, I want you to build a calculator, that's not precise enough.
• 8:55
  SPEAKER_01: That's nowhere near precise enough.
• 8:56
  SPEAKER_01: And really, management almost never gives you anywhere close to enough of a specification for what the app should do.
• 9:06
  SPEAKER_01: So the conclusion is let's make a structure for making it more precise.
• 9:11
  SPEAKER_01: And that's a good thing.
• 9:13
  SPEAKER_01: And so you start asking the right questions and start building out, you know, how do you want the data to look?
• 9:18
  SPEAKER_01: And how do you want this to look in the front end?
• 9:22
  SPEAKER_01: And what problems should it solve?
• 9:23
  SPEAKER_01: And how do we know when we're done?
• 9:25
  SPEAKER_01: And all of these are good things.
• 9:29
  SPEAKER_01: But if you take things too far, what happens is the solution starts drifting in an area where it's already a solution.
• 9:39
  SPEAKER_01: So too often in software development, we keep adding one more feature to something until it's blurred and messy.
• 9:45
  SPEAKER_01: Like if you look at really like Microsoft Word, um, that's a great product, but at the same time, it's also kind of blue.
• 9:52
  SPEAKER_01: There's a whole bunch of stuff in there.
• 9:54
  SPEAKER_01: It's like most people don't ever use this, and it's you know, hard to figure out.
• 9:58
  SPEAKER_01: There's a lot of features that you never know about, or Visual Studio, there's so many features people don't even know about.
• 10:04
  SPEAKER_01: Where those are all good things in themselves, but in the grand picture of things, it makes things very, very difficult to use.
• 10:15
  SPEAKER_01: So we tend to allow good management ideas to turn into an overbearing bureaucracy.
• 10:21
  SPEAKER_01: Um I may have just had a whole bunch of people say yes, yes, yes to that sentence.
• 10:26
  SPEAKER_01: Um I'll say it again.
• 10:28
  SPEAKER_01: Um, we tend to allow good management ideas to turn into an overbearing bureaucracy.
• 10:33
  SPEAKER_01: This is very common.
• 10:34
  SPEAKER_01: It'll probably come up in a future dev question video.
• 10:37
  SPEAKER_01: Um a lot of the things we do in software development start off as good ideas that turn into a whole bunch of ceremony, a whole bunch of management fluff.
• 10:49
  SPEAKER_01: Um and it takes away from the task of actually doing the job.
• 10:54
  SPEAKER_01: Uh, but it started from a good idea.
• 10:56
  SPEAKER_01: It's just that it got overburdened.
• 10:59
  SPEAKER_01: In this case, the idea of writing a good, clear specification for what the app should do is a great thing.
• 11:06
  SPEAKER_01: But spec-driven development takes that concept and turns it into a managerial mess.
• 11:13
  SPEAKER_01: And that's why I don't like spec-driven development.
• 11:17
  SPEAKER_01: Thanks for listening.
• 11:18
  SPEAKER_01: As always, I am Tim Corey.
• 11:21
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 11:24
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to imtimcorey.com and enroll in a course.