# How PM Skills Plugins Integrate with Claude Code and Claude Cowork: A Complete Technical Guide

> Learn how PM Skills plugins integrate with Claude Code and Claude Cowork. Discover the manifest architecture, slash commands, skills, and markdown workflows for seamless agent execution.

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

---

**PM Skills plugins integrate with Claude Code and Claude Cowork through a manifest-based architecture where [`.claude-plugin/marketplace.json`](https://github.com/phuryn/pm-skills/blob/main/.claude-plugin/marketplace.json) registers the marketplace, individual [`plugin.json`](https://github.com/phuryn/pm-skills/blob/main/plugin.json) files expose slash commands and skills, and markdown-based workflows execute directly in the Claude agent environment.**

The **phuryn/pm-skills** repository functions as a Claude Code marketplace containing nine independent plugins that bundle reusable product management capabilities. Understanding how these PM Skills plugins integrate with Claude Code requires examining the relationship between marketplace manifests, plugin descriptors, and the markdown-based skill system that Claude agents consume at runtime.

## Architecture Overview

The integration relies on a hierarchical manifest structure that Claude Code and Claude Cowork parse to discover, register, and execute plugin functionality. Each layer of the architecture serves a distinct purpose in connecting the repository to Claude's agent environment.

### Root Marketplace Manifest

The [`.claude-plugin/marketplace.json`](https://github.com/phuryn/pm-skills/blob/main/.claude-plugin/marketplace.json) file serves as the entry point for the entire ecosystem. This JSON file lists all nine plugins in the PM Skills marketplace—including `pm-product-discovery`, `pm-execution`, and `pm-go-to-market`—and declares the marketplace version. When you run `claude plugin marketplace add phuryn/pm-skills`, Claude Code reads this manifest to discover the complete collection in a single operation.

### Plugin Manifests

Every plugin directory contains a [`.claude-plugin/plugin.json`](https://github.com/phuryn/pm-skills/blob/main/.claude-plugin/plugin.json) file that describes the individual component. According to the source code in paths like [`pm-execution/.claude-plugin/plugin.json`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/.claude-plugin/plugin.json), these manifests specify the plugin's `name`, `description`, `version`, `author`, `keywords`, and the directories containing `skills/` and `commands/`. Claude Code uses this metadata to populate the slash-command namespace and expose capabilities in the autocomplete interface.

### Skills and Commands

The actual functionality resides in two types of markdown files:

- **Skills** (`*/skills/*/SKILL.md`): Plain-text knowledge modules (e.g., [`pm-execution/skills/create-prd/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/create-prd/SKILL.md)) that Claude auto-loads when detecting relevant topics. These require no runtime compilation; Claude parses the markdown at invocation time.

- **Commands** (`*/commands/*.md`): Slash-command definitions (e.g., [`pm-execution/commands/write-prd.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/commands/write-prd.md)) that chain multiple skills into end-to-end workflows. These files contain YAML front-matter with `description` and `argument-hint` fields that Claude Cowork displays in the command picker and Claude Code uses for autocomplete suggestions.

## Integration Flow for Claude Code

Claude Code integrates with PM Skills through a CLI-driven workflow that downloads manifests and registers commands in the local environment.

### Adding the Marketplace

First, register the marketplace source:

```bash
claude plugin marketplace add phuryn/pm-skills

```

This command reads [`.claude-plugin/marketplace.json`](https://github.com/phuryn/pm-skills/blob/main/.claude-plugin/marketplace.json) and copies the marketplace manifest into Claude Code's local plugin cache. The CLI now recognizes all nine plugins as installable units.

### Installing Individual Plugins

Install specific capabilities using the `<plugin-name>@<marketplace-name>` syntax:

```bash
claude plugin install pm-execution@pm-skills

```

During installation, Claude Code parses the plugin's [`plugin.json`](https://github.com/phuryn/pm-skills/blob/main/plugin.json) and registers commands like `/write-prd` and `/sprint` under the slash-command namespace. The skills directory is indexed for on-demand loading.

### Bulk Installation

To install all 68 skills and 42 commands across the entire marketplace:

```bash

# Add the marketplace first

claude plugin marketplace add phuryn/pm-skills

# Install all nine plugins

for plugin in pm-toolkit pm-product-strategy pm-product-discovery \
              pm-market-research pm-data-analytics pm-marketing-growth \
              pm-go-to-market pm-execution pm-ai-shipping; do
  claude plugin install "${plugin}@pm-skills"
done

```

### Executing Commands

Once installed, invoke commands through the chat interface:

```text
/write-prd AI-powered meeting summarizer for remote teams

```

Claude Code locates the corresponding [`commands/write-prd.md`](https://github.com/phuryn/pm-skills/blob/main/commands/write-prd.md) file, executes the markdown workflow, and invokes the linked skills in sequence.

## Integration Flow for Claude Cowork

Claude Cowork consumes the same manifest structure but surfaces capabilities through a graphical interface rather than CLI commands.

### UI-Based Installation

1. Navigate to **Customize → Browse plugins → Personal → +**
2. Select **Add marketplace from GitHub** and enter `phuryn/pm-skills`
3. Select individual plugins from the nine available options (e.g., `pm-product-discovery`, `pm-execution`)

The marketplace JSON populates the plugin browser, and each [`plugin.json`](https://github.com/phuryn/pm-skills/blob/main/plugin.json) provides the metadata for the installation cards.

### Running Workflows

After installation, commands appear in the **Plugins → Personal** list. Users can either click the command card or type directly in the chat input:

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

```

Claude Cowork executes the `/discover` command workflow, internally calling four underlying skills: `brainstorm-ideas`, `identify-assumptions`, `prioritize-assumptions`, and `brainstorm-experiments`.

## Skill Loading and Namespacing

Skills operate on an **on-demand loading** model. Claude scans the repository for [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) files and adds them to its knowledge base when relevant topics arise. If a skill name conflicts with user-defined terminology or you need to force a specific skill, use the prefix syntax:

```text
/pm-execution:write-prd Build a PRD for a new AI-assistant feature.

```

The `pm-execution:write-prd` prefix explicitly tells Claude to load the `write-prd` skill from the `pm-execution` plugin, bypassing auto-detection.

## Validation and Consistency

The repository maintains integration reliability through automated validation. The [`validate_plugins.py`](https://github.com/phuryn/pm-skills/blob/main/validate_plugins.py) script enforces Claude Code plugin specification compliance, checking for required fields, matching directory names, and correct version synchronization. Additionally, [`tests/test_consistency.py`](https://github.com/phuryn/pm-skills/blob/main/tests/test_consistency.py) verifies that version strings remain synchronized across [`CHANGELOG.md`](https://github.com/phuryn/pm-skills/blob/main/CHANGELOG.md), [`marketplace.json`](https://github.com/phuryn/pm-skills/blob/main/marketplace.json), and every [`plugin.json`](https://github.com/phuryn/pm-skills/blob/main/plugin.json).

These checks run in CI on every pull request, ensuring that malformed manifests never reach the main branch. This guarantees that Claude Code and Claude Cowork always encounter well-formed JSON that can be safely parsed and loaded.

## Summary

- **Marketplace Manifest** ([`.claude-plugin/marketplace.json`](https://github.com/phuryn/pm-skills/blob/main/.claude-plugin/marketplace.json)) tells Claude Code which plugins exist and their versions.
- **Plugin Manifests** (`*/.claude-plugin/plugin.json`) register each plugin's commands and skills with the agent.
- **Skills** are plain markdown files auto-loaded by topic relevance; **commands** are markdown workflows that orchestrate multiple skills.
- **Claude Code** uses CLI commands (`claude plugin install`) to load manifests, while **Claude Cowork** consumes the same files through its plugin browser UI.
- **Validation tooling** ([`validate_plugins.py`](https://github.com/phuryn/pm-skills/blob/main/validate_plugins.py) and [`tests/test_consistency.py`](https://github.com/phuryn/pm-skills/blob/main/tests/test_consistency.py)) ensures manifest integrity across all nine plugins.

## Frequently Asked Questions

### How do I add a custom skill to an existing PM Skills plugin?

Create a new directory under the target plugin's `skills/` folder containing a [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) file with YAML front-matter specifying `title` and `author`. Update the plugin's [`plugin.json`](https://github.com/phuryn/pm-skills/blob/main/plugin.json) to include the new skill path, then commit your changes. The CI test suite in [`tests/test_consistency.py`](https://github.com/phuryn/pm-skills/blob/main/tests/test_consistency.py) will verify the entry; once tests pass, the skill becomes available to Claude agents without requiring code compilation or deployment.

### What happens if two plugins define the same command name?

Claude Code resolves conflicts using the plugin namespace. You can disambiguate by using the prefix syntax (`/plugin-name:command-name`) or by installing only the specific plugin you need. The [`validate_plugins.py`](https://github.com/phuryn/pm-skills/blob/main/validate_plugins.py) script checks for naming collisions during CI to prevent marketplace-level conflicts.

### Can I use PM Skills plugins without installing the entire marketplace?

Yes. While adding the marketplace via `claude plugin marketplace add phuryn/pm-skills` makes discovery easier, you can install individual plugins directly if you know the repository structure. However, installing via the marketplace ensures that [`marketplace.json`](https://github.com/phuryn/pm-skills/blob/main/marketplace.json) tracks version compatibility between the nine plugins.

### How does Claude Cowork differ from Claude Code when executing PM Skills commands?

Both agents parse the same [`plugin.json`](https://github.com/phuryn/pm-skills/blob/main/plugin.json) and command markdown files, but Claude Cowork surfaces capabilities through a graphical plugin browser and command picker, whereas Claude Code exposes them via CLI installation and slash-command autocomplete in the terminal. The underlying execution engine processes the identical markdown workflows in both environments.