AI Prompts for Coding: Debug, Refactor, and Ship Faster

I am getting this error in my [language/framework] project:

[paste the full error message and stack trace]

Here is the relevant code:

[paste the code]

My environment: [language version, OS, package versions]

Explain the root cause. Then show the fix with code.

This [language] function should [expected behavior].
Instead, it [actual behavior].

Here is the function:
[paste code]

Here is a failing test case:
Input: [specific input]
Expected output: [what you expect]
Actual output: [what you get]

Walk through the logic step by step.
Identify where the logic diverges from expected behavior.
Show the corrected code.

This [language] function handles [describe operation].
It processes [data size] and takes [current time].
I need it under [target time].

Here is the code:
[paste code]

Identify performance bottlenecks.
Explain the Big-O complexity of each bottleneck.
Show an optimized version with better time complexity.
Explain the tradeoffs of your optimization.

Review this [language] code for security vulnerabilities:

[paste code]

Check specifically for:
- SQL injection
- XSS vulnerabilities
- Authentication bypasses
- Insecure data handling
- Hardcoded secrets
- Input validation gaps

Rate each finding as CRITICAL, HIGH, MEDIUM, or LOW.
Show the vulnerable line and the fix for each issue.

Review this [language] code for performance issues:

[paste code]

This code runs in [context: API endpoint, batch job, etc].
Expected load: [requests per second or data volume].

Identify:
- Unnecessary allocations
- N+1 query problems
- Missing caching opportunities
- Inefficient algorithms
- Blocking operations that could be async

Prioritize findings by impact.

Review this [language] code for readability and maintainability:

[paste code]

Check for:
- Unclear variable or function names
- Functions that do too many things
- Deep nesting that could be flattened
- Missing error handling
- Magic numbers or hardcoded values
- Violations of [your style guide, e.g., PEP 8, Airbnb]

Suggest specific improvements with refactored code snippets.

Here is a legacy [language] function that has grown too complex:

[paste code]

This function currently handles [list responsibilities].
It is [line count] lines long.

Refactor it following the Single Responsibility Principle.
Break it into smaller, focused functions.
Preserve the existing behavior exactly.
Add clear function names that describe intent.
Show the complete refactored code.

Here is [language] code that [describe the problem]:

[paste code]

This code suffers from [tight coupling / code duplication / etc].
Suggest an appropriate design pattern to improve it.
Explain why that pattern fits this situation.
Show the refactored code using that pattern.
Keep the implementation practical, not over-engineered.

Extract the [specific logic] from this function into
a separate, reusable utility function:

[paste code]

Requirements:
- Pure function with no side effects
- Clear parameter names and return type
- Add type annotations for [language]
- Include a brief docstring

Write unit tests for this [language] function:

[paste code]

Use [testing framework, e.g., Jest, pytest, JUnit].
Cover these scenarios:
- Happy path with valid inputs
- Edge cases (empty input, null, boundary values)
- Error cases (invalid input, exceptions)
- Type edge cases for [language]

Use descriptive test names that explain the scenario.
Follow the Arrange-Act-Assert pattern.
Aim for 90%+ code coverage of this function.

Write integration tests for this [language] API endpoint:

[paste route handler code]

This endpoint:
- Method: [GET/POST/PUT/DELETE]
- Accepts: [request body schema]
- Returns: [response schema]
- Requires: [authentication type]

Test scenarios:
- Successful request with valid data
- Validation errors with invalid data
- Authentication failures
- Database errors (mock the database layer)
- Rate limiting behavior

Use [testing framework]. Mock external dependencies.

Here is a [language] function:

[paste code]

Identify edge cases I might have missed.
For each edge case:
- Describe the scenario
- Show the input that triggers it
- Explain what currently happens
- Explain what should happen
- Write a test that covers it

Think about: null values, empty collections,
concurrent access, integer overflow, Unicode strings,
timezone issues, and off-by-one errors.

Generate a REST API endpoint in [language/framework]:

Endpoint: [HTTP method] [path]
Purpose: [what it does]
Request body: [schema with types]
Response: [success and error response schemas]

Include:
- Input validation with clear error messages
- Error handling with appropriate HTTP status codes
- Authentication middleware check
- Rate limiting decorator
- TypeScript/type annotations
- Brief inline comments for complex logic

Follow [framework] best practices.

Generate a [React/Vue/Svelte] component in TypeScript:

Component: [name]
Purpose: [what it renders and does]
Props: [list with types]
State: [internal state needed]

Include:
- Proper TypeScript interfaces for props
- Loading and error states
- Accessibility attributes (ARIA labels, roles)
- Responsive design considerations
- Event handlers with proper typing

Use [hooks/composition API/etc] patterns.
Do not use any CSS framework. Use CSS modules.

Design a database schema for [feature description]:

Requirements:
[list business requirements]

Database: [PostgreSQL/MySQL/MongoDB]

Include:
- Table definitions with column types
- Primary and foreign key constraints
- Indexes for common query patterns
- Created/updated timestamp columns
- Migration SQL statements
- Brief comments explaining design decisions

Follow normalization best practices.
Explain any intentional denormalization choices.

Generate a README.md for this project:

Project name: [name]
Purpose: [one sentence description]
Tech stack: [languages, frameworks, tools]

Here is the project structure:
[paste directory tree]

Here is the main entry point:
[paste key file]

Include sections for:
- Project overview (2-3 sentences)
- Prerequisites and installation
- Environment variable setup
- Running locally
- Running tests
- Project structure explanation
- Contributing guidelines
- License

Generate API documentation for these endpoints:

[paste route definitions or handler code]

For each endpoint, document:
- HTTP method and path
- Purpose (one sentence)
- Request headers required
- Request body schema with types and examples
- Success response with example
- Error responses with status codes
- Authentication requirements
- Rate limits if applicable

Use a clean markdown table format.
Include curl examples for each endpoint.

Add clear inline comments to this [language] code:

[paste code]

Rules for comments:
- Explain WHY, not WHAT
- Do not comment obvious code
- Comment complex algorithms and business logic
- Add JSDoc/docstring for public functions
- Note any non-obvious side effects
- Flag potential gotchas for future developers

Return the complete code with comments added.

Explain this [language] code to me:

[paste code]

I am a [junior/mid/senior] developer.
I am familiar with [languages you know].
I am NOT familiar with [specific concepts].

Explain:
- What this code does at a high level
- How it works line by line
- Why it is written this way
- What design patterns it uses
- What would break if specific parts changed

Compare these two approaches for [specific task] in [language]:

Approach A: [describe or paste code]
Approach B: [describe or paste code]

Compare them on:
- Readability
- Performance (time and space complexity)
- Maintainability
- Error handling
- Testability
- When to prefer each approach

Give a clear recommendation for [my specific context].

Explain [concept] to me as a [language] developer.

I understand [related concepts you know].
I do NOT understand [specific confusion].

Use concrete code examples in [language].
Start simple. Build to advanced usage.
Show a real-world scenario where this matters.
Include common mistakes developers make with [concept].