Claude Skills: The Complete Guide for Product Managers

The first time I read a Claude Skills folder out loud to a product manager, her reaction was: "wait, that's it? It's just a markdown file that tells Claude how to do the thing right, every time?" Yes. That is the entire mechanism. And because the mechanism is that simple, the interesting question is not "how do I write a skill". It is "which skills should a product manager actually run".

After a full cohort season of teaching Claude Code to product managers, I packaged the answer into the Product Builder Kit: 10 Claude Code skills covering the full feature lifecycle, from the first user interview to the post-launch recap. This post walks through all 10, what each one produces, and how they chain into a system. You can install the whole kit in two commands and have every skill running before you finish reading.

What a Claude Skill Is, in 60 Seconds

A skill is a folder containing a SKILL.md file: a name, a description, and a set of instructions. The description acts as the trigger. When your request matches it, Claude loads the instructions and follows them. That is the whole trick.

The reason this matters for product managers is consistency. Prompting from scratch gives you a different PRD structure every Tuesday. A skill encodes your template, your rules, and your quality bar once, and applies them every single time. As Anthropic's own engineering team put it when they introduced the format, "Claude is powerful, but real work requires procedural knowledge and organizational context." A skill is exactly that: procedural knowledge, written down, loaded on demand.

If you want the deeper mechanics (file anatomy, triggering, where skills live), our series on mastering Claude Code covers them. Here, we focus on the skills themselves.

Install the Product Builder Kit in Two Commands

The repo doubles as a Claude Code plugin marketplace, which means installation is two commands from any Claude Code session:

/plugin marketplace add julesb22/product-builder-kit
/plugin install pm-skills@product-builder-kit

Run /reload-plugins and all 10 skills are available in every project. Every skill writes its output to a product/ folder at your repo root (product/insights/, product/prds/, product/tickets/), so each skill can find what the previous one produced.

The 10 Skills, Across the Full Feature Lifecycle

Discovery and Definition

1. user-interview-synthesizer. Feed it raw interview transcripts or call notes (it plays especially well with Granola exports) and it returns a structured insight doc: pains ranked by frequency, verbatim quotes for each, and candidate opportunities. Crucially, it appends everything to a running product/insights/ knowledge base, so evidence compounds across interviews instead of dying in scattered docs.

2. funnel-analyst. Points at your analytics through the Amplitude MCP and answers the question that matters: where are users dropping off, and why does it matter. It knows how to pick the right chart type and segment properly, and it always returns one highest-ROI action rather than a data dump. If you have ever received a 40-screenshot "analysis" from a dashboard tool, this is the antidote.

3. competitor-teardown. Give it two or three competitor URLs and it produces a positioning map, a feature-gap table, and a pricing comparison, pulling screenshots via browser automation along the way. The output drops straight into your insights folder next to the interview evidence.

4. opportunity-prioritizer. Takes a messy list of ideas and requests (or simply reads your insights folder) and runs RICE scoring with explicit, challengeable assumptions written down for every score. The output is a ranked table plus a section most prioritization exercises skip: what we are explicitly NOT doing.

5. prd-writer. The centerpiece of the kit. It produces a one-page PRD in SCR format (Situation, Complication, Resolution), and its defining behavior is that it interviews you first: the five questions a good engineering manager would ask before accepting the work. It refuses to write solutions before the problem section is solid. No more PRDs hallucinated from a one-sentence prompt.

6. user-flow-mapper. Turns the PRD into user flow diagrams, error states included, as Mermaid (renders anywhere, versionable in git) with optional Whimsical export. The flows land in product/flows/, ready for the prototype step.

Design and Validation

7. prototype-builder. Takes the PRD and the flows and drives Lovable through its MCP to spin up a clickable prototype, then iterates from your feedback. The skill encodes the prompt patterns that actually produce good Lovable output: design constraints, scope guardrails, and a firm "prototype, not production" framing.

8. lead-dev-validator. The skill I wish every PM had before their next sprint planning. It reviews your actual codebase and delivers a shipping-feasibility verdict on your feature: Green (straightforward), Orange (doable with caveats it lists), or Red (blocked, with the specific reason). It speaks PM language, translating technical findings instead of dumping file paths, and it means you walk into the eng conversation already knowing where the landmines are.

Delivery and Post-Launch

9. eng-handoff-writer. Converts the PRD into scoped, testable tickets formatted for Linear or Jira: user story, acceptance criteria, edge cases, and the section most PMs forget until after launch, the analytics events to instrument. Tracking gets designed with the feature, not bolted on afterwards.

10. launch-recap-writer. Closes the loop. It pulls the real numbers from Amplitude, compares them against the success metrics your PRD committed to, and writes the stakeholder update plus a keep, iterate, or kill recommendation. The loop then feeds back into funnel-analyst for the next cycle.

Why 10 Skills Beat 10 Prompts

The kit is designed around one principle: the outputs chain. Interviews feed insights, insights feed priorities, priorities feed the PRD, the PRD feeds the flows, the prototype, the feasibility check, the tickets, and finally the launch recap closes the loop back into analytics. It is a system, not 10 disconnected tricks, and it mirrors the agent stack that replaces hand-offs to growth, data, and eng that the best AI-native product teams are converging on.

Two design rules run through every skill. First, graceful degradation: the tool-dependent skills (Granola, Amplitude, Whimsical, Lovable) still work when the integration is not connected, they just ask you for the inputs instead. Second, no invented data, ever: if there is no interview evidence or no analytics connection, the skill says so instead of fabricating numbers. Nothing fails silently.

And because skills are plain markdown, the kit composes with everything else in your Claude Code setup. Wrap a skill in a custom command to run it on a schedule, hand it to subagents so five competitor teardowns run in parallel, and let Claude Code Memory capture your corrections so every run gets closer to how you would have done it yourself.

The Takeaway

You do not need to become a skill author to get the benefit of Claude Skills. The Product Builder Kit on GitHub gives you 10 of them, covering discovery, definition, design, validation, delivery, and post-launch, installable in two commands and built from real product work rather than theory. Install it, run prd-writer on the feature currently sitting half-defined in your backlog, and see the difference a written-down quality bar makes. And if you are starting from zero with Claude Code itself, begin with our first-week guide for non-technical PMs, then come back for the kit.