# How Skill Chaining Enables Multi-Step Workflows Like /discover in PM-Skills > Discover how skill chaining connects modules into multi step workflows like /discover in PM-Skills. Automate complex tasks without custom code. Learn more today. - Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills) - Tags: deep-dive - Published: 2026-06-24 --- **Skill chaining connects reusable skill modules into sequential workflows where each step's output becomes the next step's input, enabling complex commands like `/discover` to execute without bespoke glue code.** The `phuryn/pm-skills` repository implements a modular architecture where **skill chaining** transforms individual capabilities into comprehensive product management workflows. By treating commands as verbs that orchestrate self-contained skills, the system eliminates code duplication while supporting 42 distinct multi-step workflows across nine plugin domains. ## What Is Skill Chaining in PM-Skills? ### Skills as Atomic Units Each skill is the smallest reusable unit of logic, encapsulated in its own directory with a [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) specification file. For example, `brainstorm-ideas-new`, `identify-assumptions-new`, and `prioritize-assumptions` each handle discrete tasks independently. These skills reside in `pm-product-discovery/skills/` and expose a standardized interface that accepts context and returns structured results. ### Commands as Orchestration Verbs Commands like `/discover` and `/plan-launch` are defined in markdown files under `pm-product-discovery/commands/` (e.g., [`discover.md`](https://github.com/phuryn/pm-skills/blob/main/discover.md)). According to the architecture specification in [`CLAUDE.md`](https://github.com/phuryn/pm-skills/blob/main/CLAUDE.md), a command is explicitly defined as a verb that chains one or more skills. The command markdown contains no executable logic—only a declarative sequence of skill references that the engine resolves at runtime. ## How the /discover Command Executes a Skill Chain When a user invokes `/discover Smart notification system for our project-management tool`, the engine executes a five-phase pipeline: 1. **Parse the Command Definition** – The system loads [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md), which defines the workflow as a sequence of four specific skills. 2. **Execute the First Skill** – The engine runs `brainstorm-ideas-new` (or `brainstorm-ideas-existing` depending on context), which returns a list of product ideas. 3. **Feed Results Forward** – The output from step 2 passes as input to `identify-assumptions-new`, which extracts and structures assumptions from the selected ideas. 4. **Iterate Through Remaining Steps** – The chain continues with `prioritize-assumptions`, followed by `brainstorm-experiments-new`, each consuming the previous step's accumulated context. 5. **Aggregate Final Artifacts** – After the last skill completes, the command assembles the outputs into a cohesive discovery plan document formatted in Markdown and returns it to the user. This sequential execution model ensures that complex workflows remain composable and maintainable. ## Implementation Architecture The chaining mechanism relies on a context-passing pattern where each skill updates a shared context dictionary. The pseudo-code in the repository illustrates this flow: ```python def run_command(command_name, args): steps = COMMAND_DEFINITIONS[command_name].steps # read from .md context = {"user_input": args} for step in steps: skill = load_skill(step.name) # e.g. "brainstorm-ideas-new" context = skill.run(context) # each skill returns updated context return render_output(context) # final discovery plan ``` Because skills are self-contained and communicate only through the context object, the same skill can participate in multiple command workflows without modification. This architecture supports 42 different chained workflows across nine plugins while maintaining a DRY (Don't Repeat Yourself) codebase. ## Key Files and Skill Definitions The `/discover` command chains four specific skills defined in the following locations: - [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md) – Defines the four-step workflow orchestration. - [`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) – Generates initial product ideas from multiple perspectives. - [`pm-product-discovery/skills/identify-assumptions-new/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/skills/identify-assumptions-new/SKILL.md) – Extracts underlying assumptions from the generated ideas. - [`pm-product-discovery/skills/prioritize-assumptions/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/skills/prioritize-assumptions/SKILL.md) – Ranks assumptions by impact and risk. - [`pm-product-discovery/skills/brainstorm-experiments-new/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/skills/brainstorm-experiments-new/SKILL.md) – Designs validation experiments for high-priority assumptions. Each skill directory contains a [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) file specifying its inputs, outputs, and internal logic, ensuring clear contracts between chained components. ## Summary - **Skill chaining** connects discrete, reusable skills into sequential workflows where output from one step becomes input for the next. - Commands like `/discover` are defined declaratively in markdown files (e.g., [`discover.md`](https://github.com/phuryn/pm-skills/blob/main/discover.md)) that specify skill sequences without containing executable logic. - The `phuryn/pm-skills` repository implements 42 chained workflows across nine plugins using this architecture. - Skills are self-contained units with standardized interfaces defined in [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) files, enabling reuse across multiple commands. - Context passing between skills eliminates the need for bespoke glue code while maintaining workflow flexibility. ## Frequently Asked Questions ### What is the difference between a skill and a command in PM-Skills? A **skill** is a self-contained unit of logic that performs a specific task (like generating ideas or prioritizing assumptions), defined in its own [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) file. A **command** is a user-facing verb (like `/discover`) that orchestrates multiple skills into a sequential workflow by referencing them in a command markdown file. ### How does skill chaining handle data flow between steps? Each skill receives a shared context dictionary containing the accumulated outputs from previous steps. After execution, the skill returns an updated context with its results appended. The engine passes this updated context to the next skill in the chain, creating a pipeline where data flows transparently without explicit wiring code. ### Can I customize the /discover workflow without modifying source code? Yes. Since command definitions live in markdown files like [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md), you can reorder, add, or remove skill references by editing the declarative workflow definition. The skills themselves remain unchanged, and the engine automatically resolves the new sequence at runtime. ### Where is the skill chaining architecture formally specified? The architecture is formally defined in [`CLAUDE.md`](https://github.com/phuryn/pm-skills/blob/main/CLAUDE.md) at the repository root, which specifies that commands are verbs that chain one or more skills. This specification document governs how the 42 workflows across nine plugins are structured and executed.