AI Coding Prompts Developers Use to Save Hours: Best Guide

You are a senior [LANGUAGE] engineer. I'm getting this error in production:[ERROR MESSAGE / STACK TRACE]Here is the relevant code:[CODE BLOCK]Environment: [framework version, OS, relevant dependencies]Don't just tell me what the error message says — I can read that. I need:1. The actual root cause (not the symptom)2. Why it's happening in my specific code3. The fix, with any alternative approaches worth knowing4. What I should check to make sure this doesn't recur

This bug only reproduces about 1 in 10 runs. It doesn't crash — it produces wrong output silently.Language: [LANGUAGE]Context: [async/concurrent/multi-threaded code description]Code:[CODE BLOCK]Symptoms: [describe what you observe]What I've already ruled out: [list your attempts]Analyze this for:- Race conditions or shared state issues- Non-deterministic behavior sources- Timing-dependent logic- Any assumptions in the code that might not hold under loadSuggest the most likely cause first, then alternatives ranked by probability.

Something broke between version A and version B of this code and I can't find it.Working version:[OLD CODE]Broken version:[NEW CODE]The bug: [describe what's wrong now]Tests: [passing/failing, or what tests exist]Do a line-by-line diff analysis. Identify every semantic difference — not just surface syntax — and flag the most likely culprit. If there are multiple possible causes, rank them.

I'm getting a null/undefined/NullPointerException in [LANGUAGE] and I can't trace where the null enters.Code:[CODE BLOCK]Error: [exact error and line number]Trace every possible code path that could produce a null/undefined at line [X]. List each path, where the null originates, and whether each path is reachable in practice. Then suggest the minimal fix that handles all paths without over-engineering.

I'm getting unexpected HTTP responses from an API call. Here's the full picture:Request:[method, endpoint, headers, body]Response:[status code, response headers, response body]My code making the request:[CODE BLOCK]What I expected: [describe expected behavior]What I'm getting: [actual behavior]Diagnose the most likely causes — consider authentication, rate limiting, serialization, CORS, encoding, and any issues in my request construction. Walk through each possibility and tell me how to confirm or eliminate it.

My SQL query returns results I don't expect. Database: [PostgreSQL/MySQL/SQLite/etc.]Query:[SQL QUERY]Schema (relevant tables):[TABLE DEFINITIONS]Sample data that produces the wrong result:[SAMPLE INPUT]Expected output:[WHAT YOU WANT]Actual output:[WHAT YOU GET]Explain why the query produces this output, where the logic error is, and provide the corrected query. If there are performance implications in the fix, mention them.

My [LANGUAGE] application has a memory leak — RSS grows by [X MB] per hour under normal load.Architecture overview: [brief description, e.g., Node.js server with Express, long-running process]Code of suspect areas:[CODE BLOCK]Profiling data I have: [what you've collected, or "none yet"]Identify the most common causes of memory leaks in this type of application and evaluate my code against each. Tell me what to measure first and how, then give me the most likely fix based on what you see.

My layout breaks at [viewport size / browser / specific condition]. It works fine otherwise.HTML structure:[RELEVANT HTML]CSS:[RELEVANT CSS]What breaks: [describe exactly — element positions wrong, overflow, etc.]Browser(s) affected: [list]Identify the CSS properties causing this, explain why they behave differently in this scenario, and provide the minimal CSS change that fixes it without affecting the working states.

I have a dependency conflict I can't resolve. Package manager: [npm/pip/cargo/etc.]Error output:[DEPENDENCY ERROR]My package.json / requirements.txt / Cargo.toml:[DEPENDENCIES LIST]I need to use [PACKAGE A] version [X] because [reason].Explain why this conflict exists, what trade-offs I'm making with each resolution option, and recommend the safest approach for a production codebase.

My CI build is failing and the error isn't clear from the logs.CI platform: [GitHub Actions / GitLab CI / Jenkins / etc.]Build step that fails: [step name]Full failure output:[LOG OUTPUT]My config file:[CI CONFIG]What's causing this failure? Is it an environment issue, a config error, or something in my code? Walk through the log output and identify the root cause, not just where it terminates.

Review this [LANGUAGE] code for security vulnerabilities. Be thorough and specific.Code:[CODE BLOCK]Context: This handles [user authentication / file uploads / payment data / etc.].Framework: [framework and version]Trust boundary: [is this public-facing, internal API, admin only, etc.]For each issue you find:1. Name the vulnerability class (e.g., SQL injection, path traversal, SSRF)2. Show the exact line(s) where it exists3. Explain how it could be exploited4. Provide the specific fixDo not flag theoretical issues that aren't actually reachable in this code. Flag only real, exploitable problems.

Review this code as a senior engineer doing a real PR review. Be honest, not diplomatic.Language: [LANGUAGE]Team context: [team size, project scale, e.g., "6-person startup, moving fast"]Code:[CODE BLOCK]I want feedback on:- Logic correctness and edge cases- Error handling completeness- Maintainability for someone new to this area- Naming and clarity- Anything you'd block a PR for vs. leave as a commentDon't approve everything. If something should be changed, say so directly.

Audit every point where user-controlled input enters this code. I need to verify I'm not missing any validation.Code:[CODE BLOCK]For each input entry point, tell me:- What validation currently exists- What's missing- What an attacker or malformed client could send that would cause problems- The specific validation code I should addFlag also any places where I'm trusting data from an upstream service that could itself be compromised.

Review this asynchronous code for correctness. Language: [LANGUAGE / runtime].Code:[CODE BLOCK]Check specifically for:- Unhandled promise rejections or uncaught exceptions in async paths- Missing awaits that would cause incorrect sequencing- Error propagation — does every error path result in appropriate handling?- Any place where the code assumes sequential execution but might run concurrently- Resource cleanup — connections, file handles, locks released in all pathsShow me each issue with the problematic line and the correct version.

Review these API endpoint definitions for design quality. This is a [REST / GraphQL / gRPC] API.Endpoints / schema:[API DEFINITION]Consumer context: [mobile apps, third-party partners, internal services, etc.]Expected request volume: [rough scale]Evaluate:- Consistency of naming and structure- Proper HTTP method and status code usage (for REST)- Breaking change risk if I need to evolve these- Anything that will make client implementation painful- Versioning strategy adequacyI'm looking for design issues, not implementation bugs.

Review my dependencies list for risk and maintenance concerns.[PASTE package.json / requirements.txt / etc.]For each significant dependency:- Is it actively maintained? (based on your training data up to your cutoff)- Are there known security issues I should know about?- Is there a lighter-weight alternative if this dep is heavyweight for what I'm using it for?- Any that I might be able to remove entirely?I'm not looking to audit every transitive dep — focus on direct dependencies only.

Review all database queries in this code for safety and correctness.Code:[CODE BLOCK]Database: [PostgreSQL / MySQL / MongoDB / etc.]ORM / query builder (if any): [name and version]Check for:- SQL/NoSQL injection vulnerabilities — is user input ever interpolated unsafely?- N+1 query patterns that would crush performance at scale- Missing transactions where atomicity is required- Queries that would produce incorrect results with concurrent writes- Indexes that would be needed for these queries to be performant

Refactor this function to reduce its cognitive complexity. Keep the exact same behavior — this is a pure refactoring, not a feature change.Language: [LANGUAGE]Code:[CODE BLOCK]Target: The refactored version should be readable by someone unfamiliar with this codebase without needing to mentally simulate many states.Constraints:- Do not change public interfaces or function signatures- Do not introduce external dependencies- Keep performance equivalent or betterAfter the refactored code, explain each structural change you made and why it reduces complexity.

Convert this callback-based code to modern async/await. Language: JavaScript/TypeScript (Node.js [version]).Code:[CODE BLOCK]Requirements:- Preserve all existing error handling — do not silently swallow errors- Maintain the same concurrency behavior (don't accidentally serialize things that ran in parallel)- Keep TypeScript types correct if applicable- Do not change the public-facing function signatureFlag any places where the conversion isn't straightforward and explain the trade-off.

This function/class is doing too many things. Help me break it apart.Language: [LANGUAGE]Code:[CODE BLOCK]Business context: [what this code does at a high level]Identify the distinct responsibilities in this code. Suggest how to split it into smaller, focused units. For each proposed unit:- Give it a name and describe its responsibility in one sentence- Show the code it would contain- Show how the pieces connectI don't want to change behavior — just reorganize. Tell me if you see any places where splitting would require changing behavior.

Add TypeScript types to this JavaScript code without changing runtime behavior.Code:[CODE BLOCK]TypeScript config notes: [strict mode on/off, target version, any special compiler options]Priority order:1. Correct types (no "any" unless genuinely unavoidable — explain each one)2. Good developer ergonomics (intellisense that actually helps)3. Compatibility with the runtime environmentIf you need to infer a type from context and aren't sure, say so and give me two options. Don't guess and move on.

Find and eliminate code duplication in these files.Language: [LANGUAGE]Files:[CODE BLOCKS FROM MULTIPLE FILES]For each instance of duplication:1. Show both duplicated sections2. Propose an abstraction (function, class, utility, etc.)3. Show how both call sites would look after the changePrioritize by impact — most-duplicated and most-likely-to-diverge first. If any duplication should be intentionally kept (e.g., different contexts that happen to look similar now), say so.

Update this code to use modern [LANGUAGE] features available in version [X.Y].Code:[CODE BLOCK]Target version: [e.g., Python 3.12, ES2024, Java 21, Go 1.23]Keep compatible with: [any minimum runtime version constraints]Replace outdated patterns with their modern equivalents. For each change:- Show old vs. new side by side- Explain the benefit (readability, performance, safety)- Flag anything where the modern version has subtly different behaviorDo not modernize things that are already idiomatic — only update patterns that are genuinely outdated.

Translate this code from [SOURCE LANGUAGE/FRAMEWORK] to [TARGET LANGUAGE/FRAMEWORK].Source code:[CODE BLOCK]Target environment: [version, conventions, any specific style guides]Translation priorities:1. Correctness — same behavior in all cases2. Idiomatic target code — not just a direct translation that "works" but reads like [SOURCE]3. Use target-language standard library where it replaces the source approach naturallyFor any logic where there's no clean 1:1 mapping, explain the difference and how you handled it.

Write comprehensive unit tests for this function.Language: [LANGUAGE]Test framework: [Jest / pytest / JUnit / RSpec / Go test / etc.]Code:[CODE BLOCK]I need tests that cover:- All valid inputs and expected outputs- Edge cases: empty inputs, null/undefined, boundary values, very large inputs- Error cases: invalid types, missing required fields, out-of-range values- Any state dependencies (mock these — don't hit real services)For each test, write a one-line comment explaining what scenario it covers. Aim for tests that would catch a future regression, not just tests that document current behavior.

Write integration tests for this API endpoint. Framework: [Express / FastAPI / Rails / Django / etc.]Test framework: [Supertest / httpx / RSpec request specs / etc.]Endpoint code:[CODE BLOCK]Test for:- 200 response with valid input (multiple valid variations)- Each 4xx error case: what inputs trigger them, what response body structure I expect- Authentication/authorization: unauthorized and forbidden cases- Any business logic constraints that should reject valid-looking requestsUse real database calls against a test database, not mocks — I want these to catch real integration bugs. Include any test setup / teardown needed.

Generate realistic test fixtures for these data structures.Language: [LANGUAGE]Schema / type definitions:[TYPE DEFINITIONS OR DB SCHEMA]I need:- 5 "happy path" examples that represent typical production data- 3 edge case examples that stress boundary conditions (max string length, zero values, nested empty collections, etc.)- 2 "almost invalid" examples that should fail validation and what specifically makes them invalidMake the test data realistic — not {"name": "test", "email": "test@test.com"} but data that could plausibly come from real users.

Help me mock the external dependencies in this code so I can test it in isolation.Language: [LANGUAGE]Test framework: [framework]Code to test:[CODE BLOCK]Dependencies to mock: [list external APIs, databases, file system, time, etc.]For each mock:1. Show how to set it up for the test2. Show how to configure different scenarios (success, failure, timeout, partial response)3. Show how to verify it was called correctly where that mattersI want mocks that are realistic enough to catch integration mismatches, not just stubs that return empty objects.

Write property-based tests for this function using [Hypothesis / fast-check / QuickCheck / proptest].Language: [LANGUAGE]Library: [property-based testing library]Function:[CODE BLOCK]Identify the invariants that should always hold — things like:- Output type constraints- Mathematical properties (idempotence, commutativity, inverse operations)- Boundary guarantees ("output is always <= input" type constraints)- Error conditions that should always be raised for certain input shapesWrite generators that cover the realistic input space, not just random noise.

I have tests for this code but I think they have gaps. Analyze both and tell me what's not covered.Code:[CODE BLOCK]Existing tests:[TEST CODE]For each code path, state or function branch that isn't covered:1. Describe what scenario is missing2. Explain why it matters (would a real bug hide there?)3. Write the missing testPrioritize by risk — which gaps are most likely to allow a real bug to go undetected?

Write a load test for this endpoint/service using [k6 / Locust / Artillery / JMeter].Endpoint details:[URL, method, headers, body template]Test scenario:- Ramp from 0 to [N] concurrent users over [duration]- Sustain [N] users for [duration]- Track: p50, p95, p99 response times; error rate; throughputThresholds: fail the test if p95 > [Xms] or error rate > [Y%]Include realistic think time between requests and parameterized test data (don't hammer the same request 1000 times).

Write an E2E test for this user flow using [Playwright / Cypress].Application: [brief description]User flow to test:[Step 1: user does X][Step 2: user expects Y to appear][Step 3: user clicks Z][Expected final state]Requirements:- Use data-testid attributes for selectors (not CSS classes — they change)- Handle async loading states — wait for real content, not arbitrary timeouts- Test with network conditions: normal, and a slow-network simulation- Clean up created test data after each run

I need to build [FEATURE] and I want to evaluate my architectural options before committing.Context:- Current stack: [languages, frameworks, databases]- Team size: [N developers]- Scale: [current and expected load]- Constraints: [hosting, cost, deadlines, existing tech debt]Feature requirements: [describe what needs to be built]Give me 3 architectural approaches — ordered from simplest to most complex. For each:1. Describe the approach in concrete terms2. List what this approach is optimized for3. List where it breaks down4. Estimate the implementation complexity (rough person-weeks)5. Name the biggest riskDon't tell me what "most companies" do. Tell me what fits this context.

Help me write an Architecture Decision Record (ADR) for a decision we've made.Decision: [what we decided]Context: [what problem we were solving, what constraints we were under]Options we considered: [list them with brief descriptions]Why we chose what we did: [your reasoning]Trade-offs we're accepting: [what we're giving up]Format it as a proper ADR with:- Status: Accepted- Context (2–3 sentences)- Decision (1 sentence)- Consequences: positive and negative- Alternatives rejected and whyWrite it clearly enough that a developer joining the team in 2 years can understand why this decision was made without asking anyone.

Review this database schema design before I build on top of it.Database: [PostgreSQL / MySQL / MongoDB / etc.]Schema:[DDL or schema description]Business context:- What this data represents: [brief description]- Access patterns: [how the data will be queried — read-heavy, write-heavy, specific query types]- Scale expectations: [approximate row counts, growth rate]Evaluate:- Normalization: is anything that should be split, split? Anything over-normalized?- Missing indexes for the access patterns described- Constraint correctness — foreign keys, null constraints, unique constraints- Anything that would require a painful migration later if requirements expand in obvious waysTell me what I'd regret in 18 months.

Walk me through designing [SYSTEM] at scale. This is for [interview prep / actual planning].Requirements (as given):- [Functional requirement 1]- [Functional requirement 2]- Scale: [DAU, QPS, data volume estimates]Guide me through:1. Requirements clarification — what questions should I ask first?2. Capacity estimation — rough numbers3. High-level design4. Component deep-dives on [specific component I want to focus on]5. Trade-offs of my approachIf you see me make assumptions that are wrong at this scale, call them out.

Help me plan a migration from [OLD SYSTEM/APPROACH] to [NEW SYSTEM/APPROACH].Current state:- [Describe current system]- Data volume: [size]- Traffic: [concurrent users, requests/sec]- Team: [N engineers available]- Zero-downtime requirement: [yes/no]Target state: [describe what we're moving to]Produce a phased migration plan with:- Phase breakdown (what happens in each phase)- Rollback strategy for each phase- How I'll validate each phase before proceeding- The highest-risk moment in the migration and how to mitigate it

Design a caching strategy for this system.Current problem: [describe the performance issue — slow queries, high DB load, latency, etc.]Data characteristics:- Read/write ratio: [e.g., 20:1]- Data size: [approximate]- Freshness requirements: [how stale can cached data be?]- Invalidation triggers: [what events make the cache stale?]Stack: [language, database, any existing infrastructure]Recommend:1. What to cache (be specific — not "cache your queries")2. Cache strategy (write-through, write-around, write-back)3. TTL and invalidation approach4. What to explicitly not cache and why5. How to handle cold start and cache stampede

Add documentation comments to this code. Language: [LANGUAGE].Code:[CODE BLOCK]Documentation style: [JSDoc / Python docstrings / Rustdoc / Javadoc / Go doc comments]For each function/method/class:- Document what it does (not how — the code shows how)- Document parameters: type, what it represents, any constraints- Document return value- Document exceptions/errors it can raise- Add @example for any function whose usage isn't obvious from the signatureDon't document things that are self-evident from the name. Skip comments like "// increment i" on "i++". Focus on intent and contract, not mechanics.

Write a README for this project.Project description: [what it does and who it's for]Tech stack: [languages, frameworks, databases]Repo structure overview:[list main directories/files]Include these sections:- What this is (2–3 sentences, no marketing)- Prerequisites (exact versions)- Installation and local setup (step by step — assume a fresh machine)- How to run tests- Environment variables needed (with example .env format, not actual values)- How to contribute- LicenseWrite it for a developer who's never seen this codebase. Err on the side of more detail in the setup section — that's where people get stuck.

Explain this code to me. I understand [LANGUAGE] well but I'm unfamiliar with [specific pattern/library/domain].Code:[CODE BLOCK]I need:1. What it does at a high level (2–3 sentences)2. How it works — walk through the logic step by step3. Why it's written this way — what pattern or constraint drives this structure?4. Anything I should know about the trade-offs or limitations of this approachUse the "what → how → why" structure. Don't assume I know [specific thing I'm unfamiliar with].

Generate OpenAPI 3.1 documentation for these endpoints.Framework: [Express / FastAPI / Rails / etc.]Route definitions:[CODE BLOCK]For each endpoint include:- Summary and description (honest about what it does and doesn't do)- All path, query, header parameters with types and whether required- Request body schema with examples for at least 2 scenarios- All possible response codes with schema and real-world example responses- Authentication requirementGenerate valid, parseable YAML. Use $ref for any schemas used in multiple places.

Write release notes for this version based on what changed.Version: [X.Y.Z]Git diff summary / commit messages:[PASTE COMMITS OR DIFF SUMMARY]Target audience: [end users / developers / both]Format:- Breaking Changes (if any — be explicit about migration steps)- New Features- Bug Fixes- Performance Improvements- DeprecationsDon't include internal refactors or test changes unless they have user-facing implications. Write in plain language — no commit-message jargon.

Write a runbook for [PROCESS NAME — e.g., "database failover", "deploys to production"].System context:[Brief description of the system and tech stack]The runbook should cover:- When to use this runbook (trigger conditions)- Prerequisites (access, tools needed)- Step-by-step procedure with commands (exact, copy-pasteable)- How to verify each step succeeded before proceeding- Rollback procedure if something goes wrong- Who to escalate to and how if this runbook failsWrite it for someone who has system access but hasn't done this before. Optimize for crisis conditions — clear, numbered, no ambiguity.

This code is too slow for the scale it needs to operate at. Help me optimize the algorithm.Language: [LANGUAGE]Current performance: [measured time/memory on realistic input size]Required performance: [target]Input characteristics: [size range, data distribution, any useful patterns]Code:[CODE BLOCK]Analyze the time and space complexity of the current implementation. Propose alternatives with better complexity, ranked by improvement potential. For each alternative, show the code and explain the trade-offs (readability, implementation complexity, space/time trade-off).

This query is slow. Help me optimize it.Database: [PostgreSQL / MySQL / etc.]Current execution time: [measured time on [N] rows]EXPLAIN ANALYZE output:[PASTE EXPLAIN ANALYZE OUTPUT]Query:[SQL QUERY]Schema and indexes:[DDL]Typical row counts per table: [estimates]Analyze the query plan, identify the bottleneck (seq scans, bad joins, missing indexes, etc.), and propose optimizations. Show the expected improvement and any trade-offs (index write overhead, storage cost, query structure changes).

My JavaScript bundle is too large. Help me reduce it.Build tool: [webpack / Vite / esbuild / etc.]Current bundle analysis: [paste bundle analyzer output or key stats]Framework: [React / Vue / Svelte / etc.]Problem areas:[list large dependencies or chunks]Evaluate each large dependency:- Is it tree-shakeable? Am I importing it correctly?- Is there a smaller alternative for what I'm actually using?- Should it be lazy-loaded or code-split?Also review my build config for common optimization misses: [attach config if relevant].

My React component re-renders too frequently and it's causing performance issues.Component:[CODE BLOCK]Profiler data (from React DevTools or equivalent): [describe what you observed — which renders are expensive, frequency]Identify:1. Every unnecessary re-render and what triggers it2. Props or state that could be memoized3. Expensive computations that should use useMemo4. Event handlers that should use useCallback5. Any structural issues (component split, data fetching location) that are the real problemPrioritize — not every memo is worth adding. Tell me which optimizations have real impact vs. premature optimization.

Review this code for N+1 query problems. Language: [LANGUAGE]. ORM/framework: [name].Code:[CODE BLOCK INCLUDING DATA FETCHING LOGIC]Identify every place where a query inside a loop (or equivalent) would produce N+1 database calls. For each:1. Show the problematic code2. Explain why it produces N+13. Show the corrected version (eager loading, batch query, or restructured logic)4. Estimate the query reduction on [typical N value from my use case]

Review my infrastructure setup for cost optimization opportunities.Cloud provider: [AWS / GCP / Azure]Current monthly spend: [approximate, or paste billing breakdown]Infrastructure as code:[Terraform / CloudFormation / etc. snippet]Traffic profile: [peak vs. average load, time patterns]Performance requirements: [latency, uptime SLA]Identify:- Overprovisioned resources (instances bigger than needed)- Resources running 24/7 that could be scheduled or autoscaled- Storage or data transfer costs that could be reduced- Better pricing models (reserved vs. spot vs. on-demand)Quantify the savings estimate for each opportunity if you can. Don't suggest changes that would compromise the SLA.