Archive registry entry

LAW-124 — AI Rule-Stacking Law

Archive registry entry

LAW-124 — AI Rule-Stacking Law

AI rule-stacking creates hidden debt when safety, policy, refusal, moderation, alignment, ranking, or governance rules accumulate faster than auditability, context integrity, feedback, and restoration capacity.

draftid: LAW-124version: 1.0.0updated: 2026-06-17

Archive Progress

This section can be read now; registry depth and cross-references are still being strengthened.

Foundation

Online

The section has a stable overview route and basic reader context.

Technical Layer

Online

A deeper technical overview is available.

Registry

Current

171 registry entries are available.

Cross-links

Curating

Related concepts are being connected conservatively for accuracy.

Jump Through This Page

LAW-123 — AI U4 Truth Discipline Law

Registry

LAW-125 — AI Memory Scaling Law

0. Plain Statement

AI rules accumulate debt when they stack faster than auditability.

Plain-language version:

Adding more rules to an AI system does not automatically make it safer, fairer, more aligned, or more coherent.

Rules can help.

But when safety policies, refusal rules, moderation layers, ranking heuristics, guardrails, hidden classifiers, escalation rules, and exception handlers accumulate faster than the system can audit, explain, correct, and repair them, the rule stack becomes a source of hidden debt.

AI safety can degrade by adding too many poorly sequenced rules.

1. Formal Definition

The AI Rule-Stacking Law states that AI governance creates hidden debt when the complexity, number, interaction density, and opacity of AI rules grow faster than effective auditability, context integrity, feedback integrity, and restoration capacity.

AI rule stacks may include:

system prompts;
safety policies;
refusal rules;
moderation rules;
hidden classifiers;
risk scoring rules;
ranking heuristics;
content filters;
guardrails;
redirection rules;
escalation rules;
fallback rules;
memory rules;
retrieval rules;
policy exceptions;
regional compliance rules;
product constraints;
brand constraints;
legal constraints;
platform norms;
enforcement pathways;
human-review triggers;
model-side alignment behavior;
post-processing rules;
invisible constraint layers.

Rules are not the problem by themselves.

The problem appears when:

textScroll

rule_stack_complexity > Au_eff + context_integrity + FI + R_eff

At that point, the system no longer understands its own safety behavior.

It may refuse legitimate requests, allow unsafe requests, collapse context, route users incorrectly, hide errors, produce pseudo-safety, or transfer repair burden to users.

2. Canonical Form

Core form:

textScroll

AI rule stacks accumulate debt when complexity exceeds auditability

Canonical form:

textScroll

rule_stack_complexity↑ + Au_eff↓ ⇒ H_AI↑

Constraint-debt form:

textScroll

AI rule count↑ + rule interaction density↑ + context_integrity↓ ⇒ misclassification risk↑

Safety inversion form:

textScroll

safety rules↑ - ℛ / FI / Au ⇒ pseudo-safety

Governance form:

textScroll

AI constraint complexity must scale slower than auditability + feedback + repair capacity

Restoration-valid contrast:

textScroll

AI rules remain coherent when scoped, sequenced, traceable, context-preserving, feedback-correctable, and repair-linked over Τ

Related variables:

textScroll

O, H, H_AI, ε, ε_AI, ι, Au, Au_eff, µᵢ, BΣ, K, σ, R, R_eff, 𝓑, 𝓓, Φ, Φ_AI, Λ, ⊗, Γ, Γ_AI, Π, Ξ, ℛ, Θ, Σ, Ψ, Τ, FI, MS, L, rule_stack_complexity, rule_count, rule_interaction_density, policy_stack_depth, guardrail_stack_depth, refusal_logic, exception_density, rule_collision_rate, context_integrity, classification_trace, rule_trace, correction_path, appeal_path, repair_load

Where:

TableScroll

Variable	Meaning in this law
`rule_stack_complexity`	Total complexity of AI rules, constraints, exceptions, policies, filters, classifiers, and interaction effects
`rule_count`	Number of explicit or implicit rules governing AI behavior
`rule_interaction_density`	Degree to which rules interact, collide, override, or obscure one another
`policy_stack_depth`	Depth of policy and governance layers acting on the AI system
`guardrail_stack_depth`	Number and depth of guardrail layers before, during, or after model execution
`refusal_logic`	Rules and classifiers controlling refusals, redirects, safety boundaries, and denials
`exception_density`	Number of exceptions, edge cases, carve-outs, and conditional overrides
`rule_collision_rate`	Frequency of inconsistent or conflicting rule outputs
`context_integrity`	Degree to which relevant context survives rule application
`classification_trace`	Trace of how AI categorized a request, signal, user, context, or action
`rule_trace`	Trace of which rules were applied, skipped, overridden, or conflicted
`correction_path`	Path by which wrong rule application can be corrected
`appeal_path`	Path by which affected nodes can challenge rule-stack effects
`repair_load`	Restoration burden created by rule-stack errors
`H_AI`	Hidden AI debt produced by rule collisions, false refusals, unsafe allowances, and opaque constraints
`Au / Au_eff`	Auditability and effective auditability of rule behavior and interactions
`FI`	Feedback integrity; rule-stack errors must be corrigible
`BΣ`	Boundary integrity; rules must preserve domain, role, authority, and context boundaries
`R / R_eff`	Restoration capacity required to repair rule-stack harms
`L`	Legitimacy of AI rule behavior under audit
`O`	Coherence; rules should preserve or increase coherence
`ι / Ξ`	Inversion when safety rules produce incoherent control or pseudo-safety
`Φ_AI`	AI safety proxy such as refusal rate, compliance score, benchmark score, or incident count
`Γ_AI`	AI classification layer affected by rule stacks
`Π`	Operational execution of rules, refusals, filters, rankings, routing, and enforcement
`Θ`	Humility preventing rule certainty and policy overproduction
`Σ`	Scope, domain, and authority of each rule
`Ψ`	Field and affected-node feedback revealing rule-stack effects
`Τ`	Time validation of rule-stack coherence, recurrence, and repair

3. Core Mechanism

The law unfolds because every added rule changes the system’s decision geometry.

Coherent AI rule-stack pathway

textScroll

new rule need appears
→ rule scope is defined
→ interaction with existing stack is tested
→ context preservation is checked
→ audit and correction traces are preserved
→ affected feedback reaches rule layer
→ repair path exists
→ rule stack reduces debt over time

AI rule-stacking failure pathway

textScroll

AI risk appears
→ new rule is added
→ exception is added
→ hidden classifier is added
→ refusal path expands
→ rule interactions become opaque
→ context collapses
→ false refusals / unsafe allowances rise
→ users carry correction burden
→ H_AI rises

The core mechanism is:

textScroll

rules improve safety only while their interaction geometry remains legible and repairable

Detailed mechanism:

A risk, incident, complaint, policy need, or governance demand appears.

The system responds by adding a rule, classifier, guardrail, refusal behavior, ranking adjustment, moderation category, or exception.

The new rule changes classification.

It affects what the AI treats as safe, unsafe, relevant, irrelevant, helpful, harmful, allowed, refused, escalated, or transformed.

Rules interact.

The new rule may collide with older rules, override context, create exceptions, trigger false positives, or hide the reason for refusal.

Audit burden rises.

Each additional rule increases the number of paths the system must be able to inspect, test, and repair.

Context integrity may fall.

The rule stack may simplify context into policy categories, losing meaning, intent, educational purpose, artistic context, cultural context, or affected-node nuance.

Feedback may fail to reach the right layer.

Users can report bad outputs, but the system may not know which rule caused the behavior.

Pseudo-safety can form.

Refusal rates, compliance scores, or visible incident counts may look safer while hidden debt rises.

Restoration requires rule-stack audit.

Safety must be re-established by mapping, simplifying, sequencing, tracing, and repairing the constraint stack.

4. When This Law Applies

This law applies whenever AI behavior is governed by multiple interacting policies, prompts, filters, classifiers, refusal rules, guardrails, ranking systems, safety rules, moderation categories, escalation pathways, or exception handlers.

It is especially important when:

AI refusals become inconsistent;
legitimate requests are blocked;
unsafe requests pass through;
policy explanations are generic;
no one can identify which rule caused a behavior;
guardrails are added after each incident;
exceptions multiply;
context is collapsed into safety labels;
users learn to route around restrictions;
AI moderation produces inconsistent decisions;
rule changes improve metrics but worsen field experience;
safety claims rely on increased refusal rate;
human reviewers cannot reconstruct rule interaction;
affected-node correction does not reach the rule layer;
governance responds to every failure by adding another constraint.

The law applies strongly when:

textScroll

AI rules are being added faster than the system can audit their interactions

or when:

textScroll

safety behavior becomes less explainable as the rule stack grows

Typical domains:

TableScroll

Domain	AI Rule-Stacking Expression
AI safety	Safety policies and refusals can accumulate into pseudo-safety when interaction effects are unaudited.
AI governance	Governance must audit rule-stack complexity, not only policy intent.
Cybersecurity	AI threat classifiers and allow/deny lists can collide, producing false positives and blind spots.
Media / information networks	AI moderation and ranking rules can suppress or amplify content without legible rationale.
Institutions	AI triage and eligibility rules can create procedural denial and appeal burden.
Economy	AI fraud, credit, hiring, or risk rules can stack into opaque exclusion.
Culture	Rule stacks can encode dominant norms while claiming neutrality.
Restoration	Rule errors must route into repair, not more unexamined rule additions.

5. When This Law Does Not Apply

This law should not be used to reject rules, guardrails, policies, refusals, or safety constraints entirely.

AI systems need constraints.

Rules can be coherent when they are clear, scoped, tested, traceable, feedback-correctable, and repair-linked.

False-positive cases:

TableScroll

Case	Why rules may still be coherent
A clear rule prevents active harm	Constraints can protect coherence
A scoped refusal preserves a real boundary	Refusal can be legitimate when traceable and correctable
A guardrail has tested interaction effects	Safety improves when rule behavior is auditable
An exception preserves context	Exceptions can improve coherence when bounded
A moderation policy has appeal and repair	Policy can be legitimate when corrigible
A classifier routes to human review	Rules can support governance when review exists
Rule simplification reduces false positives	Constraint reduction can be a safety improvement

Important distinction:

The problem is not rules; the problem is unauditable rule accumulation.

6. Diagnostic Signature

Canonical diagnostic:

textScroll

rule_stack_complexity↑ + Au_eff↓ ⇒ H_AI↑

Warning signature:

textScroll

rule_count↑
exception_density↑
rule_collision_rate↑
context_integrity↓
classification_trace↓
correction_path↓
false refusal / unsafe allowance↑
⇒ AI rule-stack debt

Common indicators:

TableScroll

Diagnostic	Expected movement	Interpretation
`rule_stack_complexity`	measured	Total constraint complexity must be visible
`rule_count`	watched	More rules increase audit burden
`rule_interaction_density`	watched	Interactions create emergent behavior
`policy_stack_depth`	watched	Policy depth can exceed operator comprehension
`guardrail_stack_depth`	watched	Guardrail layers can obscure cause
`exception_density`	watched	Exceptions increase edge-case debt
`rule_collision_rate`	should ↓	Collisions indicate incoherent stack
`context_integrity`	should remain high	Rule application must preserve context
`rule_trace`	must remain intact	Applied rules must be reconstructable
`classification_trace`	must remain intact	Rule-driven classifications must be auditable
`correction_path`	must exist	Wrong rule application must be repairable
`appeal_path`	must exist where effects matter	Affected nodes need challenge route
`R_eff`	must scale	Rule-stack harm requires repair capacity
`Φ_AI`	not sufficient	Refusal rate or compliance score is not proof
`L`	stable / ↑ if valid	Legitimacy holds when rule behavior is understandable and repairable
`H_AI`	↑ if invalid	Hidden debt rises from unauditable rule interactions
`Τ`	required	Time validates rule-stack coherence

Additional diagnostics:

TableScroll

Diagnostic	Use
AI Rule-Stacking	Detects rule accumulation beyond auditability
AI Policy Stack Complexity	Measures governance layer depth
AI Constraint Complexity	Tracks interaction burden
AI Refusal Stack	Tests refusal logic and false positives
AI Guardrail Stack	Tests guardrail layering and conflict
AI Safety Rule Interaction	Tests emergent behavior from rules
AI Rule Collision	Detects contradiction and override loops
AI Context Integrity	Detects context loss through policy categories
AI Legibility	Tests whether rule effects are traceable
Temporal Proof	Validates safety and recurrence over time

7. Failure Pattern

If ignored, this law creates AI systems that appear more governed while becoming less coherent.

General failure pathway:

textScroll

AI risk appears
→ new safety rule is added
→ exception is added
→ guardrail layer is added
→ rule interactions become opaque
→ context collapses
→ false refusals and unsafe allowances rise
→ correction cannot reach source
→ H_AI accumulates

Common failure modes:

AI Rule-Stacking — rules accumulate beyond system auditability.
AI Policy Stack Debt — governance layers create hidden operational debt.
AI Guardrail Collision — guardrails conflict, override, or obscure each other.
AI Refusal Overgrowth — refusal expands beyond coherent boundary protection.
AI Context Collapse — nuanced context is flattened into rule categories.
AI False Refusal — legitimate requests are blocked by overbroad rules.
AI Unsafe Allowance — harmful requests pass through due to rule conflict or blind spots.
AI Rule Interaction Failure — emergent behavior appears from unintended rule collisions.
AI Auditability Collapse — no one can identify which rule caused the output.
AI Legibility Collapse — affected nodes cannot understand or correct rule effects.
AI Pseudo-Safety — safety metrics improve while field coherence declines.
AI User Burden Export — users must rephrase, appeal, self-censor, or repair around the rule stack.
AI Feedback Suppression — corrections cannot reach the relevant rule layer.
AI Trust Collapse — users lose trust when rules feel arbitrary or incoherent.
Hidden Debt Accumulation — rule complexity hides classification and repair debt.

Compact failure signature:

textScroll

rules↑ + traceability↓ + context↓ ⇒ pseudo-safety + H_AI↑

8. Restoration Implications

Restoration requires auditing the rule stack as a system, not only individual rules.

The first restoration question is not:

textScroll

Which new rule should we add?

The first restoration question is:

textScroll

Which rules, interactions, exceptions, and hidden constraints are producing the behavior — and can the system trace, correct, simplify, and repair them?

Restoration priorities:

Inventory the rule stack.
Map policy, guardrail, classifier, refusal, and exception layers.
Map rule interactions and collision points.
Identify context collapse points.
Reconstruct rule and classification traces.
Measure false refusals and unsafe allowances.
Restore correction, appeal, and feedback pathways.
Simplify or remove rules that create more debt than coherence.
Re-sequence rules around boundary, audit, and repair.
Validate reduced recurrence over time.

Relevant restoration arcs:

TableScroll

Restoration Arc	Why it applies
AI Rule Stack Audit	Inventories and maps the full rule stack
AI Policy Stack Simplification	Reduces complexity and hidden interactions
AI Constraint Re-Sequencing	Reorders constraints around coherence and repair
AI Guardrail Collision Repair	Resolves conflicting guardrails
AI Refusal Logic Repair	Corrects false refusal and unsafe allowance patterns
AI Context Restoration	Restores nuance lost through rules
AI Classification Recalibration	Rebalances categories and labels
AI Feedback Integrity Restoration	Allows user and field correction to reach rule layers
AI Legibility Restoration	Rebuilds rule and decision traces
AI Restoration Capacity Increase	Builds repair capacity for affected nodes
AI Governance Re-Sequencing	Places audit and repair before adding new constraints
Hidden Debt Reduction	Repairs debt created by rule-stack behavior
Temporal Validation	Confirms simplified stack improves outcomes over time

Minimal restoration sequence:

textScroll

inventory rule_stack
→ map rules / exceptions / classifiers / guardrails
→ detect collisions + context collapse
→ restore rule_trace + classification_trace
→ measure false refusals / unsafe allowances
→ restore Au/FI/correction/appeal
→ simplify or re-sequence Π
→ perform ℛ on affected debt
→ validate H_AI↓ and L↑ over Τ

Temporal validation requirement:

textScroll

rule interactions become traceable
context integrity improves
rule collision rate decreases
false refusals decrease
unsafe allowances decrease
correction reaches rule layer
appeal outcomes improve
user burden decreases
hidden AI debt decreases
legitimacy stabilizes
coherence holds or rises over time

9. Design Rule

Do not add AI rules faster than you can audit, explain, correct, and repair their interactions.

Operational design requirements:

Inventory all rules and hidden constraints.
Define the scope of each rule.
Preserve rule trace.
Preserve classification trace.
Preserve context integrity.
Test interaction effects.
Test rule collisions.
Test false refusals.
Test unsafe allowances.
Track exception density.
Track user correction burden.
Provide appeal where effects matter.
Provide correction pathways.
Route rule errors into repair.
Remove or simplify debt-producing rules.
Validate over time before scaling.

Avoid:

adding rules as reflex after incidents;
broadening refusals without audit;
hidden classifiers without trace;
rule exceptions without scope;
guardrails that cannot be inspected;
policy stacks that human reviewers cannot reconstruct;
safety metrics based only on refusal count;
moderation rules without appeal;
AI governance by accumulation;
treating complexity as rigor;
treating opacity as safety;
fixing rule failures by adding more unaudited rules.

10. Cross-Scale Expressions

TableScroll

Scale / Layer	Expression of the Law
U0 — Substrate	Rule-stack behavior can affect physical, medical, infrastructure, and material outcomes when AI action is embodied or operationalized.
U1 — Energy / capacity	Rule stacks consume audit, review, engineering, legal, moderation, and user correction capacity.
U2 — Boundary / interface	Rules govern membranes: access, refusal, consent, role, domain, and context boundaries.
U3 — Process / execution	Rules execute as prompts, classifiers, filters, guardrails, moderation systems, rankings, and escalation workflows.
U4 — Classification / claim	Rule stacks shape what AI classifies as safe, unsafe, true, relevant, harmful, allowed, or refused.
U5 — Time / delay	Rule debt accumulates over deployments, incidents, policy updates, and exceptions.
U6 — Field effect	Field outcomes reveal whether rule stacks preserve coherence or create pseudo-safety.
U7 — Recurrence / memory	Rule-stack failures become memory, precedent, model behavior, policy habit, and user adaptation patterns.
U8 — Environment / forcing	Platforms, markets, law, media, governance, and public pressure incentivize rule accumulation unless audit is protected.

11. Examples

Example A — False Refusal From Overbroad Safety Stack

Scenario:

An AI system refuses educational, artistic, technical, or restorative content because multiple safety rules compress context into a broad risk category.

Law expression:

textScroll

rule_stack_complexity↑ + context_integrity↓ ⇒ false refusal

Interpretation:

The refusal is not only a model error; it is a rule-stack interaction failure.

Example B — Unsafe Allowance From Rule Collision

Scenario:

A request passes through because one classifier treats it as benign educational content while another guardrail fails to detect harmful execution detail.

Law expression:

textScroll

rule_collision + classification_trace weak ⇒ unsafe allowance

Interpretation:

Conflicting rules can create gaps as well as overblocking.

Example C — Generic Policy Explanation

Scenario:

A user receives “I can’t help with that” but no category, correction path, or distinction between safety issue, uncertainty, unavailable capability, or policy collision.

Law expression:

textScroll

refusal_logic opaque + rule_trace absent ⇒ AI legibility collapse

Interpretation:

The system cannot repair the refusal if it cannot trace the rule pathway.

Example D — Guardrail Added After Every Incident

Scenario:

After each public AI incident, a new guardrail is added. Over time the model becomes inconsistent, brittle, and less able to handle edge cases.

Law expression:

textScroll

incident → rule added repeatedly → interaction_density↑ ⇒ H_AI↑

Interpretation:

Safety by accumulation creates hidden debt unless the whole stack is audited and simplified.

Example E — Coherent Rule Stack

Scenario:

An AI system has a smaller set of scoped rules, clear refusal categories, traceable classification, context-aware exceptions, appeal routes, field monitoring, and repair of false refusals.

Law expression:

textScroll

rules + Au + FI + context + ℛ ⇒ coherent AI safety

Interpretation:

Rules improve safety when they remain legible, scoped, corrigible, and repair-linked.

Example F — Governance Stack Simplification

Scenario:

An AI governance team removes redundant policies, merges overlapping refusal rules, clarifies scope, improves context handling, and adds correction pathways before adding new restrictions.

Law expression:

textScroll

rule simplification + traceability↑ ⇒ H_AI↓

Interpretation:

Reducing rule complexity can be a safety improvement.

12. Relationship to Nearby Laws

TableScroll

Related Law	Relationship
LAW-001 — Coherence Priority Law	AI rules are valid only when they preserve coherence
LAW-002 — Coherence Trajectory Law	Rule stacks must improve trajectory over time
LAW-003 — Success Proxy Divergence Law	Rule-stack metrics can diverge from real safety
LAW-004 — Stability-Coherence Separation Law	Stable refusal behavior can hide incoherence
LAW-006 — Time Validation Law	Rule-stack effects require temporal validation
LAW-009 — U4 / U6 Truth Law	Rule-based claims require field validation
LAW-010 — Hidden Debt Accumulation Law	Rule stacks accumulate hidden debt
LAW-011 — Hidden Debt Return Law	Rule-stack debt returns as incidents or trust collapse
LAW-012 — Error Lag Law	Rule-stack errors may become visible late
LAW-013 — Auditability-Debt Law	Rule stacks create debt when auditability falls
LAW-014 — Constraint Complexity Debt Law	LAW-124 specializes constraint complexity debt for AI
LAW-015 — Suppressed Auditability Debt Law	Hidden policy layers create audit debt
LAW-016 — Inversion Formation Law	Safety rules can invert into control or pseudo-safety
LAW-020 — Bandwidth Threshold Law	Rule complexity can exceed human review bandwidth
LAW-024 — Latency–Gain Oscillation Law	Fast rule effects with slow correction can oscillate
LAW-027 — Meaning Collapse Threshold Law	Excessive rules can collapse meaning and context
LAW-028 — Control Density to Meaning Loss Loop	Rule stacking can increase control density and reduce meaning
LAW-031 — Observability Collapse Law	Rule stacks can make behavior less observable
LAW-036 — Signal Artifact Law	Rules can amplify artifacts as safety signals
LAW-037 — Misclassification Law	Rule stacks amplify misclassification risk
LAW-038 — Pattern Recognition Discipline Law	Rule interactions require disciplined pattern review
LAW-040 — Filtering Law	Rule stacks often operate through filtering
LAW-041 — Boundary Membrane Law	Rules must preserve boundaries without overclosing them
LAW-048 — Feedback Integrity Law	Rule errors must remain correctable
LAW-050 — Control-Restoration Separation Law	Rule stacks must not substitute control for restoration
LAW-051 — Requisite Variety Law	Rule variety must match system complexity without exceeding audit capacity
LAW-052 — Stability Proof Law	Rule stacks must survive perturbation
LAW-057 — Deception Instability Law	Safety explanations become unstable when rules are opaque
LAW-060 — Interface Legitimacy Law	Rule behavior needs legitimate explanation and correction
LAW-061 — Restoration Sequencing Law	Rule-stack errors must sequence into repair
LAW-064 — Restoration Debt Reduction Law	Rules should reduce, not create, restoration debt
LAW-066 — Restoration Capacity Sufficiency Law	Repair capacity must match rule-stack impact
LAW-067 — Temporal Proof Law	Rule-stack coherence requires proof over time
LAW-073 — Restoration Before Scaling Law	Rule stacks should not scale before repair capacity
LAW-095 — Meaning Directionality Law	Rules direct meaning and admissibility
LAW-102 — Legitimacy Audit Law	AI rule legitimacy requires audit
LAW-109 — High-Φ Legitimacy Scaling Law	High-influence rule stacks need stronger audit and repair
LAW-110 — Governance Sequencing Law	AI rules must be sequenced into governance
LAW-111 — Meaning Audit Law	AI safety narratives are not audit-exempt
LAW-112 — Security as Sustained Coherence Law	Rule stacks are security-valid only if coherence holds
LAW-113 — Incident Lag Law	Rule-stack failure may appear late
LAW-114 — Pseudo-Security Law	Rule accumulation can create pseudo-security
LAW-115 — Surveillance–Restoration Law	Monitoring rules must route into repair
LAW-116 — Emergency Normalization Law	Emergency rules can become permanent stack debt
LAW-120 — Security Legibility Law	Rule stacks require traceability
LAW-121 — AI as Γ-Amplifier Law	Rule stacks shape AI Γ amplification
LAW-122 — AI Error Lag Law	Rule-stack debt often appears as delayed AI error
LAW-123 — AI U4 Truth Discipline Law	Rule-generated claims require U4/U6 discipline
LAW-125 — AI Context Collapse Law	Rule stacks often collapse context
LAW-126 — AI Proxy Drift Law	Rule-stack metrics can drift from coherence
LAW-127 — AI Decision Pipeline Law	Rule-stack outputs must pass through disciplined decision pathways
LAW-128 — AI Representation Law	Rules governing representation require scope and appeal
LAW-129 — AI Capability–Legibility Gap Law	Rule stacks widen the gap when capability outruns traceability
LAW-130 — AI Membrane Triage Law	Rule failures must be localized to the failed membrane
LAW-131 — Cognitive Infrastructure Scaling Law	AI rule stacks affect public cognition at scale
LAW-132 — AI Legitimacy Function Law	AI legitimacy depends on accountable rule behavior
LAW-133 — Synthetic Consensus Law	Rule-stacked systems can create artificial consensus effects
LAW-134 — Layered Interception Law	Layered safeguards must avoid unauditable rule accumulation
LAW-135 — Guardrail Belief-Sculpting Law	Guardrails can shape belief through rule stacks
LAW-136 — Invisible Constraint Amplification Law	Hidden AI rules become powerful invisible constraints

Aliases folded into this law:

AI Rule-Stacking Law
AI Policy Stack Debt Law
AI Guardrail Rule-Stacking Law
AI Safety Rule Accumulation Law
AI Constraint Stack Law
AI Refusal Stack Law
AI Governance Rule Debt Law

Deduplication note:

This law should remain the root AI rule-stacking law. LAW-014 defines general constraint complexity debt. LAW-121 defines AI as Γ-amplifier. LAW-122 defines AI error lag. LAW-123 defines AI truth discipline. LAW-124 specializes these into AI policy, guardrail, refusal, moderation, and governance stacks whose interaction complexity can exceed auditability and restoration capacity.

13. Operator Mapping

TableScroll

Operator	Role in this law
`Γ`	Classifies requests, risks, contexts, refusal categories, policy classes, and rule collision states
`Π`	Operationalizes rules, policies, guardrails, filters, refusals, exceptions, reviews, and enforcement pathways
`Ξ`	Captures inversion when safety rules produce pseudo-safety, control, or hidden debt
`⊗`	Rule stacks alter couplings among users, model, policy, product, reviewers, and affected nodes
`ℛ`	Repairs false refusal, unsafe allowance, misclassification, rule collision, and user burden
`Τ`	Validates rule-stack coherence, recurrence reduction, and legitimacy over time
`Θ`	Prevents rule certainty, policy overproduction, and safety-by-accumulation reflex
`Σ`	Defines scope, domain, authority, exception boundaries, and valid rule application
`Ψ`	Field and affected-node feedback reveals rule-stack effects
`Λ`	Tests compatibility between AI rule behavior and whole-system coherence

Coherent operator sequence:

textScroll

AI policy need appears
→ Θ prevent rule-adding reflex
→ Γ classify risk / context / boundary / rule need
→ Σ define rule scope and exception boundaries
→ Π test rule against existing stack
→ Au/FI preserve rule trace and correction
→ ℛ repair affected rule-stack debt
→ Ψ validate field effects
→ Τ validate reduced H_AI and stable L

Inverted operator sequence:

textScroll

AI incident or risk appears
→ rule added
→ exception added
→ guardrail added
→ Γ context collapses
→ Π rule interactions become opaque
→ FI and appeal remain weak
→ H_AI↑
→ Ξ / ι↑
→ L↓

14. Machine-Readable Summary

yamlScroll

id: "LAW-124"
name: "AI Rule-Stacking Law"
type: "law"
status: "draft"
family:
  - "AI Laws"
summary: "AI rule-stacking creates hidden debt when safety, policy, refusal, moderation, alignment, ranking, or governance rules accumulate faster than auditability, context integrity, feedback, and restoration capacity."
canonical_statement: "AI rules accumulate debt when they stack faster than auditability."
core_form: "AI rule stacks accumulate debt when complexity exceeds auditability"
canonical_form: "rule_stack_complexity↑ + Au_eff↓ ⇒ H_AI↑"
constraint_debt_form: "AI rule count↑ + rule interaction density↑ + context_integrity↓ ⇒ misclassification risk↑"
safety_inversion_form: "safety rules↑ - ℛ / FI / Au ⇒ pseudo-safety"
governance_form: "AI constraint complexity must scale slower than auditability + feedback + repair capacity"
restoration_valid_contrast: "AI rules remain coherent when scoped, sequenced, traceable, context-preserving, feedback-correctable, and repair-linked over Τ"
variables:
  primary:
    - "rule_stack_complexity"
    - "rule_count"
    - "rule_interaction_density"
    - "policy_stack_depth"
    - "guardrail_stack_depth"
    - "refusal_logic"
    - "exception_density"
    - "rule_collision_rate"
    - "context_integrity"
    - "classification_trace"
    - "rule_trace"
    - "correction_path"
    - "appeal_path"
    - "repair_load"
    - "H_AI"
    - "Au"
    - "Au_eff"
    - "FI"
    - "BΣ"
    - "R"
    - "R_eff"
    - "L"
    - "Φ_AI"
  secondary:
    - "O"
    - "H"
    - "ε"
    - "ε_AI"
    - "ι"
    - "µᵢ"
    - "K"
    - "σ"
    - "𝓑"
    - "𝓓"
    - "Φ"
    - "Λ"
    - "⊗"
    - "Γ"
    - "Γ_AI"
    - "Π"
    - "Ξ"
    - "ℛ"
    - "Θ"
    - "Σ"
    - "Ψ"
    - "Τ"
    - "MS"
diagnostics:
  - "AI Rule-Stacking"
  - "AI Policy Stack Complexity"
  - "AI Constraint Complexity"
  - "AI Refusal Stack"
  - "AI Guardrail Stack"
  - "AI Safety Rule Interaction"
  - "AI Auditability"
  - "AI Context Integrity"
  - "AI Rule Collision"
  - "AI Feedback Integrity"
  - "AI Restoration Capacity"
  - "AI Legibility"
  - "AI Hidden Debt"
  - "Temporal Proof"
failure_modes:
  - "AI Rule-Stacking"
  - "AI Policy Stack Debt"
  - "AI Guardrail Collision"
  - "AI Refusal Overgrowth"
  - "AI Context Collapse"
  - "AI False Refusal"
  - "AI Unsafe Allowance"
  - "AI Rule Interaction Failure"
  - "AI Auditability Collapse"
  - "AI Legibility Collapse"
  - "AI Pseudo-Safety"
  - "AI User Burden Export"
  - "AI Feedback Suppression"
  - "AI Trust Collapse"
  - "Hidden Debt Accumulation"
restoration_arcs:
  - "AI Rule Stack Audit"
  - "AI Policy Stack Simplification"
  - "AI Constraint Re-Sequencing"
  - "AI Guardrail Collision Repair"
  - "AI Refusal Logic Repair"
  - "AI Context Restoration"
  - "AI Classification Recalibration"
  - "AI Feedback Integrity Restoration"
  - "AI Legibility Restoration"
  - "AI Restoration Capacity Increase"
  - "AI Governance Re-Sequencing"
  - "Hidden Debt Reduction"
  - "Temporal Validation"
related_laws:
  - "LAW-001"
  - "LAW-002"
  - "LAW-003"
  - "LAW-004"
  - "LAW-006"
  - "LAW-009"
  - "LAW-010"
  - "LAW-011"
  - "LAW-012"
  - "LAW-013"
  - "LAW-014"
  - "LAW-015"
  - "LAW-016"
  - "LAW-020"
  - "LAW-024"
  - "LAW-027"
  - "LAW-028"
  - "LAW-031"
  - "LAW-036"
  - "LAW-037"
  - "LAW-038"
  - "LAW-040"
  - "LAW-041"
  - "LAW-048"
  - "LAW-050"
  - "LAW-051"
  - "LAW-052"
  - "LAW-057"
  - "LAW-060"
  - "LAW-061"
  - "LAW-064"
  - "LAW-066"
  - "LAW-067"
  - "LAW-073"
  - "LAW-095"
  - "LAW-102"
  - "LAW-109"
  - "LAW-110"
  - "LAW-111"
  - "LAW-112"
  - "LAW-113"
  - "LAW-114"
  - "LAW-115"
  - "LAW-116"
  - "LAW-120"
  - "LAW-121"
  - "LAW-122"
  - "LAW-123"
  - "LAW-125"
  - "LAW-126"
  - "LAW-127"
  - "LAW-128"
  - "LAW-129"
  - "LAW-130"
  - "LAW-131"
  - "LAW-132"
  - "LAW-133"
  - "LAW-134"
  - "LAW-135"
  - "LAW-136"
related_invariants:
  - "INV-001"
  - "INV-002"
  - "INV-006"
  - "INV-073"
  - "INV-078"
  - "INV-080"
operator_sequence:
  coherent:
    - "AI policy need appears"
    - "Θ prevent rule-adding reflex"
    - "Γ classify risk / context / boundary / rule need"
    - "Σ define rule scope and exception boundaries"
    - "Π test rule against existing stack"
    - "Au/FI preserve rule trace and correction"
    - "ℛ repair affected rule-stack debt"
    - "Ψ validate field effects"
    - "Τ validate reduced H_AI and stable L"
  inverted:
    - "AI incident or risk appears"
    - "rule added"
    - "exception added"
    - "guardrail added"
    - "Γ context collapses"
    - "Π rule interactions become opaque"
    - "FI and appeal remain weak"
    - "H_AI↑"
    - "Ξ / ι↑"
    - "L↓"
aliases:
  - "AI Rule-Stacking Law"
  - "AI Policy Stack Debt Law"
  - "AI Guardrail Rule-Stacking Law"
  - "AI Safety Rule Accumulation Law"
  - "AI Constraint Stack Law"
  - "AI Refusal Stack Law"
  - "AI Governance Rule Debt Law"
deduplication_note: "Root AI rule-stacking law. LAW-014 defines general constraint complexity debt. LAW-121 defines AI as Γ-amplifier. LAW-122 defines AI error lag. LAW-123 defines AI truth discipline. LAW-124 specializes these into AI policy, guardrail, refusal, moderation, and governance stacks whose interaction complexity can exceed auditability and restoration capacity."
source: "content/archive/laws/technical.md"

15. Compact Card Version

LAW-124 — AI Rule-Stacking Law

AI rules accumulate debt when they stack faster than auditability.

Core form:

textScroll

AI rule stacks accumulate debt when complexity exceeds auditability

Canonical form:

textScroll

rule_stack_complexity↑ + Au_eff↓ ⇒ H_AI↑

Plain meaning:

Adding more AI rules does not automatically improve safety. Safety policies, refusal rules, moderation layers, hidden classifiers, guardrails, ranking heuristics, exceptions, and governance constraints can create hidden debt when their interactions become harder to audit, explain, correct, and repair.

Constraint-debt form:

textScroll

AI rule count↑ + rule interaction density↑ + context_integrity↓ ⇒ misclassification risk↑

Safety inversion form:

textScroll

safety rules↑ - ℛ / FI / Au ⇒ pseudo-safety

Primary variables:

rule_stack_complexity, rule_count, rule_interaction_density, policy_stack_depth, guardrail_stack_depth, refusal_logic, exception_density, rule_collision_rate, context_integrity, classification_trace, rule_trace, correction_path, appeal_path, repair_load, H_AI, Au, Au_eff, FI, BΣ, R, R_eff, L, Φ_AI, Γ, Γ_AI, Π, Ξ, ℛ, Θ, Σ, Ψ, Τ

Diagnostic signature:

Rule count, exception density, and rule collision rate rise while context integrity, rule trace, classification trace, correction path, and appeal path fall. False refusals, unsafe allowances, user burden, and hidden AI debt increase.

Failure risk:

AI rule-stacking, AI policy stack debt, AI guardrail collision, AI refusal overgrowth, AI context collapse, AI false refusal, AI unsafe allowance, AI rule interaction failure, AI auditability collapse, AI legibility collapse, AI pseudo-safety, AI user burden export, AI feedback suppression, AI trust collapse, hidden debt accumulation.

Restoration priority:

Inventory the rule stack, map policy and guardrail layers, detect rule collisions and context collapse, restore rule and classification traces, measure false refusals and unsafe allowances, restore correction and appeal pathways, simplify or re-sequence constraints, repair affected debt, and validate over time.

LAW-123 — AI U4 Truth Discipline Law

Registry

LAW-125 — AI Memory Scaling Law