/debug-error

Systematically Debug and Fix Errors

Systematically debug and fix errors

Instructions

Follow this comprehensive debugging methodology to resolve: **$ARGUMENTS**

1. **Error Information Gathering**

• Collect the complete error message, stack trace, and error code
• Note when the error occurs (timing, conditions, frequency)
• Identify the environment where the error happens (dev, staging, prod)
• Gather relevant logs from before and after the error

2. **Reproduce the Error**

• Create a minimal test case that reproduces the error consistently
• Document the exact steps needed to trigger the error
• Test in different environments if possible
• Note any patterns or conditions that affect error occurrence

3. **Stack Trace Analysis**

• Read the stack trace from bottom to top to understand the call chain
• Identify the exact line where the error originates
• Trace the execution path leading to the error
• Look for any obvious issues in the failing code

4. **Code Context Investigation**

• Examine the code around the error location
• Check recent changes that might have introduced the bug
• Review variable values and state at the time of error
• Analyze function parameters and return values

5. **Hypothesis Formation**

• Based on evidence, form hypotheses about the root cause
• Consider common causes:
• Null pointer/undefined reference
• Type mismatches
• Race conditions
• Resource exhaustion
• Logic errors
• External dependency failures

6. **Debugging Tools Setup**

• Set up appropriate debugging tools for the technology stack
• Use debugger, profiler, or logging as needed
• Configure breakpoints at strategic locations
• Set up monitoring and alerting if not already present

7. **Systematic Investigation**

• Test each hypothesis methodically
• Use binary search approach to isolate the problem
• Add strategic logging or print statements
• Check data flow and transformations step by step

8. **Data Validation**

• Verify input data format and validity
• Check for edge cases and boundary conditions
• Validate assumptions about data state
• Test with different data sets to isolate patterns

9. **Dependency Analysis**

• Check external dependencies and their versions
• Verify network connectivity and API availability
• Review configuration files and environment variables
• Test database connections and query execution

10. **Memory and Resource Analysis**

• Check for memory leaks or excessive memory usage
• Monitor CPU and I/O resource consumption
• Analyze garbage collection patterns if applicable
• Check for resource deadlocks or contention

11. **Concurrency Issues Investigation**

• Look for race conditions in multi-threaded code
• Check synchronization mechanisms and locks
• Analyze async operations and promise handling
• Test under different load conditions

12. **Root Cause Identification**

• Once the cause is identified, understand why it happened
• Determine if it's a logic error, design flaw, or external issue
• Assess the scope and impact of the problem
• Consider if similar issues exist elsewhere

13. **Solution Implementation**

• Design a fix that addresses the root cause
• Consider multiple solution approaches and trade-offs
• Implement the fix with appropriate error handling
• Add validation and defensive programming where needed

14. **Testing the Fix**

• Test the fix against the original error case
• Test edge cases and related scenarios
• Run regression tests to ensure no new issues
• Test under various load and stress conditions

15. **Prevention Measures**

• Add appropriate unit and integration tests
• Improve error handling and logging
• Add input validation and defensive checks
• Update documentation and code comments

16. **Monitoring and Alerting**

• Set up monitoring for similar issues
• Add metrics and health checks
• Configure alerts for error thresholds
• Implement better observability

17. **Documentation**

• Document the error, investigation process, and solution
• Update troubleshooting guides
• Share learnings with the team
• Update code comments with context

18. **Post-Resolution Review**

• Analyze why the error wasn't caught earlier
• Review development and testing processes
• Consider improvements to prevent similar issues
• Update coding standards or guidelines if needed

Remember to maintain detailed notes throughout the debugging process and consider the wider implications of both the error and the fix.