# Difference Between Skills and Commands in the PM Skills Marketplace

> Understand the difference between Skills and Commands in the PM Skills marketplace. Learn how skills automate tasks and commands orchestrate workflows for efficient product management.

- Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills)
- Tags: how-to-guide
- Published: 2026-06-22

---

**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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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:

```text
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`](https://github.com/phuryn/pm-skills/blob/main/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:

```text
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`](https://github.com/phuryn/pm-skills/blob/main/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:

```text
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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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).