Best Coding Prompts for Gemini (2026)

Perform a comprehensive code review of the following code.

Code to Review

{paste your code here}

Context

• Purpose of this code: {what it's supposed to do}
• Part of: {larger feature/system it belongs to}
• Languages/frameworks: {relevant technologies}

Review Categories

Evaluate the code in these areas:

1. Correctness

• Does it do what it's supposed to do?
• Are there logic errors or edge cases not handled?
• Are there potential runtime errors?

2. Security

• Input validation and sanitization
• Authentication/authorization issues
• Data exposure risks
• Injection vulnerabilities

3. Performance

• Inefficient algorithms or data structures
• Unnecessary computations or queries
• Memory leaks or excessive memory usage

4. Maintainability

• Code clarity and readability
• Function/variable naming
• Code duplication
• Proper abstraction levels

5. Testing

• Is the code testable?
• What tests should be written?
• Edge cases to cover

Output Format

For each issue found:

Severity	Category	Location	Issue	Suggestion
Critical/Major/Minor	Category	Line/Function	Description	How to fix

Then provide:

1. Summary: Overall assessment in 2-3 sentences
2. Top 3 priorities: What to fix first
3. Positive observations: What's done well

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

{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

{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:

// 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

Generate comprehensive tests for the following code.

Code to Test

{paste your code}

Testing Context

• Framework: {Jest / Pytest / JUnit / Mocha / etc.}
• Test type needed: {unit / integration / both}
• Mocking library: {if applicable}
• Existing test patterns: {describe style used in codebase}

What This Code Does

{brief description of functionality}

Test Generation Request

1. Test Plan Overview

Category	Test Cases	Priority

2. Happy Path Tests

Tests for normal, expected usage:

// Generated tests with descriptive names

3. Edge Cases

Edge Case	Why It Matters	Expected Behavior

// Edge case tests

4. Error Cases

Test error handling and failure modes:

// Error handling tests

5. Mock Setup

If external dependencies exist:

// Mock setup and helpers

6. Test Coverage Analysis

• Covered: What these tests verify
• Not covered: What additional tests might be needed
• Suggested test data: Example inputs to use

Generate documentation for the following code.

Code to Document

{paste your code}

Documentation Context

• Audience: {other developers / API consumers / end users}
• Documentation type needed: {README / API docs / inline / all}
• Existing doc style: {JSDoc / Sphinx / Markdown / etc.}

Documentation Request

1. Overview Section

Write a clear explanation of what this code does:

• Purpose: One-line summary
• Key features: Bullet list
• When to use: Use cases

2. API Documentation

For each public function/method/class:

/**
 * @description Clear explanation
 * @param {type} name - Description
 * @returns {type} Description
 * @throws {ErrorType} When this happens
 * @example
 * // Usage example
 */

3. Usage Examples

Provide practical examples:

// Basic usage
// Example 1: Common use case

// Advanced usage
// Example 2: With options/configuration

// Edge case handling
// Example 3: Error handling pattern

4. README Section

If this is a module/package:

• Installation instructions
• Quick start guide
• Configuration options
• Troubleshooting common issues

5. Inline Comments

Add comments to the original code where logic isn't obvious:

// Annotated version of the code

Analyze this code for performance issues and optimization opportunities.

Code to Analyze

{paste your code}

Performance Context

• Scale: {how much data / how many users}
• Current performance: {if known - response time, memory usage}
• Target performance: {requirements or goals}
• Hot path: {is this code called frequently?}

Analysis Request

1. Complexity Analysis

Function	Time Complexity	Space Complexity	Notes

2. Bottleneck Identification

Rank potential issues by impact:

Issue	Location	Severity	Explanation

3. Optimization Recommendations

Quick Wins (low effort, measurable impact):

Change	Expected Improvement	Implementation

Structural Improvements (higher effort, significant impact):

Change	Trade-offs	When to Consider

4. Optimized Code

Show optimized version with explanations:

// Optimized version with comments explaining changes

5. Benchmarking Suggestions

How to measure the improvement:

• What to measure
• How to set up benchmarks
• Expected results to validate

6. Trade-offs

Optimization	Benefit	Cost	Recommendation

Perform a security review of the following code.

Code to Review

{paste your code}

Security Context

• Application type: {web / API / CLI / mobile}
• Data sensitivity: {PII / financial / public / internal}
• Authentication: {how users are authenticated}
• Deployment: {cloud / on-prem / edge}

Security Review Request

1. Vulnerability Scan

Check for common vulnerabilities:

Category	Found	Severity	Location
Injection (SQL, NoSQL, Command)
XSS (Cross-Site Scripting)
CSRF (Cross-Site Request Forgery)
Authentication flaws
Authorization flaws
Sensitive data exposure
Security misconfiguration
Insecure dependencies

2. Detailed Findings

For each vulnerability found:

• Issue: What's wrong
• Risk: What could happen
• Proof of concept: How it could be exploited
• Fix: How to remediate
• Prevention: How to prevent similar issues

3. Secure Code Version

// Secured version with security comments

4. Security Checklist

Check	Status	Notes
Input validation
Output encoding
Authentication
Authorization
Data protection
Error handling
Logging

5. Recommendations

Prioritized security improvements beyond immediate fixes.

Review this API design for best practices and consistency.

API to Review

{paste your API definition or endpoint code}

API Context

• Type: {REST / GraphQL / gRPC}
• Consumers: {internal / public / partner}
• Versioning strategy: {URL / header / none}
• Authentication: {API key / OAuth / JWT}

Review Request

1. Naming Conventions

Endpoint/Field	Current	Suggestion	Reason

2. REST Best Practices

Principle	Status	Details
Resource naming
HTTP methods
Status codes
Pagination
Filtering/sorting
Error responses

3. Request/Response Design

• Consistency check: Are similar endpoints structured similarly?
• Field naming: camelCase / snake_case consistency
• Null handling: How are missing values represented?
• Date formats: ISO 8601 compliance

4. Suggested Improvements

Priority	Change	Before	After	Rationale

5. Documentation Recommendations

What should be documented for API consumers:

• Required headers
• Authentication flow
• Rate limiting
• Error codes and handling

6. Breaking Change Assessment

If changes are recommended:

• Which changes are breaking?
• Migration path for existing consumers
• Versioning recommendation

Explain the following code for a developer who needs to understand and maintain it.

Code to Explain

{paste your code}

Context Needed

• Why this exists: {what problem it solves}
• Who will read this: {junior dev / new team member / external contributor}
• Explain at level: {high-level overview / detailed walkthrough / line-by-line}

Explanation Request

1. Purpose Summary

In 2-3 sentences, what does this code accomplish?

2. Architecture Overview

• What are the main components/sections?
• How do they interact?
• What's the data flow?

3. Detailed Walkthrough

For each significant section: Section: [Name]

• What it does
• Why it's done this way
• Key decisions/trade-offs

4. Key Concepts

Explain any patterns, algorithms, or techniques used:

Concept	Where Used	Why

5. Dependencies & Side Effects

• External dependencies
• Global state access
• Side effects (I/O, mutations)
• Assumptions made

6. Gotchas & Edge Cases

Things someone maintaining this code should know:

• Non-obvious behavior
• Known limitations
• Things that might break

7. Related Code

What other code interacts with this? What should be read next?

Create a plan for updating dependencies in this project.

Current Dependencies

{paste your dependency file}

Update Context

• Urgency: {security patch / routine update / major version}
• Risk tolerance: {conservative / moderate / aggressive}
• Test coverage: {high / moderate / low}
• CI/CD: {automated testing available?}

Update Plan Request

1. Dependency Audit

Package	Current	Latest	Type	Risk Level
{List each dependency with update status}

2. Prioritization

Update immediately (security):

• Package: reason

Update soon (compatibility, features):

• Package: reason

Monitor (major version, breaking changes):

• Package: reason

3. Breaking Change Analysis

For major version updates:

Package	Breaking Changes	Impact	Migration Steps

4. Update Order

Recommended sequence to minimize risk:

1. Step 1: Update X first because...
2. Step 2: Then update Y because...
3. Step 3: Finally update Z because...

5. Testing Strategy

Update	Tests to Run	What to Watch For

6. Rollback Plan

For each risky update:

• How to identify problems
• How to rollback
• Time to wait before confirming success

Audit the error handling in this code and suggest improvements.

Code to Audit

{paste your code}

Error Handling Context

• Application type: {web service / CLI / library}
• Error reporting: {logging / monitoring / user-facing}
• Retry requirements: {automatic retry? / fail fast?}

Audit Request

1. Current State Analysis

Location	Error Type	Current Handling	Assessment

2. Missing Error Handling

Location	What Could Fail	Suggested Handling

3. Error Handling Patterns

Recommend patterns for this codebase:

• Error creation: How to create consistent errors
• Error propagation: When to catch vs. rethrow
• Error recovery: When and how to retry
• Error logging: What to include in logs

4. Error Classification

Category	Examples	Handling Strategy
Recoverable
User errors
System errors
Programming errors

5. Improved Code

// Code with improved error handling
// Comments explaining each change

6. Error Response Format

Standardized error response structure:

{
  // Recommended error format
}

Create a migration guide for the following code transformation.

Migration Details

• From: {current framework/version/language}
• To: {target framework/version/language}
• Reason: {why migrating}

Code to Migrate

{paste current code}

Migration Context

• Timeline: {urgent / planned / long-term}
• Team familiarity with target: {high / low}
• Can run in parallel: {yes / no}

Migration Guide Request

1. Conceptual Mapping

Old Concept	New Concept	Notes

2. Syntax Changes

Pattern	Old Syntax	New Syntax

3. Breaking Changes

Change	Impact	Workaround

4. Step-by-Step Migration

Step	Action	Verification	Rollback

5. Migrated Code

// Fully migrated code with comments
// explaining key differences

6. Testing After Migration

Test	Purpose	Expected Result

7. Common Pitfalls

Things that often go wrong in this migration:

• Pitfall 1: explanation and prevention
• Pitfall 2: explanation and prevention

Generate a clear pull request description for these changes.

Changes Made

{paste your git diff or describe changes}

Context

• Related issue/ticket: {link or number}
• Type of change: {feature / bugfix / refactor / docs}
• Breaking change: {yes / no}

Generate PR Description

Title

{Type}: Brief description (50 chars max)

Summary

In 2-3 sentences, what does this PR accomplish?

Changes

Bullet list of specific changes:

• Changed X to do Y
• Added Z for reason
• Removed W because

Motivation

Why are these changes needed? What problem do they solve?

Testing

How were these changes tested?

• Unit tests added/updated
• Integration tests added/updated
• Manual testing performed

Testing Instructions

Steps for reviewers to test:

1. Step 1
2. Step 2
3. Expected result

Screenshots

{if UI changes - note where screenshots should go}

Checklist

• Code follows project style guidelines
• Self-reviewed the code
• Commented on complex code
• Documentation updated
• No new warnings introduced

Additional Notes

Anything reviewers should pay special attention to?

Create an Architecture Decision Record (ADR) for the following decision.

Decision Context

• Title: {what decision was made}
• Date: {when decided}
• Status: {proposed / accepted / deprecated}
• Decision makers: {who was involved}

The Problem

{describe the problem or requirement}

ADR Request

1. Context

Describe the situation that led to this decision:

• What's the current state?
• What are the requirements?
• What constraints exist?

2. Decision Drivers

Driver	Priority	Notes
{technical requirement}	High/Medium/Low
{business requirement}	High/Medium/Low

3. Considered Options

Option	Description	Pros	Cons
Option A
Option B
Option C

4. Decision

State the decision clearly: "We decided to use [option] because [reasons]."

5. Consequences

Positive:

• Benefit 1
• Benefit 2

Negative:

• Drawback 1 (and how we'll mitigate)
• Drawback 2 (and how we'll mitigate)

Neutral:

• Implications that are neither good nor bad

6. Related Decisions

What other decisions does this affect or depend on?

7. Review Date

When should this decision be revisited?

Identify code smells in the following code and suggest improvements.

Code to Analyze

{paste your code}

Code Context

• Age of code: {new / legacy / mixed}
• Refactoring budget: {quick fixes only / thorough cleanup allowed}
• Team familiarity: {everyone knows this / few people know this}

Code Smell Analysis

1. Smell Inventory

Smell	Location	Severity	Quick Description

2. Detailed Analysis

For each smell found:

Smell: [Name]

• What: Description of the issue
• Why it's a problem: Impact on maintainability
• Example from code: Specific line/block
• Refactoring: Pattern to apply
• Effort: Low/Medium/High

3. Smell Categories

Bloaters (code that grows too large):

• Long methods
• Large classes
• Long parameter lists
• Data clumps

Object-Orientation Abusers:

• Switch statements
• Parallel inheritance hierarchies
• Refused bequest

Change Preventers:

• Divergent change
• Shotgun surgery
• Feature envy

Dispensables:

• Dead code
• Speculative generality
• Duplicate code

Couplers:

• Inappropriate intimacy
• Message chains
• Middle man

4. Prioritized Action Plan

Priority	Smell	Effort	Impact	Recommended Action

5. Clean Code Version

// Refactored version addressing top priority smells