skills.rest
santosomar
santosomarCOMMUNITY
Explore all skills by this author →
Website𝕏@santosomarGitHub

technical-debt-analyzer

Analyze codebases to quantify and prioritize technical debt hotspots.

1|2|Updated Mar 10, 2026
Search Tags:#code quality#code analysis#refactoring#maintainability#technical debt#hotspots
One-click install
npx skills add https://github.com/santosomar/general-secure-coding-agent-skills --skill technical-debt-analyzer-santosomar
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: technical-debt-analyzer
Source: https://github.com/santosomar/general-secure-coding-agent-skills/tree/main/skills/code-quality/technical-debt-analyzer
Command: npx skills add https://github.com/santosomar/general-secure-coding-agent-skills --skill technical-debt-analyzer-santosomar

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps identify and prioritize areas of technical debt within a codebase, making it easier to plan refactoring efforts and justify engineering time.

Core Features & Use Cases

  • Technical Debt Analysis: Quantifies technical debt by analyzing factors like complexity, change frequency, and bug concentration.
  • Hotspot Identification: Pinpoints the most costly areas of debt using a complexity vs. change frequency map.
  • Prioritized Paydown Plan: Provides actionable recommendations for addressing identified debt, including estimated effort and prerequisites.
  • Use Case: When planning a refactoring sprint, use this Skill to understand which files are costing the most in terms of slower development and increased bug risk, and get a clear plan on how to fix them.

Quick Start

Analyze the current codebase to identify and report on technical debt hotspots.

Frequently Asked Questions about technical-debt-analyzer

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

FAQPage Schema
How do I identify technical debt hotspots in my codebase?▼

To identify technical debt hotspots, this Skill measures code complexity, change frequency from git logs, and bug concentration. It generates a hotspot map that pinpoints files costing the most in development time and bug risk to guide refactoring.

What metrics are used to quantify technical debt for refactoring prioritization?▼

Technical debt is quantified by analyzing code complexity metrics, change frequency from git logs, and bug tracking data. These metrics identify areas where high complexity and frequent changes slow development and increase bug risk.

How do I plan a refactoring sprint based on code complexity and bug concentration?▼

Plan a refactoring sprint by using the generated debt hotspot map to target areas with high complexity and bug concentration. The Skill provides an actionable paydown plan with prerequisites and estimated effort for each refactoring task.

What data do I need to generate a technical debt hotspot map?▼

Generating a technical debt hotspot map requires git logs for change frequency, code complexity metrics, and bug tracking data. This combination allows the Skill to accurately quantify and prioritize debt based on actual maintenance costs.

Does this technical debt analyzer provide estimated effort for refactoring tasks?▼

Yes, the analyzer provides a prioritized paydown plan that includes estimated effort and prerequisites for addressing identified debt. This helps justify engineering time by highlighting the cost of high-complexity, frequently changed code areas.

Related Skills

Explore More Software Engineering Skills→
quangphu1912quangphu1912
1

analyzing-code-quality

Analyze code quality by detecting anti-patterns and evaluating complexity.

Community
Intermediate
LuminairPrimeLuminairPrime

code-simplifier

Simplify and refine code while preserving all existing functionality.

Community
Intermediate
BerryKuipersBerryKuipers
7

record-quality-baseline

Record code quality metrics before refactoring into a timestamped JSON baseline.

Community
Intermediate
jackmcintyrejackmcintyre

python-refactoring

Analyze Python code for complexity, duplication, and best practices.

Community
Intermediate