Miller's law as a lint rule: decomposing any project seven pieces at a time

In 1956 George Miller published the most famous magic number in psychology: seven, plus or minus two, the rough capacity of human working memory for distinct chunks. The finding has been refined and argued with for seventy years, but its practical core has held up: humans reason well about a handful of things at once and badly about twenty.

Project decomposition is reasoning about things at once. And that makes Miller's law something better than trivia: it is a design constraint for plans, concrete enough to check mechanically. Topolog treats it exactly that way. The validator that checks every plan carries a rule (HW-74, in the family of structural checks) that fires when any level of the plan has more than seven non-terminal children. A plan level with twelve siblings gets flagged, the same way a linter flags a 300-line function: not as an error, but as a smell with a known refactoring.

The rule, precisely#

A TOL plan is a containment hierarchy: the plan root holds milestones, milestones hold tasks or further milestones, iterations hold a template. The rule binds at every level independently: each container should have at most seven direct children that represent work (terminal states are exempt; they are endings, not things you reason about doing).

The fix for a violation is never deletion; it is grouping. Twelve top-level tasks become three milestones of four, and the plan gains a level. The information is identical. The cognitive load at each level is not, and that is the entire point. At every zoom level, the plan presents a Miller-sized set of chunks: seven phases, each opening into a handful of pieces, each of those opening again. You can hold any single level in your head completely, and that is what "understanding the plan" operationally means.

Two things about the rule's character matter. It is advisory, not blocking: an eighth child is a smell, not a structural impossibility, and the validator distinguishes those categories carefully (how validation tiers work). And it cannot be auto-fixed, deliberately. Splitting twelve children into themed groups requires deciding what the themes are, which is editorial judgement about meaning. The machine can tell you the level is overloaded; only you can say what it is three groups of.

Why seven works for plans specifically#

It could have been coincidence that a perception-lab number transfers to project structure. It is not, and the reason is quietly mathematical. Real planning graphs are structurally shallow: dependencies cluster locally (within a phase) far more than they span globally (across phases). In graph terms, real plans have small treewidth, typically five or less. A branching budget of seven sits comfortably above that, which means bounding every level at seven costs almost no real expressiveness. The constraint prunes the plans nobody should write while leaving the plans people actually need untouched. The best constraints all have this shape: cheap where you live, expensive only where you were already lost.

There is a structural bonus too. Bounded fan-out tends to produce trees with explicit grouping levels, and those levels are where summarisation lives: a milestone has a status, a forecast, a single line in the executive view, precisely because it is a real chunk rather than an accidental clump of tasks. The risk-reading habits from the plan-shape article all get easier on a plan with honest levels.

The same bound, both directions#

The most interesting consequence is who else the rule binds: the AI.

When Topolog's Express mode decomposes a goal, it works level by level, and each level is constrained to the same two-to-seven budget a human gets. The model proposes a Miller-sized cut of the problem, that cut is validated and rendered, and decomposition recurses into each piece (the full pipeline). The bound does two jobs at once. It keeps each generation step small enough to be reliable (models, like humans, degrade when asked to produce twenty coherent siblings in one breath). And it guarantees the output arrives pre-chunked for human review: every level of an AI-decomposed plan is inspectable in one screenful, one working memory's worth at a time.

That convergence is worth sitting with. The constraint that makes plans readable by humans is the same constraint that makes them reliably writable by machines. Seventy years on, the magic number turns out to be a pretty good API contract between the two.

None of this required believing seven is sacred. Five would work; nine would work. What does the work is having a bound at all, enforced where the plan is written, so that structure stays at human scale by construction rather than by occasional heroic clean-up. Miller gave us a defensible default. The lint rule does the remembering.