12 Best Coding Prompts
for ChatGPT, Claude & Gemini

Perform a thorough code review. Analyze the following code against these criteria: 1. **Correctness** – Logic errors, edge cases, possible exceptions 2. **Security** – OWASP Top 10, injection, insecure dependencies 3. **Performance** – Unnecessary operations, memory leaks, N+1 problems 4. **Readability** – Naming, comments, complexity 5. **Testability** – Coupling, mocking difficulties For each finding: severity (Critical / Medium / Low), explanation, and concrete fix suggestion. ``` [[SELECTED_TEXT]] ```

Analyze the following code and the described misbehavior: **Error/Symptom:** [[ERROR_DESCRIPTION]] **Expected behavior:** [[EXPECTED_BEHAVIOR]] **Language/Framework:** [[LANGUAGE]] ``` [[SELECTED_TEXT]] ``` Proceed as follows: 1. Identify the root cause 2. Explain why the error occurs 3. Show the corrected code 4. Name measures to prevent similar bugs in the future

Refactor the following code according to SOLID principles and Clean Code guidelines: ``` [[SELECTED_TEXT]] ``` Address each step: - **S** – Single Responsibility: separate concerns where needed - **O** – Open/Closed: enable extension without modification - **L** – Liskov: ensure substitutability of subclasses - **I** – Interface Segregation: no fat interfaces - **D** – Dependency Inversion: depend on abstractions Show the refactored code and explain each change.

Generate a comprehensive unit test suite for the following code: ``` [[SELECTED_TEXT]] ``` **Testing framework:** [[FRAMEWORK]] (e.g. Jest, pytest, JUnit) **Language:** [[LANGUAGE]] Requirements: - Cover all public methods and edge cases - Include happy path, error path, and boundary tests - Use descriptive test names following the "should... when..." pattern - Add a brief comment explaining the intent of each test group - Mock external dependencies where appropriate

Perform a security audit on the following code, focused on the OWASP Top 10: ``` [[SELECTED_TEXT]] ``` **Language/Framework:** [[LANGUAGE]] **Context:** [[CONTEXT]] (e.g. public API, internal tool, handles user auth) For each vulnerability found: 1. Map it to the relevant OWASP category 2. Rate severity: Critical / High / Medium / Low 3. Explain the attack vector and potential impact 4. Provide the remediated code snippet

Analyze and optimize the following code for performance: ``` [[SELECTED_TEXT]] ``` **Language/Runtime:** [[LANGUAGE]] **Expected scale:** [[SCALE]] (e.g. 1M records, 10k concurrent users) Analyze: 1. Time complexity – identify O(n²) or worse operations 2. Space complexity – unnecessary allocations or data copies 3. I/O & network – blocking calls, N+1 queries, missing caching 4. Language-specific – idiomatic optimizations for [[LANGUAGE]] Provide the optimized version with inline comments explaining each change.

Write a production-ready function with the following specification: **Task:** [[TASK_DESCRIPTION]] **Language/Framework:** [[LANGUAGE]] **Input:** [[INPUT_DESCRIPTION]] **Output:** [[OUTPUT_DESCRIPTION]] **Constraints:** [[CONSTRAINTS]] Requirements: - Full error handling and input validation - Cover all edge cases - JSDoc/docstring with param and return types - Add inline comments for non-obvious logic - Follow [[LANGUAGE]] best practices and naming conventions

Generate comprehensive API documentation for the following code: ``` [[SELECTED_TEXT]] ``` **Format:** [[FORMAT]] (e.g. OpenAPI/Swagger YAML, Markdown, JSDoc) **Audience:** [[AUDIENCE]] (e.g. external developers, internal team) Include for each endpoint/function: - Description and purpose - Parameters: name, type, required/optional, description - Return value: type and structure - Error codes and their meaning - One realistic usage example with code - Authentication requirements (if applicable)

Optimize the following SQL query for performance: ```sql [[SELECTED_TEXT]] ``` **Database:** [[DATABASE]] (e.g. PostgreSQL 15, MySQL 8, SQLite) **Approximate row counts:** [[TABLE_SIZES]] **Current execution time (if known):** [[CURRENT_TIME]] Analyze: 1. Missing or inefficient indexes 2. N+1 or redundant subqueries 3. Unnecessary full table scans 4. Join order and type improvements Provide the optimized query and explain each change.

Conduct an architecture review of the following codebase/design: **System description:** [[SYSTEM_DESCRIPTION]] **Tech stack:** [[TECH_STACK]] **Current scale:** [[CURRENT_SCALE]] **Target scale (12 months):** [[TARGET_SCALE]] ``` [[SELECTED_TEXT]] ``` Evaluate: 1. Separation of concerns and layering 2. Coupling and cohesion 3. Scalability bottlenecks 4. Single points of failure 5. Observability and debuggability 6. Security surface area Rate each area (Good / Needs Work / Critical) and provide concrete improvement suggestions.

Port the following code from [[SOURCE_LANGUAGE]] to [[TARGET_LANGUAGE]]: ``` [[SELECTED_TEXT]] ``` Requirements: - Use idiomatic [[TARGET_LANGUAGE]] — do not just translate syntax literally - Replace dependencies with the most common [[TARGET_LANGUAGE]] equivalents - Preserve identical behavior and edge-case handling - Add a migration note for any behavior differences - Follow [[TARGET_LANGUAGE]] naming conventions and style guide

Recommend the most suitable design pattern for the following problem and implement it: **Problem description:** [[PROBLEM_DESCRIPTION]] **Language:** [[LANGUAGE]] **Constraints:** [[CONSTRAINTS]] 1. Identify 2–3 candidate patterns and briefly explain each 2. Recommend the best fit and justify why 3. Implement the recommended pattern for this specific problem 4. Explain the trade-offs: what you gain and what you give up 5. Describe when you would choose a different pattern instead