Bug Hunter workflow skill. Use this skill when the user needs Systematically finds and fixes bugs using proven debugging techniques. Traces from symptoms to root cause, implements fixes, and prevents regression and the operator should preserve the upstream workflow, copied support files, and provenance before merging or handing off.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Bug Hunter workflow skill. Use this skill when the user needs Systematically finds and fixes bugs using proven debugging techniques. Traces from symptoms to root cause, implements fixes, and prevents regression and the operator should preserve the upstream workflow, copied support files, and provenance before merging or handing off.
This public intake copy packages plugins/antigravity-awesome-skills/skills/bug-hunter from https://github.com/sickn33/antigravity-awesome-skills into the native Omni Skills editorial shape without hiding its origin.
Use it when the operator needs the upstream workflow, support files, and repository context to stay intact while the public validator and private enhancer continue their normal downstream flow.
This intake keeps the copied upstream files intact and uses the external_source block in metadata.json plus ORIGIN.md as the provenance anchor for review.
Bug Hunter Systematically hunt down and fix bugs using proven debugging techniques. No guessing—follow the evidence.
Imported source sections that did not map cleanly to the public headings are still preserved below or in the support files. Notable imported sections: Debugging Techniques, Common Bug Patterns, Debugging Tools, Documentation Template, Bug: Login timeout after 30 seconds, Limitations.
When to Use This Skill
Use this section as the trigger filter. It should make the activation boundary explicit before the operator loads files, runs commands, or opens a pull request.
User reports a bug or error
Something isn't working as expected
User says "fix the bug" or "debug this"
Intermittent failures or weird behavior
Production issues need investigation
Take a break (seriously, walk away for 10 minutes)
Operating Table
Situation
Start here
Why it matters
First-time use
metadata.json
Confirms repository, branch, commit, and imported path through the external_source block before touching the copied workflow
Provenance review
ORIGIN.md
Gives reviewers a plain-language audit trail for the imported source
Workflow execution
README.md
Starts with the smallest copied file that materially changes execution
Supporting context
README.md
Adds the next most relevant copied source file without loading the entire package
Handoff decision
## Related Skills
Helps the operator switch to a stronger native skill when the task drifts
Workflow
This workflow is intentionally editorial and operational at the same time. It keeps the imported source useful to the operator while still satisfying the public intake standards that feed the downstream enhancer flow.
Get exact steps to reproduce
Try to reproduce locally
Note what triggers it
Document the error message/behavior
Check if it happens every time or randomly
What environment? (dev, staging, prod)
What browser/device?
Imported Workflow Notes
Imported: The Debugging Process
1. Reproduce the Bug
First, make it happen consistently:
1. Get exact steps to reproduce
2. Try to reproduce locally
3. Note what triggers it
4. Document the error message/behavior
5. Check if it happens every time or randomly
If you can't reproduce it, gather more info:
What environment? (dev, staging, prod)
What browser/device?
What user actions preceded it?
Any error logs?
2. Gather Evidence
Collect all available information:
Check logs:
# Application logstail -f logs/app.log
# System logs
journalctl -u myapp -f
# Browser console# Open DevTools → Console tab
Check error messages:
Full stack trace
Error type and message
Line numbers
Timestamp
Check state:
What data was being processed?
What was the user trying to do?
What's in the database?
What's in local storage/cookies?
3. Form a Hypothesis
Based on evidence, guess what's wrong:
"The login times out because the session cookie
expires before the auth check completes"
"The form fails because email validation regex
doesn't handle plus signs"
"The API returns 500 because the database query
has a syntax error with special characters"
4. Test the Hypothesis
Prove or disprove your guess:
Add logging:
console.log('Before API call:', userData);
const response = await api.login(userData);
console.log('After API call:', response);
Use debugger:
debugger; // Execution pauses hereconst result = processData(input);
Isolate the problem:
// Comment out code to narrow down// const result = complexFunction();const result = { mock: 'data' }; // Use mock data
5. Find Root Cause
Trace back to the actual problem:
Common root causes:
Null/undefined values
Wrong data types
Race conditions
Missing error handling
Incorrect logic
Off-by-one errors
Async/await issues
Missing validation
Example trace:
Symptom: "Cannot read property 'name' of undefined"
↓
Where: user.profile.name
↓
Why: user.profile is undefined
↓
Why: API didn't return profile
↓
Why: User ID was null
↓
Root cause: Login didn't set user ID in session
6. Implement Fix
Fix the root cause, not the symptom:
Bad fix (symptom):
// Just hide the errorconst name = user?.profile?.name || 'Unknown';
Good fix (root cause):
// Ensure user ID is set on loginconstlogin = async (credentials) => {
const user = awaitauthenticate(credentials);
if (user) {
session.userId = user.id; // Fix: Set user IDreturn user;
}
thrownewError('Invalid credentials');
};
7. Test the Fix
Verify it actually works:
1. Reproduce the original bug
2. Apply the fix
3. Try to reproduce again (should fail)
4. Test edge cases
5. Test related functionality
6. Run existing tests
8. Prevent Regression
Add a test so it doesn't come back:
test('login sets user ID in session', async () => {
const user = awaitlogin({ email: 'test@example.com', password: 'pass' });
expect(session.userId).toBe(user.id);
expect(session.userId).not.toBeNull();
});
Imported: Debugging Techniques
Binary Search
Cut the problem space in half repeatedly:
// Does the bug happen before or after this line?console.log('CHECKPOINT 1');
// ... code ...console.log('CHECKPOINT 2');
// ... code ...console.log('CHECKPOINT 3');
Rubber Duck Debugging
Explain the code line by line out loud. Often you'll spot the issue while explaining.
git bisect start
git bisect bad # Current commit is broken
git bisect good abc123 # This old commit worked# Git will check out commits for you to test
Examples
Example 1: Ask for the upstream workflow directly
Use @bug-hunter-v2 to handle <task>. Start from the copied upstream workflow, load only the files that change the outcome, and keep provenance visible in the answer.
Explanation: This is the safest starting point when the operator needs the imported workflow, but not the entire repository.
Example 2: Ask for a provenance-grounded review
Review @bug-hunter-v2 against metadata.json and ORIGIN.md, then explain which copied upstream files you would load first and why.
Explanation: Use this before review or troubleshooting when you need a precise, auditable explanation of origin and file selection.
Example 3: Narrow the copied support files before execution
Use @bug-hunter-v2 for <task>. Load only the copied references, examples, or scripts that change the outcome, and name the files explicitly before proceeding.
Explanation: This keeps the skill aligned with progressive disclosure instead of loading the whole copied package by default.
Example 4: Build a reviewer packet
Review @bug-hunter-v2 using the copied upstream files plus provenance, then summarize any gaps before merge.
Explanation: This is useful when the PR is waiting for human review and you want a repeatable audit packet.
Best Practices
Treat the generated public skill as a reviewable packaging layer around the upstream repository. The goal is to keep provenance explicit and load only the copied source material that materially improves execution.
Reproduce first, fix second
Follow the evidence, don't guess
Fix root cause, not symptoms
Test the fix thoroughly
Add tests to prevent regression
Document what you learned
Keep the imported skill grounded in the upstream repository; do not invent steps that the source material cannot support.
Imported Operating Notes
Imported: Key Principles
Reproduce first, fix second
Follow the evidence, don't guess
Fix root cause, not symptoms
Test the fix thoroughly
Add tests to prevent regression
Document what you learned
Troubleshooting
Problem: The operator skipped the imported context and answered too generically
Symptoms: The result ignores the upstream workflow in plugins/antigravity-awesome-skills/skills/bug-hunter, fails to mention provenance, or does not use any copied source files at all.
Solution: Re-open metadata.json, ORIGIN.md, and the most relevant copied upstream files. Check the external_source block first, then restate the provenance before continuing.
Problem: The imported workflow feels incomplete during review
Symptoms: Reviewers can see the generated SKILL.md, but they cannot quickly tell which references, examples, or scripts matter for the current task.
Solution: Point at the exact copied references, examples, scripts, or assets that justify the path you took. If the gap is still real, record it in the PR instead of hiding it.
Problem: The task drifted into a different specialization
Symptoms: The imported skill starts in the right place, but the work turns into debugging, architecture, design, security, or release orchestration that a native skill handles better.
Solution: Use the related skills section to hand off deliberately. Keep the imported provenance visible so the next skill inherits the right context instead of starting blind.
Related Skills
@00-andruia-consultant - Use when the work is better handled by that native specialization after this imported skill establishes context.
@00-andruia-consultant-v2 - Use when the work is better handled by that native specialization after this imported skill establishes context.
@10-andruia-skill-smith - Use when the work is better handled by that native specialization after this imported skill establishes context.
@10-andruia-skill-smith-v2 - Use when the work is better handled by that native specialization after this imported skill establishes context.
Additional Resources
Use this support matrix and the linked files below as the operator packet for this imported skill. They should reflect real copied source material, not generic scaffolding.
Resource family
What it gives the reviewer
Example path
references
copied reference notes, guides, or background material from upstream
references/n/a
examples
worked examples or reusable prompts copied from upstream
examples/n/a
scripts
upstream helper scripts that change execution or validation
scripts/n/a
agents
routing or delegation notes that are genuinely part of the imported package
agents/n/a
assets
supporting assets or schemas copied from the source package
// Bugconst name = user.profile.name;
// Fixconst name = user?.profile?.name || 'Unknown';
// Better fixif (!user || !user.profile) {
thrownewError('User profile required');
}
const name = user.profile.name;
Race Condition
// Buglet data = null;
fetchData().then(result => data = result);
console.log(data); // null - not loaded yet// Fixconst data = awaitfetchData();
console.log(data); // correct value
Off-by-One
// Bugfor (let i = 0; i <= array.length; i++) {
console.log(array[i]); // undefined on last iteration
}
// Fixfor (let i = 0; i < array.length; i++) {
console.log(array[i]);
}
Type Coercion
// Bugif (count == 0) { // true for "", [], null// Fixif (count === 0) { // only true for 0
Async Without Await
// Bugconst result = asyncFunction(); // Returns Promiseconsole.log(result.data); // undefined// Fixconst result = awaitasyncFunction();
console.log(result.data); // correct value
Imported: Debugging Tools
Browser DevTools
Console: View logs and errors
Sources: Set breakpoints, step through code
Network: Check API calls and responses
Application: View cookies, storage, cache
Performance: Find slow operations
Node.js Debugging
// Built-in debugger
node --inspect app.js// Then open chrome://inspect in Chrome
#### Imported: Bug: Login timeout after 30 seconds**Symptom:** Users get logged out immediately after login
**Root Cause:** Session cookie expires before auth check completes
**Fix:** Increased session timeout from 30s to 3600s in config
**Files Changed:**- config/session.js (line 12)
**Testing:** Verified login persists for 1 hour
**Prevention:** Added test for session persistence
Imported: Limitations
Use this skill only when the task clearly matches the scope described above.
Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
