Technical Debt Management

Quantify and prioritize technical debt using the SQALE methodology.

21|2|Updated Oct 8, 2025
One-click install
npx skills add https://github.com/yaleh/meta-cc --skill technical-debt-management
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Technical Debt Management
Source: https://github.com/yaleh/meta-cc/tree/main/.claude/skills/technical-debt-management
Command: npx skills add https://github.com/yaleh/meta-cc --skill technical-debt-management

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill quantifies technical debt objectively using the SQALE methodology, maps code smells to actionable debt items, and guides prioritized paydown with a value-effort framework. It enables teams to track debt trends over time, plan refactors, and prevent debt growth.

Core Features & Use Cases

  • SQALE-based measurement: Objective debt indices with TD ratio and rating
  • Code smell taxonomy: Bloaters, Change Preventers, Dispensables, Couplers, OO Abusers
  • Prioritization: Value-effort matrix to separate quick wins from strategic work
  • Paydown roadmap: Phased plan to fix high-impact items
  • Trend tracking & prevention: Ongoing visibility and preventative practices

Quick Start

  1. Compute SQALE Index using LOC and effort estimates.
  2. Categorize debt by smell taxonomy and assign remediation costs.
  3. Prioritize fixes with value-effort matrix, then build a paydown roadmap and start the first sprint.

Frequently Asked Questions about Technical Debt Management

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

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

Quantify technical debt using the SQALE methodology, which computes an objective debt index from lines of code and remediation effort estimates. SQALE produces a TD ratio and rating across Go, Python, JavaScript, Java, and Rust codebases, replacing subjective assessments with measurable debt metrics.

What are code smells and how do I categorize them?

Code smells are patterns indicating refactoring opportunities, grouped into five categories: Bloaters (oversized code), Change Preventers (hard-to-modify code), Dispensables (unnecessary code), Couplers (tight dependencies), and OO Abusers (misused object-oriented design). Mapping smells to these categories enables systematic prioritization.

How do I prioritize which technical debt to fix first?

Prioritize technical debt using a value-effort matrix that maps remediation impact against implementation cost. This separates quick wins from strategic work, enabling phased paydown roadmaps that focus on high-impact items first while managing team capacity.

Can I track technical debt trends over time?

Yes. SQALE methodology enables ongoing trend tracking by computing debt indices periodically, revealing whether debt is growing or shrinking. Combined with preventative practices, this visibility supports long-term refactoring strategies and prevents debt accumulation.

Does this approach work across multiple programming languages?

Yes. SQALE-based measurement applies to Go, Python, JavaScript, Java, and Rust. The code-smell taxonomy and value-effort prioritization framework are language-agnostic, enabling consistent debt quantification across polyglot codebases.

What input do I need to compute a SQALE debt index?

Gather lines of code (LOC) metrics and remediation effort estimates for identified code smells. These inputs feed SQALE index computation, which produces an objective debt rating and supports categorization and prioritization for your paydown roadmap.