# How Skills and Commands Work Together in the PM Skills Architecture > Understand how PM Skills architecture combines modular skills and user-triggered commands for seamless product management workflows. Learn to orchestrate tasks effectively. - Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills) - Tags: architecture - Published: 2026-06-11 --- **Skills are modular building blocks that encode domain knowledge, while commands are user-triggered workflows that orchestrate multiple skills into complete product management tasks.** The `phuryn/pm-skills` repository implements a modular architecture that cleanly separates domain intelligence from procedural workflows. Understanding how skills and commands work together in the PM Skills architecture enables developers to compose reusable AI-driven product management tools without duplicating logic. This separation allows the marketplace to grow organically, with new skills added independently of existing commands. ## Core Architecture: Skills vs. Commands ### What Are Skills? Skills are standalone markdown files located under `pm-*/skills/.../SKILL.md` that encapsulate specific frameworks, analyses, or knowledge domains. Each skill functions as a **reusable intelligence module** that the system auto-loads when detecting relevant conversation context, or that users can force explicitly using slash-prefixed syntax (e.g., `/brainstorm-ideas-new` or `/plugin-name:skill-name`). According to the repository's README, skills encode product-management knowledge as **modular building blocks** that remain language-agnostic and work across Claude, Gemini, OpenCode, and other AI agents. ### What Are Commands? Commands are orchestration scripts defined in markdown files under `pm-*/commands/...md`. They represent **end-to-end workflows** triggered by leading-slash syntax (e.g., `/discover`, `/strategy`). Unlike skills, commands do not contain domain logic directly; instead, they act as scripts that chain together one or more skills to achieve multi-step processes, passing the output of each skill as input to the next. ## The Interaction Model: Chaining and Data Flow When a user invokes a command, the architecture executes its constituent skills in strict sequence. The system passes the **output of one skill as the input to the next**, creating a seamless pipeline that transforms raw input into structured deliverables. For example, when running `/discover AI-powered meeting summarizer for remote teams`, the command triggers four skills in order: `brainstorm-ideas-new` → `identify-assumptions-new` → `prioritize-assumptions` → `brainstorm-experiments-new`. Each step receives the context produced by the previous skill, ultimately returning a complete discovery output. After execution, commands suggest the next logical workflow, creating guided user experiences while reusing the same skill definitions across many commands. ## Implementation Examples from Source Code ### Skill Definition: brainstorm-ideas-new The `brainstorm-ideas-new` skill demonstrates the single-responsibility pattern. Located at [`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), it contains focused instructions for generating product ideas without workflow logic: ```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 is language-agnostic and can be consumed by any AI agent that reads markdown instructions. ### Command Definition: /discover The `/discover` command orchestrates multiple skills into a complete discovery cycle. Defined in [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md), it chains four distinct skills: ```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 ``` When invoked, this command file instructs the system to execute each skill sequentially, creating a multi-step process while the individual skills remain reusable by other commands. ### Direct Skill Invocation Users can bypass command orchestration and load skills directly using `/skill-name` syntax. For example, `/product-vision` forces the `product-vision` skill to load immediately 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), useful when needing specific frameworks without executing a full workflow chain. ## Key Files and Directory Structure The repository organizes skills and commands to maintain strict separation of concerns: - **[`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)**: Encodes the brainstorming framework as a reusable skill. - **[`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md)**: Defines the `/discover` workflow orchestration. - **[`pm-toolkit/skills/review-resume/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/skills/review-resume/SKILL.md)**: Demonstrates cross-domain skill reusability outside product discovery. - **[`pm-toolkit/commands/review-resume.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/commands/review-resume.md)**: Shows simple command-to-skill forwarding for the resume review workflow. - **[`README.md`](https://github.com/phuryn/pm-skills/blob/main/README.md)**: Contains the "How It Works (Skills, Commands, Plugins)" section explaining the high-level architecture and interaction model. ## Summary - **Skills** are modular markdown files containing domain-specific knowledge and frameworks, stored under `pm-*/skills/`. - **Commands** are user-triggered workflows defined under `pm-*/commands/` that chain multiple skills into end-to-end processes. - Data flows sequentially through skill chains, with each skill's output feeding into the next skill's input. - Skills are language-agnostic and work across AI platforms, while commands use Claude-specific slash syntax. - The architecture enables organic growth: developers add new skills without changing existing commands, and compose new commands from any combination of existing skills. ## Frequently Asked Questions ### How do skills load automatically in the PM Skills architecture? Skills auto-load when the model detects that their domain knowledge is relevant to the current conversation context. Users can also force immediate loading by typing a slash-prefixed skill name (e.g., `/brainstorm-ideas-new`), which bypasses the auto-detection logic and immediately injects the skill's framework into the conversation. ### Can PM Skills commands be used with AI models other than Claude? Commands are Claude-specific implementations that rely on slash-command syntax. While other AI agents can read the command markdown files, they must translate the workflow definitions into their own native orchestration language. However, the underlying skills are language-agnostic markdown files that work with Claude, Gemini, OpenCode, and other AI systems without modification. ### What is the difference between `/discover` and `/brainstorm-ideas-new` syntax? `/discover` invokes a **command** that orchestrates multiple skills into a complete workflow, whereas `/brainstorm-ideas-new` invokes a single **skill** directly. Use command syntax when you need multi-step processes with sequential execution, and skill syntax when you need a specific framework or analysis tool without the surrounding workflow orchestration. ### How do I create a new command that uses existing skills? Create a new markdown file under the appropriate `pm-*/commands/` directory (e.g., [`pm-product-strategy/commands/my-command.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-strategy/commands/my-command.md)). Define the command name with a leading slash in the H1 heading, then list the skills to invoke in sequence. The system automatically chains these skills, passing context between them according to the standard output-to-input flow defined in the PM Skills architecture.