# How Commands Work in the PM Skills Marketplace: Chaining Skills for Product Management Workflows > Discover how user-triggered commands chain skills in the PM Skills Marketplace. Create sequential pipelines for product management workflows, passing skill outputs as inputs for seamless task execution. - Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills) - Tags: how-to-guide - Published: 2026-06-21 --- **Commands in the PM Skills Marketplace are user-triggered workflows that chain multiple skills into sequential pipelines, passing the output of each skill as input to the next to execute complete product management tasks.** The `phuryn/pm-skills` repository implements a modular AI architecture where reusable knowledge blocks called **skills** are orchestrated by **commands** to automate complex product management workflows. Understanding how commands work in the PM Skills Marketplace reveals a clean separation between domain intelligence and process execution, enabling composable AI-driven product development. ## Skills vs. Commands: The Core Architecture The PM Skills Marketplace organizes functionality into two distinct layers that work together to deliver end-to-end value. ### What Are Skills? **Skills** are modular building blocks that encode product management knowledge, frameworks, and guided workflows. Each skill is defined as a Markdown file stored under `pm-*/skills/…/SKILL.md` directories, containing system prompts and instructions for specific tasks like brainstorming ideas or identifying assumptions. Skills function as standalone, reusable components that the system auto-loads when their domain knowledge is relevant, or that users can force-load explicitly using slash-prefixed syntax (e.g., `/skill-name` or `/plugin-name:skill-name`). ### What Are Commands? **Commands** are user-triggered end-to-end workflows defined in Markdown files under `pm-*/commands/…md`. Unlike skills, which represent single capabilities, commands are scripts that orchestrate multiple skills into complete business processes. When a user invokes a command with a leading slash (e.g., `/discover` or `/strategy`), the system executes each chained skill in sequence, transforming individual AI capabilities into comprehensive product management workflows. ## How Commands Chain Skills in the PM Skills Marketplace Commands achieve complex multi-step processes by **passing the output of one skill as the input to the next**, creating a pipeline that transforms raw user input into structured product management deliverables. Consider the `/discover` command defined in [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md). When executed, it chains four distinct skills in strict order: 1. `brainstorm-ideas-new` 2. `identify-assumptions-new` 3. `prioritize-assumptions` 4. `brainstorm-experiments-new` This sequential execution means the `brainstorm-ideas-new` skill generates initial concepts, which then feed into assumption identification, prioritization, and finally experiment design—all within a single command invocation. ## File Structure and Implementation Examples The repository separates knowledge from process through distinct file locations and formats. ### Skill Definition Example The `brainstorm-ideas-new` skill resides in [`pm-product-discovery/skills/brainstorm-ideas-new/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/skills/brainstorm-ideas-new/SKILL.md) and contains the framework-specific instructions: ```markdown # Brainstorm Ideas (New Products) You are an expert product strategist. Generate 5 distinct ideas for a brand‑new SaaS product that solves a common pain point. ``` This skill file encapsulates the domain expertise for ideation, making it reusable across any command requiring brainstorming capabilities. ### Command Definition Example The corresponding `/discover` command in [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md) references these skills without duplicating their logic: ```markdown # /discover Chains four skills to run a full discovery cycle: 1. brainstorm-ideas-new 2. identify-assumptions-new 3. prioritize-assumptions 4. brainstorm-experiments-new ``` By referencing skill names rather than embedding prompts, commands remain lightweight orchestration layers that delegate specialized work to the skill implementations. ## Invoking Skills and Commands Users interact with the system through explicit slash-syntax invocations that trigger either isolated skills or full command pipelines. ### Running Commands Commands execute complete workflows when called with their slash-prefixed identifiers. For example: ```bash /discover AI-powered meeting summarizer for remote teams ``` This invocation triggers the four-skill chain defined in [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md), ultimately returning a complete discovery output including ideas, assumptions, prioritization, and experiments. ### Direct Skill Loading Users can bypass command orchestration to access individual skills directly: ```bash /product-vision ``` This forces the `product-vision` skill to load from [`pm-product-strategy/skills/product-vision/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-strategy/skills/product-vision/SKILL.md) without the surrounding command workflow, useful when only a specific framework is needed. ## Summary - **Commands** in the `phuryn/pm-skills` repository are Markdown files under `pm-*/commands/…md` that define slash-prefixed workflows chaining multiple skills. - **Skills** are reusable knowledge blocks stored in `pm-*/skills/…/SKILL.md` that execute specific product management tasks. - Commands pass output between skills sequentially, enabling complex multi-step processes like the `/discover` command's four-skill discovery pipeline. - The architecture separates domain knowledge (skills) from process orchestration (commands), allowing the marketplace to grow organically without breaking existing workflows. ## Frequently Asked Questions ### How do I create a custom command that chains existing skills? Create a new Markdown file in the appropriate `pm-*/commands/` directory with a leading slash in the filename (e.g., [`custom-workflow.md`](https://github.com/phuryn/pm-skills/blob/main/custom-workflow.md)). List the skills you want to chain using numbered steps referencing the skill names exactly as they appear in their respective [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) files. The system executes them in the order specified, passing the context generated by each skill to the next. ### Can a command use skills from different product management domains? Yes. Commands can reference any skill available in the repository regardless of its directory location. For example, a command in `pm-product-strategy/commands/` can chain skills from `pm-product-discovery/skills/` and `pm-toolkit/skills/`, enabling cross-domain workflows that combine discovery, strategy, and execution capabilities. ### What happens if a skill fails during command execution? When a command chains multiple skills, each skill receives the output of the previous one as its context. If a skill generates an error or insufficient output, the next skill in the chain receives that potentially degraded context. The repository architecture does not implement explicit error handling guards between skills, so command authors should ensure skills are compatible and test the full pipeline before deployment. ### Are commands portable across different AI platforms? Commands are Claude-specific slash-syntax implementations. While other AI agents can read the command Markdown files and understand the skill chaining logic, they must translate the slash-command syntax into their own workflow language. Skills, however, are language-agnostic and work across Claude, Gemini, OpenCode, and other platforms that can process the Markdown prompt definitions.