This is a self-published book that covers a lot of ground, and it has some flaws. Reading this feels a bit like experiencing a non-stop high velocity flow of ideas (sorry, couldn’t resist) that can be roughly organized and overwhelming at times (I was reminded of the character Jordan from the movie Real Genius).
But the ideas themselves? They are crazy thought provoking. This book has me thinking a lot, and I think you could choose almost any section of it and dig into the ideas for weeks before coming up for air. This book will definitely require a re-read to fully explore what I’ve discovered from reading it, and I expect to find it just as fascinating the second time through.
As the subtitle might have you guess, this is primarily focused on solving painful projects. As I read the book, I thought back to various projects I’ve worked on where Idea Flow could have made a tremendous difference in our ability to identify the correct problems, and sell the executives on why we needed to invest in fixing the issues identified. I’ve recommended the book to several folks who are currently working on projects that have a lot of “pain” and I expect it will help them quite a bit. One strong reaction I have after reading the book is that Idea Flow strikes me as an idea that would be very difficult to implement as a top-down initiative. This is a developer-led movement for sure — the amount of data that needs to be collected could easily be perceived as very “big brother”-ish (in fact, more than one developer I’ve described it to used exactly those words) as a management initiative. Klein’s own suggested presentation supports this:
I want to make the business case to management for fixing things around here. No more chaos and working on weekends, this needs to stop. I need data to make the case to management, though, so I need everyone’s help.
I also haven’t fully figured out my own reaction here, but although I think this framework could offer a lot of value to many teams (including teams that I’ve worked on in the past), I’m quite convinced that the approach described here would add little if any value to my current team. Why is that? I’m not sure — perhaps my team is small enough that the communication of ideas between the developers and code are easier to keep in sync. Perhaps it’s simply that the codebase itself is small enough. Maybe it’s just that the group of developers are similar enough to make ideas flow naturally. I’m also willing to concede that I may be flat out wrong. I know I’m going to be thinking through this for a while though, and trying to figure out why I think that this is true.
Klein’s ability to describe the escalation of pain in our processes can occasionally feel like re-living the very worst of our professional experiences:
The pain doesn’t happen all in one step. One decision usually sets up the preconditions for an unavoidable high-risk situation later.
The classic example of this in software is writing confusing code. When the code is written, the author can manage it fine, get it working and deployed to production. There is no immediate impact from this decision. The problem comes in when we have to understand or modify that code and there is suddenly a high risk of making mistakes.
The best way I’ve found to explain these problems, I picked up several years ago from an article by Scott Bellware. The pain comes from an increase in the number and severity of safety hazards.
When we use analogies like land-mines, fires, and various types of hell, we’re referring to the hazards in our everyday work. We may not be working with sharp objects or explosives, but the anxiety, stress and exhaustion from working in a hazardous environment is very real.
Likening these conditions to working around land-mines makes a lot of sense. We aren’t necessarily aware that we’re in a high-risk situation until we happen to step on the land-mine and something explodes. The lack of awareness makes these conditions all the more dangerous. It’s the knife that’s in the wrong drawer, the toys left out on the stairs, the loose screws in our bicycle. Hazards increase the risk of injury.
Let’s say we deploy some changes, then later realize we made a mistake. Our code is doing something horrible like over-charging our customers. Now we have an urgent situation on our hands. We care about the company and don’t want to fail, so we do whatever it takes.
Suddenly we’re working late nights and weekends, choking down Red Bull to stay awake, and hacking out last minute changes. We might end up breaking something else in the process.
It doesn’t matter if we’re sick, if we were supposed to go watch our kids’ recital, or meet our spouse for an anniversary dinner. When things go wrong and our project is online, we sacrifice a lot. At the moment of urgency, we can no longer choose safety.
By compromising safety, we increase the likelihood of making mistakes and the pain from the impact. Things don’t always go wrong, we’re gambling. If we’re lucky, we save time. If we’re not, we can lose big. The more we lose, the more time pressure builds and the more compelled we feel to gamble.
Compromising safety pulls us into a vicious cycle that’s fueled by constant urgency. We keep rolling the dice and making riskier and riskier bets, in an attempt to save time, but in the long-run our optimizations backfire.
The book is self-published and, as with many self-published books, it occasionally flared the OCD grammarian in me. A bigger problem for me is that it was not possible to read this on my kobo for two reasons. First, the images flow off to the right of the page, so they’re not fully visible. But even allowing for that, color is required for understanding the images — you’re going to have to read this on a color screen (or print it out, I suppose).
Organizationally, the book could use the hand of a professional editor as well. One example — the book could do a better job of laying out the mechanics of how idea flow mapping works and how to read an idea flow map a little earlier and more clearly. It’s not a complicated topic, but the book jumps quickly into showing idea flow maps without a sufficiently basic primer on what they are and how they work. By the end of the book, I think I understand how they work, but during the first few chapters I often felt lost.
Regardless of these small complaints, the book and it’s ideas are well worth exploring. You should go read it! If you’re not the reading type, you should at least watch Klein lay out her case here: Let’s make the pain visible