The Cabbage Tree Method: Open Source Collaborative Product Design

The Cabbage Tree Method: Open Source Collaborative Product Design

By Adam Hyde
Book Description

Imagine a bunch of people in a room, all sitting around a table. There are some whiteboards in the room, and coffee, sticky notes, and maybe even a data projector, litter a table. All of those people, except one, share a common problem and they want to create new software to solve it.

But where do they start? There are no developers here … what’s going on? One of them, the facilitator, steps up and initiates a short period of introductions and then asks the question “What is the problem?”

From this, a process unfolds where the people who need this new software (let’s call them the use case specialists) explain all their frustrations with the ways things are done now and what could be better. It is a wide-ranging discussion and everyone is involved. At the facilitator’s prompting, someone jumps up and draws a straggly diagram of a workflow on one of the whiteboards to get their point across. Another pipes up to add nuance to one part of the diagram because they fear the point wasn’t adequately understood. There are some quiet moments, some discussion, lots of laughter, a break for lunch. Plenty of coffee.

Throughout the day, the group somehow (the facilitator knows exactly how) evolves their discussion from big picture problems and ideas to a moment where they are ready to start designing some solution proposals. The facilitator breaks them into small groups and each group has 45 minutes to come up with a solution. When they come back, each group presents their ideas. Some of the ideas are very conceptual, almost poetic. Other ideas are very concrete and diagrammatic. Everyone thinks carefully about the merits of each proposal and what it is trying to say. Discussion ensues. Members of the group ask clarifying questions. After all the proposals are made, they decide on an approach.

In a short time, they have agreed on a set of requirements for software that they have consensus on and all believe will solve (at least some of) their problems. They take photos of all the whiteboard diagrams and document the design agreements thoroughly, creating a Design Brief. At the end of the day, they walk out the door and the design session is over.

The next day the Build Team, featuring user interface (UI), user experience (UX), and code specialists, looks over the documentation with the facilitator through remote conferencing. They discuss the brief, what is clearly defined and what is still to be defined. They work through the issues together, jamming out approaches to open-ended questions which are both technical and feature-focused. The session is not long, perhaps two hours. It’s a lot of fun. From this session, the Design Brief is updated with the decisions. Many technical solutions are left wide open for the code specialists to think through and solve over the next weeks. However, the code specialists can, and do, start work immediately, though the UI/UX specialists add mockups to the documents over the next days. The team works things out on the fly where necessary and gets onto it. Over the next weeks, a few questions to the use case specialists surface – these are either asked directly or through the facilitator.

The use case specialists reconvene six weeks later with the facilitator and are presented with the working code that has been created by the build team over that period. Everyone is amazed. It’s just as they imagined, only better! After seeing the working code, they each have further, exciting, insights into how this problem might be solved. The facilitator steps up and they go through it all again to design the next part of the solution. Everyone is bursting to have their say.

The design-build cycle is repeated until they are done and the software is in production.

This is the Cabbage Tree Method.

Table of Contents
  • Introduction
    • How this Book Was Written
  • Thoughts About Open Source
  • What Is the Cabbage Tree Method?
    • The Cycles of CTM
      • Design Sessions
      • Build Period
  • Getting Started
    • The Set Up
      • The Problem
      • The Facilitator
      • Stakeholder Commitment
      • A Venue
      • A Goal
      • User Interface and Code Specialists
  • Design
    • The Design Session
      • The First Design Session
        • Phase One – Why Are We Here?
        • Phase Two – Where Are We Now?
        • Phase Three – Where Are We Going?
        • Phase Four — How Do We Get There?
          • Blank Canvas
          • Pitching
          • Give Them the Pen
        • Phase Five — Summarise and Capture
        • Phase Six – Working Agreements
        • Build
      • Subsequent Design Sessions
        • Where Are We Now?
        • Where Are We Going?
        • How Do We Get There?
        • Summarise and Agree
    • Effectively Facilitating the Design Sessions
      • Facilitation Tips
  • Build
    • The Build Period
      • The Design Brief
      • The Build Meeting
      • The Build Period
    • Facilitating the Build Period
  • Onwards
    • Adoption and Diffusion
  • Things to Think About
    • Let's Be Friendly
      • A Personal Example
      • Attribute Generously
    • Cabbage Tree Open Source
    • Colophon
The book hasn't received reviews yet.
You May Also Like
The Cryptoparty Handbook
The Cryptoparty Handbook
By Adam Hyde
Also Available On
Curated Lists