AI Prompt Generator

Perform a thorough code review focusing on best practices, performance, and maintainability

Specialized review for React components focusing on hooks, performance, and patterns

Refactor code to improve modularity and separation of concerns

Convert callback-based or promise-based code to modern async/await syntax

Step-by-step debugging approach for identifying root causes

Identify and fix memory leaks in JavaScript applications

Generate comprehensive API documentation with examples

Create a comprehensive README.md for a project

Generate comprehensive unit tests with edge cases

Create end-to-end test scenarios for user workflows

Analyze and improve system architecture design

Design microservices architecture for a monolithic application

Identify and fix performance bottlenecks in code

Optimize SQL queries and database performance

Identify security vulnerabilities and suggest fixes

Secure API endpoints against common attacks

Explain complex programming concepts with practical examples

Learn design patterns with practical implementations

Convert code from one programming language to another

Generate clear, conventional commit messages

Analyze code complexity and suggest simplifications

Deep security analysis for sensitive code

Review React hooks usage and patterns

Review REST API design and implementation

Analyze database design and queries

Review TypeScript code for type safety

Debug performance bottlenecks systematically

Debug complex async flows and promise chains

Debug React component issues

Debug API communication issues

Debug database connectivity problems

Refactor to implement design patterns

Modernize legacy code gradually

Break down complex functions

Optimize data structures for better performance

Generate OpenAPI specification

Add meaningful code comments

Document architectural decisions

Create comprehensive release notes

Create comprehensive integration tests

Generate realistic test data

Test API contracts and schemas

Design performance test cases

Design serverless application architecture

Design event-driven systems

Design multi-layer caching strategy

Design database sharding approach

Comprehensive frontend performance analysis

Optimize React application performance

Optimize API response times

Reduce application memory footprint

Implement secure authentication

Comprehensive input validation

Implement secure data storage practices

Configure security headers properly

Compare similar technologies objectively

Explain algorithms with examples

Learn framework internals

Write helpful error messages

Suggest better names for code elements

Implement comprehensive logging

Design continuous integration/deployment pipeline

Plan large-scale code migrations

Evaluate and prioritize technical debt

Create comprehensive dev environment setup

Optimize Next.js applications

Refactor to Vue 3 Composition API

Secure Express.js applications

Apply Django best practices

Design Spring Boot microservice

Create Kubernetes deployment configs

Optimize Docker images and builds

Write Terraform infrastructure code

Optimize React Native app performance

Implement Flutter state management

Analyze ML model performance

Design data processing pipeline

Review API handler code for correctness and contract alignment

Review goroutine usage, channels, and cancellation patterns

Evaluate SQL queries for correctness, performance, and safety

Review ETL pipeline code for reliability and correctness

Review C# service code for quality, resiliency, and performance

Review Rust code for safety, lifetimes, and error handling

Review SwiftUI or UIKit code for best practices and structure

Review Android Kotlin code for architecture and correctness

Review legacy code for risk, cleanup, and modernization

Audit code for security vulnerabilities and unsafe patterns

Refactor a monolith into cohesive modules

Migrate class components to hooks with best practices

Standardize error handling patterns in Go code

Refactor classes to dataclasses and type hints

Replace deep inheritance with composition in OOP code

Simplify complex TypeScript types and generics

Refactor SQL queries for clarity and performance

Refactor synchronous C# code to async/await

Simplify Rust ownership and lifetime usage

Refactor handlers into service/repository layers

Systematic debugging of intermittent test failures

Find the cause of slow or timing-out API endpoints

Debug unexpected React re-renders and UI glitches

Detect and fix data races in Go services

Diagnose and resolve database deadlocks

Track down memory growth in Python applications

Investigate and fix Swift crash reports

Diagnose Application Not Responding issues

Investigate CrashLoopBackOff in Kubernetes

Diagnose and fix build failures in CI

Write an Architecture Decision Record

Create operational runbooks for services

Generate CLI command reference documentation

Write a quickstart guide for an SDK

Document tables, relationships, and constraints

Generate release notes from change summaries

Organize a changelog from raw commits

Document API error responses and resolutions

Create a developer onboarding guide

Write an architecture overview with diagrams

Design property-based tests for critical logic

Generate consumer-driven contract tests

Plan integration tests across services

Create load and stress test scenarios

Set up mutation testing to gauge test quality

Create snapshot tests for UI components

Design end-to-end tests for mobile flows

Test database migrations safely

Create tests for security regressions

Build reusable test data factories

Design an event-driven system with queues and consumers

Design architecture for multi-tenant applications

Design cache layers and invalidation strategies

Plan schema or service migrations with no downtime

Design metrics, logs, and tracing strategy

Design background processing with queues

Design an API gateway and routing strategy

Design a feature flag platform and rollout strategy

Design a normalized relational data model

Evaluate edge computing versus centralized cloud

Identify and add missing database indexes

Audit frontend for Core Web Vitals improvements

Analyze event loop blocking in Node services

Profile Python code and optimize hotspots

Optimize Go services using pprof data

Optimize Rust code for speed and allocations

Optimize build and CI execution time

Reduce end-to-end API response times

Reduce memory usage in services

Evaluate cache hit rates and invalidation

Run a structured threat model for a feature

Review OAuth/OIDC implementation for security

Implement secure secrets storage and rotation

Assess and fix vulnerable dependencies

Harden file upload endpoints and storage

Audit code for PII handling and privacy risks

Review authorization logic for least privilege

Remove secrets and PII from logs

Create a security incident response playbook

Prevent abuse with rate limiting and detection

Guided learning plan for Go concurrency

Step-by-step guide to Rust ownership and borrowing

Learn generics, constraints, and utility types

Understand SQL joins with practical examples

Guided system design learning path

Learn unit, integration, and E2E testing

Improve debugging approaches and tooling

Learn performance profiling and tuning

Learn essential application security concepts

Learn common architecture patterns and tradeoffs

Compare tech stacks based on project requirements

Prepare a sprint plan with clear goals

Estimate project scope, effort, and risk

Create a standardized code review checklist

Generate a clear pull request description

Write a postmortem after an incident

Compare tools with a weighted decision matrix

Draft an API specification from requirements

Create a checklist for safe migrations

Identify and assess risks for a project or feature