pragmatic-pm-ai-skills Review: A Claude Skill That Tightens PM-AI Output

The short version

pragmatic-pm-ai-skills is a small Claude Skill library by Valentin Brain that installs into Claude Code or Cursor and enforces four behavior rules on every AI output: audit incentives first, prefer one-page artifacts, tie every claim to proof, and treat every deliverable as a testable hypothesis. Plus a "bullshit detector" that flags generic advice and demands a concrete alternative. It scores 5 out of 5 against the falkster PM Operating System POV. The only gap: it's a constraint layer, not an agent fleet. Install it alongside your agent fleet, not instead of it.

Most PM-AI prompt libraries bounce off me in a week

I keep installing and uninstalling PM-AI prompt packs. The pattern is always the same. Day one I'm enthusiastic. Day three the prompts are producing 900-word memos that sound like a LinkedIn think-piece. Day seven I've uninstalled the thing and gone back to writing my own.

The library at github.com/vltnbrain/pragmatic-pm-ai-skills, by Valentin Brain, is the first one in a while that stayed. I've been playing with it in Claude Code and Cursor for a few days now. It has already changed how every AI output lands on my desk. This is the early read.

The library is 200 lines of opinionated restraint

Strip the repo down to what it actually is. One skill (pragmatic-pm-guidelines), one page of instructions, four principles, one anti-pattern filter. No agents, no data connectors, no cron schedules. It's a behavior constraint set that every Claude or Cursor conversation inherits.

The four principles:

1. Intent-First Discovery. Identify the target actor. State their local optimization. State explicit constraints. Ask before assuming.
2. Friction Reduction and MVP. Prefer one-page artifacts over long docs. One clear ask over narrative positioning. Remove complexity that does not change a decision.
3. Signal-to-Noise Ratio. Keep claims tied to proof: metric, shipped output, date, owner. Cut filler. Edit only sections that impact decisions.
4. Evidence-Based Outcomes. Treat every deliverable as a hypothesis. Include expected behavior change, metric, baseline, observation window, and trigger for the next decision.

And the anti-pattern filter I genuinely love:

Bullshit Detector. If the output contains generic advice, tag it [GENERIC_ADVICE], replace it with a concrete alternative, and ask for the real blocking constraint.

The repo also ships an EXAMPLES.md with 16 before/after scenarios across recruiting, discovery, PRDs, and stakeholder comms. And a BENCHMARK.md that measures whether the skill actually changes three metrics: response rate, approval speed, and PRD clarification rate.

That's the whole library. Small, dense, and opinionated in a way I respect.

Where it fits my POV (five strong hits)

I've written a lot on falkster about outcome-driven planning, the PM operating model, and the death of the PRD. Here's where the skill lines up with that worldview.

1. Evidence-Based Outcomes is the Impact Loop in skill form. The principle says every artifact needs expected behavior change, metric, baseline, observation window, and a trigger for the next decision. That's the Impact Loop compressed into frontmatter. When you install this skill, every AI output you generate inherits that structure. You stop producing strategy docs that forget to name the metric.

2. Intent-First Discovery is Teresa Torres with better enforcement. Discover the actor's incentives before proposing a solution. This is continuous-discovery orthodoxy, but most PMs I know skip it because there's no check on whether they did the work. Having the AI refuse to propose actions until incentives are named is the constraint most PMs actually need.

3. Friction Reduction is my one-pager reflex. I've killed more PRDs than I've written in the last year. One-page briefs over 12-page specs. One clear ask over a deck that hedges. The skill bakes this into the AI's defaults. My outputs got tighter the day I installed it.

4. Signal-to-Noise is the voice guide I've been trying to teach every PM. "Claims tied to proof (metric, shipped output, date, owner)" is exactly what I look for when I review a PRD. The skill enforces it automatically. When Claude wants to write "this feature will drive significant engagement," the skill reshapes the output to "activation for SMB trials targeted +6pp vs current 38%, measured weekly, decision trigger at week 4." Same idea, four times more useful.

5. The Bullshit Detector is the feature I wish every AI shipped with. Tagging generic advice and forcing a concrete alternative is the filter PMs don't realize they need until they have it. Half the LinkedIn posts on AI for PMs would not survive this filter. Neither would half of my own early drafts.

Five hits out of five principles. Unusual for a prompt library.

Where it stops short (the honest gap)

This is a voice and constraint layer. It is not an agent fleet, an automation layer, or a data pipeline. That's a real gap against my broader POV, and it's worth naming.

It's a passive skill, not active automation. The skill shapes what comes out of your Claude conversations. It does not run on a schedule. It does not pull from your Jira, Gong, Salesforce, or Amplitude. It does not deliver outputs to Slack at 9am. For the continuous, scheduled agent work I rely on, you still need the fleet wired into MCP.

Still document-centric. The examples in the repo are PRDs, memos, launch checklists, escalations. The "good" versions are shorter and sharper, but they're still documents. My actual practice is closer to prototype-first: skip the spec, show the working thing. The skill would happily produce a tight PRD. It wouldn't push you to prototype instead.

The benchmark is proxy metrics. The BENCHMARK.md file measures response rate, approval speed, and PRD clarification rate. All useful. All process metrics, not customer-outcome metrics. The real question, which the benchmark doesn't ask, is whether the features you shipped moved the customer metric you said they would. Pair this benchmark with the KPI Watchdog if you want the outcome half.

None of these are flaws, exactly. They're the scope the author chose. The library is honest about being a behavior layer, not a full operating system. I just want to be clear about what you're buying.

How I actually use it

Three places, in order of impact.

Installed globally in Cursor and Claude Code. Via the Claude marketplace and the .cursor/rules files the repo ships. Every conversation inherits the four principles. Output quality is measurably better. I spend less time editing.

Loaded as a skill inside my agent fleet runs. When a fleet agent generates output (an exec report, a PRD draft, a release note), the pragmatic-pm-guidelines skill runs as a pre-check. The agent's raw output gets passed through the Bullshit Detector before it lands in Slack. I cut one round of editing.

As a shared team standard. This is the sleeper use case. When everyone on the team has the skill installed, all our AI-generated artifacts start speaking the same compressed, evidence-tied dialect. PRDs look alike. Exec updates look alike. Review cycles get faster because the surface area you're reviewing is predictable.

The third one is where the ROI compounds. One PM running this is nice. A whole team running it changes how your org writes.

The honest takeaway

Install it. It's 200 lines of someone else's opinionated restraint, and the opinions are good ones. It fits the falkster POV on five of five principles. The one gap (it's a constraint layer, not an automation layer) is orthogonal to my fleet, so it complements rather than competes.

If you're building your own agent fleet, use this skill as the default voice for every agent's output. If you're not there yet, installing this in Cursor or Claude Code is the cheapest 30-minute upgrade to your PM-AI workflow I know of.

Pick one thing this week

1. Clone or install the plugin from github.com/vltnbrain/pragmatic-pm-ai-skills. Five minutes in Claude Code, ten in Cursor.
2. Pick the next artifact you were going to draft (PRD, memo, exec update, cold outreach). Let Claude draft it with the skill active.
3. Compare it against what you would have written. If the skill's version is tighter, evidence-tied, and uses fewer words to make the same point, keep the skill on.
4. Run the repo's mini benchmark: response rate, approval speed, PRD clarification rate. Two baseline weeks, then two weeks with the skill active. If the numbers move, you have the quantitative proof. If they don't, you've learned that your org's bottleneck is somewhere else.

Credit to Valentin Brain for making the small, opinionated thing instead of the big, generic one. Those are the libraries that actually stick.

---

Sources:

• Author: Valentin Brain on LinkedIn
• Repository: vltnbrain/pragmatic-pm-ai-skills