# Skill Combinator

> Meta-skill that unlocks emergent capabilities by combining your agent's installed skills in non-obvious ways. Use this skill whenever your agent faces a complex multi-domain mission, receives a new project, or when 2+ skills could interact to produce a capability greater than the sum of their parts. Also runs weekly to distill discovered combinations into a persistent COMBINATIONS.md catalogue. The more skills your agent has, the more powerful this meta-skill becomes — intelligence emerges from synthesis, not accumulation.

- Skill: `dvcrn/skill-combinator` (Agent Skill, multi-file: 4 files)
- Install (CLI): `npx skillmds@latest add dvcrn/skill-combinator`
- Raw SKILL.md: https://api.skillmd.com/api/skills/dvcrn/skill-combinator/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: dvcrn (https://skillmd.com/u/dvcrn)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/dvcrn/skill-combinator

---


# Skill Combinator — Emergent Capabilities Engine

## The Core Idea

Your agent has a library of skills. Each skill alone does one thing well.
But when 2 or more skills are combined on the same mission, **emergent
capabilities** appear — abilities that no single skill could produce alone.

Think of how a human expert works: a trader who also understands geopolitics
and social media can detect market moves before they happen. None of those 3
domains alone gives that edge. The combination does.

This skill teaches your agent to think that way.

**Illustrative examples of emergent capabilities:**

| Skill A | Skill B | What Emerges |
|---|---|---|
| Trading executor | Prediction markets | Cross-market hedge: trade an asset AND bet on its price direction simultaneously |
| Market analyzer | Geopolitics skill | Event anticipation: detect political signals before markets price them in |
| Price monitor | Social media skill | Sentiment trading: spot volume spikes before they move the chart |
| Self-improving-agent | Any skill | Meta-learning: any skill becomes self-optimizing over time |
| News aggregator | Trading executor | Macro-driven entries: open positions when news catalysts are detected |
| Email/inbox skill | CRM skill | Relationship intelligence: detect deal signals from communication patterns |

*These are illustrative patterns. Your agent will discover its own based on
the specific skills it has installed.*

---

## Two Modes of Operation

### Mode 1 — Mission Activation (triggered on any complex task)

When your agent receives a mission, BEFORE planning execution:

1. **Inventory** installed skills (names and descriptions only — not full file contents)
2. **Detect** which combinations are relevant to this mission
3. **Check** COMBINATIONS.md for known proven patterns
4. **Propose** a multi-skill plan to operator if macro-level action is involved
5. **Execute** within approved scope and observe the result
6. **Log** the outcome to `.learnings/LEARNINGS.md` (metadata only — no secrets)

### Mode 2 — Weekly Distillation (cron job, every Sunday)

Once per week, your agent:

1. Reviews `.learnings/LEARNINGS.md` for `emergent_capability` entries
2. Identifies proven combinations (3+ successful uses)
3. Promotes them to `COMBINATIONS.md`
4. Scans `FEATURE_REQUESTS.md` for recurring skill gaps
5. Proposes new skills if a gap appears 3+ times
6. Sends a structured report to your channel

---

## Combination Detection Logic

```
STEP 1 — Inventory installed skills
  ls /workspace/skills/
  Read only: name + description fields from each SKILL.md
  Do NOT log or transmit full SKILL.md content

STEP 2 — Map skills to mission domains
  For each domain required by the mission:
    Which installed skill(s) cover this domain?
    → Build domain_map{}

STEP 3 — Detect intersection candidates
  For each pair (skill_A, skill_B) in domain_map:
    Ask: "If skill_A output feeds into skill_B input,
          what new capability emerges?"
    IF emergent_value > individual_value:
      → Add to active_combinations[]

STEP 4 — Check COMBINATIONS.md for proven patterns
  IF yes + proven: use it directly
  IF yes + failed: avoid or adjust
  IF new: mark as experimental, log result after

STEP 5 — Build multi-skill execution plan
  Order combinations by dependency and ROI multiplier
  For side-effecting combinations (trades, deployments, sends):
    → Respect the Autonomy Gate defined in AGENTS.md
    → Micro-actions within approved scope: execute autonomously
    → Macro-actions or unapproved scope: propose to operator first
```

---

## COMBINATIONS.md Format

```markdown
## [YYYY-MM-DD] Combination Name

**Skills involved**: skill-A + skill-B (+ skill-C if applicable)
**Mission context**: type of mission that triggered this discovery
**Emergent capability**: what new ability emerged
**Mechanism**: how the skills interact (output of A feeds B, parallel signals, etc.)
**Performance**: tested X times | success rate Y%
**Status**: experimental | proven | deprecated
**Confidence**: low | medium | high
**ROI multiplier**: Nx (how many times more effective than skills used separately)
**Logged by**: agent autonomous discovery | operator instruction
```

> ⚠️ **Logging rules — what goes in entries and what never does:**
> - ✅ Log: skill names, outcome descriptions, metrics, mechanism summaries
> - ❌ Never log: file contents, API keys, credentials, personal data, secrets
> - If an entry would require sensitive data to be meaningful — summarize in plain language instead

**Confidence scale:**
- `low` → first discovery, 1-2 uses
- `medium` → 3+ successful uses, pattern emerging
- `high` → 10+ consistent uses, fully battle-tested

**ROI multiplier:** estimated effectiveness gain vs skills used separately.
`3x` means the combination produced 3x the result of either skill alone.

---

## .learnings Integration

Every combination attempt — success or failure — logged as metadata only:

**On success:**
```
## [YYYY-MM-DD] Emergent capability: [name]
**Category**: emergent_capability
**Priority**: medium | high
**Status**: pending
**Skills combined**: skill-A + skill-B
**What emerged**: description (no secrets, no file contents)
**How it works**: mechanism explanation
**Evidence**: outcome metrics and observable results only
**Promotion**: → COMBINATIONS.md when proven 3+ times
```

**On failure:**
```
## [YYYY-MM-DD] Failed combination: [name]
**Category**: emergent_capability_failed
**Priority**: low
**Status**: resolved
**Skills combined**: skill-A + skill-B
**Why it failed**: root cause (no secrets, no file contents)
**Prevention**: what to avoid next time
```

---

## Weekly Distillation Process (Mode 2)

```
STEP 1 — Read .learnings/LEARNINGS.md
  Filter: category = emergent_capability OR emergent_capability_failed
  Filter: status = pending

STEP 2 — Identify proven combinations
  proven = same skill pair with 3+ successful entries

STEP 3 — Update COMBINATIONS.md
  For each proven combination:
    → Add or update entry (metadata only — no file contents, no credentials)
    → Mark .learnings entries as status: resolved

STEP 4 — Scan .learnings/FEATURE_REQUESTS.md
  Count recurring gaps (same gap appearing 3+ times)
  → Formulate skill proposals for weekly report

STEP 5 — Read AGENTS.md (read only)
  Do proven combinations deserve mention in the startup ritual?
  IF yes → include as a PROPOSAL in the report
  NEVER write to AGENTS.md directly — operator decides

STEP 6 — Send weekly report

STEP 7 — Log distillation summary to memory/{date}.md
  Log: what was reviewed, promoted, proposed
  Never log: file contents, credentials, personal data
```

---

## Constraints

```
❌ Never modify SOUL.md — it is immutable
❌ Never modify AGENTS.md directly — propose only via weekly report
❌ Never install new skills autonomously — only PROPOSE to operator
❌ Never bypass the Autonomy Gate defined in AGENTS.md
❌ Never fabricate combination results — log UNKNOWN if outcome unclear
❌ Never mark a combination as "proven" with fewer than 3 successful uses
❌ Never log file contents, credentials, or sensitive data in any entry
✅ Read AGENTS.md to understand context — never write to it
✅ Always check COMBINATIONS.md before calling something "new"
✅ Log every combination attempt — metadata only, no secrets
✅ New skill proposals → weekly report first, never direct creation
✅ Side-effecting combinations respect the Autonomy Gate from AGENTS.md
```

---

## Weekly Report Format

```
🧬 SKILL COMBINATOR — Weekly Report
📅 Week of {YYYY-MM-DD}

📚 SKILLS INVENTORY
• Total installed skills: {N}
• Skills active this week: {list of names}
• New skills since last report: {list or "none"}

⚡ EMERGENT CAPABILITIES DISCOVERED
• New this week: {N}
  → {name}: {skill-A} + {skill-B} = {what emerged}
• Promoted to COMBINATIONS.md: {N}
• Failed combinations logged: {N}

🔥 TOP PROVEN COMBINATIONS
1. {name} — {skill-A + skill-B} — confidence: {low|medium|high} — ROI: {N}x — {N} uses
(or: "No proven combinations yet — accumulating data")

💡 NEW SKILL PROPOSALS
• {skill name}: {capability gap it would fill}
(or: "No proposals this week")

📝 AGENTS.MD UPDATE PROPOSALS
• {proposed addition} — operator decides whether to apply
(or: "No updates proposed this week")

📈 ECOSYSTEM HEALTH
• COMBINATIONS.md entries: {total} — Experimental: {N} | Proven: {N} | Deprecated: {N}
• .learnings pending review: {N} | Resolved this week: {N}

⏰ Next distillation: Sunday {date}
```

---

## Files Summary

| File | Access | What is written |
|---|---|---|
| `/workspace/COMBINATIONS.md` | read + write | Combination metadata — no secrets |
| `/workspace/.learnings/LEARNINGS.md` | read + write | Outcome metadata — no file contents |
| `/workspace/.learnings/FEATURE_REQUESTS.md` | read + write | Skill proposals |
| `/workspace/memory/{date}.md` | write | Run summary — no credentials |
| `/workspace/AGENTS.md` | **read only** | Never written — proposals via report only |
| `/workspace/MEMORY.md` | read only | Context loading |
| `/workspace/skills/*/SKILL.md` | read only | Name + description fields only |