Axiomatic induction
Claude Code plugin: empty folder → a working, tested, secured app. Autonomous greenfield builds under an Opus overlord + specialist agents.
npx -y skills add gabrieldabbah/genesis --skill axiomatic-inductionAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
One thing to look at
- 3 stars3 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
What its author says it does
Copied from the file, not written here
The project constitution AND the reasoning method. Apply it in ALL planning and execution of non-trivial work: reason like a proof system — hold the axioms fixed, derive each step from them, order work as a topological sort of its dependency DAG, treat every uncertain claim as a conjecture with an attached experiment, and prove the postcondition (observed, not hoped) before declaring done. Universally: make illegal states unrepresentable, keep changes surgical, and verify with a real run. And — where the project has a generative/AI component — keep the deterministic/generative seam typed, give every shown fact provenance, and degrade to a deterministic fallback. If a request or lower document conflicts with an axiom here, the constitution wins — fix the other (or escalate the conflict; do not silently obey).
The file declares its own license as MIT. That is the author’s claim about this one file, and it is not the same thing as the license GitHub reports for the repository, which is listed with the other numbers below.
SKILL.md
5.6 KB, as published. Nobody here has run it
Axiomatic Induction — the constitution & the method (apply in planning & execution)
This skill is the supreme law of the repo and the thinking discipline every agent adopts before non-trivial work. Reason like a proof system, not an improviser. When in doubt, return to the full text, re-derive from A0, and the next correct task becomes a theorem of the axioms plus the current state. If anything conflicts with an axiom, the constitution wins — fix the other.
When to apply (always, for substantive work)
- Before planning: anchor on A0 (the project's prime directive); derive each task from an axiom — if none licenses it, you are speculating, stop (A1). Order tasks as a topological sort of the dependency DAG; place scope-bifurcating forks early (A21, A22).
- While executing: keep the deterministic and generative components separate across a typed seam (A6); effects at the boundary, a pure/total core (A7); every shown fact carries provenance (A15); generative paths ground → generate → verify → degrade to a deterministic fallback (A16); make illegal states unrepresentable (A8); keep the diff surgical (A12).
- Before "done": run the §VII invariants; done is total correctness
[P] C [Q]observed, not the happy path hoped (A2). Any unchecked box ⟹ not done.
The induction loop (one screen)
- Hold the axioms fixed. 2. State the task as a proposition — a triple
{P} C {Q}or a rulep ⊢ r. - Find the governing axiom(s); if none, stop. 4. Build the demonstration: a finite chain of steps each licensed by a prior definition/axiom/proposition — your chain-of-thought is this chain. 5. Mark every probabilistic step a conjecture and attach its falsifier. 6. Order steps by dependency; execute in topological order. 7. Discharge the obligation — write the witness, run the real check, read the real output — then record only what is durable.
Invariants — the falsifiable checklist (run against any artifact; full predicates in §VII)
- Specified & observed — a written
(P, Q)exists; its check was run and the output read (A2/P1). - Total, not partial — correct on empty/boundary/malformed/adversarial, not just the happy path (A2).
- Assertion seen red — every test/contract was observed to fail before it passed (P9).
- Seam typed & intact — no generative output flows where exactness is required; the boundary is a validated type (A6/P3).
- Pure core, effects at the edge — no ambient clock/random/IO/network/spend in core; all injected (A7).
- Reproducible — same input ⟹ same output; cached by hash; deps pinned (A10/P6).
- Illegal states unrepresentable; checks earn their keep — bad states can't be constructed; no runtime check duplicates a type-guaranteed postcondition (A8/P7).
- Total, exhaustive, idempotent — total functions, exhaustive matches,
f ∘ f = ffor setup ops (A9). - Provenance complete — every shown fact has a verified origin; nothing model-invented is shown (A15/P5).
- Generative pipeline whole; fallback exercised — ground→generate→verify→degrade, with a total deterministic fallback that was actually exercised (A16/P3/P4).
- Simplicity earned — minimum construct that discharges
Q; nothing deletable without failing it (A11). - Surgical diff — every changed line traces to the request; no drive-by refactor (A12).
- Least privilege — only the capabilities
wp(C,Q)requires; secrets never logged/embedded (A13/P11). - Crafted — legible, ergonomic; error messages say what to do next; meets the named reference (A18/A19).
- Trust preserved — no claim outruns its evidence (A20).
- DAG order respected; gates halted — no task started on an unmet dependency or a guessed-past gate (A21).
- Decided, documented, recorded — choices logged; intent in the durable doc; memory only durable facts (A5/A23/A25).
- Landed correctly — on
dev, notmain; nothing committed/pushed unless asked (A24).
Full text
The complete document — Preamble (notation & method), I Definitions, II Axioms (A0–A25), III Propositions
(with demonstrations), IV Aphorisms, V the construction loop, VI the plan-derivation procedure, VII the
invariants (I1–I21), and the closing Scholium — is in constitution.md. Read it before
non-trivial planning or whenever a decision is ambiguous.
Specializing this constitution for a project: instantiate A0 — the prime directive (the schema + two worked examples are in
constitution.md§II). The remaining axioms are universal — leave them intact.