Pol Probe logo

Pol Probe

CommunityPopular
deanpeters
pol-probe

Define a Proof of Life probe to test a risky hypothesis cheaply. Use when you need harsh truth before building real product.

Overview

Publisherdeanpeters
RepositoryProduct-Manager-Skills
Skill namepol-probe
Stars
7K
Forks
831
Bundled files
3
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by deanpeters on GitHub. Read the source before you install it.

Installation

Install the Pol Probe AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/deanpeters/Product-Manager-Skills.git /tmp/Product-Manager-Skills
mkdir -p .claude/skills
cp -r /tmp/Product-Manager-Skills/skills/pol-probe .claude/skills/pol-probe
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Pol Probe in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Pol Probe on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Pol Probe is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

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.

Input

Works best with: The hypothesis or risk you need to test. Also useful: What evidence would change your mind, available time/resources, and what you've validated already.

Anything supplied with the invocation itself — text after the skill name, a pasted context dump, or an appended ARGUMENTS: line — counts as answers already given. Use it and skip whatever it covers; don't re-ask.

Arriving empty-handed? That works too. The skill asks for the hypothesis and the riskiest assumption inside it before designing the probe.

Example invocation: Define a PoL probe: we believe restaurant managers will photograph invoices daily if it auto-updates food costs.

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:

CharacteristicWhat It MeansWhy It Matters
LightweightMinimal resource investment (hours/days, not weeks)If it's expensive, you'll avoid killing it when the data says to
DisposableExplicitly planned for deletion, not scalingPrevents sunk-cost fallacy and scope creep
Narrow ScopeTests one specific hypothesis or riskBroad experiments yield ambiguous results
Brutally HonestSurfaces harsh truths, not vanity metricsPolite data is useless data
Tiny & FocusedReconnaissance missions, never MVPsSmall 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

DimensionPoL ProbeMVP
PurposeDe-risk decisions through narrow hypothesis testingJustify ideas or defend roadmap direction
ScopeSingle question, single riskSmallest shippable product increment
LifespanHours to days, then deletedWeeks to months, then iterated
AudienceInternal team + narrow user sampleReal customers in production
FidelityJust enough illusion to catch signalsProduction-quality (or close)
OutcomeLearn what doesn't workLearn 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.

TypeCore QuestionTimelineTools/MethodsWhen to Use
1. Feasibility Checks"Can we build this?"1-2 daysGenAI prompt chains, API tests, data integrity sweeps, spike-and-delete codeTechnical risk is unknown; third-party dependencies unclear
2. Task-Focused Tests"Can users complete this job without friction?"2-5 daysOptimal Workshop, UsabilityHub, task flowsCritical moments (field labels, decision points, drop-off zones) need validation
3. Narrative Prototypes"Does this workflow earn stakeholder buy-in?"1-3 daysLoom walkthroughs, Sora/Synthesia videos, slideware storyboardsYou need to "tell vs. test"—share the story, measure interest
4. Synthetic Data Simulations"Can we model this without production risk?"2-4 daysSynthea (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 daysChatGPT 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:

markdown
# 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:

markdown
**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

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Pol Probe AI skill do?

Define a Proof of Life probe to test a risky hypothesis cheaply. Use when you need harsh truth before building real product.

Why use Pol Probe on TypingMind?

Because you install it once and use it with any model. Pol Probe is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Pol Probe in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/deanpeters/Product-Manager-Skills/tree/main/skills/pol-probe. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Pol Probe?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Pol Probe?

As many as you like. As long as a model supports skills, you can use Pol Probe with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Pol Probe AI skill free?

It is published on GitHub by deanpeters. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇