Skip to main content
skill CX Codex

fix · buiducnhat — Claude Code skill for debugging and installation

This skill investigates a reproducible bug, applies a focused correction, and checks the outcome. It hands off work when the cause or risk exceeds a small fix.

MIT 280 installs ★ 48 updated 2026-07-06

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add buiducnhat/cobrew --skill fix -a claude-code
Open on GitHub

What fix does

The skill starts by clarifying the expected and actual behavior, reproduction steps, and available evidence such as logs or failed tests. It then reproduces the issue, traces the relevant code or data flow to a root cause, and makes a targeted change. An optional bug-report template helps gather missing details.

Checks proceed from the changed behavior to nearby regressions and relevant project checks. The task is complete only when the reported failure no longer reproduces and the expected result is confirmed. If investigation cannot establish a cause, or the fix crosses subsystems, requires migration, or carries broader risk, the skill stops implementation and directs the agent to brainstorm or write-plan.

For Claude Code, install it with npx skills add buiducnhat/cobrew --skill fix -a claude-code; the skill file goes at ~/.claude/skills/fix/SKILL.md. This workflow is deliberately limited to contained changes, so architectural work needs a planning step instead.

What it helps with

  • trace a reproducible failure from logs to its root cause
  • patch a test regression and verify the changed behavior
  • compare observed behavior with the expected result
  • halt a local fix when the work spans multiple subsystems

Example prompts for the agent

  • Investigate this login failure: submitting the form raises an exception. Reproduce it from these steps and logs, then verify a focused fix.
  • Find the cause of this failing regression test, make the smallest correction, and run nearby checks.
  • Assess whether this bug is contained; if the fix crosses subsystems, stop and recommend a planning step.

How to install fix

1Skills CLI (Vercel)

npx skills add buiducnhat/cobrew --skill fix -a claude-code

2Manually: put the files in place

~/.claude/skills/fix/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/fix/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about fix

How do I install fix in Claude Code?

Run npx skills add buiducnhat/cobrew --skill fix -a claude-code. The skill file is placed at ~/.claude/skills/fix/SKILL.md.

What does the fix skill do?

It reproduces a concrete bug, traces its root cause, makes a targeted change, and verifies the result. Work that grows beyond a contained fix is handed off for planning.

When does fix escalate to brainstorm or write-plan?

It escalates when the root cause remains unclear, changes span subsystems, or the work calls for a migration or broad refactor. Broad regressions during verification also trigger a handoff.

Source text

SKILL.md · MIT
---
name: fix
description: Diagnose and fix bugs with root-cause analysis and verification. Use when you have a concrete issue report, failing behavior, runtime error, or test regression that should be resolved safely. Stop and escalate to brainstorm when scope or risk grows.
argument-hint: "[bug report or issue description]"
license: MIT
---

# Fix

## Scope Gate (Required Before Starting)

Use this skill only when all conditions below are true:

1. **Concrete issue signal exists**
   - Clear failing behavior, error, or regression is identified
   - Enough evidence exists to begin diagnosis (logs, stack trace, failing test, or reproducible steps)

2. **Likely localized fix path**
   - Issue appears constrained to a small area
   - No expected cross-system redesign or migration

3. **Low-to-moderate architectural risk**
   - Fix can be made without foundational changes
   - No phased rollout/feature-flag strategy is expected

4. **Straightforward verification path**
   - Reproduction and post-fix checks can be run in practical scope
   - Success criteria can be validated directly

If any condition fails, escalate to `brainstorm` or `write-plan`.

## Hard Stop Escalation Criteria

Immediately stop and switch to planning if any of these occur:

- Root cause remains unclear after focused investigation
- Fix requires cross-cutting architectural or data-model changes
- Scope expands into large refactor or multi-module migration
- Security/compliance-sensitive behavior is involved
- Verification reveals broad regressions requiring phased mitigation
- Multiple fix attempts fail without converging on a root cause

Escalation action:

1. Stop all implementation activities.
2. Output the exact message: "This fix exceeds safe single-pass debugging limits. Ask, Recommend `brainstorm` or `write-plan` first to define phased diagnosis, implementation, and risk controls."

## Workflow

### Step 1: Intake and Contextualize

1. Understand the reported bug and define explicit expected behavior.
2. Collect/confirm minimum bug report fields:
   - Title
   - Expected behavior
   - Actual behavior
   - Reproduction steps
   - Evidence (logs, trace, screenshot, failing test output)
   - Environment (branch/OS/runtime/version if relevant)
   - Impact/severity
3. Load only the project context relevant to the bug:
   - If `docs/SUMMARY.md` exists, read it first.
   - Load only task-relevant detail docs.
   - Prioritize `Code Standard` docs for implementation conventions.
   - If docs conflict with code or user intent, use the available input/question tool before broad changes.

### Step 2: Reproduce and Diagnose

1. Reproduce the issue consistently.
2. Locate the failure point (file/function/line range/subsystem).
3. Trace control/data flow to identify the **root cause**.
4. Form a fix hypothesis and confirm it explains observed behavior.

Guidelines:

- Read surrounding code, not only the failing line.
- Prefer root-cause correction over symptom patching.
- Add temporary diagnostics only when needed; remove them after use.

### Step 3: Decide Small vs Bigger Fix

Classify the work before coding:

#### Small fix (continue in this skill)

Most are true:

- Root cause is clear and validated
- Change surface is narrow (typically a few files)
- Regression risk is limited and testable quickly

#### Bigger/risky fix (escalate to `brainstorm` or `write-plan`)

Any are true:

- Root cause is uncertain
- Multiple subsystems must change together
- Requires migration, rollout sequencing, or broad refactor
- Risk cannot be reasonably controlled in a single pass

If it is a bigger fix, follow **Hard Stop Escalation Criteria**.

### Step 4: Implement (Small Fix Path)

1. State a brief 1-3 bullet implementation plan.
2. Apply the smallest targeted change that resolves the root cause.
3. Keep scope strict; avoid unrelated refactors.
4. Add/update regression tests when applicable.

### Step 5: Verify

Run validation in increasing scope:

1. Focused checks for the changed behavior/module
2. Nearby regression checks
3. Relevant project checks (lint/typecheck/tests/build) as needed

Fix is complete only when:

- Reproduction no longer fails
- Expected behavior is confirmed
- No critical regressions are introduced

If verification indicates broader impact, escalate to `brainstorm` or `write-plan`.

### Step 6: Complete and Report

Provide a concise completion report with:

- **Root cause**
- **What changed**
- **Why this fix works**
- **Verification performed and results**
- **Residual risks / follow-ups**

If behavior or documentation-relevant rules changed, update the minimal relevant docs. If architecture changed, this should have been escalated.

## Rules

- Do not guess when key context is missing.
- Always prioritize root-cause fixes.
- Keep blast radius minimal.
- Do not mark done without verification.
- Escalate early when scope/risk exceeds this skill.

## Optional Bug Report Template

Use when the report is incomplete:

- Title:
- Expected behavior:
- Actual behavior:
- Reproduction steps:
- Error logs/stack trace:
- Environment:
- Impact/severity:
- Additional context:

© buiducnhat · MIT · buiducnhat/cobrew

Similar skills

All skills for Testing and QA →

fix by other authors comes first.

fix react fix is a Claude Code skill that formats changed files and checks for lint errors. Run it before committing to see whether CI checks still need fixes. CX Codex +1 2,300installs fix Alireza Rezvani Sorts a failing or flaky Playwright test into a category, applies the matching fix, then proves it holds. Useful when a test fails in CI but passes locally. CX Codex +1 1,638installs fix parcadei fix is a Claude Code skill that selects a chain of skills to take a bug from diagnosis through commit. CX Codex +1 488installs fix davepoon fix fetches vulnerability intelligence and suggests actionable package remediation steps for your project. CX Codex +1 ★ 3,785repo stars fix TakaGoto fix is a Claude Code skill that diagnoses and repairs broken RAG pipelines without theory. It handles garbage retrieval and model hallucinations. CX Codex +1 ★ 30repo stars fix-issue OrchestKit The fix-issue skill investigates a GitHub issue, applies a tested fix, opens a linked PR, and records ways to prevent the bug from returning. CX Codex +1 217installs w-debug blockmatic-icebox The w-debug Claude Code skill traces failures through logs and reproduction steps. After an authorized fix, it reruns the original scenario and affected checks. CX Codex +1 647installs bugfix ulpi-io bugfix fixes confirmed bugs through a strict loop: reproduces failures with isolated tests, pinpoints root causes, and applies minimal diffs without weakening tests. CX Codex +1 176installs focused-fix Alireza Rezvani focused-fix is a Claude Code skill that repairs a feature or module through a systematic investigation. It activates when a whole area needs work, rather than a single bug fix. CX Codex +1 600installs bug-fix bobmatnyc Provides a structured workflow for verifying bug fixes, uncovering root causes, and writing regression tests to prevent recurring defects. CX Codex +1 488installs red-green-proof RooAGI The red-green-proof plugin turns a suspected bug into evidence with a focused test, a fix, and a rollback check. Use it when the cause still needs proof. CX Codex ★ 1,596repo stars

From the same set7

Project sponsors

Companies that keep this analytics open