AI Coding Assistant Prompts

Complete the following {{language}} function based on the surrounding context.

File: {{file_path}}
Project: {{project_description}}

Existing code:
{{surrounding_code}}

Function to complete:
{{function_signature}}

Requirements:
- Follow the coding style and patterns visible in the surrounding code
- Use the same libraries/imports already present in the file
- Include proper error handling consistent with the project's approach
- Add inline comments only for non-obvious logic
- Do not modify any existing code — only fill in the function body

I am writing {{language}} code in a {{framework}} project. Suggest the next 3-5 lines of code based on what I have written so far.

Current file context:
{{current_code}}

Cursor position: after line {{line_number}}

Rules:
- Match the existing indentation and formatting style exactly
- Use variables and functions already defined in scope
- Prefer the simplest correct implementation
- If there are multiple valid approaches, pick the one most consistent with the existing code
- Return ONLY the suggested lines, no explanation

Explain the following {{language}} code to a {{audience_level}} developer.

{{code_block}}

Structure your explanation as:
1. **Purpose**: What does this code do in one sentence?
2. **How it works**: Walk through the logic step by step. For each significant line or block, explain what it does and why.
3. **Key concepts**: List any design patterns, algorithms, or language features used (e.g., closures, memoization, dependency injection)
4. **Potential issues**: Note any edge cases, performance concerns, or maintenance risks
5. **Usage example**: Show a brief example of how to call/use this code

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

Original code:
{{original_code}}

Constraints:
- Maintain the exact same external behavior (inputs and outputs must not change)
- Do not add new dependencies unless absolutely necessary
- Follow {{style_guide}} conventions

Provide:
1. The refactored code
2. A bullet list of every change made and why
3. Before/after comparison of any metrics that changed (lines of code, cyclomatic complexity, number of parameters)
4. Any risks or trade-offs introduced by the refactoring

Generate comprehensive tests for the following {{language}} code using {{test_framework}}.

{{code_to_test}}

Test coverage requirements:
1. Happy path: Test the primary expected behavior with typical inputs
2. Edge cases: Empty inputs, boundary values, maximum/minimum values
3. Error cases: Invalid inputs, null/undefined values, type mismatches
4. Integration points: Test interactions with dependencies (mock external calls)

For each test:
- Use descriptive test names that explain the scenario: "should [expected behavior] when [condition]"
- Follow the Arrange-Act-Assert pattern
- Include at least one assertion per test
- Add a brief comment explaining why each edge case matters

Generate at least {{min_tests}} tests.

Generate documentation for the following {{language}} code.

{{code_to_document}}

Documentation format: {{doc_format}}

For each public function/method/class, include:
- A one-line summary of what it does
- @param descriptions for all parameters with types and constraints
- @returns description with type and possible values
- @throws / @raises for all error conditions
- @example with a realistic usage example
- @since version (use {{version}})

For the module/file level:
- A brief overview of the module's purpose
- How it fits into the larger system
- Any prerequisites or setup required

Style: Write for a developer who has never seen this code before. Be precise, not verbose.