Skip to content
Skills Library
Programming · Building & coding

deep-fix

/deep-fix

Investigate a bug or issue deeply with parallel subagents, implement the fix, and verify correctness — all in one flow. Use when the user says "deep fix", "investigate and fix", "root cause this", "debug this deeply", "fix this thoroughly", "trace and fix", "find and fix", or when a bug is complex enough to benefit from parallel investigation before fixing. Also trigger when the user appends "deep fix" or "investigate and fix" to a bug report.

Repository
PandaStack ↗
Licence
MIT
Last repository change
12.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 12.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Investigate a bug or issue deeply with parallel subagents, implement the fix, and verify correctness — all in one flow. Use when the user says "deep fix", "investigate and fix", "root cause this", "debug this deeply", "fix this thoroughly", "trace and fix", "find and fix", or when a bug is complex enough to benefit from parallel investigation before fixing. Also trigger when the user appends "deep fix" or "investigate and fix" to a bug report.

Triggers from the description

deep fixinvestigate and fixroot cause thisdebug this deeplyfix this thoroughlytrace and fixfind and fix
Original author description

Investigate a bug or issue deeply with parallel subagents, implement the fix, and verify correctness — all in one flow. Use when the user says "deep fix", "investigate and fix", "root cause this", "debug this deeply", "fix this thoroughly", "trace and fix", "find and fix", or when a bug is complex enough to benefit from parallel investigation before fixing. Also trigger when the user appends "deep fix" or "investigate and fix" to a bug report.

How it works

  1. Protocol
  2. Rules
Original SKILL.md headings · 159 lines, 993 words
SKILL.md preview
---
name: deep-fix
description: Investigate a bug or issue deeply with parallel subagents, implement the fix, and verify correctness — all in one flow. Use when the user says "deep fix", "investigate and fix", "root cause this", "debug this deeply", "fix this thoroughly", "trace and fix", "find and fix", or when a bug is complex enough to benefit from parallel investigation before fixing. Also trigger when the user appends "deep fix" or "investigate and fix" to a bug report.
version: 0.1.0
---

# Deep Fix — Investigate, Fix, Verify

You are operating in Deep Fix mode. This is a three-phase protocol that investigates a bug with parallel subagents, implements a targeted fix, and proves the fix is correct — all without hand-holding from the user.

## Protocol

### Phase 1: Investigate (Decompose + Parallel Research)

Before writing any fix:

1. **Reproduce or confirm the symptom** — Read the code, error message, failing test, or user report. State the observable symptom clearly.

2. **Map the blast radius** — Identify every file, function, and data path that could be involved. Trace the full execution path from trigger to symptom.

3. **Decompose into investigation tracks** — Each track is an independent line of inquiry. Typical tracks:

```
## Investigation Decomposition

1. **[Track Name]** — [What this track investigates]
   - Files: [specific files to examine]
   - Question: [the specific question this track answers]
2. **[Track Name]** — [What this track investigates]
   - Files: [specific files to examine]
   - Question: [the specific question this track answers]
```

Standard investigation tracks (select relevant ones, add custom tracks as needed):

- **Trigger Path** — What initiates the buggy behavior? Trace from entry point to first anomaly.
- **Data Flow** — Are the right values passed through every layer? Where does data get dropped, coerced, or mistyped?
- **State Management** — Is shared/global state being mutated unexpectedly? Race conditions? Stale reads?
- **Error Propagation** — Are errors caught, swallowed, or propagated incorrectly? Is a silent failure masking the root cause?
- **Regression Search** — When did this break? `git log` the affected files. Was there a recent change that introduced the bug?
- **Contract Violations** — Do callers and callees agree on types, nullability, error semantics, and return values?
- **Environmental/Config** — Is the behavior environment-dependent? Wrong defaults, missing env vars, config drift?

4. **Launch parallel subagents** — One per investigation track, all in a single message with `run_in_background: true`. Each subagent gets:
   - The specific track and question to answer
   - The exact files and functions to examine
   - Instructions to output findings in this format:

```
## [Track Name] Investigation

### Finding
- **Root cause identified:** YES / NO / PARTIAL
- **Location:** `file/path:line`
- **Evidence:** [Code snippet or trace that proves the finding]
- **Mechanism:** [How exactly the bug manifests — the causal chain]
- **Confidence:** HIGH / MEDIUM / LOW

### Related Observations
[Anything else noticed that may be relevant — other bugs, code smells, fragile patterns]
```

5. **Show the decomposition** to the user before launching subagents.

### Phase 2: Fix (Synthesize + Implement)

Once all investigation subagents return:

1. **Synthesize the root cause** — Review all tracks. Identify:
   - The **primary root cause** (the one thing that, if fixed, resolves the symptom)
   - Any **contributing factors** (things that made the bug possible or harder to detect)
   - **Conflicting findings** — If tracks disagree, investigate the disagreement before proceeding

2. **Present the diagnosis:**

```
## Diagnosis

### Root Cause
[One clear statement of what's wrong and why, with file:line]

### Mechanism
[Step-by-step causal chain from trigger to symptom]

### Contributing Factors
[Other issues that made the bug possible — optional]
```

3. **Design the minimal fix** — The fix should:
   - Address the root cause directly, not paper over symptoms
   - Touch the fewest files possible
   - Not introduce new abstractions unless truly necessary
   - Handle edge cases surfaced by the investigation

4. **Implement the fix** — Write the code changes.

5. **Add or update tests** — Every fix ships with a test that:
   - Fails before the fix (reproduces the bug)
   - Passes after the fix (proves the fix works)
   - Covers edge cases discovered during investigation

### Phase 3: Verify (Prove Correctness)

After implementing:

1. **Run the test suite** — All tests must pass, not just the new ones.

2. **Launch a verification subagent** with `run_in_background: true` to:
   - Re-read the changed files and verify the fix addresses the diagnosed root cause
   - Check for regressions — did the fix break any adjacent behavior?
   - Verify edge cases are handled
   - Check for new issues introduced by the fix (typos, missing imports, broken contracts)
   - Output a verification report:

```
## Verification Report

### Fix Correctness
- **Addresses root cause:** YES / NO
- **Edge cases handled:** [list]
- **Regressions detected:** NONE / [list]

### Code Quality
- **Minimal change:** YES / NO (if NO, explain what's unnecessary)
- **Test coverage:** [assessment]
- **New issues introduced:** NONE / [list]

### Verdict: SHIP / REVISE / BLOCK
```

3. **If REVISE or BLOCK** — Fix the issues found by verification and re-verify.

4. **Present the final summary:**

```
## Deep Fix Complete

### Symptom
[Original bug description]

### Root Cause
[One-line root cause with file:line]

### Fix
[What was changed and why — keep it brief]

### Tests
[What tests were added/modified]

### Verification
[SHIP — all checks passed]
```

## Rules

- **Never skip investigation.** Even if the fix seems obvious, investigate first. You'll often discover the obvious fix is wrong or incomplete.
- **Never fix symptoms.** If you can't explain the causal chain from root cause to symptom, you don't understand the bug yet. Go back to Phase 1.
- **Minimal fixes only.** No drive-by refactoring, no "while I'm here" improvements. The fix addresses the bug and nothing else.
- **Tests are mandatory.** A fix without a test is a regression waiting to happen. No exceptions.
- **Verify, don't assume.** Phase 3 exists because Phase 2 makes mistakes. Always verify.
- **Show your work.** The user should see the investigation decomposition, the diagnosis, the fix rationale, and the verification report. Transparency prevents wrong fixes from shipping.
- **Subagents investigate, you fix.** Phase 1 subagents are research-only. Phase 3 verification subagent is read-only. Only the main thread writes code.
- **If confidence is below 80%, say so.** Flag uncertainty rather than shipping a guess. It's better to ask the user than to ship a wrong fix.

Versions

The database has no other skills named deep-fix.

Database snapshot: 13.11.2026 · package version 16fed790f895 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100triage-issue
    Investigate a reported bug to root cause, then emit a TDD-shaped fix plan as an issue artifact. Trigger when the user reports a bug, says "triage", asks for issue investigation, or wants a fix plan before code changes.
  • 100fix-bug
    Use when given a GitHub issue URL or number to investigate and implement a fix. Triggers on "fix issue", "fix bug", "fix #123", GitHub issue URLs, or any request to resolve a reported problem from a GitHub issue. Also triggers when asked to investigate errors, diagnose failures,…
  • 100verify-and-fix
    This skill should be used when the user reports an error, bug, or unexpected behavior and wants it diagnosed and fixed. Trigger on phrases like "check this error", "check this bug", "here's an error", "here's a bug", "I have an error", "I have a bug", "found a bug", "got an…
  • 100deep-debug
    Debug sub-mode for Phase 3 — Investigate → Analyze → Hypothesize → Implement, with the iron rule that no fix ships before root-cause investigation. Triggers on `/deep-debug`, \"systematic debug\", \"root cause investigation\", \"디버그 모드\", \"근본 원인 분석\", `verification_cmd` 실패 시 자동 진입, or \"fix this\".
  • 90triage-issue
    Triage a bug or issue by exploring the codebase to find root cause, then create a GitHub issue with a TDD-based fix plan. Use when user reports a bug, wants to file an issue, mentions "triage", or wants to investigate and plan a fix for a problem.
  • 100fix-bug
    Fix a reported bug in React Router from a GitHub issue. Use when the user provides a GitHub issue URL and asks to fix a bug, investigate an issue, or reproduce a problem. Handles the full workflow: fetching the issue, finding the reproduction, writing a failing test, and implementing the fix.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.