skill-creator-multi

OhadRubin's avatarfrom OhadRubin

Guide for creating multi-phase skills with orchestrated sequential execution. Use when user wants to create a skill that runs multiple steps in sequence (like gap-finder), needs a start-* orchestrator pattern, or asks about multi-step/multi-phase skill architecture.

⭐1stars🔀0forks📁View on GitHub🕐Updated Jan 5, 2026⬇️1downloads
[Tool Routing and Orchestration]

When & Why to Use This Skill

This Claude skill provides a comprehensive framework and automated tooling for designing, initializing, and implementing multi-phase agentic workflows. It enables developers to build complex, sequential skills using an orchestrator pattern, ensuring reliable data handoff and continuous execution across multiple specialized stages to improve task reliability and debuggability.

Use Cases

  • Case 1: Building complex analysis pipelines, such as gap-finders, where data must be sequentially collected, filtered, and refined into a final report.
  • Case 2: Creating automated code review or document processing chains that require distinct stages for identification, deep analysis, and final output formatting.
  • Case 3: Implementing the 'start-*' orchestrator pattern to manage long-running agent tasks that must execute multiple steps in a single turn without stopping.
  • Case 4: Standardizing agent architecture across development teams by using the provided initialization scripts to generate consistent multi-step skill structures.
nameskill-creator-multi
descriptionGuide for creating multi-phase skills with orchestrated sequential execution. Use when user wants to create a skill that runs multiple steps in sequence (like gap-finder), needs a start-* orchestrator pattern, or asks about multi-step/multi-phase skill architecture.

Multi-Phase Skill Creator

Create skills that execute multiple phases in sequence, where each phase builds on the previous phase's output.

When to Use Multi-Phase Skills

Multi-phase skills are appropriate when:

  • A task naturally decomposes into distinct sequential stages
  • Each stage transforms or filters the previous stage's output
  • Separating concerns improves reliability and debuggability
  • The same pipeline applies to different inputs

Examples: gap analysis, code review pipelines, document processing chains.

Multi-Phase Skill Structure

skill-name/
├── start-skill-name/SKILL.md   # Orchestrator (invokes phases in order)
├── skill-name-1/SKILL.md       # Phase 1 (raw collection/identification)
├── skill-name-2/SKILL.md       # Phase 2 (analysis/filtering)
└── skill-name-3/SKILL.md       # Phase 3 (refinement/final output)

Orchestrator Pattern (start-*)

The start-* skill defines the sequence and ensures all phases run without stopping:

---
name: start-skill-name
description: [What it does]. Use when user explicitly asks start-skill-name.
---

Body lists procedure steps and includes:

**IMPORTANT:** Do NOT stop between steps. Run all steps skill-name-* in a single turn.

Phase Pattern (skill-name-N)

Each phase skill:

  • Has description: Triggered by start-skill-name.
  • Defines specific task, rules, output format, anti-patterns
  • References previous step's output in conversation context

Creation Process

Step 1: Design the Pipeline

Define phases before creating files:

  1. What does each phase do?
  2. What is the input/output format for each phase?
  3. What rules constrain each phase?

Step 2: Initialize with Script

scripts/init_multi_skill.py <skill-name> --path <output-dir> [--phases N]

Examples:

# Default 3 phases
scripts/init_multi_skill.py code-reviewer --path skills/public

# Custom 4 phases
scripts/init_multi_skill.py doc-analyzer --path skills/private --phases 4

Step 3: Edit Each Phase

For each generated SKILL.md, replace TODOs with:

  1. Phase description: What this phase accomplishes
  2. Rules: Numbered constraints (keep to 3-5)
  3. Output format: Exact structure with example
  4. Anti-patterns: What to avoid

Step 4: Test the Pipeline

Invoke start-skill-name and verify:

  • All phases execute without stopping
  • Output formats match specifications
  • Each phase correctly uses previous output

Example: Gap Finder Structure

gap-finder/
├── start-gap-finder/SKILL.md
│   └── Procedure: invoke gap-finder-1, then -2, then -3
├── gap-finder-1/SKILL.md
│   └── Task: Generate raw list of potential gaps (max 20)
├── gap-finder-2/SKILL.md
│   └── Task: Mark each gap CORE or NOT CORE with verdict table
└── gap-finder-3/SKILL.md
    └── Task: Output only CORE items with clusters summary

Each phase has strict output format, enabling reliable handoff between phases.