option

Analysez les bases de code pour détecter la dette technique, évaluez la gravité, suivez les tendances et générez des plans de correction priorisés.

...Développer tout
26
Heure mise à jour 29 août 2026

Suivi de la dette technique

Niveau : PUISSANT 🔥
Catégorie : Automatisation des processus d'ingénierie
Expertise : Qualité du code, Gestion de la dette technique, Ingénierie logicielle

Aperçu

La dette technique est l'un des défis les plus insidieux du développement logiciel : elle s'accumule avec le temps, ralentit la vitesse de développement, augmente les coûts de maintenance et réduit la qualité du code. Cette compétence offre un cadre complet pour identifier, analyser, prioriser et suivre la dette technique au sein des bases de code.

La dette technique ne se limite pas au code désordonné ; elle englobe les raccourcis architecturaux, les tests manquants, les dépendances obsolètes, les lacunes en matière de documentation et les compromis en matière d'infrastructure. Comme la dette financière, elle génère des « intérêts » sous forme de temps de développement accru, d'un taux de bogues plus élevé et d'une réduction de la vitesse d'exécution des équipes.

Ce que cette compétence offre

Cette compétence propose trois outils interconnectés qui forment un système complet de gestion de la dette technique :

  1. Analyseur de dette - Identifie automatiquement les signaux de dette technique dans votre base de code
  2. Priorisateur de dette - Analyse et priorise les éléments de dette en utilisant des cadres de coût du retard
  3. Tableau de bord de dette - Suit les tendances de la dette au fil du temps et fournit des rapports exécutifs

Ensemble, ces outils permettent aux équipes d'ingénierie de prendre des décisions fondées sur les données concernant la dette technique, en équilibrant le développement de nouvelles fonctionnalités avec les travaux de maintenance.

Démarrage rapide — analyser → prioriser → tableau de bord

Tous les chemins sont relatifs à ce dossier de compétence. La sortie JSON de l'analyseur alimente directement le priorisateur ; des instantanés d'inventaire datés alimentent le tableau de bord.

1. Analyser la base de code

python3 scripts/debt_scanner.py /path/to/codebase --format json --output debt_inventory.json

Génère debt_inventory.json avec scan_metadata, summary, debt_items[], file_statistics et recommendations. Indiquez les comptes du summary à l'utilisateur. (Exécution à blanc : assets/sample_codebase.)

2. Prioriser le backlog

python3 scripts/debt_prioritizer.py debt_inventory.json --framework wsjf --team-size 6 --sprint-capacity 20 --format json --output debt_priorities.json

Cadres : cost_of_delay (par défaut), wsjf, rice. La sortie contient prioritized_backlog (travail de haut en bas), sprint_allocation (à coller dans la planification des sprints) et insights.

3. Suivre les tendances au fil du temps

Conservez des instantanés datés (debt_YYYY-MM-DD.json), puis :

python3 scripts/debt_dashboard.py --input-dir snapshots/ --period monthly --format both --output debt_dashboard

Ou passez les fichiers explicitement (échantillons : assets/historical_debt_2024-01-15.json assets/historical_debt_2024-02-01.json). Le tableau de bord indique la direction des tendances et des résumés prêts pour les dirigeants — utilisez-le pour vérifier qu'un sprint de nettoyage a effectivement réduit la dette.

Boucle de vérification

Après un sprint de correction : relancez l'étape 1, relancez l'étape 3 avec le nouvel instantané, et vérifiez que les comptes des catégories ciblées ont diminué. Un nettoyage qui ne fait pas bouger le tableau de bord est une refonte, pas un remboursement de dette.

Cadre de classification de la dette technique

→ Voir references/debt-frameworks.md pour les détails (également : references/debt-classification-taxonomy.md, references/prioritization-framework.md, references/stakeholder-communication-templates.md)

Pièges courants et comment les éviter

1. Paralysie par l'analyse

Problème : Passer trop de temps à analyser la dette au lieu de la corriger. Solution : Fixer des limites de temps pour l'analyse, utiliser une notation « suffisante » pour la plupart des éléments.

2. Perfectionnisme

Problème : Tenter d'éliminer toute la dette au lieu de la gérer. Solution : Se concentrer sur la dette à fort impact, accepter qu'une certaine dette soit acceptable.

3. Ignorer le contexte commercial

Problème : Privilégier l'élégance technique à la valeur commerciale. Solution : Toujours relier le travail sur la dette aux résultats commerciaux et à l'impact client.

4. Application incohérente

Problème : Certaines équipes adoptent des pratiques tandis que d'autres les ignorent. Solution : Intégrer le suivi de la dette dans le flux de travail standard de développement.

5. Sur-ingénierie des outils

Problème : Construire des systèmes de gestion de la dette complexes que personne n'utilise. Solution : Commencer simplement, itérer en fonction des modèles d'utilisation réels.

La gestion de la dette technique ne consiste pas seulement à écrire un meilleur code ; il s'agit de créer des pratiques de développement durables qui équilibrent la pression de livraison à court terme avec la santé à long terme du système. Utilisez ces outils et cadres pour prendre des décisions éclairées sur quand et comment investir dans la réduction de la dette.

Voir sur GitHub
---
name: tech-debt-tracker
description: Scan codebases for technical debt, score severity, track trends, and generate prioritized remediation plans.
---

# Tech Debt Tracker

**Tier**: POWERFUL 🔥  
**Category**: Engineering Process Automation  
**Expertise**: Code Quality, Technical Debt Management, Software Engineering

## Overview

Tech debt is one of the most insidious challenges in software development - it compounds over time, slowing down development velocity, increasing maintenance costs, and reducing code quality. This skill provides a comprehensive framework for identifying, analyzing, prioritizing, and tracking technical debt across codebases.

Tech debt isn't just about messy code - it encompasses architectural shortcuts, missing tests, outdated dependencies, documentation gaps, and infrastructure compromises. Like financial debt, it accrues "interest" through increased development time, higher bug rates, and reduced team velocity.

## What This Skill Provides

This skill offers three interconnected tools that form a complete tech debt management system:

1. **Debt Scanner** - Automatically identifies tech debt signals in your codebase
2. **Debt Prioritizer** - Analyzes and prioritizes debt items using cost-of-delay frameworks
3. **Debt Dashboard** - Tracks debt trends over time and provides executive reporting

Together, these tools enable engineering teams to make data-driven decisions about tech debt, balancing new feature development with maintenance work.

## Quick Start — scan → prioritize → dashboard

All paths relative to this skill folder. The scanner's JSON output feeds the prioritizer directly; dated inventory snapshots feed the dashboard.

### 1. Scan the codebase

```bash
python3 scripts/debt_scanner.py /path/to/codebase --format json --output debt_inventory.json
```

Emits `debt_inventory.json` with `scan_metadata`, `summary`, `debt_items[]`, `file_statistics`, and `recommendations`. Report the `summary` counts to the user. (Dry run: `assets/sample_codebase`.)

### 2. Prioritize the backlog

```bash
python3 scripts/debt_prioritizer.py debt_inventory.json --framework wsjf --team-size 6 --sprint-capacity 20 --format json --output debt_priorities.json
```

Frameworks: `cost_of_delay` (default), `wsjf`, `rice`. Output contains `prioritized_backlog` (work top-down), `sprint_allocation` (paste into sprint planning), and `insights`.

### 3. Track trends over time

Keep dated snapshots (`debt_YYYY-MM-DD.json`), then:

```bash
python3 scripts/debt_dashboard.py --input-dir snapshots/ --period monthly --format both --output debt_dashboard
```

Or pass files explicitly (samples: `assets/historical_debt_2024-01-15.json assets/historical_debt_2024-02-01.json`). The dashboard reports trend direction and executive-ready summaries — use it to verify a cleanup sprint actually reduced debt.

### Verification loop

After a remediation sprint: re-run step 1, re-run step 3 with the new snapshot, and assert the targeted categories' counts dropped. A cleanup that doesn't move the dashboard is rework, not debt paydown.

## Technical Debt Classification Framework
→ See references/debt-frameworks.md for details (also: references/debt-classification-taxonomy.md, references/prioritization-framework.md, references/stakeholder-communication-templates.md)

## Common Pitfalls and How to Avoid Them

### 1. Analysis Paralysis
**Problem**: Spending too much time analyzing debt instead of fixing it.
**Solution**: Set time limits for analysis, use "good enough" scoring for most items.

### 2. Perfectionism
**Problem**: Trying to eliminate all debt instead of managing it.
**Solution**: Focus on high-impact debt, accept that some debt is acceptable.

### 3. Ignoring Business Context
**Problem**: Prioritizing technical elegance over business value.
**Solution**: Always tie debt work to business outcomes and customer impact.

### 4. Inconsistent Application
**Problem**: Some teams adopt practices while others ignore them.
**Solution**: Make debt tracking part of standard development workflow.

### 5. Tool Over-Engineering
**Problem**: Building complex debt management systems that nobody uses.
**Solution**: Start simple, iterate based on actual usage patterns.

Technical debt management is not just about writing better code - it's about creating sustainable development practices that balance short-term delivery pressure with long-term system health. Use these tools and frameworks to make informed decisions about when and how to invest in debt reduction.

Tous les fichiers

0 fichiers

Installer tech-debt-tracker

Téléchargez et extrayez les fichiers de compétences dans votre répertoire .claude/skills/.

Télécharger le ZIP

Clonez le dépôt et copiez les fichiers de compétence dans votre projet.

git clone https://github.com/alirezarezvani/claude-skills/tree/main/engineering/skills/tech-debt-tracker # Copy SKILL.md to your .claude/skills/ directory

Copier Copier
Configuration rapide: Copiez le dossier de la compétence dans .claude/skills/ Claude détectera et utilisera automatiquement la compétence

Compétences similaires

algorithmic-art
Heure mise à jour 27 août 2026
receiving-code-review
Heure mise à jour 3 septembre 2026
senior-backend
Heure mise à jour 30 août 2026
systematic-debugging
Heure mise à jour 3 septembre 2026
OR