skills.rest
Inteligentsensingsolutions
InteligentsensingsolutionsOFFICIAL
Explore all skills by this author →
GitHub

systematic-debugging

Diagnose and fix Node.js and TypeScript bugs using a four-phase debugging methodology.

1|Updated Apr 13, 2026
Search Tags:#tdd#debugging#bisection#triage#root-cause#flaky-tests#test-failure
One-click install
npx skills add https://github.com/Inteligentsensingsolutions/tdd-dev-workflow --skill systematic-debugging-inteligentsensingsolutions
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/Inteligentsensingsolutions/tdd-dev-workflow/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/Inteligentsensingsolutions/tdd-dev-workflow --skill systematic-debugging-inteligentsensingsolutions

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

Systematic Debugging provides a disciplined four-phase approach to reliably diagnose and fix software bugs, test failures, regressions, crashes, and unexpected runtime behavior without guessing or shotgun-debugging.

Core Features & Use Cases

  • Phase 1 — Root Cause Investigation: Reproduce failures, capture error messages and stack traces, inspect data flow, and check recent changes.
  • Phase 2 — Pattern Analysis: Compare with working code, verify environment and dependency versions, and locate structural differences.
  • Phase 3 — Hypothesis & Testing: Form a single, testable hypothesis and design the smallest possible test that validates or invalidates it.
  • Phase 4 — Implementation (TDD): Write a failing test, apply a minimal fix, run the full test suite, and assess similar code for the same issue.
  • Operational aids: Includes a debugging checklist, escalation rules (stop after multiple failed fixes), references for condition-based waiting, defense-in-depth validation, root-cause tracing, and a bisection script to find polluting tests.
  • Use cases: Fixing flaky tests, CI regressions, failing E2E or unit tests, production crash investigation, and onboarding a reproducible fix process across a codebase.

Quick Start

Ask the debugger to run systematic-debugging on the failing test file test/user.spec.ts, reproduce the failure, produce a root-cause hypothesis, and propose a minimal failing test and fix.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I fix flaky tests and intermittent regressions in a Node.js CI environment?▼

Fix flaky tests by applying a structured four-phase debugging methodology: reproduce the intermittent failure, analyze patterns, form a single testable hypothesis, and implement a minimal TDD-based fix verified by the full test suite to prevent regressions in Node.js CI environments.

What is the best way to find the root cause of a failing unit or end-to-end test?▼

The best way to find the root cause of a failing test is to reproduce the failure, capture error messages and stack traces, inspect data flow, check recent changes, and compare working code with failing code to locate structural differences before writing a minimal failing test.

How do I debug unexpected crashes and runtime errors in TypeScript projects systematically?▼

Debug unexpected crashes and runtime errors systematically by following a four-phase approach: investigate root causes by capturing stack traces, analyze patterns against working code, test a single hypothesis with a minimal test, and implement a TDD-based minimal fix verified across the full suite.

Can I use test bisection to find polluting tests in my test suite?▼

Yes, you can use a bisection script to find polluting tests in your suite. This operational aid helps isolate tests that cause cascading failures or pollute state, allowing you to target the exact root cause of the failure efficiently.

How do I stop guessing and apply a structured TDD debugging process to fix software bugs?▼

Stop guessing by applying a structured four-phase debugging process: investigate root causes, analyze patterns, form a single testable hypothesis validated by the smallest possible test, and implement a TDD-based minimal fix assessed across similar code to ensure reliability.

Related Skills

Explore More Software Engineering Skills→
Agent-Engineer-MasterAgent-Engineer-Master
7

fix-from-logs

Diagnose bugs from error logs and propose pytest regression tests.

Official
Advanced
igij01igij01

bug-fix-and-ship

Automate bug fixes from structured reports to verified source changes.

Community
Advanced
kennyolofsson23-netizenkennyolofsson23-netizen

kaizen:root-cause-tracing

Trace errors back through call chains to locate original triggers.

Community
Advanced
SnakeOSnakeO
9

debug:django

Diagnose Django errors with a four-phase debugging workflow.

Community
Intermediate