This is a collection of ready-made coding prompts for the tasks developers face every day: writing code, debugging, code review, explaining someone else's logic, tests, refactoring, SQL, and regular expressions. Each prompt is a separate block: copy it, paste your code into the square brackets, and send it to the model. But first, a quick look at what makes a strong request — and which model to pick for which task.
What a Good Coding Prompt Looks Like
Compare two requests. "Write a sort function" — and the model returns a textbook example with no error handling. "Write a Python function that sorts a list of dicts by the price key, puts entries with price = None at the end, and doesn't mutate the input list. Add type hints and a usage example" — and you get code you can drop into a project.
The difference comes down to four elements every strong coding prompt is built from:
- Action — write, find a bug, review, explain, cover with tests, refactor.
- Context — language, version, framework, environment, what the code should do in the project.
- Constraints — no external dependencies, keep the public API, stay within O(n log n).
- Answer format — "code only", "code plus a line-by-line explanation", "a list of changes with reasons".
This structure is a special case of general prompting rules: you'll find a detailed breakdown with examples in our prompt engineering guide. Now, the templates themselves.
Which Model to Pick for Which Task
The prompt is half the result; the model is the other half. A quick map of the GPTunneL catalog:
- Claude Fable 5 and Opus 5 — complex work: legacy refactoring, architecture decisions, large codebases. A context window of up to 1M tokens fits a whole module together with its tests. More on the Claude page.
- GPT-5.3 Codex — the coding branch of GPT: confidently drives multi-step tasks like "design → write → fix per review". Available in the ChatGPT chat alongside the regular versions.
- Qwen3 Coder — fast drafts and boilerplate for pennies: CRUD, parsers, scripts. When you need a working skeleton rather than perfect architecture, start with Qwen.
- DeepSeek V4 — tests, code explanations, error analysis: cheap enough to run dozens of requests in a row. See the DeepSeek page.
We compared models on real tasks — frontend, backend, legacy, debugging — in a separate article: 7 Best AI Models for Coding. And the whole point of GPTunneL is that all models live in one chat: you can run the same prompt through two or three of them and compare the answers.
Prompts for Writing Code
Write a function in [language] that [what it does]. Input: [example]. Expected output: [example]. Handle edge cases: empty input, wrong type. Add type hints and a docstring.
Act as a senior [language/framework] developer. Design and write a [module/class] for [task]. Constraints: [no external dependencies / compatible with version X]. Show the plan first, then the code.
Write a REST endpoint in [framework]: [method and path], accepts [parameters], returns [format]. Add input validation and error handling with proper HTTP status codes.
Write a script in [language] that [routine task: rename files, parse a CSV, call an API]. The script must survive failures on individual items and print a summary at the end: how many processed, how many skipped.
Prompts for Debugging and Bug Hunting
Here is the code and the error message. Code: [code]. Error: [stack trace]. Explain the cause, propose a fix, and show how to reproduce the problem with a minimal example.
The function should [expected behavior], but instead it [actual behavior]. Here is the code: [code]. Find the bug, explain why it shows up in this exact case, and propose a fix with a minimal diff.
Analyze this code for common problems: race conditions, resource leaks, unhandled exceptions, timezone and encoding issues. Code: [code]. List the findings in descending order of severity.
Prompts for Code Review
Review this code as a strict but friendly senior engineer. Code: [code]. Split your comments into three groups: blocking (bugs, security), important (readability, performance), and stylistic. Include a suggested fix for each.
Check this code for vulnerabilities: injections, XSS, unsafe deserialization, leaked secrets, missing validation. Code: [code]. For each finding, give the line, the attack scenario, and the fix.
Here is a diff: [diff]. Assess whether it breaks backward compatibility of the public API, and list the places that most urgently need test coverage.
Prompts for Explaining Someone Else's Code
Explain what this code does as if to a developer seeing the project for the first time: [code]. Start with one paragraph for the overall idea, then go line by line through the non-obvious parts. Give an example of input and output.
Here is a function from a legacy project: [code]. Reconstruct the business requirements from the code: what it was meant to do, which scenarios it handles, and which edge cases apparently caused trouble, judging by the code.
Explain how these two snippets differ and when each is preferable: [snippet 1] and [snippet 2]. Compare performance, readability, and resilience to errors.
Prompts for Tests
Write unit tests in [framework: pytest, Jest, JUnit] for this function: [code]. Cover the main scenario, edge cases, and error handling. Name the tests so it's clear from the name what each one checks.
Here is a function and a bug that was found in it: [code and bug description]. Write a regression test that fails on the current code and passes after the fix.
Draft a test plan for [module/feature]: a prioritized list of scenarios, which ones to cover with unit tests, which with integration tests, and which checks can be skipped entirely and why.
Prompts for Refactoring
Refactor this code without changing its behavior: [code]. Goals: remove duplication, split long functions, improve names. Keep the public API intact. Show the result plus a list of what changed and why.
Here is a class of [N] lines that does too much: [code]. Propose how to split it by the single responsibility principle: which classes to extract, what their public APIs become, and in what order to refactor without freezing development.
Simplify this function while keeping its signature and behavior on all tests: [code]. If you see a way to speed it up algorithmically, propose it as a separate option with complexity estimates before and after.
Prompts for SQL and Regular Expressions
Write a SQL query for [DBMS]: select [what] from tables [table schema]. Take [conditions] into account. Explain which indexes are needed for the query to stay fast at a million rows.
This SQL query is slow: [query + execution plan if available]. Propose an optimization: rewrite the query and/or suggest indexes. Explain why it will be faster.
Build a regular expression for [task: validate a format, extract data]. Strings that must match: [examples]. Strings that must not: [counterexamples]. Explain the expression part by part and point out the pitfalls.
Prompts for Documentation and Comments
Write a docstring in [Google/NumPy/JSDoc] style for this function: [code]. Briefly: what it does, parameters, return value, exceptions, and one usage example.
Write a README for this module: [code or description]. Structure: what it is and why, installation, a minimal example, typical scenarios, limitations. Write for a developer in a hurry.
Add comments to this code, but only where they're needed: non-obvious decisions, bug workarounds, important invariants. Code: [code]. Don't comment the obvious lines.
How to Get the Most Out of These Templates
- Split the task. A model will choke on a whole feature: plan first, then the skeleton, then module-by-module implementation. Verify each step before the next.
- Show real data. A sample API request and response tells the model more than a paragraph of description. For algorithms — a normal case, an edge case, and a large input.
- Iterate. If the result is almost right, don't rewrite the prompt from scratch: "remove the recursion", "add timeout handling", "rewrite as async".
- Ask for explanations. "Explain why" after generated code is cheap insurance against solutions you don't understand.
- Build a personal library. A prompt that worked well in your project will very likely work in the next one.
And above all: read and test generated code like a stranger's pull request. Models write just as confidently when they're wrong.
FAQ
Which AI model writes code best?
There's no universal answer: Claude Fable 5 and GPT-5.3 Codex are strong for complex refactoring and large codebases, while Qwen3 Coder or DeepSeek are more cost-effective for quick drafts. In GPTunneL they're all in one chat — run one prompt through several models and pick the best answer.
Do these prompts work for any programming language?
Yes, the templates aren't tied to a language — put yours in the square brackets. Models know Python, JavaScript/TypeScript, Java, Go, and C# most deeply; with rarer languages syntax slips are more common, so review more carefully.
Can I send production code to a model?
Only send what doesn't violate your NDA or company policy: strip secrets, keys, and personal data, and replace proprietary business logic with a simplified example — for bug hunting that's usually enough.
Is it safe to ship generated code to production?
Exactly as safe as code from a junior you've never met: review and tests are mandatory. Pay special attention to error handling, edge cases, and interactions with external systems — that's where models fail most often.
How is a coding prompt different from a regular one?
Format discipline: in coding prompts, precise context (language, version, framework), explicit constraints, and a required answer format do the heavy lifting. The general principles are the same — they're covered in the prompt engineering guide.
You can put these templates to work right now: open Claude in GPTunneL — top coding models in one chat, no subscriptions, one balance for all AI models, and you pay only for what you use. Copy a prompt, paste your code — and the first answer is a minute away.