3 amigos

Read along you will

Shane: Welcome to the No Nonsense Agile Podcast. I’m Shane Gibson.

Murray: And I’m Murray Robinson.

Shane: Hey Murray, another lovely week in paradise and I think this week we decided we’re going to talk about the three amigos.

Murray: Yes, the three Amigos. 

So three Amigos is an organization pattern. The idea is that you get a product person, a developer, and a tester from your team, the most senior people usually. And you work ahead of the team by a week or two to define each feature before you estimate it. So that the developers all have a pretty good idea of what they need to do when they’re developing the feature. And the idea is that it saves the team a lot of time and a lot of confusion when they start developing. 

Shane: Yeah, so , the three amigos gives us a way of doing some initial exploration, some initial thinking so that we have a little bit more certainty. Because we’ve done some research.

Murray: Yeah So before you start developing, you need to do some preparation otherwise the developers are confused about what they’re doing and they can waste an awful lot of time doing things that is not needed.

There’s this problem that has occurred in some scrum teams, where the teams hadn’t done any preparation at all by the time it came to their sprint planning meeting. They’ll come into sprint planning and then it’ll be extremely confusing and people start wasting enormous amount so that was the kind of problem I saw where three amigos could help. Is that the problem that you’re seeing too?

Shane: Yeah. For pretty much every team I’ve worked with, the developers feel like there’s value in doing that light work upfront early. So the three amigos has been really useful. 

And in the data space, we tend to have one of the amigos as the product owner. Yeah. So they’re telling the other two these are the things we need to do. These are what the acceptance criteria will probably look like. One of the other amigos is in the analysis space. So they have those skills. So they’re analyzing those acceptance criteria and the data that may needed to support it.

And the third Amigo is typically, the more experienced data engineer or architect. So they’re coming in with that expertise to look at the platform and the patterns that are already being used and going, ah, okay we’ve got a problem because now you’re talking about data from Salesforce and we haven’t actually collected or plumbed data in from Salesforce yet. So there’s a whole lot of work the development team will need to do up front. To get that data to start coming in. So that tends to be the makeup of the three amigos when we’re in the data and analytics space. 

Murray: It’s interesting that you don’t have a test specialist

So in the data and analytics space the person with those analysis skills flip over to testing skills as well. I agree with you that it’s very helpful to have a subset of the team do some preparation and planning for a story before it comes into the sprint, because that will make it a lot easier to estimate and plan and build. 

I’d just like to add design in there.

Design is absolutely critical in anything with a front end. And that work really needs to be done at a higher level before coding in my experience. So I would add a designer.

I also like the idea of having a business analyst in there because the product owner shouldn’t be expected to define all of the detailed rules and requirements and processes around the, feature because they have a lot of other things to do. 

Shane: You’ve just got to 5 roles. So you’re almost at a scrum team. It’s just the poor old developer. That’s not there listening to everybody talk about what needs to be built.

Murray: I have tried having the entire team there do this. And then we’ve had a retrospective where the developers have all complained about us wasting their time in these meetings to define all these features. They didn’t want to be there. They wanted to send their most senior representative there.

Shane: I’ve had the same experience and I wonder if that’s a symptom of an immature agile team where the developers think their role is to get a spec and code it. And yes we’re not doing the level of documentation we used to do in terms of the requirements of the specification, but they’re still in the mindset of, tell me what you want to build and I’ll go build it.

Not tell the team what the problem is and I’ll work within the team to solve it. So I think it’s a sign of immaturity within that team about, what a self organizing team actually looks like. But that’s okay. We know that Agile is not a methodology that’s written down in black and white. It’s a bunch of patterns we put together to make things better. If the teams get value out of the three amigos, good on you. If it’s adding value to your life, keep on doing it.

Murray: Yeah. You always say that there’s four levels, right? So a developer could be a novice, a practitioner, an expert and a coach. 

So a lot of this planning is extremely challenging for people who are novices and also quite difficult for people who are practitioners. And so they want the experts in their team to, sort out some of these architectural issues because they’re better at it. And, the developers want to do what they’re good at. 

Shane: So it’s about level of input. If you’re a novice or practitioner level and you’re one of the three amigos you’re in a hard place. But I still believe that The novice or practitioner sitting in those sessions has value because they’re learning how those expert or coach level people taking this big problem and breaking it down into smaller chunks, but not going down into the details. So again, I still argue theirs value. 

Murray: The developers don’t think so because it’s always developers who push back and say, I don’t want to be in all these meetings unless they’re the expert or the coach level person.

Shane: Yeah, I’d agree with that and a lot of developers just want to code. 

Murray: Well, coding is challenging enough anyway. Without having to worry about all these other things. 

There’s a concept, related to this called ready to build and ready to test. So ready to build means that the team agree that something is at the point where it’s ready to build. And they define what that is, but usually it means it’s top priority. It’s been defined in a way that’s testable and some architecture and design planning has been done so that when the developer starts, it’s in a good state for them. They can start coding confidently knowing that they’re on the right track and doing the right thing.

Shane: yeah. So what I can talk to you about teams is the idea of definition of ready, definition of done. And then my favorite one definition of done, done, done. And then the last one being definition of value achieved. 

So definition of ready the team say. Before we start some work, these are the things that should be completed, otherwise we’re walking into a nightmare. And if we’re running three Amigos, then what the Amigos are producing should be part of that definition of ready. And that comes back to that conversation around how much documentation do we do? 

One of the things I’ve seen more successful teams do is refine the artifacts or the templates or whatever the documentation is that the three Amigos is producing. I hate documentation as handover. We much better value in handover via conversation. But when that conversation is supported by reusable artifacts the work done early seems to have more value for the team doing the delivery work.

Murray: The three Amigo’s are part of the team though, aren’t they?

Shane: So this is interesting because I have worked with organizations where the three Amigos actually set outside of each of the squads. And they went through and triaged the work early for the squads. 

Murray: Yeah. It could work but it could become a kind of waterfall silo as well. I have seen cases where, the business analysis team and the design team does this work six months ahead in a giant document, which is made up of user stories and epics, but it’s 100 pages long and it’s in a different functional group and they sit up at some sort of architectural or program level and that’s not agile at all. That’s just standard waterfall with agile words.

I think there are times when you’ve got multiple squads working on something where you can get a lot of value from an integration team. Scrum Nexus has an integration team , but the integration team is made up of representatives from the various squads. Let’s say you have on your integration team your lead technical expert. They might be 50 percent of their time in one squad and 50 percent of their time coaching people in other squads and being in the integration team. I think it’s also quite viable to have the product owner or product manager sits in that central team full time, and then they’re supported by, BAs and other people like that in teams.

I think some designers would sit at that integration team. But whatever we do, we need to downplay the handover with documents as you said.

Shane: Yeah. I like your idea that our ideal state is we have the level of expertise in every squad. So each squad has their own three amigos. So I think that’s what we should be aiming for. Sometimes the expert or the coaching level doesn’t sit in every squad. And we see that a lot in the data space around the architecture role. The platform and technology and data architecture is normally a highly skilled capability. And often you only have one when you’ve got two or three squads. So you’re starting to deal with the scaling problems.

Of course, now we’ve got people in the squad coming out to do work early so they’re no longer fully dedicated in the squad to do the work in the current iteration. And as long as we deal with that, it’s okay.

Murray: Yeah. And there’s a couple of interesting ways of dealing with that. One is you just accept it and that’s fine. The other way, is that you create activities for preparing a feature. 

I’m not a big fan of that. I actually prefer to set up a Kanban board that says prioritize, analyze, design, build, test, deploy, something like that. The team decides what it is. And you have a feature that’s been prioritized and you take that feature through that cycle. Maybe the analysis and design part is more of the three amigos and then the rest of it is more of the whole team. But I find it very useful to be able to map out the whole lifecycle of a feature on a board so that the team can see what’s coming, see what the blockers are. 

Shane: Yeah, so I think it’s really important that you have a product roadmap and that you have that at multiple layers. So I talk about time horizons. The first time horizon being somewhere between three and six iterations that should be on your road map of work that’s about to be done. And that helps the amigos focus on what they should look at next. And then, another time horizon that’s somewhere between, six months and 12 months, bigger blocks where we know that maybe there’s some spikes because we’ve got a whole lot of new technology. We haven’t even touched yet. and then the third time horizon is over the next four years. Here’s the big themes or strategies that we know may come into the product team. 

Murray: Yep. My principle here is just enough planning just in time. So, there is definitely a problem with the three amigos getting too far ahead of the team. If they get more than one sprint ahead, Then they need to stop and go back and help the team doing the work

Shane: Yeah, I give them two. 

Murray: I think we need to make space to be able to prototype concepts and test them with customers and users to see if they get a good response before they agree with the product owner that it should go into build.

Because, if you have a hypothesis and you build it, it’s going to cost you somewhere between 10 times more in effort, than it would cost to mock it up and show it to people. And you get a lot of really good feedback just from mocking something up. And the same for the architect or development expert to do a bit of prototyping.

Shane: When we do that, we tend to fall into the pipelining problem. We’re now segmenting the work into the designer designs it and the app developer builds the screens and the architect does the architecture. It’s not a problem that I’ve got a good answer for because I agree with you that some work done early have a lot of value figuring out how we’re going to deliver something. But we fall into that habit of locking it in and making it inflexible. So we just got to balance it out, I think.

Murray: The pipeline is only really a problem if it’s done in functional silos. I think if the team is doing their own pipeline it’s fine. And it’s fine when you’ve got a group of squads doing it together. It’s not fine when you go back to the traditional functional silo model. That’s where it all goes bad. 

Shane: Yeah, so I, I have a preference that we still don’t pipeline them within the squad but often we do. 

Murray: I find it works really well, actually. 

Just related to this. 

I wanted to dig down into the detail a bit more on the handovers. Let’s say you’ve got your expert technical person and they’re doing some of this prep work with the product owner, a designer and the tester for next sprint.

What I like to do is say to the developer, when you’re going to pick up this feature or the story off the backlog I think it’d be really helpful for you to have a chat to, the people from the three amigos who’ve been working on this. So it’s not just reading through it.

Shane: One team I worked with worked out that yes, conversations are great, but light documentation still had value. So they talked about the artifacts they created in the life cycle of development. The idea of a sketch or a pencil and then coloring it a little bit more and then coloring it on a bit more. And then, when it was built, it was pretty much completely colored in because the code was done. And so they would lightly fill out the artifacts as a guess. 

To give you an example, they building a dashboard and it’s the first time they’ve touched that data. So the person with the analysis skills would go and look at the data coming from the source system and go, Yeah it looks like it’s got a product and it looks like it’s got a customer and it looks like it’s got an order. So they would do a really light sketch of a conceptual model that says concept of customer, concept of product, concept of order.

And then, everybody would go cool, we’ve already got customer from everywhere else. So we know how to bring that customer data in and match it up with everything else to give us a single view of customer. We’ve got products, but, we know this is a separate product catalog and we haven’t dealt with it before.

So we know there’s a bit of gnarly stuff in there we’ll deal with later and we haven’t got orders, so we know we need to build some stuff out. And so they would lightly sketch out some of the things that would be developed or created during the development cycle. There was actually a really interesting unintended benefit of this because they picked up the documentation as code pattern, which is effectively you’re writing code that becomes your documentation. And as part of that, as soon as you checked your piece of code into your git repository it automatically updates the documentation site with that version of it. 

So a really interesting thing happened because we were running three or four squads at that stage. And ideally the squads were working on things that had no crossover, but every now and again, because it’s data, they always did. So we’re sitting in a planning session with squad one, call them. And, the squad was saying, oh we’re going to go do this and that’s order. We haven’t touched orders before. One of the other squad members said, yeah, but squad two is working on orders for another system at the moment.

And they were, how do you know that? And they said, well, I just had a look at their draft documentation and in their conceptual model, they’ve got order. So in the past, what they had to do was finish the planning, go around and ask anybody else and come back. And this way, that documentation added value. So I thought that was a really interesting use case, but we have to be careful that we don’t go to the nth degree of everything is a fully fledged document and there is no conversation.

Murray: Yeah, I’ve seen people write, a 10 page epic description where the BA team were separate team and that’s not what we’re talking about at all.

One thing that George talks about in his three amigos articles is, testable requirements. So if we are writing requirements, they’re written in a testable way in a given when then form . So that’s quite a lot more detail than bullet points. It’s almost like pseudocode. 

Shane: I think it’s a great idea, but haven’t seen it a lot. And on the data space our tests normally the last thing we worry about and they should be one of the first 

Murray: This is the concept of shift left. So we’re changing the testing expert from being somebody who finds problems to somebody who helps the team prevent problems by helping the team to define their acceptance criteria before they start coding. And I think that’s very helpful. That adds quite a lot of clarity because then when the developers coding they can start doing TDD straight away. Maybe it’s part of the transition from the three amigos to the developer that they work together to write the acceptance tests.

3mega is a pattern that’s developed because developers have said stop wasting our time making us go to all these meetings that we don’t want to be at or add value to and stop wasting our time by giving us shitty, poorly defined things to do.

Shane: And as humans, when we know complexity is coming up, we want to do early work because we think it helps. And again, every time I’ve seen a team use the three amigos, it has helped solve a problem. 

Murray: Yeah, I found it very useful as well. I was once working with some teams that were very confused about what they were doing and wasting a lot of time starting something and stopping it and changing to something else. And I found that helping them to prepare their stories for the sprint planning, for the estimation meeting on the first day of the sprint, that really helped and having the three amigos do that work, which was basically the most senior expert level people in the team. That helped them a lot. It brought a lot of clarity and really helped the team improve their productivity and get more things done and do higher quality work as well.

Shane: Yeah. 

And then I think there’s a bunch of anti patterns that you’ve got to be really careful of the three amigos. I think one that you raised was we effectively implement, Waterfall with a whole bunch of really experienced people right at the beginning of the process, pretending to be the three amigos writing, lots and lots of documentation, that is requirements. That’s an anti pattern.

Murray: Yep.

Shane: I think there’s an anti pattern of a single hit squad of three amigos across the entire organization, and they’re the only people that can do the early planning. 

There’s an anti pattern of planning far too early. So the three amigos run way ahead of all the development teams and all the prioritization roadmaps are there out iteration six ahead. And that’s, I think that’s an anti pattern. 

Over documentation or no conversation. So either they document in too much detail, or when the squads are picking up the work, they don’t actually have a conversation about the early work that’s been done. So I think they’re anti patterns you’ve got to be careful of. 

Murray: Yeah another one I’ve seen, which I think is a bit of a problem, is where requirements aren’t written in a testable form. Then the developers build it and they hand it to a separate test team who then starts to write test cases and then they, test them, so that’s just going back to Waterfall again.

Shane: Yeah I’ll preface it a little bit though, because as you may have learned over the last few months, I’m really fond of the idea of patterns. So I think, understood stories, requirements, acceptance criteria, and the tests that support them is one thing that can come out of the three amigos. Early sketches of patterns is also another thing that can come out of the three amigos.

Murray: Yeah. Contributing to your architecture.

Shane: Yeah, so they’re saying there’s this complexity coming up. We haven’t dealt with it before. We’ve done some research and we think a pattern that looks like this may be useful, so I think we should be able to throw in that producing sketches of patterns that may add value is something that three amigo’s should focus on.

Murray: Yeah. I’d also like people if they’re doing this to make sure that they define ready for build and ready for test.

Shane: So we should do that anyway. So every team should have a definition of ready that they use to go through and say this work we’re going to do next, it’s in a ready state for us to start or it’s not. 

Murray: Yeah. 

But overall, I found this pattern very helpful for teams. Sounds like you have too.

Shane: Yes, as much as I hate to admit it it is a useful pattern, and therefore, if it solves a problem, go forth and conquer. 

Murray: All right. Thanks, Shane 

Shane: All right. On that note, I’ll catch you later.