15 Coding Prompt Templates to Automate the Boring Stuff

Help me debug this issue by performing root cause analysis.

## The Problem
- **Error message**: {paste the error}
- **Expected behavior**: {what should happen}
- **Actual behavior**: {what actually happens}
- **Reproducibility**: {always / sometimes / rarely}

## Code Involved
{language}
{paste relevant code}


## Context
- **When it started**: {recent changes, deployments}
- **Environment**: {dev / staging / prod}
- **Dependencies**: {relevant libraries, services}
- **What I've tried**: {debugging steps already taken}

## Debugging Analysis Request

### 1. Error Interpretation
- Explain what this error means in plain terms
- What component/layer is likely responsible?

### 2. Hypothesis List
Generate 3-5 possible causes ranked by likelihood:
| Rank | Hypothesis | Evidence For | Evidence Against | Test |
|------|------------|--------------|------------------|------|

### 3. Debugging Steps
Provide step-by-step debugging instructions:
1. First, verify...
2. Then, check...
3. Add logging at...
4. Test with...

### 4. Solution Approaches
For the most likely cause:
- **Quick fix**: Immediate workaround
- **Proper fix**: Correct solution
- **Prevention**: How to avoid in future

### 5. Questions
What additional information would help narrow this down?

Create a refactoring plan for the following code.

## Current Code
{language}
{paste the code to refactor}


## Problems with Current Code
- {problem_1}
- {problem_2}
- {problem_3}

## Constraints
- **Test coverage**: {existing tests? / no tests?}
- **Breaking changes allowed**: {yes / no / with migration}
- **Time budget**: {quick cleanup / thorough refactor}
- **Performance requirements**: {any specific constraints}

## Refactoring Plan Request

### 1. Code Smell Identification
List specific issues:
| Smell | Location | Severity | Impact |
|-------|----------|----------|--------|

### 2. Refactoring Strategy
Recommend approach:
- **Pattern to apply**: {name the refactoring pattern}
- **Why this approach**: {brief justification}
- **Alternative considered**: {what else could work}

### 3. Step-by-Step Plan
Break down into safe, testable steps:
| Step | Change | Risk Level | Verification |
|------|--------|------------|--------------|

### 4. Refactored Code
Show the end result with comments explaining key changes:
{language}
// Show the refactored version


### 5. Before/After Comparison
| Aspect | Before | After |
|--------|--------|-------|
| Lines of code | | |
| Complexity | | |
| Testability | | |

### 6. Risk Assessment
- **What could go wrong**: Potential issues
- **Mitigation**: How to reduce risk
- **Rollback plan**: How to revert if needed

Act as a QA Automation Engineer. Write a comprehensive unit testing suite for the provided function using [Jest/PyTest/Mocha].
Ensure you cover:
- The happy path (standard expected inputs).
- Edge cases (null, undefined, extremely large numbers, empty strings).
- Expected exceptions and error throwing.
Include all necessary mock data or mocked external dependencies.

[INSERT CODE HERE]

Review the following code and generate comprehensive documentation.
Please provide:
1. A high-level overview suitable for a README.md (What it does, dependencies, how to run).
2. Detailed API documentation for every public function (Parameters, Return types, Throws).
3. The original code annotated with standard inline comments (e.g., JSDoc for JavaScript, Docstrings for Python) explaining complex logic blocks.

[INSERT CODE HERE]

Analyze the following code for performance bottlenecks.
1. Estimate the Time Complexity (Big-O) and Space Complexity.
2. Identify specific lines or loops causing inefficiencies (e.g., N+1 query problems, unmemoized expensive calculations).
3. Provide an optimized version of the code that reduces time or space complexity.

[INSERT CODE HERE]

Act as a Cybersecurity Expert. Perform a security audit on the following code snippet, checking against the OWASP Top 10 vulnerabilities.
Look specifically for: Injection (SQL/NoSQL), Cross-Site Scripting (XSS), Insecure Direct Object References (IDOR), and hardcoded secrets.
Report your findings with severity levels (Low, Medium, High, Critical) and provide secure remediation code for each finding.

[INSERT CODE HERE]

Evaluate the following API endpoint design (REST/GraphQL) for industry best practices.
Check for:
1. Correct HTTP method usage (GET, POST, PUT, PATCH, DELETE).
2. Proper RESTful naming conventions (nouns instead of verbs).
3. Pagination, filtering, and sorting standards.
4. Appropriate HTTP status code responses.
Suggest concrete improvements.

[INSERT ENDPOINT/SCHEMA HERE]

I am a junior developer trying to understand a legacy codebase. Explain the following code step-by-step in plain, accessible English.
Break down complex syntax (like regular expressions, bitwise operators, or nested ternaries). 
Summarize the ultimate goal of the function in one sentence before diving into the line-by-line breakdown.

[INSERT CODE HERE]

I need to update the dependencies in the following [package.json / requirements.txt / pom.xml].
Specifically, I am updating [LIBRARY A] from version [X] to [Y].
1. Identify any known breaking changes between these versions.
2. Highlight other dependencies that might conflict with this update.
3. Provide a step-by-step safe migration plan.

[INSERT DEPENDENCY FILE HERE]

Review the error handling in the following code.
Identify instances of "swallowed" errors, generic try-catch blocks, or missing fallback logic.
Refactor the code to:
1. Use custom Error classes.
2. Implement proper logging strategies for external monitoring tools.
3. Ensure the application fails gracefully without crashing.

[INSERT CODE HERE]

I need to migrate the following component/function from [SOURCE TECH] to [TARGET TECH] (e.g., Vue 2 to React, or JavaScript to TypeScript).
1. Translate the code idiomatically (do not just write [SOURCE TECH] syntax in [TARGET TECH]).
2. Explain the key conceptual differences between the two versions.
3. Highlight any modern features of [TARGET TECH] utilized in the new code.

[INSERT CODE HERE]

Based on the following git diff, generate a clear, professional Pull Request description.
Use this format:
### Summary (1-2 sentences)
### What Changed (Bullet points)
### Why it Changed (The problem being solved)
### How to Test (Step-by-step instructions for the reviewer)

[INSERT GIT DIFF HERE]

Draft an Architecture Decision Record (ADR) based on the following context:
Decision: We are choosing [TECH/APPROACH A] over [TECH/APPROACH B].
Reasoning Context: [INSERT BRIEF REASONING HERE]
Format the output using standard ADR markdown:
- Title & Date
- Status
- Context
- Decision
- Consequences (Pros and Cons)

[INSERT CONTEXT HERE]

Analyze this code for "Code Smells" (e.g., duplicated code, long methods, large classes, deeply nested callbacks, excessive parameters).
For every smell detected:
1. Name the smell.
2. Give it a severity score (1-10).
3. Explain why it is an anti-pattern.
4. Provide a refactored code snippet that resolves it.

[INSERT CODE HERE]