code-debugger

Map function call chains and variable dependencies to analyze code context.

6|1|Updated Jul 1, 2026
One-click install
npx skills add https://github.com/PancrePal-xiaoyibao/VitaForge --skill code-debugger-pancrepal-xiaoyibao
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: code-debugger
Source: https://github.com/PancrePal-xiaoyibao/VitaForge/tree/main/.gemini/skills/code-debugger
Command: npx skills add https://github.com/PancrePal-xiaoyibao/VitaForge --skill code-debugger-pancrepal-xiaoyibao

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

This Skill addresses the inefficiency of surface-level debugging by providing a structured, context-aware system that maps code relationships and maintains a persistent knowledge base to prevent recurring bugs.

Core Features & Use Cases

  • Context Mapping: Automatically builds dependency graphs, function call chains, and variable flow networks to understand complex logic before modification.
  • Debug-Checkfix Loop: Enforces a mandatory verification cycle using project-specific linting and build tools to ensure fixes are robust and regression-free.
  • Use Case: When a complex bug spans multiple modules, use this Skill to trace the data flow, document the root cause in a .debug file, and verify the fix against the project's specific build environment.

Quick Start

Use the code-debugger skill to analyze the current module and identify the root cause of the reported issue.

Frequently Asked Questions about code-debugger

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I debug a complex bug that spans multiple modules?▼

Debugging multi-module bugs requires mapping function call chains and variable dependencies to trace data flow. This context-aware approach identifies the root cause, documents it in a .debug file, and verifies fixes using project-specific linting.

What is context-aware code analysis for incremental development?▼

Context-aware code analysis builds dependency graphs and variable flow networks to understand logic before modification. It supports incremental development by maintaining a persistent knowledge base that prevents recurring bugs.

How do I trace function call chains and variable dependencies before refactoring?▼

You trace function call chains and variable dependencies by mapping code relationships to build a dependency graph. This structured mapping highlights complex logic flows before you modify or expand features.

Does automated linting work with the debug-checkfix verification cycle?▼

Automated linting works with the debug-checkfix loop by enforcing a mandatory verification cycle using project-specific build tools. This ensures fixes are robust and regression-free before integration.

When do I need persistent documentation for bug remediation?▼

You need persistent documentation for bug remediation when a complex bug spans multiple modules and requires tracing data flow. Documenting the root cause in a .debug file prevents recurring bugs across complex software architectures.

What's the best way to prevent recurring bugs during feature expansion?▼

The best way to prevent recurring bugs during feature expansion is maintaining a persistent knowledge base through context mapping. Mapping variable dependencies and enforcing environment-aware verification cycles ensures robust, regression-free modifications.