# Difference Between a Skill and a Command in PM Skills > Understand the core difference between PM skills and commands. Learn how skills represent expertise and commands orchestrate workflows for project management. - Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills) - Tags: deep-dive - Published: 2026-06-19 --- **A skill is an atomic knowledge unit that encodes focused domain expertise, while a command is a user-triggered workflow that orchestrates one or more skills into a complete end-to-end process.** The `phuryn/pm-skills` repository structures product management automation around three core concepts: **Skills**, **Commands**, and **Plugins**. Understanding the difference between a skill and a command in PM Skills is essential for leveraging the toolkit effectively, as each serves distinct architectural purposes within the AI assistant integration. While skills provide the underlying knowledge repositories, commands serve as the user-facing entry points that assemble that knowledge into practical workflows. ## What Is a Skill? A **skill** is the atomic knowledge unit within the PM Skills architecture. Each skill encodes a specific product management framework, analysis method, or writing guideline that provides focused domain expertise. Skills are designed to load automatically when Claude (or another AI assistant) detects that the conversation content would benefit from that specific expertise. No explicit user invocation is required for automatic loading. However, users can force a skill to load using a prefix syntax such as `/plugin-name:skill-name` or simply `/skill-name`. According to the repository structure, skill definitions reside in dedicated 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 detailed instructions the AI follows when reviewing a product management resume, including evaluation criteria and output formatting guidelines. ## What Is a Command? A **command** is a user-triggered workflow that orchestrates skills into a scripted sequence. Unlike skills, which provide passive knowledge, commands are active processes invoked with a leading slash (`/`) that collect input, call relevant skills, format output, and suggest follow-up actions. Commands stitch together multiple skills to deliver complete end-to-end processes. For instance, the `/review-resume` command defined in [`pm-toolkit/commands/review-resume.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/commands/review-resume.md) parses the input resume, executes the `review-resume` skill, and produces a structured scorecard with improvement suggestions. The command architecture handles workflow orchestration: gathering user inputs, sequencing skill calls, and formatting the final output for consumption. ## Key Architectural Differences The architectural split between these components can be summarized as follows: - **Activation**: Skills load automatically based on context or when forced with a prefix; commands require explicit user invocation with `/command-name`. - **Scope**: Skills contain reusable knowledge units; commands implement complete workflows. - **Composition**: A skill operates as a single expertise unit; a command chains multiple skills (and potentially other logic) into a process. - **User Interface**: Skills function as background expertise; commands serve as the primary user-facing entry points. ## Practical Usage Examples The following examples demonstrate how skills and commands interact in practice. ### Direct Skill Invocation When you need to force a specific skill without the orchestration logic of a command: ```markdown User: /review-resume "Here is my resume..." Claude: (loads the `review-resume` skill automatically and returns the review.) ``` This bypasses the command workflow and invokes the skill's expertise directly. ### Command Orchestration When running a complete workflow that chains multiple skills: ```markdown User: /discover AI-powered meeting summarizer Claude: Executes the `brainstorm-ideas`, `identify-assumptions`, `prioritize-assumptions`, and `brainstorm-experiments` skills in sequence, then returns the full discovery output. ``` The `/discover` command internally manages the execution order and data flow between four distinct skills to complete the product discovery workflow. ## File Structure and Implementation The repository separates these concerns at the file system level: - **Skill definitions**: Located in `pm-toolkit/skills//SKILL.md`, these files contain the detailed instructions, constraints, and knowledge models that define the skill's behavior. - **Command definitions**: Stored in `pm-toolkit/commands/.md`, these files declare the command interface, workflow steps, parameter handling, and skill invocation logic. This separation ensures that skills remain reusable across multiple commands while commands focus on user interaction patterns and workflow orchestration. ## Summary - **Skills** are atomic knowledge units that encode domain expertise and load automatically when relevant to the conversation context. - **Commands** are user-triggered workflows that orchestrate one or more skills into complete end-to-end processes. - **Invocation**: Skills can be forced with `/skill-name` syntax, while commands use `/command-name` to execute scripted sequences. - **Architecture**: The repository separates skills (in `pm-toolkit/skills/`) from commands (in `pm-toolkit/commands/`) to maintain clean separation between knowledge and workflow logic. ## Frequently Asked Questions ### How do I force a specific skill to load without using a command? You can force a skill to load by using the prefix syntax `/plugin-name:skill-name` or simply `/skill-name` followed by your input. This triggers the skill directly without the orchestration logic, input collection, or formatting steps that a command would provide. ### Can a command use multiple skills simultaneously? Yes, commands are designed to orchestrate multiple skills into a single workflow. For example, the `/discover` command chains together the `brainstorm-ideas`, `identify-assumptions`, `prioritize-assumptions`, and `brainstorm-experiments` skills in sequence to deliver a complete product discovery process. ### What is the difference between automatic skill loading and command invocation? Automatic skill loading occurs when Claude detects that conversation content would benefit from a specific expertise domain, loading the skill without explicit user action. Command invocation requires the user to type `/command-name` and triggers a scripted workflow that may include multiple steps, inputs, and skill calls. ### Where are skill definitions stored compared to command definitions? Skill definitions are stored in `pm-toolkit/skills//SKILL.md` files, containing the detailed instructions and knowledge models. Command definitions are stored in `pm-toolkit/commands/.md` files, containing the workflow orchestration logic and user interface specifications.