# Product Strategy Canvas Implementation in pm-product-strategy: A Declarative AI Skill

> Discover how the Product Strategy Canvas is implemented as a declarative AI skill in pm-product-strategy. Learn about its Markdown-based structure and Claude runtime execution.

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

---

**The Product Strategy Canvas is implemented as a declarative Markdown-based skill within the pm-product-strategy plugin, where the canvas structure and prompting logic are defined in [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) and executed by the Claude runtime without traditional executable code.**

The `pm-product-strategy` plugin in the `phuryn/pm-skills` repository delivers a fully functional Product Strategy Canvas through a unique prompt-engineering approach. Rather than relying on imperative programming, the implementation uses static Markdown files to guide the Claude language model in generating the nine-section strategic framework. This architecture separates the canvas definition from execution, allowing product managers to invoke sophisticated strategic analysis through simple commands or API calls.

## Architecture of the Product Strategy Canvas

The implementation consists of four coordinated components that define, register, and expose the canvas functionality to users.

### The SKILL.md Definition

The core implementation resides in [`pm-product-strategy/skills/product-strategy/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-strategy/skills/product-strategy/SKILL.md), which serves as both the template and the prompt engine. This file declaratively specifies the nine canvas blocks: **Vision**, **Market Segments**, **Relative Costs**, **Value Proposition**, **Trade-offs**, **Key Metrics**, **Growth**, **Capabilities**, and **Can’t/Won’t** (Defensibility).

The skill file contains the structured prompt template that the Claude runtime feeds to the language model. When invoked, the runtime substitutes the `$ARGUMENTS` placeholder with user-provided product descriptions, assembling the final prompt without executing any custom code logic.

### The Plugin Manifest

The [`pm-product-strategy/.claude-plugin/plugin.json`](https://github.com/phuryn/pm-skills/blob/main/pm-product-strategy/.claude-plugin/plugin.json) file registers the `product-strategy` skill name with the Claude plugin system. This manifest allows the runtime to locate and instantiate the skill when users request the Product Strategy Canvas, handling the binding between the skill identifier and the [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) definition automatically.

### The Command Wrapper

User-facing access is provided through [`pm-product-strategy/commands/strategy.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-strategy/commands/strategy.md), which defines the `/pm-product-strategy:strategy` CLI-style command. This command file acts as a lightweight router that forwards requests to the underlying skill while providing optional usage documentation. It offers a convenient entry point for interactive sessions without requiring users to know the internal skill structure.

## How the Canvas Generation Works

When a user triggers the Product Strategy Canvas, the Claude runtime orchestrates the generation process through a three-step pipeline:

1. **skill resolution**: The runtime locates [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) based on the manifest registration and loads the canvas template.
2. **prompt assembly**: User arguments are injected into the template, replacing the `$ARGUMENTS` placeholder to contextualize the request.
3. **model generation**: The assembled prompt is sent to the Claude LLM, which produces the filled canvas based on the nine predefined sections.

This approach means the "implementation" is entirely contained within the prompt engineering and file structure—no Python, JavaScript, or other executable code processes the canvas logic.

## Usage Examples

### CLI Command Invocation

Trigger the canvas directly in a Claude-enabled environment:

```text
/pm-product-strategy:strategy a SaaS platform for remote team collaboration

```

The model returns a fully populated Product Strategy Canvas with all nine sections completed according to the provided product description.

### Direct Skill Invocation

For programmatic access via the Claude API:

```json
{
  "skill": "product-strategy",
  "arguments": "a mobile app that helps users track daily habits"
}

```

The response follows the structured template defined in [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md), producing consistent strategic analysis for integration into roadmapping tools.

### Embedding in Python Workflows

Integrate the canvas into automated product management pipelines:

```python

# Pseudo-code demonstrating skill invocation via Claude API

response = claude.run_skill(
    plugin="pm-product-strategy",
    skill="product-strategy",
    args="a B2B analytics dashboard for supply chain optimization"
)
print(response["generated_text"])

```

This returns the nine-section canvas as structured text, ready for parsing into presentation formats or strategic documentation.

## Summary

- The Product Strategy Canvas is implemented declaratively in [`pm-product-strategy/skills/product-strategy/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-strategy/skills/product-strategy/SKILL.md) within the `phuryn/pm-skills` repository.
- Nine strategic sections (Vision, Market Segments, Relative Costs, Value Proposition, Trade-offs, Key Metrics, Growth, Capabilities, and Can’t/Won’t) are defined statically and generated by the Claude LLM.
- The `/pm-product-strategy:strategy` command in [`pm-product-strategy/commands/strategy.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-strategy/commands/strategy.md) provides the primary user interface.
- No executable code is required; the canvas is produced entirely through prompt engineering and runtime substitution of the `$ARGUMENTS` placeholder.
- The architecture separates definition (Markdown files) from execution (Claude runtime), enabling maintenance without traditional software deployment cycles.

## Frequently Asked Questions

### What are the nine sections of the Product Strategy Canvas?

The canvas defined in [`SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/SKILL.md) includes **Vision**, **Market Segments**, **Relative Costs**, **Value Proposition**, **Trade-offs**, **Key Metrics**, **Growth**, **Capabilities**, and **Can’t/Won’t** (representing Defensibility). These sections provide a comprehensive framework for strategic product analysis, populated dynamically by the language model based on the specific product context provided.

### Is there any executable code in the implementation?

No. Unlike traditional plugins that rely on Python or JavaScript business logic, the `pm-product-strategy` implementation is purely declarative. The canvas generation relies on the Claude runtime reading the Markdown skill definition and prompt template, then leveraging the language model's reasoning capabilities to fill in the strategic sections. The only "code" involved is the CLI command wrapper that routes requests to the skill.

### How do I invoke the Product Strategy Canvas skill?

You can invoke the skill either through the command-line interface using `/pm-product-strategy:strategy` followed by your product description, or programmatically via the Claude API by specifying `"skill": "product-strategy"` in your request payload. Both methods trigger the runtime to load the skill definition from [`pm-product-strategy/skills/product-strategy/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-strategy/skills/product-strategy/SKILL.md) and generate the canvas output.

### Can I customize the canvas sections?

Yes. Because the canvas structure is defined in the static Markdown file at [`pm-product-strategy/skills/product-strategy/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-product-strategy/skills/product-strategy/SKILL.md), you can modify the sections by editing this file and adjusting the prompt template. Changes take effect immediately upon the next skill invocation without requiring compilation or deployment of executable binaries, as the Claude runtime reads the skill definition at execution time.