arabelatso/skills-4-se/bug-to-patch-generator

Trust tier 3
  • community
Source check pending

Checking that the SKILL.md file is still in the repository.

Generate code fixes and patches from bug reports, failing test cases, error messages, and stack traces. Use this skill when debugging code, fixing test failures, addressing GitHub issues, resolving runtime errors, or patching security vulnerabilities. Analyzes the bug context, identifies root causes, and generates precise code patches with explanations and validation steps.

Install

npx vskill@latest install arabelatso/skills-4-se/bug-to-patch-generator

SKILL.md

Bug-to-Patch Generator

Automatically generate code fixes from bug reports, failing tests, error messages, and stack traces. Analyzes bug context, identifies root causes, and produces verified patches.

Core Capabilities

1. Bug Analysis

Understand bugs from multiple sources:

  • Failing test cases - Analyze test failures and expected vs actual behavior
  • Error messages - Parse exceptions, stack traces, and error logs
  • Bug reports - Process issue descriptions, reproduction steps, and screenshots
  • Crash dumps - Interpret segmentation faults, core dumps, and memory errors
  • Runtime errors - Handle assertion failures, type errors, and logic bugs
2. Root Cause Identification

Determine the underlying issue:

  • Trace error back to source
  • Identify incorrect logic or assumptions
  • Find missing validation or edge cases
  • Detect off-by-one errors and boundary issues
  • Recognize concurrency problems
  • Spot resource leaks and memory issues
3. Patch Generation

Create targeted fixes:

  • Minimal, focused changes
  • Preserve existing functionality
  • Follow code style and patterns
  • Include safety checks where needed
  • Add comments explaining the fix
  • Suggest related improvements
4. Patch Validation

Ensure fix correctness:

  • Verify fix addresses the bug
  • Check for regression risks
  • Suggest validation tests
  • Recommend manual verification steps
  • Consider edge cases and side effects

Bug-to-Patch Workflow

Step 1: Gather Bug Context

Collect all relevant information:

From failing tests:

python
FAILED tests/test_calculator.py::test_divide - ZeroDivisionError: division by zero
def test_divide():
    result = divide(10, 0)
    assert result == None  # Expected to return None for division by zero

From error messages:

Traceback (most recent call last):
  File "app.py", line 42, in process_data
    result = data[index]
IndexError: list index out of range

From bug reports:

Title: App crashes when processing empty file
Steps to reproduce:
1. Upload empty CSV file
2. Click "Process"
3. App crashes with NoneType error
 
Expected: Error message shown to user
Actual: Application crashes
Step 2: Analyze the Bug

Identify the root cause:

Questions to answer:

  • What is the exact error?
  • Where does it occur? (file, line, function)
  • What are the preconditions?
  • What input triggers it?
  • What was expected vs what happened?
  • Is it a logic error, validation issue, or edge case?

Common bug patterns:

  • Missing null/None checks
  • Off-by-one errors
  • Incorrect boundary conditions
  • Missing error handling
  • Wrong operator or comparison
  • Race conditions
  • Resource leaks
  • Type mismatches
Step 3: Locate Relevant Code

Find the code that needs fixing:

python
# Read the source file
def divide(a, b):
    return a / b  # Bug: No check for b == 0

Context needed:

  • The buggy function/method
  • Related functions it calls
  • Caller functions
  • Test cases
  • Similar correct implementations
Step 4: Generate the Patch

Create minimal, focused fix:

Patch format:

python
# Before (buggy code)
def divide(a, b):
    return a / b
# After (fixed code)
def divide(a, b):
    if b == 0:
        return None  # or raise ValueError("Cannot divide by zero")
    return a / b

Patch components:

  1. Clear before/after comparison
  2. Explanation of the fix
  3. Why this approach was chosen
  4. Potential alternatives
  5. Edge cases now handled
Step 5: Validate the Fix

Ensure correctness:

Validation steps:

python
# Test that should now pass
def test_divide_by_zero():
    assert divide(10, 0) is None
# Additional tests for edge cases
def test_divide_normal():
    assert divide(10, 2) == 5
def test_divide_negative():
    assert divide(-10, 2) == -5

Verification checklist:

  • [ ] Original test now passes
  • [ ] Existing tests still pass (no regression)
  • [ ] Edge cases handled
  • [ ] Error messages are clear
  • [ ] Performance not degraded

Bug Fix Patterns

Pattern 1: Missing Null/None Check

Bug report:

AttributeError: 'NoneType' object has no attribute 'upper'

Buggy code:

python
def format_name(name):
    return name.upper()

Root cause: No validation for None input

Patch:

python
def format_name(name):
    if name is None:
        return ""  # or raise ValueError("Name cannot be None")
    return name.upper()

Explanation:

  • Added None check before accessing string method
  • Returns empty string for None (or could raise exception)
  • Prevents AttributeError

Alternative approaches:

python
# Option 1: Raise exception
def format_name(name):
    if name is None:
        raise ValueError("Name cannot be None")
    return name.upper()
# Option 2: Use default parameter
def format_name(name=None):
    return (name or "").upper()
# Option 3: Type hint and early return
def format_name(name: str | None) -> str:
    if not name:
        return ""
    return name.upper()
Pattern 2: Off-by-One Error

Bug report:

IndexError: list index out of range

Failing test:

python
def test_get_last_element():
    arr = [1, 2, 3]
    assert get_element(arr, 3) == 3  # Want last element

Buggy code:

python
def get_element(arr, index):
    return arr[index]  # index 3 is out of bounds for length 3

Root cause: Confusion between length and index (0-based)

Patch:

python
def get_element(arr, index):
    if index < 0 or index >= len(arr):
        raise IndexError(f"Index {index} out of range for array of length {len(arr)}")
    return arr[index]

Explanation:

  • Added bounds checking
  • Clear error message
  • Handles negative indices too

Better alternative:

python
def get_element(arr, index):
    """Get element at index. Supports negative indexing."""
    try:
        return arr[index]
    except IndexError:
        raise IndexError(f"Index {index} out of range for array of length {len(arr)}")
Pattern 3: Missing Error Handling

Bug report:

Application crashes when file doesn't exist
FileNotFoundError: [Errno 2] No such file or directory: 'config.json'

Buggy code:

python
def load_config():
    with open('config.json') as f:
        return json.load(f)

Root cause: No handling for missing file

Patch:

python
def load_config():
    try:
        with open('config.json') as f:
            return json.load(f)
    except FileNotFoundError:
        # Return default config
        return {"debug": False, "port": 8080}
    except json.JSONDecodeError as e:
        raise ValueError(f"Invalid JSON in config.json: {e}")

Explanation:

  • Added FileNotFoundError handling with sensible default
  • Also handles JSON parsing errors
  • Provides clear error message for invalid JSON

Alternative with logging:

python
import logging
def load_config():
    try:
        with open('config.json') as f:
            return json.load(f)
    except FileNotFoundError:
        logging.warning("config.json not found, using defaults")
        return {"debug": False, "port": 8080}
    except json.JSONDecodeError as e:
        logging.error(f"Invalid JSON in config.json: {e}")
        raise
Pattern 4: Incorrect Logic/Condition

Failing test:

python
def test_is_even():
    assert is_even(0) == True  # FAILS
    assert is_even(2) == True
    assert is_even(3) == False

Buggy code:

python
def is_even(n):
    if n % 2:  # Bug: 0 % 2 == 0 which is falsy
        return False
    return True

Root cause: Incorrect boolean logic (0 is falsy)

Patch:

python
def is_even(n):
    return n % 2 == 0  # Explicitly check equality

Explanation:

  • Changed from implicit truthiness to explicit comparison
  • Handles 0 correctly (0 % 2 == 0 is True)
  • More readable and explicit
Pattern 5: Race Condition

Bug report:

Intermittent test failure in multithreaded code
AssertionError: Expected counter=1000, got counter=987

Buggy code:

python
class Counter:
    def __init__(self):
        self.count = 0
    def increment(self):
        self.count += 1  # Not atomic!

Root cause: Non-atomic operation in concurrent context

Patch (Python):

python
import threading
class Counter:
    def __init__(self):
        self.count = 0
        self.lock = threading.Lock()
    def increment(self):
        with self.lock:
            self.count += 1

Alternative using atomic operations:

python
from threading import Lock
from threading import local
class Counter:
    def __init__(self):
        self.count = 0
        self._lock = Lock()
    def increment(self):
        with self._lock:
            self.count += 1
# Or use atomic integer
from threading import Lock
class Counter:
    def __init__(self):
        from queue import Queue
        self._queue = Queue()
        self.count = 0
# Better: use threading.local or atomic types
import threading
class AtomicCounter:
    def __init__(self):
        self._value = 0
        self._lock = threading.Lock()
    def increment(self):
        with self._lock:
            self._value += 1
            return self._value
    @property
    def value(self):
        with self._lock:
            return self._value
Pattern 6: Memory Leak

Bug report:

Application memory usage grows unbounded
Memory increases by ~100MB every hour

Buggy code:

python
class Cache:
    def __init__(self):
        self.data = {}
    def store(self, key, value):
        self.data[key] = value  # Never clears old entries
    def get(self, key):
        return self.data.get(key)

Root cause: Unbounded cache growth

Patch:

python
from collections import OrderedDict
class Cache:
    def __init__(self, max_size=1000):
        self.data = OrderedDict()
        self.max_size = max_size
    def store(self, key, value):
        if key in self.data:
            # Move to end (most recently used)
            self.data.move_to_end(key)
        else:
            self.data[key] = value
        # Evict oldest if over limit
        if len(self.data) > self.max_size:
            self.data.popitem(last=False)
    def get(self, key):
        if key in self.data:
            # Move to end (most recently used)
            self.data.move_to_end(key)
            return self.data[key]
        return None

Explanation:

  • Implemented LRU cache with size limit
  • Uses OrderedDict for efficient LRU tracking
  • Automatically evicts oldest entries
Pattern 7: Incorrect Exception Type

Failing test:

python
def test_invalid_input():
    with pytest.raises(ValueError):
        process(-1)  # FAILS: raises TypeError instead

Buggy code:

python
def process(value):
    if value < 0:
        raise TypeError("Value must be non-negative")  # Wrong exception type
    return value * 2

Root cause: Using TypeError instead of ValueError

Patch:

python
def process(value):
    if value < 0:
        raise ValueError("Value must be non-negative")  # Correct exception
    return value * 2

Explanation:

  • ValueError is for invalid values
  • TypeError is for invalid types
  • Changed to appropriate exception type

Patch Presentation Format

Structured Patch Template
markdown
## Bug Fix: [Short description]
 
### Bug Details
-**Location:** [file:line]
-**Error:** [error message or test failure]
-**Root Cause:** [explanation of the underlying issue]
-**Severity:** [Critical/High/Medium/Low]
 
### Analysis
[Detailed explanation of why the bug occurs]
 
### Proposed Fix
 
#### Changes

File: [filename]

Before (lines X-Y)

[buggy code]

After

[fixed code]

 
#### Explanation
[Why this fix works and what it does]
 
#### Alternative Approaches
1. [Alternative 1]: [pros/cons]
2. [Alternative 2]: [pros/cons]
 
### Validation
 
#### Tests to Add/Modify

[test code that validates the fix]

This is the start of the file. Read the full SKILL.md on GitHub.
Security
  • Security scanPassed, 100 of 100Pattern checks on the skill's files.
  • Model reviewPassed
See the full security report
Quality evaluation
  • Task evaluationNot runNo evaluation yet. Run one in Skill Studio.
See evaluation results
Source
Popularity
Repository stars
63
Repository forks
5
7-day trend score
21
Stars and forks are for the whole GitHub repository, not this skill alone. Refreshed 20 Mar 2026, 7 months ago.
Works with
Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.
  • Claude Code
  • Cursor
  • GitHub Copilot
  • Windsurf
  • Codex
  • Gemini CLI
  • Cline
  • Amp
  • Roo Code
  • Goose
  • Continue
  • Kilo Code
  • Junie
  • Trae
  • OpenHands
  • Qwen Code
  • AI Agent
  • Tabnine Chat
  • Sourcegraph Cody
  • Amazon Q
  • Firebase Genkit
  • Sweep
  • Devin
  • Phind
  • Mentat
  • Claude Desktop
  • Aider
  • GPT Pilot
  • Plandex
  • bolt.new
  • v0
  • Replit Agent
  • Anse
  • TypingMind
  • BetterChatGPT
  • LibreChat
  • Warp AI
  • Pieces
  • Fig AI
Embed badge
vskill VERIFIED badge
[![vskill VERIFIED](https://verified-skill.com/api/v1/skills/arabelatso/skills-4-se/bug-to-patch-generator/badge)](https://verified-skill.com/skills/arabelatso/skills-4-se/bug-to-patch-generator)
Something wrong with this skill or its page? Tell us.