How to Create a Custom Command that Chains Multiple PM Skills Together

Creating a custom command in the PM Skills Marketplace requires adding a Markdown file with YAML front matter to a plugin's commands/ directory that references skills using the **Apply the <skill-name> skill** pattern, which Claude automatically loads and executes in sequence.

The phuryn/pm-skills repository provides a framework for product management workflows where commands orchestrate reusable skills. When you create a custom command that chains multiple PM skills together, you build a Markdown file that defines how Claude sequentially applies specialized capabilities, passing context between each step. This architecture allows you to construct complex workflows—such as discovery sprints or go-to-market launches—without writing any executable code.

Understanding the PM Skills Architecture

The repository organizes functionality into plugins, each following a strict directory convention. Skills reside in reusable modules while commands act as orchestrators.

The architecture follows this structure:

pm-<plugin>/
├── skills/
│   └── <skill-name>/
│       └── SKILL.md          # Reusable skill definition

└── commands/
    └── <command-name>.md     # Command that chains skills

Skills are pure Markdown definitions stored in pm-<plugin>/skills/<skill-name>/SKILL.md. These files describe frameworks like brainstorm-ideas-new or ideal-customer-profile that Claude can invoke independently.

Commands are Markdown files stored in pm-<plugin>/commands/<command-name>.md. Each command contains a YAML front-matter block describing its purpose, followed by a workflow section that references one or more skills. When Claude parses the command, it discovers every skill mentioned in the workflow, loads them automatically, and executes them in order, passing intermediate results via conversation context.

Step-by-Step: Create a Custom Command

1. Select Your Plugin Directory

Identify or create a plugin folder prefixed with pm-. Commands must live within a specific plugin's commands/ subdirectory, while the skills they reference typically reside in that same plugin's skills/ folder or can be referenced from other plugins.

2. Create the Command Markdown File

Create a new file in pm-<plugin>/commands/. The filename determines the command invocation. For example, creating pm-go-to-market/commands/quick-launch.md enables the /quick-launch command.

3. Define the Command Metadata

Start the file with a YAML front-matter block describing the command's purpose and expected arguments:

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

4. Write the Workflow Section

Reference skills using the bold pattern **Apply the <skill-name> skill** anywhere in the Markdown text. Claude automatically detects these references and loads the corresponding skill files from the skills/ directory.

Structure the workflow using headers to separate steps:

## Workflow

### Step 1: Build the Ideal Customer Profile

Apply the **ideal-customer-profile** skill to define demographics and JTBD.

### Step 2: Draft the GTM Strategy

Apply the **gtm-strategy** skill using the ICP from Step 1.

### Step 3: Design a Growth Loop

Apply the **growth-loops** skill to propose sustainable growth mechanisms.

5. Add Checkpoints for User Input (Optional)

Insert checkpoints to pause execution and request user input before proceeding to the next skill. This creates interactive workflows where users validate outputs or provide additional context mid-chain.

6. Save and Deploy

Save the file. The command becomes instantly available to Claude-Code, Claude-Cowork, or any assistant that loads the plugin. No compilation or registration step is required.

Real-World Reference: The /discover Command

The pm-product-discovery plugin demonstrates production-grade skill chaining in pm-product-discovery/commands/discover.md. This command chains four distinct skills:

1. brainstorm-ideas-new – Generates initial product concepts
2. identify-assumptions-new – Extracts underlying assumptions from the ideas
3. prioritize-assumptions – Ranks assumptions by risk and impact
4. brainstorm-experiments-new – Designs experiments to validate top assumptions

When a user invokes /discover, Claude executes these skills sequentially. The output from the brainstorming phase feeds into the assumption identification, whose results flow into prioritization, and finally into experiment design. This demonstrates how complex product discovery workflows are composed declaratively through Markdown.

Complete Implementation: Building a /quick-launch Command

Below is a minimal working example creating a /quick-launch command that chains three skills from the go-to-market plugin.

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

---
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

Combine all three sections into a single Markdown document:

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 a user types /quick-launch MyProduct, Claude will:

1. Load ideal-customer-profile from pm-go-to-market/skills/ideal-customer-profile/SKILL.md, run it, and store the result.
2. Pass that result to gtm-strategy from pm-go-to-market/skills/gtm-strategy/SKILL.md, which builds the launch plan.
3. Feed the GTM output into growth-loops from pm-go-to-market/skills/growth-loops/SKILL.md and present the combined document.

How Data Flows Between Chained Skills

The PM Skills Marketplace handles data flow implicitly through conversation context. Each skill's output becomes the next skill's input automatically—no explicit variable passing or piping syntax is required.

When brainstorm-ideas-new completes in the /discover command, its generated content remains in the conversation context. The subsequent identify-assumptions-new skill receives that context and extracts assumptions from the previously generated ideas. This hand-off continues through the entire chain until the final skill produces the ultimate output.

If you need to force load a specific skill explicitly outside of the automatic pattern, use the syntax /plugin-name:skill-name.

Summary

• Commands are Markdown files in pm-<plugin>/commands/ that orchestrate workflows.
• Skills are reusable Markdown definitions in pm-<plugin>/skills/<skill-name>/SKILL.md.
• Use the pattern **Apply the <skill-name> skill** to trigger automatic skill loading and chaining.
• Data passes between skills automatically via conversation context.
• No code compilation is required; saving the Markdown file makes the command immediately available.

Frequently Asked Questions

Do I need to write code to create a custom command?

No. Commands are pure Markdown files. You only need to create a file with YAML front matter describing the command, followed by a workflow section that references skills using the bold **Apply the <skill-name> skill** pattern. The marketplace interprets this Markdown and handles the execution logic automatically.

How does Claude know which skills to load?

Claude parses the command file and automatically loads any skill referenced in the text using the standard pattern. When you write "Apply the ideal-customer-profile skill", Claude locates pm-go-to-market/skills/ideal-customer-profile/SKILL.md and loads it. You can also force load skills using the /plugin-name:skill-name syntax if needed.

Can I chain skills from different plugins?

Yes. While commands typically reside within a specific plugin's directory, they can reference skills from other plugins by using the explicit loading syntax or by ensuring the target plugin is available in the workspace. The skills do not need to be in the same pm-<plugin> folder as the command file.

What happens if a skill requires user input mid-workflow?

The workflow pauses at checkpoints where user input is requested. After the user provides the required information, the command resumes execution and proceeds to the next skill in the chain. This allows for interactive validation of intermediate outputs before continuing the automated workflow.

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