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.