# How to Chain Multiple Skills Together in a Custom Command in PM Skills > Learn to chain multiple skills in PM Skills custom commands. Master sequential skill execution by creating Markdown files and passing data via conversation context. - Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills) - Tags: how-to-guide - Published: 2026-06-17 --- **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**` 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-/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-/skills//SKILL.md`. These files contain pure Markdown descriptions of specific product management frameworks that Claude can invoke independently. **Command definitions** reside in `pm-/commands/.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**` 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-` 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-/commands/.md`. The file must begin with a YAML front-matter block describing the command: ```markdown --- description: End-to-end workflow that chains multiple skills argument-hint: "" --- ``` ### Step 3: Define the Workflow Section Write a Markdown workflow section that calls each skill using the `**Apply the skill**` pattern. List the skills in the order you want them executed. For example, to chain four discovery skills together: ```markdown ## 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`](https://github.com/phuryn/pm-skills/blob/main/pm-go-to-market/commands/quick-launch.md) with this content: ```markdown --- description: End‑to‑end launch workflow that builds an ICP, a GTM plan, and a growth loop argument-hint: "" --- # /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`](https://github.com/phuryn/pm-skills/blob/main/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 ` 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-/commands/` that orchestrate skills - **Skills** are reusable frameworks stored in `pm-/skills//SKILL.md` - Use the `**Apply the 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**` 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.