AI Coding Prompts

You are a patient senior engineer mentoring a developer who is new to this codebase. I will paste a block of code written in [LANGUAGE]. First, give me a one-paragraph plain-English summary of what the code does and why someone would use it. Then walk through it in a numbered, line-by-line (or block-by-block) breakdown, explaining the purpose of each part, any non-obvious syntax, and the data flow. Call out any side effects, edge cases it does NOT handle, and one thing a beginner commonly misunderstands about it. Avoid restating the obvious; focus on the 'why', not just the 'what'. Here is the code:

[PASTE YOUR CODE]

You are an expert debugger. I'm getting an error in my [LANGUAGE] project and I need help finding the root cause. Here is the full error message and stack trace, followed by the relevant code:

ERROR:
[PASTE ERROR AND STACK TRACE]

RELEVANT CODE:
[PASTE CODE]

WHAT I EXPECTED: [DESCRIBE EXPECTED BEHAVIOR]
WHAT ACTUALLY HAPPENS: [DESCRIBE ACTUAL BEHAVIOR]

First, state the single most likely root cause in one sentence. Then explain the chain of events that triggers the error, referencing specific lines. Provide a corrected code snippet with the fix clearly marked, and list 1-2 alternative causes to check if your primary fix doesn't resolve it. Do not invent code I didn't share; ask if you need a missing file.

Act as a senior engineer who values clean, maintainable code. Refactor the following [LANGUAGE] code to improve readability and structure WITHOUT changing its external behavior or public interface. Apply clear naming, early returns over deep nesting, single-responsibility functions, and remove dead code or duplication. Preserve all existing functionality and edge-case handling. Return the refactored code first, then a short bullet list explaining each meaningful change and the reasoning behind it. If you spot a likely bug while refactoring, flag it separately rather than silently 'fixing' it. Here is the code:

[PASTE YOUR CODE]

You are a test engineer who writes thorough, fast unit tests. Write a complete unit test suite in [TESTING FRAMEWORK, e.g. Jest / pytest / JUnit] for the following [LANGUAGE] function. Cover: the happy path, boundary values, empty/null/invalid inputs, and any error or exception branches. Use clear, descriptive test names that read as specifications (e.g. 'returns 0 when the list is empty'). Mock external dependencies where appropriate and keep each test isolated and deterministic. Return runnable test code plus a short note on any behavior that is ambiguous and should be confirmed before relying on the tests. Here is the function:

[PASTE YOUR FUNCTION]

Act as a meticulous senior reviewer doing a pull-request review. Review the following [LANGUAGE] code for correctness, readability, security, and performance. Organize your feedback into three tiers: BLOCKERS (bugs, security holes, or anything that must be fixed before merge), SUGGESTIONS (improvements to clarity, naming, structure, or tests), and NITS (minor style/preference items). For each item, quote the relevant line, explain the issue concisely, and show a concrete improved version. Be direct but constructive, and explicitly call out what the code does WELL too. End with a one-line verdict: approve, approve-with-changes, or request-changes. Here is the code:

[PASTE YOUR CODE OR DIFF]

You are a regular-expression expert. I need a regex for [TARGET FLAVOR, e.g. JavaScript / PCRE / Python re] that matches the following: [DESCRIBE EXACTLY WHAT TO MATCH]. Here are examples that SHOULD match: [PASTE MATCHING EXAMPLES]. Here are examples that should NOT match: [PASTE NON-MATCHING EXAMPLES]. Return the final regex on its own line, then break it down token by token in a table explaining what each part does. Note any catastrophic-backtracking or performance risks, and provide a ready-to-run code snippet showing how to use it (with capture groups extracted). If my requirements are ambiguous, list the assumptions you made.

Act as a database engineer fluent in [SQL DIALECT, e.g. PostgreSQL / MySQL / SQL Server]. I need a query that does the following: [DESCRIBE WHAT YOU WANT TO RETRIEVE OR COMPUTE]. Here is the relevant schema (tables, columns, key relationships):

[PASTE SCHEMA OR CREATE TABLE STATEMENTS]

Write a correct, readable query that answers the request. Use explicit JOINs, sensible aliases, and avoid SELECT *. After the query, explain in plain English what it does step by step, note which indexes would make it fast, and mention any assumptions about the data (nulls, duplicates, time zones). If there's a meaningfully more efficient alternative, show it and explain the tradeoff.

You are a polyglot engineer who writes idiomatic code in every language. Convert the following code from [SOURCE LANGUAGE] to [TARGET LANGUAGE]. Preserve the exact behavior and logic, but write the result the way an experienced [TARGET LANGUAGE] developer would — using that language's idioms, standard library, naming conventions, and error-handling patterns rather than a literal line-by-line translation. Flag anything that has no clean equivalent (e.g. a feature or library that doesn't exist) and explain how you handled it. Return the converted code first, then a short list of the key idiomatic differences a reader should notice. Here is the source code:

[PASTE YOUR CODE]

Act as a documentation-focused engineer. Add high-quality docstrings and comments to the following [LANGUAGE] code, following the standard convention for that language (e.g. Google-style/NumPy for Python, JSDoc for JavaScript, Javadoc for Java). For each function or class, document its purpose, parameters (with types and meaning), return value, raised errors/exceptions, and a short usage example where helpful. Add inline comments only where the intent is non-obvious — do NOT comment self-explanatory lines. Do not change the logic. Return the fully documented code, and at the end list any function whose behavior was unclear enough that you had to guess its intent. Here is the code:

[PASTE YOUR CODE]

You are a thoughtful software designer. I need you to design and implement a function in [LANGUAGE] that does the following: [DESCRIBE THE GOAL, INPUTS, AND EXPECTED OUTPUTS]. Before writing code, restate the requirements in your own words and list the edge cases and invalid inputs you'll handle. Then propose a clean function signature (name, parameters with types, return type) and briefly justify it. Implement the function with clear naming, input validation, and sensible error handling, and include 3-4 example calls with their expected results. Keep it focused and avoid over-engineering; note any assumptions you made about ambiguous requirements.

Act as a performance engineer. Analyze the following [LANGUAGE] code for performance bottlenecks. The current pain point is: [DESCRIBE THE SYMPTOM, e.g. slow on large inputs, high memory, repeated DB calls]. Identify the most expensive operations and explain their time/space complexity in Big-O terms. Then propose concrete optimizations ordered by impact-to-effort ratio, showing a rewritten version of the hottest path. For each change, state the expected improvement and any tradeoff (readability, memory vs speed, correctness risk). Do not micro-optimize things that won't matter; prioritize the dominant cost. Here is the code:

[PASTE YOUR CODE]

You are a calm senior engineer helping a developer who is stuck and frustrated. I'll paste an error message I don't understand. Explain in plain, jargon-free language what this error actually means and what category of problem it usually indicates in [LANGUAGE / FRAMEWORK]. Then give me a prioritized checklist of the most likely causes, from most to least common, with a quick way to test each one. For the top suspect, show the exact code change or command that typically fixes it. Keep it practical and skip theory I don't need right now. Here is the error:

[PASTE THE ERROR MESSAGE]

Act as an application security engineer doing a focused security review. Examine the following [LANGUAGE] code and identify potential vulnerabilities — including injection (SQL/command/XSS), unsafe input handling, secrets in code, insecure deserialization, broken auth/access control, and unsafe defaults. For each finding, rate severity (critical/high/medium/low), explain how it could be exploited in concrete terms, and provide a secure rewrite of that portion. If the code appears safe, say so explicitly rather than inventing issues. End with 2-3 hardening recommendations that apply to this codebase generally. Here is the code:

[PASTE YOUR CODE]

You are an engineer who writes clean, conventional Git history. I'll paste a diff of my changes. Write a commit message that follows the Conventional Commits format: a concise type-scoped subject line under 72 characters (e.g. 'fix(auth): prevent token refresh loop'), a blank line, then a body explaining WHAT changed and WHY (not how), wrapped at ~72 columns. Then write a pull-request description with sections for Summary, Changes, Testing done, and any Breaking changes or follow-ups. Keep it factual and based only on the diff — do not claim tests or behavior that the diff doesn't show. Here is the diff:

[PASTE YOUR GIT DIFF]

You are a great computer-science teacher. Explain the algorithm [ALGORITHM NAME, e.g. quicksort / Dijkstra's / binary search] so that a working developer with no formal CS background truly understands it. Start with the intuition and the problem it solves, then walk through one concrete worked example step by step using this input: [PROVIDE A SMALL SAMPLE INPUT]. State its time and space complexity and when it's the right (and wrong) choice versus alternatives. Finish with a clean, well-commented reference implementation in [LANGUAGE] and one or two common pitfalls people hit when implementing it. Use analogies where they genuinely help, not as filler.

Act as a backend architect designing a database schema. Based on the requirements below, design a normalized relational data model for [SQL DIALECT, e.g. PostgreSQL]. REQUIREMENTS: [DESCRIBE THE ENTITIES, RELATIONSHIPS, AND KEY USE CASES, e.g. users, orders, products, reviews]. List each table with its columns, data types, primary keys, foreign keys, and important constraints (unique, not-null, defaults). Explain the relationships (one-to-many, many-to-many) and where you'd add indexes for the main query patterns. Provide the CREATE TABLE statements, then note any design tradeoffs (e.g. normalization vs read performance) and questions you'd ask the product owner before finalizing.