Interrogation Debugging: Force Root-Cause Before Fixes

Where this fits

Your agent is debugging a failing test. It spots an obvious null pointer, adds a guard, and the test still fails because the real issue is an uninitialized service in the test setup. Interrogation-debugging prevents this loop by forcing agents to investigate and document the root cause before touching code. It fits any workflow where agents are expected to fix bugs but currently jump to patches too quickly.

Why agents benefit

• Reduces random trial-and-error: the agent must complete The Brief before proposing fixes.
• Stops symptom fixes: The Iron Law says no fixes without root-cause investigation first.
• Traces causal chains: interrogation produces reproducible steps, making agent reasoning auditable.
• Works under pressure: when the user says "just one quick fix", the skill overrides with a systematic process.
• Covers all technical issues: test failures, production bugs, performance problems, build failures, integration issues.

Practical scenarios

Flaky test in CI

The agent sees a timeout and wants to increase the wait time. Interrogation reveals the test fixture starts a server on the same port as a parallel test; the real fix is isolated port allocation.

Intermittent 500s in production

The agent might add retries. Interrogation of logs and connection metrics shows pool exhaustion; the fix is pool sizing and query optimization, not a retry wrapper.

Build breaks after a dependency bump

The agent may pin the old version. Interrogation identifies the upstream API change and required migration, so the fix updates the code instead of hiding the break.

Add it to your agent workflow

Install the skill:

npx skills add kucherenko/gangsta --skill interrogation-debugging

Then use it as a gate in your agent instructions:

Before proposing any fix, run the interrogation-debugging skill.
Complete The Brief and state the root cause. No fix is allowed
until the root cause is confirmed.

You can also inspect the skill details at https://www.openagentskill.com/skills/kucherenko-interrogation-debugging to see if it matches your debugging workflow.

Compare before adopting

Compare it with other debugging skills by checking whether they enforce process or just suggest patterns. Does the skill define a stopping condition before fixes? Is the repository maintained? Does the author respond to issues? Alternatives exist for stack-trace analysis or patch generation, but this skill is a workflow guard: it adds discipline rather than magic. Also consider fit: if your agent already has strong analysis tools, this skill still adds the missing gate between guessing and understanding.

Why it is worth tracking

With 81 stars and a focused README that defines behavior, interrogation-debugging has enough community signal to track. Its value is in promoting root-cause discipline, and that becomes more important as agents are given more autonomy over debugging. Re-evaluate when the repository updates or when your agents start fixing bugs frequently—this may be the skill that turns quick patches into lasting fixes.