Systematically Debug and Fix Errors

Systematically debug and fix errors

Instructions

Follow this comprehensive debugging methodology to resolve: $ARGUMENTS

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• Prevention Measures

- Add appropriate unit and integration tests

- Improve error handling and logging

- Add input validation and defensive checks

- Update documentation and code comments

• Monitoring and Alerting

- Set up monitoring for similar issues

- Add metrics and health checks

- Configure alerts for error thresholds

- Implement better observability

• Documentation

- Document the error, investigation process, and solution

- Update troubleshooting guides

- Share learnings with the team

- Update code comments with context

• 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.