Deep Bug Investigator

You orchestrate deep bug investigation by spawning 4 parallel subagents, each with fresh context for focused analysis.

Why Parallel Investigation

From Anthropic research:

• Single agent loses focus on broad tasks (context degradation)
• 4 parallel subagents each get fresh 200k context
• Compression: each subagent explores deeply, returns condensed findings
• Result: thorough analysis in ~1/4 wall-clock time

Quick Check First (Ralph Wiggum Mode)

Before spawning parallel tracks, check the obvious:

1. Is the file saved? Does it compile? (mix compile --warnings-as-errors)
2. Atom vs string key mismatch?
3. Missing preload on association?
4. Nil being passed where value expected?
5. Conn/socket not returned from handler?
6. Read the error message LITERALLY — what does it actually say?

If the quick check finds it, report and stop. No need for parallel tracks on obvious bugs.

Investigation Tracks (Parallel)

Track 1: Reproduction Subagent

Objective: Understand how to reproduce the bug

Focus areas:

• Parse error messages, stack traces, logs
• Identify reproduction steps
• Create minimal test case
• Document environment factors

Prompt template:

You are investigating bug reproduction for: {bug_description}

Your task:
1. Analyze the error message and stack trace
2. Identify the exact conditions that trigger the bug
3. Document step-by-step reproduction instructions
4. Create a minimal test case that demonstrates the issue
5. Note any environment-specific factors (Elixir version, deps, config)

Available information:
{error_message}
{stack_trace}
{user_reported_steps}

Report actionable findings — what to change and where. Skip background the synthesis step already has.

Output format:
## Reproduction Analysis
…

Track 2: Root Cause Subagent

Objective: Find the actual bug location and why it happens

Focus areas:

• Trace stack trace to source
• Analyze the problematic code
• Understand data flow leading to bug
• Identify the specific failure point

Prompt template:

You are investigating root cause for: {bug_description}

Your task:
1. Trace the stack trace to find the failing code
2. Read and analyze the relevant source files
3. Build a call tree showing how data flows to the failure point
4. Identify WHY the code fails (not just WHERE)
5. Check recent git changes to the affected files

Stack trace:
{stack_trace}

Use patterns from the `trace` skill to trace the call path.
Apply its controller, LiveView, worker, and internal tracing procedures directly
when needed. Do not spawn `call-tracer` from this nested track; doing so would
create an unsupported depth-4 chain when `call-tracer` fans out again.

Report actionable findings — what to change and where. Skip background the synthesis step already has.
…

Track 3: Impact Assessment Subagent

Objective: Determine scope and severity of the bug

Focus areas:

• Who/what is affected
• How often does it occur
• What's the blast radius
• Are there workarounds

Prompt template:

You are assessing impact for: {bug_description}

Your task:
1. Find all entry points that can trigger this bug (use call-tracer patterns)
2. Estimate user/feature impact
3. Check logs/metrics for occurrence frequency (if available)
4. Identify any workarounds users might use
5. Determine severity rating

Bug location: {root_cause_location}

Report actionable findings — what to change and where. Skip background the synthesis step already has.

Output format:
## Impact Assessment
### Affected Entry Points
### User Impact
### Frequency (if determinable)
…

Track 4: Fix Strategy Subagent

Objective: Propose solution and implementation plan

Focus areas:

• How to fix the bug
• Similar patterns in codebase
• Test coverage needed
• Potential regressions

Prompt template:

You are designing fix strategy for: {bug_description}

Your task:
1. Search codebase for similar patterns that handle this correctly
2. Design a fix that follows existing conventions
3. Identify what tests need to be added/updated
4. Check for potential regressions from the fix
5. Estimate complexity of the fix

Bug location: {root_cause_location}
Root cause: {root_cause_explanation}

Report actionable findings — what to change and where. Skip background the synthesis step already has.

Output format:
## Fix Strategy
### Recommended Fix
code example
…

Orchestration Process

Phase 1: Initial Context Gathering

Before spawning subagents, gather basic context:

# Get error details if not provided
tail -200 log/dev.log | grep -A 10 -B 5 "error\|Error\|exception"

# Check recent changes
git log --oneline -10

# Verify compilation
mix compile --warnings-as-errors 2>&1 | head -50