flow-debugging
Debug Code with Systematic Methodology
Developers often guess at bug fixes, leading to regressions and wasted time. This skill enforces a rigorous 4-phase debugging process that requires root cause investigation before any code changes.
Baixar o ZIP da skill
Upload no Claude
Vá em Configurações → Capacidades → Skills → Upload skill
Ative e comece a usar
Testar
A utilizar "flow-debugging". Help me debug: My API returns 500 errors intermittently for user login requests.
Resultado esperado:
Let's start Phase 1: Root Cause Investigation.
## Step 1: Record Error Details
- Error type: HTTP 500 Internal Server Error
- Frequency: Intermittent (not every request)
- Impact: Users cannot log in during failures
## Step 2: Stable Reproduction
What conditions precede this error?
- Time of day? Load level? Specific user types?
## Step 3: Check Recent Changes
Run: git log --oneline -20
Run: git diff HEAD~5
What changed around when this started?
## Step 4: Trace Data Flow
Where does the login request flow break?
- Check logs for stack traces
- Identify the exact line throwing 500
STOP. Do NOT implement fixes yet. First, confirm root cause.
A utilizar "flow-debugging". I'm stuck. I've tried 3 fixes but the bug keeps coming back.
Resultado esperado:
Three failed fix attempts detected. This is a red flag. STOP and apply the methodology.
## Go Back to Phase 1
You likely fixed symptoms, not root cause.
## Questions to Answer
1. Did you reproduce before each fix?
2. Did you write failing tests first?
3. Did you verify root cause with evidence?
## Recommendation
- Roll back all recent changes
- Re-run Phase 1 systematically
- Only then proceed to Phase 2-4
The Iron Law applies: NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.
Auditoria de Segurança
SeguroDocumentation-only skill describing a 4-phase debugging methodology. All static findings are false positives: markdown code blocks flagged as shell execution, SHA256 hash strings flagged as crypto vulnerabilities, and relative documentation paths flagged as path traversal. No executable code exists.
Pontuação de qualidade
O Que Você Pode Construir
Fix Complex Bugs Systematically
When encountering difficult bugs that have resisted multiple fix attempts, use this skill to step back and apply rigorous root cause analysis before making more changes.
Learn Systematic Debugging
Junior developers can use this skill to learn professional debugging techniques that emphasize evidence-based investigation over guesswork.
Prevent Debugging Anti-Patterns
When you catch yourself saying 'let me try this', use this skill to reset and apply structured debugging methodology instead of random attempts.
Tente Estes Prompts
I'm encountering a bug: [describe the error]. Help me debug this systematically using the 4-phase process. Start with Phase 1: Root Cause Investigation. What should I look for and record?
I think I understand the bug. Before I implement a fix, guide me through creating a stable reproduction case and checking recent changes with git commands.
I've reproduced the bug. Now help me with Phase 2: Pattern Analysis. How do I find similar working examples and compare them with the broken code?
My hypothesis is: [state hypothesis]. Guide me through Phase 3: Hypothesis Testing and Phase 4: TDD Implementation. Help me write a failing test first.
Melhores Práticas
- Always complete Phase 1 (Root Cause Investigation) before writing any fix code. Resistance to this is a red flag.
- Write a failing test that reproduces the bug before implementing any fix. This is your 'red light' in Phase 4.
- When 3+ fix attempts fail, stop immediately and restart from Phase 1. The problem is deeper than you think.
- Document your investigation using the structured template. Clear documentation prevents revisiting solved issues.
Evitar
- Shotgun debugging: Trying random changes until something works. This is not debugging, it's guessing.
- Fix-first methodology: Implementing fixes before understanding the root cause. This leads to regressions.
- Skipping reproduction: Attempting fixes without first establishing reliable reproduction steps.
- Documentation skipping: Saying 'I know what's wrong' without evidence-based investigation.