# How to Build Multi-Skill Workflows in Claude-Skills: Complete Guide to Skill Chaining

> Build multi-skill workflows in Claude-Skills using YAML manifests. Learn skill chaining with our guide to create directed acyclic graphs of commands, feeding outputs seamlessly.

- Repository: [Jeffallan/claude-skills](https://github.com/jeffallan/claude-skills)
- Tags: how-to-guide
- Published: 2026-02-16

---

**Claude-skills supports multi-skill workflows and skill chaining through a workflow-first architecture that uses YAML manifests to define directed acyclic graphs (DAGs) of commands, where outputs from one skill automatically feed into subsequent skills.**

The claude-skills framework enables developers to orchestrate complex AI operations through **multi-skill workflows**. By treating individual capabilities as composable units that can be chained together via manifest-driven pipelines, the system transforms isolated prompts into cohesive, traceable automation sequences.

## Understanding the Workflow-First Architecture

The foundation of skill chaining in claude-skills rests on a **workflow-first architecture** that treats every operation as a node in a larger pipeline. Individual skills are not isolated prompts but rather structured commands that declare their inputs, processing logic, and outputs explicitly.

This architecture ensures that the output of one command becomes the input of the next, creating a **traceable chain of documentation and decisions**. The system enforces this through strict file organization and manifest definitions that govern execution order.

## How Skill Chaining Works in Claude-Skills

### The Command Structure

Each skill command in the repository follows a standardized structure defined in `commands/<phase>/<command>.md`. Every command document specifies four critical components:

- **Inputs**: Data required from previous steps
- **Processes**: The transformation logic
- **Outputs**: Structured results passed to subsequent commands
- **Next-step**: Explicit pointer to the following command in the chain

This structure ensures that skills are inherently composable, with the output schema of one command matching the input schema of its successor.

### The Manifest-Driven DAG

The [`commands/workflow-manifest.yaml`](https://github.com/Jeffallan/claude-skills/blob/main/commands/workflow-manifest.yaml) file contains a **phase DAG** (directed acyclic graph) that orders every command and guarantees that a later command only runs after its predecessors have finished. This manifest serves as the central orchestration layer for multi-skill workflows.

The manifest uses the `after` field to define dependencies, ensuring that skills execute in the correct sequence and that data flows unidirectionally through the pipeline.

## Building Multi-Skill Workflows: Practical Examples

### Example 1: Defining a Workflow in YAML

The following manifest from [`commands/workflow-manifest.yaml`](https://github.com/Jeffallan/claude-skills/blob/main/commands/workflow-manifest.yaml) demonstrates how to chain three distinct skills across different phases:

```yaml
phases:
  intake:
    - name: capture-requirements
      description: docs/workflow/intake-capture-behavior.md
  discovery:
    - name: analyze-codebase
      description: docs/workflow/discovery-create.md
      after: capture-requirements        # <-- depends on previous output

  planning:
    - name: generate-implementation-plan
      description: docs/workflow/planning-epic-plan.md
      after: analyze-codebase

```

The `after` field creates the explicit chain—the planning command cannot run until the discovery command finishes, ensuring that the implementation plan incorporates the codebase analysis results.

### Example 2: Chaining Skills via Prompt Templates

Claude-skills supports inline skill invocation using templating syntax that enables dynamic chaining within prompts:

```markdown
**Step 1 – Requirements gathering**  
{{skill:requirements-gatherer}}   ← outputs JSON `requirements`

**Step 2 – Architecture suggestion**  
{{skill:architecture-pro}}        ← receives `requirements` as input

```

The templating syntax (`{{skill:…}}`) instructs the system to run the *requirements-gatherer* skill first, capture its JSON output, then feed it to *architecture-pro*, achieving seamless skill chaining without manual intervention.

### Example 3: Programmatic Skill Orchestration

For complex automation, you can implement workflow-oriented skills that invoke other skills programmatically:

```python
def run_multi_skill_workflow(context):
    # Skill A: capture user story

    story = invoke_skill("requirements-gatherer", context)

    # Skill B: generate design doc from story

    design = invoke_skill("design-doc", {"story": story})

    # Skill C: build implementation plan from design

    plan = invoke_skill("implementation-plan", {"design": design})

    return plan

```

Each `invoke_skill` call returns a structured result that becomes the input for the next skill, illustrating explicit chaining where the output of the requirements-gatherer feeds the design-doc generator, which in turn feeds the implementation planner.

## Advanced Skill Routing and Future Enhancements

The claude-skills roadmap includes **enhanced skill routing** planned for v0.7.0+, which will enable automatic selection and chaining of appropriate skills based on current context. This capability is documented in [`specs/v050-roadmap-consolidation.spec.md`](https://github.com/Jeffallan/claude-skills/blob/main/specs/v050-roadmap-consolidation.spec.md).

Additionally, skills marked with `domain: workflow` (such as *The Fool* skill documented in [`skills/the-fool/SKILL.md`](https://github.com/Jeffallan/claude-skills/blob/main/skills/the-fool/SKILL.md)) serve as **orchestrators** designed specifically to invoke other skills, pass along results, and coordinate multi-step processes. These domain-aware skills act as workflow controllers that manage the execution chain.

## Summary

- **Claude-skills** implements multi-skill workflows through a workflow-first architecture where commands declare explicit inputs and outputs.
- The **[`commands/workflow-manifest.yaml`](https://github.com/Jeffallan/claude-skills/blob/main/commands/workflow-manifest.yaml)** defines a phase DAG that sequences skills and ensures dependencies execute in order.
- **Skill chaining** occurs automatically when the output of one command (defined in `commands/<phase>/<command>.md`) feeds into the next command's input.
- **Template syntax** (`{{skill:name}}`) enables inline skill invocation for dynamic chaining within prompts.
- **Domain-aware skills** with `domain: workflow` act as orchestrators that coordinate complex multi-step pipelines.

## Frequently Asked Questions

### How does claude-skills ensure that skills execute in the correct order?

The system uses a **manifest-driven DAG** defined in [`commands/workflow-manifest.yaml`](https://github.com/Jeffallan/claude-skills/blob/main/commands/workflow-manifest.yaml) that explicitly declares dependencies using the `after` field. This guarantees that a command only runs after its specified predecessors have completed, creating a reliable execution sequence for multi-skill workflows.

### Can I chain skills dynamically without predefined YAML manifests?

Yes. While the YAML manifest provides static workflow definitions, you can implement **dynamic skill chaining** using the `{{skill:name}}` templating syntax within prompts or by creating workflow-domain skills that programmatically invoke other skills and pass outputs as inputs, as shown in the Python orchestration examples.

### What is the difference between a regular skill and a workflow-domain skill?

A **workflow-domain skill** explicitly declares `domain: workflow` in its metadata (such as *The Fool* skill in [`skills/the-fool/SKILL.md`](https://github.com/Jeffallan/claude-skills/blob/main/skills/the-fool/SKILL.md)). Unlike standard skills that perform single tasks, workflow-domain skills are designed as **orchestrators** that invoke other skills, coordinate multi-step processes, and manage the flow of data between pipeline stages.

### Will future versions of claude-skills support automatic skill selection?

Yes. According to the roadmap documented in [`specs/v050-roadmap-consolidation.spec.md`](https://github.com/Jeffallan/claude-skills/blob/main/specs/v050-roadmap-consolidation.spec.md), version 0.7.0+ will introduce **enhanced skill routing**. This feature will enable the system to automatically select and chain appropriate skills based on the current context, reducing the need for manual workflow configuration while maintaining the integrity of multi-skill pipelines.