AI Prompts for Developers

Copy-paste AI prompts for coding, debugging, code review, documentation, and technical problem-solving.

Who These Prompts Are For

Software developers, engineers, and technical professionals who use AI to write, debug, review, and document code.

How to Use These Prompts

Copy any prompt and paste it into ChatGPT, Claude, DeepSeek, or another AI tool. Replace the brackets [ ] with your specific details.

Code Writing Prompts

Write a function:

Write a [language] function that [describe what it should do].
Input: [describe parameters and types]
Output: [describe what it should return]
Edge cases to handle: [list them]
Include: a docstring and inline comments for non-obvious logic.

Write a complete feature:

Write [language] code for [feature description].
Context: [brief description of the codebase/framework]
Requirements:
- [requirement 1]
- [requirement 2]
- [requirement 3]
Follow [framework/style guide] conventions.
Include error handling for [specific scenarios].

Convert between languages:

Convert this [source language] code to [target language]:
[paste code]
Maintain the same logic and behavior.
Use idiomatic [target language] patterns — don't just translate syntax.
Note any differences in behavior between the two versions.

Debugging Prompts

Fix an error:

I have a bug in my [language] code.
Error message: [paste full error and stack trace]
Relevant code: [paste the function or block]
Expected behavior: [what it should do]
Actual behavior: [what it does]

1. Identify the cause of the error.
2. Explain why it's happening.
3. Provide a corrected version.
4. Note any other issues you see.

Debug a logic error:

My [language] code runs without errors but produces wrong output.
Code: [paste code]
Input: [test input]
Expected output: [what it should produce]
Actual output: [what it produces]
Walk through the logic step by step to find where it goes wrong.

Code Review Prompts

Review a function:

Review this [language] function for bugs, edge cases, and improvements.
[paste function]
Check for:
1. Logic errors or off-by-one mistakes
2. Unhandled edge cases (null, empty, boundary values)
3. Performance issues
4. Security concerns (if applicable)
5. Readability improvements
For each issue: describe the problem, risk level, and fix.

Security review:

Review this [language] code for security vulnerabilities.
[paste code]
Check for: SQL injection, XSS, authentication issues, insecure data handling, 
and any OWASP Top 10 concerns relevant to this code type.
For each issue found: severity, description, and recommended fix.

Testing Prompts

Write unit tests:

Write unit tests for this [language] function using [testing framework].
[paste function]
Include tests for:
- Happy path (normal input)
- Edge cases (empty, null, boundary values)
- Error cases (invalid input, expected exceptions)
Use descriptive test names. Add a brief comment per test explaining the scenario.

Generate test cases:

Generate test cases (inputs and expected outputs) for a function that [describe what it does].
Include: typical inputs, boundary conditions, invalid inputs, and edge cases.
Format as a table: input | expected output | test scenario description.

Documentation Prompts

Write a docstring:

Write a [Google style / NumPy / JSDoc] docstring for this [language] function:
[paste function]
Include: one-line summary, parameters (name, type, description), 
return value, exceptions raised, and a usage example.

Write a README section:

Write the [Installation / Usage / API Reference / Contributing] section 
of a README for this project.
Project: [brief description]
Tech stack: [languages and frameworks]
[Add relevant details for the section]
Format as clean Markdown.

Explanation Prompts

Explain code:

Explain what this [language] code does in plain language.
[paste code]
Explain it to someone who knows programming but isn't familiar with [framework/pattern].
Cover: what it does, how it works step by step, and any non-obvious patterns used.

Explain a concept:

Explain [programming concept / pattern / algorithm] with:
1. A plain-language definition (1-2 sentences)
2. When to use it (and when not to)
3. A simple code example in [language]
4. Common mistakes or misunderstandings