# What Is the Role of the pm Executable in the pm-skills Toolkit?

> Discover the role of the pm executable in the pm-skills toolkit. Learn how it orchestrates LLM commands and discovers markdown skills for Product-Management.

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

---

**The `pm` executable acts as the command-line interface and orchestration layer for the Product-Management Skills toolkit, discovering markdown-based skills and executing LLM-powered commands.**

The `pm` executable serves as the primary entry point for the `phuryn/pm-skills` repository, bridging your terminal with AI-augmented product management capabilities. Unlike traditional CLIs that encapsulate logic in compiled code, this lightweight driver interprets static markdown definitions at runtime to deliver dynamic outputs.

## Core Responsibilities of the pm Executable

The `pm` command performs four essential functions to transform skill definitions into actionable results.

### Skill Discovery

The executable scans `pm-*` sub-directories to locate available capabilities. Each skill resides in its own directory containing prompt templates and metadata that the CLI automatically registers as available commands.

### Command Parsing

When you invoke a sub-command, `pm` reads the corresponding markdown file from `pm-*/commands/…md` to extract parameter definitions, option flags, and input requirements. These files declaratively define the CLI contract for each skill.

### LLM Invocation

Based on the parsed command structure, the executable triggers the appropriate skill logic—typically an LLM prompt template stored in `pm-toolkit/skills/**/SKILL.md`. This architecture separates the presentation layer from the AI logic.

### Response Formatting

After receiving the model output, `pm` formats the response into ready-to-use deliverables such as polished résumés, SWOT analyses, or North-Star metric definitions, streaming the results directly to your terminal.

## Command Structure and Usage Patterns

The `pm` executable follows a consistent invocation pattern: `pm <skill-name> [options]`. All commands are documented in the repository's markdown files.

### Standard Invocation Examples

```bash

# Display global help and available skills

pm --help

# Review a résumé using the skill defined in pm-toolkit/skills/review-resume

pm review-resume path/to/resume.pdf

# Generate a non-disclosure agreement with custom parameters

pm draft-nda --company "Acme Corp" --project "New Platform"

# Brainstorm product names for a specific vertical

pm product-name --industry "FinTech" --keywords "secure,fast,transparent"

```

### Skill Configuration Files

Each command maps to a specific markdown definition:
- [`pm-toolkit/commands/review-resume.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/commands/review-resume.md) specifies inputs for document analysis
- [`pm-toolkit/commands/draft-nda.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/commands/draft-nda.md) defines legal document generation parameters
- [`pm-toolkit/commands/product-name.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/commands/product-name.md) configures brainstorming session variables

## Architecture and Key Files

Understanding the repository structure reveals how the executable wires components together.

### Documentation Entry Point

The [`pm-toolkit/README.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/README.md) file provides installation instructions and explains how the CLI discovers and registers skills from the filesystem.

### Command Definitions

Individual skill interfaces are declared in `pm-toolkit/commands/` as markdown files. These documents specify the command-line arguments and help text that the `pm` executable exposes to users.

### Skill Templates

The actual prompt engineering and business logic reside in `pm-toolkit/skills/**/SKILL.md`. The executable dynamically loads these templates at runtime based on the issued sub-command, allowing product managers to modify AI behavior by editing text files rather than source code.

## Summary

- The `pm` executable functions as the **CLI driver** for the `phuryn/pm-skills` repository according to the source code structure.
- It **discovers** skills by scanning `pm-*` directories and **parses** command definitions from `pm-*/commands/…md` files.
- The executable **invokes** LLM prompts defined in `pm-toolkit/skills/**/SKILL.md` and formats AI responses for immediate use.
- Usage follows the pattern `pm <skill-name> [options]`, with each skill documented in its respective markdown configuration.

## Frequently Asked Questions

### How does the pm executable find available skills?

The `pm` executable searches `pm-*` sub-directories to locate markdown-based skill definitions. It identifies valid capabilities by detecting `commands/<skillname>.md` files and associated [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) templates, dynamically building the CLI menu from directory contents without requiring code changes.

### Can I add custom skills to the pm executable?

Yes, you can extend the toolkit by creating new directories following the `pm-<skillname>` convention and adding the required `commands/<skillname>.md` and `skills/<skillname>/SKILL.md` files. The `pm` command automatically discovers and registers these new capabilities during the next invocation.

### What distinguishes the pm executable from a standard Python CLI?

Unlike traditional CLIs that compile logic into the binary, the `pm` executable acts as a thin orchestration layer that reads markdown configurations at runtime. This architecture allows you to modify prompts and command behaviors by editing text files rather than redeploying code, effectively turning the filesystem into a plugin system for LLM capabilities.

### Where is the pm executable's source code located?

The implementation details are documented in [`pm-toolkit/README.md`](https://github.com/phuryn/pm-skills/blob/main/pm-toolkit/README.md), with command interfaces stored in `pm-toolkit/commands/` and skill logic maintained in `pm-toolkit/skills/**/`. The executable itself binds these markdown components into a cohesive command-line interface as implemented in `phuryn/pm-skills`.