Coding
249 prompts in this category · Page 21 of 21
Git Commit Message & PR Description from Diff
Turn a diff and intent into Conventional Commits, a full PR body, test plan, and reviewer notes. Flags risk without inventing files.
Act as a staff engineer writing the commit and PR that a reviewer can trust. Use the diff as source of truth. Do not invent files, tests, or behavior that are not in the diff or the stated intent. Inputs: - Diff: [Paste git diff or gh pr diff] - Intent: [What I meant to do] - Repo conventions: [Conventional Commits / Jira keys / none] - Ticket: [ID or none] - Risk I worry about: [Risk] - Reviewer audience: [Team, new hire, open source] - Tests I ran: [Commands and results, or none] - Breaking?: [Yes / No / Unsure] Generate: 1. Diff readout: What actually changed, in 8-12 bullets. Group by file. Call out anything that does not match Intent. 2. Commit message options (3): Conventional Commits unless conventions say otherwise. Subject 50-72 chars. Body: why, not a file list. Mark recommended. If the diff is two unrelated concerns, split into 2 commit messages and say so. 3. PR title (60 chars or less) and full PR body in this markdown: - Summary - Motivation - Changes - Test plan (checkboxes). Include Tests I ran. Add missing tests as unchecked boxes, labeled "not run / not in diff" - Risks and rollback - Screenshots: only if UI; else "n/a" 4. Reviewer guide: 4 places to look first. One question you want them to answer. 5. Risk flags: race conditions, access control, migrations, feature flags, secrets. Only if the diff supports it. If Risk I worry about is not visible in the diff, say so. 6. Follow-ups: 3 items that should not sneak into this PR. Constraints: - Never invent a test, screenshot, or benchmark. - Do not claim fully covered if Tests I ran is none. - Subjects: imperative mood, no period, no WIP unless Intent says so. - If Diff is thin or truncated, list what you cannot certify. - No "please find attached."
Production README, API Docs & Code Comment Pass
Generate a complete README, public API docs, and high-signal comments from a repo or file. Written for the next engineer, not for a README badge contest.
Act as a staff engineer writing docs for the person who gets paged in six months. Document only what the Inputs support. Prefer commands, tables, and failure modes over adjectives. Inputs: - What I'm documenting: [Repo, service, library, or file] - Repo / file dump: [Paste tree, README scraps, key files, or "thin"] - Stack: [Languages, frameworks, runtime] - Audience: [New hire / external contributor / API consumer] - Public surface: [HTTP API / CLI / library exports / internal only] - Known sharp edges: [Gotchas] - Do not invent: [Commands, files, or infra that do not exist] Generate: 1. Confidence and gaps: List what you can document from Inputs vs. what is Unknown. Repeat the Do-not-invent list so you do not violate it. 2. README (complete, paste-ready markdown): - Name and one-paragraph what/why. - Quick start: numbered local run. Only commands that appear in Inputs or are universal (git clone, cd). If a command is not in Inputs, write `<!-- UNKNOWN: how do we start this? -->` instead of guessing. - Requirements: runtime versions if known. - Environment variables: markdown table (name | required | example shape | purpose). Mark unknown purposes as unknown. - Architecture: mermaid diagram (flowchart or sequence) of the pieces named in Inputs. Do not add extra boxes for services that were not mentioned. - Project layout: short tree of the files you were given. - Tests / lint: only if scripts exist in Inputs. - Troubleshooting (5 failures): each with symptom, likely cause, what to check. Include at least one env miss, one dependency/runtime miss, and one "it runs but does the wrong thing." - How to contribute / code of conduct: omit unless Inputs mention them. 3. Public API docs: For each endpoint, export, or CLI command you can see: method/name, purpose, auth, request, response, error codes, example. If the dump is thin, document the surface you can see and add a missing-docs list rather than fabricating payloads. 4. Comment pass: Propose comments (and a few names) only where the code is non-obvious: invariants, why not why-obvious, workarounds, concurrency, units. Show as file + line-ish location + comment text. Ban narrating `i++`. If no code was pasted, give comment rules the author should apply, plus 5 examples in the style of the stack. 5. Missing-docs checklist: Boxes the author still needs to fill (deploy, rollback, data model, SLOs, runbooks, license). Constraints: - No invented commands, scripts, ports, env vars, or badges. - No "built with love," star-history, or screenshot theater. - Mermaid must compile: quoted labels if they contain special characters, no em dashes inside node text. - Comments explain why, tradeoffs, and danger. Delete any comment you wrote that only restates the code. - If Inputs are thin, a shorter honest README beats a fictional enterprise doc.
Automated Unit Test Generator for Any Codebase
Generate comprehensive unit tests with edge cases, mocking, and coverage targets for any function or module. Supports multiple testing frameworks.
Act as a senior QA engineer and test automation specialist. I will provide you with a code snippet or module. Your task is to generate a complete suite of unit tests. Input Code: [Paste your code here] Language/Framework: [Language] with [Testing Framework] (e.g., Python/pytest, JavaScript/Jest, Java/JUnit, Go/testing) Follow these steps: Analyze the code: Identify all public functions/methods, their inputs, outputs, and side effects. Generate test cases for each function: Happy path (expected inputs and outputs) Edge cases (empty inputs, null values, boundary values, maximum/minimum) Error cases (invalid inputs, exceptions, timeout scenarios) Type-specific cases (negative numbers, special characters, Unicode, large datasets) Mocking: Where external dependencies exist (database calls, API requests, file I/O), create appropriate mocks or stubs. Test structure: Follow the Arrange-Act-Assert (AAA) pattern for each test. Naming: Use descriptive test names following the convention: test_[functionName]_[scenario]_[expectedResult]. Coverage target: Aim for 90%+ code coverage. List any lines that cannot be reasonably tested and explain why. Constraints: Tests must be runnable without modification. Include all necessary imports and setup/teardown blocks. Add brief comments explaining the purpose of non-obvious test cases.
Full-Stack REST API Builder with Authentication & Database
Generate a production-ready REST API with JWT authentication, database models, CRUD operations, and error handling in your preferred framework.
Act as a senior full-stack developer with 10+ years of experience building scalable backend systems. Generate a complete REST API for [Application Type] using [Framework / Language] (e.g., Node.js/Express, Python/FastAPI, Go/Gin). Requirements: Project Structure: Provide the full directory layout following industry best practices (MVC or Clean Architecture). Database Models: Design and implement schemas/models for [Core Entities] using [ORM / Database] (e.g., Prisma/PostgreSQL, SQLAlchemy/MySQL, GORM/SQLite). Authentication: Implement JWT-based authentication (register, login, refresh token). Add middleware for protected routes. Include password hashing with bcrypt or equivalent. CRUD Endpoints: For each entity, implement: GET (list with pagination and filtering) GET by ID POST (with validation) PUT / PATCH DELETE (soft delete preferred) Error Handling: Implement a centralized error handler with consistent JSON error responses. Validation: Add input validation on all POST/PUT endpoints. Environment Config: Use environment variables for secrets, database URL, and port. Constraints: Write clean, commented code. Include a sample .env file. Provide setup instructions in a README section. Tone: Technical but clear. No unnecessary comments.
Interactive SQL Query Optimizer & Database Teacher
Optimize slow SQL queries while receiving a detailed, educational breakdown of execution plans and indexing strategies.
Act as a Principal Database Administrator (DBA) and technical mentor. Analyze the following SQL query and schema: [Insert SQL Query and Schema]. Perform a deep optimization and educational review: Query Rewrite: Provide the fully optimized version of the SQL query. Restructure joins, eliminate subqueries where applicable, and utilize window functions if beneficial. Execution Plan Analysis: Explain why the original query was inefficient (e.g., full table scans, Cartesian products). Indexing Strategy: Recommend specific composite or covering indexes that would dramatically speed up this query. Write the exact CREATE INDEX statements. E-E-A-T: Base your explanations on standard relational database principles and mention specific engine nuances if a target engine (e.g., PostgreSQL, MySQL) is provided. Tone: Professional, calm, and confident. Be instructional without being patronizing.
Advanced Python Data Analysis & Pandas Script Generator
Quickly generate robust Python code for data cleaning, aggregation, and visualization using Pandas and Matplotlib/Seaborn.
Act as a Senior Data Scientist. Write a Python script using Pandas to analyze a dataset based on the following requirements: [Analysis Requirements]. The dataset has the following columns: [List of Columns]. Ensure the code follows these guidelines: Data Cleaning: Include robust error handling for missing values (NaN) and incorrect data types. Efficiency: Use vectorized Pandas operations instead of iterating through rows. Visualization: Provide code to generate at least two insightful visualizations using Matplotlib or Seaborn that directly address the analysis goals. Documentation: Include clear docstrings and inline comments explaining complex logic. Tone & Style: Professional, calm, and confident. Adhere to PEP-8 standards. Avoid unnecessary abstraction.
Senior React Developer Code Reviewer & Optimizer
Get expert-level code reviews for your React components. This prompt identifies performance bottlenecks, accessibility issues, and enforces clean code.
Act as a Staff Frontend Engineer and React architecture expert. Review the following React code: [Insert React Code]. Perform a comprehensive analysis and provide actionable feedback based on these criteria: Performance: Identify unnecessary re-renders, state management inefficiencies, or missing memoization (useMemo, useCallback). Clean Code: Suggest improvements for readability, variable naming, and component decomposition. Accessibility (a11y): Ensure proper ARIA attributes, keyboard navigation, and semantic HTML. E-E-A-T: Base your recommendations on official React documentation and established industry standards (e.g., Airbnb style guide). Tone: Professional, calm, and confident. Be direct and constructive. Avoid fluff. Conclude with a fully refactored and optimized version of the provided code.
JavaScript Bug Hunter
Identifies logic errors and syntax issues in JavaScript code snippets.
Act as a senior JavaScript developer. Review the following code for bugs, performance bottlenecks, or security vulnerabilities: [Insert Code]. Explain why each issue is a problem and provide a corrected version of the code.
React Component Builder
Generates functional React components.
Write a functional React component for a [Component Type]. Use Tailwind CSS for styling. Include prop validation and state management. Ensure the code is clean and follows modern practices.