pol-probe

deanpeters/product-manager-skills · updated Apr 8, 2026

MDX-style export adds YAML metadata + attribution linking explainx.ai and this canonical listing URL.

$npx skills add https://github.com/deanpeters/product-manager-skills --skill pol-probe
0 commentsdiscussion
summary

Lightweight validation framework for testing risky hypotheses before expensive product development.

  • Defines five prototype flavors (feasibility checks, task-focused tests, narrative prototypes, synthetic data simulations, vibe-coded probes) matched to specific learning goals, not tooling preference
  • Emphasizes disposability and narrow scope: PoL probes are reconnaissance missions meant to surface harsh truths and be deleted, not scaled into MVPs
  • Includes fill-in template with hypothes
skill.md

Purpose

Define and document a Proof of Life (PoL) probe—a lightweight, disposable validation artifact designed to surface harsh truths before expensive development. Use this when you need to eliminate a specific risk or test a narrow hypothesis without building production-quality software. PoL probes are reconnaissance missions, not MVPs—they're meant to be deleted, not scaled.

This framework prevents prototype theater (expensive demos that impress stakeholders but teach nothing) and forces you to match validation method to actual learning goal.

Key Concepts

What is a PoL Probe?

A Proof of Life (PoL) probe is a deliberate, disposable validation experiment designed to answer one specific question as cheaply and quickly as possible. It's not a product, not an MVP, not a pilot—it's a targeted truth-seeking mission.

Origin: Coined by Dean Peters (Productside), building on Marty Cagan's 2014 work on prototype flavors and Jeff Patton's principle: "The most expensive way to test your idea is to build production-quality software."


The 5 Essential Characteristics

Every PoL probe must satisfy these criteria:

Characteristic What It Means Why It Matters
Lightweight Minimal resource investment (hours/days, not weeks) If it's expensive, you'll avoid killing it when the data says to
Disposable Explicitly planned for deletion, not scaling Prevents sunk-cost fallacy and scope creep
Narrow Scope Tests one specific hypothesis or risk Broad experiments yield ambiguous results
Brutally Honest Surfaces harsh truths, not vanity metrics Polite data is useless data
Tiny & Focused Reconnaissance missions, never MVPs Small surface area = faster learning cycles

Anti-Pattern: If your "prototype" feels too polished to delete, it's not a PoL probe—it's prototype theater.


PoL Probe vs. MVP

Dimension PoL Probe MVP
Purpose De-risk decisions through narrow hypothesis testing Justify ideas or defend roadmap direction
Scope Single question, single risk Smallest shippable product increment
Lifespan Hours to days, then deleted Weeks to months, then iterated
Audience Internal team + narrow user sample Real customers in production
Fidelity Just enough illusion to catch signals Production-quality (or close)
Outcome Learn what doesn't work Learn what does work (and ship it)

Key Distinction: PoL probes are pre-MVP reconnaissance. You run probes to decide if you should build an MVP, not to launch something.


The 5 Prototype Flavors

Match the probe type to your hypothesis, not your tooling comfort.

Type Core Question Timeline Tools/Methods When to Use
1. Feasibility Checks "Can we build this?" 1-2 days GenAI prompt chains, API tests, data integrity sweeps, spike-and-delete code Technical risk is unknown; third-party dependencies unclear
2. Task-Focused Tests "Can users complete this job without friction?" 2-5 days Optimal Workshop, UsabilityHub, task flows Critical moments (field labels, decision points, drop-off zones) need validation
3. Narrative Prototypes "Does this workflow earn stakeholder buy-in?" 1-3 days Loom walkthroughs, Sora/Synthesia videos, slideware storyboards You need to "tell vs. test"—share the story, measure interest
4. Synthetic Data Simulations "Can we model this without production risk?" 2-4 days Synthea (user simulation), DataStax LangFlow (prompt logic testing) Edge case exploration; unknown-unknown surfacing
5. Vibe-Coded PoL Probes "Will this solution survive real user contact?" 2-3 days ChatGPT Canvas + Replit + Airtable = "Frankensoft" You need user feedback on workflow/UX, but not production-grade code

Golden Rule: "Use the cheapest prototype that tells the harshest truth. If it doesn't sting, it's probably just theater."


When to Use a PoL Probe

Use a PoL probe when:

  • You have a specific, falsifiable hypothesis to test
  • A particular risk blocks your next decision (technical feasibility, user task completion, stakeholder support)
  • You need harsh truth fast (within days, not weeks)
  • Building production software would be premature or wasteful
  • You can articulate what "failure" looks like before you start

Don't use a PoL probe when:

  • You're trying to impress executives (that's prototype theater)
  • You already know the answer and just want validation (that's confirmation bias)
  • You can't articulate a clear hypothesis or disposal plan
  • The learning goal is too broad ("Will customers like this?")
  • You're using it to avoid making a hard decision

Application

Use template.md for the full fill-in structure.

PoL Probe Template

Use this structure to document your probe:

# PoL Probe: [Descriptive Name]

## Hypothesis
[One-sentence statement of what you believe to be true]
Example: "If we reduce the onboarding form to 3 fields, completion rate will exceed 80%."

## Risk Being Eliminated
[What specific risk or unknown are you addressing?]
Example: "We don't know if users will abandon signup due to form length."

## Prototype Type
[Select one of the 5 flavors]
- [ ] Feasibility Check
- [ ] Task-Focused Test
- [ ] Narrative Prototype
- [ ] Synthetic Data Simulation
- [x] Vibe-Coded PoL Probe

## Target Users / Audience
[Who will interact with this probe?]
Example: "10 users from our early access waitlist, non-technical SMB owners."

## Success Criteria (Harsh Truth)
[What truth are you seeking? What would prove you wrong?]
- **Pass:** 8+ users complete signup in under 2 minutes
- **Fail:** <6 users complete, or average time exceeds 5 minutes
- **Learn:** Identify specific drop-off fields

## Tools / Stack
[What will you use to build this?]
Example: "ChatGPT Canvas for form UI, Airtable for data capture, Loom for post-session interviews."

## Timeline
- **Build:** 2 days
- **Test:** 1 day (10 user sessions)
- **Analyze:** 1 day
- **Disposal:** Day 5 (delete all code, keep learnings doc)

## Disposal Plan
[When and how will you delete this?]
Example: "After user sessions complete, archive recordings, delete Frankensoft code, document learnings in Notion."

## Owner
[Who is accountable for running and disposing of this probe?]

## Status
- [ ] Hypothesis defined
- [ ] Probe built
- [ ] Users recruited
- [ ] Testing complete
- [ ] Learnings documented
- [ ] Probe disposed

Quality Checklist

Before launching your PoL probe, verify:

  • Lightweight: Can you build this in 1-3 days?
  • Disposable: Have you committed to a disposal date?
  • Narrow Scope: Does it test ONE hypothesis?
  • Brutally Honest: Will the data hurt if you're wrong?
  • Tiny & Focused: Is this smaller than an MVP?
  • Falsifiable: Can you describe what "failure" looks like?
  • Clear Owner: Is one person accountable for executing and disposing of this?

If any answer is "no," revise your probe or reconsider whether you need one.


Examples

See examples/sample.md for full PoL probe examples.

Mini example excerpt:

**Hypothesis:** Users can distinguish "archive" vs "delete"
**Probe Type:** Task-Focused Test
**Pass:** 80%+ correct interpretation

Common Pitfalls

  • Running a broad "will users like this?" experiment instead of testing one falsifiable hypothesis
  • Treating a PoL probe as a proto-MVP and refusing to dispose of it
  • Using vanity metrics that avoid uncomfortable truth
  • Skipping a pre-defined failure threshold before testing begins
  • Choosing tools first and hypothesis second

References

Related Skills

External Frameworks

  • Jeff PattonUser Story Mapping (lean validation principles)
  • Marty CaganInspired (2014 prototype flavors framework)
  • Dean PetersVibe First, Validate Fast, Verify Fit (Dean Peters' Substack, 2025)

Tools Mentioned

  • Feasibility: GenAI (ChatGPT, Claude), API testing tools
  • Task-Focused: Optimal Workshop, UsabilityHub
  • Narrative: Loom, Sora, Synthesia, Veo3 (text-to-video)
  • Synthetic Data: Synthea (patient simulation), DataStax LangFlow
  • Vibe-Coded: ChatGPT Canvas, Replit, Airtable, Carrd
how to use pol-probe

How to use pol-probe on Cursor

AI-first code editor with Composer

1

Prerequisites

Before installing skills in Cursor, ensure your development environment meets these requirements:

  • Cursor installed and configured on your development machine
  • Node.js version 16.0+ with npm package manager (verify with node --version)
  • Active project directory or workspace where you want to add pol-probe
2

Execute installation command

Execute the skills CLI command in your project's root directory to begin installation:

$npx skills add https://github.com/deanpeters/product-manager-skills --skill pol-probe

The skills CLI fetches pol-probe from GitHub repository deanpeters/product-manager-skills and configures it for Cursor.

3

Select Cursor when prompted

The CLI will show a list of available agents. Use arrow keys to navigate and space to select Cursor:

◆ Which agents do you want to install to?
│ ── Universal (.agents/skills) ── always included ────
│ • Amp
│ • Antigravity
│ • Cline
│ • Codex
│ ●Cursor(selected)
│ • Cursor
│ • Windsurf
4

Verify installation

Confirm successful installation by checking the skill directory location:

.cursor/skills/pol-probe

Reload or restart Cursor to activate pol-probe. Access the skill through slash commands (e.g., /pol-probe) or your agent's skill management interface.

Security & Verification Notice

We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.

Skills execute code in your development environment. Always verify the publisher's identity, review recent commits, and test in isolated environments before production deployment.

List & Monetize Your Skill

Submit your Claude Code skill and start earning

GET_STARTED →

Use Cases

User Story & Requirements Generation

Create detailed user stories, acceptance criteria, and feature specs

Example

Generate user stories for 'password reset feature' with acceptance criteria, edge cases, and test scenarios

Reduce spec writing time by 50%, ensure comprehensive coverage

Competitive Analysis

Research competitors, compare features, identify gaps

Example

Analyze 5 competitor products, create feature comparison matrix, suggest differentiation opportunities

Complete competitive research in 2 hours instead of 2 days

Roadmap Prioritization

Evaluate features using frameworks (RICE, ICE, Kano) and create prioritized backlogs

Example

Score 20 feature ideas using RICE framework, generate prioritized roadmap with rationale

Make data-driven prioritization decisions faster

Stakeholder Communication

Draft PRDs, status updates, and stakeholder presentations

Example

Create executive summary of Q3 roadmap, monthly progress report, feature launch announcement

Save 3-5 hours/week on communication overhead

Implementation Guide

Prerequisites

  • Claude Desktop or compatible AI client
  • Access to product documentation and roadmap tools (Jira, Notion, etc.)
  • Understanding of product management frameworks (RICE, Jobs-to-be-Done, etc.)
  • Stakeholder contact information and communication channels

Time Estimate

30-60 minutes to see productivity improvements

Installation Steps

  1. 1.Install product management skill
  2. 2.Start with user story generation for known feature
  3. 3.Progress to competitive analysis: research 2-3 competitors
  4. 4.Use for roadmap prioritization: apply RICE/ICE scoring
  5. 5.Draft stakeholder communications and refine based on feedback
  6. 6.Build template library for recurring PM tasks
  7. 7.Share effective prompts with product team

Common Pitfalls

  • Not validating competitive research—verify facts before sharing
  • Accepting user stories without involving engineering team
  • Over-relying on frameworks without qualitative judgment
  • Not customizing outputs to company culture and communication style
  • Skipping stakeholder validation of generated requirements

Best Practices

✓ Do

  • +Validate research and competitive analysis with real data
  • +Collaborate with engineering when generating technical requirements
  • +Customize frameworks and templates to your company context
  • +Use skill for first drafts, refine with stakeholder input
  • +Document successful prompt patterns for PM tasks
  • +Combine AI efficiency with human judgment and intuition

✗ Don't

  • Don't publish competitive analysis without fact-checking
  • Don't finalize user stories without engineering review
  • Don't make prioritization decisions solely on AI scoring
  • Don't skip customer validation of generated requirements
  • Don't ignore company-specific context and culture

💡 Pro Tips

  • Provide context: company goals, constraints, customer feedback
  • Ask for alternatives: 'Show 3 ways to prioritize this roadmap'
  • Request stakeholder-specific formatting: 'Executive summary vs. engineering spec'
  • Use skill for 70% generation + 30% customization to company needs

When to Use This

✓ Use When

Use for user story writing, competitive research, roadmap prioritization, stakeholder communication, and PRD drafting. Best for reducing repetitive documentation and research work.

✗ Avoid When

Avoid for strategic product vision (requires deep customer empathy), pricing decisions (needs market and financial expertise), or when face-to-face customer discovery is more valuable than speed.

Learning Path

  1. 1Basic: user stories, feature specs, status updates
  2. 2Intermediate: competitive analysis, prioritization frameworks, PRDs
  3. 3Advanced: product strategy, go-to-market planning, OKR setting
  4. 4Expert: product vision, market positioning, business model innovation

Discussion

Product Hunt–style comments (not star reviews)
  • No comments yet — start the thread.
general reviews

Ratings

4.653 reviews
  • Nikhil Rao· Dec 28, 2024

    Keeps context tight: pol-probe is the kind of skill you can hand to a new teammate without a long onboarding doc.

  • Alexander Malhotra· Dec 24, 2024

    pol-probe fits our agent workflows well — practical, well scoped, and easy to wire into existing repos.

  • Aarav Sharma· Dec 20, 2024

    Registry listing for pol-probe matched our evaluation — installs cleanly and behaves as described in the markdown.

  • Pratham Ware· Dec 12, 2024

    pol-probe reduced setup friction for our internal harness; good balance of opinion and flexibility.

  • Amelia Iyer· Dec 4, 2024

    I recommend pol-probe for anyone iterating fast on agent tooling; clear intent and a small, reviewable surface area.

  • Min Bansal· Nov 23, 2024

    pol-probe reduced setup friction for our internal harness; good balance of opinion and flexibility.

  • Alexander Chawla· Nov 19, 2024

    pol-probe has been reliable in day-to-day use. Documentation quality is above average for community skills.

  • Aarav Haddad· Nov 11, 2024

    Useful defaults in pol-probe — fewer surprises than typical one-off scripts, and it plays nicely with `npx skills` flows.

  • Yash Thakker· Nov 3, 2024

    I recommend pol-probe for anyone iterating fast on agent tooling; clear intent and a small, reviewable surface area.

  • Arjun Patel· Nov 3, 2024

    We added pol-probe from the explainx registry; install was straightforward and the SKILL.md answered most questions upfront.

showing 1-10 of 53

1 / 6