Skip to content

Ninety-Ninety Rule

The first 90 percent of the code takes the first 90 percent of the time and the last 10 percent takes the other 90 percent — a deadpan warning that nominal-progress metrics measure only the estimable bulk-work population and never the non-parallelizable, heavy-tailed completion tail.

Core Idea

The Ninety-Ninety Rule (Tom Cargill, via Bentley's "Programming Pearls") states that the first 90 percent of the code accounts for the first 90 percent of development time, and the remaining 10 percent accounts for the other 90 percent. The absurd arithmetic is the joke and the point: it names an estimation failure, the conflation of nominal completion (features built) with actual remaining work (integration, edge cases, error paths, tuning, QA). Nominal metrics saturate before the hidden tail of completion work does.

Scope of Application

The rule lives within software-engineering estimation and its project management, where a build is tracked by nominal-scope metrics that saturate before its completion tail is done.

  • Integration-heavy software builds — the canonical home, where the non-parallelizable tail dominates the schedule.
  • Release engineering and the beta-to-GA run — last-mile correctness, QA closure, deployment green-ness.
  • Feature-level effort estimation — the everyday "this feature is 90% done" reading, reclassified.

Clarity

The rule names and quarantines a specific estimation failure, so a schedule slip stops looking like a string of individual misfortunes and becomes one predictable phenomenon: nominal metrics saturate before the work does. It holds "what is built" apart from "what is shippable," and its underlying distinction — bulk work versus a qualitatively different tail population — dissolves the paradox in the absurd arithmetic.

Manages Complexity

The rule collapses a scatter of seemingly independent overruns to a single structural split: every task belongs to one of two populations, and the overruns all come from the tail. Bulk work is parallelizable, bounded, and estimable from throughput; tail work is non-parallelizable, heavy-tailed, and structurally novel. The manager then tracks one question — which population does this metric measure, and has the other been counted? — with the read-off that the unmeasured tail costs about what the bulk did.

Abstract Reasoning

The rule licenses a diagnostic move (re-read a saturating nominal metric as "the bulk was measured, the tail was not"), a predictive move (budget near another full project at "90% by lines of code"), an interventionist move (enumerate tail items, refuse to estimate them from bulk throughput, don't assume more people compress a non-parallelizable tail, front-load novel work), and boundary-drawing that fixes when the rule bites and when a 90% reading is honest.

Knowledge Transfer

Within software engineering the rule transfers as mechanism — the diagnostic, prediction, population split, and prescriptions carry intact across integration-heavy builds, release engineering, and estimation, all the same activity. Beyond software the reach becomes analogy: the logistics last-mile problem, a book's final tenth, the construction punch list undergo the same tail dominance, but travel as the parent heavy-tailed-effort / last-mile-asymptote prime (already prime-shaped, reaching far beyond software). The rule's deadpan arithmetic and software-tail taxonomy stay home; it is a vivid alias of the heavy-tail prime, specifying that the underestimate lives in the tail.

Relationships to Other Abstractions

Local relationship map for Ninety-Ninety RuleParents appear above the current abstraction, mutual partners to the right, and children below. Node labels state whether each abstraction is prime or domain-specific; colors identify relation types.Ninety-Ninety RuleDOMAINPrime abstraction: Heavy-Tailed Distributions — is part ofHeavy-TailedDistributionsPRIME

Current abstraction Ninety-Ninety Rule Domain-specific

Parents (1) — more general patterns this builds on

  • Ninety-Ninety Rule is part of Heavy-Tailed Distributions Prime

    Heavy-tailed task duration is a constituent of the Ninety-Ninety Rule's hidden completion tail, where a few novel integration items dominate effort.

Hierarchy path (1) — routes to 1 parentless root

Neighborhood in Abstraction Space

Ninety-Ninety Rule sits in a sparse region of the domain-specific corpus (82nd percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Software Evolution & Systemic Laws (16 abstractions)

Nearest neighbors

Computed from structural-signature embeddings · 2026-07-12