# What Distinguishes Skills from Commands in the PM Skills Architecture

> Understand the difference between PM skills and commands in the phuryn/pm-skills architecture. Skills are knowledge blocks, commands trigger workflows.

- Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills)
- Tags: deep-dive
- Published: 2026-07-07

---

**Skills are modular knowledge blocks that encode product management frameworks, while commands are user-triggered workflows that orchestrate multiple skills into complete end-to-end processes.**

The `phuryn/pm-skills` repository implements a modular AI architecture that separates domain knowledge from workflow orchestration. Understanding what distinguishes skills from commands in the PM Skills architecture is essential for effectively leveraging this open-source product management toolkit.

## Core Architectural Concepts

### What Are Skills

**Skills** are standalone, reusable modules that encapsulate specific product management knowledge, frameworks, or analytical capabilities. According to the `phuryn/pm-skills` source code, each skill resides as a Markdown file under `pm-*/skills/…/SKILL.md` and defines a single domain concept—such as `brainstorm-ideas-new` or `product-vision`.

Skills auto-load when the model detects relevant domain context, or users can force-load them explicitly using slash-prefixed syntax (e.g., `/skill-name` or `/plugin-name:skill-name`). This design makes skills **language-agnostic** and portable across different AI models including Claude, Gemini, and OpenCode.

### What Are Commands

**Commands** are end-to-end workflows triggered explicitly by users via slash-prefixed invocations (e.g., `/discover`, `/strategy`). Defined in `pm-*/commands/…md` files, commands function as **scripts** that chain multiple skills together to accomplish complex product management tasks.

When executed, a command invokes its constituent skills in sequence, passing the output of one skill as input to the next. This compositional approach allows a single command to execute multi-step processes—such as running a full discovery cycle—while reusing existing skill definitions.

## Key Differences Between Skills and Commands

The PM Skills architecture maintains a strict separation between knowledge storage and workflow orchestration:

- **Definition Location**: **Skills** live in `pm-*/skills/…/SKILL.md` files (e.g., [`pm-product-discovery/skills/brainstorm-ideas-new/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/skills/brainstorm-ideas-new/SKILL.md)), while **commands** reside in `pm-*/commands/…md` files (e.g., [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md)).

- **Loading Mechanism**: **Skills** load automatically when domain-relevant context is detected, or via explicit `/skill-name` invocation. **Commands** require explicit user triggers using `/command-name` syntax and do not auto-load.

- **Composition Model**: **Skills** are atomic and standalone—encapsulating a single framework like the `product-vision` skill. **Commands** are composite—chaining multiple skills (e.g., `/discover` calls `brainstorm-ideas-new → identify-assumptions-new → prioritize-assumptions → brainstorm-experiments-new`).

- **Portability**: **Skills** work across different AI platforms using natural language instructions. **Commands** use Claude-specific slash syntax and require translation for other agents.

## How Skills and Commands Interact

The interaction between skills and commands follows a **pipeline pattern**. When a user invokes a command, the system:

1. Loads the command definition from the corresponding Markdown file
2. Identifies the ordered list of skills specified in the command
3. Executes each skill sequentially, maintaining context between steps
4. Returns the final aggregated output to the user

After execution, commands suggest the next logical command in the workflow, creating guided product management journeys while keeping the underlying skills decoupled and reusable.

## File Structure and Implementation

The repository organizes these components through a predictable directory structure:

- **Skill definitions**: [`pm-product-discovery/skills/brainstorm-ideas-new/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/skills/brainstorm-ideas-new/SKILL.md) encodes a single brainstorming framework
- **Command definitions**: [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md) orchestrates multiple skills into the `/discover` workflow
- **Cross-domain reuse**: [`pm-toolkit/skills/review-resume/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/skills/review-resume/SKILL.md) demonstrates skills that serve multiple command contexts

## Practical Usage Examples

### Loading a Single Skill Directly

To access a specific framework without running a full workflow, force-load the skill using its slash-prefixed name:

```markdown
/product-vision

```

This invokes the `product-vision` skill defined in [`pm-product-strategy/skills/product-vision/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-strategy/skills/product-vision/SKILL.md), loading only that specific framework.

### Executing a Multi-Step Command

To run a complete discovery process that chains multiple skills:

```bash
/discover AI-powered meeting summarizer for remote teams

```

This executes the `/discover` command defined in [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md), which internally calls:

1. `brainstorm-ideas-new`
2. `identify-assumptions-new`
3. `prioritize-assumptions`
4. `brainstorm-experiments-new`

Each skill receives the output from the previous step, creating a cohesive discovery output while maintaining individual skill modularity.

### Skill Definition Example

The `brainstorm-ideas-new` skill in [`pm-product-discovery/skills/brainstorm-ideas-new/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/skills/brainstorm-ideas-new/SKILL.md) contains:

```markdown

# Brainstorm Ideas (New Products)

You are an expert product strategist.  
Generate 5 distinct ideas for a brand‑new SaaS product that solves a common pain point.

```

This standalone module can be called by any command requiring ideation capabilities.

## Summary

- **Skills** are atomic knowledge modules stored in [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) files that auto-load based on context and encode specific product management frameworks
- **Commands** are executable workflows stored in `commands/*.md` files that chain multiple skills using slash-prefixed triggers like `/discover`
- The architecture separates **knowledge** (skills) from **process** (commands), enabling skills to be reused across multiple commands without modification
- Skills are language-agnostic and portable across AI models, while commands use Claude-specific syntax and require translation for other platforms
- Commands execute skills sequentially, passing context between steps to create end-to-end workflows while suggesting next logical actions

## Frequently Asked Questions

### What file format defines a skill in PM Skills?

Skills are defined as Markdown files named [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) located in directories under `pm-*/skills/`. For example, the brainstorming skill resides at [`pm-product-discovery/skills/brainstorm-ideas-new/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/skills/brainstorm-ideas-new/SKILL.md). These files contain natural language instructions that encode specific product management frameworks.

### How do I invoke a command versus loading a skill directly?

Commands require explicit slash-prefixed invocation like `/discover` or `/strategy`, triggering multi-step workflows defined in command files. Skills can be force-loaded using `/skill-name` syntax (e.g., `/product-vision`) or load automatically when the model detects relevant domain context in the conversation.

### Can I create a custom command that uses existing skills?

Yes. Create a new Markdown file in `pm-*/commands/` and define the workflow by listing existing skills in execution order. The `/discover` command demonstrates this pattern by chaining `brainstorm-ideas-new`, `identify-assumptions-new`, `prioritize-assumptions`, and `brainstorm-experiments-new` without modifying the underlying skill definitions.

### Are skills and commands interchangeable between different AI models?

Skills are portable across AI platforms because they use natural language instructions. Commands, however, rely on Claude-specific slash-command syntax. While other agents like Gemini or OpenCode can read command files, they must translate the workflow definitions into their own execution language to run them.