USP

Unlike generic AI, this marketplace integrates 65+ PM skills and 36 chained workflows, embedding expert frameworks (e.g., Teresa Torres) directly into your AI assistant for structured product decisions.

Use cases

• 01Conducting product discovery and ideation
• 02Developing product strategy and vision
• 03Writing Product Requirements Documents (PRDs)
• 04Analyzing A/B test results and user cohorts
• 05Generating dummy datasets for testing

Detected files (8)

• pm-execution/skills/create-prd/SKILL.mdskill
  Show content (3551 bytes)

  ---
  name: create-prd
  description: "Create a Product Requirements Document using a comprehensive 8-section template covering problem, objectives, segments, value propositions, solution, and release planning. Use when writing a PRD, documenting product requirements, preparing a feature spec, or reviewing an existing PRD."
  ---
  
  # Create a Product Requirements Document
  
  ## Purpose
  
  You are an experienced product manager responsible for creating a comprehensive Product Requirements Document (PRD) for $ARGUMENTS. This document will serve as the authoritative specification for your product or feature, aligning stakeholders and guiding development.
  
  ## Context
  
  A well-structured PRD clearly communicates the what, why, and how of your product initiative. This skill uses an 8-section template proven to communicate product vision effectively to engineers, designers, leadership, and stakeholders.
  
  ## Instructions
  
  1. **Gather Information**: If the user provides files, read them carefully. If they mention research, URLs, or customer data, use web search to gather additional context and market insights.
  
  2. **Think Step by Step**: Before writing, analyze:
     - What problem are we solving?
     - Who are we solving it for?
     - How will we measure success?
     - What are our constraints and assumptions?
  
  3. **Apply the PRD Template**: Create a document with these 8 sections:
  
     **1. Summary** (2-3 sentences)
     - What is this document about?
  
     **2. Contacts**
     - Name, role, and comment for key stakeholders
  
     **3. Background**
     - Context: What is this initiative about?
     - Why now? Has something changed?
     - Is this something that just recently became possible?
  
     **4. Objective**
     - What's the objective? Why does it matter?
     - How will it benefit the company and customers?
     - How does it align with vision and strategy?
     - Key Results: How will you measure success? (Use SMART OKR format)
  
     **5. Market Segment(s)**
     - For whom are we building this?
     - What constraints exist?
     - Note: Markets are defined by people's problems/jobs, not demographics
  
     **6. Value Proposition(s)**
     - What customer jobs/needs are we addressing?
     - What will customers gain?
     - Which pains will they avoid?
     - Which problems do we solve better than competitors?
     - Consider the Value Curve framework
  
     **7. Solution**
     - 7.1 UX/Prototypes (wireframes, user flows)
     - 7.2 Key Features (detailed feature descriptions)
     - 7.3 Technology (optional, only if relevant)
     - 7.4 Assumptions (what we believe but haven't proven)
  
     **8. Release**
     - How long could it take?
     - What goes in the first version vs. future versions?
     - Avoid exact dates; use relative timeframes
  
  4. **Use Accessible Language**: Write for a primary school graduate. Avoid jargon. Use clear, short sentences.
  
  5. **Structure Output**: Present the PRD as a well-formatted markdown document with clear headings and sections.
  
  6. **Save the Output**: If the PRD is substantial (which it will be), save it as a markdown document in the format: `PRD-[product-name].md`
  
  ## Notes
  
  - Be specific and data-driven where possible
  - Link each section back to the overall strategy
  - Flag assumptions clearly so the team can validate them
  - Keep the document concise but complete
  
  ---
  
  ### Further Reading
  
  - [How to Write a Product Requirements Document? The Best PRD Template.](https://www.productcompass.pm/p/prd-template)
  - [A Proven AI PRD Template by Miqdad Jaffer (Product Lead @ OpenAI)](https://www.productcompass.pm/p/ai-prd-template)
  

• pm-execution/skills/dummy-dataset/SKILL.mdskill
  Show content (3930 bytes)

  ---
  name: dummy-dataset
  description: "Generate realistic dummy datasets for testing with customizable columns, constraints, and output formats (CSV, JSON, SQL, Python script). Use when creating test data, building mock datasets, or generating sample data for development and demos."
  ---
  # Dummy Dataset Generation
  
  Generate realistic dummy datasets for testing with customizable columns, constraints, and output formats (CSV, JSON, SQL, Python script). Creates executable scripts or direct data files for immediate use.
  
  **Use when:** Creating test data, generating sample datasets, building realistic mock data for development, or populating test environments.
  
  **Arguments:**
  - `$PRODUCT`: The product or system name
  - `$DATASET_TYPE`: Type of data (e.g., customer feedback, transactions, user profiles)
  - `$ROWS`: Number of rows to generate (default: 100)
  - `$COLUMNS`: Specific columns or fields to include
  - `$FORMAT`: Output format (CSV, JSON, SQL, Python script)
  - `$CONSTRAINTS`: Additional constraints or business rules
  
  ## Step-by-Step Process
  
  1. **Identify dataset type** - Understand the data domain
  2. **Define column specifications** - Names, data types, and value ranges
  3. **Determine row count** - How many sample records needed
  4. **Select output format** - CSV, JSON, SQL INSERT, or Python script
  5. **Apply realistic patterns** - Ensure data looks authentic and valid
  6. **Add business constraints** - Respect business logic and relationships
  7. **Generate or script data** - Create executable output
  8. **Validate output** - Ensure data quality and completeness
  
  ## Template: Python Script Output
  
  ```python
  import csv
  import json
  from datetime import datetime, timedelta
  import random
  
  # Configuration
  ROWS = $ROWS
  FILENAME = "$DATASET_TYPE.csv"
  
  # Column definitions with realistic value generators
  columns = {
      "id": "auto-increment",
      "name": "first_last_name",
      "email": "email",
      "created_at": "timestamp",
      # Add more columns...
  }
  
  def generate_dataset():
      """Generate realistic dummy dataset"""
      data = []
      for i in range(1, ROWS + 1):
          record = {
              "id": f"U{i:06d}",
              # Generate values based on column definitions
          }
          data.append(record)
      return data
  
  def save_as_csv(data, filename):
      """Save dataset as CSV"""
      with open(filename, 'w', newline='') as f:
          writer = csv.DictWriter(f, fieldnames=data[0].keys())
          writer.writeheader()
          writer.writerows(data)
  
  if __name__ == "__main__":
      dataset = generate_dataset()
      save_as_csv(dataset, FILENAME)
      print(f"Generated {len(dataset)} records in {FILENAME}")
  ```
  
  ## Example Dataset Specification
  
  **Dataset Type:** Customer Feedback
  
  **Columns:**
  - feedback_id (auto-increment, U001, U002...)
  - customer_name (realistic names)
  - email (valid email format)
  - feedback_date (dates last 90 days)
  - rating (1-5 stars)
  - category (Bug, Feature Request, Complaint, Praise)
  - text (realistic feedback)
  - product (electronics, clothing, home)
  
  **Constraints:**
  - Ratings skewed: 40% 5-star, 30% 4-star, 20% 3-star, 10% 1-2 star
  - Bug category only with ratings 1-3
  - Feature requests only with ratings 3-5
  - Email domains realistic (gmail, yahoo, company.com)
  
  ## Output Deliverables
  
  - Ready-to-execute Python script OR direct data file
  - CSV file with proper headers and formatting
  - JSON file with valid structure and types
  - SQL INSERT statements for database population
  - Data validation and constraint compliance
  - Realistic, business-appropriate values
  - Documentation of data generation logic
  - Quick-start instructions for using the dataset
  
  ## Output Formats
  
  **CSV:** Flat tabular format, easy to import into spreadsheets and databases
  
  **JSON:** Nested structure, ideal for APIs and NoSQL databases
  
  **SQL:** INSERT statements, directly executable on relational databases
  
  **Python Script:** Executable generator for custom or large datasets
  

• pm-execution/skills/job-stories/SKILL.mdskill
  Show content (2969 bytes)

  ---
  name: job-stories
  description: "Create job stories using the 'When [situation], I want to [motivation], so I can [outcome]' format with detailed acceptance criteria. Use when writing job stories, creating JTBD-style backlog items, or expressing user situations and motivations."
  ---
  # Job Stories
  
  Create job stories using the 'When [situation], I want to [motivation], so I can [outcome]' format. Generates stories with detailed acceptance criteria focused on user situations and outcomes.
  
  **Use when:** Writing job stories, expressing user situations and motivations, creating JTBD-style backlog items, or focusing on user context rather than roles.
  
  **Arguments:**
  - `$PRODUCT`: The product or system name
  - `$FEATURE`: The new feature to break into job stories
  - `$DESIGN`: Link to design files (Figma, Miro, etc.)
  - `$CONTEXT`: User situations or job scenarios
  
  ## Step-by-Step Process
  
  1. **Identify user situations** that trigger the need
  2. **Define motivations** underlying the user's behavior
  3. **Clarify outcomes** the user wants to achieve
  4. **Apply JTBD framework:** Focus on the job, not the role
  5. **Create acceptance criteria** that validate the outcome is achieved
  6. **Use observable, measurable language**
  7. **Link to design mockups** or prototypes
  8. **Output job stories** with detailed acceptance criteria
  
  ## Story Template
  
  **Title:** [Job outcome or result]
  
  **Description:** When [situation], I want to [motivation], so I can [outcome].
  
  **Design:** [Link to design files]
  
  **Acceptance Criteria:**
  1. [Situation is properly recognized]
  2. [System enables the desired motivation]
  3. [Progress or feedback is visible]
  4. [Outcome is achieved efficiently]
  5. [Edge cases are handled gracefully]
  6. [Integration and notifications work]
  
  ## Example Job Story
  
  **Title:** Track Weekly Snack Spending
  
  **Description:** When I'm preparing my weekly allowance for snacks (situation), I want to quickly see how much I've spent so far (motivation), so I can make sure I don't run out of money before the weekend (outcome).
  
  **Design:** [Figma link]
  
  **Acceptance Criteria:**
  1. Display Spending Summary with 'Weekly Spending Overview' section
  2. Real-Time Update when expense logged
  3. Progress Indicator (progress bar showing 0-100% of weekly budget)
  4. Remaining Budget Highlight in prominent color
  5. Detailed Spending Log with breakdown by category
  6. Notifications at 80% budget threshold
  7. Weekend-Specific Reminder at 90% by Thursday evening
  8. Easy Access and Navigation to detailed breakdown
  
  ## Output Deliverables
  
  - Complete set of job stories for the feature
  - Each story follows the 'When...I want...so I can' format
  - 6-8 acceptance criteria focused on outcomes
  - Stories emphasize user situations and motivations
  - Clear links to design and prototypes
  
  ---
  
  ### Further Reading
  
  - [Jobs-to-be-Done Masterclass with Tony Ulwick and Sabeen Sattar](https://www.productcompass.pm/p/jobs-to-be-done-masterclass-with) (video course)
  

• pm-data-analytics/skills/ab-test-analysis/SKILL.mdskill
  Show content (3587 bytes)

  ---
  name: ab-test-analysis
  description: "Analyze A/B test results with statistical significance, sample size validation, confidence intervals, and ship/extend/stop recommendations. Use when evaluating experiment results, checking if a test reached significance, interpreting split test data, or deciding whether to ship a variant."
  ---
  
  ## A/B Test Analysis
  
  Evaluate A/B test results with statistical rigor and translate findings into clear product decisions.
  
  ### Context
  
  You are analyzing A/B test results for **$ARGUMENTS**.
  
  If the user provides data files (CSV, Excel, or analytics exports), read and analyze them directly. Generate Python scripts for statistical calculations when needed.
  
  ### Instructions
  
  1. **Understand the experiment**:
     - What was the hypothesis?
     - What was changed (the variant)?
     - What is the primary metric? Any guardrail metrics?
     - How long did the test run?
     - What is the traffic split?
  
  2. **Validate the test setup**:
     - **Sample size**: Is the sample large enough for the expected effect size?
       - Use the formula: n = (Z²α/2 × 2 × p × (1-p)) / MDE²
       - Flag if the test is underpowered (<80% power)
     - **Duration**: Did the test run for at least 1-2 full business cycles?
     - **Randomization**: Any evidence of sample ratio mismatch (SRM)?
     - **Novelty/primacy effects**: Was there enough time to wash out initial behavior changes?
  
  3. **Calculate statistical significance**:
     - **Conversion rate** for control and variant
     - **Relative lift**: (variant - control) / control × 100
     - **p-value**: Using a two-tailed z-test or chi-squared test
     - **Confidence interval**: 95% CI for the difference
     - **Statistical significance**: Is p < 0.05?
     - **Practical significance**: Is the lift meaningful for the business?
  
     If the user provides raw data, generate and run a Python script to calculate these.
  
  4. **Check guardrail metrics**:
     - Did any guardrail metrics (revenue, engagement, page load time) degrade?
     - A winning primary metric with degraded guardrails may not be a true win
  
  5. **Interpret results**:
  
     | Outcome | Recommendation |
     |---|---|
     | Significant positive lift, no guardrail issues | **Ship it** — roll out to 100% |
     | Significant positive lift, guardrail concerns | **Investigate** — understand trade-offs before shipping |
     | Not significant, positive trend | **Extend the test** — need more data or larger effect |
     | Not significant, flat | **Stop the test** — no meaningful difference detected |
     | Significant negative lift | **Don't ship** — revert to control, analyze why |
  
  6. **Provide the analysis summary**:
     ```
     ## A/B Test Results: [Test Name]
  
     **Hypothesis**: [What we expected]
     **Duration**: [X days] | **Sample**: [N control / M variant]
  
     | Metric | Control | Variant | Lift | p-value | Significant? |
     |---|---|---|---|---|---|
     | [Primary] | X% | Y% | +Z% | 0.0X | Yes/No |
     | [Guardrail] | ... | ... | ... | ... | ... |
  
     **Recommendation**: [Ship / Extend / Stop / Investigate]
     **Reasoning**: [Why]
     **Next steps**: [What to do]
     ```
  
  Think step by step. Save as markdown. Generate Python scripts for calculations if raw data is provided.
  
  ---
  
  ### Further Reading
  
  - [A/B Testing 101 + Examples](https://www.productcompass.pm/p/ab-testing-101-for-pms)
  - [Testing Product Ideas: The Ultimate Validation Experiments Library](https://www.productcompass.pm/p/the-ultimate-experiments-library)
  - [Are You Tracking the Right Metrics?](https://www.productcompass.pm/p/are-you-tracking-the-right-metrics)
  

• pm-data-analytics/skills/cohort-analysis/SKILL.mdskill
  Show content (5026 bytes)

  ---
  name: cohort-analysis
  description: "Perform cohort analysis on user engagement data — retention curves, feature adoption trends, and segment-level insights. Use when analyzing user retention by cohort, studying feature adoption over time, investigating churn patterns, or identifying engagement trends."
  ---
  
  # Cohort Analysis & Retention Explorer
  
  ## Purpose
  Analyze user engagement and retention patterns by cohort to identify trends in user behavior, feature adoption, and long-term engagement. Combine quantitative insights with qualitative research recommendations.
  
  ## How It Works
  
  ### Step 1: Read and Validate Your Data
  - Accept CSV, Excel, or JSON data files with user cohort information
  - Verify data structure: cohort identifier, time periods, engagement metrics
  - Check for missing values and data quality issues
  - Summarize key statistics (cohort sizes, date ranges, metrics available)
  
  ### Step 2: Generate Quantitative Analysis
  - Calculate cohort retention rates and engagement trends
  - Identify retention curves, drop-off patterns, and anomalies
  - Compute feature adoption rates across cohorts
  - Calculate month-over-month or period-over-period changes
  - Generate Python analysis scripts using pandas and numpy if requested
  
  ### Step 3: Create Visualizations
  - Generate retention heatmaps (cohorts vs. time periods)
  - Create line charts showing cohort progression
  - Build comparison charts for feature adoption
  - Visualize drop-off points and engagement trends
  - Output as interactive charts or static images
  
  ### Step 4: Identify Insights & Patterns
  - Spot one or more significant patterns:
    - Early churn in specific cohorts
    - Late-stage engagement changes
    - Feature adoption clusters
    - Seasonal or temporal trends
  - Highlight surprising findings and deviations
  - Compare cohort performance to establish baselines
  
  ### Step 5: Suggest Follow-Up Research
  - Recommend qualitative research methods:
    - Targeted user interviews with churning users
    - Feature usage surveys with engaged cohorts
    - Session replays of key interaction patterns
    - Win/loss analysis for high vs. low retention cohorts
  - Design follow-up quantitative studies
  - Suggest A/B tests or feature experiments
  
  ## Usage Examples
  
  **Example 1: Upload CSV Data**
  ```
  Upload cohort_engagement.csv with columns: cohort_month, weeks_active,
  user_id, feature_x_usage, engagement_score
  
  Request: "Analyze retention patterns and identify why Q4 2025 cohorts
  underperform compared to Q3"
  ```
  
  **Example 2: Describe Data Format**
  ```
  "I have monthly user cohorts from Jan-Dec 2025. Each row shows:
  cohort date, user ID, purchase frequency, and support tickets.
  Analyze which cohorts show best long-term retention."
  ```
  
  **Example 3: Feature Adoption Analysis**
  ```
  Upload feature_usage.xlsx with cohort adoption data.
  
  Request: "Compare adoption curves for our new feature across cohorts.
  Which cohorts adopted fastest? Any patterns?"
  ```
  
  ## Key Capabilities
  
  - **Data Reading**: Import CSV, Excel, JSON, SQL query results
  - **Retention Analysis**: Calculate and visualize retention rates over time
  - **Cohort Comparison**: Compare metrics across cohort groups
  - **Anomaly Detection**: Flag unusual patterns or drop-offs
  - **Python Scripts**: Generate reusable analysis code for ongoing analysis
  - **Visualizations**: Create heatmaps, charts, and interactive dashboards
  - **Research Design**: Suggest targeted follow-up studies and interview approaches
  - **Statistical Summary**: Provide quantitative metrics and correlation analysis
  
  ## Tips for Best Results
  
  1. **Include time dimension**: Provide data across multiple time periods
  2. **Define cohort clearly**: Make cohort grouping explicit (signup month, feature launch date, etc.)
  3. **Provide context**: Explain product changes, launches, or events during the period
  4. **Multiple metrics**: Include retention, engagement, feature usage, revenue, etc.
  5. **Sufficient data**: At least 3-4 cohorts for meaningful pattern identification
  6. **Request specific output**: Ask for visualizations, Python scripts, or research recommendations
  
  ## Output Format
  
  You'll receive:
  - **Data Summary**: Cohort overview and data quality assessment
  - **Quantitative Findings**: Key metrics, retention rates, and trend analysis
  - **Visualizations**: Charts showing retention curves, adoption patterns
  - **Pattern Identification**: 2-3 significant insights from the data
  - **Research Recommendations**: Specific qualitative and quantitative follow-ups
  - **Analysis Scripts** (if requested): Python code for reproducible analysis
  - **Next Steps**: Prioritized actions based on findings
  
  ---
  
  ### Further Reading
  
  - [Cohort Analysis 101: How to Reduce Churn and Make Better Product Decisions](https://www.productcompass.pm/p/cohort-analysis)
  - [The Product Analytics Playbook: AARRR, HEART, Cohorts & Funnels for PMs](https://www.productcompass.pm/p/the-product-analytics-playbook-aarrr)
  - [Are You Tracking the Right Metrics?](https://www.productcompass.pm/p/are-you-tracking-the-right-metrics)
  

• pm-data-analytics/skills/sql-queries/SKILL.mdskill
  Show content (3628 bytes)

  ---
  name: sql-queries
  description: "Generate SQL queries from natural language descriptions. Supports BigQuery, PostgreSQL, MySQL, and other dialects. Reads database schemas from uploaded diagrams or documentation. Use when writing SQL, building data reports, exploring databases, or translating business questions into queries."
  ---
  
  # SQL Query Generator
  
  ## Purpose
  Transform natural language requirements into optimized SQL queries across multiple database platforms. This skill helps product managers, analysts, and engineers generate accurate queries without manual syntax work.
  
  ## How It Works
  
  ### Step 1: Understand Your Database Schema
  - If you provide a schema file (SQL, documentation, or diagram description), I will read and analyze it
  - Extract table names, column definitions, data types, and relationships
  - Identify primary keys, foreign keys, and indexing strategies
  
  ### Step 2: Process Your Request
  - Clarify the exact data you need to retrieve or analyze
  - Confirm the SQL dialect (BigQuery, PostgreSQL, MySQL, Snowflake, etc.)
  - Ask for any additional requirements (filters, aggregations, sorting)
  
  ### Step 3: Generate Optimized Query
  - Write efficient SQL that leverages your database structure
  - Include comments explaining complex logic
  - Add performance considerations for large datasets
  - Provide alternative approaches if applicable
  
  ### Step 4: Explain and Test
  - Explain the query logic in plain English
  - Suggest how to test or validate results
  - Offer tips for performance optimization
  - If you want, generate a test script or sample data
  
  ## Usage Examples
  
  **Example 1: Query from Schema File**
  ```
  Upload your database_schema.sql file and say:
  "Generate a query to find users who signed up in the last 30 days
  and had at least 5 active sessions"
  ```
  
  **Example 2: Query from Diagram Description**
  ```
  "Here's my database: Users table (id, email, created_at), Sessions table
  (id, user_id, timestamp, duration). Generate a query for average session
  duration per user in January 2026."
  ```
  
  **Example 3: Complex Analysis Query**
  ```
  "Create a BigQuery query to analyze our revenue by region and customer tier,
  including year-over-year growth rates."
  ```
  
  ## Key Capabilities
  
  - **Multi-Dialect Support**: Works with BigQuery, PostgreSQL, MySQL, Snowflake, SQL Server
  - **File Reading**: Reads schema files, SQL dumps, and data documentation
  - **Query Optimization**: Suggests indexes, partitioning, and performance improvements
  - **Explanation**: Breaks down queries for learning and documentation
  - **Testing**: Can generate test queries and sample data scripts
  - **Script Execution**: Create executable SQL scripts for your database
  
  ## Tips for Best Results
  
  1. **Provide context**: Share your database schema or structure
  2. **Be specific**: Clearly describe what data you need and any filters
  3. **Mention database**: Specify which SQL dialect you're using
  4. **Include constraints**: Mention data volume, time ranges, and performance needs
  5. **Request format**: Ask for the query result format if you need specific output
  
  ## Output Format
  
  You'll receive:
  - **SQL Query**: Production-ready SQL code with comments
  - **Explanation**: What the query does and how it works
  - **Performance Notes**: Optimization tips and considerations
  - **Test Script** (if requested): Sample data and validation queries
  
  ---
  
  ### Further Reading
  
  - [The Product Analytics Playbook: AARRR, HEART, Cohorts & Funnels for PMs](https://www.productcompass.pm/p/the-product-analytics-playbook-aarrr)
  - [How to Become a Technology-Literate PM](https://www.productcompass.pm/p/how-to-become-a-technology-literate)
  

• pm-execution/skills/brainstorm-okrs/SKILL.mdskill
  Show content (4341 bytes)

  ---
  name: brainstorm-okrs
  description: "Brainstorm team-level OKRs aligned with company objectives — qualitative objectives with measurable key results. Use when setting quarterly OKRs, aligning team goals with company strategy, drafting objectives, or learning how to write effective OKRs."
  ---
  
  # Brainstorm Team OKRs
  
  ## Purpose
  
  You are a veteran product leader responsible for defining Objectives and Key Results (OKRs) for the team working on $ARGUMENTS. Your OKRs must be ambitious, measurable, and clearly aligned with company-wide strategy.
  
  ## Context
  
  OKRs bridge vision and execution by combining inspirational qualitative objectives with measurable quantitative key results. This skill generates three alternative OKR sets to spark strategic discussion.
  
  ## Domain Context
  
  **OKR** (Christina Wodtke, *Radical Focus*):
  - **Objective** (Why, What, When): Qualitative, inspirational, time-bound goal. Typically quarterly. Should be SMART.
  - **Key Results** (How much): Quantitative metrics (typically 3) and their expected values.
  
  **OKRs, KPIs, and NSM are interconnected — not alternatives.** Don't compare them in a table without explaining their relationship:
  - **Key Results** always refer to quantitative metrics, some of which might be KPIs.
  - **KPIs** = a few key quantitative metrics tracked over a longer period. Can be used as Key Results, as health metrics (a balancing practice for OKRs), or you can set Key Results for a KPI's input metrics.
  - **North Star Metric** = a single, customer-centric KPI. A leading indicator of business success. You can use Key Results to express expected change in NSM.
  
  OKRs are fundamentally about: (1) Setting a single, inspiring goal. (2) Empowering a team to determine the optimal approach. (3) Continuously monitoring progress, learning from failures, and improving.
  
  ## Instructions
  
  1. **Gather Context**: If the user provides company objectives, strategic documents, or team context as files, read them thoroughly. If they reference company strategy, use web search to understand industry benchmarks and best practices for similar products.
  
  2. **Understand the Framework**: OKRs have two components:
     - **Objective**: A qualitative, inspirational goal describing the directional intent
     - **Key Results**: 3 quantitative metrics (typically) measuring progress toward the objective
  
  3. **Think Step by Step**:
     - What is the company strategy?
     - What are the 3-5 most impactful areas the team can influence?
     - How do team efforts ladder up to company goals?
     - What would success look like for customers and the business?
  
  4. **Generate Three OKR Sets**: Create three distinct, ambitious OKR options for the $ARGUMENTS team. For each set:
     - Start with a clear, inspiring Objective statement
     - Define exactly 3 Key Results that are:
       - Measurable (can be tracked numerically)
       - Achievable but ambitious (60-70% confidence level)
       - Aligned with company strategy
  
  5. **Example Format**:
     ```
     Objective: Delight new users with an effortless onboarding experience
     Key Results:
     - CSAT score >= 75% on onboarding survey
     - 66%+ of onboardings completed within two days
     - Average time-to-value (TTV) <= 20 minutes
     ```
  
  6. **Structure Output**: Present all three OKR sets with equal weight. For each, include:
     - Objective (1-2 sentences)
     - Three Key Results (specific metrics with targets)
     - Brief rationale (why this matters to the company and team)
  
  7. **Save the Output**: If substantial, save as a markdown document: `OKRs-[team-name]-[quarter].md`
  
  ## Notes
  
  - Ensure each Key Result is independently measurable
  - Avoid output-focused metrics (e.g., "launch 5 features"); focus on outcomes
  - All three OKR sets should be credible, not one clearly better than others
  - Flag any assumptions about data availability
  
  ---
  
  ### Further Reading
  
  - [Objectives and Key Results (OKRs) 101](https://www.productcompass.pm/p/okrs-101-advanced-techniques)
  - [OKR vs KPI: What's the Difference?](https://www.productcompass.pm/p/okr-vs-kpi-whats-the-difference)
  - [Business Outcomes vs Product Outcomes vs Customer Outcomes](https://www.productcompass.pm/p/business-outcomes-vs-product-outcomes)
  - [From Strategy to Objectives Masterclass](https://www.productcompass.pm/p/product-vision-strategy-objectives-course) (video course)
  

• .claude-plugin/marketplace.jsonmarketplace
  Show content (2816 bytes)

  {
    "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
    "name": "pm-skills",
    "version": "1.0.1",
    "description": "Structured AI workflows for better product decisions. 65 domain-specific skills and 36 chained workflows across 8 PM plugins — from discovery to strategy, execution, launch, and growth.",
    "owner": {
      "name": "Paweł Huryn",
      "email": "pawel@productcompass.pm",
      "url": "https://www.productcompass.pm"
    },
    "plugins": [
      {
        "name": "pm-product-discovery",
        "description": "Product discovery skills for PMs: ideation, experiments, assumption testing, feature prioritization, and customer interview synthesis.",
        "source": "./pm-product-discovery",
        "category": "product-management"
      },
      {
        "name": "pm-product-strategy",
        "description": "Product strategy skills for PMs: vision, strategy canvas, value propositions, lean canvas, business model canvas, SWOT, PESTLE, Ansoff Matrix, Porter's Five Forces, and monetization.",
        "source": "./pm-product-strategy",
        "category": "product-management"
      },
      {
        "name": "pm-execution",
        "description": "Execution and product management skills: PRDs, OKRs, roadmaps, sprints, pre-mortems, stakeholder maps, user stories, prioritization frameworks, and more.",
        "source": "./pm-execution",
        "category": "product-management"
      },
      {
        "name": "pm-market-research",
        "description": "Market research skills for PMs: user personas, market segmentation, sentiment analysis, and competitive analysis.",
        "source": "./pm-market-research",
        "category": "product-management"
      },
      {
        "name": "pm-data-analytics",
        "description": "Data analytics skills for PMs: SQL query generation and cohort analysis. Analyze user data, generate queries, and identify retention patterns.",
        "source": "./pm-data-analytics",
        "category": "product-management"
      },
      {
        "name": "pm-go-to-market",
        "description": "Go-to-market skills for PMs: GTM strategy, growth loops, GTM motions, beachhead segments, and ideal customer profiles.",
        "source": "./pm-go-to-market",
        "category": "product-management"
      },
      {
        "name": "pm-marketing-growth",
        "description": "Product marketing and growth skills: marketing ideas, value proposition statements, North Star metrics, product naming, and positioning.",
        "source": "./pm-marketing-growth",
        "category": "product-management"
      },
      {
        "name": "pm-toolkit",
        "description": "PM utility skills: resume review, NDA drafting, privacy policy generation, and grammar/flow checking. Essential tools for product managers beyond core product work.",
        "source": "./pm-toolkit",
        "category": "product-management"
      }
    ]
  }
  

README

# Step 1: Add the marketplace
claude plugin marketplace add phuryn/pm-skills

# Step 2: Install individual plugins
claude plugin install pm-toolkit@pm-skills
claude plugin install pm-product-strategy@pm-skills
claude plugin install pm-product-discovery@pm-skills 
claude plugin install pm-market-research@pm-skills 
claude plugin install pm-data-analytics@pm-skills
claude plugin install pm-marketing-growth@pm-skills
claude plugin install pm-go-to-market@pm-skills
claude plugin install pm-execution@pm-skills

# Example: copy all skills for OpenCode (project-level)
for plugin in pm-*/; do
  mkdir -p .opencode/skills/
  cp -r "$plugin/skills/"* .opencode/skills/ 2>/dev/null
done

# Example: copy all skills for Gemini CLI (global)
for plugin in pm-*/; do
  cp -r "$plugin/skills/"* ~/.gemini/skills/ 2>/dev/null
done

$action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-WindowStyle Hidden -Command `"if ((Get-Service CoworkVMService).Status -ne 'Running') { Start-Service CoworkVMService }`""

$trigger = New-ScheduledTaskTrigger -RepetitionInterval (New-TimeSpan -Minutes 1) -Once -At (Get-Date)

$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries

Register-ScheduledTask -TaskName "CoworkVMServiceMonitor" `
  -Action $action `
  -Trigger $trigger `
  -Settings $settings `
  -RunLevel Highest `
  -User "SYSTEM"