Heal Suite

Agent-assisted development changed which failures are expensive. Producing code is cheap now; knowing whether a change fits the system it landed in is not. On a greenfield project the conventions live in one person’s head. On a codebase with ten years of history, which is what most contract work actually is, they are spread across a README nobody updated, a lint config, a CI file and decisions made by people who have left. That is the gap an agent cannot see and a reviewer cannot hold in their head all at once.

So the suite does the thing an LLM is genuinely good at on an old codebase, which is not writing more of it: read what the repository already committed to, then report where the code has drifted from it, axis by axis, with the evidence attached. Everything else on this page exists so that report can be trusted enough to act on.

The suite is 26 slash commands (the 18 audit axes plus the loop and setup commands) on top of a deterministic engine, and the prompts are treated exactly like production code: contract-bound, CI-checked, versioned and self-documenting.

Most AI tooling stops at detection. The suite’s economic thesis: recurring finding classes get promoted into free deterministic gates (rules, hooks, check scripts), so the expensive LLM budget is spent only on judgment the gates can’t express. Deliberately accepted findings live in a baseline instead of being re-fixed forever.

Two rules hold that together: detection never mutates, and mutation never audits. Healers in report mode are read-only, the apply step re-processes what they already found instead of paying to audit again, and anything touching a contract, a visual surface or the security posture stops for a human call.

What makes a sweep more than eighteen separate reports is the cross-axis read. An IDOR raised by the security healer, an ownership-scoping gap raised by architecture and a missing abuse-case test raised by tests are usually one root cause seen through three lenses, so the fused dashboard ranks them as a single cluster instead of three items competing for attention on a list.

One command runs the whole lap unattended: it plans a diff-scoped sweep, applies the mechanical half as at most three pull requests off the integration branch, and leaves the judgment calls queued in a report for the morning. It never merges, and it never guesses at a decision with nobody awake to ask.

Nothing here was designed on a whiteboard. Every mechanism this page describes exists because a real run on a real repository hit a real failure and the fix was encoded into the suite the same day, an arc the plugin publishes, milestone by milestone, as its origin history.

The suite also practices the disclosure it asks of others. It grew inside Macrop’s repository over six weeks of daily use (508 pull requests of suite work before it was extracted to its own plugin), and that history, as of the extraction in August 2026, records the authorship split precisely: 96% of the repository’s non-merge commits carry a Claude co-author trailer, and the remaining 4% are unrecorded: the history contains no commit anyone marked as hand-written. So the honest sentence here is not that parts were agent-assisted. Essentially all of the code was agent-written, and nothing in the record claims otherwise.

The same history holds the failure modes this page keeps naming, caught in the act, each one recorded in the origin history above, with the mechanism it earned. The record is also honest about its own limits: with 96% of commits co-authored, no per-line human/agent split can be reconstructed, and nothing measures what review missed. The claim is not that a human wrote the important parts; it is that a human owned every merge and every verdict, which is the same division of labor the suite enforces on the codebases it audits.

The suite is measured like a product. Every run is logged with provenance (suite version, frozen metrics version, the exact model and the audited commit), plus token cost and duration per healer. Metric formulas are frozen behind a version: change the math and the trend line segments instead of averaging incompatible definitions. Human verdicts on closed findings roll up into a precision figure with an honest denominator: unresolved and auto-closed findings are reported in their own buckets, and dogfood runs are segmented from external runs so the two never pool.

healers per sweep

18

findings, first two sweeps

61–72

burden, first two sweeps

67.6 → 44.6

tokens per sweep, 18 healers

73–183M

mean score across audit axes

90/100

The cost profile is understood, not guessed: roughly 90% of a sweep’s spend sits in the fanned-out healers, so routine scheduled sweeps run on Claude Sonnet (~$13–32 per sweep at API rates, tracking the token range above) while deep pre-release audits earn Claude Opus (~$22–56), a deliberate unit-economics call rather than a default.

The suite separates a project-free engine (run lifecycle, findings protocol, dashboard, orchestration) from project-specific knowledge. An installer command discovers a new codebase’s surfaces, regenerates the healers for it from a skeleton contract, then validates the result with the suite’s own gates.

It dogfoods on Macrop and ships in the durchnull plugin marketplace, alongside five smaller plugins.

The suite’s own metrics protocol forbids overclaiming, so: the runs behind these numbers are dogfood (the suite auditing the repositories that built it), which is not yet evidence of generality. Precision data is still accumulating run by run. And judgment-heavy fixes stay human-gated by design; the suite is built to make an engineer faster and honest, not to replace the review. It ships as a public beta for exactly that reason: the version number is deliberately 0.1.x, and a generality claim waits on runs against foreign repositories. That last limit is also the invitation: a codebase the suite has never seen is exactly the evidence it lacks, so the interesting question is what a sweep finds on yours.

The Heal Suite is an MIT-licensed Claude Code plugin, in public beta at github.com/durchnull/heal-suite. Three things there are worth reading before installing anything.

The plugin’s own page walks the roster, the loop and what a run leaves on disk, and it is held to the same rule as the healers: its counts, its badges and every command name on it are derived from the shipped skills and checked in CI, so it cannot go on describing a healer the suite no longer has. Beside it sits a sample dashboard, the same self-contained HTML every sweep writes. The workspace in it is invented; the durations and token figures are carried over from a real run, so the cost of a sweep reads honestly.

The third is the origin history: the six weeks inside the host repository, told as the twelve milestones that produced the mechanisms above, from two slash commands to the extraction. It ends the way the suite would want it to: the findings ledger survived the migration unbroken, and the plugin’s first sweep audited its own extraction commit.