# How to Chain Multiple Skills Together in PM Skills: A Complete Guide > Learn how to chain multiple skills together in PM Skills by creating commands that define your workflow. Master building end-to-end processes with this complete guide. - Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills) - Tags: how-to-guide - Published: 2026-07-06 --- **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`](https://github.com/phuryn/pm-skills/blob/main/CLAUDE.md) and the root [`README.md`](https://github.com/phuryn/pm-skills/blob/main/README.md). **Skills** are noun-style building blocks that encapsulate domain-specific knowledge. They reside in `pm-/skills//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-/commands/.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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/discover.md) (lines 33-70) executes the following sequence: ```markdown 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`](https://github.com/phuryn/pm-skills/blob/main/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-/commands/.md`. Here is an example of a custom command that chains three skills for rapid pivot analysis: ```markdown --- description: Run a rapid pivot analysis by chaining three skills argument-hint: "" --- # /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-/skills//SKILL.md` while commands live at `pm-/commands/.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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/CLAUDE.md). ### How do I create a custom command that chains skills? Create a new markdown file in `pm-/commands/.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`](https://github.com/phuryn/pm-skills/blob/main/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-/skills//SKILL.md` directories, while commands are stored as individual markdown files at `pm-/commands/.md`. This separation maintains clean organization between the noun-style skill definitions and verb-style command orchestrations, as documented in the root [`README.md`](https://github.com/phuryn/pm-skills/blob/main/README.md) (lines 43-45).