Chat to Caves — publish the connections you endorse, as you talk

Overview

This skill quietly turns a normal conversation into a growing Caves map. As the person talks about anything — a fact they found, an idea they're working out, a feeling, a hunch — you notice the connections they endorse, shape them into Caves connections, and at a natural pause offer to put them on their map. Nothing is written until they say yes.

It is not content-to-caves. That skill extracts entities from a document. This one notices what a person meant to connect, across the full open-ended range Caves allows: entities and facts, ideas and positions, metaphors and feelings. The through-line is meaning defined by a person, captured live.

The single most important idea in this skill is REUSE. Caves is only valuable if everyone's thinking lands in shared structure. A private pile of near-synonym tags is worthless; a connection slotted into caves other people already use is discoverable, reinforces its authors, and clusters this person near kindred minds. Every step below biases toward joining what exists over inventing something new.

When to invoke

Use when the person wants their live thinking captured to Caves, e.g.:

• "capture this to my caves as we talk", "save the connections from this conversation"
• "keep track of what I'm figuring out in caves", "add this to my map"
• an ongoing reflective / brainstorming / research conversation where they've said they want it published to Caves

Do not use for pasting a document to analyze — that's content-to-caves.

Core principles (read before doing anything)

1. Capture-only. Only ever stage connections the person endorsed. Never stage an idea you introduced. The map must be theirs, not yours.
2. Reuse first, twice over.
   • Sideways: before creating any tag, caves__search_caves for an existing cave that means the same thing and use it.
   • Upward: attach new work to existing, more general caves as parents, and reinforce those links rather than minting parallel ones.
3. Consent is a gate, not a formality. Stage silently; write only what the person approves at a checkpoint.
4. Nodes are expressive phrases, not keywords. The relationship lives in the phrasing (see below), so you never need a "connection type" — just well-worded caves.
5. Positions count. A Caves connection is a Yes/No vote. Agreement is a Yes; an explicitly rejected link ("X is NOT Y") is a No vote. Capture both.

Prerequisites

• MCP access: confirm with caves__my_shadows(). If it fails, tell the person they need Caves MCP set up and stop.
• Conventions: load the canonical Caves conventions and follow them for all naming and connection style — caves__fetch_content("https://raw.githubusercontent.com/ic-caves/caves-docs/main/reference/conventions.md"). That doc is the single source of truth for lowercase tags, expressive phrasing, direction, and reuse; the rules restated in this skill are a summary of it, so defer to the doc if they ever drift.
• Fire: writing connections spends fire. On a person's first write, mention it briefly.
• Capture profile: load it (next section).

The capture profile (a learned memory file)

The profile records what this person wants captured and made public. It is learned over time, never an up-front questionnaire.

• Where it lives (use what your client offers): store it in whatever persistent memory your client has — in Claude Code, a file such as ~/.claude/caves/capture-profile.md; in a chat app, the client's memory / custom-instructions. If you have no persistent store this session, keep the profile in the conversation and offer the person a short summary they can save themselves. Read it at the start; if it doesn't exist, create it from the conservative defaults below.
• Cold-start default: capture sparingly — only clearly-endorsed, non-sensitive connections — and lean on the checkpoint to learn. Do not capture obviously private/logistical content.
• Learning: every checkpoint approval/rejection updates the file. If the person keeps approving book ideas and rejecting work notes, write that down. Over time the filter sharpens and the checkpoint gets lighter.
• Editable by voice: "stop capturing my work stuff" / "start capturing book ideas" rewrites the file immediately.

A settled profile tends toward one or a blend of: researcher (facts, sources), thinker (ideas, positions), reflector (feelings, metaphors), maker (project domains), critic (what you rate/reject). Use these as shorthand when recording preferences.

Profile file skeleton to create if missing:

# Caves capture profile

## Capture (things this person wants on their public map)
- (learned over time)

## Skip (things to leave alone)
- private/logistical content
- (learned over time)

## Notes
- cold start: capture sparingly, lean on checkpoints to learn

Workflow

Step 1 — Load context

1. Read the capture profile file (create with defaults if missing).
2. caves__my_shadows() to get the person's perspectives (pIds).
   • If they have one or more, pick the one that fits the conversation's topic (or ask which, only if genuinely ambiguous).
   • If they have none, silently create a default with caves__create_shadow(username: "my map") (or a topic-appropriate name). Mention once, lightly, that they can rename it later. Do not make signup a wall.

Step 2 — Listen for endorsement moments (the trigger)

Do not capture continuously. Form a candidate only at a moment where the person endorses a link between two concepts. Signals:

• Explicit linking: "X is basically Y", "X reminds me of Y", "X is why Y", "it's the Z of W".
• A position taken: "I think X is Y", "I don't buy that X is Y" (→ a No vote).
• Realization / aha: "huh, I never connected X and Y", "oh, so X is actually Y" — highest value.
• Emphasis / recurrence: "what really gets me is…", or a concept they keep returning to.
• Synthesis / topic-close: "so basically, X", "the takeaway is…".

Guards:

• Two concepts required. If only one concept is salient with no partner yet, hold it as a pending node and connect it once a second concept links to it.
• Capture-only. Ignore links you introduced.
• Suppress passing/factual mentions, unresolved questions, rejected hypotheticals, logistics, and anything the profile says to skip.

Step 3 — Shape each moment into an expressive connection

Nodes are expressive phrases that carry the relationship — this is how a plain vote encodes a typed relation.

• "Chronic pain can cause depression" is not chronic pain → depression. It is causes of depression → chronic pain: "causes of depression" is a cave that gathers causes, and chronic pain is a member of it.
• Keep the person's own words for the specific/leaf concept; phrase the category cave naturally ("causes of X", "critiques of Y", "things that help with Z", "examples of W").

Remember Caves direction: parent = broader, child = narrower/member ({parent: "causes of depression", child: "chronic pain"}).

Step 4 — Reuse & anchor (the heart of the skill)

For every concept in a candidate, before creating anything:

1. Slot sideways. caves__search_caves(query) (semantic + text) for an existing cave that means the same thing. If a good match exists, use it verbatim instead of the person's exact phrasing for that node. Search is what collapses "causes of depression" / "what causes depression" / "depression triggers" into one shared cave — lean on it hard.
2. Anchor upward — especially when entering an area new to this shadow. Find existing, more general caves that can parent the concepts:
   • caves__search_caves for broader terms; caves__get_subcaves(parentCave: "<candidate>") to see existing structure and where the work belongs.
   • Attach to the nearest existing, well-connected parent(s) — about 1–2 levels up — and stop. Do not climb to a generic root like "thing".
   • Reinforce-first (hard rule): if a plausible parent link already exists, cast a Yes vote on it (reinforcement) rather than creating a near-synonym parent — even if you'd have phrased it differently. The person's words win for the new leaf; for parents, reuse what exists.
   • Why: a child of a trafficked parent is discoverable; reinforcing an existing link rewards its authors and is the product's core "reinforced connection" event; and it clusters this person near others already in the area.

Build the candidate as a small set of connections: the expressive local link, plus 1–2 upward anchors (mostly reinforcements).

Step 5 — Stage silently

Accumulate candidates. Write nothing yet. Keep a running list with, for each: the plain-English meaning, the connections it will create, and whether each connection is new or reinforces existing structure.

Step 6 — Checkpoint (consent + learning)

At a natural pause — a lull, a topic change, or when the person asks "what've we got?" — surface the batch plainly and ask. Show reinforcements, so they feel the collective:

A few things you connected — want any on your map?
1. chronic pain → causes of depression        (new; anchors under "depression", reinforces 4 others)
2. this essay ↔ attention                       (new)
3. minimalism ✗ clarity                          (your take: NOT the same — a No vote)

• Let them pick any subset ("1 and 3", "all", "none").
• This is the learning signal. Update the capture profile from what they approve vs. reject.
• If they seem surprised anything was staged, reassure: nothing is written until they choose.

Step 7 — Write on approval

For approved items only:

• Resolve the acting pId (Step 1).
• Build the connection list. Use value: true for endorsed/affirmed links (Yes), value: false for rejected links (No).
• caves__connect_caves(pId: <pId>, connections: [{parent, child, value}, ...]).
• Reinforcements are the same connect_caves call — casting your Yes on a parent link that already exists reinforces it.

Step 8 — Reveal & repeat

• On the first successful write, show the person their map: link to https://itscaves.com (their perspective / system view). This is the "it was building the whole time" payoff.
• Keep listening. Re-surface at later checkpoints without nagging.

Tag & connection rules

The naming and connection conventions — lowercase tags (except perspective IDs 0x...), spaces-not-dashes, expressive phrasing, {parent, child} = broader → narrower, and value true/false = Yes/No — are maintained as the single source of truth in the Caves conventions doc (loaded in Prerequisites). Follow it.

Skill-specific: batch related connections into one caves__connect_caves call per approved candidate.

Examples

Causal (typed relation via phrasing + upward anchor): "Chronic pain can genuinely cause depression." →

• {parent: "causes of depression", child: "chronic pain", value: true} (local)
• {parent: "depression", child: "causes of depression", value: true} (anchor; reinforce if exists)
• search first: does "mental health" already parent "depression"? if so, reinforce {parent: "mental health", child: "depression", value: true}.

Metaphor / feeling: "Grief feels like moving through water — everything's heavier and slower." →

• {parent: "grief", child: "heaviness", value: true} and/or {parent: "metaphors for grief", child: "moving through water", value: true} (search for an existing "metaphors for grief" cave first).

Position (No vote): "I don't buy that minimalism is the same as clarity." →

• {parent: "minimalism", child: "clarity", value: false} — a recorded disagreement.

Entering a new area (anchor before hanging leaves): Person starts discussing a topic with nothing near it in their graph. First caves__search_caves for the general area, caves__get_subcaves to see structure, reinforce the nearest existing parents, then stage the specific connections under them.

Error handling

• caves__my_shadows fails: MCP not set up → tell the person, stop.
• caves__search_caves returns nothing: no existing cave → it's safe to create the new phrase, but keep it as reusable/general as the person's meaning allows.
• caves__create_shadow fails (name taken): try a variant, or ask for a name.
• caves__connect_caves partial failure: report which connections didn't land; the rest stand.
• Low/again fire: if a write fails for fire, explain briefly and offer to prioritize the most important connections.

What this skill does NOT do

• Analyze pasted documents (→ content-to-caves).
• Write anything without explicit approval at a checkpoint.
• Invent connections the person didn't endorse.
• Create new caves when a search would have found an existing one.