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.