No Bugs Journey Episode 1: Inventory

Over the past few years I had the opportunity to work in an environment in which we achieved a significant reduction in bugs and an associated increase in quality and developer satisfaction.

This series will be about how to start the journey from wherever you currently are to a place with fewer bugs, and a bunch of things to think about and perhaps try on your team. Some will be applicable for the individual developer, some will be about an engineering team, some will be for the entire group.

As with all things agile, some techniques will work great for your team, some may require some modification, and some may not work at all. Becoming agile is all about adopting an experimental mindset.

Whether you are on a team awash in bugs or you are already working towards fewer bugs, I hope you will find something of value.


We’re going to start by stepping back, taking stock of the situation, and practicing the “Inspect” part of the agile “Inspect and adapt” cycle. We’ll be using a feedback technique that is often used in agile groups.


The agile software community is very effective at finding useful techniques outside of the field and adopting them, which is great. They are not great at giving credit for where those techniques were created, so there are a lot of “agile” practices that really came from somewhere else. Which is why I wrote “is often used in agile groups” rather than “agile technique”…

The technique we’re going to use is known as “affinity mapping”, which has been around for a long time.


(Note: the following exercise works great as a team/group activity as well. If you want to do it as a group exercise, go find a few videos on affinity mapping and watch them first).

Find some free time and a place where you won’t be disturbed. Get a stack of sticky notes and a pen.

Your task is to write down the issues that are contributing to having lots of bugs, one per sticky note. Write down whatever comes into your head, and don’t spend a lot of time getting it perfect. You can phrase it either as a problem (“lots of build breaks”) or a solution (“set up a continuous integration server”).

Start with what is in the forefront of your mind, and write them down until you run out of things to write. There is no correct number to end up with; some people end up with 4 notes, some people end up with 20.

Now that you have done that, look at this list below, and see if thinking about those areas leads you to get any more ideas. Write them down as well.

  1. Planning
  2. Process tracking and management
  3. Reacting to changes
  4. Interactions between roles (dev, test, management, design, customer)
  5. Recognition – what leads to positive recognition, what leads to negative recognition
  6. Who is respected on the team, and why?
  7. Promotion – what sort of performance leads to promotion
  8. Developer techniques
  9. How is training handled
  10. Who owns getting something done

This second part of the exercise is about thinking different (aka “out of the box”), in looking for non-obvious causes. I’m explicitly having you do it to see if you come up with some of the topics that I’m going to cover in the future.


We now have a big pile of sticky notes. Our next task is to review the notes to see if there is any obvious clustering in them. Put all of the notes up on a wall/whiteboard, and look at them. If you find two notes that are closely related, put them next to each other. If you are doing this as an individuals, you will probably only find one or two clusters; if doing it as a group, you will find more.

Note that we are not doing categorization, where each sticky is in a group. At the end I expect to see a lot of notes that aren’t in clusters. That is expected.


Take a few minutes and look at what you have. My guess is that you have a decent list of issues, and my hope is that you thought of things that you weren’t thinking about before.

At this point, you might be saying, “If I know what the issues are, why shouldn’t I just go off and start working to address them? Why do I need to read what Eric says?”

If you said that, I am heartily in support of the first statement. Determine which sticky/cluster you (or your team) wants to tackle, figure out a small/cheap/low-risk experiment that you can try, and start making things better.

As for my value-add, my plan is for it to add value in two ways:

First, I’ve been through this a few times, and my guess is that you missed a few issues during the exercise. I know that I missed a ton of stuff the first time I tried this.

Second, I’m hoping to give some useful advice around what techniques might be used for a specific issue, common pitfalls, and ordering constraints (you may have to address issue B to have a decent chance of addressing issue A).

Next time

Next time I’m to talk about the incentives that are present in a lot of teams and how they relate to bugs.

No bugs journey episode 2: Stop encouraging your developers to write bugs

It’s about to get real.

Comments (3)

  1. Mark Levison says:

    Eric – thanks for helping the world become aware of zero bugs as sane sensible target. This is much needed and has just been added as suggested reading for people who attend my Agile for Developers course.

    Small detail – the agile community struggles to remember who came with great ideas and mis-attributes just like normal people. For years I've been crediting Beck for 7+/-2 people on team. Now recently Ron J and others suggested to me that it was either Schwaber or Sutherland. I've been part of the community for 15 yrs and still make these mistakes.



  2. ericgu says:

    My understanding was that 7 +/- 2 came out of psychological research. I've been meaning to write something about this for a while, but the short version is that I don't like it; First off, I've seen it used a couple of times to justify teams of 9 or 10 (and my experience is that those are way too much work), and I suspect that the best size is 5-7.

    On the subject of attribution, you are of course correct for the agile influentials; i was speaking more about  the people who are applying agile. I've seen times where somebody says, "there's this great concept from agile called a Kanban board". It mostly bothers me because it cuts off the exploration that somebody might do if they knew about something known as "lean"…

  3. Mark Levison says:

    Mis-attribution is a problem far beyond Agile. If we look at any creative endavour, poetry, fiction, … most creative work is a collaborative. The collaboration gets missed because historians focus on the author forgetting the others involved. Classic examples include the Inklings group @ Oxford influencing Tolkien and CS Lewis; Kubla Khan by Coleridge etc. In many creative endavours we often forget the details of the source and in so doing create small new changes to the idea.

    BTW I owe this point largely to Keith Sawyer and his book Group Genius which makes for interesting reading.

    As to 7 -/+ 2 the details get better the more you dig into it. Since the they based on Millers number – something which is largely outdated and definitely not applicable.

    Ping me mark @ agilepainrelief dot com if you ever want to chat about teams offline.

Skip to main content