bug-diagnosis

Orchestrating multi-phase agent workflows with structured handoff and consensus-driven decision gates.

Root-causing errors in unfamiliar codebases with structured investigation.

Isolating flaky test root causes by running suspected culprits in parallel with detailed logging.

Rapidly fixing startup/tooling bugs without broad code exploration

Finding production bugs and preventing them via systematic testing rather than trial-and-error

fan-out parallel research with synthesized results

Orchestrating multi-phase autonomous workflows where fan-out and synthesis improve outcomes.

Orchestrating multi-phase agent workflows with structured handoff and consensus-driven decision gates.

When stack traces don't immediately reveal the bug and multiple independent-seeming changes coincide.

Root-cause analysis across multi-scenario runs with dedup and regression detection.

When you have a mysterious bug and need deep root-cause analysis with test-driven validation

Production bugs and flaky tests when you need runtime truth instead of plausible code stories.

Efficiently diagnosing where a prompt failed (plan/prompt/code level) rather than blindly retrying

Debugging across software/data/infra layers when the cause isn't obvious from symptoms alone

Production defects where root cause is unknown and a regression guard is mandatory before closing.

Teams enforcing TDD discipline to prevent regressions and verify actual bug fix.

Finding where a feature or bug lives by tracing the complete data flow with file:line accuracy

Production incidents or complex bugs where root cause is unclear and multi-hypothesis investigation needed

Isolate root cause of flaky tests through hypothesis-driven test mutation.

Code review when runtime errors, type issues, or boundary cases are primary concern.

When something breaks and guessing wastes more time than structured triage.

Systematic hypothesis-driven debugging beats random code changes.

Identify root causes of application failures and performance issues with guided troubleshooting.

Isolating elusive bugs using binary search and hypothesis testing rather than random code inspection or blame.

Debugging tests when you need to distinguish flakiness from real failures and identify patterns.

Narrowing down what went wrong in implementator skill before escalating to maintainer.

Debugging production issues by tracing logs, reproducing errors, and identifying root causes systematically.