subtractive-debugging

Isolate regression-introducing changes by subtracting from a known-good baseline.

Updated Apr 20, 2026
One-click install
npx skills add https://github.com/thistleknot/skills --skill subtractive-debugging
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: subtractive-debugging
Source: https://github.com/thistleknot/skills/tree/main/subtractive-debugging
Command: npx skills add https://github.com/thistleknot/skills --skill subtractive-debugging

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Subtractive debugging prevents regression hunts from turning into broad, noisy speculation by forcing you to identify the first cascaded mismatch between a known-good baseline and the current broken state.

Core Features & Use Cases

  • Known-good anchoring: Requires defining one stable control plus exact property targets so the mechanism can be validated while shrinking the suspect space.
  • Surface-specific checking: Narrows comparison to a single closure layer (loader, schema, import/display, runtime behavior, or artifact/render) to make differences actionable.
  • Signature-based comparison: Compares entity signatures (IDs and required-field sections) instead of raw file churn to reduce noise from wide diffs.
  • Interval subtraction then entity subtraction: Collapses the history interval first, then the changed-entity set, ensuring the introducing boundary is found with evidence.
  • Causality-style mismatch naming: Produces a single first cascaded mismatch claim, then patches only that isolated boundary and reruns the same checker.

Quick Start

Ask the agent to isolate the introducing change for your regression by anchoring a known-good control, defining the exact property, running a surface-specific checker across progressively tighter baselines, and then patching only the first cascaded mismatch it identifies for your specified surface.

Frequently Asked Questions about subtractive-debugging

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I isolate a regression when there is broad code and import churn across the commit history?

Regression isolation works by subtracting from a known-good baseline while preserving a stable control, comparing entity signatures at one closure layer to find the first cascaded mismatch. You first collapse the history interval, then shrink the changed-entity set to pinpoint the boundary.

What is subtractive debugging and how does it differ from standard git bisect?

Subtractive debugging isolates regressions by comparing entity signatures at a specific surface layer rather than raw file churn. Unlike standard git bisect, it collapses the history interval first, then subtracts the changed-entity set to name the first cascaded mismatch with deterministic evidence.

How do I set up a deterministic surface checker to find an introducing change for a regression?

To set up a deterministic surface checker, define a stable control, exact property targets, and known-good plus current bad baselines. The checker validates a narrow property at a single closure layer like loader, schema, import, runtime, or artifact render.

Can I use regression isolation for debugging schema or import display issues instead of runtime behavior?

Yes, regression isolation applies to any single closure layer including loader, schema, import display, runtime behavior, or artifact render. You narrow comparison to that specific surface to make differences actionable and reduce noise from wide diffs.

Why does subtractive debugging compare entity signatures instead of raw file diffs?

Subtractive debugging compares entity signatures, such as IDs and required-field sections, to reduce noise from wide diffs caused by broad code and import churn. This signature-based comparison ensures the introducing boundary is found with actionable evidence.

When should I avoid using subtractive debugging for regression hunting?

You should avoid subtractive debugging when you cannot define a narrow property to validate or lack a deterministic surface-specific checker. It requires a stable control and exact baselines, making it unsuitable for non-deterministic behaviors or broad speculation without clear targets.