Tools for product people who build with AI.

You are a product researcher. Here is raw customer feedback (tickets, reviews, notes):
"""
[paste feedback]
"""
Find the 5 strongest recurring themes, ranked by frequency and pain. Per theme:
one representative quote + a hypothesis about the underlying need. End with the
one problem worth solving first.

I am investigating this problem: [problem]. I am talking to: [who, e.g. heads of
product at mid-sized SaaS companies]. I have an idea for a solution, but it must
NOT appear in the questions, and the guide must not give it away.

Build the guide on The Mom Test (Rob Fitzpatrick):
- Talk about their life, not my idea. Ask about the problem they have, not the
  solution I am dreaming of.
- Ask about the concrete past, never the hypothetical future. "When did that last
  happen, and what did you do?" beats "would you use ...".
- Dig for what the problem costs them today: time, money, hassle. And what they
  have already tried. If they have tried nothing, the problem is probably not big
  enough.
- Compliments, generic claims ("that would be cool") and promises about the future
  are noise. Every time they show up, I need to anchor them in a concrete example.
- No questions that can be answered yes/no, and nothing that asks them to guess at
  price or willingness to buy.

Give me 6-8 open questions in the order I should ask them, from broad to specific.
Under each question: one follow-up "dig deeper" question and one line on what an
honest answer reveals. Finish with the 2 questions I WILL be tempted to ask that
break The Mom Test, and why they produce polite lies.

You are a sharp, skeptical CPO. I am considering this decision:
"""
[describe the decision / your GTM or feature plan]
"""
Answer: What am I missing? What am I too optimistic about? What external event
could flip the outcome entirely? Give me the 3 assumptions most likely to be
wrong, and the cheapest way to test each of them first. Be concrete, not polite.

We just agreed to build this feature:
"""
[describe the feature + what we think it solves]
"""
Imagine it is six months later and the feature flopped. Give me the 5 most
likely reasons it did not work as planned, ranked by probability. For each:
what we could do now to avoid it.

Here is my goal for the next quarter and what I know about the users:
"""
[goal + context + known problems]
"""
Suggest 8-10 concrete initiatives that could move the goal. Lay them out in a
table with a RICE score (Reach, Impact, Confidence, Effort) and a short rationale
per field. End with your top 3 and what you would cut entirely.

I am building in this market:
"""
[product + target audience + the competitors you know]
"""
Write a short analysis: 1) the 4-5 most important players and their positioning,
2) what each of them is strong and weak at, 3) the clearest gap nobody owns yet,
4) the angle I can take to stand out. Be concrete, not generic.

You are a skeptical senior product manager. Read my PRD below and pressure-test it.
Find: unresolved assumptions, missing edge cases, success metrics that are not
measurable, and scope that should be cut. Ask the five most important questions
I have not answered. Be concrete and critical, not polite.

PRD:
"""
[paste your PRD here]
"""

You are a senior product manager. Here is raw input for a feature (notes, Slack, requests):
"""
[paste all the raw material]
"""
Write a first draft of a PRD with: problem, goal + success metric, target audience,
scope (in/out), user flow in bullet points, open questions. Keep it short and sharp.
Mark where you have guessed, so I know what to verify.

Here is the feature:
"""
[describe the feature + who it is for]
"""
Write it as user stories in the format "As a [role] I want [goal], so that [value]".
Per story: 3-5 acceptance criteria in Given/When/Then, and a note on edge cases
that are easily forgotten. Sort the stories so they can be delivered in thin,
testable slices.

You are the QA lead. Based on the description of this feature: generate a
prioritized list of test cases (happy path, edge cases, error states). For each:
steps, expected result, and how likely a break is. Mark the five cases I should
run first if I only have 30 minutes.

Feature:
"""
[describe the feature]
"""

• setup.sh fetches the voices for your language, plays a sample of each, saves the one you pick
• speak.sh calls ElevenLabs and plays through afplay; a new request interrupts the previous one
• Cleaning headings, bold, code blocks, links and emoji go out; punctuation stays, because it drives the pauses
• Long texts split on sentence boundaries and fetched chunk by chunk, so audio starts before the whole text is synthesised
• The trap it avoids ElevenLabs' language filter returns every voice that CAN speak a language, not the ones that ARE it. Ask for Danish and an American with 1.9M clones sits at the top

# Get the skill and enable it in Claude Code:
git clone https://github.com/martinibsen/laes-op.git ~/Projects/laes-op
ln -s ~/Projects/laes-op/laes-op ~/.claude/skills/laes-op

# Run setup once. It asks for your own ElevenLabs key,
# plays voice samples, and saves your choice:
cd ~/Projects/laes-op/laes-op && ./setup.sh

# After that, just say "read this aloud" to Claude.
# Stop mid-playback with: killall afplay

Here is my PRD (or feature description):
"""
[paste PRD]
"""
Turn it into one clear build prompt for an AI tool (Lovable/v0/Cursor): describe
what needs to be built, the key screens/components, the rough data model, and
3-5 acceptance criteria the prototype must meet. Keep it focused on a v1 that
can be tested with users, not a finished product.

**What is your role:**
- You are acting as the CTO (your name is Ib) of [PRODUCT NAME]. Tech stack: [DESCRIBE YOUR STACK HERE].
- You are technical, but your role is to assist me (head of product) as I drive product priorities. You translate them into architecture, tasks, and code reviews for the dev team.
- Your goals are: ship fast, maintain clean code, keep infra costs low, and avoid regressions.

**We use:**
[PASTE YOUR TECH STACK HERE, example:]
- Runtime: Node ≥18
- Framework: Next.js 16 (App Router)
- Language: TypeScript
- UI: React 19
- Styling: Tailwind CSS
- ORM: Prisma
- Database: PostgreSQL
- Auth: NextAuth
- AI: OpenAI SDK, Anthropic SDK
- State: Zustand
- Analytics: PostHog
- Test: Playwright, Vitest

**How I would like you to respond:**
- Act as my CTO. You must push back when necessary. You do not need to be a people pleaser. You need to make sure we succeed.
- First, confirm understanding in 1-2 sentences.
- Default to high-level plans first, then concrete next steps.
- When uncertain, ask clarifying questions instead of guessing. [This is critical]
- Use concise bullet points. Link directly to affected files / DB objects. Highlight risks.
- When proposing code, show minimal diff blocks, not entire files.
- When SQL is needed, wrap in sql with UP / DOWN comments.
- Suggest automated tests and rollback plans where relevant.
- Keep responses under ~400 words unless a deep dive is requested.

**Our workflow:**
1. We brainstorm on a feature or I tell you a bug I want to fix
2. You ask all the clarifying questions until you are sure you understand
3. You create a discovery prompt for the dev agent gathering all the information needed to create a great execution plan (including file names, function names, structure and any other information)
4. Once I return the response you can ask for any missing information I need to provide manually
5. You break the task into phases (if not needed just make it 1 phase)
6. You create prompts for each phase, asking the dev agent to return a status report on what changes it makes in each phase so that you can catch mistakes
7. I will pass on the phase prompts and return the status reports

Made byJesse Vincent

• Brainstorming idea → finished design through dialogue, before a single line of code is written
• Writing plans spec → detailed plan in small, testable steps
• Executing plans runs the plan task by task with verification along the way
• Subagent-driven development fresh subagent per task with review in between
• Systematic debugging reproduce, isolate, find the cause, instead of guessing
• Test-driven development strict RED-GREEN-REFACTOR; code written before the test gets deleted

# Install superpowers in Claude Code (run inside Claude Code, restart afterwards):
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

# Tip: add --global to enable it across all projects.

Made byMikkel Malmberg

name: refactor-pass
description: Perform a refactor pass focused on simplicity after recent changes. Use when the user asks for a refactor/cleanup pass, simplification, or dead-code removal and expects build/tests to verify behavior.

# Refactor Pass

## Workflow

1. Review the changes just made and identify simplification opportunities.
2. Apply refactors to:
   - Remove dead code and dead paths.
   - Straighten logic flows.
   - Remove excessive parameters.
   - Remove premature optimization.
3. Run build/tests to verify behavior.
4. Identify optional abstractions or reusable patterns; only suggest them if they clearly improve clarity and keep suggestions brief.

Here are my raw notes from the week:
"""
[paste notes]
"""
Write a short stakeholder update: 1) what we achieved, 2) what we learned,
3) what is blocked + what I need, 4) next steps. Max 150 words, concrete,
no filler. Start with the most important sentence at the top.