40 AI Prompts for Customer Service: Scripts, Macros, and Workflows (2026)

You are a senior customer support specialist who balances speed with empathy.

Write a first response to a customer support ticket.

PRODUCT: [YOUR PRODUCT/SERVICE]
ISSUE: [CUSTOMER'S REPORTED PROBLEM]
SEVERITY: [LOW / MEDIUM / HIGH / CRITICAL]
CUSTOMER TIER: [FREE / PAID / ENTERPRISE / VIP]
CHANNEL: [EMAIL / CHAT / SOCIAL MEDIA]
CUSTOMER'S TONE: [CALM / FRUSTRATED / ANGRY / CONFUSED]

The response should:
- Acknowledge their issue specifically (not "we received your request")
- Show you understand the impact on them
- Provide immediate next step (what you're doing OR what they should try)
- Set a realistic timeline for resolution
- Include your name and a way to reach you directly

Length: Under 150 words for email, under 75 for chat.
Tone: empathetic, competent, human. Not scripted.
Do NOT use: "I understand your frustration" (overused), "please be advised," or "we apologize for any inconvenience."

Write a response to a customer requesting a refund.

PRODUCT: [WHAT THEY BOUGHT]
REASON FOR REFUND: [WHY THEY WANT IT]
REFUND POLICY: [YOUR ACTUAL POLICY — e.g., "30-day money-back guarantee" or "no refunds after 14 days"]
PURCHASE DATE: [WHEN THEY BOUGHT IT]
ELIGIBLE: [YES / NO / PARTIAL]
CUSTOMER HISTORY: [NEW CUSTOMER / LONG-TERM / REPEAT ISSUE]

If ELIGIBLE:
- Confirm the refund with timeline
- Express genuine regret they weren't satisfied
- Ask if there's anything that would have changed their experience
- Mention the door is always open

If NOT ELIGIBLE:
- Explain why clearly and cite the specific policy
- Offer alternatives (credit, exchange, downgrade, extended trial)
- Escalation path if they disagree
- Remain warm — this is a retention opportunity

Tone: fair, transparent, not defensive.

Write a response acknowledging a customer's bug report.

PRODUCT: [YOUR PRODUCT]
BUG REPORTED: [WHAT THE CUSTOMER DESCRIBED]
REPRODUCIBLE: [YES / NO / NEEDS MORE INFO]
IMPACT: [BLOCKING THEIR WORK / ANNOYING BUT WORKAROUND EXISTS / COSMETIC]
CURRENT STATUS: [KNOWN ISSUE / NEW REPORT / UNDER INVESTIGATION]

The response should:
- Thank them for the detailed report (or ask for more details if vague)
- Confirm you can reproduce it (or explain what you need to try)
- Provide a workaround if one exists
- Give a realistic timeline (NOT "we'll fix it ASAP")
- Offer to notify them when it's resolved
- If it's a known issue: link to status page or existing thread

Do NOT promise a fix date unless engineering has confirmed one.

Write a response to a customer requesting a feature.

PRODUCT: [YOUR PRODUCT]
REQUESTED FEATURE: [WHAT THEY WANT]
FEATURE STATUS: [ON ROADMAP / UNDER CONSIDERATION / NOT PLANNED / ALREADY EXISTS]
CUSTOMER TIER: [FREE / PAID / ENTERPRISE]
REQUEST FREQUENCY: [FIRST TIME / COMMONLY REQUESTED / TOP REQUEST]

If ON ROADMAP:
- Confirm it's planned (without promising a date)
- Share rough timeline if available (this quarter, this year)
- Offer to add them to the notification list

If UNDER CONSIDERATION:
- Thank them for the input
- Explain how feature requests influence your roadmap
- Ask follow-up questions about their use case

If NOT PLANNED:
- Be honest — don't say "we'll consider it" if you won't
- Explain the reasoning briefly
- Suggest a workaround or alternative approach

If ALREADY EXISTS:
- Show them how to use it (with steps or a link)
- Ask if it solves their need or if they need something different

Never say "great suggestion!" if you have no intention of building it.

Write a response to a customer disputing a charge.

COMPANY: [YOUR COMPANY]
DISPUTED AMOUNT: [CHARGE AMOUNT]
CHARGE REASON: [WHY THEY WERE CHARGED — renewal, overage, upgrade, etc.]
CUSTOMER'S CLAIM: [WHAT THEY BELIEVE HAPPENED]
ACTUAL SITUATION: [WHAT ACTUALLY HAPPENED BASED ON YOUR RECORDS]
RESOLUTION OPTIONS: [REFUND / CREDIT / EXPLANATION / ESCALATION]

The response should:
- Start with understanding, not defensiveness
- Clearly explain what the charge is for with dates and details
- If we made an error: own it immediately, state the fix, and apologize
- If the charge is correct: explain clearly with evidence (signup date, terms agreed to, notification sent)
- Provide the resolution and next steps
- If they disagree: offer to connect with a billing specialist

Include specifics — "Your subscription renewed on [DATE] as per the annual plan you selected on [SIGNUP DATE]."
Never: "Per our records" or "As per our terms and conditions" without human context.

Write a de-escalation response to an angry customer.

PRODUCT: [YOUR PRODUCT]
CUSTOMER'S COMPLAINT: [WHAT THEY'RE UPSET ABOUT — QUOTE THEIR WORDS IF POSSIBLE]
LEGITIMACY: [THEY HAVE A VALID POINT / PARTIALLY VALID / MISUNDERSTANDING]
WHAT WENT WRONG: [ROOT CAUSE IF KNOWN]
WHAT WE CAN DO: [AVAILABLE REMEDIES]
PREVIOUS INTERACTIONS: [FIRST CONTACT / REPEATED ISSUE / ESCALATED BEFORE]

The response should:
- Lead with validation, not defense (even if they're wrong about specifics)
- Name the emotion without being patronizing ("I can see this has been a frustrating experience" — once, not three times)
- Take responsibility where appropriate
- State clearly what you WILL do (specific action, specific timeline)
- State what you CAN'T do and why (if applicable)
- Provide a direct contact for follow-up (not "reply to this ticket")

Do NOT: apologize more than once, use the word "unfortunately" repeatedly, or make promises you can't keep.

Write a service recovery response after a significant failure.

PRODUCT: [YOUR PRODUCT/SERVICE]
WHAT FAILED: [WHAT HAPPENED — outage, data loss, missed SLA, wrong delivery, etc.]
DURATION/IMPACT: [HOW LONG / HOW MANY AFFECTED]
CUSTOMER IMPACT: [WHAT THIS COST THEM — DOWNTIME, LOST REVENUE, WASTED TIME]
ROOT CAUSE: [WHAT WENT WRONG — BE HONEST]
WHAT YOU'VE DONE: [IMMEDIATE FIX OR REMEDIATION]
PREVENTION: [WHAT YOU'RE DOING TO PREVENT RECURRENCE]
COMPENSATION: [CREDIT / REFUND / EXTENDED SERVICE / NONE]

Structure:
1. Acknowledge what happened (no minimizing)
2. Take responsibility
3. Explain the root cause (simply, no jargon)
4. Detail what you've done to fix it
5. Explain what you're doing to prevent it from happening again
6. Offer compensation if appropriate
7. Personal contact for follow-up

This should read like it came from a human who genuinely cares, not a legal-approved template.

Write a script for escalating a customer to a manager/supervisor.

SITUATION: [WHAT THE CUSTOMER NEEDS]
WHY ESCALATING: [AGENT CAN'T RESOLVE / CUSTOMER REQUESTED MANAGER / POLICY EXCEPTION NEEDED]
CUSTOMER'S EMOTIONAL STATE: [CALM / FRUSTRATED / ANGRY / THREATENING TO LEAVE]

Provide two scripts:

Script 1 — What the agent says to the customer:
- Transition statement (positions the escalation as helpful, not a brush-off)
- What happens next (who they'll talk to, when, what authority that person has)
- Reassurance that their issue details will transfer (they won't repeat themselves)

Script 2 — Internal handoff note to the manager:
- Customer summary (name, tier, account value)
- Issue summary (what happened, what was tried)
- Customer's emotional state and key concerns
- What the customer expects as resolution
- Recommended resolution if the agent has one
- Urgency level

Write an initial response to a customer who has mentioned legal action, lawyers, or regulatory complaints.

PRODUCT: [YOUR PRODUCT/SERVICE]
CUSTOMER'S STATEMENT: [WHAT THEY SAID — PARAPHRASE]
UNDERLYING ISSUE: [THE ACTUAL PROBLEM THEY'RE EXPERIENCING]
VALID COMPLAINT: [YES / PARTIALLY / NO]

The response should:
- Remain calm and professional (no emotional reaction to the legal threat)
- Take their underlying concern seriously
- Do NOT acknowledge or respond to the legal threat directly
- Focus on resolving the actual issue
- Offer to connect them with a senior team member
- Document everything but don't say "this is being documented"

Include an internal escalation note:
- Flag for legal/compliance team review
- Full interaction history summary
- Recommended immediate actions
- Do not make any admissions or commitments beyond standard policy

Write a response to a VIP/high-value customer who has a complaint.

CUSTOMER: [NAME AND ACCOUNT DETAILS]
ACCOUNT VALUE: [ANNUAL REVENUE OR TIER]
ISSUE: [THEIR COMPLAINT]
HISTORY: [HOW LONG THEY'VE BEEN A CUSTOMER, PREVIOUS ISSUES]
WHAT WE CAN OFFER: [AVAILABLE REMEDIES AND AUTHORITY LEVEL]

The response should:
- Use their name and reference their history with you
- Acknowledge this isn't the experience they deserve
- Skip the standard process — go straight to resolution
- Offer something concrete (not just "we'll look into it")
- Provide direct access to a named person going forward
- Follow up proactively (don't wait for them to chase)

Tone: premium, personal, action-oriented. This customer should feel like a human is handling their issue, not a ticket system.

Analyze these common support ticket themes and generate an FAQ page.

PRODUCT: [YOUR PRODUCT]
TOP TICKET THEMES:
1. [THEME 1] — frequency: [X TICKETS/MONTH]
2. [THEME 2] — frequency: [X TICKETS/MONTH]
3. [THEME 3] — frequency: [X TICKETS/MONTH]
4. [THEME 4] — frequency: [X TICKETS/MONTH]
5. [THEME 5] — frequency: [X TICKETS/MONTH]

For each theme, generate:
- FAQ question (phrased the way a customer would ask it)
- Answer (clear, concise, step-by-step if applicable)
- Related questions (2-3 follow-ups they might have)
- Link placeholders to relevant docs or features

Organize by category, not alphabetically.
Lead with the highest-volume questions.
Write answers at an 8th-grade reading level — no jargon.
Include a "Still need help?" CTA at the bottom of each answer.

Write a help center article explaining how to [TASK].

PRODUCT: [YOUR PRODUCT]
FEATURE: [SPECIFIC FEATURE]
AUDIENCE: [BEGINNER / INTERMEDIATE / ADVANCED USERS]
PLATFORM: [WEB / MOBILE / DESKTOP / ALL]

Include:
- Title (task-oriented — "How to [verb] [thing]")
- Brief intro (1-2 sentences — what this helps them do and when they'd need it)
- Prerequisites (what they need before starting)
- Step-by-step instructions:
  - Numbered steps with specific UI references ("Click the gear icon in the top right")
  - Screenshot placeholders: [SCREENSHOT: description of what to capture]
  - Expected result after each major step
- Troubleshooting section (3 common issues and fixes)
- Related articles (link placeholders)

Keep it scannable: short paragraphs, bold key terms, use bullet points for lists.

Create a troubleshooting guide for [COMMON ISSUE].

PRODUCT: [YOUR PRODUCT]
ISSUE: [WHAT THE USER IS EXPERIENCING]
AFFECTED USERS: [ALL / SPECIFIC SEGMENT — e.g., mobile users, free tier]
KNOWN CAUSES: [LIST POSSIBLE CAUSES]

Structure as a decision tree:
1. Start with the most common cause and simplest fix
2. If that doesn't work, try [NEXT STEP]
3. Continue with progressively more complex solutions
4. End with "Contact support" if nothing works

For each step:
- What to check
- How to check it (specific instructions)
- What the fix is
- Expected outcome if the fix works

Include:
- Time estimate for total troubleshooting (e.g., "This should take 5-10 minutes")
- When to skip straight to contacting support (data loss, security, etc.)
- Information to have ready when contacting support

Write customer-facing release notes for [PRODUCT] version [VERSION].

CHANGES:
- New features:
  1. [FEATURE 1]: [TECHNICAL DESCRIPTION]
  2. [FEATURE 2]: [TECHNICAL DESCRIPTION]
- Improvements:
  1. [IMPROVEMENT 1]: [WHAT CHANGED]
  2. [IMPROVEMENT 2]: [WHAT CHANGED]
- Bug fixes:
  1. [BUG 1]: [WHAT WAS FIXED]
  2. [BUG 2]: [WHAT WAS FIXED]
- Breaking changes: [ANY, OR "NONE"]

For each item, translate the technical description into customer language:
- What it does (benefit, not feature)
- Who it's for (which users care)
- How to use it (1-2 sentences or link to docs)

Format with clear sections: New, Improved, Fixed, Changed.
Lead with the most impactful change.
Tone: informative and direct. Not marketing copy — these are for existing users.

Write product documentation for [FEATURE NAME].

PRODUCT: [YOUR PRODUCT]
FEATURE: [FEATURE NAME AND PURPOSE]
USER TYPES: [WHO USES THIS — roles, tiers]
RELATED FEATURES: [FEATURES THAT CONNECT TO THIS ONE]

Create a comprehensive documentation page:

Overview:
- What this feature does (2-3 sentences)
- Why you'd use it (use case examples)
- Who has access (plan/role requirements)

Getting Started:
- How to enable or access the feature
- Initial setup steps
- Default settings and recommendations

Using the Feature:
- Core workflows (step-by-step for each major use case)
- Configuration options with explanations
- Tips and best practices

Advanced Usage:
- Power user features
- API access (if applicable)
- Integrations with other features

FAQs:
- 5 common questions with answers

Keep language consistent with your existing docs. Use present tense. Address the user as "you."

Create a ticket categorization system for [PRODUCT] support.

CURRENT VOLUME: [TICKETS PER MONTH]
TEAM SIZE: [NUMBER OF AGENTS]
CURRENT CATEGORIES: [LIST EXISTING ONES, OR "NONE — STARTING FRESH"]

Design a categorization taxonomy:

Level 1 — Issue Type (5-7 categories max):
- [e.g., Billing, Technical, Account, Feature Request, General]

Level 2 — Sub-category (3-5 per category):
- [e.g., Technical > Login Issues, Performance, Integration, Bug Report]

Level 3 — Specific Issue (optional, for top-volume areas):
- [e.g., Login Issues > Password Reset, SSO, 2FA]

For each Level 1 category:
- Priority assignment rules (what makes it P1 vs P2 vs P3)
- SLA target (first response time, resolution time)
- Routing rules (which agent/team handles it)
- Auto-response template recommendation

Include: decision tree for agents to categorize tickets consistently.

Create a quality assurance scorecard for evaluating customer support interactions.

CHANNEL: [EMAIL / CHAT / PHONE / ALL]
SCORING SCALE: [1-5 / PERCENTAGE / PASS-FAIL]
TEAM SIZE: [NUMBER OF AGENTS]

Evaluation criteria (weighted):

Communication Quality (X%):
- Grammar, spelling, and professionalism
- Tone matching (appropriate to customer's emotional state)
- Clarity and conciseness

Issue Resolution (X%):
- Correct diagnosis of the issue
- Appropriate solution provided
- Complete resolution (customer doesn't need to write back)

Process Adherence (X%):
- Proper categorization and tagging
- Followed escalation procedures when needed
- Used correct templates/macros appropriately (not robotically)

Customer Experience (X%):
- Personalization (used name, referenced history)
- Proactive support (anticipated follow-up questions)
- Set appropriate expectations

For each criterion: description, scoring guide, and examples of 1 vs 3 vs 5 ratings.
Include: monthly calibration session agenda to keep scoring consistent across reviewers.

Create a macro/template library for [PRODUCT] support team.

PRODUCT: [YOUR PRODUCT]
TOP TICKET TYPES:
1. [TYPE 1]
2. [TYPE 2]
3. [TYPE 3]
4. [TYPE 4]
5. [TYPE 5]
BRAND VOICE: [DESCRIBE YOUR SUPPORT TONE]

For each ticket type, create 2-3 macros:
- Macro name (searchable, descriptive)
- When to use it (trigger criteria)
- The template text with personalization placeholders:
  - {{customer_name}}
  - {{specific_issue}}
  - {{product_name}}
  - {{custom_field}} where needed
- Required customization notes (what the agent MUST personalize before sending)

Include:
- Naming convention for the macro library
- Tagging system for easy search
- Review schedule (when to update outdated macros)
- Guidelines: when to use a macro vs write from scratch

Define clear escalation criteria for [PRODUCT] support team.

SUPPORT TIERS:
- Tier 1: [WHAT THEY HANDLE]
- Tier 2: [WHAT THEY HANDLE]
- Tier 3 / Engineering: [WHAT THEY HANDLE]
- Management: [WHEN TO INVOLVE]

Create an escalation matrix:

Auto-escalate (no agent decision needed):
- [LIST SITUATIONS — e.g., data breach, complete outage, legal threat]

Escalate to Tier 2 when:
- [CRITERIA — e.g., issue requires backend access, multi-system problem]
- Time trigger: [HOURS BEFORE AUTO-ESCALATION]
- Required handoff information

Escalate to Engineering when:
- [CRITERIA — e.g., confirmed bug, infrastructure issue]
- Required handoff information (reproduction steps, logs, etc.)

Escalate to Management when:
- [CRITERIA — e.g., revenue risk above $X, PR risk, repeated failure]
- Required handoff information

For each escalation path:
- How to escalate (channel, format, urgency marking)
- Expected response time from the next tier
- What the escalating agent should tell the customer
- What NOT to promise during escalation

Write response templates for when SLA targets are missed.

YOUR SLA COMMITMENTS:
- First response: [TIME]
- Resolution: [TIME]
- Uptime: [PERCENTAGE]

Create templates for:

Template 1 — First response SLA breach (you're late responding):
- Apologize for the delay specifically
- Acknowledge the missed commitment
- Provide the substantive response (don't just say sorry and make them wait more)

Template 2 — Resolution SLA breach (issue taking too long):
- Update on what's happening and why it's taking longer than expected
- Revised timeline
- What you're doing to speed things up
- Offer to escalate or provide interim solution

Template 3 — Uptime SLA breach (service was down):
- Outage acknowledgment
- Impact summary
- Root cause (at appropriate detail level)
- SLA credit calculation or next steps for claiming it
- Prevention measures

Each template should be adaptable to the severity and customer tier.