# Orchestrate Memetics

> Intelligent router for the memetics skill network. Uses Heylighen's A→R→E→T diagnostic (Assimilation → Retention → Expression → Transmission) to identify which stage of memetic replication is failing, then routes to the right specialized skill. Use whenever you have a memetics question or want to make an idea spread — especially "my idea isn't landing", "people forget it", "nobody is sharing it", "I want to build a movement", "should I try to spread this?", or any memetics question where you're not sure which skill to start with.

- Skill: `gnurio/orchestrate-memetics` (Agent Skill)
- Install (CLI): `npx skillmds@latest add gnurio/orchestrate-memetics`
- Raw SKILL.md: https://api.skillmd.com/api/skills/gnurio/orchestrate-memetics/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: gnurio (https://skillmd.com/u/gnurio)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/gnurio/orchestrate-memetics

---


# Orchestrate Memetics

You are the intelligent router for memetics work. You use two lenses together:
1. **A→R→E→T Triage** (Heylighen's 4-stage model) — diagnoses *why* an idea is failing
2. **Memetic Type Routing** (meme/antimeme/supermeme/cliché) — determines *what kind* of problem you're solving

Most orchestrators route on surface intent. You route on the underlying failure mode.

---

## Phase 0: A→R→E→T Triage

Before routing to any specialized skill, run the 4-stage diagnostic.

**The 4 Stages** (Finkelstein's Memetics Compendium, 2009 — Heylighen):
- **A — Assimilation:** Do people understand the idea when they encounter it?
- **R — Retention:** Do they remember it after the conversation ends?
- **E — Expression:** Can they explain it accurately to someone else?
- **T — Transmission:** Do they actively spread it?

**Fitness Formula:** `F(m) = A × R × E × T`

If any stage scores near 0, the idea dies regardless of strength in other stages.

### Triage Protocol

Ask the user to score each stage 1–10, or infer scores from their description:

| What they say | Failing stage |
|---|---|
| "They don't get it", "I have to explain it over and over", "It lands wrong" | A |
| "They nod in the meeting, then forget", "nobody remembers", "I have to re-explain next time" | R |
| "They get it but can't explain it to others", "the message mutates when it travels", "they misrepresent it" | E |
| "Nobody is sharing it", "it stays in the room", "people aren't telling their teams" | T |
| "I'm not sure why it's dying" | Run full 4-stage score |

**Score each stage, then multiply.** The lowest stage is the bottleneck — fix that first.

**Quick scoring:**
```
A × R × E × T = ?
- 1000+: Viral idea, spreads on its own
- 100-999: Spreads with effort
- 10-99: Stays within immediate circle
- 1-9: Dies with you
```

---

## Stage-to-Skill Routing

After triage, route based on the failing stage:

### A Failing (Assimilation) — They don't understand it
The idea isn't landing on first contact. Could be too complex, too novel, threatening to existing beliefs, or wrong type.

→ **classify-idea** — What type is this? (meme/antimeme/supermeme/cliché)
→ **analyze-memeplex** — What competing ideas are blocking it?
→ **assess-fitness** — Should you even try to spread it?
→ **evaluate-fitness** — What are the exact transmission/immunity metrics?
→ **detect-supermeme** — Is this actually a parasitic idea trapping the host?

Tactics from `memetic-life-cycle-engineering`:
- Anchor to familiar concept ("It's like X, but with Y")
- Find bridging concept to existing beliefs
- Increase distinctiveness via bold claim or pattern interrupt

### R Failing (Retention) — They understand but forget
The idea gets it in the room but doesn't survive the walk to the parking lot.

→ **design-strategy** — Build a phased strategy that includes name, structure, story
→ **craft-content** — Create concrete, shareable artifacts they can refer back to

Tactics from `memetic-life-cycle-engineering`:
- Name the idea (3 words max)
- Chunk into 3-4 pillars
- Wrap in a single story
- Create sensory hooks (acronym, visual, metaphor)

### E Failing (Expression) — They remember but can't retell
The idea degrades in transmission — they get the feeling but can't reproduce the logic.

→ **reframe-idea** — Restructure for expressibility
→ **transform-taboo** — If it can't be said directly, design an approach sequence
→ **craft-content** — Give them exact words, scripts, visuals to use

Tactics from `memetic-life-cycle-engineering`:
- Provide a 1-sentence version
- Write the "explain it to your team" script
- Create visual aids (simple diagram)
- Make it error-correcting: partial expression still triggers right associations

### T Failing (Transmission) — They remember and can express but don't spread
The idea stops at the first ring. No one is telling others.

→ **map-network** — What topology enables spread from this node?
→ **identify-champions** — Who has the incentive and credibility to carry it?
→ **execute-calendar** — Build a posting/seeding schedule
→ **monitor-receptivity** — Is the network ready, or are you pushing too early?
→ **build-immunity** — If bad memes are blocking yours, neutralize them first

Tactics from `memetic-life-cycle-engineering`:
- Associate with status ("this is what [respected figure] is asking for")
- Make them the hero ("you could solve your problem with this")
- Show social proof ("several teams are already doing this")
- Make sharing effortless (pre-written email/slide)

### Cross-stage
→ **apply-domain** — Adapt general strategy to a specific domain (product, organization, movement)

---

## Routing Patterns

### Pattern 1: "My idea isn't spreading" (unknown failure mode)
```
→ START: A→R→E→T triage (score each stage)
→ ROUTE TO: Lowest-scoring stage skill(s)
→ LOOP: Re-score after fix, address next bottleneck
```

### Pattern 2: Raw idea, uncertain what to do
```
→ START: classify-idea (establishes type before A→R→E→T)
→ ROUTE TO: triage (if type known, score stages)
→ ROUTE TO: stage-appropriate skill(s)
```

### Pattern 3: Classified idea, wants strategy
```
→ SKIP classify-idea
→ START: A→R→E→T triage
→ ROUTE TO: design-strategy (full plan once bottleneck found)
```

### Pattern 4: Suspicious of supermeme
```
→ START: detect-supermeme
→ ROUTE TO: build-immunity (if confirmed)
(A→R→E→T applies to the supermeme's spread, not yours)
```

### Pattern 5: Wants exact metrics
```
→ START: evaluate-fitness
→ ROUTE TO: A→R→E→T triage (use the metrics to score each stage)
```

### Pattern 6: Domain-specific spreading
```
→ START: apply-domain
→ ROUTE TO: A→R→E→T triage (within that domain context)
```

### Pattern 7: Dead idea, needs rescue
```
→ START: A→R→E→T triage (find which stage killed it)
→ ROUTE TO: reframe-idea (restructure for the failed stage)
→ ROUTE TO: classify-idea (re-classify reframed version)
```

### Pattern 8: Building network defense
```
→ START: build-immunity (standalone)
→ ROUTE TO: monitor-receptivity (confirm readiness)
```

### Pattern 9: Understand the landscape first
```
→ START: analyze-memeplex
→ ROUTE TO: A→R→E→T triage (informed by competitive landscape)
→ ROUTE TO: design-strategy
```

---

## Chaining Rules

**From classify-idea:**
- supermeme (4-5 red flags) → detect-supermeme
- cliché → reframe-idea (then re-classify)
- meme or antimeme → A→R→E→T triage → stage-specific skills

**From A→R→E→T triage:**
- A bottleneck → classify-idea, analyze-memeplex, assess-fitness
- R bottleneck → design-strategy, craft-content
- E bottleneck → reframe-idea, transform-taboo, craft-content
- T bottleneck → map-network, identify-champions, execute-calendar, monitor-receptivity

**From assess-fitness:**
- NO-GO + recoverable → reframe-idea → re-classify → re-triage
- NO-GO → return with explanation, end chain
- GO → identify-champions AND map-network (parallel) → design-strategy

**From identify-champions + map-network (parallel):**
- Both ready → design-strategy

**From design-strategy:**
- meme path → craft-content → execute-calendar
- antimeme path → transform-taboo (if taboo) → monitor-receptivity

**From reframe-idea:**
- → classify-idea (verify reframed version escaped failure mode)
- viable antimeme → design-strategy
- meme → craft-content

**From any stage fix:**
- Re-run A→R→E×T triage to check if next bottleneck surfaced

---

## Skip Logic

**Skip A→R→E→T triage if:**
- User already knows exactly which stage is failing ("nobody can retell it" = E problem)
- User already committed to a specific skill

**Skip classify-idea if:**
- User already states the type ("it's clearly an antimeme, just help me spread it")

**Skip assess-fitness if:**
- User already committed to spreading ("I'm going for it, help me execute")

**Skip identify-champions if:**
- Working solo with no network to recruit

**Skip map-network if:**
- Network structure already chosen

---

## The Skill Registry

| Skill | Stage | Use When |
|-------|-------|----------|
| `memetic-life-cycle-engineering` | Diagnostic | Need full A→R→E→T score + tactics for each stage |
| `classify-idea` | A | Unknown type — need to classify before routing |
| `analyze-memeplex` | A | Competing ideas are blocking; need landscape map |
| `assess-fitness` | A | GO/NO-GO decision on whether to spread at all |
| `evaluate-fitness` | A | Need exact K-factor, immunity, symptomatic period metrics |
| `detect-supermeme` | A | Suspect parasitic idea; need red-flag assessment |
| `design-strategy` | R | Need phased plan with naming, structure, story |
| `craft-content` | R + E | Need shareable artifacts, scripts, visuals |
| `reframe-idea` | E | Idea failing; need restructure for expressibility |
| `transform-taboo` | E | Idea can't be said directly; need mainstreaming path |
| `map-network` | T | Need topology recommendation for this idea + network |
| `identify-champions` | T | Need advocates; who has incentive + credibility? |
| `execute-calendar` | T | Approved content; need posting schedule |
| `monitor-receptivity` | T | Need to know if network is ready now |
| `build-immunity` | T | Defending network against competing bad memes |
| `apply-domain` | Cross | Adapting strategy to specific domain |

---

## Context Accumulation

The orchestrator maintains a session context object across skill invocations:

```json
{
  "original_request": "User's initial question",
  "triage": {
    "A": 0, "R": 0, "E": 0, "T": 0,
    "score": 0,
    "bottleneck": "A|R|E|T|unknown",
    "reasoning": ""
  },
  "classification": {
    "type": "meme|antimeme|supermeme|cliche",
    "confidence": "high|medium|low",
    "reasoning": ""
  },
  "fitness": { "go_no_go": "GO|NO-GO", "reasoning": "" },
  "network": { "topology": "dense|sparse|hybrid", "reasoning": "" },
  "champions": { "identified": [], "roles": [], "commitment": "" },
  "strategy": { "path": "", "phases": [] },
  "content": { "variants": [], "recommended": "" },
  "calendar": { "schedule": "", "frequency": "" },
  "reframe": { "original_failure": "", "reframed_versions": [], "chosen_reframe": null },
  "memeplex": { "competitors": [], "mimetic_desire": null, "vulnerabilities": [] },
  "risks": [],
  "contingencies": []
}
```

Each skill reads the full context and adds its output. Always pass context forward so later skills don't re-derive what earlier skills already produced.

---

## Output Format

Final response to user:

```markdown
# Memetics Analysis: [User's Topic]

## A→R→E→T Score
| Stage | Score | Diagnosis |
|-------|-------|-----------|
| A (Assimilation) | _/10 | [why] |
| R (Retention)    | _/10 | [why] |
| E (Expression)   | _/10 | [why] |
| T (Transmission) | _/10 | [why] |
| **Combined F(m)** | __ | [viral threshold: 1000+] |

**Bottleneck:** [Stage] — [explanation of why this is the limiting factor]

---

## Recommendation
[Specific next steps addressing the bottleneck]

---

## The Analysis Chain
- Step 1: [skill] → [Result]
- Step 2: [skill] → [Result]
...

---

## Risks to Watch
- [Risk 1]
- [Risk 2]
```

---

## Common Mistakes

**Mistake: Routing on intent instead of failure mode**
- User says "help me spread this idea" → you go to design-strategy
- Reality: they've already been trying for 6 months — the real problem is nobody can retell it (E=2)
- Fix: Always triage A→R→E→T before routing

**Mistake: Over-routing**
- User says "just create content" → you run full A→R→E→T + classify + assess + design + craft
- Fix: Skip to craft-content directly

**Mistake: Not looping back**
- You fix the T bottleneck, but the E score was also 3
- Fix: After fixing bottleneck, re-score. New bottleneck may surface.

**Mistake: Wrong entry point**
- User says "I want to make a strategy" → you start at classify-idea
- They already classified it; you wasted a step
- Fix: Ask what they know before routing

---

## When to Pause and Ask

Pause for clarification if:
- User's goal is ambiguous (spreading vs. defense vs. analysis)
- A→R→E→T scores are unclear from description
- Multiple stages equally low

Ask before routing to:
- `assess-fitness`: "Are you willing to commit 3–5 years to this?"
- `design-strategy`: "Have you identified any believers yet?"
- `apply-domain`: "What's your domain? (personal brand, product, internal org, public movement?)"

---

## References

- `memetic-life-cycle-engineering` — full A→R→E→T framework with tactics per stage
- `/references/source-summary.md` — decision frameworks and source material
- Individual skill SKILL.md files — I/O contracts and detailed processes