ChatGPT Prompts for Customer Service Teams

Create a set of professional response templates for the most common customer service issues we receive.

Product/Service: [product or service name]
Industry: [SaaS | ecommerce | finance | healthcare | other]
Common issues to cover:
1. [e.g., Login problems]
2. [e.g., Billing questions]
3. [e.g., Feature requests]
4. [e.g., Shipping delays]
5. [e.g., Account cancellation]

For each issue, provide:
- A clear, empathetic opening that acknowledges the customer's situation
- Step-by-step resolution instructions (numbered, scannable)
- Alternative actions if the first solution does not work
- A warm closing that invites follow-up without being pushy
- Suggested subject line for email responses
- Tone: warm and professional — never robotic, never overly casual
- Length: 100-200 words per template

Write a de-escalation script for handling an angry customer interaction across multiple touchpoints.

Channel: [phone | email | live chat | social media]
Customer message or situation: "[paste the customer's message or describe the call]"
Root cause: [product defect | billing error | delayed delivery | broken promise | poor previous support | other]
Customer history: [first-time buyer | loyal customer | VIP account | serial complainer]
What we can offer: [full refund | partial credit | replacement | priority fix | manager callback | other]
What we cannot offer: [describe hard limits]

The script must:
- Open with a genuine validation of their frustration — not a hollow apology
- Use their name at least twice
- Mirror their language to show you truly listened
- Pivot from the problem to what you will do, not what you cannot
- Provide a specific action with a concrete timeline ("by end of day Thursday" not "soon")
- Include a recovery gesture that feels generous, not transactional
- End with a commitment to personally follow up
- Never blame another department, system, or policy

Write a clear, friendly explanation of our refund and return policy for a customer who is requesting one.

Our policy details:
- Refund window: [X days from purchase]
- Return shipping: [paid by customer | prepaid label provided | free returns]
- Refund method: [original payment method | store credit | choice]
- Exceptions: [list any non-refundable items or conditions]
- Processing time: [X business days after item received]

Customer's situation: "[describe their specific request]"
Product purchased: [product name, price, purchase date]
Is this within policy: [yes | no — explain why]

Write a response that:
- Explains the policy in plain language without legal jargon
- Applies the policy to their specific situation
- If eligible: provides clear next steps with a return link or instructions
- If not eligible: explains why compassionately and offers alternatives (store credit, exchange, discount on next purchase)
- Maintains a tone that makes the customer feel valued regardless of the outcome
- Length: 150-250 words

Generate a comprehensive FAQ article for our customer service knowledge base.

Topic area: [product setup | billing | troubleshooting | account management | integrations]
Product: [product name]
Target audience: [new customers | existing users | enterprise clients]
Support data: [list the top 8-12 questions your team receives about this topic]
Current gaps: [what questions are customers asking that are NOT in your existing FAQ]

For each FAQ entry:
- Phrase the question exactly as a real customer would ask it (informal, specific)
- Write a concise answer (50-150 words) using short paragraphs and bullet points
- Include a "Still need help?" fallback with a link to contact support
- Tag entries with difficulty level: basic | intermediate | advanced
- Flag any answers that need a screenshot, GIF, or video walkthrough

Organize entries into logical sections with clear headings.
End with 3 "Related articles" suggestions per section.
Total: at least 12 FAQ entries.

Design a customer satisfaction survey to send after support interactions.

Survey goal: [measure agent quality | identify product friction | track resolution speed | all of the above]
Channel the support happened on: [email | live chat | phone | social media]
Average ticket complexity: [simple questions | moderate troubleshooting | complex technical issues]
Survey tool: [Typeform | Google Forms | SurveyMonkey | in-app widget | email embedded]

Create a survey with:
- A brief intro (2 sentences max) explaining why their feedback matters
- 5-7 questions mixing quantitative and qualitative formats:
  - At least 2 rating scale questions (1-5 or 1-10)
  - At least 1 multiple choice question
  - At least 1 open-ended question
  - 1 question about effort ("How easy was it to get your issue resolved?")
- Conditional logic suggestions (e.g., if rating < 3, ask "What could we have done better?")
- A thank-you message that feels genuine, not corporate
- Estimated completion time (aim for under 2 minutes)
- A follow-up trigger: what score should automatically alert a manager for outreach

Create a detailed escalation criteria guide for our customer service team.

Team structure: [tier 1 agents | tier 2 specialists | engineering | management | legal]
Products covered: [list products or service areas]
Current SLA targets:
- First response: [X hours]
- Resolution: [X hours for standard, X hours for critical]
- Escalation response: [X hours]

Build a guide that includes:
- Clear definitions of each escalation tier with examples
- Specific triggers that require immediate escalation:
  - Technical (e.g., data loss, security breach, full outage)
  - Business (e.g., enterprise client, legal threat, media mention)
  - Emotional (e.g., repeated contacts, profanity, churn threats from high-value accounts)
- A decision tree format: "If [condition], then escalate to [team] via [channel]"
- Required information to include in every escalation handoff
- What NOT to escalate (common mistakes that waste senior time)
- Response time expectations for each tier
- Post-escalation follow-up responsibilities

Format as a reference document agents can scan in under 30 seconds during a live interaction.

Write a 5-email onboarding sequence for new customers to reduce early-stage support tickets.

Product: [product name]
Onboarding goal: [first value moment, e.g., "complete their first export" or "set up their first automation"]
Typical time to value: [X days]
Top 5 reasons new customers contact support in their first week:
1. [e.g., Can't find a feature]
2. [e.g., Confused by setup wizard]
3. [e.g., Integration not working]
4. [e.g., Unsure what to do next]
5. [e.g., Billing confusion]

For each email:
- Day and trigger (e.g., "Day 0: immediately after signup")
- Subject line (write 2 options per email)
- Body copy: friendly, scannable, action-oriented (under 200 words each)
- One clear CTA per email (button text + destination)
- Preemptively answer the most common support question for that stage
- Include a "Need help?" fallback link to your support channel

End with a summary table showing the full sequence timeline.

Write a comprehensive knowledge base article that preemptively solves a common support issue.

Article topic: [e.g., "How to connect your account to Zapier"]
Product: [product name]
Current support volume for this topic: [e.g., "~40 tickets per month"]
Target reader: [beginner | intermediate | advanced]
Prerequisites: [list anything the user needs before starting]
Related existing articles: [list titles or links]

Article structure:
- Title: action-oriented (start with a verb)
- Overview paragraph: what the article covers and estimated time to complete
- "Before you begin" checklist (if applicable)
- Step-by-step instructions with numbered steps
- Bold all UI elements, button names, and menu paths
- Include placeholder notes for screenshots: [SCREENSHOT: description of what to capture]
- "Common issues" section with 3-5 troubleshooting tips in Q&A format
- "What's next" section with links to related articles
- Target length: 500-800 words
- Readability: 8th grade level — no jargon without definition

Write a service recovery script for when our company has made a clear mistake that impacted the customer.

What went wrong: [describe the service failure]
Impact on customer: [what they lost — time, money, data, trust]
How many customers affected: [individual case | small group | widespread incident]
Our accountability: [fully our fault | partially our fault | third-party caused it]
Recovery actions available:
- Immediate fix: [describe]
- Compensation options: [refund | credit | free months | upgrade | gift]
- Long-term prevention: [what we are changing to prevent recurrence]

Write a recovery message that:
- Takes clear ownership without weasel words ("We made a mistake" not "Mistakes were made")
- Explains what happened in plain language — no hiding behind technical jargon
- Details exactly what you are doing to fix it right now
- Offers meaningful compensation proportional to the impact
- Explains what you are changing so it does not happen again
- Does not over-apologize or grovel — be direct, confident, and action-focused
- Closes with a personal commitment from a named team member
- Length: 200-350 words

Analyze the following batch of customer feedback and produce an actionable insights report.

Feedback source: [support tickets | NPS responses | app store reviews | social media mentions | survey results]
Time period: [e.g., "last 30 days"]
Number of entries: [X]

Feedback entries:
[Paste 15-30 feedback entries, one per line. Include any rating if available.]

Produce a report with:
- Executive summary (3-4 sentences capturing the big picture)
- Sentiment breakdown: percentage positive / neutral / negative with trend vs. previous period
- Top 5 themes mentioned (with frequency count and representative quotes)
- Top 3 product improvement requests (ranked by frequency and impact)
- Top 3 things customers love (preserve exact language for marketing use)
- 3 urgent issues requiring immediate attention (red flags)
- Recommended actions for each theme: who should own it, suggested timeline, expected impact
- A one-paragraph customer voice summary written as if one customer is speaking for all of them

Format the report with clear headers, bullet points, and bold key insights for executive skimming.

Rewrite and optimize the following live chat responses to be faster, clearer, and more empathetic.

Channel: [live chat widget | Facebook Messenger | WhatsApp | SMS | Slack]
Average customer wait time: [X seconds/minutes]
Current responses to optimize:
1. "[paste current response 1]"
2. "[paste current response 2]"
3. "[paste current response 3]"
4. "[paste current response 4]"
5. "[paste current response 5]"

For each response, provide:
- Original version (for comparison)
- Optimized version following these rules:
  - Under 60 words (live chat requires brevity)
  - Front-load the answer — put the resolution in the first sentence
  - Use line breaks for readability on mobile screens
  - Replace formal language with conversational tone
  - Add one human touch (emoji, first name, or personality)
  - Include a clear next action or question to keep the conversation moving
- What changed and why (one sentence explaining the improvement)

End with 5 general live chat best practices your team should follow.

Create a realistic customer service training scenario for role-play practice with new agents.

Scenario difficulty: [beginner | intermediate | advanced]
Channel: [phone | email | live chat]
Product area: [billing | technical support | onboarding | cancellation | complaint]
Customer persona: [describe the customer — their mood, history, communication style]
Hidden context the agent will not know initially: [a detail that changes the situation when discovered]

Build the scenario with:
- Setup briefing for the trainer (background context, what the agent should and should not know)
- Customer opening message or call script (written in the customer's voice, 3-5 sentences)
- 4 conversation branches showing how the interaction changes based on the agent's response:
  - Branch A: agent responds perfectly (ideal resolution path)
  - Branch B: agent misses the emotional cue (escalation path)
  - Branch C: agent follows policy rigidly without empathy (frustration path)
  - Branch D: agent over-promises something they cannot deliver (trust erosion path)
- Debrief questions for after the role-play (5 questions that prompt reflection)
- Key teaching moment: the one skill this scenario is designed to build

Make the customer dialogue feel authentic — include typos, incomplete sentences, and emotional language.