AI Prompts for Debugging

I have a {{language}} application ({{framework}}, version {{version}}) that is throwing the following error:

```
{{error_message}}
```

Full stack trace:
```
{{stack_trace}}
```

The relevant code around the failure point:
```
{{code}}
```

Please:
1. Explain what this error means in plain language
2. Identify the originating frame vs. propagated frames in the stack trace
3. Highlight which frames are my code vs. library/framework code
4. Provide the root cause — not just the symptom
5. Suggest 2-3 fixes ranked by risk (least invasive first)
6. Explain if this error could be masking a deeper issue

Analyze the following application logs from my {{service_name}} service. The issue started at approximately {{incident_time}} and the symptom is {{observed_symptom}}.

Logs (last {{time_window}}):
```
{{logs}}
```

Please:
1. Identify any anomalous patterns, spikes, or error clusters
2. Find the first occurrence of unusual behavior — this is likely closer to the root cause than the most recent error
3. Correlate timestamps across different log entries to establish a sequence of events
4. Highlight any log entries that suggest resource exhaustion (connections, memory, file handles, threads)
5. Note any entries that stopped appearing when they should be recurring
6. Provide a timeline reconstruction: what happened in what order, and what likely caused it

A feature that was working in {{previous_version}} is now broken in {{current_version}}. The expected behavior is: {{expected_behavior}}. The actual behavior is: {{actual_behavior}}.

Here is the diff of changes between the two versions:
```diff
{{diff}}
```

The affected code path:
```
{{affected_code}}
```

Please:
1. Identify which change(s) in the diff most likely caused the regression
2. Explain the causal chain — how the change leads to the broken behavior
3. Check for subtle side effects: shared state mutations, changed return types, altered event ordering
4. Determine if this is a direct regression (the change broke it) or an indirect one (the change exposed a pre-existing bug)
5. Suggest a minimal fix that restores the expected behavior without reverting the entire change
6. Recommend a test case that would have caught this regression

My {{language}} application ({{runtime_environment}}) is experiencing increasing memory usage over time. Current behavior: {{memory_symptoms}}.

The suspected area of code:
```
{{code}}
```

Application context:
- The service handles: {{workload_description}}
- Memory grows by approximately {{growth_rate}} over {{time_period}}
- The issue {{does_or_does_not}} occur under low traffic

Please analyze for:
1. Object references that prevent garbage collection (closures capturing large objects, circular references, event listeners never removed)
2. Collections that grow unbounded (caches without eviction, arrays that only append)
3. Resource handles not being released (DB connections, file handles, timers, subscriptions)
4. Scope issues where variables outlive their intended lifetime
5. Framework-specific leak patterns for {{framework}}

For each potential leak, explain the accumulation mechanism and provide a fix. If you need heap snapshot data to confirm, describe exactly what I should capture.

I have a concurrency bug in my {{language}} application. The behavior is non-deterministic: {{intermittent_behavior}}.

The code involved in the concurrent operation:
```
{{code}}
```

Concurrency model: {{concurrency_model}} (e.g., threads, async/await, goroutines, actors)
Shared resources: {{shared_resources}}

Please:
1. Identify all shared mutable state accessed by concurrent operations
2. Map out the possible interleavings that could lead to the observed bug
3. Check for classic race condition patterns: check-then-act, read-modify-write, double-checked locking
4. Identify any operations that appear atomic but are not (e.g., compound operations on a HashMap)
5. Suggest a fix using the appropriate synchronization primitive for this language and concurrency model
6. Explain whether the fix could introduce deadlock risk and how to avoid it

An integration between {{service_a}} and {{service_b}} is failing. The communication happens via {{protocol}} (e.g., REST, gRPC, message queue, WebSocket).

Error or unexpected response:
```
{{error_or_response}}
```

Request that was sent:
```
{{request}}
```

Expected response:
```
{{expected_response}}
```

Recent changes: {{recent_changes}}

Please diagnose by checking:
1. **Contract mismatch** — Has the API schema, field naming, or data type changed on either side?
2. **Serialization issues** — JSON/protobuf encoding differences, date formats, null vs. missing fields
3. **Authentication/authorization** — Expired tokens, changed scopes, rotated keys
4. **Network layer** — Timeouts, DNS resolution, TLS certificate issues, proxy or firewall changes
5. **Ordering and timing** — Messages arriving out of order, race between service startup and first request
6. **Environment drift** — Config differences between environments that worked and the one that doesn't

Provide a step-by-step debugging plan I can execute, starting with the most likely cause.