Skip to main content

Debug with AI Language Support

tip

Cursor's AI-powered debugging features help you identify and fix issues faster by providing intelligent analysis and suggestions.

Getting Started​

Enabling AI Debug Support​

  1. Open Command Palette (Ctrl/Cmd + Shift + P)
  2. Type "Enable AI Debug"
  3. Select to activate the feature

Basic Features​

1. Error Analysis​

When you encounter an error, AI can help analyze it:

example-error.js
// Error in code
const user = getUserData();
console.log(user.name.toLowerCase());

// AI Analysis
// ⚠️ Potential null reference
// - user might be null/undefined
// - user.name might be null/undefined
// Suggestion: Add null checks

2. Quick Fixes​

AI suggests fixes for common issues:

component.tsx
// Before: Type error
const handleClick = (event) => {
  console.log(event.value);
};

// AI Suggestion
const handleClick = (event: React.MouseEvent) => {
  console.log(event.currentTarget.value);
};

Advanced Features​

1. Runtime Analysis​

AI can analyze runtime behavior:

performance.py
# Performance issue
def process_data(items):
    result = []
    for item in items:
        result.append(transform(item))
    return result

# AI Suggestion
def process_data(items):
    return [transform(item) for item in items]
    # 🚀 Performance improvement:
    # - List comprehension is faster
    # - Reduces memory allocation

2. Context-Aware Debugging​

The AI understands your codebase context:

auth.service.ts
// Original code with bug
async function validateUser(token) {
  const user = await getUser(token);
  return user.isValid;
}

// AI Debug Analysis
/**
 * Issues found:
 * 1. No error handling for invalid tokens
 * 2. No type checking for user object
 * 3. Missing null check for user
 */

// AI Suggested Fix
async function validateUser(token: string): Promise<boolean> {
  try {
    const user = await getUser(token);
    return user?.isValid ?? false;
  } catch (error) {
    console.error('User validation failed:', error);
    return false;
  }
}

Debugging Workflows​

1. Interactive Debugging​

Use AI during debugging sessions:

// Place AI-powered breakpoints
debugger; // AI will analyze variable states

// AI Debug Console
> ai.analyze(variableName)
> ai.suggest.fix()
> ai.explain.state()

2. Log Analysis​

AI can help analyze complex logs:

# Complex log output
[2024-03-20T10:15:30] Error: Connection refused...
[2024-03-20T10:15:31] Retry attempt 1...
[2024-03-20T10:15:32] Error: Timeout...

# AI Analysis
"""
Issue detected: Network connectivity problem
- Initial connection refused
- Timeout on retry
Suggestion: Check network settings and firewall rules
"""

Language-Specific Features​

JavaScript/TypeScript​

// Type inference
function processData(data) {
  // AI suggests types based on usage
  return data.map(item => item.value);
}

Python​

# Type hints and runtime checks
def calculate_average(numbers: List[float]) -> float:
    # AI suggests input validation
    if not numbers:
        raise ValueError("Empty list provided")
    return sum(numbers) / len(numbers)

Best Practices​

1. Error Prevention​

Use AI to catch potential errors:

// AI-suggested error prevention
function divideNumbers(a: number, b: number): number {
  // AI adds safety checks
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new TypeError('Arguments must be numbers');
  }
  if (b === 0) {
    throw new Error('Division by zero');
  }
  return a / b;
}

2. Code Quality​

AI helps maintain code quality:

// Before
function fn(x) {
  var res = x + 1;
  return res;
}

// After (AI-improved)
const increment = (value: number): number => {
  return value + 1;
};

3. Performance Optimization​

AI identifies performance issues:

// Performance issue
const results = data
  .filter(item => item.active)
  .map(item => transform(item))
  .filter(item => item !== null);

// AI optimization
const results = data.reduce((acc, item) => {
  if (item.active) {
    const transformed = transform(item);
    if (transformed !== null) {
      acc.push(transformed);
    }
  }
  return acc;
}, []);

Advanced Debugging Techniques​

1. Memory Leak Detection​

AI helps identify memory leaks:

// Memory leak detection
class Component {
  constructor() {
    // AI warning: Potential memory leak
    window.addEventListener('resize', this.onResize);
  }
  
  // AI suggestion
  cleanup() {
    window.removeEventListener('resize', this.onResize);
  }
}

2. Async Debug​

Debug async operations with AI:

// Async debugging
async function fetchData() {
  try {
    const response = await api.get('/data');
    return response.data;
  } catch (error) {
    // AI provides context-aware error handling
    if (error.response?.status === 404) {
      return [];
    }
    throw new Error(`Data fetch failed: ${error.message}`);
  }
}

Integration with Tools​

1. Version Control​

AI helps debug git-related issues:

# Git conflict
<<<<<<< HEAD
const config = { port: 3000 };
=======
const config = { port: 8080 };
>>>>>>> feature-branch

# AI Analysis
"""
Conflict type: Configuration value
Recommendation: Use environment variable
Solution: const config = { port: process.env.PORT || 3000 };
"""

2. Testing​

AI assists in test debugging:

user.test.ts
describe('User Authentication', () => {
  it('should validate user credentials', async () => {
    // AI suggests test improvements
    const result = await auth.validate(credentials);
    expect(result).toBe(true);
    // AI: Add edge case tests
    // AI: Add timeout handling
  });
});

Troubleshooting AI Debug​

Common Issues​

  1. AI Not Responding

    # Reset AI debug session
    > ai.debug.reset()

  2. Incorrect Suggestions

    # Provide more context
    > ai.debug.context.add(fileContent)

  3. Performance Issues

    # Optimize AI analysis
    > ai.debug.optimize()

Tips for Success​

  1. Provide Clear Context

    • Include relevant code
    • Describe expected behavior
    • Share error messages

  2. Iterative Debugging

    • Start with simple cases
    • Add complexity gradually
    • Validate AI suggestions

  3. Maintain Documentation

    • Document fixed issues
    • Track AI suggestions
    • Share solutions
tip

Use ai.debug.explain() to get detailed explanations of AI suggestions!