Skills vs Commands in PM Skills: Understanding the Core Architecture

Skills are self-contained knowledge units that encode product-management frameworks, while commands are user-triggered slash-commands that orchestrate multiple skills into end-to-end workflows.

The phuryn/pm-skills repository implements a modular architecture distinguishing between skills and commands to separate domain knowledge from workflow orchestration. Understanding the difference between skills and commands in PM Skills is essential for effectively leveraging the marketplace's automated assistance and structured discovery processes.

What Are Skills in PM Skills?

A skill is a self-contained knowledge unit that encodes a proven product-management framework, analysis method, or guided workflow. According to the repository's source code, skills reside in */skills/*/SKILL.md files that describe their purpose, inputs, and output format.

Skills load automatically when the conversation requires underlying domain knowledge. The model detects relevant queries and invokes the appropriate skill without explicit user instruction. For example, when asking about riskiest assumptions, the system automatically loads identify-assumptions-new from pm-product-discovery/skills/identify-assumptions-new/SKILL.md.

Skills are designed for reusability across multiple workflows. The prioritization-frameworks skill in pm-execution/skills/prioritization-frameworks/SKILL.md serves as a reference guide used by both /write-prd and /discover commands, as well as being available for direct invocation.

What Are Commands in PM Skills?

A command is a user-triggered slash-command (/command-name) that strings together one or more skills into an end-to-end process. Commands serve as entry points for complete workflows and must be explicitly invoked with a leading slash.

Unlike skills, commands do not load automatically. Once executed, they may suggest the next relevant command, guiding users through a full PM pipeline. Each command definition lives in a */commands/*.md file that outlines the orchestration logic and slash-syntax.

The /discover command defined in pm-product-discovery/commands/discover.md exemplifies this by chaining four distinct skills: brainstorm-ideas, identify-assumptions, prioritize-assumptions, and brainstorm-experiments to deliver a compiled discovery package.

Key Differences Between Skills and Commands

The architectural distinction between these components determines how users interact with the PM Skills marketplace:

• Invocation: Skills trigger automatically based on context or via prefixed syntax (/skill-name), while commands require explicit slash-command entry (/discover).
• Loading Mechanism: Skills load automatically when the model detects relevant queries; commands load only upon explicit user request.
• Scope: Skills provide discrete knowledge units; commands chain multiple skills to deliver finished products.
• Reusability: Skills are reusable across commands, while commands represent specific workflow sequences.

Practical Usage Examples

Invoking a Skill Directly

When asking a natural question, the model automatically selects the appropriate 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"
  ]
}

This automatically invokes the identify-assumptions-new skill from pm-product-discovery/skills/identify-assumptions-new/SKILL.md.

Running a Command Workflow

Commands initiate structured multi-step processes:

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 orchestrates this sequence as defined in pm-product-discovery/commands/discover.md.

Forcing Skill Loading with Prefix Syntax

You can force a specific skill to load using prefixed syntax:

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

This syntax bypasses auto-detection and directly loads the prioritization-frameworks skill from pm-execution/skills/prioritization-frameworks/SKILL.md.

File Structure and Source Organization

The repository separates these components into distinct directory structures:

• Skills: */skills/*/SKILL.md files contain framework definitions, input specifications, and output formats. Example: pm-product-discovery/skills/identify-assumptions-new/SKILL.md.
• Commands: */commands/*.md files contain orchestration logic and slash-command definitions. Example: pm-product-discovery/commands/discover.md and pm-toolkit/commands/review-resume.md.

This separation enables the marketplace to maintain clean boundaries between knowledge units and workflow implementations.

Summary

• Skills are self-contained knowledge units encoding product-management frameworks, stored in */skills/*/SKILL.md files, and loaded automatically or via prefixed syntax.
• Commands are slash-command entry points (/command-name) that chain multiple skills into end-to-end workflows, defined in */commands/*.md files.
• Skills emphasize reusability across multiple commands, while commands emphasize orchestration of complete processes.
• The /discover command in pm-product-discovery/commands/discover.md demonstrates command functionality by chaining four skills to produce a discovery package.
• The prioritization-frameworks skill in pm-execution/skills/prioritization-frameworks/SKILL.md illustrates skill reusability across different command workflows.

Frequently Asked Questions

Can skills be used without commands?

Yes. Skills can be invoked automatically when the model detects a relevant query, or you can force them to load using prefixed syntax like /pm-product-discovery:prioritization-frameworks. Some skills function as pure reference materials that Claude draws upon whenever appropriate, without requiring any command wrapper.

How do I know which command chains which skills?

Each command's documentation in */commands/*.md files outlines the specific orchestration logic and skill sequence. For example, pm-product-discovery/commands/discover.md explicitly documents that it chains brainstorm-ideas, identify-assumptions, prioritize-assumptions, and brainstorm-experiments to complete the discovery workflow.

Can I create custom commands that reuse existing skills?

Yes. The architecture encourages skill reusability across multiple commands. You can define new commands in */commands/*.md files that reference existing skills from the */skills/ directories, such as incorporating prioritization-frameworks from pm-execution/skills/prioritization-frameworks/SKILL.md into custom workflows.

What is the relationship between plugins and skills?

Skills can be forced to load using a prefixed plugin name syntax: /plugin-name:skill-name. This indicates that skills are organized within plugin namespaces, allowing for explicit addressing of specific skill implementations when automatic detection is insufficient or when targeting a particular domain framework.

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