# Break Dogma > Use when an inherited assumption is steering a decision and nobody has checked whether it still holds HERE — "that's how vLLM/SGLang/everyone does it", "you need X to do Y", "this is compute-bound / physics-capped / can't beat Z", "we always do it this way", "best practice is". Triggers on any borrowed runtime/algorithm/protocol adopted by default, any asserted wall or limit, any "must have" that was never measured in our regime, and any "break all dogma / challenge the assumption / why do we even do this" request. The move: name the dogma, mine where it came from and why (competitor issues/PRs/RFCs + searxng + repomix + deepwiki), test whether the constraint is actually load-bearing in OUR regime or cargo-culted from a different one, and if it is not necessary, break it and route to invention. Reach for it by default before adopting any borrowed component or accepting any asserted limit; skip only when the practice is a genuine leaf you are reusing on purpose (KISS). - Skill: `88plug/break-dogma` (Agent Skill, multi-file: 2 files) - Install (CLI): `npx skillmds@latest add 88plug/break-dogma` - Raw SKILL.md: https://api.skillmd.com/api/skills/88plug/break-dogma/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Web & Frontend - Author: 88plug (https://skillmd.com/u/88plug) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/88plug/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). | Assumption (dogma) | Test | Verdict | Evidence | |---|---|---|---| | "int4 GEMV is compute-bound" | re-audit occupancy | **BROKE** | 46.8 GB/s = ~20× below peak → occupancy misconfig (38 blocks/128 SMs), not a compute wall → gate 46.8→**159 GB/s** (commit `2a7e911`) | | "single-stream is launch-bound → build a megakernel" | cudaEvent launch-gap probe | **FALSIFIED** (0.9) | gap only ~14% → DO-NOT-build; one probe beat three council priors | | "more concurrency = faster per-token" | our own arithmetic | **FALSIFIED** | 418÷32 = 13.1 tok/s/seq vs 149.6 single → ITL *rose* ~11× | | "int4 halves bytes → faster" | event-timed bench | **BROKE** | 106.9 vs int8 159.2 tok/s — 33% *slower* | | "we're 2.4× faster than baseline" | fair aggregate-vs-aggregate rematch | **RETRACTED** | was aggregate-vs-single-stream; real = baseline 1.84× faster | | "spec-decode helps single-stream on 0.5B" | graph-verify ≈ eager (1.01×) | **FALSIFIED** | verify is compute-bound → DO-NOT-RE-ATTACK | 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`.