tech-debt-auditor

Classify and risk-rank technical debt into a refactoring backlog.

2|1|Updated May 17, 2026
One-click install
npx skills add https://github.com/rakibulism/agent-skills-os --skill tech-debt-auditor-rakibulism
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tech-debt-auditor
Source: https://github.com/rakibulism/agent-skills-os/tree/main/skills/tech-debt-auditor
Command: npx skills add https://github.com/rakibulism/agent-skills-os --skill tech-debt-auditor-rakibulism

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams turn a vague sense of "the codebase feels messy" into a prioritized refactoring backlog based on real risk, cost of delay, and effort.

Core Features & Use Cases

  • Debt Classification: Separates deliberate shortcuts, inadvertent drift, and bit rot so each issue is understood in context.
  • Risk-Based Prioritization: Focuses on high-change, security-sensitive, or bug-prone areas instead of superficial cleanup.
  • Backlog Planning: Sizes fixes and organizes them into quick wins, high-priority work, low-priority items, and things not worth fixing.
  • Use Case: Use it after a codebase review to decide which refactors should be scheduled now, which can wait, and which should be ignored.

Quick Start

Ask the skill to audit your codebase context and return a risk-ranked tech-debt backlog with quick wins, scheduled refactors, and items safe to defer.

Frequently Asked Questions about tech-debt-auditor

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

FAQPage Schema
How do I prioritize technical debt in my codebase?

You prioritize technical debt by classifying issues into deliberate, inadvertent, and bit rot categories, then evaluating them by risk, impact, and effort. This approach generates a risk-ranked refactoring backlog with clear cost-of-delay guidance for maintenance planning.

What is the best way to decide what to refactor now versus later?

The best way to decide what to refactor now versus later is to map each issue on an impact-versus-effort matrix and calculate the cost of delay. This separates quick wins and high-priority work from low-priority items and issues safe to ignore.

How do I classify technical debt types during a codebase audit?

You classify technical debt during a codebase audit by identifying the origin of each issue: deliberate shortcuts taken for speed, inadvertent drift from evolving standards, or bit rot from aging dependencies. This context dictates whether a fix should be scheduled or deferred.

Does this approach work for routine maintenance planning or only major refactoring?

This approach works for routine maintenance planning by focusing on high-change, security-sensitive, or bug-prone areas rather than superficial cleanup. It organizes refactoring into quick wins, high-priority work, low-priority items, and things not worth fixing.

When should I avoid scheduling refactors for technical debt?

You should avoid scheduling refactors when the technical debt exists in low-change, isolated areas where the cost of delay and impact is minimal. The backlog planning process categorizes these as low-priority items or things not worth fixing.