hunt
by tw93hunt is a debugging-first skill that forces root-cause thinking before any fix is applied. Use it for errors, crashes, regressions, failing tests, stale cache issues, screenshot bugs, and “it used to work” failures. It helps you find a testable hypothesis, gather evidence, and avoid guesswork. Not for code review or new features.
This skill scores 84/100, which means it is a solid listing candidate for users who need a structured diagnose-before-fix workflow for bugs, crashes, regressions, and failed tests. The repository gives enough operational detail for agents to trigger it correctly and follow a repeatable debugging process, though it is narrower than a full general-purpose debugging skill and lacks some adoption aids like an install command.
- Strong triggerability: frontmatter explicitly targets errors, crashes, regressions, failing tests, and 'used to work and now fails' cases with multilingual and English trigger phrases.
- Operationally clear workflow: it instructs agents to form a one-sentence root-cause hypothesis before touching code, with testable specifics like file/function/line/condition.
- Helpful reference depth: four focused reference files cover recurring failure patterns, logging techniques, IME/unicode issues, and rendering bugs, giving agents concrete next-step guidance.
- No install command in SKILL.md, so users may need extra setup or manual interpretation before adoption.
- Scope is specialized to debugging and root-cause analysis; it is not positioned for code review or feature work, so it will not fit broader generalist use cases.
Overview of hunt skill
What hunt is for
hunt is a debugging-first skill that forces root-cause thinking before any fix is applied. It is best for errors, crashes, regressions, failing tests, stale cache issues, screenshot bugs, and “it used to work” failures where you need a testable hypothesis, not a quick patch.
Who should install it
Install the hunt skill if you regularly debug across app code, tests, build artifacts, or runtime behavior and want a repeatable hunt guide for narrowing the problem fast. It is especially useful when symptoms are noisy, repeated fixes keep failing, or the bug spans logs, UI state, and generated output.
What makes it different
The core value is discipline: identify a specific file, function, line, or condition, then gather evidence until the root cause is defensible. The supporting references cover logging, failure patterns, IME/Unicode edge cases, and rendering bugs, so the skill is not just “debug harder”; it pushes you toward the right class of diagnosis.
How to Use hunt skill
Install and context setup
Use the normal skill install flow for your environment, then open the skill files in this order: SKILL.md, references/failure-patterns.md, references/logging-techniques.md, references/ime-unicode.md, and references/rendering-debug.md. Start with the reference that matches the symptom; do not read everything unless the issue crosses domains.
How to prompt for hunt usage
For best hunt usage, ask for diagnosis before repair and include the smallest reproducible symptom you have. Strong input sounds like: “hunt this regression: clicking Save no longer persists after refresh; latest change touched src/hooks/user.ts; logs show cache hit.” Weak input sounds like: “save is broken, please fix.”
Workflow that the skill expects
The hunt guide expects you to state a one-sentence hypothesis, verify it with evidence, then only patch once the cause is testable. In practice: reproduce, narrow the path, collect one discriminating log or check, confirm the propagation path, then write the smallest fix and a regression test if possible.
Practical reading path
Use references/failure-patterns.md when the bug smells like cache, queue, guard, or build boundary issues. Use references/logging-techniques.md when you need instrumented evidence. Use references/ime-unicode.md for CJK input or composition bugs. Use references/rendering-debug.md for PDF, print, font, or layout failures.
hunt skill FAQ
Is hunt only for code bugs?
No. The hunt skill is for debugging any concrete failure mode: runtime errors, failing tests, broken generated artifacts, UI regressions, and output mismatches. It is not the right fit for pure code review or feature design.
Do I need to know the exact root cause first?
No, but you do need a hypothesis that could be falsified. The skill is built to help you move from “something is wrong” to “I believe the root cause is X because Y.”
Is hunt better than a normal prompt?
Usually yes when the failure is ambiguous or recurring. A generic prompt may produce a patch; hunt tries to reduce guesswork first, which lowers the chance of a fix that breaks another path.
When should I not use hunt?
Skip it when you are adding a new feature, refactoring without a bug, or already have a confirmed minimal fix and just need implementation help. It is also not the best match for high-level architectural brainstorming.
How to Improve hunt skill
Provide stronger evidence up front
Give the symptom, the latest change, the exact environment, and one or two concrete observations. For example: “fails only on cold start,” “passes after cache clear,” “breaks on macOS with CJK input,” or “PDF renders locally but not in CI.” This helps hunt choose the right failure pattern immediately.
Avoid common failure modes
The biggest mistake is asking for a fix before the cause is bounded. Another common failure is vague observability: logs that show only the error message, not the branch, sequence, or state transition that distinguishes one hypothesis from another. Add discriminating evidence, not more noise.
Iterate after the first pass
If the first diagnosis is incomplete, respond with the new observation instead of restarting the whole prompt. The hunt skill works best as a narrowing loop: hypothesis, check, counterexample, stronger hypothesis. That is how you get from a hunt skill install to a reliable hunt for Debugging workflow.