Skill vs Command in PM Skills: What Is the Difference Between a Skill and a Command?

In the PM Skills Marketplace, skills are atomic building blocks of product management knowledge that can be invoked implicitly or explicitly, while commands are user-triggered workflows invoked with a slash prefix that chain multiple skills into complete end-to-end processes.

The phuryn/pm-skills repository implements an AI-driven marketplace for product management workflows. Understanding what is the difference between a skill and a command is essential for leveraging the platform's modular architecture. These complementary concepts separate atomic knowledge units from orchestrated automation layers.

What Is a Skill in PM Skills?

Purpose and Definition

A skill encodes a single piece of product management knowledge, framework, or guided workflow. According to the repository's README, "Skills are the building blocks of the marketplace… Some skills also work as reusable foundations that multiple commands share." Each skill handles one atomic operation, such as generating ideas with brainstorm-ideas-new, mapping assumptions with identify-assumptions-new, or drafting specific PRD sections.

Skill definitions reside in plugins/<plugin-name>/skills/* directories, such as pm-product-discovery/skills/brainstorm-ideas-new/README.md.

How Skills Are Loaded and Invoked

Skills support flexible invocation patterns. They are auto-loaded when Claude detects relevant context in the conversation, or you can force-load them using /plugin-name:skill-name or /skill-name syntax. Unlike commands, skills do not require a leading slash when invoked implicitly through natural conversation.

What Is a Command in PM Skills?

Purpose and Definition

A command represents a user-triggered end-to-end workflow that chains one or more skills together. The README defines commands as "user-triggered workflows invoked with /command-name. They chain one or more skills into an end-to-end process." Commands cover complete product management phases like discovery, strategy, or execution.

Command implementations live in plugins/<plugin-name>/commands/* directories, such as pm-product-discovery/commands/discover/README.md.

How Commands Are Triggered

Commands are explicitly user-triggered and always require a slash prefix. They are not loaded automatically; you must deliberately invoke them using syntax like /discover or /write-prd to initiate the predefined skill chain.

What Is the Difference Between a Skill and a Command?

The distinction between these concepts spans granularity, invocation methods, and architectural roles.

Aspect	Skill	Command
Granularity	Atomic, single operation (e.g., brainstorming ideas)	Orchestrated, multi-step workflow (e.g., full discovery phase)
Invocation	Implicit auto-load or explicit without /	Explicit with / prefix only
Loading Behavior	Auto-loaded when relevant or force-loaded	User-triggered only
Reusability	Shared across multiple commands	Specific orchestration instance
Source Location	plugins/<plugin-name>/skills/*	plugins/<plugin-name>/commands/*

As implemented in phuryn/pm-skills, skills provide the reusable intelligence while commands provide the workflow orchestration.

Practical Usage Examples

Invoking a Skill Directly

When you ask a specific question requiring domain knowledge, Claude implicitly invokes the relevant skill without requiring slash syntax:

What are the riskiest assumptions for our AI writing assistant idea?

Claude automatically invokes the identify-assumptions-new skill behind the scenes.

Running a Command Workflow

To execute a complete discovery process that chains multiple skills, use the slash command:

/discover AI-powered meeting summarizer for remote teams

The /discover command runs a predefined sequence: brainstorm-ideas-new → identify-assumptions-new → prioritize-assumptions → brainstorm-experiments-new.

Repository Structure and Source Files

The codebase enforces this separation through directory organization:

• Skills: plugins/<plugin-name>/skills/* (e.g., pm-product-discovery/skills/brainstorm-ideas-new/README.md)
• Commands: plugins/<plugin-name>/commands/* (e.g., pm-product-discovery/commands/discover/README.md)

This structure ensures skills remain atomic and reusable while commands maintain their orchestration logic in dedicated directories.

Summary

• Skills are atomic units of product management knowledge that handle single operations like ideation or assumption mapping.
• Commands are slash-prefixed workflows that chain multiple skills into complete end-to-end processes.
• Skills auto-load based on context or force-load via specific syntax, while commands require explicit user invocation with /.
• The repository separates these concerns: skills live in skills/ directories, commands in commands/ directories.
• Skills maximize reusability across different commands, enabling modular workflow construction.

Frequently Asked Questions

Can a skill be used without a command?

Yes. Skills can be invoked directly in conversation either implicitly when Claude detects relevant context or explicitly using the /plugin-name:skill-name syntax. They function as standalone units of knowledge without requiring command orchestration.

How do I know when to use a slash command versus letting skills auto-load?

Use slash commands when you need a complete end-to-end workflow like discovery or PRD writing. Allow skills to auto-load when you have specific, atomic questions that don't require multi-step orchestration, such as asking for prioritization frameworks or brainstorming individual ideas.

Can I create custom commands that reuse existing skills?

Yes. The repository architecture encourages skill reuse across multiple commands. You can define new command implementations in plugins/<plugin-name>/commands/* that reference existing skills in plugins/<plugin-name>/skills/*, creating custom workflows that leverage the marketplace's modular building blocks.

What is the performance difference between invoking skills directly versus through commands?

There is no inherent performance penalty; commands simply provide orchestration logic. When you invoke /discover, the system sequentially executes the chained skills. Direct skill invocation skips the orchestration layer but provides less structured workflow automation.

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