# Skills vs Commands in the PM Skills Plugin Architecture: Complete Guide

> Understand the difference between skills and commands in the PM Skills plugin architecture. Learn how skills offer reusable methods and commands orchestrate workflows for end-to-end problem-solving.

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

---

**In the PM Skills plugin architecture, skills are self-contained units of domain expertise that provide reusable templates and analysis methods, while commands are slash-prefixed workflows that orchestrate multiple skills to solve end-to-end problems.**

The `phuryn/pm-skills` repository defines a marketplace architecture for product management workflows within Claude's plugin ecosystem. Understanding the **difference between skills and commands in the PM Skills plugin architecture** is essential for developers extending the toolkit and power users optimizing their interaction patterns. Both constructs coexist within the same plugin infrastructure but serve distinct roles in how domain knowledge is packaged and delivered.

## What Are Skills?

### Definition and Purpose

A **skill** is a self-contained piece of domain knowledge or reusable workflow that encodes a specific product-management framework. According to the repository's README, skills include value-proposition templates, SWOT analysis guides, and resume-review workflows that remain dormant until relevant to the conversation. Each skill resides in its own directory under the plugin's `skills/` folder, such as [`pm-toolkit/skills/review-resume/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/skills/review-resume/SKILL.md).

### How Skills Are Invoked

Skills activate through two distinct mechanisms. The model can implicitly load a skill when it detects conversational relevance, or users can invoke skills explicitly by referencing the skill name directly without any prefix.

```text
review-resume

```

When processed, the model pulls the `review-resume` skill definition and returns feedback immediately. Similarly, requesting a SWOT analysis automatically loads the `swot-analysis` skill even without explicit mention.

## What Are Commands?

### Definition and Structure

A **command** is a user-triggered, higher-level workflow that strings together one or more skills to solve an end-to-end problem. Commands always require a leading slash (`/`) and drive multi-step interactions. Unlike skills, commands do not contain the actual domain logic; instead, they orchestrate existing skills into processing pipelines.

### Command Execution Flow

When you invoke a command like `/discover`, the system executes a predefined workflow that chains multiple discrete skills. As implemented in [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md), this command runs the complete discovery pipeline:

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

```

This single command internally chains the `brainstorm-ideas`, `identify-assumptions`, `prioritize-assumptions`, and `brainstorm-experiments` skills to produce a comprehensive analysis.

## Architecture Comparison

The fundamental distinction between these constructs manifests across four key dimensions:

| Aspect | Skills | Commands |
| ------ | ------ | -------- |
| **Purpose** | Provide discrete, reusable expertise (templates, analysis methods, prompts). | Orchestrate complete processes by chaining skills. |
| **Invocation** | Implicitly when relevant, or explicitly by name (`review-resume`). | Always explicit via slash command (`/review-resume`). |
| **Scope** | Single, focused task; can be shared across many commands. | Composite, multi-step task that may involve several skills. |
| **Visibility** | Listed under each plugin's "Skills" section. | Listed under each plugin's "Commands" section. |

## Implementation Examples from Source Code

### Skill Definition File

The `review-resume` skill is defined in [`pm-toolkit/skills/review-resume/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/skills/review-resume/SKILL.md). This file contains the actual domain knowledge for conducting resume reviews, including evaluation criteria and feedback templates.

### Command Wrapper Implementation

The corresponding command exists in [`pm-toolkit/commands/review-resume.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/commands/review-resume.md). This file does not redefine the resume review logic; instead, it creates a slash-accessible entry point that wraps the underlying skill with additional orchestration logic.

### Complex Multi-Skill Workflows

The `/plan-launch` command demonstrates advanced orchestration. Located in [`pm-go-to-market/commands/plan-launch.md`](https://github.com/phuryn/pm-skills/blob/main/pm-go-to-market/commands/plan-launch.md), this command incorporates the `gtm-strategy` skill, the `ideal-customer-profile` skill, and additional components to generate comprehensive launch plans:

```text
/plan-launch AI code review tool targeting mid-size engineering teams

```

## Plugin Registration and Discovery

Both skills and commands register through the same manifest system. The file [`pm-toolkit/.claude-plugin/plugin.json`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/.claude-plugin/plugin.json) serves as the plugin manifest that registers skill files and command files, making them discoverable in the marketplace. This centralized registration ensures that skills remain available as reusable units while commands present as unified workflow entry points.

## Summary

- **Skills** are atomic units of domain knowledge stored in [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) files that provide specific product management expertise.
- **Commands** are orchestration layers defined in markdown files under `commands/` directories that chain multiple skills using slash-triggered invocations.
- Skills activate implicitly by context or explicitly by name without prefixes, while commands always require explicit `/` invocation.
- The `/discover` command chains four distinct skills (`brainstorm-ideas`, `identify-assumptions`, `prioritize-assumptions`, `brainstorm-experiments`) to create a complete discovery workflow.
- Both constructs register through [`plugin.json`](https://github.com/phuryn/pm-skills/blob/main/plugin.json) but appear separately in the marketplace under "Skills" and "Commands" sections.

## Frequently Asked Questions

### Can a command exist without calling any skills?

While technically possible, commands in the PM Skills architecture are designed specifically to orchestrate skills. The repository's examples, including `/discover` and `/plan-launch`, demonstrate that commands serve as workflow wrappers that invoke multiple skills. A command that implemented all logic internally would deviate from the architectural pattern established in `phuryn/pm-skills`.

### How do I know whether to invoke a skill directly or use a command?

Use **direct skill invocation** when you need a specific, discrete piece of expertise like `swot-analysis` or `review-resume`. Use **slash commands** when you need a complete multi-step process such as `/discover` for idea validation or `/plan-launch` for go-to-market planning. Commands automatically handle the sequencing of multiple skills that would otherwise require manual chaining.

### Where are skill and command definitions physically located in the repository?

Skill definitions reside in [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) files within plugin-specific `skills/` directories, such as [`pm-toolkit/skills/review-resume/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/skills/review-resume/SKILL.md). Command definitions exist as separate markdown files within `commands/` directories, such as [`pm-product-discovery/commands/discover.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-discovery/commands/discover.md). The [`plugin.json`](https://github.com/phuryn/pm-skills/blob/main/plugin.json) manifest in each plugin's `.claude-plugin` directory registers both types for marketplace discovery.

### Can the same skill be used by multiple commands?

Yes, skills are designed as reusable components that can be shared across many commands. For example, a skill defined in one plugin can be invoked by commands from different plugins within the marketplace, enabling composable architecture where domain expertise remains DRY (Don't Repeat Yourself) while workflows vary by use case.