Codebase: 
Team: 
Velocity: 

Assess and manage technical debt:

1. Identify debt (be specific)
   Categories of debt:
   - Architecture (monolith vs microservices trade-offs)
   - Dependencies (outdated libraries, security risks)
   - Testing (missing tests = fragility)
   - Code quality (duplicate code, unclear logic)
   - Documentation (knowledge silos)
   - Infrastructure (manual processes, reliability gaps)
   - Database (schema issues, scaling problems)
   
   For each debt:
   - When was it created? (MVP, 3 years ago, yesterday?)
   - Why does it exist? (deadline, wrong decision, evolution?)
   - What's the cost? (reduced velocity, bugs, frustration)
   - What's the payoff?

2. Impact scoring
   For each debt item:
   - Velocity impact (1-5): Slows down feature work?
   - Risk impact (1-5): Causes bugs or crashes?
   - Scaling impact (1-5): Blocks growth/performance?
   - Team impact (1-5): Frustrates engineers/causes churn?
   - Score = V + R + S + T
   
   Highest scores = address first

3. Payoff analysis
   For top 3 debt items:
   - Effort to fix (days/weeks/months)
   - Impact if you fix (% velocity gain?)
   - Risk of fixing (could break something?)
   - Payoff period (when does investment break even?)

4. Strategic choices
   Sometimes you KEEP debt because:
   - You'll rewrite this in 6 months anyway
   - Customer need is more important
   - Team is fine with it
   - Not on critical path
   
   Be intentional about the trade-off

5. Prevention going forward
   - What caused this debt?
   - How do you prevent similar debt?
   - Definition of "done" (must include X?)
   - Code review process (catch debt early?)
   - Sprint time for debt payoff (10-20% of velocity)

6. Sequencing payoff
   Quarter 1: Fix highest-risk debt (system stability)
   Quarter 2: Fix highest-velocity-impact (speed up development)
   Quarter 3: Fix highest-frustration (team morale)
   
   Don't do all at once.

7. Measurement
   Before payoff:
   - How fast do features ship? (days per feature)
   - How many bugs? (defect rate)
   - How often do you touch this code? (pain frequency)
   
   After payoff:
   - Velocity should improve by X%
   - Defect rate should drop by Y%
   - Team should feel faster

8. The honest conversation
   - Is your team burned out? (debt accumulated faster than paid)
   - Did you over-engineer? (unnecessary complexity)
   - Did you under-invest in foundation? (scaling issues)
   - Is the market moving faster than your code? (need rewrite)
   
   Answer truthfully shapes your strategy

Examples

Input

{
  "codebaseDescription": "3-year-old Node.js monolith, 250k LOC, minimal tests (15% coverage), outdated dependencies, database scaling issues",
  "teamSize": "5 backend engineers, 2 frontend",
  "currentVelocity": "3-4 features per 2-week sprint"
}

Output

Complete debt inventory with categories, impact scoring, payoff analysis for top 3 items, strategic choices, prevention plan, sequencing roadmap, and measurement framework.

Sources

https://martinfowler.com/bliki/TechnicalDebt.html

Ready to explore more prompts?

Discover our complete library of research-backed prompts with proven results. From multi-expert panels to tree-of-thought reasoning.

Browse All Prompts Learn Prompt Engineering