# What Is the Difference Between Skills and Commands in PM Skills?

> Understand the difference between skills and commands in PM Skills. Skills are context sensitive knowledge units, commands chain skills for workflows. Enhance your PM productivity.

- Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills)
- Tags: internals
- Published: 2026-06-11

---

**Skills are self-contained knowledge units that encode product management frameworks and load automatically based on context, while commands are explicit slash-commands that chain multiple skills into complete end-to-end workflows.**

The PM Skills Marketplace (`phuryn/pm-skills`) organizes product management expertise into two distinct architectural layers. Understanding the difference between skills and commands in PM Skills is essential for effectively leveraging the repository's automated workflows and reusable knowledge components.

## What Are Skills?

Skills are self-contained knowledge units that encode proven product-management frameworks, analysis methods, and guided workflows.

Each skill lives in a `*/skills/*/SKILL.md` file, such as [`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) or [`pm-execution/skills/prioritization-frameworks/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/prioritization-frameworks/SKILL.md). These files define the skill's purpose, inputs, and output format according to the repository's README.

### Automatic Loading and Reusability

Skills load automatically when the model detects a relevant query. For example, asking "What are the riskiest assumptions for our AI-writing-assistant product?" triggers the `identify-assumptions-new` skill without explicit invocation.

Many skills are reusable across multiple commands. The `prioritization-frameworks` skill, for instance, supports both `/write-prd` and `/discover` commands, while some skills function as pure reference material that Claude draws upon whenever appropriate.

## What Are Commands?

Commands are user-triggered slash-commands (`/command-name`) that serve as entry points for complete workflows. Unlike skills, commands must be explicitly invoked with a leading slash.

Each command definition resides in a `*/commands/*.md` file, such as [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md) or [`pm-toolkit/commands/review-resume.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/commands/review-resume.md). These files outline the orchestration logic and the slash-syntax required for invocation.

### Skill Chaining and Workflow Orchestration

Commands string together one or more skills into end-to-end processes. When you run `/discover AI-powered meeting summarizer`, the system executes a full pipeline: `brainstorm-ideas` → `identify-assumptions` → `prioritize-assumptions` → `brainstorm-experiments`. After execution, commands may suggest the next relevant command to guide users through a complete PM pipeline.

## Key Architectural Differences

**Invocation Method**: Skills load automatically based on context or via prefixed syntax (`/skill-name`), while commands require explicit slash-commands (`/discover`).

**Scope**: Skills represent individual knowledge units (e.g., a specific framework), whereas commands represent complete workflows that chain multiple skills.

**File Location**: Skills follow the path pattern `*/skills/*/SKILL.md`, while commands follow `*/commands/*.md`.

**User Interaction**: Skills can operate transparently in the background, while commands always start with explicit user input and may produce compiled results like structured discovery packages or review documents.

## Practical Usage Examples

### Invoking a Skill Directly

When you ask a contextual question, the model automatically loads the relevant skill:

```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"
  ]
}

```

*The model automatically loads the `identify-assumptions-new` skill from [`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).*

### Running a Command

Commands trigger multi-step workflows:

```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 `/discover` command is defined in [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md).*

### Forcing Skill Loading

You can force a 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 forces the `prioritization-frameworks` skill from [`pm-execution/skills/prioritization-frameworks/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/prioritization-frameworks/SKILL.md) to load even when not auto-triggered.*

## Summary

- **Skills** are self-contained knowledge units stored in `*/skills/*/SKILL.md` files that encode product management frameworks and can load automatically based on conversation context.
- **Commands** are explicit slash-commands defined in `*/commands/*.md` files that chain multiple skills into complete end-to-end workflows.
- **Invocation differs**: Skills respond to contextual queries or prefixed syntax, while commands require leading slashes like `/discover` or `/review-resume`.
- **Reusability**: Individual skills are reused across multiple commands (e.g., `prioritization-frameworks` supports both `/write-prd` and `/discover`), while commands provide the orchestration layer for user-facing processes.

## Frequently Asked Questions

### Can skills be used without commands?

Yes. Skills can be invoked automatically when the model detects relevant queries, or you can force them to load using prefixed syntax like `/plugin-name:skill-name` or simply `/skill-name`. Some skills function as pure reference material that Claude draws upon whenever appropriate without any command invocation.

### How do I force a specific skill to load?

Use the prefixed plugin syntax `/plugin-name:skill-name` or the direct `/skill-name` format. For example, typing `/pm-product-discovery:prioritization-frameworks` forces the system to load the prioritization frameworks skill from [`pm-execution/skills/prioritization-frameworks/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/prioritization-frameworks/SKILL.md) regardless of conversation context.

### What happens when I run a command?

When you execute a slash-command like `/discover`, the system runs an orchestrated workflow defined in the corresponding `*/commands/*.md` file. This typically chains multiple skills sequentially (e.g., `brainstorm-ideas` → `identify-assumptions` → `prioritize-assumptions`) and produces a compiled result, such as a structured discovery package or analysis document.

### Are skills reusable across different commands?

Yes. Many skills are designed for reuse across multiple commands. For instance, the `prioritization-frameworks` skill is utilized by both `/write-prd` and `/discover` commands, while the `identify-assumptions-new` skill supports various discovery workflows. This modular architecture prevents duplication and ensures consistent application of product management frameworks.