Wednesday, October 17, 2018

What Does an Agile Coach Do All Day? Part 1


Understanding active listening, emotional intelligence, facilitation and a host of other coaching skills is great, but what does an Agile Coach actually do on a day to day basis? How do they create value? One can imagine a coach wandering around, making observations, dropping pearls of wisdom here and there, and being approached for advice. Or perhaps they are like a lucky charm; just great to have around, imparting greater levels of Agility through proximity.

Part of the difficulty of being an Agile Coach is that you are only successful when others are successful. You work is "indirect." Compounding this is the fact that if everybody were already experienced Agilists, you wouldn’t need to explain the value of Agile or how to become Agile. Agile is very different from traditional ways of working. As a result, it can easily end up in people’s “blindspot.” That is, when you explain parts of Agile, they can sound like exactly the wrong thing to do. For example, phrases like “consider working on fewer projects at the same time” and “produce new end-to-end functionality from scratch every two weeks” make many people shake their heads, even in supposedly Agile environments.

As a result, there are many different views of what “Agile” really is. When you show up at a client or a new team, it is likely that the true value that you can provide is not fully understood and that people will have certain pre-conceived notions of who you are, what you believe in, and how you will provide value to the organization, teams, and individuals. To counteract these difficulties, one thing you can do is create and publicize a catalog of service offerings. This gives people a tangible list of things that you can do for them that they may not have even thought of asking for.

Here is my catalog. It is in word format and I invite you to use any and all of the text that will help you create your own service offering catalog.

This idea came from Gillian Lee as she was looking to provide new ways to make Agile Coaching even more approachable and self-serve for her teams.

In part 2 I will talk about ways to discover the potential needs of your teams.

Agile Games!

Over the past couple of years, and even more so lately, Gillian and I have been creating lots of Agile games, including user story games and games that teach Agile Coaching. You can download the full trove here.

Upcoming Events

I've got a number of events coming up! Tonight I'll be at the Kendal Square Agilists doing a talk/large game on "Scaling Agile Organically." You can learn more and register at their meetup page.

This Thursday, and every Thursday, I'll be doing an Agile Coaching webinar. Sign up for this week's webinar here.

And if you are interested in getting your ICAgile Agile Coaching certification (ICP-ACC), I've got three opportunities coming up in Boston and Dallas. Dates and details are on my eventbrite page. Use coupon code ICPACC1 to get $300 off!

Hope to meet you in person soon. What can we learn from each other?

Friday, October 12, 2018

Switching Focus to Agile Coaching

After a long hiatus on this blog, I'll be switching the focus from DIY to Agile Coaching. That said, the essence of providing information for the Agile DIY'er will remain, it is just a change of focus. So, what do I mean by "Agile Coaching?" Topics related to coaching within an Agile environment. Topics like powerful questions, presence, listening, and remaining neutral. These are all things that come from coaching and are independent of any particular domain area. But as an Agilist, you are often working to catalyze change which requires good coaching skills. So, I'll be talking about coaching, but within an Agile context.

One awesome thing about the Agile community is that we have so many tools that are great coaching tools. For instance, part of coaching is identifying what the issue is that needs coaching. Powerful questions are great for that. And what are speedboat and open space if not powerful non-leading open-ended questions? So I'll be talking about great tools like that within a coaching context. Let me know what topics you'd like me to cover and ask me whatever you'd like. I look forward to your participation!

Saturday, March 24, 2018

The Best Product Owners Write Small Valuable User Stories

Are you a product owner, or aspiring to be one? Is your organization struggling with producing user stories that can be implemented start to finish in a few days or less that real users will recognize as valuable and say "thank you" for? Too often, the "user stories" that get implemented in a short period of time are really tasks. In extreme cases, providing end user consumable value takes multiple sprints.

On April 4th, Nexxle and Banner Solutions are partnering to bring you a webinar that will introduce you to a number of story writing and story splitting techniques that can help you and your organization create small valuable stories. We'll do a quick refresher on INVEST using examples of stories that meet or don't meet the INVEST criteria and then cover story splitting techniques including split by test scenario, split by generated list, cake slicing, and many more

Register now for our April 4th webinar.

Sunday, March 11, 2012

11 Self-organizing Teams Teaching Themselves Agile at the Same Time

In a previous post I talked about how I came to learn that I could teach Agile to lots of people at the same time. In writing that post I realized that it was a great illustration of self-organization. That realization was in the forefront of my mind as I ran the session "Hands On Agile Immersion" on March 10th at Agile and Beyond 2012 .

Although I've trained large groups of people on Agile many times over the last few years, it never occurred to me to create a video of the experience. This time, I decided to do it to illustrate large-scale self-organization in action. There were eleven separate teams with no appointed leader.

All I did was set up the learning environment, provide the materials, and give just a few instructions for each activity. The participants did all of the learning/teaching as a self-organized team on their own.

In the span of only an hour and a half, all 11 teams taught themselves the basics of 9 Agile practices as follows:

  • Form cross functional, collocated teams
  • Pick a software product to "build"
  • Write 12 User Stories for that product
  • Put the stories into a backlog ordered by business value with the help of a Product Owner
  • Estimate the stories in story points using Planning Poker
  • Plan a release using 2 iterations worth of stories
  • Do all of the above as independent self-organized teams

The teams did self-organization so well, I was able to do capture lots of video clips of the session and only had to answer 4 or 5 questions about the mechanics during the whole 90 minutes of the session.

As always, one of the favorite things that people learned was "Planning Poker," an Agile estimation technique involving special playing cards. I told people I didn't need them back and I also gave away all of my extras. I brought 48 decks and they were all gone at the end of the session. Not even a single card was left behind!


A short video (4:10) of the session is available on YouTube .


Some folks from Macomb Community College made their own video (3:58). The "Hands on Agile Immersion" part goes from 1:25 until the end.

Friday, March 02, 2012

Agile is a Game

While attending a presentation at Agile New England last night on “Gamestorming” by Todd Lombardo I was reminded that Agile is a game. That may seem a bit uncomfortable for something that is done as a professional activity, but it is actually a very good thing from a business perspective. After all, what is a game? A game is an activity that is governed by a set of rules, has a goal, has a scorekeeping system, and is fun to do.

The Rules of the Game
Nobody really likes rules, but what is the first thing you ask when you are about to play a new game? You ask “what are the rules?” You want to make sure you understand all of the rules and that people are “playing fair.” When these two conditions are met it is a lot easier to learn how to get good at the game and have fun.

The rules in Agile are deceptively simple. They are things like "iterations should be no more than 4 weeks" and "all iterations should be shippable." Following the rules mostly involves unlearning years of what you will later realize were bad habits.

The best part of the rules in Agile is that they are so clear. Don't ask me what the rules are in traditional development. I have no idea and I played that game professionally for more than twenty years!

Winning the Game
The next question you ask when learning a game is “how do I win?” This is the goal of the game. It is important to know what the goal is so that you can work within the rules to achieve the goal.
In all of this, it is important to know how to keep score because it is usually how you know how close you are to your goal.

There are aspects of software development that make it difficult to know the actual score, which is the amount of value produced. Value is a lagging indicator which you don’t really know until after somebody has used what you have provided and given you back something in return. Most of the ways of “keeping score” within Agile, such as burn up and velocity, are really only a proxy for the real score (value produced), but they are still important to know and monitor.

The Fun of Playing
You may wonder what “fun” has to do with a professional activity. Well, I don’t know about you but if I have my choice between working in a “fun” environment or a not-fun environment, I’ll pick the fun environment every time. Another way to look at fun is “doing something that is satisfying.” I believe that most people want to gain satisfaction from their work and that usually comes from feeling that you have provided something of value that benefits others in some way. In my experience, high job satisfaction corresponds directly to personal productivity.

The game of Agile development is simple to learn and to play, at least in comparison to traditional development. As a result, it is much easier to reach the goal and provide a high degree of job satisfaction. In my book, that’s a win-win.

Cooperative Play vs Competitive Play
One last point on this subject is that Agile development is both a team game and a competitive game. It is a team game within your organization and it is a competitive game that your organization plays in the marketplace. Now, get out there and win, win, win!


Learn the rules of the game: Boston, March 20th, Agile Whole Team Training .

Sunday, February 26, 2012

Software Development Nirvana vs Hotfixes

The purpose of software development is not actually the development of software. If one could accomplish the same result that software development provides without developing any software, then that is what people would do. The purpose of developing software is to provide value to the user of that software. Ideally, the user could get new value from their software as soon as they realized that they needed it or as soon as somebody discovered something new that could be added that would deliver new value. But in the real world it takes time to deliver something new.

Development Efficiency vs Market Efficiency
The value of any particular feature erodes over time. If you take 2 years to develop a whole bunch of great new features and they were all developed really efficiently, that’s great, but what if the value of most of those features has eroded away during the time it took you to do it? You may have gained development efficiency, but you’ve lost market efficiency. Development efficiency is important because cost needs to be less than revenues or you’ll eventually go out of business. But market efficiency generally trumps development efficiency because revenue is so closely tied to delivery time. That is, the faster you can deliver something that people value, the faster you will get the return on that investment. Equally valuable is failing fast; learning that you are headed in the wrong direction and finding a new and more valuable tact to take.

Look at it this way. Which would you rather do? Option 1: plan to deliver 12 features in a year and “efficiently” deliver them in a year but only 4 of the features are a hit with customers. Option 2: have a flexible plan, make changes all year long, and deliver just 10 features in that same year, but 6 of the features are a hit with customers? Also consider that in option 2 the quality is higher. Hopefully, you picked option 2 and voted for market efficiency over development efficiency.

Software Development Nirvana
Based on this, I would say that software development nirvana would be 1 developer, 1 tester, and 1 user documentation writer producing changes and delivering them as fast as they possibly can. And of course the customer(s) are sending money to the team just as fast as that team delivers the software. I realize you may have questions about quality, architecture, and just how fast a customer can take changes. And of course we will want to be able to replicate what this small team does on a larger scale. Let’s park those thoughts for now and just consider that it is hard to imagine a more effective team than the one described here.

Hotfixes to the Rescue?!
It turns out that there is something that all development teams do that mimics this description of Nirvana. It is something that is done very quickly, gets whatever resources are needed, and is done because it is absolutely the highest value producing activity that the organization can do at the time that it is done. That’s right, a hotfix!

Why do you do a hotfix? Because if you don’t somebody somewhere will be losing a great deal of value. That value may be revenues, customer satisfaction, or something else of value. In any case, you do a hotfix because it produces the most possible value to your organization compared to anything else you could do at that moment. It may not seem like value, but negating a negative value is a positive value.

A good deal of my Agile thinking stems from this one observation: if the process used to resolve a hotfix is the best way to produce the highest value as fast as possible, then why don’t we do that with all of the software we produce all the time? One caveat is that most hotfix processes cut corners in order to go fast, but what if there was a way to do hotfixes without cutting corners? 


Read: "One Piece Flow", an intentional version of hotfixes.

Check out our free webinar "Panning for User Story Gold"
Date: March 6th at 1pm ET.
Description: "Putting User Stories into business value order is a key tennet of Agile, but that's just the first step. There's much more value to be extracted from your user stories using specific story splitting techniques combined with reducing cycle time. By splitting user stories you can separate the gold from the dirt as well as reduce the cost of implementation. This session will cover a variety of methods for splitting user stories and reducing cycle time including the "create/read/update/delete" method, the acceptance test method, the split by value method, frequent grooming, Kanban flow, and software tool support."

One Piece Flow

One piece flow is a concept from Lean and is the key to succeeding with Agile. One piece flow is exactly what is done when producing a hotfix. The only difference is that one piece flow is an intentional practice rather than something done in reaction to a critical problem.

There are four main concepts in “one piece flow.” Each story is done as if it was the only thing in the release, each aspect of developing a user story happens in rapid succession, there is as much done in parallel as possible, and each team member focuses on a single user story at a time. The result of one piece flow is that the time between when the team first starts working on a user story and when they can ship it fully developed, tested, and documented is very short. The timeframe is generally on the order of a week at most and usually days.

In one piece flow, when development starts on a story, QA should be creating test cases for that story (story testing) at the same time. When development is done, QA should then automate the test cases and make sure they all pass. At the same time, the user documentation is written. One last step that must be completed prior to considering the story done is that all of the artifacts connected to that story such as source code changes, documentation updates, new test cases, etc must be integrated into the source code mainline.

Ideally, when following one piece flow, you would have done everything required to release the product to validate that the story really is done. That’s generally an impossible goal when just getting started with Agile, but it is a goal to keep in mind as you go. When working on stories, try to adhere to the principle of one piece flow to the greatest extent possible. As you read on you will find additional practices which simplify and reinforce the practice of one piece flow.

One last point. It may sound from the name that you can only work on one story at a time when following one piece flow. But really it means that for any story that is being worked on, it is progressing as fast as it possibly can without anybody that is working on it switching between multiple tasks. Another way to look at it is that the team should only be working on more than one story if the second story can be worked on without affecting the total time it will take to complete the first story. Likewise, the team should only be working on three stories if it won’t affect the total time it will take to complete the first two stories on an individual basis, and so on. A good rule of thumb is to only be working on as many stories simultaneously as you have developers on the team.

Friday, February 24, 2012

Burning Down Hours is Anti-Agile Because Working Software is the Primary Measure of Progress

A burn-down chart can use anything for the units, such as hours or points, but originally Scrum's burn-down chart tracked hours of work remaining in the iteration. Many people still use an hours-based burn-down chart as their primary measure of progress during an iteration. That’s a useful tool, but it is similar to tracking yardage in an (American) football game. It measures activity, but not accomplishment. After all, what percentage of a touchdown is 30 yards?
Working Software is the Primary Measure of Progress
One of the principles from the Agile Manifesto is "Working software is the primary measure of progress". But burning down hours is measuring and reinforcing progress against a plan without any requirement to have working software until the end of the iteration. That's pretty much the same as not having to have working software until the end of a waterfall release! This is one of the reasons that many people have moved away from burning down hours or supplemented it with other tools, such as burning up story points.
Burning Up Points to the Rescue
The Burn-up by points chart is one of the very best tools in Agile. It brings together many of the best aspects of Agile all in one place and gives you an instant heads up as to how you are really doing. The way a points-based burn-up chart works is simple.

For the iteration you are about to commence, total up the story points in all of the stories you have targeted for that iteration. Let’s say it made up of two 5 point stories, two 3 point stories, one 2 point story and two 1 point stories. That’s a total of 20 story points. Make a chart with an X axis that represents all of the days in the iteration from the first day to the last day from left to right. Let’s say it is 10 days. The Y axis represents the number of story points completed and in this case would go from 0 to 20 story points.


At the end of each day you tally up the story points associated with all of the stories that meet your definition of “done” and record the total on the chart. For instance, if you completed a 1 point story on the first day, nothing on the second day, and a 2 point story on the second day, your chart would have a 1 point bar for the first day, a 1 point bar for the second day, and a 3 point bar for the third day.

A points-based burn-up chart lets you see graphically day-by-day how much progress you are making towards your goal. It only records accomplishment, not activity, and allows you to see if you are on track or getting behind. To me, this is exactly what is meant by "Working software is the primary measure of progress."

Won't The Chart be Empty Until the End of the Iteration?
At first you may think that the chart will show that you are behind for most of the iteration and catch up only at the end when QA is able to start testing and marking stories as done, but whenever the chart shows something other than a steady march to the end of the iteration, here are some of the questions you should be asking:
  • Are our user stories too big? Is that preventing QA from getting involved earlier?
  • Are people working on too many stories at once?
  • Are we unable to produce a stable build for QA to test?
  • Are developers producing a bunch of problems and then going on to the next story instead of helping QA resolve the problem?
  • Should the developers drop what they are doing and lend a hand writing automated tests?
Using a points-based burn-up chart gives everybody, from team to manager to the organization as a whole, an instantly understandable picture of the health of the project and team. It simplifies the life of the manager because if it indicates a problem anybody can stand up and say “hey team, we’re messing up, what are we going to do about it team?”

A burn-up chart reinforces the following ideas:
  • Use story points for estimation, it enables whole-team thinking such as this whole-team metric.
  • Make stories as small as possible to get them done as fast as possible to keep the focus on accomplishment rather than activity
  • Have as co-located and as cross-functional a team as possible to enable the fastest possible turn-around time on stories
  • Enable the team to work as a team and to manage more things on their own
Unlike Burning Down Hours,  Burning up by Points is Fully Automatic!
You may not be ready to give up burning down hours yet, but there's no reason you can't use both. And most Agile Project Management tools, such as Rally , Version One, and Jira will generate a points-based burn-up chart for you automatically.

There's one more reason you may want to consider moving from burning down hours to burning up points, assuming your user stories are small enough in general and you are mostly getting stories done all the way through the iteration. In my experience, team members don't really like having to enter their hours remaining for their tasks every day, often forget to do it, and it keeps the focus on activity rather than accomplishment. Also, the only manual step required is to mark the story done, which helps to make the whole process much smoother.



[Excerpted from my free eBook "Do It Yourself Agile Kickstart". ]