Skill · v1.0

Self-Healing

Self-Healing is the posture that lets a build session keep moving when a routine error appears. Your AI reads the error, finds the root cause, applies the most direct fix and continues, surfacing only what truly needs your attention. The session stops stalling on the small stuff.

Install

Claude Code (CLI / WSL / Git Bash)

/plugin marketplace add https://www.infinitegameos.io/marketplace.json
/plugin install self-healing@igos-library

Claude Code (VS Code)

Install in VS Code

Opens the Claude Code plugins dialog with the marketplace and skill prefilled. Requires the Claude Code VS Code extension installed and signed in. Or paste the snippet below into .claude/settings.json for VS Code, JetBrains or any setup that prefers manual config.

{
  "extraKnownMarketplaces": {
    "igos-library": {
      "source": {
        "source": "url",
        "url": "https://www.infinitegameos.io/marketplace.json"
      }
    }
  },
  "enabledPlugins": {
    "self-healing@igos-library": true
  }
}

Direct markdown URL (Claude Code, Cursor, Codex CLI)

https://www.infinitegameos.io/markdown/skills/self-healing

This URL returns the narrative concept page. The plugin install path above delivers the operational SKILL.md instruction file.

Cursor (.mdc rules file)

curl -O https://www.infinitegameos.io/install/cursor/self-healing.mdc

Aider, Cline, any agent with --read

curl -O https://www.infinitegameos.io/markdown/skills/self-healing
aider --read self-healing.md

This skill ships in both homes, the Sovereign Ecosystem Foundation and this library.

Definition

Self-Healing governs how your AI handles errors throughout any implementation session. It is always active rather than invoked for a single task. When an error appears, the skill reads the full message, identifies the root cause (a missing dependency, a wrong path, a syntax slip, a permission issue), applies the most direct fix and continues the work. Recoverable mistakes resolve in place. Governance-class blocks, external API errors and structural file operations surface immediately rather than self-correct. One fix attempt, then escalation. The skill never loops silently on a fix that is not landing. It also ships inside the Sovereign Ecosystem Foundation, the starting workspace where these disciplines live together.

Read, diagnose, fix, continue

An error is information, not a stop sign. The skill reads the full message first. No guessing, no skipping ahead. It names the root cause, then applies the most direct fix and continues the task. A typo gets corrected inline. A wrong path gets righted. A missing directory gets created when the intent is clear. The work keeps its momentum.

Triage decides what self-corrects and what surfaces. Syntax errors, wrong paths and clearly intentional missing files resolve in place. A missing dependency proposes an install before running, because the install carries a cost. A failing test gets one diagnose-and-rerun. Permission blocks, governance gates, external API errors and structural file moves surface to you immediately. The same error twice means the fix is not working, so it surfaces rather than loops.

Use Cases

A long build that no longer stalls on typos

A multi-step implementation session hits a syntax slip in a config file. Without Self-Healing the session pauses and asks. With it, your AI reads the error, corrects the line and continues. The flow holds. You see the result, not the interruption.

A missing dependency handled with a cost gate

A script fails because a package is not installed. The skill identifies the cause precisely, then proposes the install before running it. Cost-bearing actions stay visible. Everything below that line keeps moving on its own.

A governance block that surfaces instead of bypassing

An operation trips an approval gate. Self-Healing does not attempt a workaround. It surfaces the block, names the cause and waits for your call. The boundary between recoverable error and protected action stays sharp.

FAQ

Does Self-Healing hide errors from me?

No. It hides nothing that matters. Recoverable mistakes resolve in place so the session keeps moving. Governance blocks, external API errors and structural file operations always surface. You see the decisions that need you and skip the ones that do not.

What stops it from looping on a bad fix?

A one-attempt rule. If the same error returns after one fix, the skill surfaces it rather than trying again. Silent loops are the failure mode this skill is built to avoid.

When would I activate it on purpose?

It is always active during implementation. Activate it explicitly only when you notice your AI stopping on routine errors that it could clearly recover from. A single line restores the posture.

Related

Self-Healing keeps a session moving. Systematic Debugging is the deeper discipline for when an error resists the quick fix. Both ship inside the Sovereign Ecosystem Foundation, the starting workspace you can adopt and make your own. The full life-design frame behind clean, recoverable systems is the Sovereign Life Playbook.

See the Sovereign Life Playbook