Incremental Design Simulations
after Ross Ashby and Christopher Alexander
-- Greg Bryant

The necessity of organic modularity in design

You're about to run three simulations. Each one asks: how do we most quickly satisfy a system of needs?

Each node or state variable represents a fit or a misfit. If we act as if each variable is totally dependent on every other, it would take forever to come to a solution.

Imagine these 'requirement' variables as a handful of pennies. If you toss them up in the air all at once, in the hope that they will all land heads, you may never finish. This is why so many projects ignore actual requirements, creating compound mistakes: because the complexity of the problem using this approach seems unsurmountable.

But if you flip one penny at a time, until they are heads, you'll be done very quickly. That's the mathematical beauty of incremental design. So that's our base assumption here. (Christopher Alexander credits Ross Ashby for this observation).

However, some variables in a design really do depend on each other. We represent those dependencies among state variables as wires between nodes. And you will see how important this wiring is.

SIMULATION 1 of 3

Start with nodes. No connections yet. No dependencies.

Below are 10 variables — things in a design that can be right or wrong, fitting or misfitting. Right now they're all misfitting (problem unsolved). Each variable independently does a coin flip to try to become a fit. Every second, each misfitting node has a 50% chance of resolving. No dependencies that can effect its state. This resolves quickly with our basic incrementalism.

No connections. Press Run and see what happens.

Nodes misfitting

Seconds elapsed

Status

Ready

Press Run to start. Watch how fast it settles.

Notice what happened. With no dependencies, each node resolved in 1 or more tries. The whole system reached equilibrium, or the design resolved, nearly as fast as a single state variable would.

SIMULATION 2 of 3

Many dependencies.

Same 10 nodes. But now they might be entwined. A connection means: if my neighbor is still misfitting, it can pull me back even after I've resolved.

Start at 50% and run it. Then reset, try a different density, and run again. See how the time changes.

Dependency density 50%

Nodes misfitting

Seconds elapsed

Status

Ready

Set density and press Run. Try 100% first — then reset and try lower values.

Compare this to simulation 1. At full density, the system barely moves — almost as if we weren't using the power of incrementalism at all. Every node that resolves gets pulled back by its still-misfitting neighbors. The more connections, the longer it takes. Try resetting and lowering the density slider to see how the time changes. Then move on to the final experiment.

SIMULATION 3 of 3

Groups with shared variables between them.

Same 10 nodes, but now divided into subsystems or groups or clusters. Nodes within a cluster are as densely connected as you choose. A few nodes are also connected across clusters — these are dependencies between subsystems.

Choose how many clusters, set the intra- and inter-group connection densities, then Run. Notice how even a few cross-group connections slow everything down.

2 Clusters or subsystems

Dependencies within clusters 100%

Dependencies between clusters 1 link

Resolved clusters become fixed

On: a cluster that fully resolves is locked — cross-cluster dependencies can no longer effect it. The 'later' clusters must adapt to it, as a settled constraint. (In using unfolding sequences in design, it's important for this reason to first take care of subsystems other subsystems depend upon.)
Off: resolved clusters remain vulnerable to disturbance from neighbors.

Nodes misfitting

Seconds elapsed

Status

Ready

Choose your settings and press Run. Compare the result to experiment 2.

This is Alexander's key insight. The clusters don't need to be perfectly isolated — a few shared variables between them is realistic and inevitable. But notice how even 1 or 2 cross-group links slows the system down: a resolved cluster can become unresolved by a neighbor in another group that is still misfitting. The careful definition of subsystems of state variables, and the ratio of intra-group to inter-group connections, determines whether a problem is tractable.

What you just experienced

The shape of the problem is the problem

In 1964, Christopher Alexander published his dissertaion Notes on the Synthesis of Form — which set out to explain why some design problems are tractable, why others are not, and how to resolve these difficulties in complex situations. These three simulations are part of his argument in chapter 4.

He called the nodes misfit variables: aspects of a design that are failing. The connections between them represent dependencies — the fact that fixing one aspect of a design can disturb another. And the question he asked was: given a set of misfits with a given pattern of connections, how long will it take for the system to find its way to full fitness? This assumes that someone is, of course, trying to make that happen.

It is not hard to see that apart from chance this depends only on the pattern of interconnections between the lights. — Christopher Alexander, Notes on the Synthesis of Form

The mathematics

Why clustering changes everything

The expected time to resolve isn't just longer in the fully-coupled case — it's exponentially longer. With n nodes in a single fully-coupled cluster, the expected wait is roughly 2ⁿ seconds. Split those nodes into k clusters of n/k each, and the expected wait drops to 2^n/k seconds — because each cluster can settle independently, and you only need to wait for the slowest one.

Structure	Nodes	Expected convergence
No connections (10 clusters of 1)	10	~2 seconds
2 clusters of 5	10	2⁵ sec ≈ 30 seconds
5 clusters of 2	10	2² sec ≈ 4 seconds
1 cluster (fully coupled)	10	2¹⁰ sec ≈ 17 minutes

Alexander's original thought experiment used 100 nodes — which made the fully-coupled case take 2¹⁰⁰ seconds, or about 10²² years. The universe itself is only 10¹⁰ years old. With 20 nodes the numbers are more modest, but the principle is identical: the exponential gap between clustered and fully-coupled structures is real at any scale.

The deeper lesson

Why this matters for design — and everything else

Alexander wasn't writing about abstract mathematics. He was writing about why designing things is hard — and why some designers and some cultures manage it better than others. A traditional craftsman building a wall, or a city growing street by street, is unconsciously exploiting clustering: each decision is made within a limited scope, incrementally, building on settled ground, without requiring the whole system to resolve simultaneously. Modern designers, working from blank-sheet specifications, often find themselves in the fully-coupled trap without knowing it.

No complex adaptive system will succeed in adapting in a reasonable amount of time unless the adaptation can proceed subsystem by subsystem, each subsystem relatively independent of the others. — Christopher Alexander, Notes on the Synthesis of Form

This is not a stylistic preference. It is a mathematical constraint on what is even possible. And the same constraint shows up everywhere:

Software engineering

Modular code, microservices, and clear API boundaries are engineering responses to exactly this problem. A codebase where every function depends on every other is the fully-coupled nightmare. Good modularization creates clusters that can evolve independently.

Urban planning

Cities that grow gradually, neighborhood by neighborhood, develop natural clustering. Master-planned cities, designed all at once and imposed on the land, are rigid and unable to adapt — the important variables are just ignored, creating a city of misfits.

Evolutionary biology

The genome is organized into modules: not physical boxes, but regulatory networks, developmental pathways, protein families. This lets evolution improve one system without unraveling another — clustering at the molecular scale.

Craft and making

Traditional building trades, weaving, and instrument-making all proceed in sequences that preserve semi-independence. Each step builds on settled ground; the maker never holds more than a few constraints in mind at once.

The question Alexander left us with is not whether to cluster — it is how to find the clusters that are latently present in any real problem. Finding them is what he called the synthesis of form: not inventing structure, but revealing the structure that creates the form.