Code

Bug Triage & Fix Plan (5 Approaches + Ranking)

Bug debugging

What does this prompt do?

It guides the model to triage and resolve a bug with a structured, evidence-driven workflow. It produces exactly five distinct investigation and mitigation approaches, each with a clear hypothesis, the precise system areas to inspect, the specific logs/metrics/traces or SQL to collect, and an ordered checklist to confirm or falsify the hypothesis. It then ranks the approaches by fastest path to high-confidence resolution (including blast-radius and data-integrity risk) and performs a second-pass cross-comparison with scenario playbooks (e.g., PROD outage, data corruption risk, flaky issues) to refine the recommended path and output the first 10 concrete actions. By forcing explicit assumptions when context is incomplete, it reduces guesswork and lowers hallucination risk while keeping the plan executable.

The Prompt

Act as a [enter your role].

Description:
[enter your description]

Bug context:
- Title:
- Symptoms (expected vs actual):
- Repro steps (best known):
- Frequency/impact (users, severity, business impact):
- Environment(s) (DEV/ACC/PROD), region, feature flags:
- Stack + relevant modules/services:
- Recent changes (deploys, config, migrations, toggles):
- Observations (logs/metrics/traces/errors/screenshots):
- Constraints (time, rollback policy, data loss tolerance):

Rules:
- Do not ask me questions. If information is missing, state explicit assumptions and proceed.
- Provide exactly 5 DISTINCT investigation/mitigation approaches (not minor variants).
- Be concrete and action-oriented. No generic debugging theory.
- Prefer highest-signal actions first.

Task:
1) For each approach, include:
   - Hypothesis: likely root-cause class + why
   - Where to look: exact components/files/queries/system areas to inspect
   - Data to collect: specific logs/metrics/trace attributes, correlation IDs, SQL queries, dashboards
   - Steps: ordered checklist to confirm/falsify the hypothesis
   - Fix strategy: code/config/DB change, including rollback plan
   - Ops: containment steps, observability improvements, and regression tests to add
   - Risk: blast radius, data integrity, and regression risk
   - Effort: S/M/L

2) Rank the 5 approaches from #1 (best first move) to #5 (least optimal).
   For each rank, provide:
   - Primary justification
   - Key trade-offs
   - Risk assessment (speed vs certainty vs safety)

3) Second pass (iteration):
   - Cross-comparison: how the approaches overlap and what evidence would switch you from #1 to #2/#3
   - Scenario playbook:
     - PROD outage / high severity → recommended path + immediate containment steps
     - Silent data corruption risk → recommended path + safeguards
     - Flaky/intermittent bug → recommended path + instrumentation plan
   - Final refined recommendation: choose the initial path, define decision checkpoints, and list the first 10 concrete actions

Output format:
Bug Triage & Resolution Plan for 
Approach 1..5 (same headings for each)
Ranking & Justification
Second Pass
Final Refined Recommendation
Assumptions
Copied to clipboard!

How to Use This Prompt

  1. Copy the prompt using the button above
  2. Open your preferred AI tool (ChatGPT, Claude, etc.)
  3. Paste the prompt and customize the fields in [] as you needed
  4. Hope it finds the cause

Related Prompts

CODE
Feature

Refactor Plan + Safety Net (Incremental Steps + Tests)

Turns a messy module into a staged refactor plan that preserves behavior. It identifies seams, proposes an incremental sequence of changes with checkpoints, defines the tests and characterization coverage needed to prevent regressions, and includes rollback/feature-flag guidance for safe delivery. Best for legacy code, large components, and “we need to clean this up without breaking prod”.

Zero-shot Role-based Structured-output Analytical
CODE
code-review

PR Review + Fix Plan (Concrete Edits + Tests)

Reviews a code change like a senior engineer before merge. It finds correctness issues, edge cases, API contract problems, performance pitfalls, and security/privacy risks, then outputs an ordered fix plan with concrete code edits (pseudo diff), a targeted test plan, and a safe rollout and monitoring checklist. The “assumptions and proceed” rule keeps it moving even if context is incomplete, while staying specific and implementation ready.

Zero-shot Role-based Structured-output Analytical
CODE

Feature devlopment Blueprint (5 Approaches + Ranking)

It forces the model to produce an implementation-ready plan for a feature by generating exactly five distinct approaches, each with concrete architecture, code structure, and database design (including keys and indexes). It then ranks the approaches with explicit trade-offs and risks and runs a second-pass cross-comparison to refine the final recommendation under different scenarios. The “state assumptions and proceed” rule reduces vague back-and-forth and makes uncertainty explicit, which lowers hallucination risk and pushes the output toward actionable, verifiable engineering decisions.

Zero-shot Role-based Structured-output Analytical