Skip to main content
skill CX Codex

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

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add daffy0208/ai-dev-standards --skill customer-feedback-analyzer -a claude-code
Open on GitHub

What 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-code

2Manually: put the files in place

~/.claude/skills/customer-feedback-analyzer/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/customer-feedback-analyzer/

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

Similar skills

All skills for Notes, tasks and projects →

From the same set63

The whole set →
API Designer API Designer guides REST and GraphQL design with consistent resource naming, standard error formats, and pagination patterns. CX Codex +1 204installs quality-auditor quality-auditor audits repositories, architecture, and code across 12 dimensions with a 1-to-10 scoring system. CX Codex +1 201installs audio-producer audio-producer builds audio players, processes sound and adds interactive effects to web apps. The examples come as React components. CX Codex +1 200installs UX Designer The UX Designer skill guides user flows, information architecture, wireframes, prototypes, and usability work. Use it when shaping or revising an interface. CX Codex +1 196installs RAG Implementer RAG Implementer — a skill that walks the agent through eight phases of a RAG build, from knowledge-base design to retrieval, after checking that RAG is the right call. CX Codex +1 189installs usability-tester usability-tester designs observational usability studies, crafts task scenarios without leading instructions, and scores UX issue severity. CX Codex +1 188installs Supabase Developer Supabase Developer guides full-stack Supabase setup: PostgreSQL schemas with RLS, auth flows, storage buckets, and Edge Functions. CX Codex +1 187installs voice-interface-builder voice-interface-builder is a Claude Code skill for adding speech recognition, voice commands, and spoken output to web interfaces. It comes into play when building voice controls or accessibility features. CX Codex +1 187installs

Project sponsors

Companies that keep this analytics open