Twenty prompts for the code you actually write — debugging with real root-cause analysis, senior-level code review, tests, regex, and docs your teammates will read.
💡 Tired of copy-pasting? Import this whole pack into PromptDock and insert any prompt by typing // inside ChatGPT, Claude, Gemini & 7 more AI chats. Free, no account, stored on your device.
Explain this error like I'm mid-level, not a beginner: what it actually means, the 3 most likely root causes ranked by probability for this stack, and the fastest way to confirm which one it is. Then give the fix.
Error:
Relevant code:
Find the bug in this function
Here's a function that's producing {{wrong behavior}} instead of {{expected behavior}}. Walk through it line by line, identify the bug, explain why it causes this specific symptom, and give the corrected version. Don't rewrite the whole thing — minimal change.
Code:
Rubber-duck a problem I'm stuck on
I'm stuck on {{problem}}. Here's what I've tried and what happened each time: {{attempts}}. Ask me the clarifying questions a senior engineer would ask before suggesting anything, then give your best hypothesis for what's actually going wrong.
Reproduce and isolate a flaky bug
This bug happens intermittently: {{description}}. Help me design a way to reproduce it reliably — what to log, what conditions to vary, and a minimal test harness to isolate whether it's timing, state, concurrency, or environment.
Code Review & Quality
Review this code like a senior engineer
Review this code the way a senior engineer would in a PR: correctness bugs first, then edge cases not handled, then security/perf concerns, then readability. Be specific with line references. Skip nitpicks unless they matter.
Code:
Refactor for readability
Refactor this code to be more readable without changing behavior: better names, smaller functions where it helps, remove duplication, and add comments only where the 'why' isn't obvious. Explain each change briefly.
Code:
Spot security issues
Audit this code for security issues: injection, auth/authorization gaps, unsafe input handling, secrets in code, and dependency risks. For each finding, rate severity and give the concrete fix.
Code:
Simplify overly complex code
This code works but feels over-engineered. Suggest a simpler approach that does the same thing, explain the tradeoff you're making, and flag anything I'd lose by simplifying (flexibility, perf, etc).
Code:
Writing Code
Write unit tests for this function
Write unit tests for this function covering: the happy path, edge cases (empty, null, boundary values), and failure modes. Use {{test framework}}. Name each test so the intent is obvious from the name alone.
Code:
Generate a regex with explanation
Write a regex that matches {{pattern description}} and doesn't match {{counter-examples}}. Give the regex, a plain-English breakdown of each part, and 3 test strings showing matches and non-matches. Flavor: {{JS / Python / PCRE}}.
Convert code between languages
Convert this code from {{source language}} to {{target language}}. Keep it idiomatic to the target language (not a literal translation), preserve behavior, and note any spot where the languages differ enough that behavior could subtly change.
Code:
Write a script for a one-off task
Write a {{language}} script that {{task}}. Handle the obvious error cases, print clear progress output, and add a comment at the top explaining how to run it and what args it takes. Keep it a single file.
Understanding Code
Explain what this code does
Explain what this code does at two levels: a one-paragraph summary of its purpose, then a step-by-step walkthrough of the logic. Call out anything surprising, clever, or potentially buggy.
Code:
Understand an unfamiliar codebase area
I'm new to this codebase and looking at {{file/module}}. Based on this code, explain: what it's responsible for, what it depends on, what depends on it (as far as you can tell), and the 2-3 things I should be careful changing.
Code:
Turn requirements into a technical plan
Here's a feature request: {{requirement}}. Break it into a technical plan: the components/files likely involved, the order to build them, edge cases to decide on up front, and the riskiest part to prototype first. Ask me anything ambiguous before planning.
Docs & Communication
Write a clear docstring / function doc
Write documentation for this function: a one-line summary, params with types and meaning, return value, exceptions/errors it can throw, and one short usage example. Match {{docstring style}}.
Code:
Write a README for this project
Write a README for this project: what it does and who it's for, quick-start install/run steps, a minimal usage example, config/env vars, and a troubleshooting section for the 2-3 most likely setup problems.
Project details:
Write a clear pull request description
Write a PR description from this diff/summary: what changed and why, how to test it, anything reviewers should pay special attention to, and any follow-up work intentionally left out of scope.
Changes:
Explain a technical decision to non-engineers
Explain {{technical decision/tradeoff}} to a non-technical stakeholder ({{PM / manager / client}}): what we're choosing, why, what it costs, and what it buys us — in plain language, with an analogy if it helps, no jargon.
Write a commit message
Write a clear commit message for these changes following conventional-commits style: a concise summary line, and a body explaining the why (not just the what) if the change isn't trivial.
Changes:
Tips
Give it the error AND the code, not just one. Most debugging prompts fail because the model is guessing at context — paste the stack trace and the relevant function together.
Ask it to explain before it fixes. Making the model state the root cause first catches wrong-but-plausible fixes before you paste them into your codebase.
Save your review, test, and docstring prompts in PromptDock. These are the prompts you run on every PR — insert them with // instead of retyping the same instructions each time, with {{variables}} for framework and style.
Insert these with two keystrokes instead of copy-paste
Download the pack, import it once into PromptDock, and every prompt above is // away inside ChatGPT, Claude, Gemini and 7 more — with fill-in-the-blank {{variables}} that ask for the specifics as they insert.
No — treat generated code as a strong draft, not gospel. These prompts are structured to make it explain its reasoning so you can catch mistakes, and you should always review and test before shipping.
Do these work with Claude, Copilot, and Gemini too?
Yes. The prompts are model-agnostic. PromptDock lets you insert them by typing // inside ChatGPT, Claude, Gemini, Copilot and more, so you can reuse the same prompt across whatever you code with.
Should I paste proprietary code into ChatGPT?
Check your company's policy first. For sensitive code, strip identifiers/secrets, use a minimal reproduction, or use an approved enterprise instance. The prompts work the same on a sanitized snippet.