Latest / Definitely, Maybe Agile / AI Is Speeding Up Delivery. Are You Building the Right Thing?

Transcript

AI Is Speeding Up Delivery. Are You Building the Right Thing? · Definitely, Maybe Agile

• 0:04
  Peter: Welcome to Definitely Maybe Agile, the podcast where Peter Madison and David Shurk discuss the complexities of adopting new ways of working at scale.
• 0:13
  Dave: Hello, Dave.
• 0:14
  Dave: How are you doing?
• 0:15
  Dave: Always good to catch up.
• 0:16
  Dave: It's uh well it's been a while since we've had a chance to just have a one-on-one chat.
• 0:20
  Peter: It it has, hasn't it?
• 0:22
  Peter: I I mean I'm uh it's a bit unusual, so I uh I feel like it'd be good to dig into an interesting topic.
• 0:28
  Peter: What do you have for me today?
• 0:29
  Dave: I was gonna say we've had some fantastic guests in the last few weeks that have kept us busy, and and it's always a pleasure to have the guests coming on board.
• 0:36
  Dave: But sometimes it's just nice to just talk a little bit about what's going on in the world of well, the the stuff that we do, process improvement, product delivery, getting things out of the door in a timely manner.
• 0:48
  Peter: Yeah, all of that kind of fun stuff.
• 0:49
  Peter: Because uh so the what you were you were mentioning right before this, we were we were chatting about what different areas and different things are that are happening in the world around us.
• 0:57
  Peter: And you were mentioning you were seeing a rise or some people commenting on the fact, yay, we've got AIs, let's go back to doing projects.
• 1:06
  Dave: Yes, yeah, the resurgence of project delivery over product delivery, right, or agile delivery.
• 1:11
  Dave: And I think that that's certainly something we're beginning to see.
• 1:14
  Dave: I'm bumping into this in a number of conversations where it's almost like the tide has been going out for some time on project versus product and shifting towards product delivery, and all of a sudden, AI is enabling organizations to put all of the plans together, big plans, and so this sort of renaissance, if you like, of big upfront design and you know, huge projects being delivered over longer time frames, in some belief that this AI augmentation is going to make it more successful than it has proven to be in the past.
• 1:48
  Peter: Which seems completely the opposite of what you would expect.
• 1:52
  Peter: Um and because I mean with we know that the the reason that we that everybody was like breaking, I say everybody, but the the people who moved to a product delivery type uh mindset and method were doing this because they understood that breaking things into smaller incremental pieces, putting them in front of a customer, because we simply don't know if what we're building is the thing that we should be building.
• 2:16
  Peter: So we need to get feedback as quickly as we can.
• 2:19
  Peter: So we need to build as a complete small piece of it, get it in front of a customer, ask, say, hey, what do you think of this?
• 2:26
  Peter: Get that information back and then figure out what we do next, and then rinse and repeat and incrementally build it out.
• 2:32
  Peter: They that that logic hasn't changed just because we can do this faster.
• 2:37
  Peter: In fact, if anything, we can now do this much, much faster and in parallel.
• 2:42
  Dave: So it's kind of like now in 3D, we can well it's interesting when you say that because what you're describing is first of all an ideal state.
• 2:51
  Dave: And many of the organizations never really got to the validation piece.
• 2:55
  Dave: They talked about iterative and incremental, they took that on because it reduced risk and delivery risk, but they didn't do the business risk, the sort of, is this what the customers like?
• 3:06
  Dave: Is that what they need?
• 3:07
  Dave: Are they prepared to pay us more for it, stay with us, be engaged with us longer?
• 3:11
  Dave: That element, there are many organizations that definitely did go in that direction, but we both of us work with organizations that kind of didn't really take that on board and are still very kind of, you know, get these features out of the door and make sure you meet the specifications that we've agreed internally rather than validating what customers really want and they're looking for.
• 3:32
  Peter: Yeah, which is interesting, really, isn't it?
• 3:34
  Peter: Because that we've we know and we have seen on many occasions that that when you put it in front of the customer, that's when you realize that what's actually going wrong.
• 3:45
  Dave: Yeah, absolutely.
• 3:46
  Dave: Yeah, yeah.
• 3:47
  Dave: And then and then there's a whole kind of process that goes through, and and you know, product delivery optimizes that process, really sort of shrinks it down so you can get quick feedback, you can build that back into it.
• 3:59
  Dave: We don't have to necessarily go through some of the hoops that you jump through when you're doing something in a more sort of scaled project-driven approach where you're gonna have to wait 18 months or two years before the annual budgeting cycle comes around, it gets you know grouped together and actually delivered and so on.
• 4:17
  Dave: So there's definitely that sort of shift.
• 4:20
  Dave: But we would, or at least that that recognition that there are companies that aren't doing that validation.
• 4:25
  Dave: But there's another piece that I wanted to add into that, which you were just touching on, which is the AI augmentation didn't really touch the validation as much as it touched building and releasing features and enabled, like I think of it as commoditization or utility.
• 4:43
  Dave: You know, it's almost that getting a feature out of the door is a utility now.
• 4:47
  Dave: You just turn on the tap and it goes.
• 4:49
  Dave: And so instead of going, okay, now we can do lots and lots of micro changes and maybe look at how those changes are going to change what our customers deal with, those micro changes have got bucketed up into these bigger releases because there's confidence that that release will not have the headaches that they used to have in the past.
• 5:10
  Peter: Yes.
• 5:11
  Peter: And we we understand and have known for a very long time that if you jam everything into one big packet, then you're gonna it's gonna be much more confusing to figure out well, which part of that big packet was the thing that did what I wanted.
• 5:25
  Peter: And what about the other 80% that we didn't actually need?
• 5:28
  Peter: Um, do I still continue to add and maintain that complexity?
• 5:33
  Peter: Because that that's the other problem you get.
• 5:35
  Peter: The more stuff you jam into uh production, the more stuff there is in production that needs looking after, and the more things that can go wrong.
• 5:42
  Peter: So we we also need to consider the the entire system, not just the part of it that we're looking at.
• 5:49
  Peter: And so I do find it interesting, this idea that uh the big upfront design and planning piece of it uh is sort of comes back into the vogue.
• 6:00
  Peter: I yeah I think that there is a piece here where we we are looking at the coordination of AI agents to build out the various parts of the system, and that we a lot of that requires much better uh understanding of the context and the design of the pieces that we're building.
• 6:17
  Peter: So that is 100% true.
• 6:19
  Dave: But but that that is that is the same problem of building cars by hand in a garage where we're all kind of tinkering and and we're artisans building out the car and shaping the wing mirrors to match and moving that to effectively uh you know forward bringing on the assembly line, in that when you go to the assembly line to move at speed, I need to think about the entire picture of what we're doing, not little pieces of it.
• 6:45
  Dave: And I feel that in until recently we've been able to think about the little pieces because we never went quick enough.
• 6:52
  Dave: There was never really the assembly line type of model and speed that we saw in automotive uh industry versus computing, which is a bit weird.
• 7:02
  Dave: Software actually doesn't have that, it still has a very artisanal kind of um way of working where you know solution design gets done over here and specialists come in and do their piece and it all gets stitched together.
• 7:16
  Dave: Now that changes.
• 7:17
  Dave: We've talked about context.
• 7:18
  Dave: We talked about you need to know what the big picture is and be able to articulate that and break that down in a way so that now all of those, the agentics side of things, the AI piece knows what it's validating and evaluating again.
• 7:32
  Peter: Because if you I mean, theoretically, you could say, okay, here's my entire application.
• 7:37
  Peter: I'm going to take that entire application, I'm going to break it down into all of the pieces, and I'm going to spend probably quite a lot of money uh sending it through a set of agents to go build out all those different parts of that solution.
• 7:49
  Peter: And then you might put it in front of a customer, and the customer's going to go, Well, I didn't need that.
• 7:54
  Peter: Yeah.
• 7:54
  Peter: So you're I need this bit, but I don't need everything else that you've given.
• 7:58
  Peter: Yeah.
• 7:59
  Peter: So I'll look somewhere else.
• 8:00
  Peter: Yeah.
• 8:00
  Peter: And I'll go find the thing that actually does what I want.
• 8:04
  Peter: Yeah.
• 8:04
  Peter: And they and this, I mean, this is from a business perspective, this difference of you look around at everybody else and say, Well, we've got to catch up, and they've all got all of these features.
• 8:14
  Peter: And so I've got to have all of those features too.
• 8:17
  Peter: But if you actually go and talk to the customers of those other businesses, and they say, Well, out of all the things that they have, I use this one feature.
• 8:25
  Peter: All of those other things they have, I don't care.
• 8:27
  Peter: And they weren't, and quite often they'll say, and it had nothing to do with why I picked them.
• 8:32
  Peter: So sometimes we'll sometimes people will well, they'll pick it because, well, they had 10 features.
• 8:35
  Peter: I only actually ended up using one.
• 8:37
  Peter: The other nine, I did entice me, though, because look, it says, look what we've got.
• 8:42
  Peter: Um, but if you can say, okay, so that one thing that uh that those customers really, really like, can we do that better?
• 8:49
  Peter: Can we do that faster?
• 8:50
  Peter: Can we do that prettier?
• 8:52
  Peter: Can we make that easier?
• 8:54
  Peter: Um because then you've got something that a customer might want.
• 8:57
  Dave: So so as we're chatting about this, how do what do we actually want to see?
• 9:02
  Dave: Because I don't I don't think either of us want to see a resurgence of project delivery.
• 9:07
  Dave: I mean, there's a lot of reasons we we've talked about why project delivery actually increases your risk, whether it's business, customer-facing risk, whether we're building the right thing, or whether we're building it right, and whether that technical feasibility risk is being addressed appropriately, delivery risk is being addressed appropriately.
• 9:26
  Dave: None of those are solved with a project delivery mind.
• 9:29
  Peter: I I think there's it you still end up in a situation where we we've got to have a big North Star picture of where it is we're going.
• 9:37
  Peter: We need to have a rough idea of what are the main things that we think we're gonna need and what goes first.
• 9:43
  Peter: Um so we need some form of prioritization.
• 9:46
  Peter: From that, which should be a small piece, we want to break that down and have the agents go and execute.
• 9:51
  Peter: If we're really unsure, one of the wonderful things we can do now is try a couple of things.
• 9:55
  Peter: But to do that, let's just say we're gonna pick one.
• 9:58
  Peter: We we're good enough to be able to prioritize, and we're going to we can build that out, we can try out multiple different versions, we can do all sorts of fun things to experiment with that, but we've got to have a clear understanding as we go into that as to what is the outcome we're looking for and by what measure, how are we gonna measure it?
• 10:15
  Dave: How are we going to know that I was just going to say that part of this is this resurgence of the project plan end-to-end.
• 10:24
  Dave: And and whenever we've worked, uh certainly my experience has been that when you're introducing iterative and incremental ways of working, that product delivery piece, it's always within a container that is some form of project plan with a beginning and a middle and an end, because that's the longer term piece that sits within the firm, within the company as the container within which this product delivery is being done.
• 10:47
  Dave: But the critical thing is that that planning or that description of the North Star and what the goal is, that's become context, become how do you define the boundaries within which your agents are going to be doing their various tasks.
• 11:03
  Dave: And that's research, it's sort of elevated to being super important again, whereas before it's been kind of package it up and put it to one side.
• 11:11
  Dave: So that bit I completely see, but the problem is the delivery piece should still be tiny and iterative and incremental in the ways that we've always talked about, even though it's cheaper to do it, you know, it's cheap now and you can do it at scale.
• 11:24
  Dave: But why would you?
• 11:26
  Peter: You don't reduce the risk.
• 11:28
  Peter: And it should be tied to those concrete measurements of outcome that you're looking for.
• 11:34
  Peter: Absolutely.
• 11:35
  Peter: So you you should be looking for that as a part of it, and then you feed this into the engine as you go too.
• 11:41
  Peter: But on the other end of that, you gotta think about uh especially if you're delivering something that humans are gonna consume, which isn't always the case, but say you are, then you need to have an understanding of what is the rate at which those humans are going to be able to consume the thing that you're building, and how am I going to understand um whether they liked it or not, or whether it's useful to them, or how it needs to change, or what might need to be different, before I come back and just build the next one and just basically pile more slop on dip slopes.
• 12:14
  Dave: Exactly, exactly and just end up with a gloopy soup thing that's not really what anybody needs.
• 12:19
  Dave: Which again, we're beginning to see as a consequence of it.
• 12:22
  Peter: Um so I think I think it's a combination of these different pieces.
• 12:25
  Peter: Because I think I I there's a there's a part where uh it's not about being on a soapbox about projects or not projects, it's about thinking about your entire end-to-end delivery system, yeah, understanding how that works, how it changes as a consequence of bringing AI into it, thinking about how do I know that the product that is being created, the thing that's coming out of the end of the pipe is of value.
• 12:48
  Peter: And how like how am I gonna tell that and feed that back into the system?
• 12:52
  Peter: It's that continuous learning, uh, that is the system learning what's going right.
• 12:57
  Peter: Because in a in an idealistically simple solution, uh, which um if it's got humans involved at the end, it ain't gonna necessarily be simple.
• 13:06
  Peter: Uh, you can say, uh say say you could you've definitively determined that uh it if uh we reduce the number of clicks from five to four, then then it was a success.
• 13:19
  Peter: And then that I can measure for that and I can then feed that back in.
• 13:22
  Peter: And the this A, I can monitor and say, oh, it's going up to five again.
• 13:25
  Peter: I better make a change.
• 13:26
  Peter: What change might bring it down and then continue to improve the system, uh, and it which is uh systems theory at this best.
• 13:34
  Peter: Uh yeah, but that um the the fundamental um uh uh the ability to do that um at scale in a highly complex system with many, many levers and uh little uncertainty around what it is going to be, and potentially humans who you may not easily be able to sort of determine something as concrete as that to measure that then it but you need a you need a longer life cycle and you need a way of having that fed back into the system and you need to think about what that looks like because then you can start to think about okay, what I need I need a point here where I can say, where do I now?
• 14:10
  Peter: What needs to change about the next thing that goes into the funnel?
• 14:14
  Dave: Well, and that and that kind of pushes away from this, let's group all the changes together in one big bang release, which is I think that when we started this conversation, we were going back to the it feels like those sort of big projects are beginning to kind of be brought back into they're back in vogue.
• 14:33
  Dave: And we want to be aware that that's just because there's it might be something that's sort of doable with the AI augmentation, we don't want to go in that direction because you don't solve the underlying problems, that risk problem point that you're making about how can I create these positive reinforcing loops where the system is and understands what different parts of the system are trying to do and therefore can fine-tune and optimize those individually.
• 15:00
  Dave: On its own.
• 15:01
  Dave: On its own, even.
• 15:02
  Dave: Yeah.
• 15:03
  Dave: So how do we summarize this conversation?
• 15:05
  Peter: I I I can go first if you like.
• 15:07
  Peter: Um so projects are good, projects are bad, they're necessary, you know, in the sense that we need some kind of what is the sequence of things that we can overall.
• 15:16
  Peter: Let's have an idea we're doing.
• 15:19
  Peter: There is still a very good case, say is don't overplan every last little detail in every step of what needs to happen up front, because that isn't going to get you the results you need, because you know it already is going to have changed, so you're going to have wasted your time creating a bunch of steps that aren't going to need to happen.
• 15:35
  Peter: So that's there's no value in doing that part of it.
• 15:39
  Peter: Uh, there's there is definitely value in thinking about your end-to-end.
• 15:43
  Peter: So this would be my second point.
• 15:44
  Peter: There is value in thinking about the end-to-end system and how uh as you start to introduce uh AI into the way that your delivery system works, what changes, like what's going to be different.
• 15:56
  Peter: Um, and are you creating and understanding the the right measures to be able to learn what's necessary from your customers to inform those delivery systems so that the product feature you're building is being built right?
• 16:12
  Peter: But also so that you can think about what's coming next.
• 16:15
  Peter: And over to you, I'll let you have the third one.
• 16:18
  Dave: So here's one of the I I feel like we're we're hitting a maturation of this the sort of life cycle process that we've been discussing over the years.
• 16:27
  Dave: And it's so it instead of it being a step back where we can no longer think in terms of product and we can go back to thinking in terms of project, I think that's a retrograde, retrograde step.
• 16:39
  Dave: I think what we're actually seeing is that as the technology's changed, as things are progressing, we've now kind of bringing together the two sides of it, that big picture piece of project.
• 16:50
  Dave: That one is back in vogue, correctly so, is driven a lot by this sort of need for a holistic North Star context-driven view of the systems and what we're trying to create.
• 17:02
  Dave: But then coupled with that is the fact that delivery still needs to be this small iterative.
• 17:07
  Dave: So you're bringing the best of the product delivery world coupled with the best sort of long-term perspectives that you get from a project world rather than letting go of that product delivery.
• 17:18
  Dave: You still need that muscle, you still need to be able to use that.
• 17:20
  Dave: In fact, it gets easier when it's structured correctly, but we want to dovetail that with the project view.
• 17:27
  Peter: Sounds good.
• 17:28
  Dave: We've done what we can.
• 17:29
  Peter: Uh, with that, well, it's a pleasure as always, Dave.
• 17:32
  Peter: Always uh good to uh chat about these things.
• 17:35
  Peter: And uh I look forward to next time.
• 17:37
  Peter: Right, until next time.
• 17:38
  Peter: Thanks again.
• 17:39
  Peter: Thanks.
• 17:39
  Peter: And uh to all of our listeners, don't forget to hit subscribe, tell your friends about us, and uh send us a message of feedback at definitely maybeagile.com.
• 17:47
  Peter: You've been listening to Definitely Maybe Agile, the podcast where your hosts Peter Madison and David Sharr focus on the art and science of digital, agile, and DevOps at scale.