customer-feedback-analyzer — Claude Code skill: setup & guide
customer-feedback-analyzer synthesizes user feedback from tickets, NPS surveys, and interviews into prioritized feature requests for product roadmaps.
MIT 190 installs ★ 39 updated 2025-12-25
npx skills add daffy0208/ai-dev-standards --skill customer-feedback-analyzer -a claude-codeWhat customer-feedback-analyzer does
The skill organizes user input across multiple touchpoints, including in-app widgets, support tickets, user interviews, and churn surveys. It categorizes every incoming report by type, such as bugs, usability friction, or feature requests, and tags it by user cohort and severity.
Prioritization relies on a mathematical score: impact multiplied by frequency and strategic alignment, each rated from 1 to 5. Items scoring 40 or higher move straight to the next sprint, while ideas below 20 drop off the active backlog. The skill takes a strict stance: never solicit customer input that your team cannot commit to reviewing and shipping, because unfulfilled promises ruin user trust.
Beyond sorting, it includes response templates. These help teams close the loop with customers and announce features in public changelogs. It also flags risks like squeaky wheel bias, where vocal users skew roadmap choices without data support.
What it helps with
- Categorize customer feedback by type, severity, and user segment
- Calculate feature priority scores using impact, frequency, and strategic fit
- Draft notification emails to users when requested features go live
- Spot product issues from recurring support ticket volume
Example prompts for the agent
- Analyze this batch of NPS responses and segment the feedback by customer persona
- Calculate the priority score for a new Slack integration based on impact and frequency
- Draft an email notifying users that their requested export feature is now live
How to install customer-feedback-analyzer
1Skills CLI (Vercel)
npx skills add daffy0208/ai-dev-standards --skill customer-feedback-analyzer -a claude-code2Manually: put the files in place
~/.claude/skills/customer-feedback-analyzer/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/customer-feedback-analyzer/
1Skills CLI (Vercel)
npx skills add daffy0208/ai-dev-standards --skill customer-feedback-analyzer -a codex2Manually: put the files in place
.agents/skills/customer-feedback-analyzer/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add daffy0208/ai-dev-standards --skill customer-feedback-analyzer -a cursor2Manually: put the files in place
.cursor/skills/customer-feedback-analyzer/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install daffy0208/ai-dev-standards skills/customer-feedback-analyzer2Manually: put the files in place
.github/skills/customer-feedback-analyzer/SKILL.md1Skills CLI (Vercel)
npx skills add daffy0208/ai-dev-standards --skill customer-feedback-analyzer -a gemini-cli2Platform CLI
gemini skills install https://github.com/daffy0208/ai-dev-standards --path skills/customer-feedback-analyzerManually: put the files in place
.devin/skills/customer-feedback-analyzer/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add daffy0208/ai-dev-standards --skill customer-feedback-analyzer -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about customer-feedback-analyzer
How do I install customer-feedback-analyzer in Claude Code?
Run npx skills add daffy0208/ai-dev-standards --skill customer-feedback-analyzer -a claude-code in your terminal.
What does customer-feedback-analyzer do?
It structures customer feedback from surveys, tickets, and interviews, helping teams score requests and update roadmap priorities.
How does the prioritization formula work?
The skill multiplies Impact (1–5), Frequency (1–5), and Strategic Alignment (1–5). A score of 40 or higher marks an item as high priority for the upcoming sprint.
Source text
SKILL.md · MIT
---
name: customer-feedback-analyzer
description: Synthesize user feedback from multiple channels and identify patterns to inform product decisions. Use when analyzing feedback, prioritizing feature requests, conducting NPS surveys, or understanding user sentiment. Covers feedback collection, categorization, prioritization frameworks, and closing the feedback loop.
---
# Customer Feedback Analyzer
Collect, analyze, and prioritize user feedback to inform product decisions.
## Core Principle
**Never collect feedback you won't act on.** Collecting feedback creates expectation of action. If you can't commit to reviewing and acting on it, don't ask for it. Destroys trust.
## Feedback Channels
### 1. In-App Feedback Widget
**Best for**: Contextual feedback, low friction
```javascript
// Contextual feedback
<FeedbackWidget
context={{
page: 'dashboard',
feature: 'export',
user_action: 'clicked_export'
}}
placeholder="How can we improve exports?"
/>
```
**Pros**: High quality (contextual), immediate
**Cons**: Can interrupt user flow
### 2. NPS Surveys
**Best for**: Measuring overall satisfaction and loyalty
```yaml
Question: "How likely are you to recommend [Product] to a friend or colleague?"
Scale: 0-10
Scoring:
Promoters (9-10): Love your product, will advocate
Passives (7-8): Satisfied but not enthusiastic
Detractors (0-6): Unhappy, will churn
NPS = % Promoters - % Detractors
Benchmarks:
Excellent: ≥50
Good: 30-49
Needs Work: <30
```
**Follow-up question**: "What's the main reason for your score?"
### 3. Support Tickets
**Best for**: Identifying recurring issues
```yaml
Pattern Recognition:
- Same issue reported 5+ times → UX problem, not edge case
- Support time > 10 min per ticket → Needs better docs
- Ticket volume spike → Recent deploy likely caused issue
```
### 4. User Interviews
**Best for**: Deep qualitative insights
```yaml
Interview Structure:
1. Background (5 min): Their role, use case
2. Problem Discovery (10 min): Challenges they face
3. Solution Validation (10 min): Show prototype, get reaction
4. Wrap-up (5 min): Any other feedback?
Sample Size: 5-10 users per persona
```
### 5. Feature Request Voting
**Best for**: Prioritizing roadmap
**Tools**: Canny, ProductBoard, Upvoty
```yaml
Benefits:
- See most requested features
- Reduce duplicate requests
- Public roadmap transparency
- Close the loop automatically
Avoid:
- Building everything requested
- Letting voters drive strategy
```
### 6. Exit Interviews
**Best for**: Understanding why users churn
```yaml
Key Questions:
- What made you decide to cancel?
- What feature/change would have kept you?
- What are you switching to?
- What did we do well?
```
## Feedback Categorization
### By Type
```yaml
Bug: Something broken
- "Export fails with >100 rows"
- Priority: Fix immediately
Feature Request: New capability
- "Add Slack integration"
- Priority: Vote/validate
Enhancement: Improve existing feature
- "Export should include timestamps"
- Priority: Nice to have
Usability: Confusing UX
- "Can't find where to invite team members"
- Priority: High (friction)
Performance: Speed issue
- "Dashboard loads slowly"
- Priority: Depends on impact
```
### By Severity
```yaml
Critical: Blocks core workflow
- "Can't save projects"
- Action: Hotfix immediately
High: Significant friction
- "Onboarding confusing"
- Action: Fix this sprint
Medium: Minor annoyance
- "Button text unclear"
- Action: Fix next quarter
Low: Edge case or cosmetic
- "Spacing looks off on mobile"
- Action: Backlog
```
### By Frequency
```yaml
Widespread: 50+ reports
→ High priority
Common: 10-50 reports
→ Medium priority
Occasional: 5-10 reports
→ Low priority, monitor
Rare: <5 reports
→ Likely edge case, document workaround
```
### By User Segment
```yaml
Power Users: High engagement, experienced
→ Actionable, technical feedback
New Users: Recently signed up
→ Onboarding issues, first impressions
Churned Users: Cancelled/inactive
→ Why did they leave?
Enterprise: Paying customers
→ Security, compliance, integrations
```
## Prioritization Framework
### Priority Score Formula
```
Score = Impact (1-5) × Frequency (1-5) × Strategic Alignment (1-5)
Score ≥ 40: High Priority (next sprint)
Score 20-39: Medium Priority (next quarter)
Score < 20: Low Priority (backlog or never)
```
**Example**:
```yaml
Feedback: "Add Slack integration"
Impact: 4 (significantly improves collaboration)
Frequency: 5 (50+ requests)
Strategic Alignment: 4 (fits roadmap)
Score: 4 × 5 × 4 = 80
Decision: HIGH PRIORITY - Build next sprint
Feedback: "Change button color"
Impact: 1 (minor cosmetic)
Frequency: 1 (1 person mentioned)
Strategic Alignment: 1 (not strategic)
Score: 1 × 1 × 1 = 1
Decision: LOW PRIORITY - Backlog
```
## Close the Feedback Loop
### 1. Acknowledge
```markdown
Email Template:
Subject: Thanks for your feedback!
Hi [Name],
Thanks for taking the time to share your thoughts on [topic].
We review all feedback and use it to prioritize our roadmap. I've shared
your input with the product team.
You can track feature requests on our public roadmap: [link]
Thanks for helping us improve!
[Your Name]
```
### 2. Act
```yaml
Decision Tree: Is it reported 10+ times?
Yes → Add to roadmap
No → Monitor
Does it align with strategy?
Yes → Prioritize
No → Document why not
Can we ship in 2 weeks?
Yes → Quick win, do it
No → Add to backlog
```
### 3. Notify Users Who Requested It
```markdown
Email Template:
Subject: You asked for [Feature] - it's live!
Hi [Name],
Remember when you asked us to add [feature]? Good news - it's live!
[Screenshot/GIF of feature]
Here's how it works:
1. [Step 1]
2. [Step 2]
Try it now: [Link]
Thanks for the feedback that made this happen.
[Your Name]
P.S. Have more ideas? Reply to this email.
```
### 4. Public Changelog
```markdown
## [Feature] is now live!
Requested by 47 users, [Feature] lets you [benefit].
How it works:
- [Key point 1]
- [Key point 2]
Try it: [Link]
Thanks to everyone who suggested this!
```
## Common Feedback Patterns
### Squeaky Wheel Syndrome
```yaml
Problem: Vocal minority ≠ Real need
Example:
- 1 user emails daily about dark mode
- Analytics show 2% use dark mode
Action: Validate with data before building
```
### Silent Churn
```yaml
Problem: Users leave without complaining
Example:
- Retention drops from 40% to 30%
- No feedback, no complaints
Action:
- Proactive exit interviews
- Check analytics for drop-off points
- Run usability tests
```
### Feature Bloat Risk
```yaml
Problem: Building everything requested leads to bloat
Example:
- 'Add Excel export'
- 'Add CSV export'
- 'Add JSON export'
- 'Add PDF export'
Action: Build generic solution, not every variant
```
## Synthesis & Reporting
### Weekly Feedback Summary
```yaml
feedback_summary:
period: "2024-01-15 to 2024-01-22"
total_items: 87
top_themes:
- theme: "Slack Integration"
frequency: 23
severity: high
example_quotes:
- "We need Slack notifications"
- "Can't notify team without Slack"
recommended_action: "Build Slack integration next sprint"
- theme: "Slow Dashboard Load"
frequency: 15
severity: medium
example_quotes:
- "Dashboard takes 10+ seconds"
- "Performance is terrible"
recommended_action: "Optimize queries, add caching"
- theme: "Mobile App Request"
frequency: 8
severity: low
example_quotes:
- "I want a mobile app"
recommended_action: "Monitor, not enough demand yet"
nps:
score: 42
detractor_reasons:
- "Too expensive" (12 mentions)
- "Missing features" (8 mentions)
- "Slow performance" (5 mentions)
prioritized_backlog:
- feedback: "Add Slack integration"
score: 80
priority: high
- feedback: "Optimize dashboard performance"
score: 45
priority: medium
- feedback: "Mobile app"
score: 16
priority: low
```
## Tools & Software
```yaml
Feedback Collection:
- In-app: Canny, UserVoice, Intercom
- Surveys: Typeform, SurveyMonkey, Delighted (NPS)
- User Research: Calendly, Zoom, UserTesting.com
Analysis:
- Qualitative: Dovetail, Notion, Airtable
- Quantitative: Excel, Google Sheets, Tableau
- Sentiment: MonkeyLearn, Lexalytics
Roadmap Transparency:
- Public Roadmap: Canny, ProductBoard, Trello
- Changelog: Headway, ReleaseNotes.io, Beamer
```
## Feedback Cadence
```yaml
Daily:
- Review support tickets
- Monitor in-app feedback
Weekly:
- Synthesize themes
- Share with product team
- Prioritize top requests
Monthly:
- Send NPS survey
- Review feature requests
- Update public roadmap
Quarterly:
- User interviews (5-10)
- Exit surveys for churned users
- Competitive feedback analysis
```
## Quick Start Checklist
- [ ] Set up in-app feedback widget
- [ ] Schedule NPS survey (monthly)
- [ ] Create feedback tracking spreadsheet
- [ ] Review support tickets weekly
- [ ] Conduct 2-3 user interviews
- [ ] Set up public roadmap (optional)
- [ ] Create email templates for acknowledging feedback
- [ ] Document feedback categorization process
## Common Pitfalls
❌ **Collecting feedback without acting**: Damages trust
❌ **Building everything requested**: Feature bloat
❌ **Not validating with data**: Vocal minority ≠ majority
❌ **Ignoring silent majority**: Not everyone gives feedback
❌ **No follow-up**: Users want to know you listened
## Summary
Great feedback analysis:
- ✅ Multiple channels (surveys, tickets, interviews)
- ✅ Categorize and prioritize systematically
- ✅ Act on high-priority feedback quickly
- ✅ Close the loop (notify users)
- ✅ Balance requests with strategy
- ✅ Share insights with team
© daffy0208 · MIT · daffy0208/ai-dev-standards