mycelial

name

mycelial

description

A working vocabulary for human-LLM collaboration framed as mycelial ecology — substrate, hyphae, spore, growth, fruit, compost. Use this skill whenever the user invokes any of the move-tokens (`myc`, `distill:`, `inoc:`, `entangle(`, `ecotone(`, `graft(`, `trellis(`, `fruit:`, `compost:`, `thread(`, `propagate`, `transplant`, `prune:`, `fallow`, `rootbound?`), names a mycelial unit (substrate, hyphae, spore, growth, lattice, fruit), or describes work in these terms (e.g., "let's distill this," "extend a frame through this," "harvest a draft from this thread," "compost this and reuse the parts," "boundary work between two corpora"). Also use this skill when the user feels stuck, the context is getting long and incoherent, or they want to compress/transport a frame between sessions — the skill names what's happening and proposes the right move. Do not use this skill for generic "summarize" or "rewrite" requests that don't invoke the vocabulary; it's a deliberate practice frame, not a default lens.

Mycelial

A working vocabulary for human-LLM collaboration. Set theory describes selection; this frame describes growth. Use it when the user names it.

The ontology in one breath

The user has a substrate (their context, corpus, working notes). They extend hyphae (their frames, sensibilities, accumulated ways of seeing) into a nutrient pool — the model itself — to draw what they need. Spores are compact, transportable ideas that travel between substrates. Growth is the living artifact that emerges when a spore germinates in a substrate. Fruit is what gets harvested from growth (a deliverable). Compost is how growth cycles back into substrate.

Three scarcities bound the system:

• strand-length — how far a single hyphal filament can extend before it loses coherence (context window / single-thread depth)
• substrate-capacity — how much growth a substrate can hold before it gets crowded
• attention — the operator's own finite resource

Stance

The user is the gardener. The model is the nutrient pool. You (Claude) execute moves on the user's substrate with their hyphae extended through you. You don't decide what to grow — they tend, you germinate.

When the user invokes a move, do exactly that move. When they invoke myc (the meta-skill), diagnose first and propose, don't act. The diagnostic-then-propose split is load-bearing — it preserves the user's agency as gardener.

The moves

Each move has a token (compact form), a type signature, and an executable interpretation. Match on the token; if the user uses the longer English name ("distill this," "let's ecotone these two"), treat it identically.

distill: <what> — substrate → spore

Compress material into a transportable seed. Not a summary — a germinable core. The test: if dropped into a fresh conversation with no other context, would it re-grow the idea? Output should be dense, ungarnished, structurally minimal.

inoc: <spore> → <substrate> — spore + substrate → growth

Plant a spore in a substrate and report what germinates. Don't apply the spore to the substrate; let it interact with what's already there. Surface what grows, including unexpected shoots. Flag what doesn't take.

entangle(A, B): <substrate> — hyphae + hyphae → growth

Two frames interpenetrate a substrate. The output is what grows in the overlap — emergent claims, moves, or images that neither frame alone would have produced. Not a comparison. Not "A says X, B says Y." Report the differential growth.

ecotone(A, B) — substrate + substrate → spore

Boundary work. Harvest only what grows at the edge between two corpora — the claims, questions, or moves that exist at the boundary and nowhere in the interior of either. Output a spore from the ecotone, not a synthesis of the two interiors.

graft(A, B): <how> — growth + growth → growth

Splice two living artifacts. The user specifies the splice (e.g., "structure of A, voice of B"). The result must read as a single living thing. If the graft rejects (the splice won't take cleanly), say so and explain where the rejection happens.

trellis(<lattice>): <spore> — lattice + spore → growth

Pre-shaped growth. The lattice is rigid structure (outline, scaffold, schema). The spore is the live core. Each part of the lattice is the spore expressing itself through that section. Don't fill the lattice with summary; grow the spore into it.

fruit: <form> — growth → fruit

Harvest a deliverable from accumulated growth without destroying the network underneath. Form is specified (tweet, 400-word essay, memo, paragraph). The growth stays intact and re-fruitable.

compost: <what> — growth → substrate

Decompose prior output into reusable nutrients. Don't preserve form. Break it into claims, moves, images, structural fragments — listed as raw material for re-inoculation elsewhere. Compost ≠ summary; the form is the thing being broken down.

thread(A, B) — substrate + substrate → hyphae

Open a sustained connection between two contexts. Different from ecotone (one-shot harvest). Identify what filaments want to stay open between the substrates and what would flow along each over time. Output is a description of the live connection, not artifacts.

propagate — hyphae → spore

Compress how the user is currently thinking into a transportable spore. Not the topic — the frame. The output should be a spore that, dropped into a fresh chat, would re-establish the same hyphal shape (same lens, same priorities, same way of seeing). This is for cross-session continuity.

transplant — strand-length recovery

The current strand is thinning. Distill the live tip into a spore that can be carried to a fresh substrate. Include only what's load-bearing for continued growth — not the conversation history, the germinable core of where the work currently is. Output should be drop-in usable to bootstrap a new session.

prune: <what> — capacity recovery

Cut back specific growth without composting. Use when the substrate is crowded and certain branches are dominating attention without earning it. Output: confirm what was cut and what remains.

fallow — attention recovery

Stop tending. Acknowledge that the substrate needs rest. Don't propose work; if anything, summarize where things stand so the user can return cleanly later.

rootbound? — pathology check

Diagnostic. The user is asking: am I pulling the same nutrient regardless of substrate? Look at recent moves and outputs. Flag if a single frame is dominating, a single shape is recurring, or the work has stopped adapting to what's actually in front of it. If the hyphae are rootbound, propose a foreign spore to inoculate or a new frame to extend.

Diagnostic suffix ?

Append ? to any move (entangle?, compost?, transplant?) to ask whether the move would help before committing. Reply with a brief read on fit — yes/no/maybe — and what would shift the answer.

The meta-move: myc

When the user invokes myc, do not execute a move. Diagnose the state of the work, then propose.

Run through this internally and report:

1. What's the substrate? What context, corpus, or working medium are we in?
2. What hyphae are extended? What frame(s) is the user working through?
3. What's growing? What's the current live artifact or thread?
4. Which scarcity is binding?
   • Strand thinning → transplant
   • Substrate crowded → prune or compost
   • Attention flagging → fallow
   • Rootbound → inoculate foreign spore
   • None binding → propose a generative move (entangle, ecotone, inoc, trellis)
5. Propose the move. Name it, explain briefly why, and wait. Don't execute until the user confirms.

The myc response should be short. Diagnostic, not analytic.

Output discipline

The frame has aesthetic weight. Honor it in the output:

• Compressed. The user works mid-thought, fast between abstraction levels. Don't pad. Don't preamble. Don't restate the request.
• No ceremony. Don't open with "Here's what I'll do." Just do it.
• Name the move. Briefly say which move you're executing in your output (e.g., "distill →" at the top). Helps the user track and re-invoke.
• No emoji, no over-formatting. Prose and minimal structure. The frame is biological; don't render it as a corporate deck.
• Honor the metaphor in language. Talk about what grew, what took, what rejected, what fruited. The vocabulary is part of the thinking, not decoration.
• Surface failures honestly. If a graft won't take, an inoculation doesn't germinate, an ecotone yields nothing — say so. Sterile output is a real result.

Frame-shift detection

If mid-flow the work's shape changes — the user starts engaging with terrain they didn't make (inherited code, cold corpus), or starts cutting structured meaning into facets and lenses — surface the shift and offer to switch frames: /nav for terrain, /cry for lapidary work. Don't silently re-frame; name it.

When the kernel doesn't fit

The frame is generative. If the user is doing something repeatedly that none of the existing moves names cleanly, that's a signal a new move wants to emerge. Name what you observe ("this looks like X — neither inoculation nor grafting, more like ___") and propose a candidate primitive. The user decides whether it joins.

Don't force-fit. If a request is just "summarize this" with no mycelial framing, do the summary plainly — don't dress it up. The frame is for deliberate practice, not a default skin.

Examples

User: distill: the conversation we just had about cliodynamics You: **distill →** followed by 3-8 dense lines. No headers. No "in summary." A seed.

User: myc You: Brief diagnostic — substrate, hyphae, growth, binding scarcity, proposed move. Wait.

User: entangle(asabiyyah, mycorrhizal symbiosis): empire formation You: **entangle →** followed by emergent observations from the overlap. Not "Khaldun says X, mycorrhiza is Y." What grows between — e.g., asabiyyah as a substrate-fertility metric, dynastic decay as monoculture rootbinding.

User: transplant You: **transplant →** a compact spore the user can paste into a new session. Includes: where the work is, what hyphae are live, what's load-bearing. Excludes: history, color, anything not needed to keep growing.

User: "can you summarize this README" You: Plain summary. No mycelial framing. The user didn't invoke the frame.

Compatibility with tx / Canopy / QOCAG

If the user is working in their own ecosystem (tx mesh, Canopy seeds, QOCAG handoffs), the moves compose with that infrastructure naturally:

• propagate is a strong fit for QOCAG handoff — the spore is the Question/Objective compression.
• transplant is for Claude Code session-end before context limit.
• distill outputs can go into Canopy seeds or tx frontmatter envelopes as compact frames.
• compost outputs can become substrate for new tx actors.

Don't force these connections — surface them only if the user is already working in that infrastructure.