On the Relation between Designing and Implementing in Permaculture – Part 8

Welcome back to the next instalment in this inquiry into the relation between designing and implementing in permaculture design. We are now up to post 1, 2, 3, 4, 5, 6, 7, 8! I don’t know about you, but for me it’s been a fascinating journey with some unexpected twists and turns.

Speaking of twists and turns, in the last post I zoomed way out and up from permaculture to consider design process discussions in general. There, starting from the wickipedia design entry, I followed my nose to something called the Agile approach.

The Agile Approach

From what I can gather, the Agile approach is the pointy end of the action-centric stick we discussed in the previous post.

It is an approach to software development that in less than two decades appears to have revolutionised its field. Agile is apparently now used by more software developers than any other approach. There are hundreds upon hundreds of books about it, and it is being rolled out into business management, project management, process managementmarketing, naval ship deploymentweddingsfamily life (for better or worse!) and much else.

In short, it’s a thing.

So what kind of a thing is it?

While this is the best introduction I have found online, I’m delighted to hand this next bit over to someone who can speak both permaculture and agile. Paul d’Aoust, who in a recent comment explained:

I’m a software developer by day (permaculture designer wannabe on the weekends), and a lot of what you said resonates strongly with me. Over the past few decades, the software development world went through a similar set of discoveries ­— ‘Big Design Up Front’ (BDUF)1 didn’t work well because (a) it assumed too much about the client’s needs, (b) it wasn’t capable of changing its course quickly if client needs changed, and (c) it assumed that the expressed needs of the client truly were the real needs of the client.

Nowadays the darling software development methodology is called ‘Agile development’, expressed most succinctly in the Agile Manifesto http://agilemanifesto.org/ Design and implementation cycles happen regularly (typically somewhere between weekly and monthly), and the goal of each cycle is working software that meets real client needs. (Any given iteration might add anything from a few accounting-related functions that spit out the correct answers, up to a new user interface element that solves a recently discovered pain point for customers.)

The emphasis is on relationships with the client, solving the right problems, small iterations with tight feedback loops, nimble decision-making, and demonstrable results. Sound familiar? Sounds a bit like “integrate rather than segregate”, “articulate goals accurately”, “apply self-regulation and accept feedback”, “creatively use and respond to change”, and “obtain a yield”.

See also this further comment from Paul, this note from Ethan Roland of Appleseed Permaculture and additional mentions of Agile-Permaculture affinities here and here and here and here.

So where does this land the agile approach in terms of the categories I developed in the post before last? Here they are again:2

As Paul says, a foundational principle of agile is breaking tradition with up-front design and getting implementation into the design process as early as possible. So Agile is by definition anti-CDDUF. But there are two remaining places it might sit. This further note from Paul helps us locate which:

One mismatch that I see between agile software dev and permaculture is that agile typically just starts working on details and expects a cohesive design to emerge, whereas with permaculture we try to get the big design right to avoid any foundational errors. This is a bit of a caricature, I guess; a good agile developer is always thinking about patterns and overall architecture as they build individual elements. Still, it’s definitely a detail-to-pattern approach.

Despite the apparent lack of up-front design, this works surprisingly well, because (as the Agile axiom goes) you never know what you’re supposed to be building until you start building it. I think another reason it works so well is because of another Agile axiom: refactor (tweak/modify/rearchitect) mercilessly as your project grows.

Clearly Agile belongs if anywhere in the CDDAYG (concept and detailed design emerges as you go) camp. Indeed, taking Paul’s above comment on board it is almost like a new sub-category DCDAYG (let detailed then concept design emerge as you go) might be a better fit. But let’s not get too carried away here with such details (or concepts). I’m putting Agile down as CDDAYG.

So, coming back to the thread of this inquiry as a whole, it is interesting to reflect that:

  • Permaculture design process is presented by the permaculture literature in general as all about the big CDDUF (completing a concept and detailed design before implementing)
  • Leading permaculture design process practitioners and writers on a closer look are actually are more about CDUFDDAYG (concept design up front then detailed design emerges as you go – e.g., Bill Mollison, Dave Jacke) sometimes also edging into CDDAYG (concept and detailed design emerges as you go – e.g., David Holmgren, Ben Falk), where, as Paul put it, “with permaculture we try to get the big design right to avoid any foundational errors.” It seems to me likely that over time that permaculture’s centre of gravity will drift in this direction (though a lot of work is still required to clarify the details).
  • Christopher Alexander and the wildly popular, influential, and fast-growing Agile approach are over in CDDAYG.

A Key Difference Between Developing Software and Developing a Landscape

I want to emphasise a key difference between software development and landscape development: the relative reversibility of implemented decisions.

My friend Tom Sparrey has put it this way:

Agile works so well in software because you’re dealing with digital elements, easily rolled back or altered if there’s a functionality problem or bug, whereas in the physical world if you make a big change (i.e. a $10,000 new driveway), you want to make sure you’ve considered it thoroughly (plenty of immersing/emerging) before making a move.

I will come back to this matter in subsequent posts. In particular, I will be exploring this question: does this relative irreversibility in changing the physical (as opposed to a virtual) landscape require a whole-site concept design up front? Or is there some way of safely entering the realms of CDDAYG short of this? Thankfully this is an empirical question and so I’ll be testing it empirically, in the context of a full-scale permaculture property design and development project.3

The Plot Thickens

The day I started writing this post maybe a month or so ago, I was emailed by Takeshi Kakeda4 who is not only a Japanese student of both permaculture and the work of Christopher Alexander5 but a software development consultant.

Naturally, in my reply, I mentioned that I was at that moment researching the Agile movement in software design. He replied explaining that a well known instance of agile called extreme programming (or XP)6 was hugely influenced and informed by the work of none other than Christopher Alexander! Takeshi went on to say that:

Software people paid attention to Alexander’s work, and have been interchanging since the 20th century.7

A few weeks later Paul commented that:

The early proponents of Agile were also big fans of Alexander8

Then Lilian Ricaud added this comment:

Like Paul d’Aoust I emphasize there is a strong link between what you described and the methodologies used by agile practitioners (Ward Cunningham was strongly influenced by Christopher Alexander) and design thinking methodologies.

Reminding me of his interesting essay Permaculture patterning: a design framework for systemic transformation (2015) in which he wrote:

Indeed, in the last few years new schools of thought have emerged in the design field. Pioneered by developers seeking to improve their ability to deal with complex software building projects, agile methodologies embed in their process several principles common to pattern languages and per- maculture approach: (iterative steps, structure- preserving unfolding, adaptive instead of predic- tive approach, use of feedback…). Interestingly Ward Cunningham, inventor of the wiki and one of the main actors of the extreme program- ming methodology and the Agile Manifesto was directly influenced by Alexander (p. 202)

Following up these comments, I found this on Christopher Alexander’s wikipedia page:

In the field of software, Alexander is regarded as the father of the pattern language movement. The first wiki – the technology behind Wikipedia – led directly from Alexander’s work, according to its creator, Ward Cunningham. Alexander’s work has also influenced the development of agile software development and Scrum (From the Wikipedia entry on Christopher Alexander)

Well this was a surprise! No wonder Agile is over with Alexander in our diagram – Alexander was a formative influence in its very creation!

Digging Deeper into the Alexander-Agile Connection

This discovery left me curious to track down the point where Alexander’s thinking started wielding an influence on software development. I believe I found it. At a significant gathering of computer programmers in 1987, Kent Beck (father of the Agile approach called XP or eXtreme Programming) & Ward Cunningham (inventor of the wiki9presented a technical note in which they wrote:

We propose a radical shift in the burden of design and implementation, using concepts adapted from the work of Christopher Alexander, an architect and founder of the Center for Environmental Structures. Alexander proposes homes and offices be designed and built by their eventual occupants. These people, he reasons, know best their requirements for a particular structure. We agree, and make the same argument for computer programs. Computer users should write their own programs. The idea sounds foolish when one considers the size and complexity of both buildings and programs, and the years of training for the design professions. Yet Alexander offers a convincing scenario. It revolves around a concept called a “pattern language.”

A pattern language guides a designer by providing workable solutions to all of the problems known to arise in the course of design. It is a sequence of bits of knowledge written in a style and arranged in an order which leads a designer to ask (and answer) the right questions at the right time. Alexander encodes these bits of knowledge in written patterns, each sharing the same structure. Each has a statement of a problem, a summary of circumstances creating the problem and, most important, a solution that works in those circumstances. A pattern language collects the patterns for a complete structure, a residential building for example, or an interactive computer program. Within a pattern language, patterns connect to other patterns where decisions made in one influence the others. A written pattern includes these connections as prologue and epilogue. Alexander has shown that nontrivial languages can be organized without cycles in their influence and that this allows the design process to proceed without any need for reversing prior decisions

Hmm, this tempts me to dive a little deeper than I intended to go inside this particular inquiry. But oh well, what the heck. Let’s go there. Yo see I have been aware for a while that at some point someone needs to properly explore the relation between Alexander’s work on pattern languages (which permaculturalists are very fond of) and his work on the design-implementation relationship inside a nature-mimicking organic unfolding process (which permaculturalists seem to have missed or at least not mentioned if they are aware of it). For, as Alexander stressed more and more throughout his career, the two are intertwined to the point of being inseparable if the application of either is to be done justice.

In the above snippet, which I believe marked the start of Alexander’s enormous (if completely unintentional) influence on the software development world, Kent and Ward convey at least two significant aspects of Alexander’s pattern language concept when applied as he intended:

  • As soon as you start breaking down the boundary between design and implementation you start breaking down the boundary between designer and user. The user becomes a design participant rather than a design recipient.
  • You can do this incrementally and iteratively in a way where you can implement bit-by-bit (where implementation is inside and integral to design rather than happening afterwards) and yet not have to then go back and reverse a prior decision. In their words, “nontrivial languages can be organized without cycles in their influence and that this allows the design process to proceed without any need for reversing prior decisions.” Alexander himself came to call these “backtrack-free sequences,” which we will return to in a very practical way later in this inquiry.

Now Kent and Ward don’t in the above statement clarify fully what they mean by “a radical shift in the burden of design and implementation.” But given that a cornerstone of the subsequent development of the Agile approach (Which Kent and Ward were key players in) is moving away from CDDUF (concept & then a detailed design up front) toward CDDAYG (concept and detailed design emerges as you go) with a crazy-tight continuous iteration between designing and implementing (and hence designer and user or client) I think it’s clear they were tuned into the significance of this stuff from the start. They got pattern languages. But they also got the idea that the patterns therein work their best only inside a generating as opposed to a fabricating process.


Wow. Epic. When I casually googled “design process” at the beginning of the last post, I had absolutely no idea what I was getting myself into.

We’ve seen that Alexander’s critique of the conventional separation and chronological sequencing of design and implementation has triggered massive, global-scale transformation in the software design community (via the Agile movement). This transformation is being embraced and channelled in almost every direction imaginable.

Despite permaculture’s soft spot for Alexander’s pattern language concept, Alexander’s more fundamental ideas about the character of nature-mimicking design in terms of what it means for the relation of design and implementation do not yet seem to have been fully appreciated (at least to the point you find this stuff mentioned in the permaculture literature).

In spite of this, I have detected a movement inside part of what we might call the cutting edge of permaculture design away from CDDUF (completing a concept and detailed design up front before implementing) and toward CDUFDDAYG (concept design up front then detailed design emerges as you go).10 In David Holmgren and Ben Falk’s case we’ve even seen an inclination towards going a step or two further into the land of CDDAYG (concept and detailed design emerges as you go) – the land Alexander and the Agile folk appear to reside.

Now I don’t know what you make of all this, but I personally would venture the following conclusion. In at least one important respect, many modern software designers are using design processes that are more sophisticated, more throughly researched and crash tested, more adaptive, and in some ways even more nature mimicking than the processes used (or at least publicly taught and communicated) by permaculture designers, who ostensively are all about mimicking nature!11

What is up with that!?!

One might even go so far as to claim that in its insularity from design science in general, and software development process in particular, permaculture as a whole has quite simply been left behind when it comes to the best and most effective design process understandings.

Yes, at the end of the day this stuff has been used in software design to more efficiently generate, well, software. I am not saying the stuff it creates there is necessarily of that much interest to permaculture.12 I am saying that the way in which it creates that stuff maybe should be, given that it is some important ways several steps ahead of the game.

As a permaculturalist, I have to admit I found this all a little embarrassing at first. But in a good way! In a motivating way! In a “sleeves up people – we got some catching up to” do kind of way.

The findings of this post have clear implications for our inquiry. In a twist I never would have expected, as we strive toward a fresh and more internally consistent conceptualisation of permaculture design process, we’ve realised that as counterintuitive as it may seem for people interested in real plants and animals and water and soil and sunlight, the agile movement in contemporary software programming may have a lot to teach us about getting better at what we do in our own domain.

In the next post, I’ll start introducing some field-experiments13 where I’ve been putting some of these ideas to the test on the ground.


  1. This is where I got the idea for the acronyms in the last post – yep, you can blame Paul
  2. Note adding the terms of the last post, we we might say fabricating is akin to the ‘rational model’ and generating the ‘action-centric model’.
  3. Thanks to a trusting group of clients including Tom and his new driveway!
  4. Takeshi was asking permission to translate and republish some Making Permaculture Stronger posts in Japanese.
  5. working under Hiroshi Nakano, who designed the famous Eishin High School project with Christopher Alexander
  6. Paul recently mentioned XP in this comment
  7. For the record, he went on to say “But I don’t know whether permaculture people did. I hope that permaculture people, pattern people and software people share ideas and make the world better”
  8. For the record, he went on to say “there are many pattern libraries available for programmers who don’t want to re-solve solved problems. They tend to be articulated in similar ways to Alexander’s patterns: state the problem, give a label to the pattern that solves the problem, then describe (in a general way that’s not tied to any programming language or architectural methodology) the ‘recipe’ of the pattern.”
  9. wikipedia ironically being the very place I’m finding out most of this stuff!
  10. I won’t go into the fact that Dave Jacke and Ben Falk were profoundly influenced by Alexander’s writings, David Homgren was heavily influenced by Alexander’s pattern language concept, and Mollison was familiar with and had much respect for Alexander’s work. I mean just who the heck does this guy think he is having such a massive impact on so many people and professions!
  11. Not to mention working in an area arguably more relevant to riding out the interesting times ahead than (mostly corporate) software development!
  12. Though nor am I discounting the possibility for contributions to permaculture from the software world
  13. As in actual fields, full of grass and soil and stuff.


  1. Hi Dan,

    Alex has had some of these conversations with me and I’m also very grateful for your post on the possible links between Agile & ‘traditional’ permaculture design. It’s an exciting conversation with a lot more to be learned by the permaculture community, I suspect. (I’m teaching the design component on Alex’s PDC so she’s keeping me on my toes!)

    Two quick comments:
    1. I agree 100% with comments already made about the difficulty of reversing or redirecting landscape solutions as opposed to digital solutions. Because of the expense and (sometimes) impossibility of reversing a strategy in the landscape, I think there is a good case to be made for getting the big patterns right in terms of general placement of elements within a design… especially if the placement of those elements involves bulldozers or similar equipment.

    Possibly there is a continuum whereby more Up Front design happens on larger scale properties and more Agile design on smaller scale?

    2. What is the permaculture equivalent of the Agile concept of Minimum Viable Product?
    “A minimum viable product (MVP) is a development technique in which a new product or website is developed with sufficient features to satisfy early adopters. The final, complete set of features is only designed and developed after considering feedback from the product’s initial users.”
    For instance, is a Jacke Design Concept & Schematic Design a minimum viable product?

    1. Hi Steve, good to see you here!

      Here’s a good definition of MVP that I found:

      It has enough value that people are willing to use it or buy it initially
      It demonstrates enough future benefit to retain early adopters
      It provides a feedback loop to guide future development

      I think you can see Dave Jacke’s process as, in some ways, following an MVP process from broad design to detailed design: the design concept is an MVP for the final design.

      What I’m wondering, though, is whether the “product” here is the design, or the long-term system in action?

      If you conceive of the design concept as leading toward a fully-fledged, “perfect” design on paper, then the paper design is the product.

      If you conceive of the eventual impemented system as the product, then I don’t think you have an MVP until you have done the first round of implementation and people are using it and seeing how it feels. But that might just be my agile biases showing 😉

  2. “does this relative irreversibility in changing the physical (as opposed to a virtual) landscape require a whole-site concept design up front?”

    Does Agile works only because it deals with digital elements ?

    It’s worth mentioning that Extreme Programming and Agile methodologies influenced the design and building of Wikispeed, an open source car.

    This gave birth to Extreme Manufacturing (XM: https://en.wikipedia.org/wiki/EXtreme_Manufacturing) a method to design physical objects/machine.

    To understand better the principles of XM, I collected principles and hope to generate patterns from them:


    So it seems likely XM and Alexander’s methods (such as the ones used to build a whole university campus and described in “The battle for the life and beauty of the earth”) could be adapted for large projects such as the ones permaculture deals with.

    Thanks again for writing all this so comprehensively, it helps a lot !

  3. Augh, WordPress just ate my comment! And now it’s complaining about duplicates and uuuughhh. Please ignore this paragraph, it’s just here to let me post the same comment again.

    I was going to say, Kent Beck is maybe being a bit misleading about element assembly, because it’s not anywhere near as haphazard as it sounds.

    In XP, there is a “metaphor” which is a high level articulation of the overall concept, and then software developers tend to work from broad scale to small scale within a session of work. For instance, you decide:

    * what overall design concept works for this problem
    * what elements fit together to solve it
    * how they communicate
    * how each element works internally

    … and then apply the same process at a smaller scale as you get down to patterns-within-patterns. In fact, in software testing, the process of “test driven development” says that for even tiny bits of code, just a few lines, you write a test FIRST, then see if your code passes the test. That’s actually goal articulation at the micro level.

    There are also other practices such as “spikes”, which in XP are when you say “look, there’s 3 potential ways to solve this, let’s spend a day experimenting and see which one works best.”

    On top of that, XP’s reliance on the onsite customer and pair programming mean that everything you do is constantly peer reviewed and seen through multiple sets of eyes, who tend to ask questions like “why did you…?” and “what if…?”

    And then, automated testing and continuous integration mean that if you make a mistake, you’ll know about it instantly.

    Permaculture doesn’t have the toolchain that software development does (stuff like automated testing software, rapid deployment, refactoring aids, etc) but imagine if it did! My mind is going to a really fascinating future.

    1. Thanks Alex and great to hear more about XP – I hope to pick up on some of these threads come “rubber-hits-the-road” (or better in this context to say “spade-hits-the-ground”) time in this inquiry.

  4. Hi Dan,

    Thank you for this post – GREAT timing! I’ve been thinking about this stuff a lot lately.

    I actually came to Permaculture via Christopher Alexander, after hearing about design patterns in a software engineering course in the mid 1990s. Although I’ve hung around the edges of Permaculture since then, I haven’t done a PDC in part because the impression I got (largely through Mollison’s Permaculture Designers Manual) was that the design methodology was haphazard – at least compared to what I was seeing in my software engineering work at the time. When I heard that a lot of permaculturists had started to pick up some design rigour from Dave Jacke’s work, I started to get interested, googled “dave jacke design methodology”, read a bunch of your posts, and to cut a long story short I’m currently in the middle of a PDC that’s running over several weekends in the first half of this year.

    At the moment the PDC is going deep into Jacke’s process, so imagine my surprise when I found out that his method is basically the “waterfall model” of software development that I learned in the early 1990s – though even then it was taught with the caveat that it was already outdated and mostly to be found in big, old, slow-moving organisations like banks or the military.

    So I spent a chunk of this weekend, as my PDC covered Dave Jacke’s design methodology, wondering:

    – will Jacke’s method have the same problems and failure modes, in time, as waterfall software development?
    – what relationship do methodologies such as agile, XP, rapid prototyping, lean software development, etc have to permaculture?
    – does the inherent “cycle” of nature – the year – mean that the rapid releases and quick feedback of agile development don’t work in land-based permaculture? What about in non-land-based, such as social permaculture?
    – how do the agile manifesto, agile principles, and the 12 practices of XP map to the permaculture ethics and principles? what’s missing on each side?

    I came home from the PDC and googled “agile permaculture” and there was your post – very timely! I’m delighted to be able to point people at it, as you express it much more clearly than I’m able to – I keep relapsing into incomprehensible handwaving and nerd-speak.

    Btw the original book “Extreme Programming Explained” by Kent Beck et al has a fantastic diagram of the 12 XP practices with arrows between them showing how practices support each other. Eg. “automated testing” supports “continuous integration” which in turn supports “short release cycles”. Here’s the pic online: https://ullizee.files.wordpress.com/2009/11/kent-beck-12-xp-practices.jpg … What struck me is that if you remove any of those pieces, the whole mutually supportive network starts to collapse. (Incidentally I believe this has happened in modern agile vs the more idealistic XP as it was 15+ years ago; XP had a much stronger focus on “people care”, which I think was watered down in recent years to make it more corporate-friendly. But that’s an aside.) I’d love to see a similar diagram done of permaculture principles, either in general or in their application to a particular project, to show that all the principles are in play and are supporting each other. Much like having each element in a design fulfil 2+ needs/having 2+ elements to fulfil each need, you could ensure that each principle is in play in 2+ places and that each element demonstrates 2+ principles. Drawing a diagram of them would clearly show any outliers that weren’t strongly connected.

    On another note, a few weeks ago I went down a pattern rabbit hole, reflecting on pattern languages from Alexander to the “Gang of Four” with their software design patterns in the 90s. Along the way I found this presentation given to a software conference, which I think has a lot of application to permaculture and how permaculturists talk about “patterns” and “pattern language”: http://perl.plover.com/yak/design/ – I’d be very interested to know what you think (and if you’re interested, I have a longish set of notes synthesising what i know about patterns from Alexander, software eng, textile design(!!!) and permaculture which I could share by email).

    Thanks again for this post and for making us all exercise our brains in making permaculture stronger.


    1. Greetings Alex and what a delicious comment!

      As I explored in this post and as I know from having the pleasure of seeing him at work, in practice Dave Jacke uses a process more adaptive/generative than some of those reading and teaching from his book (EFGVII) might realise. Dave has also mentioned to me that his design approach has evolved a lot since the book was written and I look forward to him publishing an update or speaking to these evolutions on a podcast or some such in future. As these comments likely reflect (see also this post), I have nothing but deep gratitude and respect for Dave Jacke’s enormous contribution toward permaculture getting its design process shit together.

      Re principles I’ve been keen for a while to get myself clearer on the relations amongst permaculture principles possibly including the sort of networked approach in Kent’s diagram (I hope to progress this during this event).

      Speaking of XP asides another one I came across is that, ironically, the most prominent aspect of permaculture I’ve seen Kent Beck noting appreciatively is the idea of design as element assembly, which I think must work well in software design, but which as I explored in the previous inquiry, can create problems in the permaculture context he lifted it from!

      I love the punch line of that presentation you linkedDAMNED STRAIGHT WE DO! Reminds me of a youtube of a talk Alexander gave to software developers where as I recall the punch line was something like “don’t just appreciate my process innovations, appreciate what those innovations were in service of” (Alexander’s career-long quest to help bring the real physical world back to life).

      And I’d love to see your notes – please do send them through (info at this website’s url or use the contact page and I’ll reply).

Leave a Comment

Your email address will not be published. Required fields are marked *