PromptOrix

The difference between developers who get real value from ChatGPT and those who get frustrating results is almost entirely about how they write prompts. Generic requests produce generic code. Specific prompts that include the right context produce output that is closer to production-ready.

These 30+ prompts cover every major coding task: writing new code, debugging, code review, refactoring, documentation, working with APIs, and explaining concepts. Each prompt includes the specific context fields that make it work.

The Coding Context Opener

Run this at the start of any coding session to set the baseline context. It significantly improves the relevance of every response that follows.

I am a [junior / mid-level / senior] developer working primarily in [language(s)].
Current project: [brief description].
Tech stack: [list key frameworks, libraries, databases].
Constraints to keep in mind: [e.g., no external libraries unless necessary, must support Python 3.9+, legacy codebase, etc.]
Code style preferences: [e.g., functional over OOP where possible, descriptive variable names, always include error handling].
When you write code:
- Include comments explaining non-obvious logic
- Flag any assumptions you are making
- Note any edge cases I should handle
- If there is a simpler approach than what I asked for, suggest it.

Writing Code Prompts

Prompt 1: Function or method

Write a [language] function that [describe what it does].
Input: [describe input parameters and their types]
Expected output: [describe what it should return]
Edge cases to handle: [list any, e.g., empty input, null values, negative numbers]
Constraints: [e.g., must run in O(n) time, no recursion, must be pure function]
Include: docstring/comments, type hints if applicable, and an example usage.
Do not use: [any libraries or approaches to avoid]

Prompt 2: Class or component

Write a [language] class for [describe the purpose].
The class should:
- Handle: [list core responsibilities]
- Expose these public methods: [list methods with brief descriptions]
- Store these properties: [list state the class needs to maintain]
Include:
- Constructor with appropriate defaults
- Input validation where relevant
- Error handling
- Brief docstring for the class and each public method
Do not include: [anything to exclude, e.g., persistence logic, unnecessary abstractions]

Prompt 3: Script for a specific task

Write a [language] script that [describe the task].
Input source: [file / API / stdin / database / etc.]
Output destination: [file / stdout / database / API call / etc.]
The script should:
- Handle errors gracefully and log them clearly
- Accept [any command-line arguments or configuration]
- Not hardcode any credentials or file paths (use environment variables or config)
Expected to run: [once / on a schedule / triggered by X]
Include a brief usage comment at the top of the file.

Prompt 4: SQL query

Write a SQL query for [database: PostgreSQL / MySQL / SQLite / etc.].
What I need: [describe what the query should return]
Tables involved: [list table names and key columns]
Conditions: [describe any filters, date ranges, or constraints]
Sorting and limits: [describe if relevant]
If the query will be slow on large tables, suggest how to optimise it and what indexes would help.

Debugging Prompts

Prompt 5: Debug an error

I am getting this error: [paste error message]
Here is the code where it occurs: [paste relevant code]
Language and version: [e.g., Python 3.11, Node 20]
What I was trying to do: [describe the intent]
What I have already tried: [describe any fixes you attempted]
Find the bug, explain why it is happening, and give me the corrected code.

Prompt 6: Unexpected behaviour (no error message)

My code runs without errors but produces unexpected results.
Here is the code: [paste code]
What I expect it to do: [describe expected behaviour]
What it actually does: [describe actual behaviour]
Sample input that triggers the issue: [paste if possible]
Walk me through what the code is actually doing step by step, identify where it diverges from my intention, and fix it.

Prompt 7: Performance problem

This function is too slow on large inputs.
Here is the code: [paste code]
Current performance: [describe, e.g., "takes 30s on a list of 100,000 items"]
Target: [describe, e.g., "needs to run in under 2s"]
Constraints: [e.g., must remain pure Python, cannot use external libraries]
Identify the bottleneck, explain the time complexity of the current approach, and rewrite it to be faster. Show me the before and after complexity.

Code Review Prompts

Prompt 8: Full code review

Review this code as a senior [language] developer doing a pull request review.
Code: [paste code]
Context: [what this code does and how it fits into the larger system]
Review for:
1. Correctness: does it do what it is supposed to do?
2. Edge cases: what inputs or states could break it?
3. Security: any vulnerabilities or unsafe patterns?
4. Performance: any obvious inefficiencies?
5. Readability: is it clear what it does and why?
6. Style: does it follow [language] conventions?
Format your feedback as: [Issue] - [Why it matters] - [Suggested fix]

Prompt 9: Security-focused review

Review this code specifically for security vulnerabilities.
Code: [paste code]
Context: [where this code runs, e.g., backend API, user-facing form handler, database query builder]
Check for:
- Injection vulnerabilities (SQL, command, template)
- Authentication or authorization issues
- Unsafe handling of user input
- Insecure data storage or transmission
- Exposed secrets or credentials
- Any OWASP Top 10 issues
Rate the severity of each finding (Critical / High / Medium / Low) and give a specific fix for each.

Refactoring Prompts

Prompt 10: Refactor for readability

Refactor this code to make it more readable without changing its behaviour.
Code: [paste code]
Specific issues I notice: [list what you think is unclear, e.g., confusing variable names, deeply nested logic, magic numbers]
Keep: [anything that must not change, e.g., function signatures, external API compatibility]
Show me the refactored version with a brief note on each change you made and why.

Prompt 11: Break down a large function

This function is too long and does too many things.
Code: [paste code]
Break it down into smaller, single-responsibility functions.
Rules:
- Each function should do exactly one thing
- All function names should describe what they do clearly
- The original logic and output must be preserved exactly
Show the refactored code and explain the responsibility of each new function.

Prompt 12: Modernise old code

Modernise this [language] code to use current best practices and syntax.
Code: [paste code]
Current version: [e.g., Python 2.7, ES5, Java 8]
Target version: [e.g., Python 3.12, ES2022, Java 17]
Keep: [anything to preserve, e.g., same public API, same database schema]
List each modernisation you make and why it is an improvement.

Documentation Prompts

Prompt 13: Write docstrings or comments

Write docstrings and inline comments for this code.
Code: [paste code]
Docstring format: [e.g., Google style, NumPy style, JSDoc, Javadoc]
For each function include: what it does, parameters with types, return value, and any exceptions it raises.
For inline comments: only comment non-obvious logic. Do not comment things that are clear from the code itself.

Prompt 14: Write a README

Write a README.md for this project.
Project name: [name]
What it does: [describe in one sentence]
Who it is for: [describe the intended user]
Here is the key code or structure: [paste or describe]
Include:
- Brief description
- Prerequisites and installation steps
- Usage with at least one concrete example
- Configuration options (if any)
- How to run tests
- Contributing guidelines (brief)
Format in clean Markdown with appropriate headers.

Explanation and Learning Prompts

Prompt 15: Explain what this code does

Explain what this code does, line by line if necessary.
Code: [paste code]
My experience level: [junior / learning / unfamiliar with this pattern]
Explain:
1. What the code does overall (1-2 sentences)
2. Each significant block or function, in plain English
3. Any patterns or design choices being used and why they are used
4. Any parts I should be cautious about or that have non-obvious behaviour

Prompt 16: Teach a concept with code

Teach me [concept, e.g., closures in JavaScript / dependency injection / async/await patterns].
My current understanding: [describe what you know]
Use:
- A simple plain English explanation first
- A minimal code example that isolates the concept
- A slightly more realistic example showing when you would actually use this
- A common mistake developers make with this concept and how to avoid it
Language: [specify]. Keep it focused on this one concept, do not introduce unrelated ideas.

API and Integration Prompts

Prompt 17: Write API integration code

Write code to integrate with [API name].
Language: [specify]
What I need to do: [describe the specific operation, e.g., "fetch all orders created in the last 7 days"]
Authentication method: [e.g., API key in header, OAuth2, Bearer token]
Relevant endpoint: [paste the endpoint URL and any docs if available]
Include:
- Authentication setup
- The API call with proper error handling
- Parsing the response into a usable format
- Rate limiting or retry logic if the API requires it
Do not hardcode credentials. Use environment variables.

Prompt 18: Understand an API response

Help me understand and work with this API response.
Response JSON: [paste the JSON]
What I am trying to extract: [describe the data you need]
Write code to:
1. Parse this response correctly
2. Extract [the specific fields I need]
3. Handle cases where the expected fields are missing or null
Language: [specify]

Testing Prompts

Prompt 19: Write unit tests

Write unit tests for this function.
Code: [paste function]
Testing framework: [e.g., pytest, Jest, JUnit, RSpec]
Test for:
- Normal inputs and expected outputs
- Edge cases: empty input, null/None values, boundary values
- Invalid inputs that should raise exceptions
- Any side effects the function should or should not have
Use descriptive test names that explain what each test is verifying.
Mock any external dependencies.

Prompt 20: Find untested edge cases

Here are my existing tests for this function: [paste tests]
Here is the function being tested: [paste function]
What edge cases am I missing?
Specifically look for:
- Inputs I have not considered
- Concurrent or async scenarios (if applicable)
- Dependency failures I have not mocked
- State changes that could affect other tests
Write the missing test cases using [testing framework].

Common Mistakes When Using ChatGPT for Coding

Not providing enough context

The most common reason ChatGPT produces code that does not quite fit is insufficient context about the codebase, constraints, and environment. A prompt that specifies the language version, the existing patterns in the codebase, what the code must or must not depend on, and the specific edge cases to handle produces dramatically better results than a bare description of the task.

Treating first-output code as production-ready

ChatGPT-generated code should be treated as a strong first draft, not finished code. Always review it against your specific requirements, check it handles your actual edge cases, and run it through your test suite before committing. The model can produce plausible-looking code that fails in non-obvious ways, particularly on complex business logic or security-sensitive operations.

Not asking for explanations

If you do not understand the code ChatGPT wrote, ask it to explain. Understanding what the code does and why is more valuable than just having code that works. Use the explanation prompts in this guide to turn AI-generated code into a learning opportunity. A codebase full of code you do not understand is a long-term maintenance liability regardless of how it was produced.

Frequently Asked Questions

Is ChatGPT or GitHub Copilot better for coding?

They serve different purposes. GitHub Copilot is better for inline autocomplete as you type: it sees your code context in real time and suggests completions without breaking your flow. ChatGPT is better for longer conversations about code: explaining what something does, designing a new component, debugging a complex problem, or reviewing an entire file. The most productive setup uses both: Copilot for day-to-day coding and ChatGPT for the thinking and review work that surrounds it.

Is Claude better than ChatGPT for coding?

Both are strong. ChatGPT has a slight ecosystem edge with more coding-specific custom GPTs and tighter integration with developer tools. Claude tends to produce more thorough and well-explained code, which makes it stronger for learning, code review, and understanding unfamiliar codebases. See our Claude vs ChatGPT guide for a full comparison including coding.

Can I use ChatGPT for code at work without security concerns?

Check your organisation’s AI policy before pasting any code that contains proprietary logic, sensitive data, or customer information. ChatGPT conversations are used by OpenAI for safety purposes by default, though you can turn off training data sharing in Settings. ChatGPT Team and Enterprise plans offer stronger data privacy guarantees if your organisation requires them. Never paste credentials, API keys, or personally identifiable data into any AI chat interface.

More Prompt Resources

For the broader techniques behind these coding prompts, including chain-of-thought for complex logic and few-shot examples for pattern-matching, our prompt engineering techniques guide covers every major method. For prompts beyond coding, the ChatGPT prompt mega-list covers writing, marketing, business, and more across 100+ use cases. And for general tips on getting better results from ChatGPT across all tasks, our how to use ChatGPT effectively guide covers the core habits and techniques.

More copy-paste prompt guides for developers and teams at Promptorix.