# Differences Between Skills and Commands in the PM Skills Plugin Architecture > Understand the key differences between skills and commands in the phuryn/pm-skills plugin architecture. Learn how skills execute tasks and commands orchestrate workflows for product management. - Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills) - Tags: deep-dive - Published: 2026-07-05 --- **Skills are self-contained units of domain knowledge that execute discrete tasks, while commands are orchestrated workflows that chain multiple skills together to solve end-to-end product management problems.** The `phuryn/pm-skills` repository implements a modular plugin architecture that separates reusable expertise from complex multi-step processes. Understanding the differences between these two primitives is essential for effectively using or extending the PM Skills marketplace. ## What Are Skills in the PM Plugin Architecture? A **skill** is a self-contained piece of domain knowledge or a reusable workflow that encodes a specific product-management framework. According to the repository's [`README.md`](https://github.com/phuryn/pm-skills/blob/main/README.md) (lines 32-44), skills include value-proposition templates, SWOT analysis guides, resume-review frameworks, and other discrete PM methodologies. Skills function as atomic units of expertise that can be invoked in two ways: implicitly when the model detects contextual relevance, or explicitly by name without any special prefix. For example, typing `review-resume` triggers the resume review skill directly. The architecture defines skills in individual [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) files within plugin-specific directories, such as [`pm-toolkit/skills/review-resume/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/skills/review-resume/SKILL.md). Key characteristics of skills include: - **Single-purpose focus**: Each skill handles one specific task (e.g., generating a SWOT analysis, brainstorming ideas, or identifying assumptions). - **Automatic loading**: The system can implicitly load skills based on conversation context, even without explicit user invocation. - **Reusability**: Skills are designed to be shared across multiple commands and plugins. ## What Are Commands in the PM Plugin Architecture? A **command** is a user-triggered, higher-level workflow that strings together one or more skills to solve an end-to-end problem. As documented in the [`README.md`](https://github.com/phuryn/pm-skills/blob/main/README.md) (lines 55-62), commands always require explicit invocation with a leading slash (`/`) and drive multi-step interactions. For example, the `/discover` command runs a complete product discovery workflow that internally chains the `brainstorm-ideas`, `identify-assumptions`, `prioritize-assumptions`, and `brainstorm-experiments` skills. Unlike skills, commands are composite operations that manage state across multiple steps and coordinate the execution sequence of underlying skills. Commands are defined in separate markdown files within `commands/` directories, such as [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md) and [`pm-go-to-market/commands/plan-launch.md`](https://github.com/phuryn/pm-skills/blob/main/pm-go-to-market/commands/plan-launch.md). ## Key Differences Between Skills and Commands The architectural distinction between these components can be summarized across four dimensions: | Aspect | Skills | Commands | |--------|--------|----------| | **Purpose** | Provide discrete, reusable expertise (templates, analysis methods, prompts). | Orchestrate complete processes by chaining multiple skills. | | **Invocation** | Implicitly when relevant, or explicitly by name without prefix. | Always explicit via slash command (`/command-name`). | | **Scope** | Single, focused task; shared across many commands. | Composite, multi-step task involving several skills. | | **Marketplace Visibility** | Listed under each plugin's "Skills" section. | Listed under each plugin's "Commands" section. | In the source code, this separation is maintained through distinct directory structures: skills reside in `skills/` subdirectories while commands live in `commands/` subdirectories within each plugin folder. ## Practical Usage Examples ### Direct Skill Invocation You can invoke a skill directly by name without any slash prefix: ```text review-resume ``` The model pulls the `review-resume` skill from [`pm-toolkit/skills/review-resume/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/skills/review-resume/SKILL.md) and returns feedback immediately. This executes as a single, self-contained operation without additional workflow orchestration. ### Running a Command with Skill Chaining Commands use the slash prefix and trigger complex workflows: ```text /discover AI-powered meeting summarizer for remote teams ``` According to the [`README.md`](https://github.com/phuryn/pm-skills/blob/main/README.md) (lines 60-62), this command executes a pipeline that sequentially invokes the `brainstorm-ideas`, `identify-assumptions`, `prioritize-assumptions`, and `brainstorm-experiments` skills to produce a comprehensive discovery output. ### Natural Language Skill Detection Skills can also activate implicitly based on context: ```text I need a SWOT analysis for our new AI-assistant product. ``` The model automatically detects the need for the `swot-analysis` skill and loads it without requiring explicit command syntax, demonstrating the architecture's contextual awareness capabilities. ### Command Reusing Multiple Skills The `/plan-launch` command demonstrates how commands aggregate skills: ```text /plan-launch AI code review tool targeting mid-size engineering teams ``` As defined in [`pm-go-to-market/commands/plan-launch.md`](https://github.com/phuryn/pm-skills/blob/main/pm-go-to-market/commands/plan-launch.md) (referenced in [`README.md`](https://github.com/phuryn/pm-skills/blob/main/README.md) lines 55-57), this command incorporates the `gtm-strategy` skill, the `ideal-customer-profile` skill, and others to generate a comprehensive go-to-market plan. ## Source Code Implementation The differences between skills and commands are reflected in the repository's file structure and configuration files. ### Skill Definition Files Individual skills are defined in [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) files within plugin-specific skill directories. For example, [`pm-toolkit/skills/review-resume/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/skills/review-resume/SKILL.md) contains the complete definition of the resume review capability, including prompts, templates, and execution logic. ### Command Implementation Files Commands are implemented as separate markdown files in `commands/` directories. The file [`pm-toolkit/commands/review-resume.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/commands/review-resume.md) wraps the `review-resume` skill as a slash command, while [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md) implements the multi-skill chaining logic for the discovery workflow. ### Plugin Manifest Configuration The registration of both components occurs in the plugin manifest at [`pm-toolkit/.claude-plugin/plugin.json`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/.claude-plugin/plugin.json). This file registers skill files and command files, making them discoverable within the marketplace while maintaining the architectural separation between reusable knowledge (skills) and orchestrated workflows (commands). ## Summary - **Skills** are atomic units of PM expertise that perform single tasks and can be invoked implicitly or explicitly by name. - **Commands** are slash-prefixed workflows that chain multiple skills to solve complex, end-to-end problems. - **Architecture**: Skills reside in `skills/` directories with [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) files, while commands live in `commands/` directories as separate markdown files. - **Invocation**: Skills use natural language or direct names; commands require the `/` prefix. - **Reusability**: Skills are designed to be shared across commands; commands are specific workflow implementations. ## Frequently Asked Questions ### Can a skill invoke another skill directly? No, skills are designed as atomic units that do not chain other skills. According to the architecture defined in [`README.md`](https://github.com/phuryn/pm-skills/blob/main/README.md), skill composition and orchestration are the responsibility of commands. When you need to combine multiple capabilities, you should implement a command that references the relevant skills in sequence. ### How do I know whether to use a skill or command? Use a **skill** when you need a specific analysis or template (e.g., "create a SWOT analysis" or "review this resume"). Use a **command** when you need a complete workflow that coordinates multiple steps (e.g., `/discover` for full product discovery or `/plan-launch` for go-to-market planning). If the task involves multiple phases or deliverables, use a command. ### Where are skills and commands registered in the codebase? Both are registered in the plugin manifest file at [`pm-toolkit/.claude-plugin/plugin.json`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/.claude-plugin/plugin.json). Skills are defined in [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) files within `skills/` subdirectories (e.g., [`pm-toolkit/skills/review-resume/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/skills/review-resume/SKILL.md)), while commands are defined in markdown files within `commands/` subdirectories (e.g., [`pm-toolkit/commands/review-resume.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/commands/review-resume.md)). ### Can commands exist without skills? While technically possible, commands are architecturally designed to orchestrate skills. A command that doesn't utilize skills would need to implement all logic internally, bypassing the reusable skill framework. The PM Skills architecture encourages commands to leverage existing skills for maintainability and consistency across the marketplace.