How to Chain Multiple Skills Together in PM Skills: A Complete Guide

In PM Skills, you chain multiple skills together by creating a command (a verb-style workflow) that lists the sequence of skills to execute in its Workflow section, effectively turning individual noun-style skills into an end-to-end process.

PM Skills is an open-source plugin framework designed to streamline product management workflows. The repository phuryn/pm-skills organizes functionality into two distinct artifact types that work together to create powerful, automated workflows. Understanding how to chain multiple skills together allows you to build sophisticated, multi-step processes that run with a single slash command.

Understanding the Core Architecture: Skills vs Commands

The PM Skills framework maintains a strict separation between skills and commands, a concept documented in CLAUDE.md and the root README.md.

Skills are noun-style building blocks that encapsulate domain-specific knowledge. They reside in pm-<domain>/skills/<skill-name>/SKILL.md and automatically load when Claude detects relevant trigger phrases. For example, brainstorm-ideas-existing, identify-assumptions-new, and prioritize-assumptions are individual skills that handle specific cognitive tasks.

Commands are verb-style workflows that users invoke with a leading slash (e.g., /discover). According to the repository's design principles, commands function as declarative scripts that wire together a series of skills. A command file located at pm-<domain>/commands/<command>.md contains a Workflow section that explicitly defines the sequence of skills to execute, creating the chaining mechanism.

How the Chaining Mechanism Works

When you chain multiple skills together in PM Skills, the execution follows a predictable pipeline orchestrated by the command file:

1. User invokes the command by typing a slash command such as /discover AI-powered meeting summarizer. The command file's front-matter tells Claude which workflow to initialize.

2. Command reads its workflow from the Workflow section inside the command markdown. This section enumerates each skill to call, in order. For instance, the /discover command in pm-product-discovery/commands/discover.md defines a workflow that alternates between idea generation and assumption validation.

3. Each skill executes sequentially. When a skill is invoked, Claude loads its front-matter (name, description) and executes the body of the corresponding SKILL.md file. The skill may ask follow-up questions, generate output, or request files.

4. Checkpoints provide user control. After each skill execution, the command can pause for user confirmation before proceeding to the next skill in the chain, as implemented in discover.md between lines 41-66.

5. Final artifact assembly. When the last skill completes, the command assembles a consolidated document and offers next-step commands.

Examining the Built-in Discovery Workflow

The /discover command in pm-product-discovery/commands/discover.md demonstrates a complete skill chain for product discovery. This command chains multiple skills together to transform a raw product idea into a validated discovery plan.

The workflow defined in discover.md (lines 33-70) executes the following sequence:

Workflow:
1. Apply `brainstorm-ideas-existing` or `brainstorm-ideas-new` skill
2. Run `identify-assumptions-existing` or `identify-assumptions-new` skill  
3. Execute `prioritize-assumptions` skill
4. Run `brainstorm-experiments-existing` or `brainstorm-experiments-new` skill

When you invoke /discover with a product concept, the system automatically:

• Generates initial ideas using the appropriate brainstorm skill
• Surfaces critical assumptions using the identification skill
• Prioritizes those assumptions using the dedicated prioritization skill
• Designs experiments to validate the top assumptions

The command concludes by assembling a consolidated discovery plan and offering next-step commands, as documented in lines 77-92 of discover.md.

Creating a Custom Command to Chain Skills

You can create custom commands to chain any combination of skills for your specific workflow. Custom commands follow the same structure as built-in commands, residing in pm-<domain>/commands/<command-name>.md.

Here is an example of a custom command that chains three skills for rapid pivot analysis:

---
description: Run a rapid pivot analysis by chaining three skills
argument-hint: "<product idea>"
---

# /quick-pivot -- Rapid Pivot Analysis

## Workflow

1. Apply `product-vision` skill to restate the vision.
2. Run `swot-analysis` skill to surface strengths & threats.
3. Run `opportunity-solution-tree` skill to map new opportunities.

When a user types /quick-pivot "enterprise SaaS feature", the system executes the product-vision skill first, followed by swot-analysis, then opportunity-solution-tree, producing a concise pivot report derived from the outputs of all three skills.

Summary

• Commands are verbs, skills are nouns: Commands orchestrate workflows while skills contain domain knowledge.
• Chaining happens in the Workflow section: The command markdown file lists skills in execution order under a Workflow heading.
• File locations matter: Skills live at pm-<domain>/skills/<skill>/SKILL.md while commands live at pm-<domain>/commands/<command>.md.
• Checkpoints enable human-in-the-loop: Commands can pause between skills for user confirmation before continuing the chain.
• Final artifacts consolidate outputs: The command assembles outputs from all chained skills into a unified deliverable.

Frequently Asked Questions

What is the difference between a skill and a command in PM Skills?

Skills are noun-style building blocks stored in SKILL.md files that contain specific domain knowledge and automatically load when triggered. Commands are verb-style workflows invoked with a slash (e.g., /discover) that explicitly list which skills to execute and in what order, effectively chaining multiple skills into an end-to-end process as defined in CLAUDE.md.

How do I create a custom command that chains skills?

Create a new markdown file in pm-<domain>/commands/<command-name>.md with front-matter containing description and argument-hint fields. Include a Workflow section that lists the skills to execute in numbered order. The system will execute each skill sequentially when the slash command is invoked.

Can I add checkpoints between skills in a command chain?

Yes, commands support checkpoints that pause execution for user confirmation before proceeding to the next skill. The /discover command in pm-product-discovery/commands/discover.md demonstrates this pattern between lines 41-66, asking questions like "Which ideas should we stress-test?" before continuing to the next skill in the workflow.

Where are skill and command files stored in the repository?

Skills are stored in pm-<domain>/skills/<skill-name>/SKILL.md directories, while commands are stored as individual markdown files at pm-<domain>/commands/<command-name>.md. This separation maintains clean organization between the noun-style skill definitions and verb-style command orchestrations, as documented in the root README.md (lines 43-45).

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