Exploratory work discovers its structure — you cannot file a shape you don’t yet know. So keep the substrate write-optimized (a web: forward links, flat-ish folders, cheap to add in unknown directions) and derive the read-optimized hierarchy — indexes, two-way ledgers, the orphan audit — with tooling, after the shape emerges. Never tax the exploration to pay for the tidiness. A sprawling vault that’s hard to manage because it has covered so much is succeeding: the difficulty is the cost of compounding generativity, paid down by deriving, not by suppressing.
Links: The Anchor Method (grounding is a maturity axis — projects start “ohh neat” because you aren’t grounded in what the thing is yet), Specimen & Thesis — The Two-Altitude Ledger (the ledger this principle says to generate, not hand-maintain), NA1 — A Game-Design Crucible (the worked “let it sprawl, then index” instance)
This is the data-structures tradeoff: index vs log, B-tree vs LSM-tree, normalized vs denormalized. Hierarchy is a read-optimized index — cheap retrieval, small working set, expensive to modify (you pay the reorg). Web is a write-optimized log — append-cheap, direct-access if you hold the pointer, but unindexed it forces a full scan. The instinct to build hierarchy is the instinct to make retrieval cheap; the cost is paid at every edit.
Nobody actually chooses. Google didn’t make authors file the web into a tree — it let the web stay a write-optimized mess and derived a read-optimized index over it (inverted index + PageRank, which is literally deriving a hierarchy from the link graph). Databases keep the table as truth and let the engine maintain the index. Keep the web as source of truth AND have the hierarchy — but derive it, don’t author it. The mistake is hand-maintaining the index: every reciprocal link, ledger entry, and INDEX/tag update is a deterministic function of forward-links + frontmatter. That’s index maintenance — the engine’s job, not the author’s.
You cannot author a hierarchy for a shape you haven’t discovered. NA1 began ambitious-but-tractable and radiated into agent design, LLM grounding, and bytecode-transpilation — none planned. pygone is the miniature: “ohh neat” → grows → covers ground nobody scoped. The structure is found by walking (epic decomposition is discovered). A tree demands the branches up front; exploration can’t pay that, so its only fit is the substrate cheap to extend in unknown directions.
The management pain isn’t depth, it’s lateral radiation: one project spawns theses in other domains. NA1’s randomness-termination is game design; its transpilation-as-grounding is LLM architecture; its multi-pass-RE is methodology. A tree can’t hold this — each thesis lives in exactly one branch, so the cross-domain edges (the valuable part) get severed; that severing is why a sprawling project feels untrackable. A web holds it natively — the thesis links back to every source that fed it. The lived difficulty is proof a tree would be worse, not the cure. The crucible pattern is the answer: let the project sprawl, then build a hub that radiates outward to wherever the theses landed — you index a crucible after it’s done being one.
The friction is fast-exploration vs slow-manual-organization. Resolve it by making organization deferred and derived — never a gate on the next exploration.
A vault hard to manage because it covered so much is doing its job. The compounding is the point — accumulated frameworks make each new analysis sharper (the Colorado-v-Trump argument that satisfied all parties and none, sharper than the court’s, is the [verification-layer thesis] in action). That compounding is inseparable from the sprawl. So the move is never “cover less / tidy more”; it’s explore freely, derive the index, spend judgment on promotion.
tools/vault-graph.py — the audit half (broken-link + ledger-reciprocity + orphan gate). Its first run returned ledger reciprocity CLEAN, validating this session’s two-way wiring by machine, and surfaced 178 pre-existing broken links — mostly the game-annotation/pygone repo-extraction casualties in tag files + INDEX (this principle’s seam-breaker, quantified). The generate half (auto-emit backlinks + regenerate indexes) is the next increment.