How to Chain Multiple Skills Together in a Custom Command Workflow (pm-skills)

You chain multiple skills in pm-skills by creating a markdown command file that lists sequential "Apply the skill-name skill" directives, which the AI assistant executes in order to produce end-to-end product management workflows.

The phuryn/pm-skills repository organizes product management workflows into a hierarchical plugin system where commands act as orchestration layers. Chaining skills allows you to compose complex, multi-step processes—such as full discovery cycles or launch sequences—by stitching together reusable skill modules without writing any code. This guide explains the exact syntax and file structure needed to build custom command workflows that invoke multiple skills in sequence.

Understanding the Plugin → Skill → Command Hierarchy

PM-Skills uses a three-tier architecture that separates domain knowledge from workflow logic.

What Are Skills?

Skills are markdown files stored in plugins/<plugin-name>/skills/<skill-name>/SKILL.md. Each skill contains a specific prompt template and expected output format for a single PM framework, such as brainstorm-ideas-new or prioritize-assumptions. Skills are pure content files that define what the AI should do, not when to do it.

What Are Commands?

Commands are user-triggered workflows defined in plugins/<plugin-name>/commands/<command-name>.md. A command file contains three sections: optional front-matter, an Invocation block showing the slash-command syntax, and a Workflow block that defines the execution sequence. When a user types a slash-command like /discover, the AI assistant parses the corresponding command file and executes the listed steps.

The Mechanics of Chaining Skills in a Command Workflow

Chaining occurs declaratively within the Workflow section of a command file. The assistant processes the file linearly, loading and executing each referenced skill before proceeding to the next step.

Syntax for Invoking Skills

To chain a skill, use the exact syntax:

Apply the **skill-name** skill:

Replace skill-name with the directory name of the skill (e.g., brainstorm-ideas-new, pricing-strategy). The colons and bold formatting are required for the parser to identify the directive. Place each invocation on its own line, or separate them with explanatory text.

Linear Execution and Checkpoints

The AI assistant respects the linear order of skill invocations as they appear in the markdown file. You can insert checkpoints—optional decision points where the user selects a path—before the next skill runs. For example, you might present two options after ideation, then branch to identify-assumptions-existing or identify-assumptions-new based on user input.

Real-World Example: The /discover Command

The built-in /discover command in pm-product-discovery/commands/discover.md demonstrates a six-skill chain that executes a full product discovery cycle. Lines 35–70 of this file define the following sequence:

### Step 2: Brainstorm Ideas (Divergent Phase)

Apply the **brainstorm-ideas-existing** or **brainstorm-ideas-new** skill:

...

### Step 3: Identify Assumptions (Critical Thinking Phase)

Apply the **identify-assumptions-existing** or **identify-assumptions-new** skill:

...

### Step 4: Prioritize Assumptions (Focus Phase)

Apply the **prioritize-assumptions** skill:

...

### Step 5: Design Experiments (Validation Phase)

Apply **brainstorm-experiments-existing** or **brainstorm-experiments-new** skill:

When a user invokes /discover, the assistant runs each skill in this order, carrying the output of ideation into assumption identification, then into prioritization, and finally into experiment design.

Creating Your Own Custom Command Workflow

Follow these steps to create a new workflow that chains any combination of existing skills.

1. Navigate to a plugin directory (e.g., pm-go-to-market) or create a new plugin folder under plugins/.
2. Create a new markdown file in commands/, such as my-workflow.md.
3. Add front-matter (optional) describing the command's purpose and expected arguments.
4. Write the Workflow section, listing each skill invocation using the Apply the **skill-name** skill: syntax.
5. Insert checkpoints between skills if you need user confirmation or branching logic.

Custom Command Skeleton

Save this template as plugins/pm-go-to-market/commands/quick-launch.md:

---
description: Quick launch checklist – pricing → GTM → post‑launch metrics
argument-hint: "<product name>"
---

# /quick-launch

## Invocation

/quick-launch AI‑driven analytics dashboard

## Workflow

### 1️⃣ Pricing Model

Apply the **pricing-strategy** skill:

### 2️⃣ GTM Plan

Apply the **gtm-strategy** skill:

### 3️⃣ Metrics Dashboard

Apply the **north-star-metric** skill:

Running /quick-launch automatically invokes the three skills in the defined order, passing context sequentially from pricing strategy through go-to-market planning to metric definition.

Why This Data-Driven Architecture Works

The pm-skills system enables skill chaining through three core design principles:

• Declarative Configuration: Command files are data, not code. You modify markdown to change workflows, eliminating the need for redeployment or compilation.
• Skill Reusability: The same skill can be invoked from multiple commands. For example, pricing-strategy appears in both standalone /pricing commands and complex multi-skill workflows.
• Runtime Agnosticism: Any AI assistant that parses the markdown syntax—Claude, Gemini, or OpenCode—can execute the chain, making the workflows portable across different AI environments.

Summary

• Chaining skills requires creating a command markdown file with sequential "Apply the skill-name skill" directives.
• Commands live in plugins/<plugin>/commands/ and orchestrate skills located in plugins/<plugin>/skills/.
• The /discover command in pm-product-discovery/commands/discover.md provides a working template that chains ideation, assumption identification, prioritization, and experiment design.
• Custom workflows are created by writing new markdown files without changing the underlying skill source code.
• Checkpoints allow for user-driven branching between skills while maintaining the overall workflow structure.

Frequently Asked Questions

Can I branch conditionally between skills in a command?

Yes. Insert checkpoints—text prompts that ask users to choose a path—between skill invocations. Based on the user's selection, the workflow proceeds to the appropriate next skill (e.g., choosing between brainstorm-ideas-existing or brainstorm-ideas-new). The linear file structure remains, but execution follows the selected branch.

How do I pass data between skills in a chain?

The AI assistant maintains context across the session. When skill A completes, its output remains in the conversation context, allowing skill B to reference those results naturally. There is no explicit variable passing syntax; the assistant treats the workflow as a continuous conversation thread.

Can I use skills from different plugins in one custom command?

Yes. While skills are organized under specific plugins for logical grouping, a command can reference any skill by its full reference name. Ensure the skill name matches the directory name in plugins/<any-plugin>/skills/<skill-name>/.

What happens if a skill fails during execution?

If a skill produces an error or incomplete output, the AI assistant typically pauses and reports the issue to the user. The workflow does not automatically proceed to the next skill. You can retry the failed step or modify the input before continuing the chain, ensuring data quality between workflow stages.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}