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 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).
license
MIT
allowed-tools
Read
metadata
{"internal":true}
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 rule p ⊢ 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 = f for 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, not main; 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.
