oimiragieo Feedback Analysis
Overview
Customer feedback analysis transforms raw feedback into actionable intelligence across six interconnected capability areas. All capabilities share a common data pipeline: unified multi-channel feedback collection feeds sentiment detection, which powers NPS/CSAT scoring, feature clustering, ticket triage, churn signals, and ultimately roadmap prioritization.
Six Capability Areas:
- Sentiment Analysis — Multi-channel emotion detection beyond positive/negative/neutral
- NPS/CSAT Frameworks — Dual-track score + text analysis with mismatch detection
- Feature Request Clustering — Group and prioritize by frequency, emotion, and churn correlation
- Support Ticket Triage — Hierarchical taxonomy-based categorization and routing
- Churn Signal Detection — Behavioral and textual early warning systems
- Feedback-to-Roadmap Translation — Convert clusters to ranked product decisions
When to Invoke
Invoke Skill({ skill: 'feedback-analysis' }) when:
- Analyzing customer feedback at scale (>50 items)
- Processing NPS/CSAT survey responses
- Triaging support tickets or classifying issues
- Detecting early churn signals in user behavior or feedback
- Prioritizing the product roadmap from customer requests
- Synthesizing qualitative feedback into actionable themes
- Running feedback campaigns and evaluating results
The Six-Phase Process
Phase 1: Multi-Channel Data Unification (MANDATORY FIRST STEP)
Iron Law: All analysis degrades without unified data. Single-channel view creates blind spots.
Channels to unify:
- In-app surveys (NPS, CSAT, CES)
- Support tickets (Zendesk, Intercom, Freshdesk)
- App store reviews (iOS, Android)
- Social mentions (Twitter/X, Reddit, LinkedIn)
- Chat transcripts (live chat, chatbot logs)
- Product reviews (G2, Capterra, Trustpilot)
- Email responses
Output: A unified feedback dataset with source, timestamp, channel, user tier, and raw text per item.
Phase 2: Sentiment Analysis
Method: NLP-based multi-dimensional sentiment classification.
Classifications:
- Polarity: Positive / Negative / Neutral
- Emotion: Frustration, Satisfaction, Confusion, Delight, Urgency
- Intensity: High / Medium / Low
- Topic: Product area, feature, support experience, pricing
Key Pattern — Mismatch Detection (Critical Insight):
A customer scoring 8 (NPS Passive) with deeply negative text is high churn risk. A customer scoring 6 (NPS Detractor) with positive text is recoverable. Mismatch = highest priority segment for intervention.
Mismatch Types:
- High score + negative text → At-risk, intervention needed
- Low score + positive text → Recoverable, reduce friction
- Neutral score + high emotion → Emerging issue, monitor closely
Output: Sentiment-tagged dataset with polarity, emotion, intensity, and mismatch flags.
Phase 3: NPS/CSAT Frameworks
Dual-Track Analysis: Process numerical scores AND open-text responses in parallel.
NPS Segments:
- Promoters (9-10): Surface testimonials, referral triggers
- Passives (7-8): Identify friction points preventing promotion
- Detractors (0-6): Root cause analysis, recovery playbooks
CSAT Layers:
- Score distribution by product area, agent, date range, cohort
- Text sentiment correlation with CSAT score
- Trend analysis: rolling averages, anomaly detection on score drops
- Causation analysis: what drove score changes?
Multi-Dimensional Segmentation:
Dimensions to segment by:
- User tier (free, pro, enterprise)
- Acquisition channel
- Product area (onboarding, core feature, billing, support)
- Agent/team (for support CSAT)
- Cohort (joined date, plan upgrade date)
- Region/language
Output: NPS/CSAT dashboard data with trend lines, mismatch segments, and causation narratives.
Phase 4: Feature Request Clustering
Method: Group verbatims into themes without manual tagging using pattern detection.
Clustering Dimensions:
- Frequency: How many users requested this?
- Emotional Weight: How strongly do they feel? (high emotion = high priority)
- Churn Correlation: Does absence of this feature correlate with churned users?
- Segment Impact: Which user tiers/cohorts are most affected?
Category Taxonomy:
Request Categories:
- Bug Report (broken functionality)
- Feature Gap (missing capability)
- UX Friction (confusing/slow workflow)
- Performance Issue (speed, reliability)
- Integration Request (connect to other tools)
- Pricing Feedback (too expensive, wrong tier)
- Documentation Gap (can't figure out how to use it)
Prioritization Formula:
Priority Score = (Frequency × 0.3) + (Emotion Weight × 0.3) + (Churn Correlation × 0.4)
Output: Ranked feature request list with evidence count, sentiment weight, and churn correlation per cluster.
Phase 5: Support Ticket Triage
Taxonomy Design: Hierarchical, max 30-50 tags to prevent tag bloat.
Recommended Taxonomy Structure:
Level 1 (Category): Level 2 (Subcategory): Level 3 (Root Cause):
- Technical Issue - Login/Auth - Password reset broken
- Billing - Charge dispute - Double-charged
- Feature Usage - Onboarding - Setup wizard unclear
- Performance - Slow response - Database timeout
- Integration - API error - Rate limit exceeded
- Account Management - Team permissions - Role not propagating
Triage Modes:
- Rule-based: Fast pattern matching for obvious categories
- AI-powered: NLP for ambiguous tickets (45% faster routing per Zendesk data)
- Human review: Escalation queue for complex/sensitive cases
Priority Scoring:
Ticket Priority = Urgency (language cues) + Impact (user tier/revenue) + Sentiment (frustration level)
- P0: Critical + Enterprise user + High frustration
- P1: High urgency + Any paid user + Negative sentiment
- P2: Medium urgency + Any user + Neutral/negative
- P3: Low urgency + Any user + Neutral
Output: Categorized and prioritized ticket queue with taxonomy assignments and routing rules.
Phase 6: Churn Signal Detection
Behavioral Profile Clustering:
User Engagement Profiles:
- Power User: High session frequency, feature breadth, collaborative
- Dabbler: Irregular sessions, single workflow, no integrations
- One-Feature User: Deep single-feature use, no expansion
- Trial Tourist: Onboarding complete, then disengaged
Early Warning Signals (detect BEFORE explicit churn):
- Session frequency drop (>50% decrease week-over-week)
- Feature contraction (fewer features used than prior period)
- Support ticket surge (3+ tickets in 2 weeks)
- Negative sentiment spike in recent feedback
- Admin account downgrade events
- Billing inquiry (pricing-related tickets/queries)
- Export activity (data portability requests)
Churn Risk Scoring:
Churn Risk = (Behavioral signals × 0.4) + (Feedback sentiment × 0.3) + (Support ticket pattern × 0.3)
Risk Tiers:
- High (>0.7): Trigger immediate retention playbook
- Medium (0.4-0.7): Proactive outreach + success check-in
- Low (<0.4): Monitor, standard touchpoints
Reason Code Generation: Each high-risk user gets a human-readable reason code:
- "Feature-gap: Missing [X] blocking workflow"
- "Billing: Perceives pricing as misaligned with value"
- "Support: 3 unresolved critical tickets in 14 days"
Output: Churn risk cohort with risk scores, reason codes, and triggered playbook recommendations.
Phase 7: Feedback-to-Roadmap Translation
Input: Completed phases 1-6 (sentiment, NPS/CSAT, clusters, triage, churn signals)
Prioritization Matrix:
Roadmap Score = (Feature Request Frequency × 0.25)
+ (Churn Correlation × 0.35)
+ (NPS Impact × 0.25)
+ (Support Volume × 0.15)
Stakeholder Output Format:
## Roadmap Recommendation: [Feature/Fix Name]
**Evidence Summary**: [N] users requested this across [channels]
**Sentiment**: [Avg. emotional weight and polarity]
**Churn Correlation**: [% of churned users mentioned this]
**NPS Impact**: [Correlation to Detractor-to-Promoter potential]
**Support Impact**: [Ticket volume and priority distribution]
**Recommended Action**: [Implement / Investigate / Defer / Decline]
**Priority Tier**: P0 / P1 / P2 / P3
**Supporting Quotes**: [3-5 verbatim user quotes]
Continuous Loop: Feed roadmap decisions back into feedback collection ("Did we solve the problem?").
Output: Ranked roadmap items with quantitative evidence, stakeholder narrative, and action recommendations.
Iron Laws
- ALWAYS unify channels first — single-channel analysis creates blind spots that lead to wrong prioritization decisions.
- ALWAYS run mismatch detection — numerical scores alone miss high-churn-risk Passives and recoverable Detractors.
- ALWAYS produce an actionable output — analysis that doesn't result in a decision, playbook trigger, or roadmap item has failed its purpose.
- NEVER use flat taxonomy with >50 tags — tag bloat causes inconsistent categorization; use hierarchical taxonomy with 30-50 leaf nodes.
- ALWAYS correlate feature requests with churn data — frequency alone is a poor proxy for priority; churn correlation is the real signal.
Anti-Patterns
| Anti-Pattern | Why It Fails | Correct Approach |
|---|---|---|
| Analyzing only NPS scores without text | Misses mismatch segments (fake Promoters, recoverable Detractors) | Always run dual-track score + text analysis |
| Flat taxonomy with 200+ ticket tags | Agents use first matching tag; root cause data is lost | Hierarchical taxonomy, max 50 leaf nodes |
| Clustering by frequency alone | Missing features that don't come up often but cause 80% of churn | Weight clusters by churn correlation (0.4 weight) |
| Waiting for explicit churn to detect it | Post-churn analysis doesn't save the customer | Behavioral early warning signals, 14-day detection horizon |
| Roadmap items without evidence count | Stakeholders can't evaluate priority or trade-offs | Every roadmap item needs: frequency, sentiment weight, churn %, quotes |
| Single-channel feedback collection | Blind spots by channel; social complaints ≠ support tickets | Unify all channels before analysis |
Enforcement Hooks
Input validated against schemas/input.schema.json before execution.
Output contract defined in schemas/output.schema.json.
Pre-execution hook: hooks/pre-execute.cjs
Post-execution hook (observability): hooks/post-execute.cjs
Memory Protocol (MANDATORY)
Before starting:
Read .claude/context/memory/learnings.md
Check for:
- Previous feedback analysis results
- Known data quality issues in feedback channels
- Prior roadmap decisions from feedback
After completing:
- New pattern discovered →
.claude/context/memory/learnings.md - Issue found →
.claude/context/memory/issues.md - Roadmap decision →
.claude/context/memory/decisions.md
ASSUME INTERRUPTION: If it's not in memory, it didn't happen.