# Feedback Pipeline Setup Guide

## Data Source Checklist

Before running your feedback pipeline, connect these sources:

- [ ] **Intercom** or **Zendesk** (support tickets & customer messages)
- [ ] **Slack** (your feedback or #feedback channel)
- [ ] **Google Forms / Typeform** (in-app surveys or NPS)
- [ ] **LinkedIn / Twitter mentions** (if monitoring social)
- [ ] **Customer calls** (export transcripts if you record)
- [ ] **Email** (customer success team notes)
- [ ] **Product analytics** (user behavior data from Amplitude/Mixpanel)

**Setup time:** 30 minutes to gather links and export most recent feedback (last 30 days)

---

## AI Categorization Prompt

Use this prompt weekly to organize incoming feedback:

```
Organize this customer feedback into themes.

[PASTE YOUR FEEDBACK HERE - copy-paste from Intercom, Slack, surveys, or email]

For each theme:
1. Theme name
2. How many times mentioned (frequency)
3. Sentiment (positive / neutral / negative)
4. Impact type (feature request / bug / UX issue / compliment)
5. Key quotes (2-3 most representative)

Rank themes by: (frequency × impact)
Flag the top 3 themes that need immediate action.

Output as a prioritized list.
```

**Frequency:** Run weekly (Monday morning is ideal)
**Time:** 10 minutes to paste + 5 minutes to review output
**Output location:** Save to a shared doc or Notion database

---

## Sample Python Script (for engineers)

```python
# Feedback Pipeline Skeleton
# Use this to auto-collect and tag feedback

import requests
from datetime import datetime, timedelta

class FeedbackPipeline:
    def __init__(self, api_keys):
        self.intercom_key = api_keys['intercom']
        self.slack_token = api_keys['slack']

    def fetch_intercom_feedback(self, days=7):
        """Fetch messages from Intercom from last N days"""
        url = "https://api.intercom.io/conversations"
        params = {
            'created_after': int((datetime.now() - timedelta(days=days)).timestamp())
        }
        headers = {'Authorization': f'Bearer {self.intercom_key}'}
        response = requests.get(url, params=params, headers=headers)
        return response.json()

    def fetch_slack_feedback(self, channel, days=7):
        """Fetch messages from a Slack feedback channel"""
        # Similar pattern - fetch from Slack API
        pass

    def compile_feedback(self):
        """Combine all sources into one list"""
        intercom = self.fetch_intercom_feedback()
        slack = self.fetch_slack_feedback('#feedback')
        return intercom + slack

    def generate_categorization_prompt(self, feedback_list):
        """Format feedback for the AI categorization prompt"""
        formatted = "\n".join([f"{item['source']}: {item['text']}" for item in feedback_list])
        return f"""
        Categorize this feedback:
        {formatted}
        """

    def run(self):
        """Run the full pipeline"""
        feedback = self.compile_feedback()
        prompt = self.generate_categorization_prompt(feedback)
        print(prompt)
        # Send to Claude API or similar
        return prompt

# Usage:
# keys = {'intercom': 'your-key', 'slack': 'your-token'}
# pipeline = FeedbackPipeline(keys)
# pipeline.run()
```

---

## Daily Digest Prompt Template

Run this every morning to surface urgent feedback:

```
Here's customer feedback from the last 24 hours:

[PASTE FEEDBACK]

Identify:
1. Any critical bugs mentioned (need immediate fix)
2. Feature requests that match our roadmap
3. Churn signals (unhappy customers)
4. One surprising insight we missed

Format: Slack-friendly message (under 200 words)
Tone: matter-of-fact, highlight urgency

Tag @[PM_NAME] if churn signal detected.
```

---

## Weekly Workflow

**Monday 9am:** Run categorization prompt (30 min, output to Notion)
**Daily:** Run digest prompt (5 min, Slack to #product)
**Friday 4pm:** Review top themes, add to backlog
**Monthly:** Deep dive: conduct 3-5 customer calls on top theme

**Total time investment:** ~1 hour/week
**ROI:** Never miss critical feedback, always know customer priorities