Code Review

Overview

Get instant code review feedback for Python, JavaScript, TypeScript, Java, and Swift. This template catches SQL injection vulnerabilities, performance bottlenecks, memory leaks, and readability issues before they hit production.

Skip the 30-minute manual review process. Generate detailed security analysis, refactoring suggestions, and best practice recommendations in under a minute.

Benefits

Real time savings from teams using this template:

• Cut review time by 80% - Get comprehensive feedback in 60 seconds instead of 30 minutes per code block
• Catch critical bugs early - Identify SQL injection, XSS vulnerabilities, and race conditions before deployment
• Consistent quality standards - Apply the same rigorous checks across your entire codebase and team
• Learn while you code - Each review includes explanations and code examples for implementing fixes
• Multi-language support - Works across Python, JavaScript, TypeScript, Java, Swift, Go, Rust, PHP, Ruby, and C++

Use Cases

Real scenarios where this template saves hours:

• Review 200+ line pull requests in 5 minutes instead of blocking your afternoon for manual inspection
• Audit legacy authentication code for SQL injection before migrating to production infrastructure
• Validate API endpoint security during sprint planning to catch auth bypass vulnerabilities
• Check React component performance when users report slow render times
• Review contractor code submissions for consistent quality standards across external teams
• Train junior developers by showing specific security issues and how to fix them with working code examples

Template

Review the following {{language}} code for best practices, potential bugs, security issues, and performance improvements.

Code:
{{code}}

Focus areas: {{focusAreas}}

Properties

• language: Single Selection (default: Python)
  • Options: Python, JavaScript, TypeScript, Java, Swift, and 5 more
• code: Multi-line Text
• focusAreas: Multiple Selection (default: Security, Performance, Readability)
  • Options: Security, Performance, Readability, Best Practices, Error Handling, and 1 more

Example Output

Here’s what you get when reviewing a simple authentication function with this template:

Input code:

def authenticate_user(username, password):
    query = f"SELECT * FROM users WHERE username = '{username}' AND password = '{password}';"
    result = db.execute(query)
    if result:
        return result[0]
    return None

Generated review:

Critical issues found in this code:

Security

• SQL injection vulnerability on line 2 - user input is directly interpolated into the query string. An attacker could pass username = "admin' OR '1'='1" to bypass authentication.
• Passwords stored in plaintext - violates basic security practices.

Recommended fixes:

def authenticate_user(username, password):
    query = "SELECT * FROM users WHERE username = ? LIMIT 1;"
    result = db.execute(query, (username,))

    if result and verify_password(password, result[0]['password_hash']):
        return result[0]
    return None

Changes:

1. Use parameterized query with ? placeholder to prevent SQL injection
2. Remove password from query - verify hash after retrieval
3. Add LIMIT 1 to optimize query
4. Use password hashing (bcrypt/argon2) instead of plaintext storage

Additional concerns:

• No rate limiting - vulnerable to brute force attacks
• No logging of failed attempts
• Consider using an ORM like SQLAlchemy for safer database operations

Common Mistakes This Template Catches

When reviewing code manually, developers often miss these critical issues:

Security blind spots

• SQL injection from string concatenation in database queries
• XSS vulnerabilities when rendering user input in templates
• Hardcoded API keys and credentials committed to version control
• Missing authentication checks on admin endpoints
• Unsafe deserialization of untrusted data

Performance issues

• N+1 query problems loading related database records
• Missing database indexes on frequently queried columns
• Inefficient list comprehensions that could use generator expressions
• Unnecessary API calls inside loops
• Memory leaks from unclosed file handles or database connections

Code quality problems

• Functions doing multiple unrelated tasks (violating single responsibility)
• Deeply nested conditionals that are hard to test and maintain
• Missing error handling for network requests and file operations
• Inconsistent naming conventions across similar functions
• Magic numbers without explanation or constants

This template systematically checks for all of these, giving you confidence your code meets production standards.

Frequently Used With

Combine code review with these templates for a complete development workflow:

• Unit Test - Generate test cases for code that passes review
• Bug Report - Document issues found during review for your team
• Refactoring Plan - Create a strategy for fixing complex issues
• Performance Optimization - Deep dive into bottlenecks identified in review
• API Documentation - Document endpoints after security review

Related Templates

Explore more Coding templates or browse all templates.