رمزگشای Stack Trace: هر خطایی را Paste کنید، علت ریشه‌ای و راه حل را در چند ثانیه دریافت کنید

The Prompt

I'm debugging an error. Please help me understand what went wrong and how to fix it.

**Error message:**
[PASTE ERROR MESSAGE HERE]

**Stack trace:**
[PASTE FULL STACK TRACE HERE]

**Relevant code (the function/file where the error originates):**
```
[PASTE CODE HERE]
```

**Context:**
- Language/runtime: [e.g. Python 3.11, Node.js 22, Go 1.22]
- What I was trying to do when the error occurred: [one sentence]
- What I've already tried: [or "nothing yet"]

Please provide:
1. **Root cause** — explain in plain language what actually went wrong and why
2. **The fix** — show the corrected code with inline comments explaining the change
3. **Why this happened** — the underlying mechanism or misconception that caused the bug, so I understand it rather than just copying the fix
4. **Prevention** — one sentence on how to avoid this class of error in the future

How to Use It

Copy the template above. Fill in the four sections — error message, stack trace, code, and context. The more complete the stack trace, the better the diagnosis. You don't need to edit or clean it up; paste it raw.

The context section is optional but worth filling in. "What I was trying to do" helps the model understand intent. "What I've already tried" prevents it from suggesting things you've already ruled out.

What You Get Back

The four-part response structure is designed specifically to avoid the two most common failure modes of AI debugging help:

• The blind fix — giving you corrected code without explaining why the original was wrong. You apply it, it works, but you don't understand it and hit the same pattern in a different file next week.
• The vague diagnosis — "it looks like there might be a null reference issue." No specifics, no fix, no path forward.

The structured output forces specificity: root cause first (what is actually broken), then the fix with inline comments (not just a code dump), then the mechanism (the why behind the why), then prevention (a rule you can internalize).

Works Across Languages

This prompt is language-agnostic. It works well with:

• Python — great for tracebacks, import errors, type errors, async/await issues
• JavaScript / TypeScript — handles Node.js errors, browser console exceptions, TypeScript compiler errors
• Go — runtime panics, goroutine stack traces, interface assertion failures
• Java / Kotlin — NullPointerException chains, JVM stack traces, Spring context errors
• Rust — compiler error messages (which are already detailed but still benefit from explanation)
• SQL — query parse errors, constraint violations, deadlock traces from PostgreSQL/MySQL

For compiled languages where the stack trace is less informative, paste the full compiler output along with the error.

Example Input and Output

Input (simplified):

Error message: TypeError: Cannot read properties of undefined (reading 'map')

Stack trace:
  at ProductList (ProductList.jsx:14:22)
  at renderWithHooks (react-dom.development.js:14985:18)

Relevant code:
function ProductList({ products }) {
  return (
    <ul>
      {products.map(p => <li key={p.id}>{p.name}</li>)}
    </ul>
  );
}

Context: React 18, Node 22. Trying to render a list fetched from an API.

What a good response looks like:

• Root cause: products is undefined when the component first renders, before the API response arrives. .map() can't run on undefined.
• Fix: Add a default value — function ProductList({ products = [] }) — or add a null guard before the map.
• Why this happened: React renders synchronously before async data fetches resolve. The component renders with whatever initial value the parent passes, which is undefined if the parent hasn't set an initial state yet.
• Prevention: Always initialize list props with a default empty array and handle loading/empty states explicitly in the component.

Tips for Better Results

• Paste the full stack trace, not just the top line. Lower frames often reveal the actual call that triggered the error.
• Include the immediate surrounding code, not just the line that errored. A few lines of context above and below matter.
• If the error is intermittent, say so — the model will consider race conditions and timing issues.
• For TypeScript errors, include the tsconfig.json relevant settings if the error is about strictness or module resolution.