# Skill vs Command in PM Skills: What Is the Difference Between a Skill and a Command? > Learn the difference between PM skills and commands. Skills are atomic knowledge blocks, while commands are user-triggered workflows chaining skills for end-to-end processes. Understand PM skills today. - Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills) - Tags: deep-dive - Published: 2026-06-28 --- **In the PM Skills Marketplace, skills are atomic building blocks of product management knowledge that can be invoked implicitly or explicitly, while commands are user-triggered workflows invoked with a slash prefix that chain multiple skills into complete end-to-end processes.** The `phuryn/pm-skills` repository implements an AI-driven marketplace for product management workflows. Understanding what is the difference between a skill and a command is essential for leveraging the platform's modular architecture. These complementary concepts separate atomic knowledge units from orchestrated automation layers. ## What Is a Skill in PM Skills? ### Purpose and Definition A **skill** encodes a single piece of product management knowledge, framework, or guided workflow. According to the repository's README, "Skills are the building blocks of the marketplace… Some skills also work as reusable foundations that multiple commands share." Each skill handles one atomic operation, such as generating ideas with `brainstorm-ideas-new`, mapping assumptions with `identify-assumptions-new`, or drafting specific PRD sections. Skill definitions reside in `plugins//skills/*` directories, such as [`pm-product-discovery/skills/brainstorm-ideas-new/README.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/skills/brainstorm-ideas-new/README.md). ### How Skills Are Loaded and Invoked Skills support flexible invocation patterns. They are **auto-loaded** when Claude detects relevant context in the conversation, or you can force-load them using `/plugin-name:skill-name` or `/skill-name` syntax. Unlike commands, skills do not require a leading slash when invoked implicitly through natural conversation. ## What Is a Command in PM Skills? ### Purpose and Definition A **command** represents a user-triggered end-to-end workflow that **chains one or more skills together**. The README defines commands as "user-triggered workflows invoked with `/command-name`. They chain one or more skills into an end-to-end process." Commands cover complete product management phases like discovery, strategy, or execution. Command implementations live in `plugins//commands/*` directories, such as [`pm-product-discovery/commands/discover/README.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover/README.md). ### How Commands Are Triggered Commands are **explicitly user-triggered** and always require a slash prefix. They are not loaded automatically; you must deliberately invoke them using syntax like `/discover` or `/write-prd` to initiate the predefined skill chain. ## What Is the Difference Between a Skill and a Command? The distinction between these concepts spans granularity, invocation methods, and architectural roles. | Aspect | Skill | Command | |--------|-------|---------| | **Granularity** | Atomic, single operation (e.g., brainstorming ideas) | Orchestrated, multi-step workflow (e.g., full discovery phase) | | **Invocation** | Implicit auto-load or explicit without `/` | Explicit with `/` prefix only | | **Loading Behavior** | Auto-loaded when relevant or force-loaded | User-triggered only | | **Reusability** | Shared across multiple commands | Specific orchestration instance | | **Source Location** | `plugins//skills/*` | `plugins//commands/*` | As implemented in `phuryn/pm-skills`, skills provide the reusable intelligence while commands provide the workflow orchestration. ## Practical Usage Examples ### Invoking a Skill Directly When you ask a specific question requiring domain knowledge, Claude implicitly invokes the relevant skill without requiring slash syntax: ```markdown What are the riskiest assumptions for our AI writing assistant idea? ``` Claude automatically invokes the `identify-assumptions-new` skill behind the scenes. ### Running a Command Workflow To execute a complete discovery process that chains multiple skills, use the slash command: ```markdown /discover AI-powered meeting summarizer for remote teams ``` The `/discover` command runs a predefined sequence: `brainstorm-ideas-new → identify-assumptions-new → prioritize-assumptions → brainstorm-experiments-new`. ## Repository Structure and Source Files The codebase enforces this separation through directory organization: - **Skills**: `plugins//skills/*` (e.g., [`pm-product-discovery/skills/brainstorm-ideas-new/README.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/skills/brainstorm-ideas-new/README.md)) - **Commands**: `plugins//commands/*` (e.g., [`pm-product-discovery/commands/discover/README.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover/README.md)) This structure ensures skills remain atomic and reusable while commands maintain their orchestration logic in dedicated directories. ## Summary - **Skills** are atomic units of product management knowledge that handle single operations like ideation or assumption mapping. - **Commands** are slash-prefixed workflows that chain multiple skills into complete end-to-end processes. - Skills auto-load based on context or force-load via specific syntax, while commands require explicit user invocation with `/`. - The repository separates these concerns: skills live in `skills/` directories, commands in `commands/` directories. - Skills maximize reusability across different commands, enabling modular workflow construction. ## Frequently Asked Questions ### Can a skill be used without a command? Yes. Skills can be invoked directly in conversation either implicitly when Claude detects relevant context or explicitly using the `/plugin-name:skill-name` syntax. They function as standalone units of knowledge without requiring command orchestration. ### How do I know when to use a slash command versus letting skills auto-load? Use slash commands when you need a complete end-to-end workflow like discovery or PRD writing. Allow skills to auto-load when you have specific, atomic questions that don't require multi-step orchestration, such as asking for prioritization frameworks or brainstorming individual ideas. ### Can I create custom commands that reuse existing skills? Yes. The repository architecture encourages skill reuse across multiple commands. You can define new command implementations in `plugins//commands/*` that reference existing skills in `plugins//skills/*`, creating custom workflows that leverage the marketplace's modular building blocks. ### What is the performance difference between invoking skills directly versus through commands? There is no inherent performance penalty; commands simply provide orchestration logic. When you invoke `/discover`, the system sequentially executes the chained skills. Direct skill invocation skips the orchestration layer but provides less structured workflow automation.