Skip to content

Intervention Stack Accretion

Prime #
935
Origin domain
Systems Thinking & Cybernetics
Subdomain
intervention dynamics → Systems Thinking & Cybernetics

Core Idea

Intervention stack accretion is the structural pattern in which a system accumulates a growing set of concurrently active interventions, each individually justified at the time of addition, whose joint behaviour and management cost grow disproportionately to the simple sum of parts, and whose removal is structurally harder than their addition. Three commitments define it. First, asymmetric add/remove costs: adding an intervention requires showing only that it might help against a felt local need, while removing one requires showing it is no longer needed — structurally harder, because the counterfactual of what happens without it is unobservable while the intervention is in place. Second, combinatorial interaction: with \(N\) concurrently active interventions the joint-effect space is not \(N\) items but the \(2^N\) subsets and their pairwise and higher-order interactions, so management complexity scales super-linearly. Third, constituency formation: each intervention, once present, acquires stakeholders, dependencies, audit trails, and institutional memory that resist its removal independently of whether the intervention still does net good.

Together these produce a one-way ratchet: the stack only grows under ordinary operation. Reversing it requires a distinct named operation — deprescribing, sunset review, refactor, regulatory simplification, technical-debt sprint, change moratorium — which must itself be deliberately instituted and is resisted by the same forces that resist any individual removal. The pattern is sharper than a generic directional-asymmetry ratchet because it specifies what is accreting: discrete interventions on a shared system, each with its own justification, audit trail, and constituency. It is sharper than a generic rising-load pattern because it specifies the add-remove asymmetry and the combinatorial interaction rather than just monotonic accumulation. The decisive feature is that the default trajectory is accretion, so without an opposite procedure with its own ritual, the stack only grows.

How would you explain it like I'm…

The Pile Only Grows

Imagine every time something goes a little wrong, you add a new rule to fix it, and you never take old rules away. Soon you have a giant pile of rules nobody can keep track of, and taking one away feels scary because what if you needed it? Adding is easy, but cleaning up almost never happens on its own. So the pile of rules just keeps growing.

Easy to Add, Hard to Remove

Intervention Stack Accretion is what happens when a system keeps piling on fixes — rules, patches, safety steps — that all stay switched on, and the pile only ever grows. Adding a new fix is easy: you just have to show it might help with a problem you feel right now. Removing one is hard: you'd have to prove it's no longer needed, and you can't see what would happen without it while it's still in place. On top of that, every fix grows fans, paperwork, and other things depending on it, so people resist removing it even if it stopped helping. Because adding is easy and removing is hard, you get a one-way ratchet. The only way to shrink the pile is a special clean-up job — a sunset review, a refactor, a debt sprint — that someone has to deliberately start.

The One-Way Fix Ratchet

Intervention Stack Accretion is the pattern where a system accumulates a growing set of concurrently active interventions — each individually justified when added — whose joint behavior and management cost grow disproportionately to the simple sum of parts, and whose removal is structurally harder than their addition. Three commitments define it. First, asymmetric add/remove costs: adding needs only a showing that it might help a felt local need, while removing needs a showing that it is no longer needed — harder, because the counterfactual of life without it is unobservable while it's in place. Second, combinatorial interaction: with N active interventions the joint-effect space isn't N items but the 2^N subsets and their interactions, so complexity scales super-linearly. Third, constituency formation: each intervention acquires stakeholders, dependencies, and audit trails that resist removal regardless of whether it still does net good. Together these form a one-way ratchet — the stack only grows under ordinary operation — and reversing it takes a distinct named operation (deprescribing, sunset review, refactor, technical-debt sprint) that must be deliberately instituted.

 

Intervention Stack Accretion is the structural pattern in which a system accumulates a growing set of concurrently active interventions, each individually justified at the time of addition, whose joint behavior and management cost grow disproportionately to the simple sum of parts, and whose removal is structurally harder than their addition. Three commitments define it. First, asymmetric add/remove costs: adding an intervention requires showing only that it might help against a felt local need, while removing one requires showing it is no longer needed — structurally harder, because the counterfactual of what happens without it is unobservable while the intervention is in place. Second, combinatorial interaction: with N concurrently active interventions the joint-effect space is not N items but the 2^N subsets and their pairwise and higher-order interactions, so management complexity scales super-linearly. Third, constituency formation: each intervention, once present, acquires stakeholders, dependencies, audit trails, and institutional memory that resist its removal independently of whether it still does net good. Together these produce a one-way ratchet: the stack only grows under ordinary operation. Reversing it requires a distinct named operation — deprescribing, sunset review, refactor, regulatory simplification, technical-debt sprint, change moratorium — which must itself be deliberately instituted and is resisted by the same forces that resist any individual removal. The pattern is sharper than a generic directional-asymmetry ratchet because it specifies what is accreting: discrete interventions on a shared system, each with its own justification, audit trail, and constituency; and sharper than a generic rising-load pattern because it specifies the add-remove asymmetry and combinatorial interaction rather than mere monotonic accumulation.

Structural Signature

the managed substrate — the discrete locally-justified additions — the asymmetric add-cost versus remove-cost — the combinatorial interaction across concurrently active interventions — the constituency that forms around each — the one-way accretion ratchet — the distinct named inverse-operation

A system exhibits intervention stack accretion when each of the following holds:

  • A managed substrate. There is a shared system on which interventions are placed — a patient, a codebase, a regulatory regime, a curriculum, an organisation.
  • Discrete, locally-justified additions. Interventions are added one at a time, each justified at add-time against a felt local need, each carrying its own rationale and audit trail.
  • An add/remove cost asymmetry. Adding requires showing only that an intervention might help; removing requires showing it is no longer needed — structurally harder, because the counterfactual of operating without it is unobservable while it remains in place.
  • A combinatorial interaction. With \(N\) concurrently active interventions the joint-effect space is the \(2^N\) subsets and their interactions, so management cost scales super-linearly rather than as the simple sum of parts.
  • A constituency formation. Each intervention, once present, acquires stakeholders, dependencies, and institutional memory that resist its removal independently of whether it still does net good.
  • A one-way ratchet. Under ordinary operation the stack only grows; accretion is the default trajectory.
  • A distinct named inverse-operation. Reversal requires a deliberately instituted procedure with its own ritual — deprescribing, sunset review, refactor sprint, simplification budget, moratorium — that does not arise from normal operation and is resisted by the same forces that resist any single removal.

These components name three designable quantities — the add/remove asymmetry, the interaction matrix, and the constituency — and identify the named inverse-operation as the only force that counters the ratchet.

What It Is Not

  • Not a bare ratchet_effect. A ratchet names directional asymmetry in the abstract. This prime is one substrate-general instantiation that adds three commitments — discrete interventions, combinatorial interaction, and constituency formation — a bare ratchet does not specify.
  • Not lock_in. Lock-in is per-item: one choice becomes hard to reverse. Accretion adds the additive accumulation across many items and their super-linear joint cost, which single-item lock-in does not capture.
  • Not a cascade. A cascade is a trigger pattern — one event causing the next. Accretion is the accumulated state; many additions are independent, and accretion does not require cascade (though a cascade can drive it).
  • Not refinement. Refinement progressively improves a single artefact toward higher quality; accretion piles up concurrently active, separately-justified interventions whose joint cost exceeds their sum and whose removal needs a distinct named operation.
  • Not technical_debt. Technical debt is the software-specific child (and metaphor source); this prime is the cross-substrate parent covering polypharmacy, regulatory codes, curricula, and organisational initiatives under one structure.
  • Common misclassification. Evaluating each intervention on its own merits and adding it if positive. Under stack-accretion logic the joint stack can be net-negative even when every component is individually positive; the relevant quantity is the marginal joint-effect given the existing stack.

Broad Use

The discrete-additions-with-asymmetric-removal shape recurs across substrates anchored in deliberate intervention with constituency dynamics. Clinical polypharmacy is the canonical case: patients accumulate medications over years, each prescribed for a current indication, until the combined regimen produces interactions, prescribing cascades, and medication burden exceeding any single drug's effect — and the Beers Criteria, STOPP/START frameworks, and the deprescribing literature are the professional response. In regulatory and legal codes, successive administrations and constituency demands add rules, and sunset clauses exist precisely because the default trajectory is monotonic accretion, documented in tax codes, financial regulation, environmental permitting, and occupational licensing. In software systems, feature creep, configuration matrices, dependency stacks, observability layers, and security controls accrete into technical debt, with refactor cycles, deprecation policies, and scheduled rewrites as the deliberate inverse. The pattern recurs in security controls (defence-in-depth deployments each justified by a specific incident, producing alert fatigue and conflicting requirements, with periodic control rationalisation as the inverse), in organisational initiatives (change programmes, meeting cadences, OKRs, and training mandates accreting into "initiative fatigue," with "change moratoria" as the named reverse), in build systems and CI pipelines (pre-commit checks, lints, test stages, and deploy gates accreting, with pipeline-simplification sprints as the inverse), in curricula and standards (required courses, learning objectives, and prerequisites accreting, with curriculum reform as the inverse), and in tax exemptions and deductions (each individually justified, the combined complexity exceeding any actor's ability to optimise across, with simplification proposals as the politically difficult inverse). In every case, add-time justification is one-sided, remove-time justification is bilateral, and the inverse operation is named and disciplined precisely because the default is accretion.

Clarity

Intervention stack accretion clarifies by separating intervention quality from intervention quantity. A frequent error is to evaluate each intervention on its own merits and add it if positive — which, under stack-accretion logic, produces a stack whose joint properties are negative even though each component is individually positive. The diagnostic question shifts from "does this intervention help?" to "what is the marginal joint-effect of this intervention given the existing stack?" Naming the pattern makes this shift visible, because it exposes that the per-item evaluation, however rigorous, systematically misses the combinatorial interaction that determines the stack's actual behaviour.

The clarifying force extends to why specific reverse-procedures — deprescribing, sunset clauses, refactor sprints, simplification budgets — are not redundant with good intervention design. They exist because the default trajectory is monotonic: without an opposite procedure carrying its own ritual, the stack only grows, regardless of how well each addition was vetted. This reframes the reverse-procedure from a nice-to-have into a structural necessity, the only force that can counter the one-way ratchet. The prime also distinguishes itself from neighbours that share surface features. It is one substrate-general instantiation of a directional-asymmetry ratchet, but with three added commitments — discrete interventions, combinatorial interaction, constituency formation — that a bare ratchet does not name. It involves per-item lock-in but adds the additive accumulation across many items that single-item lock-in does not capture. And while a cascade can produce stack accretion (one intervention triggering the next), accretion does not require cascade, because many additions are independent; cascade is a trigger pattern, accretion is the accumulated state. Holding these apart keeps the prime from being mistaken for a generic ratchet, a single lock-in, or a cascade.

Manages Complexity

The pattern compresses an apparently scattered set of substrate-specific findings — Beers Criteria failures, regulatory burden, technical debt, alert fatigue, initiative fatigue, tax simplification — into one diagnostic family with a shared intervention space. Adoption gates raise the bar for addition so the stack grows slower (formulary committees, change advisory boards, RFC processes). Sunset defaults require interventions to be re-justified on a cadence (sunset clauses, certificate expiry, mandatory refactor sprints, scheduled deprescribing reviews). Removal disciplines institute the named inverse-procedure with its own ritual (deprescribing, refactor, simplification, moratorium). Stack visibility keeps the full active stack legible (medication reconciliation, regulatory inventory, dependency graph, control matrix) so combinatorial effects are at least visible. And constituency rotation rotates the stakeholder so the intervention's constituency does not become institutional (term limits on advisory committees, code-ownership rotation). By mapping each substrate's scattered remedies onto these five moves, the prime replaces a long list of domain-specific gotchas with a single shared toolkit.

The compression is operational because the prime supplies the quantities the toolkit acts on. The add-remove asymmetry is a designable parameter: adoption gates and pre-committed removal triggers narrow the gap between how easy it is to add and how hard it is to remove. The combinatorial interaction is a sizing variable: the management cost scales super-linearly in stack size, so sizing the cost of any addition must include the cross-interaction matrix, not the per-intervention cost alone. And the constituency is an object to be detected and managed: identifying, before adding an intervention, which stakeholders will form around it and what their interest in continuation will be after the original problem dissolves turns an invisible source of removal-resistance into an explicit design consideration. Because these three quantities are named, the prime converts the open-ended problem of "why does this system keep getting more complicated" into a bounded set of leverage points with matched interventions.

Abstract Reasoning

Intervention stack accretion trains a reasoner to interrogate any accumulating set of deliberate interventions through a fixed set of questions. What evidence will be required to remove this intervention later, and does the proposed addition include a pre-committed removal trigger? How does the management cost scale with stack size — does the sizing include the cross-interaction matrix, not just the per-item cost? Which stakeholders will form around this intervention, and what will their interest in continuation be after the original problem dissolves? And does this domain have a named inverse-operation, or must one be imported? Because these questions reference only the abstract roles — managed substrate, discrete justified addition, add-cost asymmetry, remove-cost asymmetry, interaction matrix, constituency, named inverse-operation — they apply to a patient, a codebase, a regulatory regime, or a curriculum without translation.

Several reusable moves follow. The add-remove-asymmetry move treats the gap between add-ease and remove-difficulty as the engine of the ratchet, so the reasoner attends to removal evidence at add-time rather than only at remove-time. The \(N^2\)-interaction move treats the joint-effect space as super-linear in stack size, so the reasoner sizes the cost of any addition against the interaction matrix rather than the item alone. The constituency-detection move treats the stakeholders that will form around an intervention as a predictable consequence of adding it, so the reasoner anticipates removal-resistance before it exists. And the reverse-operation-institution move recognises that where the pattern is acknowledged but the inverse-operation is not yet named, importing the inverse discipline from another domain — sunset clauses from regulation into code, refactor budgets from software into curriculum design — is itself a portable intervention. The same reasoning that tells a clinician to schedule deprescribing reviews tells a regulator to attach sunset clauses, because both are reasoning about countering a one-way accretion ratchet with a named reverse procedure.

Knowledge Transfer

The transferable content of the prime is that the named-inverse-operation discipline ports cleanly across substrates that each rediscovered the need for it independently. Deprescribing protocols, sunset clauses, and refactor sprints are the same move in pharmacy, regulation, and software; recognising the common structure compresses the design space and lets a domain that lacks a named inverse import one. The "debt" metaphor that surfaces as technical debt travels to regulatory debt and curricular debt, and once named, the same instruments — debt budget, interest rate, scheduled paydown — port across. The Beers Criteria methodology, an evidence-based list of interventions whose joint-stack presence is harmful more often than helpful, is itself substrate-portable: security teams adopting Beers-style "controls of concern" lists is a direct port. And the change-advisory-board pattern of pre-add gating with cross-stack review transfers across clinical formulary committees, regulatory impact analysis, and software RFC processes.

The transfer is deep because the convergent independent invention of a distinct named inverse-operation across substrates is itself the strongest signal that the underlying pattern is structural. A primary-care patient makes the accretion concrete: starting at 55 on one antihypertensive, each subsequent year adds a medication — a statin, an SSRI, a PPI to treat reflux triggered by the antihypertensive, a benzo for SSRI-induced insomnia, an analgesic, a second antihypertensive for pressure elevated under the analgesic's renal effects — until by 75 the patient is on 11 medications, each justified at its time of addition, while the combined regimen contributes to falls, dizziness, and cognitive slowing, and a significant fraction of the indications are themselves caused by other drugs in the stack. The standard intervention is a deprescribing review: a clinician with the full list, independent of any single prescribing event, evaluates the joint stack and removes items whose marginal contribution is now negative — a distinct named operation that does not arise from the prescribing cascade itself. The identical structural moves appear in a tax code where each exemption was passed for a felt constituency need but the combined code is unworkable, a codebase where each feature flag was added for a felt product need but the combined matrix is untestable, and an organisation where each initiative addressed a felt problem but the combined cadence consumes more time than the work it organises — and in each, the deliberate inverse (tax simplification, flag rationalisation, initiative moratorium) is the structural counterpart of deprescribing. Because the inverse-operation discipline is substrate-neutral, a practitioner who has run deprescribing in one domain can institute the matched reverse procedure in another on first contact.

Examples

Formal/abstract

Software technical debt exhibits the pattern with its three commitments laid bare, and it is the substrate where the combinatorial term is most explicitly measurable. The managed substrate is a codebase. The discrete locally-justified additions are feature flags: each flag is added to gate one feature for one rollout, justified entirely at add-time by a felt product need. The add/remove asymmetry is structural and visible in the engineering economics — adding a flag requires only an argument that it might be needed for a controlled rollout, while removing one requires proving it is no longer referenced by any code path or experiment, and that proof is expensive because the counterfactual ("does anything still depend on this branch?") is hard to establish while the flag remains. The combinatorial interaction is exact rather than metaphorical: with \(N\) concurrently active flags the configuration space is the \(2^N\) combinations, and a test suite that validates each flag in isolation does not validate the interactions — so management cost and untested-state risk grow super-linearly in \(N\), not linearly. The constituency forms as teams build features that assume a flag's presence, dashboards monitor it, and on-call runbooks reference it, so the flag acquires defenders independent of whether it still does net good. The one-way ratchet follows: ordinary sprint work only adds flags. The named inverse-operation is the flag-rationalisation sprint — a deliberately instituted procedure where an engineer with the full flag inventory, independent of any single feature launch, evaluates the joint stack and removes flags whose marginal contribution is now negative. It does not arise from feature work and is resisted by the same constituencies that resist any single removal.

Mapped back: The codebase is the managed substrate, feature flags are the discrete locally-justified additions, the \(2^N\) configuration space is the combinatorial interaction, runbook-and-dashboard dependence is the constituency, and the flag-rationalisation sprint is the distinct named inverse-operation — intervention stack accretion with the super-linear cost term made literally countable.

Applied/industry

Clinical polypharmacy and regulatory code accretion run the identical structure in human substrates. A primary-care patient starts at 55 on one antihypertensive; each subsequent year adds a medication — a statin, an SSRI, a proton-pump inhibitor for reflux triggered by the antihypertensive, a benzodiazepine for SSRI-induced insomnia, an analgesic, a second antihypertensive for pressure elevated under the analgesic's renal effects — until by 75 the patient is on eleven drugs. Each was locally justified at its time of addition; the add/remove asymmetry is acute because stopping a drug requires showing the indication has resolved, which is hard when the indication is invisible while the drug is taken; the combinatorial interaction shows up as interactions, prescribing cascades, and a fall-and-cognition burden exceeding any single drug's effect; and a significant fraction of the indications are themselves caused by other drugs in the stack. The named inverse-operation is a deprescribing review — a clinician with the full list, independent of any single prescribing event, evaluating the joint stack and removing net-negative items. A tax code runs the same anatomy: each exemption and deduction was passed for a felt constituency need (the constituency literally being the beneficiaries who now defend it), the one-way ratchet means administrations only add provisions, and the combined code becomes unworkable to optimise across — with tax simplification as the politically difficult, distinctly-named inverse that the Beers-Criteria-style "controls of concern" inventory and the deprescribing protocol structurally mirror. A clinician running deprescribing, a legislator drafting a sunset clause, and an engineer scheduling a flag-rationalisation sprint are instituting one reverse discipline against one ratchet.

Mapped back: The patient and the tax code are managed substrates; the eleven drugs and the accumulated exemptions are discrete locally-justified additions whose joint cost exceeds their sum; the prescribing cascade and the beneficiary constituencies are the removal-resisting forces; deprescribing and tax simplification are the named inverse-operations — the same prime in medicine and law.

Structural Tensions

T1 — Add Cost versus Remove Cost (sign/direction). The engine of the ratchet is that adding requires only "this might help" while removing requires "this is no longer needed" — and the latter is structurally harder because the counterfactual of operating without the intervention is unobservable while it remains in place. The characteristic failure is evaluating removals by the same evidentiary bar as additions and concluding nothing can be safely removed, so the stack only grows. The diagnostic is to demand a pre-committed removal trigger at add-time: an intervention added without a stated condition for its own removal has set the asymmetry to maximum and guaranteed it will outlive its usefulness.

T2 — Per-Item Merit versus Joint-Stack Effect (scalar / local-global). Each intervention can be locally net-positive while the joint stack is net-negative, because the relevant quantity is the marginal joint-effect given the existing stack, not the item in isolation. The failure is the rigorous per-item review that approves every addition on its own merits and never sees the combinatorial interaction that determines actual behaviour — a regimen where each drug helps but the eleven together cause falls. The diagnostic is to shift the question from "does this help?" to "what does this do given everything already present?", sizing each addition against the interaction matrix rather than evaluating it alone.

T3 — Linear Sizing versus Combinatorial Interaction (scalar). With \(N\) concurrently active interventions the joint-effect space is the \(2^N\) subsets and their interactions, so management cost scales super-linearly — yet additions are routinely costed as if the burden grew by one. The failure is budgeting the cost of an addition as its per-item cost, missing that it multiplies untested interaction states with everything already in the stack. The diagnostic is to price any addition against the cross-interaction matrix, not the item: a test suite validating each flag in isolation, or a review approving each drug singly, is measuring \(N\) where the real cost lives in \(2^N\).

T4 — Default Accretion versus Named Inverse-Operation (temporal). The default trajectory under ordinary operation is monotonic growth; reversal requires a distinct named operation — deprescribing, sunset review, refactor sprint — that does not arise from normal work and must be deliberately instituted. The failure is assuming good per-addition discipline suffices, so no reverse procedure is ever ritualised and the stack ratchets up regardless of how well each item was vetted. The diagnostic is to ask whether the domain has a named, scheduled inverse-operation with its own cadence; if removal happens only opportunistically, the ratchet has no counter-force and accretion is guaranteed.

T5 — Stated Rationale versus Self-Interested Constituency (coupling). Each intervention acquires stakeholders, dependencies, and institutional memory that resist its removal independently of whether it still does net good — the constituency couples the intervention's survival to interests divorced from its current value. The failure is debating a removal on the merits while the real resistance is constituency defence, so evidence of net harm fails to dislodge an intervention its beneficiaries protect. The diagnostic is to identify, before adding, which stakeholders will form around the intervention and what their interest in its continuation will be after the original problem dissolves — and to rotate constituencies so they do not become institutional.

T6 — Cascade Trigger versus Independent Accretion (scopal). Stack growth has two distinct sources that demand different remedies: a cascade where one intervention causes the indication for the next (a drug treating another drug's side effect), versus independent additions that merely co-accumulate. The failure is treating all accretion as independent and missing a cascade — removing downstream items while the upstream cause keeps regenerating them — or treating independent additions as a cascade and hunting for a root cause that does not exist. The diagnostic is to trace whether each addition's indication was created by an existing intervention; cascade-driven items are removed by addressing the trigger, independent ones by direct deprescription.

Structural–Framed Character

Intervention stack accretion sits on the framed side of the structural–framed spectrum, consistent with its framed label and aggregate of 0.6. There is a genuine relational skeleton — asymmetric add/remove costs, combinatorial interaction across \(2^N\) subsets, a one-way accretion ratchet requiring a distinct named inverse-operation — but the prime cannot be stated without naming human institutional practice, and that is what tips it past the middle.

The decisive criterion is human_practice_bound (1.0): the ratchet's signature mechanism is constituency formation — each intervention acquiring stakeholders, audit trails, and institutional memory that resist its removal — and the asymmetric add/remove cost is grounded in who must justify what to whom. These are facts about organizations and their politics, not about matter; the prime's home cases (polypharmacy, regulatory codes, software features under feature-owners, security controls, organizational initiatives, curricula) are all deliberate-intervention substrates with constituency dynamics, with no physical or biological substrate where the ratchet runs indifferently. The remaining four criteria each read mid (0.5), holding the aggregate at 0.6. The accretion-with-asymmetric-removal shape partly travels — recognisable as polypharmacy, regulatory accretion, feature creep, control sprawl — but an "intervention / sunset review / deprescribing / technical-debt" design lexicon tends to come along (vocab_travels 0.5). It carries a mild negative valence: "accretion," "ratchet," and "stack" frame the pattern as bloat to be pruned, though the structural diagnosis itself is neutral about whether any given stack is over-grown (evaluative_weight 0.5). Its origin is cybernetic and intervention-design rather than tied to one named institution (institutional_origin 0.5). And invoking it imports a modest interpretive frame — read this accumulation as a one-way ratchet needing a deliberate inverse-operation — while still recognising a genuine super-linear cost growth that is really present (import_vs_recognize 0.5). The ratchet skeleton is real and recurs cleanly, but because it lives only in human-institutional substrates with constituencies and arrives in designed-intervention vocabulary, the prime belongs on the framed side.

Substrate Independence

Intervention-stack accretion is a moderately substrate-independent prime — composite 3 / 5 on the substrate-independence scale. Its domain breadth is real but bounded: the discrete-additions-with-asymmetric-removal shape recurs across clinical polypharmacy (the canonical case, with Beers/STOPP-START and deprescribing as the response), regulatory and legal codes (sunset clauses as the named inverse), software systems (feature creep and technical debt), security controls (alert fatigue and control rationalisation), organisational initiatives ("initiative fatigue" and change moratoria), build and CI pipelines, curricula and standards, and tax exemptions — genuinely distinct fields, but every one of them a deliberate-intervention substrate with constituency dynamics, with no physical or biological substrate where the ratchet runs indifferently. Its structural abstraction is mid because the signature mechanism — constituency formation, where each intervention acquires stakeholders, audit trails, and institutional memory that resist its removal, producing one-sided add-time justification and bilateral remove-time justification — is a fact about organisations and their politics, not about matter, so the abstraction cannot be lifted out of human-institutional settings. Its transfer evidence earns a 4: the asymmetric add/remove cost, the super-linear interaction growth, and above all the named and disciplined inverse operation (deprescribing, sunset review, refactor cycles, control rationalisation, curriculum reform, simplification proposals) recur across every substrate as recognisable counterparts, so a clinician's deprescribing logic and a software team's deprecation policy are visibly the same move. The composite sits at 3 because the human-constituency ceiling pins breadth and abstraction even as the inverse-operation transfer is concretely documented.

  • Composite substrate independence — 3 / 5
  • Domain breadth — 3 / 5
  • Structural abstraction — 3 / 5
  • Transfer evidence — 4 / 5

Relationships to Other Primes

One-hop neighborhood: parents above, mutual partners to the right, children below.InterventionStack Accretionsubsumption: Ratchet EffectRatchet Effectsubsumption: Technical DebtTechnical Debt

Parents (1) — more general patterns this builds on

  • Intervention Stack Accretion is a kind of Ratchet Effect

    The file: 'one substrate-general instantiation of a directional-asymmetry ratchet' that ADDS three commitments (discrete interventions, combinatorial 2^N interaction, constituency formation). ratchet_effect is the genus; this is the enriched child. ratchet_effect is a candidate.

Children (1) — more specific cases that build on this

  • Technical Debt is a kind of, typical Intervention Stack Accretion

    The file: 'technical_debt is the software-specific child (and metaphor source); this prime is the cross-substrate parent covering polypharmacy, regulatory codes, curricula.' BUT technical_debt is a CANDIDATE (CAND-R2-053-06), not canonical — recorded as a candidate-link below, not a canonical subsumes_existing edge.

Path to root: Intervention Stack Accretion → Ratchet Effect → Path Dependence → Dependency

Neighborhood in Abstraction Space

Intervention Stack Accretion sits in a moderately populated region (48th percentile for distinctiveness): it has near-neighbors but no dense thicket of synonyms.

Family — Unclustered & Miscellaneous (91 primes)

Nearest neighbors

Computed from structural-signature embeddings · 2026-06-14

Not to Be Confused With

The broadest confusion is with the bare ratchet_effect, since intervention stack accretion is a one-way ratchet — but a richly specified one, and the specification is what carries the prime's content. A bare ratchet names only directional asymmetry: a quantity that moves easily in one direction and resists moving back. Intervention stack accretion adds three commitments the bare ratchet does not name. First, what is accreting: discrete interventions on a shared substrate, each with its own justification, audit trail, and constituency, not an undifferentiated quantity. Second, combinatorial interaction: with \(N\) concurrently active interventions the management cost scales as the \(2^N\) subsets and their interactions, super-linearly rather than monotonically. Third, constituency formation: each item acquires stakeholders that resist its removal independently of its current value. A reader who collapses the prime into "a ratchet" keeps only the asymmetry and loses the super-linear interaction term and the constituency dynamics — which is to lose exactly the leverage points (the interaction matrix and the stakeholder set) the prime exists to expose, and the recognition that the only counter-force is a distinct named inverse-operation with its own ritual.

A second genuine confusion is with lock_in. Lock-in is per-item: a single choice, once made, becomes costly to reverse because of switching costs, sunk investment, or accumulated dependency. Intervention stack accretion involves per-item lock-in as one ingredient — each intervention is harder to remove than to add — but its distinctive content is the additive accumulation across many items. The pathology is not that any one intervention is locked in but that dozens co-accumulate, their joint behaviour exceeding the sum of parts, so a system whose every individual item could in principle be removed still ratchets upward in aggregate complexity. Reading the prime as lock-in focuses attention on the reversibility of single choices and misses the combinatorial joint-stack effect — the eleven medications that each help while the regimen together causes falls — which is where the actual cost lives and which no single-item lock-in analysis reaches.

A third confusion is with cascade. A cascade is a trigger pattern: one intervention causes the indication for the next, as when a drug is prescribed to treat another drug's side effect, generating a chain. Intervention stack accretion is the accumulated state, and crucially it does not require a cascade: many additions are independent, each justified by its own felt local need with no causal link to the others. Cascade and accretion can co-occur — a prescribing cascade is one way a stack grows — but conflating them mis-routes the remedy. Cascade-driven items are removed by addressing the upstream trigger (remove the cause and the downstream indications dissolve); independent items are removed only by direct deprescription of each. Treating all accretion as cascade sends the analyst hunting for a root cause that does not exist among independent additions, while treating a genuine cascade as independent accretion removes downstream items the upstream cause keeps regenerating.

These distinctions matter because they determine the fix. A ratchet framing prescribes only "resist the asymmetry" and misses the interaction matrix and constituencies; a lock-in framing addresses single-item reversibility and misses the joint stack; a cascade framing hunts for triggers that independent additions lack — whereas the prime routes to its full toolkit (adoption gates, sunset defaults, the named inverse-operation, constituency rotation) sized against the super-linear interaction term that is its signature.

Solution Archetypes

No catalogued solution archetypes reference this prime yet.