How to Chain Multiple Skills Together in a Custom Command in PM Skills

You chain multiple skills in PM Skills by creating a Markdown file in a plugin's commands/ directory that references each skill using the **Apply the <skill-name> skill** pattern, allowing Claude to execute them sequentially while passing data through conversation context.

The PM Skills Marketplace framework lets you orchestrate complex product management workflows by combining reusable skills into custom commands. According to the phuryn/pm-skills repository, a command is simply a Markdown file stored in pm-<plugin>/commands/ that sequences one or more skills from the corresponding skills/ directory. When you invoke a command like /discover, Claude automatically loads the referenced skills and executes them in order, making it easy to build sophisticated workflows without writing code.

Understanding the PM Skills Architecture

Before chaining skills, you need to understand how the marketplace organizes its components. The repository follows a strict folder convention where skills are reusable frameworks and commands are orchestration layer.

Skill definitions live in pm-<plugin>/skills/<skill-name>/SKILL.md. These files contain pure Markdown descriptions of specific product management frameworks that Claude can invoke independently.

Command definitions reside in pm-<plugin>/commands/<command-name>.md. These files contain YAML front-matter describing the command metadata, followed by a Markdown workflow section that references skills using the **Apply the <skill-name> skill** pattern.

When Claude parses a command file, it discovers every skill referenced in the workflow text, loads them from the skills/ directory, and executes them in sequence. Intermediate results pass automatically through conversation context, with each skill's output becoming the next skill's input.

Creating a Custom Command That Chains Multiple Skills

To build your own command that chains multiple PM Skills together, follow these steps:

Step 1: Select Your Plugin Directory

Choose an existing plugin folder (such as pm-product-discovery or pm-go-to-market) or create a new one following the pm-<plugin> naming convention. Commands live in the commands/ subdirectory, while reusable skills reside in skills/.

Step 2: Create the Command Markdown File

Create a new file in pm-<plugin>/commands/<command-name>.md. The file must begin with a YAML front-matter block describing the command:

---
description: End-to-end workflow that chains multiple skills
argument-hint: "<product name>"
---

Step 3: Define the Workflow Section

Write a Markdown workflow section that calls each skill using the **Apply the <skill-name> skill** pattern. List the skills in the order you want them executed. For example, to chain four discovery skills together:

## Workflow

Apply the **brainstorm-ideas-new** skill to generate potential solutions.

Apply the **identify-assumptions-new** skill to extract key assumptions from the generated ideas.

Apply the **prioritize-assumptions** skill to rank assumptions by risk and impact.

Apply the **brainstorm-experiments-new** skill to design validation experiments for top assumptions.

Step 4: Add Optional Checkpoints

Insert checkpoints between skill calls to ask the user for input before proceeding to the next skill. This creates decision points in your workflow where users can review intermediate outputs or provide additional context.

Real-World Example: Building a /quick-launch Command

The following example demonstrates how to create a /quick-launch command that chains three skills from the Go-to-Market plugin: ideal-customer-profile, gtm-strategy, and growth-loops.

Create the file pm-go-to-market/commands/quick-launch.md with this content:

---
description: End‑to‑end launch workflow that builds an ICP, a GTM plan, and a growth loop
argument-hint: "<product name>"
---

# /quick-launch – Fast Go‑to‑Market Launch

> Quickly generate a market‑ready launch package.

## Invocation

/quick-launch Super‑AI Writing Assistant

## Workflow

### Step 1: Build the Ideal Customer Profile

Apply the **ideal-customer-profile** skill:

- Ask the user for the product name (already provided) and primary market.
- Generate an ICP with demographics, behaviors, JTBD, and needs.

### Step 2: Draft the GTM Strategy

Apply the **gtm-strategy** skill:

- Use the ICP from Step 1.
- Produce a channel mix, messaging pillars, success metrics, and a launch timeline.

### Step 3: Design a Growth Loop

Apply the **growth-loops** skill:

- Based on the GTM plan, suggest a self‑reinforcing loop (e.g., referral‑driven, content‑driven).
- Include high‑level tactics and effort estimates.

## Output

Quick Launch Package for Super‑AI Writing Assistant

Ideal Customer Profile

...

GTM Strategy

...

Growth Loop

...

Save the tailored launch package as a Markdown file in the user’s workspace.

When you run /quick-launch, Claude executes ideal-customer-profile first, passes that output to gtm-strategy, then feeds the resulting strategy into growth-loops, presenting the final combined document.

How Data Flows Between Chained Skills

Data hand-off between skills occurs via conversation context. When the first skill completes, its output remains in the conversation history, becoming available as context for the next skill's prompts.

This architecture means you don't need explicit variable passing or data pipelines. The /discover command in pm-product-discovery/commands/discover.md demonstrates this pattern: it chains brainstorm-ideas-new → identify-assumptions-new → prioritize-assumptions → brainstorm-experiments-new, with each step building upon the previous results naturally.

Testing Your Custom Command

To verify your chained workflow functions correctly:

1. Install the plugin containing your new command (e.g., pm-go-to-market)
2. Place your command file in pm-go-to-market/commands/
3. In Claude-Code or Claude-Cowork, type /quick-launch <product-name>
4. Observe the three skill sections executing in order and the final markdown output

The command becomes instantly available to any assistant that loads the plugin, with no additional compilation or deployment steps required.

Summary

• Commands are Markdown files in pm-<plugin>/commands/ that orchestrate skills
• Skills are reusable frameworks stored in pm-<plugin>/skills/<skill-name>/SKILL.md
• Use the **Apply the <skill-name> skill** pattern to reference skills in your workflow
• Skills execute sequentially, with data passing automatically through conversation context
• Add checkpoints between skills to create user decision points
• The /discover command in pm-product-discovery provides a reference implementation chaining four skills

Frequently Asked Questions

How does PM Skills know which skills to load for a command?

Claude automatically discovers and loads any skill mentioned in the command's Markdown text using the **Apply the <skill-name> skill** pattern. You can also force loading with /plugin-name:skill-name if you need to reference a skill without using the standard pattern, though the automatic discovery handles most use cases.

Can I chain skills from different plugins in one command?

Yes, you can reference skills across plugin boundaries. The marketplace resolves skill names based on the conversation context and available plugins. However, keeping related skills within the same plugin directory (e.g., pm-product-discovery) ensures better organization and reduces naming conflicts.

What happens if a skill fails during the chain execution?

If a skill encounters an error or produces unexpected output, the workflow pauses at that checkpoint. Since skills communicate via conversation context, you can review the intermediate output, provide corrections, and manually continue the chain, or modify the command file to adjust the skill parameters.

Do I need to configure data passing between skills manually?

No. The PM Skills Marketplace handles data flow implicitly through the conversation context. Each skill's output becomes part of the conversation history, which the next skill accesses automatically. This design eliminates the need for explicit data mapping or variable binding between steps.

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