Copy-paste prompts for the work you actually do — debugging, code review, refactoring, writing tests, regex and SQL. Language-agnostic and battle-tested. Works with ChatGPT, Claude, Gemini and Copilot. No signup — just tap Copy.
An LLM is only as good as the instructions you give it. Vague prompts like "fix my code" get you a confident, plausible-looking wrong answer. Each prompt below gives the model a role, forces it to reason before answering, and pins down the exact output you want — so you get something you can actually paste into your editor. Swap the [brackets] for your code and go.
Find the real bug — not the one that looks obvious.
Best for: bugs where the fix isn't obvious and you've been staring too long.
You are a senior engineer pair-programming with me. Before suggesting any fix, walk through the code below line by line and explain in plain English what it actually does — including edge cases and what happens with empty, null, or unexpected inputs. THEN state the specific bug, why it happens, and the minimal fix. Do not rewrite the whole thing; give me the smallest diff that solves it. CODE: [paste your code] EXPECTED behavior: [what should happen] ACTUAL behavior: [what happens instead, plus any error message]
Best for: cryptic errors from a framework or dependency you don't fully know.
Explain this error to me like I'm a competent developer who just doesn't know this specific library. Break down: (1) what the error message literally means, (2) the 3 most common root causes ranked by likelihood, (3) exactly what to check or print to confirm which one it is, and (4) the fix for each. Be concrete — reference the actual line/symbol names in the trace. ERROR / STACK TRACE: [paste it here] CONTEXT: [language, framework, what you were doing]
Best for: intermittent bugs that only happen sometimes.
I have a bug that only reproduces intermittently. Act as a debugging specialist. Based on the description below, list the usual suspects for non-deterministic behavior — race conditions, uninitialized state, ordering assumptions, time/timezone, caching, floating-point, network flakiness — and for each, tell me how to quickly rule it in or out. End with the single most likely cause given my stack and the cheapest experiment to confirm it. WHAT HAPPENS: [describe the flaky behavior] STACK: [language, concurrency model, environment]
This page is a taster. The Ultimate AI Prompt Vault gives you 68 battle-tested, categorized prompts — with fill-in-the-blank variables and usage notes — covering coding, debugging, writing, marketing, sales and research. One download, yours forever.
Get the Vault — $7 → Instant download · Use code JULY25 for 25% off · 100% money-back guaranteeGet a second pair of eyes that never gets tired or polite.
Best for: catching issues before your teammate does in the PR.
Review the code below as a strict but constructive senior reviewer. Organize your feedback into: 🔴 Bugs / correctness issues, 🟠 Security or data-safety concerns, 🟡 Readability & maintainability, 🟢 Nice-to-haves. For each point, quote the specific line, explain why it matters, and show the corrected version. Skip praise and style nitpicks a linter would catch — focus on what a human reviewer must catch. CODE: [paste your code]
Best for: cleaning up a function you're afraid to touch.
Refactor the function below for readability and maintainability WITHOUT changing its observable behavior. Keep the same inputs, outputs, and side effects. Explain each change and why it's safe. Call out any place where you're unsure the behavior is identical so I can add a test there first. Preserve existing naming conventions and the language's idioms. CODE: [paste your code]
Best for: inheriting code with zero comments and no author around.
I inherited this code with no documentation. Explain it to me at three levels: (1) a one-paragraph summary of what it does and why it probably exists, (2) a section-by-section walkthrough of the logic, and (3) a list of hidden assumptions, gotchas, or things that would break if I changed them. Flag anything that looks like a bug or a workaround for a bug. CODE: [paste your code]
Best for: optimizing without guessing where the cost is.
Analyze the code below for performance. First, tell me the actual time/space complexity of the hot path and where the real cost is — don't micro-optimize things that don't matter. Then propose the single highest-impact change, show the optimized version, and state the new complexity. If the bottleneck is likely I/O, database, or network rather than CPU, say so and point me to the right fix instead. CODE: [paste your code] CONTEXT: [rough input size, how often it runs]
Write the tests you keep meaning to write.
Best for: covering the edge cases, not just the happy path.
Write a thorough set of unit tests for the function below using [test framework — e.g. pytest / Jest / JUnit]. Cover: the happy path, boundary values, empty/null/zero inputs, invalid inputs, and any edge case implied by the logic. Name each test so it reads as a sentence describing the behavior. List any case you think should be tested but can't, and why. CODE: [paste your function]
Best for: making sure a bug you just fixed never comes back.
I just fixed the bug described below. Write a focused regression test in [framework] that would have FAILED before the fix and PASSES after it. Include a comment explaining what the bug was so a future reader understands why this test exists. Keep it minimal and deterministic — no reliance on real time, network, or random values. THE BUG: [describe what was broken] THE FIX: [describe or paste the corrected code]
Best for: QA-ing a feature before you ship it.
Act as a QA engineer. Given the feature description below, produce a test plan as a table: Scenario, Steps, Expected result, Priority. Cover functional cases, edge cases, error handling, permissions/auth, and at least 3 "what could go wrong" scenarios a developer would overlook. Mark which ones are worth automating vs checking manually once. FEATURE: [describe what it does and who uses it]
The two things everyone Googles ten times a week.
Best for: getting a correct query and understanding why it's correct.
Write a SQL query for [database — e.g. PostgreSQL / MySQL / SQLite] that does the following: [describe what you want]. My relevant tables and columns are: [paste schema or describe]. Give me the query, then explain each clause in one line, note any assumptions about the data, and warn me about anything that could make it slow at scale (missing index, N+1, full scan). Show a faster alternative if one exists.
Best for: a query that works but crawls on real data.
This SQL query is slow. Act as a database performance expert. Explain likely reasons it's slow, what to look for in the EXPLAIN/EXPLAIN ANALYZE output, which indexes would help (and their trade-offs), and a rewritten version if the query itself can be improved. Assume [rough row counts] and [database engine]. QUERY: [paste your query] SCHEMA / INDEXES: [what exists now]
Best for: matching a pattern without 30 minutes of trial and error.
Write a regular expression for [flavor — e.g. JavaScript / PCRE / Python re] that matches: [describe exactly what should match]. It should match these examples: [list valid strings] and NOT match these: [list invalid strings]. Give me the regex, a plain-English breakdown of each part, and a warning about any edge case it doesn't handle. If regex is the wrong tool here, tell me what to use instead.
The parts of the job that aren't typing code.
Best for: docstrings and comments that explain why, not just what.
Add documentation to the code below in the idiomatic style for [language] (e.g. JSDoc / Google-style docstrings / rustdoc). Document what it does, each parameter and return value, what it throws/errors on, and — most importantly — any non-obvious why behind the logic. Don't restate the obvious ("increments i by 1"). Keep it concise enough that a busy dev will actually read it.
CODE:
[paste your code]
Best for: an open-source repo or internal tool that needs onboarding.
Write a clear README for the project described below. Sections: one-line description, the problem it solves, quick-start (install + minimal working example), key features, configuration, and common gotchas. Lead with a copy-pasteable example that works in under 60 seconds. Skip filler and badges spam. Tone: helpful senior dev explaining it to a new teammate. PROJECT: [what it is, language, how it's used]
Best for: choosing an approach before you commit a week to it.
I'm deciding how to build [describe the feature or system]. My leading approach is [your plan]. Act as a pragmatic staff engineer. Give me: the 3 biggest risks or failure modes of this approach, one simpler alternative I might be over-engineering past, the scaling/maintenance cost I'm underestimating, and the one question I should answer before writing any code. Be direct — I want the flaws, not reassurance.
The Ultimate AI Prompt Vault: 68 categorized, ready-to-run prompts for coding, debugging, writing, marketing, sales and research — each with fill-in-the-blank variables so you never start from a blank prompt again. Built by a developer who uses them daily.
Get the Vault — $7 → Instant download · Code JULY25 = 25% off · Money-back guaranteeAI coding assistants are fast, confident, and sometimes confidently wrong. The trick to trusting the output is structuring the prompt so the model has to reason before it answers. Every prompt on this page does that: it assigns a role ("act as a senior reviewer"), forces a step ("explain what the code does before fixing it"), and specifies the output format. That's why they surface the real problem instead of a plausible-looking guess.
Yes. None of these are ChatGPT-specific — they're plain-language instructions, so they work in ChatGPT (GPT-4o / GPT-4.1), Claude, Gemini, GitHub Copilot Chat, and local models like Llama or Qwen. Paste your code where the brackets are and run.
Always paste the real code and the real error, and tell the model what you expected versus what happened. "My function is broken" gets you a lecture. "Here's the function, here's the input, I expected X and got Y" gets you the bug. The more concrete context you give, the less the model has to hallucinate — and hallucination is where AI coding tools cost you time instead of saving it.
Treat AI output like a pull request from a talented but overconfident junior: read it, run it, test it. The prompts here are designed to make that verification easier — asking the model to flag its own uncertainty, show minimal diffs, and explain its reasoning — but the final git commit is still on you.
These 15 cover the situations most developers hit weekly. If you'd rather not rewrite prompts every time — and want the same quality across debugging, architecture, writing and research — the Ultimate AI Prompt Vault packs 68 of them into one organized download with variables and notes. Less than the price of lunch, and it pays for itself the first time it saves you an afternoon.
← 50 more free ChatGPT prompts for everyday work, writing & code · Prompts for business → · Prompts for marketing →