Difference Between Skills and Commands in the PM Skills Marketplace

Skills are self-contained knowledge units that encode product management frameworks and can be invoked automatically or by name, while Commands are explicit slash-command entry points that orchestrate multiple skills into complete end-to-end workflows.

The PM Skills Marketplace (phuryn/pm-skills) structures product management expertise into modular components that operate at two distinct levels. Understanding the architectural distinction between these building blocks allows you to leverage quick reference information on demand or execute structured multi-step processes.

Core Definitions

Skills: Modular Knowledge Units

A skill is a self-contained module that encapsulates a proven product management framework, analysis method, or guided workflow. Stored in */skills/*/SKILL.md files throughout the repository, each skill functions as a discrete unit of expertise. For example, pm-product-discovery/skills/identify-assumptions-new/SKILL.md contains the logic for extracting riskiest assumptions from product ideas, while pm-execution/skills/prioritization-frameworks/SKILL.md defines reference materials for ICE, RICE, and MoSCoW methodologies.

Skills are designed for automatic loading when the model detects a relevant query context. They can also be forced to load using prefixed plugin syntax (/plugin-name:skill-name) or direct invocation (/skill-name). Many skills serve as pure reference materials that the system draws upon whenever appropriate, independent of any specific command workflow.

Commands: Workflow Entry Points

A command is a user-triggered slash-command (formatted as /command-name) that strings together one or more skills into a cohesive process. Defined in */commands/*.md files such as pm-product-discovery/commands/discover.md, commands represent the primary entry points for complete product management workflows. Unlike skills, commands must be explicitly invoked with a leading slash and cannot trigger automatically.

Commands function as orchestration layers. When you run /discover, the system chains multiple skills—brainstorm-ideas, identify-assumptions, prioritize-assumptions, and brainstorm-experiments—to produce a structured discovery package. Similarly, pm-toolkit/commands/review-resume.md demonstrates how commands wrap specific skills to deliver targeted outputs.

Loading Patterns and Invocation

Automatic versus Explicit Loading

Skills support contextual loading. When you ask, "What are the riskiest assumptions for our AI-writing-assistant product?" the system automatically invokes the identify-assumptions-new skill without requiring explicit syntax. This behavior is defined in the repository's README.md under the How It Works section.

Commands require explicit invocation. You must type the full slash-command syntax to trigger the workflow. Once initiated, a command may suggest subsequent commands to guide you through a complete PM pipeline, but it never runs without direct user input.

Forced Skill Loading

You can override automatic detection and 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 directly targets pm-execution/skills/prioritization-frameworks/SKILL.md, bypassing the automatic inference engine.

Reusability and Composition

Skills as Reusable Components

Individual skills are highly reusable across multiple command workflows. The prioritization-frameworks skill, for instance, is utilized by both /write-prd and /discover commands. This modular approach ensures that foundational knowledge—such as prioritization matrices or assumption identification techniques—remains consistent across different stages of the product lifecycle.

Commands as Orchestration Chains

Commands chain skills to deliver finished products. The /discover command does not contain the analysis logic itself; instead, it orchestrates the execution of four distinct skills in sequence, prompting at each stage and compiling the outputs into a unified result. This separation of concerns allows domain experts to refine individual skills while workflow designers compose them into complex processes.

Practical Usage Examples

Using a Skill Directly

When the model detects a relevant query, it loads the appropriate skill automatically:

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 invokes pm-product-discovery/skills/identify-assumptions-new/SKILL.md directly without requiring a slash-command.

Running a Complete Workflow

Commands initiate structured processes that coordinate multiple skills:

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 command defined in pm-product-discovery/commands/discover.md manages the state transitions between these distinct skill invocations.

Summary

• Skills are atomic knowledge units stored in */skills/*/SKILL.md files that encode specific frameworks and can be invoked automatically or by explicit name.
• Commands are user-triggered slash-commands defined in */commands/*.md files that orchestrate multiple skills into end-to-end workflows.
• Skills load automatically based on conversation context or via forced prefix syntax (/plugin:skill-name), while commands require explicit /command-name invocation.
• Skills are designed for reusability across multiple commands, whereas commands chain skills to deliver complete process outcomes.

Frequently Asked Questions

Can I use a Skill without running a Command?

Yes. Skills can operate independently of commands. When you ask a specific question that matches a skill's domain, the system automatically loads the relevant SKILL.md file and returns the structured knowledge. Some skills function purely as reference materials that Claude draws upon whenever appropriate, without requiring any command wrapper.

How do Commands chain multiple Skills together?

Commands contain orchestration logic that specifies the sequence of skill invocations. For example, the /discover command sequentially invokes brainstorm-ideas, identify-assumptions, prioritize-assumptions, and brainstorm-experiments, passing context between each stage. This chaining is defined in the command's markdown file, which acts as a workflow blueprint rather than containing the analytical logic itself.

What is the difference between automatic and forced Skill loading?

Automatic loading occurs when the model detects conversation context that matches a skill's purpose, requiring no special syntax. Forced loading requires you to specify the skill explicitly using either /skill-name or the prefixed format /plugin-name:skill-name. The prefixed syntax is particularly useful when you need to access a specific skill that might not trigger automatically due to ambiguous context.

When should I use a Skill versus a Command?

Use a Skill when you need specific reference information, quick analysis, or answers to targeted questions (e.g., "List prioritization frameworks"). Use a Command when you need to execute a complete workflow that requires multiple analytical steps, user inputs at various stages, or a compiled final deliverable (e.g., running /discover to generate a full product discovery package).

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