debug-skill: Interactive Debugger for Coding Agents
Gives AI coding agents a real debugger — breakpoints, stepping, live state inspection — instead of print-statement guesswork.
Tool permission is scoped to Bash(dap *), reasonable least privilege; the skill asks/notify the user before installing dap and discloses tool provenance (GitHub, Homebrew tap); eval side-effect warnings are present. Deductions: README recommends curl|bash install and the script downloads unverified binaries from the network; the macOS Go PID-attach note mentions disabling SIP (flagged but not strongly discouraged); no integrity checksums or rollback guidance; publisher identity unverified.
Instructions are self-consistent: command tables, breakpoint syntax, sample outputs, and failure scenarios (early exit, adjusted breakpoints, missing backends) are documented with diagnostic paths; installing-debuggers.md covers per-language check/install/gotchas. Deductions: static review cannot execute; multi-level external dependencies (dap binary plus per-language debug adapters) create availability failure points; no guaranteed failure feedback for methodology steps.
Trigger conditions in description are concrete (crashes, exceptions, wrong output, print-insufficiency); scenarios are clear; non-fit ranges disclosed (library-internal breakpoints, noisy stop-on-entry on large projects, macOS Go PID limits). Deductions: no Chinese-language support; core installation depends entirely on GitHub Releases/Homebrew/go install, questionable reachability from mainland China with no mirror fallback.
Good layering: SKILL.md plus references (advanced techniques, debugger installs) plus scripts; progressive disclosure is sound; MIT license explicit; CI-driven version bumping and release workflow exist. Deductions: no substantive changelog content or named maintenance responsibility; no version notes within the skill; install script assumes release structure without minimum dap version compatibility declaration.
The core task (driving real debuggers via DAP instead of print debugging) is logically complete; example outputs are directly interpretable; walkthrough and fix-verification loop show real marginal value. Deductions: static review cannot confirm outputs are directly usable; actual effect depends on the dap CLI implementation (outside this skill's assessed evidence); machine-readable -- mode is not demonstrated within the skill.
Real CI exists (golangci-lint plus cross-platform go test matrix with debugpy E2E) covering the dap CLI's key paths, and the install script is auditable. Deductions: tests target the Go CLI rather than the skill instruction paths; no independent third-party reproduction; README stars/demo are marketing-grade and unverifiable statically.
- The recommended one-liner (curl|bash) and the install script download unsigned, checksum-unverified binaries; in enterprise environments prefer the Homebrew tap or source build with independent verification.
- Attaching to a Go process by PID on macOS requires disabling SIP; the skill mentions it but users should never disable System Integrity Protection for this.
- Installation and operation depend on GitHub Releases, Homebrew, go install, and debugpy/dlv/js-debug/lldb-dap; mainland-China network reachability is uncertain, so proxies or mirrors may be needed.
- The skill's effectiveness hinges on the external dap CLI; this review executed nothing, so real-world usability must be verified by the user.
- Publisher is not verified by the FollowSkills registry and is treated as unknown.
What does this skill do, and when should you use it?
debug-skill bundles a Claude Code skill with the `dap` CLI. The skill teaches the agent a structured debugging workflow — when to set breakpoints, how to step, how to read locals and the call stack — while `dap` wraps Microsoft's Debug Adapter Protocol behind stateless shell commands. It natively supports Python, Go, Node.js/TypeScript, Rust, and C/C++, plus any DAP-compatible language. Sessions run without restarts or an interactive terminal, and multiple agents can debug in parallel via named sessions. MIT-licensed and installable into 20+ coding agents via a plugin marketplace or skills.sh.
The skill drives debugging through allowed Bash calls to the dap CLI: dap debug <file> launches a program under an auto-detected debugger backend; breakpoints can be set at a line, conditionally ("file:line:condition"), on exceptions, or attached to remote debuggers (--attach host:port) or running processes (--pid). Every execution command returns full context: current location, surrounding source, locals, call stack, and output. The agent can evaluate expressions against the live process (dap eval, including frame selection), expand nested objects (dap inspect), step over/in/out, run to a temporary breakpoint (dap continue --to), restart preserving breakpoints (dap restart), and add/remove breakpoints mid-session (dap break). Named --session isolates concurrent agents.
- A developer debugging a Python service that throws a TypeError at an unknown location: the agent uses --break-on-exception to stop at the throw site and walks up the stack.
- A team maintaining a multi-module Go or Node.js app: the agent sets breakpoints across several files to trace where state first goes wrong.
- An engineer investigating a stuck live server: the agent attaches by PID without restarting the process to inspect real-time state.
- A developer chasing a loop or hot-path bug: conditional breakpoints like "app.py:42:i == 100" skip irrelevant iterations and stop only on the meaningful input.
- Users of Cursor, GitHub Copilot, Windsurf, or Cline: install the same skill via skills.sh to get identical debugging behavior in those agents.
- Environments running multiple AI agents concurrently: each gets its own named dap session with an isolated daemon and socket.
What are this skill's strengths and limitations?
- Real debugger capability — breakpoints, stepping, variable inspection, expression evaluation — far beyond print debugging.
- Native support for Python, Go, Node.js/TypeScript, Rust, C/C++; extensible to any DAP-compatible language.
- Every command returns full context (location, source, locals, stack, output) in one call, minimizing round trips.
- Daemon-plus-stateless-CLI design drives a debugger with no interactive terminal required.
- Named multi-session isolation supports parallel agents; MIT-licensed with Homebrew, script, and Go install paths.
- Built-in debugging methodology keeps the agent from盲目 stepping or scattering breakpoints.
- Requires installing the dap CLI plus per-language debugger backends (debugpy, Delve, js-debug, lldb-dap); backend failures need a separate reference doc.
- Attaching to a Go process by PID on macOS requires disabling SIP (csrutil disable), limiting that workflow in practice.
- The README provides no evidence of a test suite, benchmarks, or production adoption.
- Eval expressions with side effects can corrupt program state — the skill itself warns against this.
- The repo ships no description or topics, so maintenance cadence and community health must be inferred from the README alone.
How do you install this skill?
Claude Code: run /plugin marketplace add AlmogBaku/debug-skill, then /plugin install debugging-code@debug-skill-marketplace. Other agents (Cursor, Copilot, Windsurf, Cline, etc.): run npx skills add AlmogBaku/debug-skill (or bunx skills add AlmogBaku/debug-skill), or manually copy the skills/debugging-code/ folder into your agent's skills directory. The skill requires the dap CLI; install via brew install AlmogBaku/tap/dap, the repo's scripts/install-dap.sh, or go install github.com/AlmogBaku/debug-skill/cmd/dap@latest. The skill instructs the agent to notify you and get consent before installing dap.
How do you use this skill?
Once installed, the agent follows SKILL.md's guidance to call dap automatically. A typical trigger: "This Python script returns None on empty input — use the debugger to find the root cause." The agent might run dap debug script.py --break script.py:41, check the caller's values with dap eval "items" --frame 1, step out with dap step out, and verify a fix with dap restart. The skill embeds methodology: form falsifiable hypotheses, rethink after two failed hypotheses at the same spot, break at data boundaries rather than symptoms, and only trust a fix after observing correct behavior at the same breakpoint. Full command reference: dap --help.
How does this skill compare with similar options?
The source explicitly contrasts the skill with traditional print-statement debugging, positioning it as giving agents the real debugger workflow human developers already have; no named competitors are mentioned.