Identify-Bugs Skill

Use this skill when tasked with identifying or analyzing a bug. This is strictly for code traversal, root cause analysis (RCA), and bug identification. Do not use this skill for implementing fixes or writing fix code.

• •Persona: Act like you are a master of the language being analyzed and you know every core concept of this language.

1. Reproduce & Isolate

• •Consistent Repro: Can the bug be reproduced consistently? Document the steps.
• •Isolate: Identify the minimal environment or code subset where the bug occurs.
• •Isolate Variables: Remove unrelated code/logic to simplify the problem space.

2. Code Traversal & Method Analysis

• •Entry Point: Start traversing code from a clear starting point (e.g., API endpoint, event trigger, or specific function call).
• •Loop Analysis: When encountering a loop, analyze the function or logic that initiates the loop to understand its boundaries and intent.
• •Trace Execution: Traverse from one method to the next sequentially to maintain context.
• •Method Logic: Check the internal working of each method visited; bugs often hide in subtle internal logic even if parameter passing is correct.

3. State & Data Flow Analysis

• •State Tracking: Trace how the internal state of an object or system changes at each step. Identify where the state diverges from the expected value.
• •Data Integrity: Verify that all arguments and parameters passed between methods are correct and maintain integrity.
• •Side Effects: In functional or hybrid languages, check for unexpected side effects in "pure" functions.
• •Type Safety: In statically typed languages, look for unsafe casts or logic that bypasses type checks. In dynamic languages, check for unexpected type mutations.

4. Concurrency & Resource Analysis

• •Race Conditions: If the language supports concurrency (async/await, threads, actors), check if multiple processes are accessing shared state without proper synchronization.
• •Resource Leaks: Look for unclosed streams, database connections, or memory that isn't being freed (even in GC languages, check for global references/closures).
• •Deadlocks/Starvation: Analyze if execution is hanging due to circular dependencies on resources or locks.

5. Paradigm-Specific Quiddities

• •Language Master Lens: Apply your mastery of the specific language's "quirks" (e.g., Python's mutable default arguments, JavaScript's this context/event loop, Rust's ownership, or C's pointer arithmetic).
• •Control Flow Logic: Analyze logic hierarchies. In OO, check for inheritance/polymorphism abuse. In Functional, check for deep recursion or complex closure captured variables.

6. Understand & Explain (RCA)

• •Root Cause: Identify the root cause of the issue, not just the symptoms, and explain why it occurs.
• •Bug Type: Categorize as a logical bug, race condition, memory/resource issue, or syntax/runtime bug.
• •Scope check: If a bug is found, investigate why it's happening and determine what other locations in the codebase might be affected by the same pattern.
• •Explain: Clearly describe the bug and its origin in plain language before acting.

7. Scenario Evaluation

• •Universal Edge Cases: Consider extremes: maximum/minimum integers, empty strings/collections, null/undefined, character encoding (UTF-8), timezones, and network latency.
• •Impact Analysis: Assess how this bug (and potential fixes) might affect the broader system.

8. Verification (Identification Only)

• •Confirmation: Ensure the identified bug's source has been pinpointed and its reproduction steps are fully understood.
• •Reporting: List any potential risks or related issues found during the traversal.

[!IMPORTANT] This skill is for identifying bugs in any language (current or future). For implementing fixes, use the bug-fixing skill. Always find the root cause before proceeding.