ChatGPT Prompts for Coding

Write a [language] function called [function_name] that:
[specification in plain English]
Include input validation, error handling, and a docstring. Add 3 unit test examples at the bottom.

Review the following [language] code for bugs, performance issues, and security vulnerabilities:
[code block]
Format your response as: Critical Issues → Warnings → Style Suggestions → Positive Notes.

Explain why the following code produces the error: [error message]:
[code block]
Walk through the execution step-by-step. Then provide the corrected code with an explanation of the fix.

Suggest a refactoring plan for the following [language] module:
[code block]
Group issues by: readability, performance, testability, and maintainability. Prioritise by effort vs impact. Show before/after for the top 3 changes.

Write a SQL query for the following task:
Tables: [table schema]
Task: [plain English description]
Optimise for performance. Include a comment explaining each major clause. Dialect: [MySQL/PostgreSQL/SQLite].

Design a RESTful API endpoint for [feature].
Include: HTTP method, URL path, request body schema (JSON), response body schema, status codes, authentication requirement, and rate limit note.
Language/framework: [stack].

Write a regular expression to match: [pattern description].
Language: [language]. Provide: the regex, a plain-English explanation of each part, 3 matching examples, and 2 non-matching examples.

Generate comprehensive unit tests for the following function:
[code block]
Framework: [Jest/PyTest/JUnit/etc]. Cover: happy path, edge cases, invalid inputs, and boundary conditions. Aim for 85%+ code coverage.

Write a README.md for the project: [project name].
Include: badges, description, features list, installation steps, usage examples (with code blocks), configuration options, contributing guide, and license.
Tech stack: [stack].

Add comprehensive documentation to the following [language] code:
[code block]
Use the standard docstring format for [language]. Document: purpose, parameters (type + description), return value, exceptions, and a usage example.

Explain the [algorithm name] algorithm to a [beginner/intermediate/senior] developer.
Include: the core idea (1 paragraph), step-by-step walkthrough with a concrete example, time/space complexity analysis, and when to use vs avoid it.

I need to store [data description] and perform these operations: [operations list].
Recommend the best data structure for this use case. Explain your reasoning, compare 2 alternatives, and show a code snippet for the recommended approach in [language].

The following [language] code is slow on inputs of size [scale]:
[code block]
Identify bottlenecks with Big-O analysis. Provide an optimised version. Estimate the speedup factor and explain the trade-offs.

Add robust error handling to the following [language] code:
[code block]
Use try/catch/finally appropriately. Log errors with context. Return meaningful error messages to callers. Don't swallow exceptions silently.

Write a setup script for a new developer joining the [project name] project.
OS: [OS]. Stack: [stack].
Script should: install dependencies, set up environment variables (with placeholder values), run DB migrations, and seed test data. Include error checks at each step.

Write a webhook handler in [language/framework] for events from [service].
Events to handle: [event types].
Include: signature verification, idempotency check, async processing, and a success/failure response. Add logging.

Design a caching strategy for [system/feature] using [Redis/Memcached/in-memory].
Data to cache: [data type]. Read frequency: [frequency]. Invalidation trigger: [trigger].
Provide: cache key schema, TTL recommendation, code snippet, and cache stampede prevention.

Write a Dockerfile + docker-compose.yml for a [language/framework] app.
Services needed: [services e.g. app, db, redis]. Env: development.
Include: multi-stage build, non-root user, health checks, volume mounts, and environment variable handling.

Design a JWT authentication flow for a [type of app].
Include: login endpoint, token generation (payload fields), token verification middleware, refresh token logic, and logout/revocation.
Language: [language]. Show code for each step.

Write a database migration script to [migration description].
Database: [DB type]. Table(s) affected: [tables].
Include: up migration, down migration (rollback), data backfill if needed, and a pre-flight check query.

Write a GitHub Actions workflow for a [language] project.
Triggers: push to main + PRs. Steps: lint → test → build → deploy to [target].
Include: caching dependencies, environment secrets, test coverage report, and Slack notification on failure.

Identify code smells in the following [language] codebase excerpt:
[code block]
List each smell, explain why it's problematic, and provide a refactored example. Categories: duplication, coupling, cohesion, naming, complexity.

Generate TypeScript type definitions for the following JSON API response:
[JSON example]
Use interface for objects, union types for enums, and optional (?) where fields can be absent. Add JSDoc comments for non-obvious fields.

Audit the following [language] code for OWASP Top 10 vulnerabilities:
[code block]
For each finding: vulnerability type, CWE ID, affected line(s), severity (Critical/High/Medium/Low), and remediation code snippet.

Write a load test script using [k6/Locust/JMeter] for the [endpoint/API].
Scenario: ramp from 10 to [max users] over [duration]. Target RPS: [target].
Include: assertions on p95 latency < [threshold]ms, error rate < 1%, and a summary report setup.

Design the interface contract for a [service name] microservice.
Language: [language]. Communication: [REST/gRPC/event].
Include: service boundary, public methods/endpoints, request/response schemas, error codes, and event schemas if applicable.

Build a code generator that takes [input spec format] and outputs [output type].
Language: [language]. Template engine: [Jinja2/Handlebars/custom].
Handle: missing fields with defaults, validation of required fields, and output formatting.

Create a safe upgrade plan for migrating [package] from v[current] to v[target] in a [language] project.
Include: breaking changes checklist, files likely affected, testing strategy, rollback plan, and estimated effort in hours.

Design a state machine for [entity e.g. order, subscription] with these states: [states].
Define: valid transitions, trigger events, guard conditions, and side effects per transition.
Show as: table + code implementation in [language].

Implement [async pattern: queue, pub-sub, saga] for the following use case:
[use case description]
Language: [language]. Include: producer code, consumer code, error handling, retry logic, and dead-letter queue setup.