Where design thinking and open source community collaboration meet


I’m currently reading the new book on design thinking from IDEO’s Tim Brown called Change By Design. (Full review coming soon.) The design thinking philosophy was first introduced to me, and to Red Hat throughout the company, by David Burney.

In comparing traits associated with design thinking collaboration and collaboration in the open source community, there are many parallels: open exchange, broad participation, rapid prototyping.

There’s also one really interesting contrast: The mindset you tend to see when generating and choosing ideas. But what I’ll suggest here is that when you apply the best elements of these two mindsets at just the right time in their respective processes, the results can be pretty amazing.

I’ll start with design thinking.

The brainstorming phase of design thinking is probably the most recognizable part of the process. These brainstorming sessions are designed to be open. Lots of ideas are generated, ideas are built on ideas–there are no bad ones. To do that, we have to establish ground rules. Stanford’s d.school posts their list, and our rules at Red Hat have many similarities. Rather than criticizing someone’s ideas, you have to build on them and suggest your own. No devil’s advocates allowed. In this environment, a good collaborator is one who generates and encourages the most ideas from others.

There are a few good reasons for the rules. First, criticizing an idea too soon can kill that idea in its most fragile state. It doesn’t give others a chance to carry it forward and improve on it. Second, even the wildest–sometimes worst–ideas could spark a great idea in someone else. This happens all the time. Often the worst ideas and best ideas are closer than they seem.

And third, it’s essential to create an open, positive environment so people are willing to share their ideas and explore. You’ve got to believe the best idea is always right on the verge of discovery.

Community collaboration is similarly open, but can be somewhat less nurturing.

A solution is found to have merit when it can stand up to scrutiny. In other words, what doesn’t kill your idea makes it stronger.

Here a good collaborator is often the one who finds the most bugs. So rather than looking for the positive aspects to build upon we look for holes. And that’s a good thing. As the classic open source saying goes, “With many eyes, all bugs are shallow.” It’s better to find them in beta.

But that doesn’t make it easy. In fact, sometimes it can feel like a middle school dodgeball game where you put yourself up against the wall and invite your classmates to take their best shot.

There are good reasons why this environment works this way, too. If a solution is going to fail, it needs to fail early so it can fail forward. A tough testing environment isn’t going to get easier in the real world.

Second, in open source the code is shared, so there’s always a possibility, and even an expectation, for improvement. A solution can always be better. If you’re lucky, you’ll find lots of people to tell you so. If you’re really lucky, they’ll offer to help fix it. That’s the beauty of the model.

In both cases, each environment is dependent on an open exchange. Everyone has access to information. Many people participate. Even design thinking processes have a prototype stage.

But even though their mindsets may seem in conflict with each other–I believe they’re two important functions of the same process, simply applied at different stages:

When you’re in the early stages of brainstorming and generating ideas–take care to protect creative thinking and the ideas they generate so those ideas can multiply.

And when you’ve got that idea you think is good–then it’s time to to put it to the test. Find the holes. Invite smart people to do the same. I’ll be the first to admit this is far easier said than done. Sometimes it can be nearly impossible. But if the idea is still standing at the end, it’ll be all the better for it. And then you know you’ve really got something.


2 Replies to “Where design thinking and open source community collaboration meet”

  1. Yep. Diverge first, then converge on the best idea(s).

    I’m one of the UX leads for Drupal, and I’m finding that the challenge in an open source/developer driven process is nurturing this environment for generating multiple ideas first.

    The process is often fully geared towards the scrutinizing peer review part. I see a lot of straight-to-solutioneering ‘fixing’ that never took time to get the actual problem clearly defined first.

    Which media/channels/tools have you’ve seen used succesfully for creating an online ideation phase? Bug trackers are not it, that’s for sure.

  2. Thanks Roy. Well said.

    It’s hard to resist the temptation to jump to that fixing phase. It almost takes a common understanding up front by everyone that all ideas are on the table, and that the group will reserve judgement until all of those ideas have an equal chance to be heard.

    Regarding tools, from what I’ve seen, I think tools are kept very simple on purpose–everyone knows how to use them, and then people focus more on the idea than the tool itself.

    Of course wikis make great, simple tools for ideation because anyone can make changes easily and all of those changes are tracked. And a lot of good work still gets done on mailing lists because email is so accessible and pervasive.

    Thanks again. Keep up the good work on Drupal.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: