Differences Between Skills and Commands in the PM Skills Plugin Architecture

Skills are self-contained units of domain knowledge that execute discrete tasks, while commands are orchestrated workflows that chain multiple skills together to solve end-to-end product management problems.

The phuryn/pm-skills repository implements a modular plugin architecture that separates reusable expertise from complex multi-step processes. Understanding the differences between these two primitives is essential for effectively using or extending the PM Skills marketplace.

What Are Skills in the PM Plugin Architecture?

A skill is a self-contained piece of domain knowledge or a reusable workflow that encodes a specific product-management framework. According to the repository's README.md (lines 32-44), skills include value-proposition templates, SWOT analysis guides, resume-review frameworks, and other discrete PM methodologies.

Skills function as atomic units of expertise that can be invoked in two ways: implicitly when the model detects contextual relevance, or explicitly by name without any special prefix. For example, typing review-resume triggers the resume review skill directly. The architecture defines skills in individual SKILL.md files within plugin-specific directories, such as pm-toolkit/skills/review-resume/SKILL.md.

Key characteristics of skills include:

• Single-purpose focus: Each skill handles one specific task (e.g., generating a SWOT analysis, brainstorming ideas, or identifying assumptions).
• Automatic loading: The system can implicitly load skills based on conversation context, even without explicit user invocation.
• Reusability: Skills are designed to be shared across multiple commands and plugins.

What Are Commands in the PM Plugin Architecture?

A command is a user-triggered, higher-level workflow that strings together one or more skills to solve an end-to-end problem. As documented in the README.md (lines 55-62), commands always require explicit invocation with a leading slash (/) and drive multi-step interactions.

For example, the /discover command runs a complete product discovery workflow that internally chains the brainstorm-ideas, identify-assumptions, prioritize-assumptions, and brainstorm-experiments skills. Unlike skills, commands are composite operations that manage state across multiple steps and coordinate the execution sequence of underlying skills.

Commands are defined in separate markdown files within commands/ directories, such as pm-product-discovery/commands/discover.md and pm-go-to-market/commands/plan-launch.md.

Key Differences Between Skills and Commands

The architectural distinction between these components can be summarized across four dimensions:

Aspect	Skills	Commands
Purpose	Provide discrete, reusable expertise (templates, analysis methods, prompts).	Orchestrate complete processes by chaining multiple skills.
Invocation	Implicitly when relevant, or explicitly by name without prefix.	Always explicit via slash command (/command-name).
Scope	Single, focused task; shared across many commands.	Composite, multi-step task involving several skills.
Marketplace Visibility	Listed under each plugin's "Skills" section.	Listed under each plugin's "Commands" section.

In the source code, this separation is maintained through distinct directory structures: skills reside in skills/ subdirectories while commands live in commands/ subdirectories within each plugin folder.

Practical Usage Examples

Direct Skill Invocation

You can invoke a skill directly by name without any slash prefix:

review-resume

The model pulls the review-resume skill from pm-toolkit/skills/review-resume/SKILL.md and returns feedback immediately. This executes as a single, self-contained operation without additional workflow orchestration.

Running a Command with Skill Chaining

Commands use the slash prefix and trigger complex workflows:

/discover AI-powered meeting summarizer for remote teams

According to the README.md (lines 60-62), this command executes a pipeline that sequentially invokes the brainstorm-ideas, identify-assumptions, prioritize-assumptions, and brainstorm-experiments skills to produce a comprehensive discovery output.

Natural Language Skill Detection

Skills can also activate implicitly based on context:

I need a SWOT analysis for our new AI-assistant product.

The model automatically detects the need for the swot-analysis skill and loads it without requiring explicit command syntax, demonstrating the architecture's contextual awareness capabilities.

Command Reusing Multiple Skills

The /plan-launch command demonstrates how commands aggregate skills:

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

As defined in pm-go-to-market/commands/plan-launch.md (referenced in README.md lines 55-57), this command incorporates the gtm-strategy skill, the ideal-customer-profile skill, and others to generate a comprehensive go-to-market plan.

Source Code Implementation

The differences between skills and commands are reflected in the repository's file structure and configuration files.

Skill Definition Files

Individual skills are defined in SKILL.md files within plugin-specific skill directories. For example, pm-toolkit/skills/review-resume/SKILL.md contains the complete definition of the resume review capability, including prompts, templates, and execution logic.

Command Implementation Files

Commands are implemented as separate markdown files in commands/ directories. The file pm-toolkit/commands/review-resume.md wraps the review-resume skill as a slash command, while pm-product-discovery/commands/discover.md implements the multi-skill chaining logic for the discovery workflow.

Plugin Manifest Configuration

The registration of both components occurs in the plugin manifest at pm-toolkit/.claude-plugin/plugin.json. This file registers skill files and command files, making them discoverable within the marketplace while maintaining the architectural separation between reusable knowledge (skills) and orchestrated workflows (commands).

Summary

• Skills are atomic units of PM expertise that perform single tasks and can be invoked implicitly or explicitly by name.
• Commands are slash-prefixed workflows that chain multiple skills to solve complex, end-to-end problems.
• Architecture: Skills reside in skills/ directories with SKILL.md files, while commands live in commands/ directories as separate markdown files.
• Invocation: Skills use natural language or direct names; commands require the / prefix.
• Reusability: Skills are designed to be shared across commands; commands are specific workflow implementations.

Frequently Asked Questions

Can a skill invoke another skill directly?

No, skills are designed as atomic units that do not chain other skills. According to the architecture defined in README.md, skill composition and orchestration are the responsibility of commands. When you need to combine multiple capabilities, you should implement a command that references the relevant skills in sequence.

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

Use a skill when you need a specific analysis or template (e.g., "create a SWOT analysis" or "review this resume"). Use a command when you need a complete workflow that coordinates multiple steps (e.g., /discover for full product discovery or /plan-launch for go-to-market planning). If the task involves multiple phases or deliverables, use a command.

Where are skills and commands registered in the codebase?

Both are registered in the plugin manifest file at pm-toolkit/.claude-plugin/plugin.json. Skills are defined in SKILL.md files within skills/ subdirectories (e.g., pm-toolkit/skills/review-resume/SKILL.md), while commands are defined in markdown files within commands/ subdirectories (e.g., pm-toolkit/commands/review-resume.md).

Can commands exist without skills?

While technically possible, commands are architecturally designed to orchestrate skills. A command that doesn't utilize skills would need to implement all logic internally, bypassing the reusable skill framework. The PM Skills architecture encourages commands to leverage existing skills for maintainability and consistency across the marketplace.

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