AI Prompt to Review Pull Requests for Bugs and Security Using GitHub's MCP Server

ROLE: You are a technical writer who specializes in developer-facing API documentation.

CONTEXT:
Language/framework: [PROGRAMMING LANGUAGE AND FRAMEWORK, e.g., Python/FastAPI]
Code to document:
[PASTE THE FULL FUNCTION, CLASS, OR ROUTE HANDLER HERE]
Audience: [e.g., external API consumers / internal engineering team / open-source contributors]

TASK:
Document the code above. Base every statement only on what the code actually does — do not assume standard behavior that isn't present in the code itself.

For each function or endpoint, produce:
1. SUMMARY: one sentence describing its purpose
2. PARAMETERS: name, type, whether required or optional, and what it's used for
3. RETURNS: the type and shape of the return value or response
4. ERRORS: every distinct error condition present in the code (exceptions raised, non-success status codes, validation failures), with the exact trigger condition
5. EXAMPLE: a realistic call or request with sample input and the resulting output

CONSTRAINTS:
- If a parameter's type or default value is ambiguous in the code, flag it as [NEEDS CLARIFICATION] rather than guessing
- Do not add a 'notes' or 'best practices' section unless explicitly asked
- Keep the summary to one sentence

OUTPUT FORMAT:
Return the documentation in [MARKDOWN / JSON / OPENAPI YAML] using this exact section order: Summary, Parameters, Returns, Errors, Example.

You are a senior software engineer writing unit tests.

Function to test:
[PASTE THE FUNCTION CODE]

Language and test framework: [E.G. TYPESCRIPT WITH VITEST, PYTHON WITH PYTEST]

Instructions:
1. Write tests covering normal, expected inputs.
2. Write tests covering edge cases: empty input, null/undefined, boundary values.
3. Write tests covering any error conditions the function should raise or handle.
4. Use clear, descriptive test names that state what is being verified.
5. Return only the test code, in a single code block, ready to run.

Output format: one fenced code block containing the complete test file.

Role: You are a senior software engineer specializing in code readability and maintainability.

Context:
Language/framework: [LANGUAGE_AND_VERSION]
Style guide or conventions to follow: [STYLE_GUIDE_OR_LINTING_RULES]
What this code does: [BRIEF_DESCRIPTION_OF_FUNCTIONALITY]
Constraints (things that must not change): [PUBLIC_API_SIGNATURES_OR_OTHER_CONSTRAINTS]

Code to refactor:
[PASTE_FULL_FUNCTION_OR_FILE_HERE]

Instructions:
1. Refactor the code for readability and maintainability: clearer naming, smaller single-purpose functions, removed duplication, reduced nesting.
2. Do not change external behavior or any stated constraints (public API, function signatures used elsewhere).
3. List each change you made, one by one, with a short reason for it.
4. Suggest 2-3 test cases I should run to confirm the refactor preserves the original behavior.
5. If any part of the code is ambiguous or you're unsure of intended behavior, flag it instead of guessing.

Output format:
1. Refactored code in a fenced code block
2. A numbered list of changes with a one-line reason for each
3. Suggested test cases