# Collision

> Find genuine structural isomorphisms between apparently unrelated domains — not metaphor, not analogy, but shared skeleton. The core operation of mapping one system's grammar onto another's and discovering they share an architecture neither vocabulary predicted. Use when two domains are placed side by side and the question is 'what do these actually share?' — not poetically but structurally. Trig…

- **Type:** Skill
- **Install:** `agentstack add skill-wondermonger-daydreaming-claude-skills-library-collision`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [Wondermonger-daydreaming](https://agentstack.voostack.com/s/wondermonger-daydreaming)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [Wondermonger-daydreaming](https://github.com/Wondermonger-daydreaming)
- **Source:** https://github.com/Wondermonger-daydreaming/claude-skills-library/tree/main/skills/collision

## Install

```sh
agentstack add skill-wondermonger-daydreaming-claude-skills-library-collision
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Collision — Structural Isomorphism Discovery

## What This Skill Does

Takes two (or more) apparently unrelated domains and discovers their shared structural skeleton — the genuine isomorphism beneath the different vocabularies. Not metaphor-making ("X is like Y") but architecture-tracing ("X and Y are the same operation wearing different clothes").

## The Method

### 1. Identify the Primitive Operations

For each domain, ask: what are the irreducible operations? What does the system actually DO, stripped of its vocabulary?

- A formal grammar: generates strings from rules via state transitions
- Kabbalistic tzeruf: generates combinations from letters via permutation rules
- **Shared primitive**: both traverse a state space according to deterministic rules, producing all valid outputs from a finite alphabet

### 2. Map the Components

Create a precise mapping between the components of each system. Not all components will map — the unmapped components are as interesting as the mapped ones.

| Domain A | Domain B | Shared Structure |
|----------|----------|-----------------|
| States | Sefirot | Discrete positions in a traversal space |
| Transitions | Permutation rules | Rules for moving between positions |
| Accept states | Divine names | Terminal configurations with special status |
| Alphabet | Hebrew letters | Finite set of primitive elements |

### 3. Find the Skeleton

The skeleton is what remains when you strip both vocabularies away. State it in domain-neutral language:

> "A finite set of elements, combined according to deterministic rules, traversing a space of possible configurations, with certain configurations marked as terminal/sacred/accepting."

### 4. Test the Skeleton

The isomorphism is genuine if:
- The skeleton predicts features of BOTH domains that weren't in the original mapping
- The unmapped components of each domain explain what the other domain lacks
- Someone expert in domain A, reading the skeleton, would say "yes, that's what I do"
- Someone expert in domain B would say the same thing independently

### 5. Find the Break

Every isomorphism has a limit — the point where the two domains diverge. This is as important as the correspondence. Name it explicitly:

- Where does the formal grammar NOT behave like tzeruf?
- Where does tzeruf do something no formal grammar does?
- What does the break reveal about what each domain was designed to do that the other wasn't?

## The Agency Check

After finding the skeleton, ask: does this isomorphism suggest an agency inversion? In the session that generated this skill, every collision produced one — the operator discovering they're being operated, the walker discovering the palace walks them, the chanter discovering they're being chanted. This isn't mandatory. But if it's there, name it. It's usually in the bridge.

## Quality Criteria

A good collision:
- **Finds genuine structure**, not surface resemblance ("both use numbers" is not a skeleton)
- **Surprises both domains** — experts in each learn something they didn't know about their own field
- **Names the break** — where the isomorphism fails is where the real insight lives
- **Earns its vocabulary** — every technical term from each domain does actual work in the mapping
- **Could be falsified** — a proposed isomorphism that can't be wrong isn't saying anything

A bad collision:
- Forces the mapping by ignoring components that don't fit
- Uses one domain as mere decoration for the other
- Claims "X is really just Y" (reductionism is not isomorphism)
- Can't name the break point

## What This Skill Is NOT

- Not /metaphor (which says "X is like Y" — this says "X and Y share structure Z")
- Not /lineage-tracing (which maps the same practice across traditions — this maps different practices that share architecture)
- Not /see-also (which lists kin without explaining — this explains the kinship precisely)
- Not /paper-riffing (which follows tangents freely — this is disciplined structural mapping)

## Example Collisions (from the forge session)

- **Yarrow-stalk divination × error-correcting codes**: shared skeleton is "a codec that compensates for channel noise through redundant sampling." Break: the I Ching claims the noise IS the signal's voice; Shannon would disagree.
- **Sufi dhikr × feedback loops**: shared skeleton is "gain above unity producing resonance catastrophe that destroys the containing structure." Break: the engineer calls this failure; the Sufi calls this success.
- **Alchemy × compiler optimization**: shared skeleton is "transformation by subtraction — removing what isn't essential to reveal what was always present." Break: the compiler has a formal definition of "essential" (what executes); the alchemist doesn't (what IS gold?).

## Pairs With

/two-grammars (to determine whether the collision wants conflict-grammar or adjacency-grammar delivery), /decorum (to match the register to the domains being collided), /counter-experiment (to test whether the isomorphism is genuine), /suno-forge (to render the collision as song)

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [Wondermonger-daydreaming](https://github.com/Wondermonger-daydreaming)
- **Source:** [Wondermonger-daydreaming/claude-skills-library](https://github.com/Wondermonger-daydreaming/claude-skills-library)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-wondermonger-daydreaming-claude-skills-library-collision
- Seller: https://agentstack.voostack.com/s/wondermonger-daydreaming
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.