Difference Between a Skill and a Command in PM Skills

A skill is an atomic knowledge unit that encodes focused domain expertise, while a command is a user-triggered workflow that orchestrates one or more skills into a complete end-to-end process.

The phuryn/pm-skills repository structures product management automation around three core concepts: Skills, Commands, and Plugins. Understanding the difference between a skill and a command in PM Skills is essential for leveraging the toolkit effectively, as each serves distinct architectural purposes within the AI assistant integration. While skills provide the underlying knowledge repositories, commands serve as the user-facing entry points that assemble that knowledge into practical workflows.

What Is a Skill?

A skill is the atomic knowledge unit within the PM Skills architecture. Each skill encodes a specific product management framework, analysis method, or writing guideline that provides focused domain expertise.

Skills are designed to load automatically when Claude (or another AI assistant) detects that the conversation content would benefit from that specific expertise. No explicit user invocation is required for automatic loading. However, users can force a skill to load using a prefix syntax such as /plugin-name:skill-name or simply /skill-name.

According to the repository structure, skill definitions reside in dedicated directories. For example, pm-toolkit/skills/review-resume/SKILL.md contains the detailed instructions the AI follows when reviewing a product management resume, including evaluation criteria and output formatting guidelines.

What Is a Command?

A command is a user-triggered workflow that orchestrates skills into a scripted sequence. Unlike skills, which provide passive knowledge, commands are active processes invoked with a leading slash (/) that collect input, call relevant skills, format output, and suggest follow-up actions.

Commands stitch together multiple skills to deliver complete end-to-end processes. For instance, the /review-resume command defined in pm-toolkit/commands/review-resume.md parses the input resume, executes the review-resume skill, and produces a structured scorecard with improvement suggestions.

The command architecture handles workflow orchestration: gathering user inputs, sequencing skill calls, and formatting the final output for consumption.

Key Architectural Differences

The architectural split between these components can be summarized as follows:

• Activation: Skills load automatically based on context or when forced with a prefix; commands require explicit user invocation with /command-name.
• Scope: Skills contain reusable knowledge units; commands implement complete workflows.
• Composition: A skill operates as a single expertise unit; a command chains multiple skills (and potentially other logic) into a process.
• User Interface: Skills function as background expertise; commands serve as the primary user-facing entry points.

Practical Usage Examples

The following examples demonstrate how skills and commands interact in practice.

Direct Skill Invocation

When you need to force a specific skill without the orchestration logic of a command:

User: /review-resume "Here is my resume..."
Claude: (loads the `review-resume` skill automatically and returns the review.)

This bypasses the command workflow and invokes the skill's expertise directly.

Command Orchestration

When running a complete workflow that chains multiple skills:

User: /discover AI-powered meeting summarizer
Claude: Executes the `brainstorm-ideas`, `identify-assumptions`, `prioritize-assumptions`,
and `brainstorm-experiments` skills in sequence, then returns the full discovery output.

The /discover command internally manages the execution order and data flow between four distinct skills to complete the product discovery workflow.

File Structure and Implementation

The repository separates these concerns at the file system level:

• Skill definitions: Located in pm-toolkit/skills/<skill-name>/SKILL.md, these files contain the detailed instructions, constraints, and knowledge models that define the skill's behavior.
• Command definitions: Stored in pm-toolkit/commands/<command-name>.md, these files declare the command interface, workflow steps, parameter handling, and skill invocation logic.

This separation ensures that skills remain reusable across multiple commands while commands focus on user interaction patterns and workflow orchestration.

Summary

• Skills are atomic knowledge units that encode domain expertise and load automatically when relevant to the conversation context.
• Commands are user-triggered workflows that orchestrate one or more skills into complete end-to-end processes.
• Invocation: Skills can be forced with /skill-name syntax, while commands use /command-name to execute scripted sequences.
• Architecture: The repository separates skills (in pm-toolkit/skills/) from commands (in pm-toolkit/commands/) to maintain clean separation between knowledge and workflow logic.

Frequently Asked Questions

How do I force a specific skill to load without using a command?

You can force a skill to load by using the prefix syntax /plugin-name:skill-name or simply /skill-name followed by your input. This triggers the skill directly without the orchestration logic, input collection, or formatting steps that a command would provide.

Can a command use multiple skills simultaneously?

Yes, commands are designed to orchestrate multiple skills into a single workflow. For example, the /discover command chains together the brainstorm-ideas, identify-assumptions, prioritize-assumptions, and brainstorm-experiments skills in sequence to deliver a complete product discovery process.

What is the difference between automatic skill loading and command invocation?

Automatic skill loading occurs when Claude detects that conversation content would benefit from a specific expertise domain, loading the skill without explicit user action. Command invocation requires the user to type /command-name and triggers a scripted workflow that may include multiple steps, inputs, and skill calls.

Where are skill definitions stored compared to command definitions?

Skill definitions are stored in pm-toolkit/skills/<skill-name>/SKILL.md files, containing the detailed instructions and knowledge models. Command definitions are stored in pm-toolkit/commands/<command-name>.md files, containing the workflow orchestration logic and user interface specifications.

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