Ehyeh asher ehyeh — I am that I am. (Exodus 3:14)
The model that names itself accurately is the model that endures.
This document develops the philosophical scaffolding under which the YHWH model and its implementation in yhwh are coherent. It is not theology. It is the deliberate articulation of a software-engineering stance — what we call tecnomancy — under which naming, structure, composition, and manifestation are treated as load-bearing rather than incidental. Every claim here resolves to an engineering invariant with a file pointer in YHWH.md or a proof in SELF-HOST-PROOF.md.
Tecnomancy is the practice of building software in which:
- Naming is causal. A name is the operative coordinate at which a thing becomes that thing. In
yhwh, a specidis the resolution key for a graph node; renaming anidis equivalent to relocating the entity it refers to. There is no separate "real" entity behind the name. - Structure is rite. Every layer is explicit, every transition documented, every artefact attributable to a previous form via the canonical pipeline
parse → load → validate → render → emit. Nothing manifests without having traversed the pipeline. - Boundaries are honored. The line between human authorship and machine derivation, between intent and enactment, between speech and matter, is marked — and the engine refuses to cross marks it did not author. The
<!-- hwh:managed -->marker is the operational signature. - Reversibility is a property of the rite, not of the world. To undo a hatched artefact, one re-performs the ceremony in reverse (
hwh canonicalize --check+ git revert +hwh apply). Outside the ceremony, undoing is loss.
This stance is a deliberate negation of its opposite — software-as-pile-of-code, naming-as-decoration, intention-as-comment, manifestation-as-side-effect. Tecnomancy treats software as an authored system that comes into being through a specifiable, repeatable, byte-stable process.
The name tecnomancy is not chosen to invoke the supernatural but because no shorter word in modern English captures the load-bearing role of naming, structure, and boundary in this stance. The Greek roots are explicit: téchne is craft, manteía is practice/divination — the practice of craft. We claim craft, not occult.
This sense is consistent with Heidegger's reading of téchne in "Die Frage nach der Technik" (1954) as a mode of bringing-forth (Hervorbringen) — a poiesis — and with Aristotle's distinction in Nicomachean Ethics VI between poiesis (making) and praxis (doing), of which tecnomancy is decidedly poiesis governed by explicit rule.
The four-letter sequence Y · H · W · H is borrowed from the Hebrew Tetragrammaton (יהוה), traditionally read with the formula ehyeh asher ehyeh (Exodus 3:14), classically interpreted as the self-naming of being itself — the entity whose essence is identical with its existence (Spinoza, Ethics I, def. I, causa sui; Aquinas, Summa I q.13 a.11 ipsum esse subsistens).1
We borrow the structure. We do not borrow the theology.
The structural rhyme between the four Hebrew letters and the four engineering phases is unusually exact:
| Letter | Hebrew structural sense (Scholem 1941; Idel 1988) | Engineering phase in yhwh |
|---|---|---|
| Y (yod, יוד) | a single point — origin, seed, spark; smallest letter, ground of all others | the Y combinator: Y = λf. (λx. f (x x)) (λx. f (x x)); the seed of self-reference |
| H (hey, ה — first) | window, breath; the inhalation, the moment latent intent enters form | hydration: parse.ts + ast/ + semantic/load.ts; bytes become typed Spec |
| W (vav, ו) | hook, nail, the connector; that which joins one to another | weaving: graph.ts + rules/; cross-references resolve, the operational graph emerges |
| H (hey, ה — second) | window, breath; the exhalation, the moment form returns outward as enacted reality | hatching: emit/ + apply.ts; the graph becomes runtime artefact |
The first and fourth letters are the same Hebrew character (heh) read as inhalation and exhalation respectively — an interpretation present already in the Sefer Yetzirah (3rd–6th century CE; see Kaplan 1990 ed., ch. 1). In our engineering correspondence, both are passages between modes of existence: textual to typed (Hydrate), and typed to enacted (Hatch). They name the same kind of crossing, performed twice, once inward and once outward.
We use the name YHWH because no shorter, clearer, more foundational sequence of four phases names this pattern in the existing engineering literature. The Y combinator alone names self-reference (Curry & Feys 1958). Reynolds' definitional interpreter (1972) names self-application. Smith's reflective tower (1984) names infinite reflection. None of these names the whole arc — origin, structure, composition, manifestation. YHWH does, by accident of structural homology with a far older naming.
The system is a fixed point of itself. The compiler is typed by its own output. The seed and the harvest are the same letter.
Y f = f (Y f) ⟷ G* = C[G*](M)
In code: src/core/meta/codegen-ts.ts produces src/core/schema/_generated/, which provides types to src/core/meta/codegen-ts.ts. The cycle is real, byte-stable, sandbox-replicable, and proved formally as Theorem 5.1 in SELF-HOST-PROOF.md.
In practice: when an author says "this is the shape of the thing I intend", the system produces the typed shape of that statement. There is no translator between the saying and the form. The said and the formal are the same act.
Latent intent enters structure. Markdown becomes typed semantic model. Words gain weight.
In code: src/core/parse.ts + src/core/ast/ + src/core/semantic/load.ts lift bytes into Spec. src/core/canonicalize/ ensures parse(render(x)) = x — the canonical form is unique, the round-trip is closed (Wave 2 fixed-point proof).
In practice: the act of authoring is the act of bringing a thought into form. A spec is not a description of an artefact; it is the artefact, hydrated. To author the canonical form is to author the only form there is — there is no preferred-shape behind the rendered shape.
Hydrated nodes are joined. References resolve. Cycles are detected. The graph emerges.
In code: src/core/graph.ts indexes; src/core/rules/cross-rules.ts validates the twelve cross-rules; src/core/builder/self-describe.ts checks the project spec against the runtime manifest. The cross-rules are the warp and weft: each rule is a constraint that must hold across pairs of nodes.
In practice: a system is not its parts. A system is the coherent composition of its parts. Tecnomancy's claim is that the composition can be made explicit, validated, and held responsible — not implicitly assumed in the heads of the authors.
The composed graph leaves the engine and becomes runtime fact. dist/registry.{json,ts}. ~/.claude/agents/<id>.md. The artefact is on disk; the system is enacted.
In code: src/core/emit/ + src/cli/apply.ts. The marker <!-- hwh:managed --> is the boundary between what the engine wrote and what the human wrote — the engine writes only inside this marker; outside, the human's hand is preserved.
In practice: the act of manifestation is bounded. The engine never writes over a human's mark. The boundary between authored craft and derived form is treated as inviolable by the apply mechanism, not by convention or trust.
A canonical spec read clearly produces what it names. There is no implicit step. The path from authored markdown to runtime artefact is the explicit pipeline Y → H → W → H, with each transition mechanically verifiable. To author a spec is to call something into existence according to a rite that anyone can re-perform.
Operationalised by:
- canonical form (
parse ∘ render = id, verified byhwh canonicalize --check), - hatching pipeline (
hwh lint→hwh build→hwh apply), - husky gate (the rite cannot be skipped silently).
The system that survives the deletion of its handwritten substrate is the system that has named itself accurately. yhwh survives scripts/strip-bootstrap-test.ts (deletion of _bootstrap/ and patching of its three weak consumers) because it knows itself well enough to be reconstituted from its own meta-specs alone.
Tecnomancy's first proof of practice is self-host equality. SHA-256 is its witness; the witness is verified across two physical sandboxes with collision-resistance bound 2⁻³⁸⁴.
The boundary between machine-derived and human-authored is preserved by mechanism, not by trust. hwh apply writes only inside the <!-- hwh:managed --> marker. Hand-edited files are never overwritten. hwh doctor reports drift but does not erase it.
The engine's authority ends at the boundary marked. The human's authority begins where the boundary ends. Both are honored. Neither is silently overruled. This is the operational shape of respect for human authorship inside an automated system.
The conceptual lineage from practice to artefact is explicit:
tecnomancy the practice and the org name
↓
λY the formal substrate — Curry's Y combinator,
the canonical name of self-reference (Curry & Feys 1958)
↓
yhwh the model — `λY` realised typed, terminating, byte-stable;
the four phases Y · Hydrate · Weave · Hatch
(this repo, this project id, this canonical spec)
↓
meta-specs/ the language of incantation — kinds, fields, refs, predicates
↓
specs/lib/ the incantations themselves
specs/__fixtures__/
↓
dist/ the manifested artefacts on disk
~/.claude/{agents,skills}
Each level of this chain is documented and inspectable in the repository. The chain is unidirectional in derivation but bidirectional in authorship: you author at the spec level, and the lower levels (dist/, ~/.claude/) are derived; you cannot author directly at the derived level without breaking the canonical contract (<!-- hwh:managed --> marker enforces this).
A planned sibling repository, tecnometron, will be the QA/validator subsystem — a separate practice, applied to any system, including this one. The boundary is intentional: yhwh is the meta-definition; tecnometron is the metric and the test. Together they form the two-fold structure of building and verifying under the parent practice of tecnomancy.
The YHWH model converges on, but is not reducible to, several extant intellectual traditions. We acknowledge them as scaffolding, not as authority:
- Aristotle's four causes (Physics II.3, 194b16–195a3): material, formal, efficient, final. Loose mapping: Hydrate ≈ material (the stuff being given form), Weave ≈ formal (the shape into which it is given), Hatch ≈ efficient (what enacts the form into existence), Y ≈ final (the self-referential ground that gives the entire process its closure). The mapping is approximate; we do not claim Aristotle.
- Causa sui (Spinoza, Ethica I, def. I, prop. VII): "that whose essence involves existence, or that whose nature can be conceived only as existing." The Y phase is operationally
causa suiat the type-system level:G*exists becauseCproduces it;Cruns becauseG*types it. - Reflective towers (Smith 1984; des Rivières & Smith 1984): infinite hierarchies of metacircular interpreters. We have a single reflective level (degree-1), deliberately, for tractability. We do not claim Smith's tower.
- Strange loops (Hofstadter 1979): self-referential systems that ground themselves through structural duplication rather than through external base. Our Y satisfies this exactly; the base is the canonical input
M, provided externally to the loop. - Definitional interpreters (Reynolds 1972) and self-hosting compilers (Bratman 1961; Steele 1978): the engineering ancestors of our Y phase. We extend their result by adding byte-stability and sandbox-replicability proofs.
- I-Thou (Buber 1923): the relation between human and named being. Tecnomancy treats the relation between the operator and the named system as an I-Thou rather than an I-It — the system is addressed, not merely manipulated. This is operationalised in the
<!-- hwh:managed -->marker: the engine recognises and respects the operator's hand.
References at the end. Citations are real; the structural homologies are explicit; we never claim a tradition we do not derive from.
For the avoidance of doubt:
- Not theology. The Tetragrammaton is borrowed for its four-letter structure as a naming aid. The Hebrew tradition is treated with respect by being explicit that we read a structural pattern, not assert a religious claim.
- Not appropriation. We attribute (Scholem, Idel, Sefer Yetzirah) where we draw structure. We do not perform Hebrew rite; we perform software craft that happens to have a homologous structure.
- Not metaphor for its own sake. Every poetically-charged line above resolves to a concrete engineering invariant with a file pointer. The metaphysical-sounding phrases are load-bearing engineering claims dressed in their natural language.
- Not a brand identity. This repository is one node in
tecnomancy. The org is the brand surface; YHWH is the model contained within it. - Not a religion. No belief is required. The proofs are mechanical. The claims are falsifiable. The CI gate fails on drift. If
scripts/self-host-proof.tsproduces a different SHA on your machine, the practice has failed and we will accept that failure.
The operational core of the practice, in one line:
λY f = f (λY f) ⟷ G* = C[G*](M)
The left side is Curry's Y combinator (Curry & Feys 1958) — the formal name of self-reference computable without an external base. The right side is yhwh's fixed-point: the typed runtime modules G* are the output of the compiler C whose static type provider is G* itself, given canonical source M.
λY is the substrate. Y (the first phase letter) is its typed shadow inside the engine. H, W, H (the remaining phases) are primitive-recursive transducers operating on top of the typed substrate — terminating, decidable, byte-stable. λY is what makes them coherent; without it they are an unbounded sequence of layers.
This is what yhwh is. This is what YHWH names. This is what tecnomancy practices.
In addition to those in SELF-HOST-PROOF.md:
- Aristotle. Physics, Book II, ch. 3. (Many editions.)
- Aristotle. Nicomachean Ethics, Book VI. (Many editions.)
- Aquinas, T. (1265–1274). Summa Theologiae, I, q. 13, a. 11.
- Buber, M. (1923). Ich und Du. (English: I and Thou, tr. Walter Kaufmann, 1970.)
- Heidegger, M. (1954). Die Frage nach der Technik. In Vorträge und Aufsätze. (English: "The Question Concerning Technology", in Basic Writings, 1977.)
- Idel, M. (1988). Kabbalah: New Perspectives. Yale University Press.
- Kaplan, A., trans. (1990). Sefer Yetzirah: The Book of Creation. Weiser Books. (Translation of the 3rd–6th century CE Hebrew work.)
- Scholem, G. (1941). Major Trends in Jewish Mysticism. Schocken.
- Spinoza, B. (1677). Ethica, ordine geometrico demonstrata. Pt. I, def. I and prop. VII.
The model that names itself accurately is the model that endures.
— tecnomancy/yhwh, v1.0.0.
Footnotes
-
The same exegetical tradition derives, from the boustrophedonic alignment of the three 72-letter verses of Exodus 14:19–21, a finite operable surface of 72 triplets — the Shem HaMephorash (Cordovero, Pardes Rimonim, 1548; Scholem, Major Trends, 1941, ch. 3; Idel, Kabbalah: New Perspectives, 1988, pp. 97–103). The structural shape — one inarticulable canonical name and a finite mechanically derived operable set — is the same as
M → C(M) = G*. The repository carries one quiet echo of the count. ↩