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.