/skill-composer

name: skill-composer
promoted_to: workflow
description: "DAG-based multi-skill orchestration with dependency resolution."
user-invocable: false
allowed-tools:
  - Read
  - Write
  - Bash
  - Grep
  - Glob
  - Edit
  - Task
  - Skill
routing:
  triggers:
    - "compose skills"
    - "DAG orchestration"
    - "multi-skill chain"
    - "skill pipeline"
    - "combine skills"
  category: meta-tooling
  pairs_with:
    - workflow
    - feature-lifecycle

Skill Composer

Overview

Orchestrate complex workflows by chaining multiple skills into validated execution DAGs. This skill discovers applicable skills, resolves dependencies, validates compatibility, presents execution plans, and manages skill-to-skill context passing. Use when a task requires 2+ skills chained together, parallel skill execution, or conditional branching between skills. Invoke the single skill directly when it can handle the request alone, or for simple sequential invocation that needs no dependency management.

**Core principle**: Minimize composition overhead. Prefer simple 2-3 skill chains. Add only skills directly needed or "nice to have" additions without explicit user request.

Reference Loading Table

| Signal | Load These Files | Why | |---|---|---| | checking skill chain compatibility and input/output type matching | `compatibility-matrix.md` | Loads detailed guidance from `compatibility-matrix.md`. | | choosing sequential vs parallel composition; chain length limits | `composition-patterns.md` | Loads detailed guidance from `composition-patterns.md`. | | composition walkthroughs: feature+tests, debug+docs, parallel quality checks, research-driven builds | `examples.md` | Loads detailed guidance from `examples.md`. | | selecting a proven composition pattern; troubleshooting compositions | `skill-patterns.md` | Loads detailed guidance from `skill-patterns.md`. |

Instructions

Phase 1: DISCOVER

**Goal**: Analyze the task and find applicable skills.

**Step 1: Analyze the user's request**

Identify:

• Primary goals (what needs to be accomplished)
• Quality requirements (testing, verification, documentation)
• Domain constraints (language, framework, standards)
• Execution constraints (sequential vs parallel, conditionals)

**Step 2: Discover available skills**

Before building any DAG, scan skills/*/SKILL.md for available skills:

python3 ${CLAUDE_SKILL_DIR}/scripts/discover_skills.py ./skills

Review the discovered skills. Categorize by type (workflow, testing, quality, documentation, code-analysis, debugging) with dependency metadata.

**Step 3: Select skills (Apply minimum-skills principle)**

Choose only skills directly needed for the stated goals. This prevents over-composition and unnecessary failure points:

• Can a single skill handle this? If yes, invoke it directly. Invoke it directly.
• Can 2 skills handle this? Prefer that over 3+.
• Is a skill being added "for quality" or "just in case"? Remove it.

Cross-reference selections against `references/compatibility-matrix.md` to confirm chaining is valid before proceeding.

**Gate**: Task goals identified. Available skills indexed. Selected skills directly address stated goals with no extras. Proceed only when gate passes.

Phase 2: PLAN

**Goal**: Build a validated execution DAG.

**Step 1: Build the DAG**

Construct the execution DAG as a JSON structure with nodes (skills) and edges (dependencies) based on the task analysis:

python3 ${CLAUDE_SKILL_DIR}/scripts/build_dag.py skill-index.json task-description.json

**Step 2: Validate the DAG**

Validate the execution graph before moving to execution. Validation checks:

• **Acyclic**: No circular dependencies exist between skills
• **Compatibility**: Output types from each skill match input requirements of downstream skills (consult `references/compatibility-matrix.md`)
• **Availability**: All referenced skills exist in the skill index
• **Ordering**: Dependencies satisfy topological ordering

If validation fails, fix the issue and re-validate. Common fixes:

• Circular dependency: Remove one edge or split into two independent compositions
• Type mismatch: Choose different skill or add transformation step
• Missing skill: Check spelling, re-run discovery
• Ordering violation: Reorder phases to satisfy dependencies

**Step 3: Present the execution plan**

Show the execution plan and get user confirmation before running skills, so composition errors surface before any skill runs:

=== Execution Plan ===

Phase 1 (Sequential):
  -> skill-name
    Purpose: [what it does in this context]
    Output: [what it produces]

Phase 2 (Parallel):
  -> skill-a
    Purpose: [what it does]
    Input: [from Phase 1]
  -> skill-b
    Purpose: [what it does]
    Input: [from Phase 1]

Phase 3 (Sequential):
  -> skill-c
    Purpose: [what it does]
    Input: [from Phase 2]

Skills: N | Phases: N | Parallel phases: N

Proceed? [Y/n]

**Gate**: DAG is acyclic. All skills exist. Input/output types are compatible. Topological ordering is valid. User has seen the plan. Proceed only when gate passes.

Phase 3: EXECUTE

**Goal**: Run skills in topological order, passing context between them.

**Step 1: Execute each phase**

For sequential phases: 1. Invoke skill with context from previous phases 2. Capture output 3. Verify output/input compatibility between chained skills 4. Proceed to next phase

For parallel phases: 1. Launch all independent skills using Task tool (execute independent skills concurrently when no shared resources or dependencies exist) 2. Wait for all to complete 3. Aggregate results for next phase

**Step 2: Pass context between skills**

Verify output/input compatibility between chained skills before passing context:

1. Capture output from completed skill 2. Transform to format expected by next skill (validate using `references/compatibility-matrix.md`) 3. Inject as context when invoking next skill 4. Verify transformation succeeded

**Step 3: Report pro