What Is the Difference Between Skills and Commands in PM Skills?

Skills are self-contained knowledge units that encode product management frameworks and load automatically based on context, while commands are explicit slash-commands that chain multiple skills into complete end-to-end workflows.

The PM Skills Marketplace (phuryn/pm-skills) organizes product management expertise into two distinct architectural layers. Understanding the difference between skills and commands in PM Skills is essential for effectively leveraging the repository's automated workflows and reusable knowledge components.

What Are Skills?

Skills are self-contained knowledge units that encode proven product-management frameworks, analysis methods, and guided workflows.

Each skill lives in a */skills/*/SKILL.md file, such as pm-product-discovery/skills/identify-assumptions-new/SKILL.md or pm-execution/skills/prioritization-frameworks/SKILL.md. These files define the skill's purpose, inputs, and output format according to the repository's README.

Automatic Loading and Reusability

Skills load automatically when the model detects a relevant query. For example, asking "What are the riskiest assumptions for our AI-writing-assistant product?" triggers the identify-assumptions-new skill without explicit invocation.

Many skills are reusable across multiple commands. The prioritization-frameworks skill, for instance, supports both /write-prd and /discover commands, while some skills function as pure reference material that Claude draws upon whenever appropriate.

What Are Commands?

Commands are user-triggered slash-commands (/command-name) that serve as entry points for complete workflows. Unlike skills, commands must be explicitly invoked with a leading slash.

Each command definition resides in a */commands/*.md file, such as pm-product-discovery/commands/discover.md or pm-toolkit/commands/review-resume.md. These files outline the orchestration logic and the slash-syntax required for invocation.

Skill Chaining and Workflow Orchestration

Commands string together one or more skills into end-to-end processes. When you run /discover AI-powered meeting summarizer, the system executes a full pipeline: brainstorm-ideas → identify-assumptions → prioritize-assumptions → brainstorm-experiments. After execution, commands may suggest the next relevant command to guide users through a complete PM pipeline.

Key Architectural Differences

Invocation Method: Skills load automatically based on context or via prefixed syntax (/skill-name), while commands require explicit slash-commands (/discover).

Scope: Skills represent individual knowledge units (e.g., a specific framework), whereas commands represent complete workflows that chain multiple skills.

File Location: Skills follow the path pattern */skills/*/SKILL.md, while commands follow */commands/*.md.

User Interaction: Skills can operate transparently in the background, while commands always start with explicit user input and may produce compiled results like structured discovery packages or review documents.

Practical Usage Examples

Invoking a Skill Directly

When you ask a contextual question, the model automatically loads the relevant skill:

User: What are the riskiest assumptions for our AI-writing-assistant product?
Claude (skill invoked): 
{
  "assumptions": [
    "Users will adopt the new editor despite existing habits",
    "The AI can generate plagiarism-free content at scale",
    "Privacy regulations will not restrict the data used for training"
  ]
}

The model automatically loads the identify-assumptions-new skill from pm-product-discovery/skills/identify-assumptions-new/SKILL.md.

Running a Command

Commands trigger multi-step workflows:

User: /discover AI-powered meeting summarizer for remote teams
Claude (command workflow):
1. brainstorm-ideas → 2. identify-assumptions → 3. prioritize-assumptions → 4. brainstorm-experiments
Result: A structured discovery package (idea list, assumption map, prioritization matrix, experiment plan).

The /discover command is defined in pm-product-discovery/commands/discover.md.

Forcing Skill Loading

You can force a skill to load using prefixed syntax:

User: /pm-product-discovery:prioritization-frameworks
Claude: (returns the reference guide for ICE, RICE, MoSCoW, etc.)

This syntax forces the prioritization-frameworks skill from pm-execution/skills/prioritization-frameworks/SKILL.md to load even when not auto-triggered.

Summary

• Skills are self-contained knowledge units stored in */skills/*/SKILL.md files that encode product management frameworks and can load automatically based on conversation context.
• Commands are explicit slash-commands defined in */commands/*.md files that chain multiple skills into complete end-to-end workflows.
• Invocation differs: Skills respond to contextual queries or prefixed syntax, while commands require leading slashes like /discover or /review-resume.
• Reusability: Individual skills are reused across multiple commands (e.g., prioritization-frameworks supports both /write-prd and /discover), while commands provide the orchestration layer for user-facing processes.

Frequently Asked Questions

Can skills be used without commands?

Yes. Skills can be invoked automatically when the model detects relevant queries, or you can force them to load using prefixed syntax like /plugin-name:skill-name or simply /skill-name. Some skills function as pure reference material that Claude draws upon whenever appropriate without any command invocation.

How do I force a specific skill to load?

Use the prefixed plugin syntax /plugin-name:skill-name or the direct /skill-name format. For example, typing /pm-product-discovery:prioritization-frameworks forces the system to load the prioritization frameworks skill from pm-execution/skills/prioritization-frameworks/SKILL.md regardless of conversation context.

What happens when I run a command?

When you execute a slash-command like /discover, the system runs an orchestrated workflow defined in the corresponding */commands/*.md file. This typically chains multiple skills sequentially (e.g., brainstorm-ideas → identify-assumptions → prioritize-assumptions) and produces a compiled result, such as a structured discovery package or analysis document.

Are skills reusable across different commands?

Yes. Many skills are designed for reuse across multiple commands. For instance, the prioritization-frameworks skill is utilized by both /write-prd and /discover commands, while the identify-assumptions-new skill supports various discovery workflows. This modular architecture prevents duplication and ensures consistent application of product management frameworks.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}