skills.rest
hohai99
hohai99COMMUNITY
Explore all skills by this author →
WebsiteGitHub

self-healing-debugger

Fix implementation bugs flagged by failing tests and re-run tests.

1|Updated Jan 22, 2026
Search Tags:#automation#debugging#test-driven#self-healing#spec-compliance#code-fix
One-click install
npx skills add https://github.com/hohai99/antigravity-skills --skill self-healing-debugger
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: self-healing-debugger
Source: https://github.com/hohai99/antigravity-skills/tree/main/.agent/skills/self-healing-debugger
Command: npx skills add https://github.com/hohai99/antigravity-skills --skill self-healing-debugger

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill autonomously fixes implementation bugs detected by tests while preserving spec intent. It only applies fixes that align with the spec, never changing behavior to make tests pass.

Core Features & Use Cases

  • Minimal, targeted fixes: changes are the smallest possible edits to restore spec alignment.
  • Spec-aligned fixes: each fix references the relevant spec ID and stays within the task boundary.
  • Safe, test-driven repair: after applying a fix, tests are re-run to ensure no regressions and documentation is updated.

Quick Start

Trigger this skill after a test failure is classified as an implementation bug by the autonomous test runner and apply the minimal fix required to restore spec conformance.

Frequently Asked Questions about self-healing-debugger

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

FAQPage Schema
How do I automatically fix implementation bugs detected by failing tests?▼

To automatically fix implementation bugs detected by failing tests, you can use a self-healing debugger that applies minimal, spec-aligned code changes to resolve the failure without breaking intended behavior.

What is self-healing debugging in test-driven development?▼

Self-healing debugging in test-driven development is an automated process where implementation bugs flagged by failing tests are fixed autonomously, ensuring minimal edits that restore spec compliance and re-running tests to confirm no regressions.

How do I ensure automated code fixes do not break my original specifications?▼

To ensure automated code fixes do not break original specifications, the self-healing debugger enforces spec-aligned changes by referencing the relevant spec ID and applying only the smallest possible edits required to restore spec conformance.

When should I use an autonomous test runner for code repair?▼

You should use an autonomous test runner for code repair when you need to classify test failures as implementation bugs, triggering an automated debugger to apply targeted fixes and update documentation after verifying no regressions.

Can I apply targeted fixes to failing tests without changing intended behavior?▼

Yes, you can apply targeted fixes to failing tests without changing intended behavior by enforcing minimal, spec-aligned code edits that stay within the task boundary and verifying the results by re-running the tests.

What are the limitations of autonomous bug fixing in software engineering?▼

A limitation of autonomous bug fixing is that it only applies to failures classified as implementation bugs by an autonomous test runner, meaning it cannot resolve design flaws or spec ambiguities outside of the defined task boundary.

Related Skills

Explore More Software Engineering Skills→
Luis-ERPLuis-ERP

bug-phase-classification

Classify bugs by detected and injected phases in bug logs.

Community
Basic
skwuwuskwuwu

gvm_audit

Verify GVM audit log integrity and export compliance reports.

Community
Intermediate
Destynova2Destynova2
5

cli-audit-tangle

Analyze codebases for god functions, circular dependencies, dead code, and module boundaries.

Community
Advanced
miles990miles990

subagent-driven-development

Dispatch fresh subagents to execute multi-step implementation plans with two-stage reviews.

Community
Advanced