Skip to main content

Command Palette

Search for a command to run...

Cursor for Support

Resolving customer issues often requires understanding code you did not write: how a feature works, what could cause it to fail, why a user is seeing unexpected behavior. Cursor makes the codebase queryable, connects to your existing tools (Jira, Salesforce, Datadog, Slack), and lets you trace errors to their source.

Investigating issues

Open your product's repository and ask questions about specific features, error handling, or user flows. The codebase reflects the actual implementation, including edge cases and error conditions that may not be covered in documentation.

Ask mode example: Understand a feature
How does the data export feature work? What file formats does it support and what could cause an export to fail or produce an empty file?
Agent example: Investigate a support ticket
A customer reports: 'I tried to export my data but got a blank file. I'm on the Pro plan, account ID 12345.' Find the export functionality and identify what could cause blank exports.

Use Ask mode when exploring. Press Shift+Tab and select Ask. It prevents accidental changes while you trace through code paths.

For more exploration techniques, see Understanding Unfamiliar Code.

Multi-root workspaces

Cursor supports multi-root workspaces, which allow you to open multiple repositories at once. This is useful for opening the frontend, backend, and documentation associated with a given functionality.

Agent example: Trace across services
The customer sees an error on the checkout page. I have the frontend, backend, and payment service repos open. Trace what happens when they click 'Submit' and find where it's failing.

For complex support inquiries, you can give the model context on the full stack of the functionality and supplement it with information from your documentation. This all occurs in an Agent or Ask conversation.

This is useful when symptoms appear in one place but root causes live elsewhere: UI errors caused by API issues, or API failures caused by database problems.

Connecting your support stack

MCP integrations connect Cursor to tools you already use. Pull ticket context, customer data, and logs into your investigation without switching windows.

Agent example: Investigate with full context
Check this Jira ticket, review the customer's account in Salesforce, and look at their recent error logs in Datadog. What's causing their issue?
Agent example: Debug a billing issue
This customer says billing is wrong. Pull their subscription history from our database and compare it to what Stripe shows.

With MCP, you can connect Jira to check ticket details, pull documentation for context, and query databases to find the root cause. When you validate that a bug exists, you can use the Linear integration or Deeplinks to write a bug report with full context from your investigation. Engineers can pick up the investigation where you left off.

Browse the Marketplace for available integrations: Jira, Linear, Zendesk, Intercom, Salesforce, Datadog, Sentry, and more.

Automating ticket workflows

Cloud Agents run investigations asynchronously. Start an investigation, continue with other tickets, and check back when the agent has findings.

Agent example: Triage tickets automatically
For each new support ticket tagged 'technical', pull the customer's recent error logs, check for known issues in our runbook, and add a summary of likely causes to the ticket.

This works well for:

  • Initial triage: Gather context, check logs, and identify likely causes before a human reviews the ticket
  • Pattern detection: Flag tickets that match known issues with suggested resolutions
  • Documentation gaps: Identify when a ticket reveals missing documentation and draft updates

Background Agents also let you work on multiple tasks in parallel. While investigating an issue, you may find improvements that can be made to your documentation. Start a Background Agent to update the documentation while you continue investigating.

Updating documentation

When you resolve an issue and discover something worth documenting, you can update the documentation in the same session.

Agent example: Update docs from investigation
I just resolved a ticket about export timeouts for large files. Update our troubleshooting docs with this edge case and add the workaround.
Ask mode example: Find documentation gaps
Review the last 50 resolved tickets and identify common questions that aren't covered in our help docs. Draft articles for the top 3 gaps.

Switch from Ask mode to Agent mode to make changes. Have Cursor update the docs and submit a PR.

Building support tools

Ticket analyzers, customer lookup dashboards, internal runbooks: these are straightforward to build in Cursor.

Agent example: Build a ticket dashboard
Build a dashboard that shows our top 10 ticket categories this week, with links to relevant documentation for each.
Agent example: Build a customer lookup tool
Create a tool that takes a customer email, looks up their account, and shows their subscription status, recent activity, and any open tickets.

Escalating effectively

When escalating to engineering, Cursor helps you provide better context:

  • Share the Cursor chat so engineers have your investigation context
  • Reference specific files and code paths rather than vague descriptions
  • Document what you already ruled out to save engineering time
  • Provide clear reproduction steps based on your investigation

Use the Linear integration or Deeplinks to hand off investigations with full context. Engineers can pick up the investigation where you left off, with access to the files you examined and the hypotheses you tested.

Building a support knowledge base

Create a rules file to capture your team's debugging patterns:

Rules example: Support Debugging Patterns
# Support Debugging Context## Common issue categories- "Can't log in" -> Check auth provider status, then session/token issues- "Missing data" -> Check permissions first, then sync status, then data integrity- "Slow performance" -> Get timestamp range, check for N+1 queries or missing indexes## Useful queries- Find user by email: SELECT * FROM users WHERE email = ?- Check subscription: SELECT * FROM subscriptions WHERE user_id = ?- Recent errors: SELECT * FROM error_logs WHERE user_id = ? ORDER BY created_at DESC## Access notes- Production logs in Datadog, filter by user_id tag- Admin panel at /internal/admin for account lookups- Feature flags in LaunchDarkly dashboard

Getting started

You do not need a local development environment to start. Cloud Agents connect to your repositories and run in the background. Combined with the Slack integration, you can ask questions and kick off investigations from Slack without opening the editor.

For support teams who want to go deeper, the full Cursor app provides more control: multi-root workspaces for full-stack context, direct file editing, and the integrated browser for testing changes.

  1. Start with Cloud Agents. Ask questions about your codebase from Slack. No setup required, just connect your repositories.

  2. Connect your support tools. Browse the Marketplace for Jira, Zendesk, Salesforce, Datadog, and other integrations.

  3. Use Ask mode for research. Query the codebase without risk of changes. See Understanding Unfamiliar Code for exploration techniques.

  4. Automate with Background Agents. Set up agents to triage tickets, gather context, and update documentation automatically.

  5. Ship fixes yourself. When you find documentation gaps or small issues, switch to Agent mode and submit a PR. See Generating Documentation for documentation workflows.