The Referee: Not Good Enough, Then Overshoot

"The theory that explains why Apple lost the 1990s is the theory that explains why it is winning local inference. Same referee, different round."

The Rule

Clayton Christensen, with Michael Raynor and Scott Anthony, stated the rule in 2003 as plainly as it can be stated: "Integration provides advantages whenever a product is not good enough to meet customer needs." When a product falls short of what customers want to do with it, every interface is a place performance leaks, so the company that controls both sides of every boundary — that can tune the processor to the memory to the operating system — builds the better product. Their second sentence is the one to keep beside the previous lesson: "the modular architectures that characterize disintegration always sacrifice raw performance."

Then the regime flips. "Once a product's basic performance is more than good enough, competition forces firms to compete on convenience or customization." When the product overshoots what customers can use, nobody pays for the last increment of performance; they pay for price, for choice, for the ability to swap a part. Modular architectures win that competition, because interfaces are what make price competition and choice possible. The integrated company, still optimizing for performance nobody needs, finds its strength has become its cost.

Apple, Round One

The Christensen Institute's own summary of the theory uses Apple as the worked example — from the losing side: "Apple's proprietary architecture, which in the not-good-enough circumstance was a strength, became a disadvantage in the more-than-good-enough circumstance." That is the 1990s. Once a personal computer was good enough for the spreadsheets and documents most buyers needed, the modular PC industry of lesson one competed on price and choice, and the integrated Mac could not. The founder of this household lived through that round and drew the lesson the theory draws: modularity is what a mature market wants.

Apple, Round Two

Now apply the same rule to a different product: a computer that runs a large language model locally, in 2026. Is it good enough? Measure it against what people want to do — hold a whole codebase in context, answer at reading speed, run the model everyone is talking about. No machine anyone can buy does that. Nothing under 512 GB of memory runs the largest open checkpoints at all; nothing that sits on a desk decodes a 200 GB model faster than a few dozen tokens per second at batch 1 (the HBM parts that would are rack hardware, and the memory track prices them); time to first token on a full context is measured in minutes. Local inference is squarely in the not-good-enough regime, and the theory's prediction for that regime is unambiguous: the integrated design wins. It does — the machine people actually buy for local inference is the one where memory, GPU and CPU were tuned together on one package. The mouse Apple stepped on (track seven) is that this integration was built for a phone before anyone knew the product it would be good enough for.

What the Referee Also Says

The rule cuts both ways, and this is the part that keeps the founder's position intact rather than defeated. The same theory that says integration wins now says modularity returns when the product overshoots. The modular industry is already building the interfaces for that day — CXL for pooled memory, UCIe for mixed-vendor chiplets, SOCAMM for memory you can replace — and the convergence track shows every rival copying Apple's layout while keeping a socket somewhere. The founder's position is therefore not wrong; it is early. In the household's own phrase, direction is not timing: the road is known, the time cannot be forced. Integration wins this round because the product is not good enough. The day it is, the referee changes the call — and the price of a sealed package, which the next lessons state in full, comes due.

Code

referee.py — which architecture does the theory predict for this product?·python

#!/usr/bin/env python3
"""Christensen's rule as a function: a product not yet good enough for what
customers want -> integration wins; overshoot -> modularity wins.
The inputs are judgments; the point is to write them down."""
from dataclasses import dataclass


@dataclass
class Product:
    name: str
    what_customers_want: str
    good_enough: bool          # does the best available product already do it?
    year: int

    def call(self) -> str:
        if self.good_enough:
            return "more-than-good-enough -> compete on price/choice -> MODULAR wins"
        return "not-good-enough -> performance leaks at every interface -> INTEGRATED wins"


ROUNDS = [
    Product("personal computer", "spreadsheets, documents, email", True, 1998),
    Product("smartphone", "apps, camera, battery through a day", False, 2010),
    Product("smartphone", "apps, camera, battery through a day", True, 2022),
    Product("local LLM machine", "whole-repo context at reading speed, frontier-size models", False, 2026),
    Product("local LLM machine", "the same, once 1-2 TB pools and >2 TB/s are ordinary", True, 20_30),
]

for p in ROUNDS:
    print(f"{p.year}  {p.name:18} {p.call()}")
print("\n(the last row is a prediction, not a fact; the year is a placeholder)")

Exercise

Run referee.py, then add two products of your own — one you believe is currently not good enough and one you believe has overshot — with the customer need spelled out. Then argue the local-LLM row from the other side: what would have to be true for a 2026 buyer to say the machine is already good enough, and what would the theory predict for the Mac's design if that were so?

Hint

The other side is a real position: for short-context tasks — dictation cleanup, tagging, a mail draft — a 24 GB laptop is already more than good enough, and for those buyers the theory predicts a price war and a socket. The edge-era track takes that population seriously. The local-LLM row is not good enough only for the workload people currently pay for.