---

name: skill-compose description: This skill should be used when orchestrating multiple skills together for complex workflows. Triggers include "chain these skills", "use X then Y skill", "multi-skill workflow", or when a task requires capabilities from several skills. Handles skill sequencing, data flow, and aggregated validation.

skill-compose

orchestrate multiple Claude Code skills together for complex workflows. determines optimal skill sequence, handles data flow between skills, and aggregates validation across the chain.

philosophy

"the whole is greater than the sum of its skills"

principle	application
composition over complexity	chain simple skills, don't create mega-skills
explicit handoffs	clear data flow between skills
aggregated validation	validate the chain, not just individual skills
fail-fast	stop chain on skill failure

when to use

use	skip
task needs multiple skill capabilities	single skill sufficient
"do X then Y" requests	skills are independent
complex workflows	simple sequential tasks
skill chaining opportunities	creating new skill instead

skill categories for composition

producers (generate output)

• create-skill → new skill
• metaprompt-factory → prompt template
• issue-context → enriched issue

transformers (modify input)

• skill-improve → improved skill
• pr-audit → audited PR

validators (check quality)

• consult-light → quick validation
• consult-deep → thorough validation

orchestrators (manage flow)

• loop → autonomous iteration
• long-horizon → sustained work
• deep-work → delegated execution

connections (external systems)

• slack → messaging
• imessage → personal messaging

composition patterns

sequential chain

skill-A → skill-B → skill-C

example: create-skill → skill-improve → consult-deep
         (create)     (improve)       (validate)

validation sandwich

consult-light → skill-A → consult-light
(pre-check)    (work)    (post-check)

example: consult-light → deep-work → consult-light
         (approach ok?)  (implement) (result ok?)

parallel fan-out

         ┌→ skill-A
input →──┼→ skill-B
         └→ skill-C
              ↓
          aggregate

example: issue arrives
         ├→ issue-context (enrich)
         ├→ consult-light (approach)
         └→ tdd-convex (test plan)
              ↓
          combined context for loop

iterative loop

while (!done) {
  skill-A → validate → continue?
}

example: skill-improve iteration
         improve → consult-deep → depth < 8? → improve again

workflow

1. identify required capabilities

Task: "improve a skill and notify me when done"

Required capabilities:
├── skill improvement → skill-improve
├── validation → consult-deep, consult-light
└── notification → slack or imessage

2. determine sequence

dependency analysis:
- skill-improve needs skill to exist ✓
- consult-deep needs improved skill → after skill-improve
- notification needs result → after validation

sequence: skill-improve → consult-deep → slack

3. define handoffs

| from | to | data passed |
|------|-----|-------------|
| skill-improve | consult-deep | improved SKILL.md content |
| consult-deep | slack | validation result JSON |

4. execute chain

# step 1: improve
SKILL_CONTENT=$(cat ~/.claude/skills/target/SKILL.md)
# [run skill-improve workflow]

# step 2: validate
VALIDATION=$(cat <<'EOF' | codex exec --model gpt-5.2-max
[consult-deep prompt with $SKILL_CONTENT]
EOF
)

# step 3: notify
echo "Skill improved. Validation: $VALIDATION" | slack dm send --user luke

5. aggregate validation

{
  "chain": "skill-improve → consult-deep → slack",
  "steps": [
    {"skill": "skill-improve", "status": "pass", "output": "improved"},
    {"skill": "consult-deep", "status": "pass", "depth_score": 9},
    {"skill": "slack", "status": "pass", "message_sent": true}
  ],
  "overall": "pass",
  "duration": "3m 42s"
}

common compositions

skill creation pipeline

create-skill → skill-improve → consult-deep → artifact → consult-light

autonomous work with notification

loop → [internal flywheel] → pr-audit → slack

research and synthesis

deep-ask → [gather answers] → metaprompt-factory → consult-light

issue to implementation

issue-context → consult-light → loop → pr-audit → slack

execution modes

synchronous (default)

each skill completes before next starts:

skill-A (3min) → skill-B (2min) → skill-C (1min) = 6min total

parallel where possible

independent skills run concurrently:

         ┌→ skill-A (3min) ─┐
input →──┤                  ├→ aggregate (1min) = 4min total
         └→ skill-B (2min) ─┘

background with callback

long-running skills don't block:

deep-work (background) → on_complete: slack notify

error handling

fail-fast (default)

skill-A → skill-B (fails) → STOP
                          ↓
                    notify failure

retry with backoff

skill-A → skill-B (fails) → retry (1s) → retry (2s) → fail

fallback chain

skill-A → skill-B (fails) → skill-B-fallback → skill-C

references

• references/composition-examples.md - detailed examples
• references/handoff-patterns.md - data flow patterns

anti-patterns

pattern	problem	fix
mega-skill	one skill tries to do everything	compose simpler skills
implicit handoffs	unclear what data flows between	document handoff explicitly
no aggregated validation	individual passes, chain fails	validate the whole chain
ignore failures	chain continues after error	fail-fast by default
sequential when parallel possible	slower than needed	identify independent skills