How to Use ChatGPT for Coding

Write a {{language}} function that {{function_description}}.

Requirements:
- Input: {{input_description}}
- Output: {{output_description}}
- Handle edge cases: empty input, null values, invalid types
- Add JSDoc/docstring with parameter descriptions and return type
- Time complexity should be O({{complexity}}) or better
- Include 3 usage examples with expected output as comments

Do not use external libraries unless absolutely necessary. If you do, explain why the standard library isn't sufficient.

I have a bug in my {{language}} code. Here's the situation:

**Code:**
```{{language}}
{{code_snippet}}
```

**Expected behavior:** {{expected}}
**Actual behavior:** {{actual}}
**Error message (if any):** {{error}}

Please:
1. Identify the root cause (not just the symptom)
2. Explain WHY this bug occurs — what misconception or oversight led to it
3. Provide the minimal fix (change as few lines as possible)
4. Show the corrected code with the fix highlighted in a comment
5. Suggest a defensive coding pattern that would prevent this class of bug in the future

Review the following {{language}} code as a senior developer would:

```{{language}}
{{code_to_review}}
```

Context: This code {{code_context}}.

Review for:
1. **Bugs** — Any logic errors, race conditions, or edge cases not handled
2. **Security** — SQL injection, XSS, auth bypasses, data exposure, input validation gaps
3. **Performance** — Unnecessary computations, N+1 queries, memory leaks, missing caching opportunities
4. **Readability** — Unclear naming, overly complex logic, missing comments on non-obvious code
5. **Best practices** — {{framework}} conventions, SOLID principles, DRY violations

For each issue found, rate severity (critical / warning / suggestion) and provide the exact fix. If the code is solid, say so — don't manufacture issues.

Refactor the following {{language}} code to improve {{refactoring_goal}}:

```{{language}}
{{code_to_refactor}}
```

Constraints:
- Do NOT change the external API/interface (same inputs and outputs)
- Preserve all existing functionality and edge case handling
- Break the refactoring into numbered steps — show each step's change separately
- After each step, briefly explain what improved and what tradeoff (if any) was made
- The final version should pass all existing tests without modification

Show a before/after comparison for the most significant change. If the code is already well-structured and refactoring would be marginal, say so and suggest what would be worth changing if the codebase grows.

Write comprehensive documentation for the following {{language}} code:

```{{language}}
{{code_to_document}}
```

Generate:
1. **Overview** — What this code does in 2-3 sentences (non-technical summary)
2. **API Reference** — Every public function/method with:
   - Description
   - Parameters (name, type, required/optional, description)
   - Return value (type and description)
   - Throws/errors (what conditions trigger errors)
   - Example usage
3. **Architecture notes** — Key design decisions and why they were made
4. **Dependencies** — What this code depends on and why
5. **Common pitfalls** — Mistakes developers might make when using this code

Format as {{doc_format}}. Write for a developer who has never seen this code before.

Write tests for the following {{language}} code using {{test_framework}}:

```{{language}}
{{code_to_test}}
```

Generate test cases covering:
1. **Happy path** — Normal expected inputs and outputs (at least 3 cases)
2. **Edge cases** — Empty inputs, boundary values, maximum sizes, Unicode, special characters
3. **Error cases** — Invalid inputs, null/undefined, wrong types, network failures
4. **Integration** — If this code interacts with external services, mock them and test the integration points

For each test:
- Use descriptive test names that read like sentences ("should return empty array when no items match filter")
- Add a brief comment explaining WHY this case matters
- Group related tests with describe/context blocks
- Include setup and teardown if needed

Aim for {{coverage_target}}% code coverage. Flag any code that's untestable and suggest how to refactor it for testability.