How Skills and Commands Differ in PM Skills Marketplace: Architecture and Usage

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

The PM Skills Marketplace repository (phuryn/pm-skills) organizes product management expertise into two distinct architectural layers. Understanding how skills and commands differ is essential for leveraging the platform effectively, whether you need quick reference information or guided multi-step workflows.

Core Architectural Definitions

What Is a Skill?

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 README.md (lines 32-46), skills can be invoked automatically when the model detects a relevant query, or users can call them directly by name. Each skill lives in a */skills/*/SKILL.md file that describes its purpose, inputs, and output format.

Skills function as the atomic building blocks of domain knowledge. For example, the identify-assumptions-new skill located at pm-product-discovery/skills/identify-assumptions-new/SKILL.md contains structured logic for extracting riskiest assumptions from product concepts without requiring a predefined workflow.

What Is a Command?

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 the entry points for complete workflows and must be explicitly invoked with a leading slash. Unlike skills, commands do not contain domain knowledge themselves; instead, they orchestrate existing skills to deliver finished products.

The command definitions reside in */commands/*.md files. For instance, the /discover command defined in pm-product-discovery/commands/discover.md chains multiple discovery skills into a comprehensive product exploration pipeline.

Key Differences: Loading Mechanisms and Reusability

Automatic vs Explicit Loading

Skills load automatically when the conversation requires underlying domain knowledge. The model detects contextual cues and pulls the relevant skill files without user intervention. Users can also force-load skills using prefixed syntax (/plugin-name:skill-name) or direct naming (/skill-name).

Commands require explicit invocation through slash syntax. Once triggered, commands may suggest subsequent commands, guiding users through full PM pipelines. This architectural distinction ensures that skills provide ambient intelligence while commands deliver structured experiences.

Reusability vs Orchestration

Many skills are reusable across multiple commands. The prioritization-frameworks skill in pm-execution/skills/prioritization-frameworks/SKILL.md serves both /write-prd and /discover commands, providing ICE, RICE, and MoSCoW frameworks wherever prioritization logic is needed. Some skills operate purely as reference material that Claude draws upon whenever appropriate, independent of any command workflow.

Commands chain skills to deliver compiled results. The /discover workflow demonstrates this orchestration by sequentially invoking brainstorm-ideas, identify-assumptions, prioritize-assumptions, and brainstorm-experiments skills to produce a complete discovery package.

Practical Usage Patterns

Automatic Skill Invocation

When users ask specific analytical questions, the system automatically loads relevant skills without slash commands:

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 interaction automatically loads the identify-assumptions-new skill from pm-product-discovery/skills/identify-assumptions-new/SKILL.md, returning structured analysis without workflow overhead.

Explicit Command Execution

For structured multi-step processes, commands provide guided 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 defined in pm-product-discovery/commands/discover.md executes this skill chain, prompting at each stage and compiling intermediate outputs into a final deliverable.

Forced Skill Loading

Users can bypass automatic detection and explicitly load reference skills:

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

This prefixed syntax forces the prioritization-frameworks skill to load from pm-execution/skills/prioritization-frameworks/SKILL.md, useful when you need specific framework documentation outside of command workflows.

File Structure and Implementation

The repository maintains strict separation between these concepts through file organization:

• Skill definitions: */skills/*/SKILL.md — Each skill owns its directory containing implementation logic and documentation
• Command definitions: */commands/*.md — Each command file outlines orchestration logic and slash-syntax invocation patterns

For example, pm-toolkit/commands/review-resume.md implements the /review-resume command by utilizing the underlying review-resume skill, demonstrating how commands act as interfaces while skills contain the actual domain expertise.

Summary

• Skills are self-contained knowledge units in */skills/*/SKILL.md that encode frameworks and can be auto-invoked or forced via prefix syntax
• Commands are slash-triggered workflows in */commands/*.md that chain multiple skills into structured end-to-end processes
• Skills emphasize reusability across multiple commands, while commands emphasize orchestration of sequential skill execution
• Skills load automatically based on context; commands require explicit /command-name invocation
• The prioritization-frameworks skill demonstrates cross-cutting reusability, while /discover demonstrates command-level orchestration

Frequently Asked Questions

Can I use a skill without invoking a command?

Yes. Skills function independently as reference materials and analytical tools. The model automatically loads relevant skills like identify-assumptions-new when it detects applicable queries, or you can force-load them using /skill-name syntax. This allows quick access to specific frameworks without running full command workflows.

How do I know whether to use a skill or a command?

Use commands when you need structured, multi-step workflows that guide you through complete processes like product discovery or PRD writing. Use skills directly when you need specific analysis, frameworks, or reference information without the overhead of a guided workflow. According to the repository structure, commands exist in */commands/*.md while skills live in */skills/*/SKILL.md.

Can commands share skills across different PM domains?

Yes. Skills are designed for reusability across command boundaries. The prioritization-frameworks skill in pm-execution/skills/prioritization-frameworks/SKILL.md serves multiple commands including /write-prd and /discover, allowing consistent prioritization methodology across different product management phases without code duplication.

What happens if a command references a skill that doesn't exist?

The system relies on the file structure defined in phuryn/pm-skills. Commands reference skills by name based on the */skills/*/SKILL.md pattern. If a referenced skill is missing, the command workflow would fail to load that specific skill's knowledge, though the repository maintains complete skill catalogs for each command to prevent this scenario.

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