Break Dogma

Break Dogma

A dogma is an assumption adopted because someone else does it or someone asserted it — never because it was measured true here, in this regime. Most inherited "you must / you can't" survives on authority, not evidence. This skill is the discipline that separates a real constraint from a cargo-culted one, so we break the ones blocking the faster/atomic path and keep the ones that are actually load-bearing.

Breaking dogma is not contrarianism. Some inherited practice is correct, and reinventing a leaf that isn't the moat is its own dogma (build-don't-reuse). The goal is calibrated: challenge every assumption, but let the honest ones survive the test. A dogma broken without a measured reason is just a different dogma.

This skill is the upstream ideation move. What it surfaces feeds:

• world-first — a broken dogma is often the incumbent's removed-constraint (the wall to invent past).
• scientific-method — an asserted limit is a falsifiable hypothesis; the probe kills or confirms it.
• herlihy — once you break a serialization/lock dogma, atomicize what it forbade.

The four kinds of dogma

Name which one you are looking at — the test differs.

1. Borrowed-runtime dogma — "we need the vLLM/SGLang scheduler / their KV layout / their launcher." Adopted to save effort. Test: is the borrowed component the moat, or a leaf? If it is the moat, owning it is the point — break it. If it is a leaf, reusing it is fine (don't reinvent).
2. Borrowed-algorithm dogma — "everyone uses PagedAttention / continuous batching / symmetric-TP." Test: does the algorithm's payoff regime match ours? PagedAttention pays at concurrency; at B=1 small-model it is overhead. A practice optimal in one regime is dogma in another.
3. Asserted-limit dogma — "this is compute-bound / bandwidth-capped / physics-limited / can't beat X." The most dangerous, because it stops the run. Test: name the single number the limit rests on and MEASURE it. (int4 GEMV "compute-bound" was actually an occupancy misconfig — 38 blocks on 128 SMs.)
4. Our-own legacy dogma — "we already built it this way." Comfort, not correctness. Test: if a subsystem isn't the purest/fastest atomic form, legacy comfort is not a reason to keep it.

How dogma hides — it rarely wears a buzzword

A dogma almost never announces itself as "compute-bound." It rides inside ordinary confident language, in six costumes — this is why the plugin's per-turn detector fires broadly on claim-shape, not on a keyword list:

1. Necessity / impossibility — "needs X", "can't", "only", "always/never".
2. Normative — "should", "just use Y", "the right way", "best practice".
3. Consensus appeal — "obviously", "everyone knows", "the standard way".
4. Bare quantitative/comparative verdict — a number or "faster than Z" with no measurement cited.
5. Borrowed framing — "vLLM does X → we must" (inherited, untested here).
6. Your own prior win reused as an axiom — yesterday's result as today's given.

Any of these is a place an untested premise may ride. False positives are cheap (a one-line nudge); a miss ships a dogma — so when in doubt, flag it.

The break procedure

1. Name the dogma as a falsifiable claim. Not "vLLM does X" — "X is necessary to achieve Y in our regime (B=1, 0.5B, one small GPU)." A dogma you can't state as a testable sentence is a vibe; sharpen it first. To drag out the hidden premise behind a confident claim, pick a lens: 5 Whys (chain past the symptom), inversion (Munger — what would guarantee this is false?), assumption reversal (negate each premise, ask how you'd achieve the reversal), pre-mortem (assume it already failed — why?), or "what would have to be true" (list the conditions the claim requires). Chesterton's Fence: know why a constraint exists before removing it.

2. Mine its origin — why does it exist, and for whom? A constraint is only load-bearing in the regime that created it. Find that regime. Dogma-mining is the highest-value research move — recipes in references/dogma-mining.md:

   • gh issues/PRs/comments/won't-fix/RFCs on the incumbents — this is where they admit the limit and its regime ("by design", "requires symmetric", "GIL", "won't fix", a load-bearing RFC).
   • searxng full surface (search_many, research, fetch_many) — the paper/blog that established the practice and the regime it assumed. Cite.
   • repomix pack_remote_repository + grep — read the actual mechanism to prove the constraint is architectural vs incidental.
   • deepwiki ask_question — targeted "why does X require Y?" on the repo.

3. Test whether it is load-bearing HERE. Two outcomes:

   • Regime-matched → the constraint is real for us too. Keep it (or route the asserted-limit to scientific-method for a measured confirm). Honest.
   • Regime-mismatched or cargo-culted → the payoff assumed a regime we are not in. The dogma is breakable. This is the win. For an asserted-limit dogma, the test is always the cheapest-falsification probe — one bench/grep/profile that could kill the claim. Never argue a limit you can measure.

4. Break it → route to invention. A broken load-bearing constraint is exactly world-first's removed-constraint test entry: build the structure the constraint forbade, atomicize it via herlihy, and prove it past a tuned baseline. Do not stop at "the dogma is false" — the value is what you build in the space it was guarding.

How we broke it — case log (proof the discipline pays)

Every one of these died to its own number — often a number already in the ledger — not to argument. This is what "test the assumption" looks like in practice (source: EXPERIMENTS.md, atomic-inference).

The lesson: a confident claim is worth exactly the number under it. Some broke, one held and got logged — both outcomes are wins; only the un-tested premise is a loss.

The honesty guard (what NOT to break)

• Reuse where it isn't the moat. KISS. A tokenizer, a safetensors loader, a well-tested leaf — reusing it is not dogma, it is judgment. Breaking it to "own everything" is itself the build-don't-reuse dogma.
• A surviving dogma is a result. If the mining + probe show the constraint is real in our regime, say so and keep it. "We tested the assumption and it holds" is a first-class finding — it stops the next person re-litigating it. Log it.
• Don't break on authority either direction. "Everyone does X" is not a reason to keep X; "everyone does X so I'll do the opposite" is not a reason to break it. The only reason is the measured/architectural test.

Cynefin tie (why a dogma stalls a run)

An asserted-limit dogma is usually a Clear or Complicated problem mis-cast as a Complex wall — the mis-classification is what makes it feel unbreakable. "int4 is compute-bound" (Complex, give up) was a Clear occupancy heuristic misconfig. When a limit feels like a wall, re-sense the domain: a wall you can measure from here is not Complex, it is Clear-wearing-a-costume. Route through scientific-method's cheapest-falsification-first.

The one-sentence version

State the assumption as a testable sentence, find the regime that made it real, measure whether that regime is ours — then break the ones that aren't and build in the space they were guarding, keep the ones that are and log that you checked.

Sources

Kuhn, The Structure of Scientific Revolutions (1962) — anomaly as signal, not noise. Aristotle, Physics I — reason from primitives, not analogy. Munger/Jacobi inversion. Feynman, "Cargo Cult Science" (Caltech, 1974) — measurement, not imitation. Chesterton's Fence — know why before removing. 5 Whys (Ohno/Toyota). Assumption reversal; Pre-mortem (Klein, HBR 2007). TRIZ. Case log: EXPERIMENTS.md (atomic-inference), commit 2a7e911.