Skip to main content
skill CX Codex

absolute-debt — Claude Code skill: what it does, how to install

absolute-debt — a skill for Claude Code resolves accumulated lint and typecheck violations across your codebase. Execution proceeds in controlled waves on a passing main branch.

MIT 162 installs ★ 224 updated 2026-10-26

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add dhruvjainin/absolute --skill absolute-debt -a claude-code
Open on GitHub

What absolute-debt does

The skill audits legacy linter warnings, type-checker failures, and inline suppression comments such as @ts-ignore or # type: ignore. Fixes apply one rule across the entire repository per wave, keeping review diffs bisectable. It covers JS/TS via eslint and tsc, Python via ruff, flake8, mypy, and pyright, plus Go via golangci-lint and staticcheck.

Triage groups work into four sequential risk waves, starting with mechanical autofixes and concluding with suppression removals. A full test, lint, and build suite executes after every wave. Suppressing violations with casts to any or extra ignore tags is explicitly barred by the engine.

The skill requires a green baseline on main before starting. For diff-level improvements on in-progress feature code, the companion tool is absolute-simplify.

What it helps with

  • burn down accumulated repo-wide lint warnings and errors
  • remove legacy @ts-ignore and # type: ignore comments safely
  • prepare the project for strict compiler checks
  • eliminate root causes of type errors without resorting to any casts

Example prompts for the agent

  • Clear our pre-existing lint warnings across the repo
  • Burn down the remaining @ts-ignore suppressions rule by rule
  • Fix standing type errors and get the project to strict mode

How to install absolute-debt

1Skills CLI (Vercel)

npx skills add dhruvjainin/absolute --skill absolute-debt -a claude-code

2Manually: put the files in place

~/.claude/skills/absolute-debt/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/absolute-debt/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about absolute-debt

How to install absolute-debt in Claude Code?

Run npx skills add dhruvjainin/absolute --skill absolute-debt -a claude-code in your terminal.

What does absolute-debt do?

It scans the entire codebase for lint and type debt, then cleans up violations and suppressions rule by rule across staged passes.

How does absolute-debt differ from absolute-simplify?

The simplify tool improves code in your active working diff, whereas debt systematically clears pre-existing codebase violations on main.

Source text

SKILL.md · MIT
---
name: absolute-debt
version: 0.5.0
description: >
  Lint and typecheck debt paydown: clear pre-existing repo-wide lint/type violations and suppressions (@ts-ignore, # type: ignore) one rule per wave, fixing causes not symptoms. Runs on green main. For diff-scoped quality use absolute-simplify.
  Triggers on "absolute debt", "fix our lint warnings", "clear the type errors", "get to strict mode", "burn down suppressions".
category: workflow
tags:
  - workflow
  - maintenance
  - linting
  - typescript
  - debt
platforms:
  - claude-code
  - gemini-cli
  - openai-codex
  - mcp
user-invocable: true
argument-hint: "[target]"
license: MIT
maintainers:
  - github: maddhruv
---

> Start your first response with the 🧾 emoji.

## Absolute Debt

Pay down accumulated lint and type-checker debt across the repo — existing warnings,
errors, and suppressions that built up over time — in safe waves, by rule, with tests green
after each. The goal is a genuinely clean `lint` + `typecheck`, not a quieter one.

Runs the shared engine in **`references/health-engine.md`** — read it for the
DETECT → SCAN → TRIAGE → FIX → VERIFY → REPORT loop and the safety contract. This file
covers only what's specific to lint/type debt.

---

## When to use

- "Fix our lint warnings", "clean up the type errors", "get the codebase to strict mode".
- Tightening config (enable a rule, raise `tsconfig` strictness) and clearing the fallout.
- Burning down accumulated `eslint-disable` / `@ts-ignore` / `# type: ignore` suppressions.

**`debt` vs `simplify`:** `simplify` improves *your working diff's* quality. `debt` clears
**pre-existing repo-wide** lint/type violations on green `main`. Use `debt` for standing
cleanup, not for changes you're actively making.

---

## What it scans

| Ecosystem | Lint debt | Type debt |
|---|---|---|
| JS/TS | `eslint .` (full report, by rule) | `tsc --noEmit` |
| Python | `ruff check` / `flake8` | `mypy` / `pyright` |
| Go | `golangci-lint run` | `go vet ./...`, `staticcheck` |

Also inventory **suppressions** as debt in their own right: `eslint-disable*`,
`@ts-ignore`/`@ts-expect-error`, `# type: ignore`, `# noqa`, `//nolint`. Each is a hidden
violation. Count violations grouped **by rule** (not by file) — that's how you wave them.

---

## Risk ranking (TRIAGE)

| Wave | Class | Default |
|---|---|---|
| 1 | autofixable lint (`eslint --fix`, `ruff --fix`, `gofmt`) | fix now — mechanical, safe |
| 2 | manual lint by rule, low behavioral risk (unused, style, imports) | fix this pass, one rule at a time |
| 3 | type errors, and lint rules that can change behavior if "fixed" wrong | gated — review each, may need real logic |
| 4 | removing suppressions (`@ts-ignore` etc.) | gated — each may surface a real bug |

Fix **one rule across the repo per wave**, not one file across all rules — keeps diffs
reviewable and regressions bisectable. Config tightening (enable rule / raise strictness) is
itself a finding: propose it, then clear what it surfaces.

---

## Fix & verify

- Run the autofixers first (wave 1), commit-ready, then re-scan to see what's truly manual.
- Manual fixes: address the *cause*, not the symptom. A type error means the types are
  wrong somewhere — fix the type, don't cast to `any`/add `# type: ignore`.
- **Never** clear a violation by suppressing it. Removing suppressions is the *goal*, not a tool.
- After each wave: full test + lint + typecheck + build. The violation count must drop and
  nothing regress.

---

## Gotchas

1. **Fixing by suppressing.** `@ts-ignore` to clear a type error *adds* debt. Forbidden here.
2. **`any` / `cast` to win.** Silences the checker, keeps the bug. Fix the real type.
3. **One-file-all-rules waves.** Mixes concerns, unreviewable. Go one-rule-all-files.
4. **Autofix without review.** `--fix` can change behavior (e.g. `prefer-const` on a
   reassigned var via a bug). Run tests after autofix too.
5. **Disabling the rule instead of fixing.** Loosening config to hit zero is debt laundering,
   not paydown.

---

## Companion commands

- **`/absolute simplify`** — quality of code you're *currently changing*.
- **`/absolute prune`** — many unused-var/import warnings vanish once dead code is pruned.
- **`/absolute work`** — if clearing the debt needs real refactoring, hand off.

© dhruvjainin · MIT · dhruvjainin/absolute

Similar skills

All skills for Code review and refactoring →

From the same set11

The whole set →
absolute-simplify absolute-simplify — a skill for Claude Code and Cursor that simplifies code, flattens nesting, and removes dead code. Runs autonomously on git changes or target paths. CX Codex +1 336installs absolute-work absolute-work — a skill for Claude Code and Codex that enforces a phased SDLC from design interview to verified code. It triggers on requests to build features end-to-end, plan tasks, or run migrations. CX Codex +1 216installs absolute-spec The absolute-spec Claude Code skill turns a feature request into a reviewed design document after scanning the codebase. It asks a short set of clarifying questions, writes the spec, then stops before implementation. CX Codex +1 176installs absolute-docs absolute-docs is a Claude Code skill that structures technical documentation with Diátaxis. It creates and reviews tutorials, how-to guides, reference pages, and architectural explanations from code. CX Codex +1 171installs absolute-prune absolute-prune — a cleanup skill for Claude Code that sweeps repositories for dead code and unreferenced dependencies. Runs on green main branches using static analyzer evidence. CX Codex +1 170installs absolute-deflake The absolute-deflake Claude Code skill finds tests with inconsistent results and targets the cause of each failure. It activates on requests about flaky CI or tests that fail intermittently. CX Codex +1 165installs absolute-init absolute-init — a skill for Claude Code configures absolute around a repository’s conventions and user preferences. It starts when asked to initialize or configure absolute, including during first-time setup. CX Codex +1 160installs absolute-upgrade The absolute-upgrade Claude Code skill updates outdated and vulnerable dependencies in risk-based groups. It runs on a green main branch or in response to a request to update packages. CX Codex +1 155installs

Project sponsors

Companies that keep this analytics open