bug-work

Find and fix correctness bugs across repo sections using static analyzers at configurable depth.

2|Updated Apr 5, 2026
One-click install
npx skills add https://github.com/witwave-ai/witwave --skill bug-work-witwave-ai
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: bug-work
Source: https://github.com/witwave-ai/witwave/tree/main/.agents/self/evan/.claude/skills/bug-work
Command: npx skills add https://github.com/witwave-ai/witwave --skill bug-work-witwave-ai

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Manually hunting logic bugs across a large multi-language repository is slow and inconsistent, and naive auto-fixing creates false positives and broken code. This Skill runs a disciplined single-pass find-and-fix workflow that scans code with bug-class static analyzers, validates candidates against intentional-design patterns, and only commits fixes that pass a strict safety bar. ## Core Features & Use Cases - Depth-scaled bug hunting: Choose depth 1-10 to control how hard the analysis hunts, from bare analyzer hits to full-subsystem adversarial review. - 17 addressable repo sections: Covers Python, Go, Dockerfile, shell, GitHub Actions, Helm charts, and Vue/TypeScript with per-section toolchains (ruff, go vet, staticcheck, errcheck, hadolint, shellcheck, actionlint, helm lint, vue-tsc). - Fix-bar safety gate: Every fix must be function-body contained, have bounded blast radius, have test coverage (or match the safe-pattern catalogue), and come from a high-signal analyzer rule; everything else is flagged for human review. - Use Case: Run "fix bugs in operator depth 7" to scan the Go operator with go vet, staticcheck, errcheck, and ineffassign, validate each candidate against the 8-concern gauntlet, commit safe fixes individually, and record flagged candidates in a findings memory file. ## Quick Start Ask the agent to work bugs at a chosen depth and scope, for example: run bug-work on the harness and shared sections at depth 5.

Frequently Asked Questions about bug-work

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I find and fix bugs automatically in a repo?▼

Run the bug-work workflow with a depth and section scope, such as "fix bugs in operator depth 7". It scans with bug-class static analyzers, validates each candidate against intentional-design concerns, commits safe fixes individually, and flags anything needing human judgment.

What static analysis tools find logic bugs in Go and Python?▼

For Go, go vet, staticcheck (SA checks), errcheck, and ineffassign catch correctness bugs. For Python, ruff with the B (bugbear) and F (Pyflakes) rule sets covers bug-class issues. Dockerfiles use hadolint, shell scripts use shellcheck, and workflows use actionlint.

What does the depth parameter control in bug scanning?▼

Depth (1-10) controls how hard the analysis hunts: depth 1-2 trusts bare analyzer hits, depth 3-4 reads a 20-line context window, depth 5-6 reads full function bodies, depth 7-8 reads whole files, and depth 9-10 does full-subsystem adversarial review. Every depth still fixes qualifying bugs.

When does an auto-fix get flagged instead of committed?▼

A candidate is flagged when it fails the fix-bar: the fix is not function-body contained, blast radius is unclear, no test coverage exists for the path (unless it matches the safe-pattern catalogue), or the analyzer signal is ambiguous. Flagged candidates are recorded in the findings memory file for human review.

Which code is out of scope for automated bug fixing?▼

Markdown, TOML/JSON, lockfiles, generated and vendored code, and test files are excluded. Style-only findings (pycodestyle E/W rules) are also out of scope since the workflow targets correctness bugs only.