Showing posts with label agile. Show all posts
Showing posts with label agile. Show all posts

Wednesday, January 04, 2023

Even the Best Chefs can't make a bad recipe taste good; why someone else's Agile Transformation recipe may not work for you


 I've been reflecting on some of the agile transformations I've been involved in over the past few years. In some cases, I see some real progress made. Other times it seems like just re-arranging the deck chairs on the Titanic. An organization follows some recipe, but they don't get the results. Why?

I was working with a large financial institution. They had adopted the "Spotify Model" (yes I know, it's not a real thing) and after that they adopted another scaling framework. I came in and started looking at what was going on and discovered they had a huge challenge with dependencies across teams and products. They failed to realize how much the dependencies on other teams was slowing any one team down.

I took some on-line training recently, a course called Agile Physics - the Math of Flow led by Troy Magennis. In it, he talks about Amdahl's law, which was developed in the late 60s to explain parallel processing. The bottom line is that there is always going to be a limit on how much additional output you can get by adding more processing power. Troy points out the law applies to people and teams as well as CPUs.

One source of the limit is how much can be done in parallel, or said another way, how much dependency there is between teams. So two processors (teams) in parallel with no dependencies can produce twice the output of one. However, as less of the work can be done in parallel (ie, dependencies), the output drops. Using the formula Amdahl developed, if you have 4 teams and 80% parallelization, your output is 2.5 (not 4). If you want to learn more, take the course...it's free and some really interesting ideas.

Back to my client with all the dependencies. What could have helped them? Maybe if before they applied the recipe for scaling, they took some time to look at how their teams were set up and came up with a better approach there, that is, one that reduced/eliminated dependencies. More on this idea in a future blog post. 

Wednesday, January 31, 2018

Psychological Safety

I had an interesting experience recently. I was working with a team as they went thru their sprint planning. They had figured out their capacity based on yesterday's weather and their average amount of interrupt. The product owner suggested the sprint goal and they started picking stories based on the goal. They reached the point where one more story met the sprint goal, but put them over their estimated capacity. The scrum master pulled it into the sprint and said he thought they could get the story done.

At this point I stepped in and commented that it was up to the developers to decide if they wanted to commit to the work. The developers remained silent. I made a comment about not over-committing and finally some comments were made by the team to keep the story out and pull it in if they get everything else done.
So what happened here? Why didn't any of the developers speak up when the extra story was first pushed on them? Based on this and other observations in the organization, I attribute it to a lack of psychological safety. The developers didn't feel safe to say "No, that's more than we can get done."

I wrote another article recently talked about group think. The two ideas are related. Group think exists in situations where people don't feel safe stating an opposing view. But psychological safety goes much further than that. A team without psychological safety will be reluctant to take chances, it impacts their ability to learn, they will be afraid to admit mistakes. In general, it keeps them from becoming a high-performing team.

So how does a team fix this? The reality is they can't. It's not the team but the organization around the team that will or won't create a space of psychological safety for the team to exist in.  Product owners and chief product owners need to be coached to understand how their actions impact the environment. It's starts with them showing they are vulnerable, by admitting their mistakes. They need to encourage teams to take risks and not punish failure but show how it can be used as a learning event. It's only when teams see these kinds of behaviors that they will start feeling safer, and next time a developer will speak up and say "No, that's more than we can get done."

Tuesday, September 26, 2017

Debriefs

I’m working on a new assignment as part of an agile coaching team leading a transformation at a large organization. One of my fellow coaches is also a former Navy officer. We’ve had a number of conversations about how many of the techniques developed by the military can be applied to make any team a high-performing one.

One particular tool is debriefing. I’ll admit, I didn’t do a lot of this in my military career, but the idea is to take time after any activity to review how it went. Kind of sounds like a retrospective, doesn’t it?

As an agile coach, I find this is a great tool. Just the other day I observed one of my teams run a stand-up. As soon as they were done, I gave them a debrief. It only lasted a minute. I highlighted what they did well and where they could improve. I have used the same approach with other teams on everything from iteration planning to retrospectives...sounds kind of “meta” but why shouldn’t you evaluate how effective your retrospective was? This technique is based on the approach of learning a new idea, practicing it, and getting feedback to reinforce the idea.

Learn, Practice, Reinforce

One key to debriefs, and I think this is important for a good retrospective, is to start by stating the goal of the activity. At the end of the iteration, can your team members state what the iteration goal was? How else can you evaluate how you did without thinking about what you set out to do. 

Monday, May 22, 2017

Estimating

I was flying home from a client visit last week at the airport getting ready to board the plane when the gate agent announced that the flight was gonna be delayed by ten minutes due to some unspecified mechanical issue. Ten minutes later they announcement another ten minute delay. They did this two more times.

So what was going on? Did the airlines not want to admit upfront that they had a 40 minute delay so they fed the delays to us ten minutes at a time? Or did the person who is doing the work really not understand how long it was going to take? I started thinking about how common it is for people to not be able to provide good estimates. Sometimes they underestimate the complexity, or maybe student syndrome sets in, or they're just overly optimistic.

It was ironic, but part of the work with my client that week was explaining the technique of relative estimates using t-shirt sizes and story points. The team I was working with was  new to agile and used to the old way of doing absolute estimates, which as we all know are not as accurate because of things like student syndrome or Parkinson's Law.

So how do we get better at estimating? I think the real question should be how we recognize estimates for what they are. An uncertain prediction of a future event. Even when we use story points, we won't know our true velocity until after a couple iterations when the team has time to come together. At the beginning of the project, we need to recognize how much uncertainty we have. So instead of saying "that will take about 2 months" we should say "that may take 2 months, but it could take as long as 3 months." So we provide not only the estimate but some measure of the uncertainty that goes with it. Similarly, if we think a story might be 13 points, but there's a lot of uncertainty, we should state that and make the story 20 points (or 21 if you're being strict with your Fibonacci sequence). Now if only I could get the airlines to provide a more accurate estimate the next time there's a delay...or at least how certain they are!

Tuesday, December 15, 2015

Design, Agile, and Gall's Law

The topic of design has been crossing my path lately. I see a lot of overlap with Agile principles. One of the principles I came across is called Gall’s law. It states that "all complex systems that work evolved from simpler systems that worked.” It was introduced by John Gall in his book Systematics in 1975.

This is very similar to the Agile principle of simplicity. It can be seen in the practice of Test Driven Development. You write your test case and only code until it passes the test and then you stop. No gold-plating here. 

This is also similar to the principle of MVP (minimal viable product)  that originated in the Lean Startup. The idea is to make a product as simple as possible, get it into your users hands, and see how it works. You make your improvements to the product based on the feedback from your users. 

Seems pretty logical, but my experience is that it isn’t followed as often as it should be. I see plenty of examples where scope creep takes over, and rather than getting the MVP out, features keep getting added - needed or not - while the users are left waiting. So next time there's a request for just one more feature, remind people of Gall's Law.

Tuesday, July 29, 2014

Agile2014 - Day 1

Yesterday was the first full day of Agile2014. In general it was a pretty good day.

The original keynote speaker, Aneesh Chopra, apparently had to cancel. His replacement, Sam Guckenheimer, provided an overview of Microsoft's journey to agile. It was an ok case study with some interesting information, but it wasn't a motivational keynote to get us all charged up. Talking to some of the organizers later, I found out they made a conscious decision not to pay for a headliner keynote speaker.

One of the more interesting talks was with Ron Jeffries and Chet Hendrickson in which they took questions from the audience. Everything from is TDD dead? (it isn't) to budgeting around technical debt. Ron and Chet showed their extensive years of experience. One point they hit on is that agile is really about the team figuring it out. The team has to own the process and make it work for them. Using something like a formal Scrum approach should only be your starting point.

Mike Cottmeyer did a good presentation on why agile adoption fails. He has a nice write-up on his website here and posted the slides here.

The last presentation I attended was with Jesse Fewell and Dana Wright. They walked us through a more engaging way to prepare for meetings & events based on Dana's book.

On the exhibit floor was the usual group of vendors, mostly tool vendors. Automating testing and continuous integration were big...and DevOps was being thrown around alot. I was reminded that Agile is a software conference, not a project management conference like PMI's Global Congress so the focus was really on software development.

Tuesday, July 09, 2013

Agile Isn't New

When I was in the US Navy, one of my assignments was working with the U-2 spy plane and the folks at Lockheed Martin, famous for their Skunk Works program. I was recently researching the program for some training I was doing, and realized how closely the principles of Kelly Johnson aligned with the principles of agile.

Skunk Works came about in 1943 as Lockheed (as they were know as then) was working on the first jet fighter. Kelly Johnson was a young engineer on this program. He outlined his 14 rules & practices to  guide the teams. Some of the key points include:

  • The manager should have practical control of the program (think product owner)
  • Use a small number of good people
  • Use very simple drawings with flexibility for making changes
  • Minimize reporting to what is important
  • Mutual trust between the military project organization and the contractor

Now some of the other rules related to the relationship between the vendor and the government, but this list sounds similar to some points in the Agile Manifesto and Guiding Principles. I don't know if the work of Kelly Johnson influenced the people that wrote the manifesto, but it's clear the ideas have been around for a while. And as far as a track record, the original fighter plane (XP-80) was designed and built in 143 days, and the U-2 has been operational for almost 60 years.

Tuesday, January 31, 2012

Critical Chain, Agile, and Program Management

I've been doing some research for a project at work on Critical Chain (a result of my articles <here and here> for Projects at Work being noticed within the company). I started by re-reading Goldratt's book Critical Chain. If you haven't read it, I recommend it. It's written as a novel and is an easy read, but still has some good content.

What I've been pondering is how to use Critical Chain in Program Management. I've come across some agilist talking about Critical Chain and Theory of Constraints (TOC-Goldratt's work in manufacturing). Dave Prior recently wrote an article for Projects at Work on transforming to agile where Drum-Buffer-Rope (part of TOC) was mentioned. There was also Mike Cottmeyer's mention of Theory of Constraints I mentioned in a previous post.

So is Critical Chain the answer to scaling agility? When Mike talked about scaling agility at the PMI North America Global Congress last year, he argued that Scrum isn't the answer to scaling agility. Some other tool that can address constraints needs to be used. I think many of us have experienced resources being the big constraint in a program. Critical Chain provides an answer to this.

When using Critical Chain, your first step is to identify the constraint. Let's say it's the number of U/I designers you have. You can't run four projects in parallel because your two designers will be constantly pulled back and forth, and we all know multi-tasking is bad! Critical Chain would say that you need to delay some of your projects to address this constraint, even if this means other resources are idle.

It sounds simple, but will it work? How else can you address constraints across a program? Do we also need to be concerned with buffers? Goldratt spends a lot of time talking about buffers on the project level, including resource buffers. But how does this scale to the program level? Do we need program schedules with resource buffers? I'm going to keep digging in. If you have any suggestions, let me know.