Dev & Engineering

ce-debug: Systematic Bug Diagnosis & Fix

Systematically trace root causes of bugs, diagnose before fixing, and produce regression tests.

55/ 100
Use with care

Useful, but reliability, evidence or controls still have material gaps.

See how it was scored ↓
Works as-is in
Claude Code · ChatGPT(Partial support) · Codex(Partial support)
Stars
★ 25k
Last updated
3d ago
License
MIT
debuggingroot-cause-analysistest-firstbug-fixing
+2cursorcodex

What does this skill do, and when should you use it?

ce-debug is an Agent Skill for diagnosing and fixing software bugs with a methodical, causal-chain investigation. It starts by reproducing the problem, tracing the code path, verifying the environment, and checking the issue tracker and PR history to avoid duplicating others' work. After establishing the root cause, it offers an interactive choice to fix now, diagnose only, or rethink the design. If fixing, it uses test-first discipline, follows a one-change-at-a-time principle, and includes workspace safety checks before committing to a PR. It also supports a pipeline mode for fully autonomous operation, ideal for CI babysitting. This skill is part of the Compound Engineering plugin collection and works across multiple AI coding tools.

This skill takes a bug description (e.g., error message, stack trace, test path, or issue reference) and executes a multi-phase workflow: it fetches issues from trackers in Phase 0, reproduces the bug and traces code paths in Phase 1, forms and tests hypotheses in Phase 2, optionally writes tests to drive the fix in Phase 3, and produces a structured summary in Phase 4. It reads local files, runs shell commands (e.g., git, tests), invokes browser tools if needed, and may use GitHub CLI for issue information. It also writes residual findings and compound learnings to designated artifact directories.

Good fit
  • A developer faces a stack trace or failing test and needs to find the root cause without guessing.
  • An engineer works on a regression and wants to trace back to the original commit that introduced the bug.
  • A developer is stuck on a bug and wants a disciplined approach to avoid shotgun debugging.
  • A CI bot (like a PR babysitter) needs a non-interactive bug fix that can commit and push autonomously.
  • A team wants to ensure every bug fix includes a regression test and captures lessons learned.

How do you install this skill?

Before you use it
  • Publisher identity unverified; review before installation.
  • Context script executes shell commands, potential security risk; review script content.
  • Skill may be triggered for design problems; ensure clear boundaries.
  • No version or changelog; update path unclear.
Before you start
Your agent needs
  • Shell / CLI
  • Local filesystem
Install first
  • Node.js
  • GitHub CLI (optional)
  • Browser tools (optional)

This skill is part of the Compound Engineering plugin. For Claude Code: run /plugin marketplace add EveryInc/compound-engineering-plugin and /plugin install compound-engineering. For Cursor, add from the plugin marketplace search. For Codex, follow the README steps. Existing users must refresh the marketplace before updating the plugin.

Generic route: install into Claude Code manually (macOS / Linux)
tmp="$(mktemp -d)"
git clone --depth 1 https://github.com/EveryInc/compound-engineering-plugin.git "$tmp"
mkdir -p ~/.claude/skills
cp -R "$tmp/skills/ce-debug" ~/.claude/skills/
rm -rf "$tmp"

Generated from the source repository and skill path; it copies only this skill's folder. If the author's install steps above differ, follow those first. To scope it to one project, replace ~/.claude/skills with that project's .claude/skills.

How do you use this skill?

After installation, invoke /ce-debug with a bug description in a supported tool, e.g., /ce-debug the checkout webhook sometimes creates duplicate invoices. The skill will guide you through investigation phases. In interactive mode, you can choose to fix now or diagnose only. In pipeline mode, it fixes and pushes automatically.

What are this skill's strengths and limitations?

Pros
  • Enforces root-cause analysis, preventing symptom patching.
  • Includes test-first discipline with regression test generation.
  • Supports both interactive and autonomous pipeline modes.
  • Integrates with other Compound Engineering skills for review and learning capture.
  • Works across multiple AI tools (Claude Code, Cursor, Codex, etc.).
Limitations
  • Cognitive overhead; may be overkill for simple typos.
  • Requires Node.js for the context script; functionality reduced without it.
  • Depends on GitHub CLI for issue fetching; other trackers may need manual paste.
  • No full automated test suite shown in docs; only internal scripts described.
  • Phase 4's auto-commit/PR behavior requires user consent; may not fit all workflows.

How does this skill compare with similar options?

Side by side with related skills; every score comes from the same FSRS standard.

Skill FS score Stars Last updated License
ce-debug: Systematic Bug Diagnosis & Fix this page 55 · Use with care ★ 25k 3d ago MIT
RenderCV Issue Solver 51 · Use with care ★ 18k 6mo ago MIT
Obsidian Knowledge Brain v4.0 56 · Use with care ★ 100 3mo ago MIT
Vibe Replay 56 · Use with care ★ 39 3d ago MIT
Agent Skills Manager — manage-skills Skill 50 · Use with care ★ 41 6mo ago MIT

How did FollowSkills review this skill?

FollowSkills review · FSRS-2.0
Use with care
55/ 100 5-point scale 2.8 / 5
The upstream repository has new commits since this review. The score still applies to the reviewed revision shown and may not cover the latest changes.
1Trust15 / 25 · 3.0/5

Evidence: SKILL.md requires checking uncommitted changes and default branch creation before editing, and follows least privilege. It asks the user to choose whether to fix, discloses data flow (reading git logs, logs, telemetry). The context script runs git commands but only outputs read-only info, no exfiltration. Dependencies like gh are disclosed. Deduction: publisher identity unverified, only MIT license metadata; context script executes shell commands, potential tampering; no rollback mechanism provided.

2Reliability7 / 20 · 1.8/5

Evidence: SKILL.md provides detailed step-by-step process, references files, includes error handling (degradation if context script fails). Key path is guiding user through diagnosis, not independent reproduction; not execution-verified here. Deduction: no test suite or CI evidence to confirm reliability; failure feedback quality only defined in pipeline mode, not interactive.

3Adaptability12 / 15 · 4.0/5

Evidence: SKILL.md specifies triggers (errors, stack traces, regressions, test failures), defines input format and expected output (diagnosis, fix), has pipeline and interactive modes. No external services, uses local tools and git, suitable for mainland China networks. Deduction: non-fit boundaries (e.g., design problems) not explicitly excluded, potential false triggers; no Chinese translation, but English is acceptable for technical users.

4Convention12 / 15 · 4.0/5

Evidence: SKILL.md has clear hierarchy, references files, provides examples and common pitfalls, includes known limitations (divergent fixes in pipeline mode). License MIT, no version or changelog. Deduction: missing version and changelog, maintenance responsibility not explicit (who maintains), only implied via README as EveryInc plugin.

5Effectiveness6 / 15 · 2.0/5

Evidence: The skill aims to diagnose and fix bugs, expected output is root cause analysis and fix suggestion, provides marginal value over manual debugging via systematic approach. However, output depends on user confirmation, actual fix not always automatic. Deduction: no verifiable representative output, not execution-verified, marginal value not quantified.

6Verifiability3 / 10 · 1.5/5

Evidence: Provides CI badge (build status) but no test suite or reproducible tests. Context script includes executable verification steps but no results. Deduction: static review cannot independently verify behavior; CI badge insufficient; no concrete test results.

1 2 3 4 5 6

Open a dimension to read why it scored that way

Reviewed Aug 07, 2026 Reviewed revision 0a2957852e20 Review evidence[1][2][3][4][5][6][7]

Evidence confidence:Low — Mostly static review, author material or a limited demo; useful for discovery, not high-risk decisions.

See the full review method →

FAQ

Is this skill suitable for simple bugs?
It has a fast-path for obvious fixes, but defaults to full investigation, so it may be overkill for trivial issues.
How does it work in pipeline mode?
It runs fully non-interactively, defers divergent fixes (that would overturn design decisions) to human, and commits/pushes convergent fixes automatically.
What tools or permissions do I need?
Shell access, Git, and Node.js. GitHub CLI is optional but recommended for issue integration. Browser tools are needed for reproducing web issues.
Will it commit or push automatically?
In interactive mode, only if you explicitly approve. In pipeline mode, it does so automatically.

More skills from this repository

All from EveryInc/compound-engineering-plugin

Related skills