PM Superpowers 🧭

Ask “what’s our moat?” about your own product and get a straight answer in about five minutes.

_{Current recording of the re-run Linear example (about 33s).}

Install

Claude Code

claude plugin marketplace add aniganti/pm-superpowers
claude plugin install pm-superpowers

Then ask find my moat for <your product>.

Cursor

git clone --depth 1 https://github.com/aniganti/pm-superpowers.git /tmp/pms
mkdir -p ~/.cursor/plugins/local && cp -R /tmp/pms/plugins/pm-superpowers ~/.cursor/plugins/local/pm-superpowers

Reload Cursor, then ask find my moat for <your product>.

What you get back

A thin first pass on Linear, from the same public inputs, re-run under the current skill. Four moat types scored, four screened yes or no. Full write-up: examples/find-your-moat-linear.md.

Depth: Thin first pass (4 types scored, 8 screened). Not a complete defensibility assessment.

Moat type	Rating	Evidence	Deepen
Feedback loops	Moderate	Filing or updating an issue does not wait on the network (Linear's public local-first sync writeup), and Cycles are the product's repeating cadence: the Method describes an n-week cycle as the routine where a team sets priorities and unfinished work rolls forward. [public web]	At the next cycle close, show one pre-filled line of customer-request issues finished that cycle, and see whether the team opens the cycle without a reminder.
Network effects	None	N/A, not a dependency [inference]	Do not fund a cross-company network. If the only growth idea is inviting another teammate, count it as seat expansion.
Switching costs	Moderate	Linear's migration guide treats a move from Jira or GitHub Issues as an import plus a rewire of GitHub, Slack, and support tools, and offers two-way sync so a team can avoid a hard cutover. [public web]	On one team, write the exit inventory: issues that export, and cycle history plus automations that stay behind. Spend the week making cycle history and automations the reason a team stays.
Unique data/tech	Emerging	The public sync-engine post documents a real local-first system, with the largest workspaces producing close to one million sync actions a day, and the public product does not show usage compounding into a dataset Jira or GitHub cannot assemble. [public web]	For one workspace, plot triage-suggestion accept rate against workspace age. If the rate is flat, the advantage is the engine's speed, not a data flywheel.

Moat type	Could this be a primary moat?	Evidence
Ecosystem lock-in	No	Linear is one workspace. GitHub, Slack, and support-tool connectors are integrations, and the migration guide's two-way sync is a way out, not a suite a team loses by leaving. [public web]
Economies of scale	No	N/A, not a dependency [inference]
Brand and trust	No	The public site and the Method give software teams a point of view, and they do not show a reputation barrier a faster issue tracker would need years to copy. [public web]
Regulatory barriers	No	N/A, not a dependency [inference]

So-what

Strongest scored: Switching costs. A settled team leaves behind issue history, the cycle rhythm, and the GitHub, Slack, and support-tool wiring. The rating stays Moderate because Linear's own importers and two-way GitHub sync are a built-in way through that wall.
Most at-risk moat: Switching costs — the business depends on issue history, the cycle rhythm, and the tool wiring, and the substitute (GitHub Projects) lets a team plan where the code lives without migrating that history, because Linear's own two-way sync copies new issues into GitHub. [public web]
Competitor-copy risk: GitHub Projects is the substitute. Linear's GitHub issue sync copies new issues into the system where the code already lives, so a team can plan in GitHub Projects and keep Linear as a mirror. Jira remains the suite teams buy when they want Atlassian's breadth. Local-first speed and the cycle habit are the parts with a slower copy.
Do this week: On one team, turn on two-way GitHub Issues sync for a single cycle and watch where planning actually happens. If the cycle review stays in Linear, keep sync as an issue mirror. If planning moves to GitHub, move the cycle review back into Linear so the GitHub copy stays issues only.

If that was useful on your product, a ⭐ helps other PMs find it.

Skills · Getting started · Companion plugin · Frameworks · Contributing · MIT

pm-superpowers-grid

_{Thirteen skills, one sub-agent, zero prompt engineering.}

What is this, really?

It's a plugin for Claude Code, Cursor, and Grok Bot: a set of skills, one sub-agent, and a shared library of framework definitions, packaged so they trigger naturally in conversation instead of living in a doc you have to remember to open.

Origin. In 2022 Ani published a 6-step product strategy framework. In 2026 that thinking became this runnable plugin.

In practice it feels like having a strategy-minded chief of staff who's read VRIO, aggregation theory, and every pre-mortem post-mortem, and asks the right follow-up question instead of just generating a wall of text. You don't copy-paste a prompt — you say "find my moat" for a thin first pass on your product, or run /strategy when you want the full framework, and the skill walks you through it step by step.

Most AI-for-PM tools stop at "generate a PRD." They help you write faster, not think straighter. PM Superpowers is grounded in named, proven strategy frameworks — the AI doesn't freestyle; it interviews you the way a sharp analyst would, then structures the output around the framework's actual dimensions.

Stuff you do with it

Get a VRIO read on your differentiation before it becomes a slide in the board deck — Value, Rarity, Imitability, Organization, applied to your actual product.
Stress-test a launch with a pre-mortem before the launch stress-tests you — Tigers, Paper Tigers, and Elephants, named and owned.
Run competitive research without opening fifteen tabs — a sub-agent gathers the intelligence, you review the synthesis.
Turn a strategy doc into a briefing your VP will actually read — audience-specific FAQs and workshop agendas generated from the artifacts you already built.
Log a decision the moment you make it — reasoning, alternatives, and trade-offs captured while you still remember why, not reconstructed from Slack three months later.

Getting started

Claude Code

Installing the pm-superpowers plugin in Claude Code

# Add the marketplace
claude plugin marketplace add aniganti/pm-superpowers

# Install the plugin
claude plugin install pm-superpowers

Then ask "find my moat" for a thin first-pass read on your product. For a skill menu, ask "skill guide." Run /strategy when you want the full framework.

Cursor / Grok Bot

Install from a local copy. This works today:

git clone --depth 1 https://github.com/aniganti/pm-superpowers.git /tmp/pms
mkdir -p ~/.cursor/plugins/local && cp -R /tmp/pms/plugins/pm-superpowers ~/.cursor/plugins/local/pm-superpowers

Reload Cursor, then ask "find my moat" for a thin first-pass read on your product. For a skill menu, ask "skill guide."

The same GitHub repo powers Claude Code and Cursor. Cursor discovers skills from plugins/pm-superpowers/skills/ via .cursor-plugin manifests — Claude Code continues to use .claude-plugin.

Cursor local-copy notes

Copy the plugin directory rather than symlinking the git checkout; Cursor skips symlinks that point outside ~/.cursor/plugins/local. Reload Cursor (Developer: Reload Window) and confirm the skills appear under Plugins / Customize. This copy includes .cursor-plugin/plugin.json, skills/, and agents/. Repo-root references/ is shared documentation, not required for Cursor skill discovery.

From a checkout you already have, the same copy is:

mkdir -p ~/.cursor/plugins/local
cp -R plugins/pm-superpowers ~/.cursor/plugins/local/pm-superpowers

To update the public Cursor listing, submit this repo at cursor.com/marketplace/publish. Do not create a second marketplace.

Live X/Twitter research is a separate, optional Claude/Hermes companion — see Companion plugin. You do not need it to use PM Superpowers.

I want to add a skill or framework

See CONTRIBUTING.md — new skills, new frameworks, agents, and bug fixes are all welcome. Direct pushes to main aren't accepted; everything goes through review.

What's inside

Strategic advisor skills

Skill	What it does
`find-your-moat`	Thin first-pass moat read on your product — four types scored, all eight screened, a short so-what, and a saved artifact. Start here for first value. Not a full defensibility assessment.
`strategy`	Full 6-step interactive workflow: market analysis → problem space → strategic pillars (VRIO) → design/technical alignment → vision/mission/goals → communicate
`competitive-landscape`	Standalone competitor analysis with automated web research via sub-agent
`vrio-analysis`	VRIO framework competitive advantage evaluation — Value, Rarity, Imitability, Organization — applied to your specific product
`strategic-moat`	Full defensibility assessment across 8 moat types, including the most-at-risk moat. Optional 10-K / 20-F check when the product is a public company
`product-ecosystem`	Aggregation theory and value chain analysis for platform/ecosystem strategy

Planning & execution skills

Skill	What it does
`pre-mortem`	Launch readiness risk analysis using the Tigers / Paper Tigers / Elephants framework
`prioritization`	Framework-driven feature/initiative prioritization using RICE, ICE, or weighted scoring — grounded in strategic pillars
`decision-log`	Structured capture of product decisions with reasoning, alternatives, evidence, and trade-offs — builds institutional memory

Alignment & communication skills

Skill	What it does
`stakeholder-alignment`	Transforms strategy artifacts into tailored briefing docs, audience-specific FAQs, and workshop agendas for each stakeholder group
`verification`	Quality gate that re-reads any artifact against structured checklists and issues a PASS / PASS WITH WARNINGS / FAIL verdict

Utility skills

Skill	What it does
`prompt-builder`	Guided AI prompt creation through 9 structured questions — role, audience, outcome, obstacles, tone, task, context, examples, format
`skill-guide`	Interactive guide to all available skills, recommended workflows, and output save locations

Sub-agents

Agent	What it does
`competitive-researcher`	Automated competitive intelligence gathering via web research, plus a public-company 10-K or 20-F fetch when a moat skill asks

Companion plugin

hermes-tweet is an optional, documentation-only companion for Claude Code and Hermes Agent. It is not listed in the Cursor marketplace: the skill only guides live tweet_* work in a Hermes runtime, which Cursor / Grok Bot do not provide. Installing it in Claude Code does not add X/Twitter tools and does not run live research.

Live work requires a separate Hermes Agent session with the native Hermes Tweet plugin. That runtime uses Xquik, a third-party paid API (account, API key, and sufficient plan or credits). PM Superpowers does not provide or operate it. Xquik is not affiliated with this project or with X Corp.

Plugin	Skill	What it does
`hermes-tweet`	`social-signal-intelligence`	Guides X/Twitter launch monitoring, competitive listening, and evidence capture in Hermes — then you feed that evidence into the skills above.

# Guidance only — does not add tweet_* tools to Claude Code
claude plugin install hermes-tweet

# Live research: native Hermes plugin + optional PyPI fallback
hermes plugins install Xquik-dev/hermes-tweet --enable
uv pip install --python ~/.hermes/hermes-agent/venv/bin/python hermes-tweet

Keep XQUIK_API_KEY in the Hermes runtime, not in chat, prompts, or this repo. See plugins/hermes-tweet/README.md for setup and safety defaults.

Available today · Being sharpened · Under consideration

✅ Available today	🚧 Being sharpened	💭 Under consideration
13 skills across strategy, planning, and alignment	Deeper workflow chaining between skills (auto-suggest next step)	Skills for OKR authoring and quarterly planning
1 sub-agent for competitive research	Richer verification checklists per artifact type	Multi-product / portfolio-level strategy rollups
Optional docs-only companion for Hermes X/Twitter research	More worked examples in `references/`	Native integrations with roadmap tools (Jira, Linear)
Claude Code via `claude plugin`; Cursor via the local copy at the top of this page

_{The 💭 column is intent, not a promise — see CONTRIBUTING.md if you want to help build it.}

Two little stories

The QBR nobody dreaded. A PM runs competitive-landscape, then vrio-analysis on the same product. Twenty minutes later they have a defensibility argument built on named advantages, not adjectives. strategic-moat adds the eight-moat check. By the time strategy synthesizes it into pillars, the QBR deck writes itself — and survives the first hard question.

The launch that didn't blow up. Two weeks before ship, a PM runs pre-mortem. The skill surfaces three Tigers (real risks), two Paper Tigers (looked scary, aren't), and one Elephant nobody wanted to name out loud — a dependency on a team that hasn't confirmed capacity. It gets named. stakeholder-alignment turns the findings into a one-pager for the exec review. The launch ships on time, because the risk got caught in week two instead of week six.

Recommended workflows

First value after install

find-your-moat → strategic-moat  (or competitive-landscape / vrio-analysis)

Just installed or want a real moat read on your product now? Start with the thin pass, then deepen or enter the full strategy pipeline.

Full Strategy Pipeline

competitive-landscape → vrio-analysis → strategic-moat → strategy → pre-mortem

Each skill's output feeds into the next. Start with external landscape, move to internal capabilities, synthesize into strategy, then stress-test.

Launch Readiness

pre-mortem → stakeholder-alignment

Decision Capture

[any analysis skill] → decision-log → stakeholder-alignment

Prioritization

strategy → prioritization → stakeholder-alignment

Social signal → strategy evidence

[Hermes + hermes-tweet] → competitive-landscape / pre-mortem / decision-log / prioritization

Capture public X/Twitter evidence in Hermes, then bring it into Claude Code as source material. Do not expect live tweet_* tools here.

Run verification after any of these before sharing artifacts with stakeholders.

Where outputs are saved

All artifacts are saved to the docs/ directory:

Skill	Save Location
find-your-moat	`docs/strategic-moat/YYYY-MM-DD-find-moat-<slug>.md`
strategy	`docs/strategies/YYYY-MM-DD-<slug>.md`
competitive-landscape	`docs/competitive-analyses/YYYY-MM-DD-competitive-landscape-<name>.md`
vrio-analysis	`docs/vrio-analyses/YYYY-MM-DD-vrio-<product-name>.md`
strategic-moat	`docs/strategic-moat/YYYY-MM-DD-moat-<product-name>.md`
product-ecosystem	`docs/ecosystem-strategies/YYYY-MM-DD-ecosystem-strategy-<name>.md`
pre-mortem	`docs/pre-mortems/YYYY-MM-DD-pre-mortem-<name>.md`
prompt-builder	`docs/prompts/YYYY-MM-DD-<slug>.md`
stakeholder-alignment	`docs/stakeholder-alignment/YYYY-MM-DD-alignment-<topic>.md`
decision-log	`docs/decisions/YYYY-MM-DD-<slug>.md`
prioritization	`docs/prioritization/YYYY-MM-DD-prioritization-<topic>.md`

Architecture

pm-superpowers/
├── .claude-plugin/
│   └── marketplace.json        # Claude Code marketplace
├── .cursor-plugin/
│   └── marketplace.json        # Cursor / Grok Bot marketplace
├── plugins/
│   ├── hermes-tweet/           # Optional docs-only companion (Claude/Hermes only)
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   └── skills/
│   │       └── social-signal-intelligence/
│   └── pm-superpowers/
│       ├── .claude-plugin/
│       │   └── plugin.json     # Claude Code plugin manifest
│       ├── .cursor-plugin/
│       │   └── plugin.json     # Cursor / Grok Bot plugin manifest
│       ├── agents/             # Sub-agent definitions
│       └── skills/             # SKILL.md per skill (the core logic)
└── references/                 # Shared framework definitions (VRIO, moats, etc.)

Each skill follows a consistent structure: domain context → instructions → interactive process steps → structured output format. Skills include stopping conditions, red flags/anti-patterns, completion requirements, and workflow chaining to naturally guide PMs to the next relevant analysis.

Plugin marketplace, not a prompt library. Most PM-for-AI repos are flat collections of markdown templates. This is a proper plugin with dual manifests (Claude Code and Cursor / Grok Bot), a sub-agent, and skills that install cleanly, trigger naturally, and compose with other tools.

What this is not

Not a PRD generator. Plenty of tools already do that well. This one exists for the thinking that has to happen before the PRD.
Not a live X/Twitter client. hermes-tweet in this marketplace is workflow documentation. Live reads and actions run in Hermes Agent via Xquik, a third-party paid API.
Not a replacement for your judgment. The frameworks structure the analysis and ask the questions you'd otherwise forget to ask. You still own the call.
Not gospel. VRIO, RICE, the Tigers/Paper Tigers/Elephants framework — these are starting points with decades of use behind them, not the only lens worth applying.
Not finished. New skills and sharper frameworks are still landing — see the table above.

_{PM Superpowers 🧭}
_{MIT · Built by Ani Ganti, Principal PM at Wrapbook}