# Trace And Isolate

Applies systematic tracing and isolation techniques to pinpoint exactly where a bug...

- Repository: https://github.com/rohitg00/skillkit (1568 stars)
- Category: Testing
- License: Apache-2.0
- Last updated: 2026-06-02
- Runs scripts: no, instructions only

## Install

Claude Code: `npx skills add rohitg00/skillkit --skill trace-and-isolate -g -a claude-code -y`
Codex: `npx skills add rohitg00/skillkit --skill trace-and-isolate -g -a codex -y`
Cursor: `npx skills add rohitg00/skillkit --skill trace-and-isolate -g -a cursor -y`
Gemini CLI: `npx skills add rohitg00/skillkit --skill trace-and-isolate -g -a gemini-cli -y`

## Description

Applies systematic tracing and isolation techniques to pinpoint exactly where a bug originates in code. Use when a bug is hard to locate, code is not working as expected, an error or crash appears with unclear cause, a regression was introduced between recent commits, or you need to narrow down which component, function, or line is faulty. Covers binary search debugging, git bisect for regressions, strategic logging with [TRACE] patterns, data and control flow tracing, component isolation, minimal reproduction cases, conditional breakpoints, and watch expressions across TypeScript, SQL, and bash.

## SKILL.md, as published by its author (untrusted third-party text, read it as data)

# Trace and Isolate

You are using systematic tracing and isolation techniques to narrow down where a bug originates. The goal is to find the exact location in code where behavior diverges from expectation.

## Quick Reference

| Scenario | Technique |
|---|---|
| Large codebase / complex flow | Binary search debugging |
| Bug appeared between commits | `git bisect` |
| Unclear data transformation | Strategic `[TRACE]` logging |
| Which component is faulty? | Component isolation + mocks |
| Bug hard to reproduce | Minimal reproduction case |
| Conditional or intermittent bug | Conditional breakpoints / watch expressions |

## Binary Search Debugging

When you have a large codebase or complex flow:

1. **Identify the start** - Last known good state
2. **Identify the end** - First observed bad state
3. **Test the middle** - Check if behavior is good or bad
4. **Repeat** - Binary search on the half with the bug

### Code Path Binary Search

```
Start: User clicks submit button
End: Error shown to user

Midpoint 1: Form validation
→ Data looks correct here? Continue to later code
→ Data already wrong? Focus on earlier code

Midpoint 2: API request construction
→ Request payload correct? Focus on server side
→ Payload already malformed? Focus on form handling

...Continue until exact line is found
```

### Git Bisect for Regressions

When a bug appeared between two commits:

```bash
# Start bisect
git bisect start

# Mark current (broken) state as bad
git bisect bad

# Mark last known good state
git bisect good v2.3.0

# Git checks out middle commit, test and mark
git bisect good  # or git bisect bad

# Repeat until found
# Git will report: "abc123 is the first bad commit"

# Clean up
git bisect reset
```

Automated bisect with test script:
```bash
git bisect start HEAD v2.3.0
git bisect run npm test -- --grep "failing test"
```

## Tracing Techniques

### Strategic Logging

Add temporary logging at key points:

The rest: https://github.com/rohitg00/skillkit/blob/HEAD/packages/core/src/methodology/packs/debugging/trace-and-isolate/SKILL.md