Why High-Output Systems Are Often the First to Stop Growing为什么最高产的系统往往最先停止成长

On instances, primitives, and the difference between novelty that compounds and novelty that merely accumulates.

“The limits of my language mean the limits of my world.” – Wittgenstein, Tractatus 5.6

At first it looked like progress.

For one week, an AI Agent pipeline kept shipping. Commits arrived roughly every hour. Small fixes landed, minor improvements accumulated, the activity graph looked alive. Only one thing was missing: the product itself did not become larger ¹. It was not broken. It was not idle. It was moving, but inside a vocabulary it already had.

That confusion is not rare. Conway’s Game of Life has produced new patterns for half a century, and when its central open question about oscillators was settled in 2023, the community did not wind down; it accelerated. Speedrunning communities deliberately ban whole classes of glitches and still find new routes inside the smaller rule book. Out-of-print fighting games keep tournaments alive on rule sets that have been frozen for decades. Most viral internet ideas, by contrast, are mined out within a month and quietly abandoned.

From the outside, all of these can look like activity. The easy diagnosis is “the well is dry,” but that is often too crude. The Game of Life community could be plateauing; the agent pipeline could still be growing; the viral fad might still have another form waiting somewhere. The thing that separates these cases is not visible in the usual busyness metrics, but it is sharp enough to name, and in principle sharp enough to measure.

So the question is: what is the difference between a system that is producing and a system that is growing? Between motion and progress? “Vibe” is not a metric. The distinction needs a name.

The uncomfortable part is that the distinction is not subtle. After the next two sections almost everyone will say “yes, of course.” And yet most of the systems we actually run, build, and reward are the ones that erase the difference. The point of this essay is less the distinction itself than the structural reason we keep walking into it.

More Is Not New

The distinction is simple: there are two kinds of novelty, and we routinely confuse them.

The first is instance novelty: a previously unseen output. A new solution, a new feature, a new generated artifact. The second is primitive novelty: a new reusable building block, something that enters the vocabulary and changes what becomes cheap to say or do next.

A finite grammar can generate infinitely many sentences. That fact is the trap. A system can produce an unbounded stream of genuinely new instances without adding a single new primitive. From the outside it looks open-ended. Underneath, the vocabulary has stopped moving. There is always something new to say, and nothing new to say it with.

Once the distinction is visible, examples are everywhere. A pop-song generator can produce ten thousand chord progressions without introducing a new chord. A research subfield can publish for a decade, every paper different, while quietly running on the same three theorems it started with. An organization can ship features for years on an architecture nobody is allowed to question. A solo creative practice can jump between one-off experiments where each piece is new and none of them make the next one easier. The outputs are genuinely novel. The vocabulary is frozen. The system is productive, but it is not becoming more generative.

Fig 1: Instance novelty vs primitive novelty. Filling a level with more instances (horizontal) is not the same as promoting a new reusable primitive that opens a level (vertical). A finite grammar yields unboundedly many instances at fixed primitive height.

The cellular automata world gives the cleanest example, and it is a real result, not just a metaphor. In 2023 it was proven that Conway’s Game of Life has an oscillator of every period; the system is “omniperiodic” ². That closed an entire family of instance questions at once: is there a thing that blinks with period N? Yes, for all N.

A community might be expected to slow down after a central open problem is solved. The opposite happened. The constructions invented along the way, the reusable techniques for engineering behavior into the grid, were primitives, and the community immediately carried them into new questions. The oscillators were instances. The ways of building them were primitives. They move on different clocks, and mixing them up is one way to misread whether a field, a community, or any system is still alive.

The Two Curves

One picture is enough for the rest of the argument. Run any open-ended system over time and track two numbers.

$g_{\text{inst}}$ (instance yield): how surprising each new output is, given everything that came before. How much genuinely new stuff is arriving.

$g_{\text{prim}}$ (primitive yield): how often a genuinely new reusable building block gets promoted into the vocabulary.

Fig 2: The two-curve criterion. Instance-level marginal complexity $g{\text{inst}}$ stays bounded away from zero while primitive-level marginal yield $g_{\text{prim}}$ decays to zero: unboundedly many novel instances, yet generative closure._

The diagnostic is not the level of either curve. It is their divergence. The failure mode that looks healthy from a distance goes like this: $g_{\text{inst}}$ stays high, new instances keep coming, while $g_{\text{prim}}$ quietly decays toward zero. There are no new building blocks. Infinitely many instances, generative closure. The busyness metrics can stay green exactly when the thing that matters has flattened.

The same shape appears at very different scales. A research group that keeps publishing variations of the same trick has high $g_{\text{inst}}$ and near-zero $g_{\text{prim}}$: every paper is new, but the toolkit is frozen. A craft practice that moves from one-off experiment to one-off experiment has the same signature: a new piece each week, none of them inheriting much from the last. A late paradigm in science can look similar: work continues, anomalies are absorbed, but no new explanatory primitives enter the canon. In each case, the first useful move is to ask where new primitives could actually form, instead of spending all attention on more instances of the old ones.

So the first practical move is almost embarrassingly simple: stop watching one curve. Output volume and instance novelty are vanity metrics. They can look great during a plateau. The number to watch is primitive yield, and it behaves very differently.

What Counts as a New Primitive

“Reusable building block” is still vague. Here a useful idea from program synthesis does real work, and it is the only formula in this essay worth remembering.

A candidate counts as a primitive only when adding it to the library makes the total description of past work shorter. Write the sum of two costs:

$$\text{cost}(\text{library}) ;+; \text{cost}(\text{work, expressed in terms of the library})$$

Adding an abstraction costs something: the library grows. It pays only if everything written using it gets cheaper. The hard part of this test is that it is retrospective. A new “abstraction” cannot be qualified by looking at its design, or by how clean it feels in code review. It has to be applied to old work, and the description has to get shorter. If past work does not compress, future work probably will not either. That is the operational form of the distinction the rest of this essay is built on.

This is what library-learning systems like DreamCoder ³ and Stitch ⁴ do: they comb through a corpus of solutions and promote the abstractions that maximize compression. The useful point is that this is not mystical and it is not a vibe. A reusable skill is one that allows past work to be re-described more compactly, because it factors out a pattern that kept being re-derived. That gives an operational test for whether a system is accumulating capability or only accumulating output: is its library compressing its own history, or not?

This also reframes what a good open-ended structure is for, whether that structure is a research group, an artistic movement, a software organization, or an autonomous system. For generativity ⁵, task completion is not enough. The system needs a persistent, shared library and an incentive to compress into it: a structural reason for someone, or something, to notice that the same pattern has appeared five times and should become a primitive. Without that, every cycle starts from the same vocabulary, and the primitive curve never lifts off ⁶.

Why We Keep Forgetting This

So far this is mostly a definition, and an obvious one. Most systems run by experienced people are run by people who already know, in some form, that mere output is not capability. So why does the same pattern keep reappearing, in shipped product after shipped product, agent system after agent system, lab after lab?

The answer is structural. Every running system has an accounting layer: a changelog, a velocity dashboard, an OKR sheet, an evaluation harness, a paper count. Those layers track output. None of them track library compression. The changelog records what the system did; the library records what it became. The two are not on the same dashboard, because the second one is hard to define and harder to incentivize, and people optimize what they can see paid out.

In practice that means the things that get rewarded are the things that get measured. A pull request closes a ticket and the closing is visible. An engineer who instead spends a week retiring three modules and adding one cleaner primitive does roughly the same amount of work and produces nothing the system can score as “shipped.” Across enough quarters, the incentive ratchet eats the library. The system trends, predictably, toward higher $g_{\text{inst}}$ and lower $g_{\text{prim}}$.

Consider two systems. The first ships a feature every day; its dashboard glows green; its team is celebrated. The second ships nothing for a month while a team rebuilds an internal representation nobody outside the org will ever see. Most accounting layers cannot tell you that, six months on, the second is producing twice as many primitives per quarter as the first, and the first is on a curve toward exhaustion. The honest reading reverses the obvious one.

The same shape recurs in less commercial settings. Research labs that count publications converge on instance work. AI agent benchmarks that score pass rates select for agents that solve more problems with the same vocabulary, not for agents that grow a vocabulary at all. Generative-AI products priced by tokens are economically indifferent to whether the next token came from a compressed concept or a re-derivation. In each case the accounting layer cannot see the variable that actually matters, so the system optimizes a proxy.

So the embarrassing fact is not that “more is not new” is a sophisticated insight some organization might fail to grasp. The fact is that the insight is obvious, almost everyone running these systems will agree with it on a whiteboard, and the systems still produce the wrong answer because nobody has written the right one down in a place that pays out money.

The Second Trap: Lock-In

Suppose the primitives are available. The current way of framing the problem is exhausted, but a better frame exists: a new representation, a new theoretical kit, a new architecture, something that would reopen the primitive curve. Does the system move to it?

Usually not. This is a different failure from “nothing left to find.” It is lock-in: the system should move and cannot. Kuhn’s account of scientific revolutions is largely a study of this ⁷: anomalies accumulate, the community keeps not switching, and eventually the cost of staying exceeds the cost of jumping. The field then reorganizes in a discrete jump rather than a smooth transition.

The math here is only a comparison. A system switches frames when the gain from switching, call it $\Delta g$, exceeds the cost of switching, $c$. It stays locked in whenever $c > \Delta g$. Two flavors matter:

Pure convention. The alternatives are about equally good. A system is stuck on one for historical reasons, and the cost of changing is not worth it. QWERTY is the classic case ⁸. Often harmless.

Coordination lock-in. The new frame is genuinely better ($\Delta g > 0$), but the cost of everyone relearning the shared vocabulary, rebuilding the tooling, and recoordinating evaluation standards exceeds the gain. This is the expensive one. It is the shape of pre-Copernican astronomy carrying epicycles on epicycles for centuries, each patch a competent local fix, the underlying frame left unquestioned. It is also the shape of mature engineering organizations whose process makes the leap unrepresentable, so that “pause delivery for three weeks and rethink the topology” is not a sentence the structure can accept ⁹. The frame will not question itself.

Fig 3: Lock-in as a potential landscape. Even when a better framework $V'$ exists ($\Delta g > 0$), the collective stays in $V$ if the escape resistance $[c - \Delta g]+$ exceeds the available perturbations: a metastable basin. Pure-convention lock-in is the special case $\Delta g \approx 0$._

Put the two traps on perpendicular axes and a richer picture appears.

Fig 4: Two axes generate four corners. Generativity (does discovery keep producing new primitives?) is the horizontal axis. Epistemic lock-in (when yield decays, does the collective stay?) is the vertical. Low-generativity, low-lock-in is the flash-in-the-pan fad: once people see through it, they leave. Low-generativity, high-lock-in is the long-lived culture on closed rules: an out-of-print game with a competitive scene that lasts decades. High-generativity, low-lock-in is the open community deliberately bounding itself: speedrunning a still-rich game under “glitchless” rules. High-generativity, high-lock-in is sustained deepening: Game of Life fifty years on.

Most writing about “open-endedness” sees only one axis at a time. For a stalled system it helps to ask both before reaching for an answer. Even a genuinely generative system will plateau if it is welded to a representation whose primitive curve has flattened, and no amount of local cleverness gets it out. Migration is a different operation from optimization. It has a real cost, and someone, usually still a human, has to decide to pay it on purpose.

One sharper thing to say about both traps. What can actually be measured is never a system’s raw capacity for primitive generation; the measurable quantity is how many primitives were actualized, given where attention was spent. Two systems with access to the same material can trace wildly different libraries depending on how attention is allocated ¹⁰. Lock-in is the special case where attention is pointed at a flat curve and the structure will not let it move.

The Hard Part Is Not the Idea

The argument has a definition, a test, an explanation for why systems keep failing the test, and a separate trap that catches the ones that pass it. None of the pieces is hard. The hard part, the part that actually matters, is the second one: knowing the distinction does not get a system out of the trap, because the trap is in the accounting layer, not in anyone’s understanding.

So the working version of the test is short. A system’s real state is not in its output sequence. It is in its library. The changelog says what it did; the library says what it became. Most measurement systems only count the first. A few systems somehow find a way to also count the second. The rest stay busy.