Claude Code Plugins Are Turning Engineers Into PMs

YC Asked for a "Cursor for PMs." The Ecosystem Built It.

Y Combinator's Spring 2026 Request for Startups included a category that made every PM tool founder nervous: "Cursor for Product Managers." The ask was specific — upload customer data, ask "what should we build next?", get feature outlines with reasoning.

While startups raced to build dedicated PM products, something unexpected happened. The Claude Code plugin ecosystem — an open-source, community-driven collection of skills, commands, and workflows — quietly assembled the components YC described. Not as a single product, but as a composable system of plugins that turn a CLI agent into a product management powerhouse.

The plugins didn't come from a product company. They came from engineers who were already doing PM work and built the tools they needed.

The Superpowers Framework: Brainstorm, Plan, Implement

Superpowers is the most popular Claude Code plugin framework, and it's the backbone of the PM workflow ecosystem. Created by Jesse Vincent, it encodes a structured development methodology: brainstorm first, plan second, implement third.

The framework's key insight is that AI agents are too eager to code. Ask Claude Code to "add a notification system" and it starts writing code immediately. Superpowers interrupts this impulse with mandatory process gates:

Brainstorm. Before any implementation, the agent explores the problem space. What are the requirements? What are the edge cases? What exists in the codebase that's relevant? The output is a design document, not code.

Plan. The brainstorm becomes a structured plan — specific files to create or modify, acceptance criteria, architectural decisions. The plan is reviewed before implementation starts.

Implement. Only after brainstorm and plan are reviewed does the agent write code. And it does so in an isolated git worktree, so the main branch stays clean until the work is verified.

Vincent's approach to building skills is itself fascinating. He pressure-tested them using Robert Cialdini's persuasion principles — simulating production emergencies with "$5k/minute cost pressure" to see if the agent would skip process under stress. The discovery: persuasion research applies to LLMs, and skills need to be written to resist exactly the kind of urgency that makes humans cut corners.

The result: skills that are "mandatory, not advisory." As Vincent puts it: "If you have a skill to do something, you must use it." The framework doesn't suggest process — it enforces it.

47 PM Skills, One Install Command

Dean Peters' Product-Manager-Skills is the most comprehensive PM-specific plugin for Claude Code. With 3,000+ GitHub stars and 47 skills across three tiers, it encodes decades of product management frameworks into agent-executable workflows.

Component Skills (21 skills, 10-30 minutes each). The building blocks — user story generation, persona creation, PRD writing, competitive analysis, feature prioritization, stakeholder mapping. Each skill is a structured workflow the agent runs interactively, asking clarifying questions and producing formatted output.

Interactive Skills (20 skills, 30-90 minutes each). Guided discovery sessions with 3-5 adaptive questions. Customer journey mapping, opportunity scoring, assumption testing, market sizing. These encode frameworks from Teresa Torres (Continuous Discovery Habits), Geoffrey Moore (Crossing the Chasm), Amazon's Working Backwards methodology, and Jobs-to-Be-Done theory.

Workflow Skills (6 skills, spanning weeks). Full product processes — product strategy sessions, discovery cycles, launch planning, retrospectives. These orchestrate multiple component and interactive skills into end-to-end workflows.

Install it with a single command: /plugin marketplace add deanpeters/Product-Manager-Skills. Claude Code immediately gains structured PM capabilities. Type /user-story and the agent walks you through a Jobs-to-Be-Done framework to generate a user story grounded in your codebase. Type /competitive-analysis and it runs a structured competitive assessment.

Peters' design principle is worth noting: "Always Be Coaching." Every skill includes explanatory context alongside its outputs. The agent doesn't just generate a PRD — it explains why each section matters, which framework it's applying, and how to evaluate the output. The plugin "simultaneously serves two audiences — it equips AI agents to perform PM work competently while teaching human product managers the reasoning behind each framework."

Spec-Driven Development, as a Plugin

Claude-code-spec-workflow takes spec-driven development and encodes it directly into Claude Code. The workflow moves through four stages:

1. Requirements — gather and document what needs to be built, grounded in the codebase
2. Design — architectural decisions, data models, API shapes
3. Tasks — decompose the design into implementable work items
4. Implementation — build against the spec with continuous verification

The plugin includes "steering documents" — product.md, tech.md, structure.md — that provide persistent context across sessions. The agent reads these before every task, maintaining coherence over multi-day development cycles.

Similarly, cc-sdd implements Kiro-style spec-driven development with explicit requirement-to-design-to-task steering. The spec isn't a document you write once — it's a live artifact the agent reads, updates, and verifies against throughout implementation.

These plugins solve the problem that kills PRDs within 48 hours: disconnection between spec and code. When the spec is a plugin artifact that the agent references during implementation, drift becomes detectable — because the same system that reads the spec is writing the code.

The Marketplace Model

The Superpowers Marketplace aggregates plugins into an installable ecosystem. Beyond PM-specific skills, it includes:

• Core development skills — brainstorming, planning, TDD, code review, debugging, git worktree management
• Elements of Style — a writing plugin based on Strunk & White that improves agent prose output (useful for PM communication)
• Development documentation — 42+ official docs baked into agent context for reference

The marketplace model matters because it's composable. A PM who installs Product-Manager-Skills, Superpowers core, and a spec-workflow plugin gets an integrated system — the brainstorm skill feeds the spec workflow, which feeds the implementation pipeline, which gets reviewed by the code review skill. Each plugin is independent, but together they form a coherent product development methodology.

Awesome-claude-code maintains the broadest index — a curated list of every significant plugin, hook, slash command, and tool in the ecosystem. It's the starting point for discovering what's available and the closest thing the ecosystem has to a package registry.

For PM-specific extensions beyond Peters' package, alirezarezvani/claude-skills offers 248 production-ready skills spanning product, marketing, compliance, and C-level advisory work across 11 AI coding tools. Product-on-purpose/pm-skills provides 27 plug-and-play PM skills with templates and workflow bundles. The ecosystem is deep and growing fast.

Skills vs. MCP: The Architecture Debate

There's a fascinating architectural tension in the Claude Code ecosystem between skills (markdown-based instructions) and MCP (protocol-based tool access). Shankar — whose team runs one of the largest Claude Code deployments — argues that skills represent a more powerful model:

The practical distinction: skills tell the agent HOW to think about a problem. MCP gives the agent access to external data. For PM work, you need both — skills that encode PM methodology (how to write a spec, how to prioritize, how to run discovery) and MCP that provides product context (the specs themselves, customer feedback, board state).

The tools that win will be the ones that provide both layers: structured methodology via skills AND structured data via MCP. A skill that knows how to write a spec, connected to an MCP server that provides the codebase context, customer feedback, and existing decisions the spec needs to reference.

The Self-Improving Loop

The most powerful pattern in the plugin ecosystem isn't any individual skill — it's the flywheel.

Shankar described his team's approach: they review agent logs from CI, feed them back into Claude, and ask "what were other agents getting stuck on? Fix it." The system improves itself. Vincent extracted 2,249 markdown files from previous conversations, clustered the lessons learned, and mined them for new skills.

This is what makes the plugin ecosystem fundamentally different from a PM tool: it evolves from usage. Every team that uses these skills and encounters friction can write a new skill, submit it to the marketplace, and improve the system for everyone. The open-source PM tool that nobody's built might not be a tool at all — it might be a skill ecosystem.

The Stack Is Assembling Itself

Step back and look at what exists today in the Claude Code ecosystem:

• Discovery: Product-Manager-Skills provides structured discovery frameworks
• Specification: Spec-workflow plugins encode requirements-to-design-to-tasks pipelines
• Planning: Superpowers enforces brainstorm-plan-implement methodology
• Implementation: Claude Code itself, with full codebase context
• Review: Code review skills check PRs against intent
• Iteration: Self-improving loops mine agent logs for process improvements

This is a product development stack. It's distributed across a dozen repos, maintained by a community of engineers, and assembled by individual teams who install the plugins they need. It's not polished. It's not integrated. But it works — and it's evolving faster than any single product company can ship features.

The "Cursor for PMs" that YC asked for isn't a startup. It's an ecosystem. And the layer that's still missing — the structured product knowledge that all these skills need to reference — is the opportunity.

The spec, the board, and the institutional memory need a home. Not a static document. Not a flat file. A live system that these plugins can query via MCP, that accumulates company knowledge over time, and that keeps specs connected to code as implementation evolves.

The skills know how to do PM work. They just need something to think with.