100 AI Prompts for Developers & EngineersSpeed up debugging, write better docs, and level up your career with AI.

Review this pull request and identify: (1) potential bugs or logic errors, (2) performance issues, (3) security vulnerabilities, (4) code style inconsistencies, and (5) anything missing from the tests. Code: [paste code here]

Explain this error message in plain English and give me the 3 most likely root causes with steps to diagnose each: [paste error here]

Identify edge cases that my code doesn't currently handle. Think through boundary conditions, null/undefined inputs, concurrency issues, and failure modes. Function: [paste code]

Generate a comprehensive test suite for this function using [Jest/pytest/etc]. Include unit tests for happy paths, edge cases, error conditions, and boundary values. Function: [paste code]

This legacy code works but is hard to maintain. Refactor it to be more readable and modular without changing its behavior. Add comments explaining the non-obvious parts. Code: [paste code]

I'm getting a [type of error] in production but can't reproduce it locally. Walk me through a systematic debugging checklist — what to check, logs to pull, and hypotheses to test.

Review this database query for performance issues. Suggest indexes, rewrites, or caching strategies that would improve speed. Query: [paste query]

This code has a bug where [describe behavior]. Walk me through a step-by-step debugging approach using console.log / breakpoints / profiling — starting with the most likely culprit.

Write a code review comment for this code that is constructive, specific, and includes a suggested fix or alternative approach. Tone: collaborative, not critical. Code: [paste code]

Analyze this function for security vulnerabilities — SQL injection, XSS, authentication bypass, insecure deserialization, etc. Code: [paste code]

Write a README for this project. Include: project overview, tech stack, local setup instructions, environment variables needed, how to run tests, and deployment notes. Project details: [describe project]

Write API documentation for this endpoint in OpenAPI/Swagger style. Include description, parameters, request body schema, response schemas (success + error), and 2–3 usage examples. Endpoint: [describe or paste]

Write an Architecture Decision Record (ADR) for the decision to [use technology/pattern]. Include: context, decision, rationale, alternatives considered, and consequences.

Create an onboarding guide for a new developer joining a team working on [type of project]. Cover: codebase overview, how to run it locally, key architectural patterns, team workflows, and where to find help.

Write inline code comments for this function that explain WHY it works the way it does — not just WHAT it does. Focus on non-obvious logic, performance tradeoffs, and gotchas. Code: [paste code]

Convert this technical specification into a plain-English summary a non-technical stakeholder could understand. Keep it under 200 words. Spec: [paste spec]

Write a CHANGELOG entry for this release. Format: version number, release date, and organized bullet points under Added / Changed / Fixed / Removed. Changes: [describe changes]

Create a troubleshooting guide for the top 5 most common issues developers face when setting up [project/tool]. Include symptoms, likely cause, and step-by-step fix.

Write a technical blog post outline explaining [complex technical topic] to a mid-level engineer audience. Include: hook, problem statement, core concepts, practical walkthrough, and key takeaways.

Review this documentation for clarity, completeness, and accuracy. Flag anything that's confusing, outdated, or missing. Suggest specific rewrites for the weakest sections. Docs: [paste docs]

Design a scalable architecture for [describe system]. Include: components, data flow, storage choices, caching strategy, and how it handles 10x traffic growth. Draw it as a component diagram in text format.

Compare these two architectural approaches for [use case]: [Option A] vs [Option B]. Analyze: performance, scalability, complexity, cost, and operational overhead. Which would you recommend and why?

Design a database schema for [describe application]. Include: tables/collections, key fields, relationships, indexes, and explain your normalization decisions. Consider read vs write patterns.

Design a RESTful API for [describe resource/domain]. Include: endpoints, HTTP methods, URL structure, request/response schemas, error codes, versioning strategy, and authentication approach.

Break down this monolithic application into microservices. Identify: service boundaries, what each service owns, how they communicate, shared infrastructure, and migration sequence. App description: [describe app]

Design a caching strategy for [describe system]. Cover: what to cache, cache invalidation approach, TTLs, cache layers (CDN, in-memory, database), and failure scenarios.

Review this system design for potential failure points. For each: what breaks, how severe, how to detect it, and how to prevent or recover from it. Design: [describe architecture]

Design the data pipeline for [describe use case — analytics, ML, real-time events, etc.]. Include: data sources, ingestion approach, transformation steps, storage, and consumption patterns.

I need to choose between [Technology A] and [Technology B] for [use case]. Give me a structured trade-off analysis covering: fit for use case, scalability, operational complexity, community/support, and cost.

Design an authentication and authorization system for [describe app]. Cover: auth strategy (JWT, OAuth, sessions), role-based access, token lifecycle, and security considerations.

Run a mock technical interview for a [role — senior frontend, backend, full-stack, etc.] position. Ask me 3 LeetCode-style coding questions (medium difficulty), then give me feedback on my solutions.

Ask me a system design interview question for a [senior/staff] engineer role. After I answer, give me feedback on: clarity, coverage of key components, scalability thinking, and what I missed.

Help me answer this behavioral interview question using the STAR format (Situation, Task, Action, Result): "[question, e.g., Tell me about a time you led a technically complex project]". My experience: [briefly describe]

Rewrite these resume bullet points for a software engineer applying to [company/role type]. Make each bullet start with a strong action verb, include a metric, and highlight impact. Current bullets: [paste bullets]

Write a negotiation script for a software engineer salary conversation. I received an offer of $[X] for [role] and want to counter at $[Y]. Include: opener, rationale, how to handle pushback, and closing.

Create a 12-week learning plan for a software engineer who wants to get better at [skill — system design, distributed systems, Rust, ML engineering, etc.]. Include: resources, weekly goals, and a capstone project.

Write 5 strong questions I should ask at the end of a software engineering interview at [company type — startup, FAANG, etc.]. Questions that show technical depth and genuine interest, not generic ones.

I want to transition from [current role — backend, frontend, mobile] to [target role — staff engineer, engineering manager, ML engineer]. Create a 6-month transition plan with milestones.

Write a LinkedIn summary for a software engineer with [X years] of experience in [tech stack/domain] who is [goal — open to new roles, building a personal brand, transitioning to staff engineering].

Give me a cheat sheet of the 10 most important concepts I need to master for a senior [frontend/backend/full-stack] engineer interview. For each: what it is, why it matters, and a common interview angle.

Write a Git commit message for this change following Conventional Commits format. Be specific about what changed and why — not just what files were modified. Change description: [describe the change]

Write a Jira ticket for this feature request. Include: user story, acceptance criteria, technical notes, definition of done, and estimated complexity (XS/S/M/L/XL). Request: [describe feature]

Summarize this sprint retrospective. Organize the feedback under: What went well, What didn't go well, Action items (with owners), and Key themes to carry forward. Raw notes: [paste notes]

Write a stakeholder update email about [project/milestone]. Audience: non-technical product and business stakeholders. Cover: progress, what's next, risks, and what you need from them. Keep it under 200 words.

Create a knowledge base article explaining [technical concept or process] for our internal engineering wiki. Include: overview, step-by-step instructions, common pitfalls, and links to related resources.

Write a technical spec for [feature or system]. Include: problem statement, proposed solution, implementation approach, API changes, data model changes, open questions, and success metrics.

I have these tasks to complete today: [list tasks]. Help me prioritize using the Eisenhower Matrix and suggest a time-blocked schedule given I have [available hours] of deep work time.

Write a post-mortem for this incident: [describe incident]. Include: timeline, root cause analysis, customer impact, contributing factors, remediation steps taken, and action items to prevent recurrence.

Create an engineering onboarding checklist for a new [frontend/backend/full-stack] engineer joining our team. Cover: local setup, codebase orientation, first-week goals, key contacts, and 30/60/90 day milestones.

Write a proposal to engineering leadership for [technical initiative — refactoring, new tooling, process change]. Include: current pain point, proposed change, estimated effort, expected ROI, and risks.