Tools · Software engineering
Tech Debt Register
Describe a system — get a rated, prioritized tech-debt register.
How it works
Corpus-grounded (software-engineering cluster). Surfaces the real debt rated by impact / effort / risk-if-ignored / priority, the quick wins (low-effort/high-impact), and a payoff sequence — distinguishing debt from missing features.
You bring
{ context, cluster? }
You get
{ context_summary, items[]{item, impact, effort, risk_if_ignored, priority}, quick_wins[], sequencing[], riskiest_assumptions[], grounded_in, provenance }
Use it for
- →SWE-guide reader: make tech debt visible + ranked instead of vibes
- →Find the low-effort/high-impact quick wins
- →Get a payoff order that unblocks the highest-leverage work
See it work
example outputContext: a 5-year-old Rails monolith for a B2B invoicing SaaS — slow CI, a 'God' Invoice model, no staging parity, and flaky payment-webhook handling.
Tech Debt Register — B2B invoicing SaaS (Rails monolith)
Context: A 5-year-old Rails monolith; team of 8; pain points are slow CI, a sprawling Invoice model, drift between staging and production, and intermittently failing payment webhooks.
Register
| Item | Impact | Effort | Priority | Risk if ignored |
|---|---|---|---|---|
| Flaky payment-webhook handling (no idempotency/retry) | high | low | high | Silent missed payments → revenue leakage + reconciliation pain |
| 12-minute CI suite (serial, no parallelism) | high | low | high | Slows every merge; encourages skipping tests |
'God' Invoice model (~2k lines, mixed concerns) | high | high | medium | Every change is risky; onboarding is slow; bugs cluster here |
| Staging ≠ production (config + data drift) | medium | medium | medium | Bugs reach prod that staging can't catch |
| No structured logging / request tracing | medium | low | medium | Incidents take hours to diagnose |
| Pinned EOL Ruby version | medium | high | low | Security exposure; blocks gem upgrades |
Quick wins (low effort / high impact)
- Add idempotency keys + retry/backoff to webhook handling — directly protects revenue.
- Parallelize CI (split + parallel runners) — cuts the suite to ~4 min, compounding across every PR.
- Introduce structured logging — cheap, immediately speeds incident triage.
Sequencing (payoff order)
- Webhook idempotency — stops active revenue leakage now.
- CI parallelization — unblocks team velocity, making everything after it cheaper.
- Structured logging + staging parity — make change safe to observe and rehearse.
- Decompose
Invoicemodel behind the now-fast tests — the big rock, done last because the prior steps de-risk it. - Ruby upgrade — schedule once the model is untangled.
Distinguishing debt from missing features
'Multi-currency support' surfaced in intake but is a product gap, not debt — excluded from this register.
Riskiest assumptions
- That the webhook flakiness is idempotency-related, not an upstream provider issue — confirm with logs before investing.
- That CI is parallelizable without a deeper test-isolation problem.
Grounded in: software-engineering cluster · constructs: technical-debt quadrant, impact/effort prioritization, strangler-fig decomposition · sources: Working Effectively with Legacy Code (Feathers), Accelerate (Forsgren et al.).
Run it now
Build a tech-debt register
Surface the technical debt in a system, rated by impact / effort / risk-if-ignored / priority, with the quick wins and a sensible payoff order.
Prefer code? Call it over the API or hand it to your AI agent via MCP — POST /api/bicycle/tech-debt-register · build_tech_debt_register. API & agent access →