Claude Prompts for Engineering

Generate clear, complete API documentation for one or more endpoints — covering request/response schemas, authentication, error codes, rate limits, and usage examples that developers can use immediately.

Produce a complete integration plan for connecting to a third-party API — covering authentication, data mapping, error handling, rate limiting, testing strategy, and operational concerns.

Document a significant architectural decision with full context, the options considered, the decision made, and the consequences — so future engineers understand why the system is designed the way it is.

Surface the real trade-offs in a technical design, weight them against the team's actual context, and recommend with named assumptions.

Turn a list of merged pull requests into a clean, customer-readable changelog grouped by impact, with internal-only items filtered out.

Run a code review at the level of a senior engineer who has been burned: hidden state, error paths, performance cliffs, security, and the change's effect on the surrounding system.

Debug an issue by generating a ranked tree of hypotheses, the cheapest test for each, and what each result rules in or out.

Break down a function, module, or system into plain English — explaining what it does, why it's written that way, and what someone needs to know to work with it confidently.

Critically evaluate a database schema or data model — identifying normalization issues, missing constraints, indexing gaps, and design patterns that will cause problems at scale — with concrete improvements.

Systematically diagnose an error message by analyzing the stack trace, context, and code — and produce a root cause explanation with a concrete fix.

Generate a complete, step-by-step developer environment setup guide that gets a new engineer from zero to running the project locally — covering prerequisites, installation, configuration, and validation.

Generate a thorough, blameless incident postmortem that captures the timeline, root cause, contributing factors, and concrete action items — turning an outage into lasting organizational learning.

Analyze a monolithic application and produce a decomposition plan — identifying service boundaries, migration sequence, communication patterns, and the risks of the split — with a phased approach that keeps the system running throughout.

Generate a database migration script with rollback, safety checks, batching for large tables, and a step-by-step execution plan that minimizes downtime and risk.

Analyze a function, endpoint, or system component for performance bottlenecks — identifying N+1 queries, unnecessary computation, memory leaks, and algorithmic inefficiencies with specific fixes and benchmarking guidance.

Conduct a thorough pull request review covering correctness, security, performance, test coverage, and code quality — with prioritized, actionable feedback for each finding.

Generate a complete, well-structured README that helps developers get from zero to working in the shortest possible path — covering what it does, how to install it, how to use it, and how to contribute.

Analyze a function or module and produce a refactored version that improves readability, reduces complexity, and addresses performance issues — with a full explanation of every change.

Refactor code with an explicit rationale and risk note for every change, so reviewers can evaluate the diff one decision at a time.

Write a regex pattern for a specific matching or extraction task, with a full explanation of each component, test cases, and edge case handling.

Transform raw code review observations into polished, professional feedback — clearly communicating the issue, the reasoning, and the suggested fix without being discouraging or vague.

Generate a complete operational runbook for a service — covering startup/shutdown, health checks, common failure scenarios with step-by-step resolution procedures, escalation paths, and on-call guidance.

Systematically assess a feature or code change for security vulnerabilities — covering OWASP Top 10, authentication, authorization, data exposure, and input handling — with severity ratings and concrete fixes.

Analyze a slow SQL query, identify the root cause of performance issues, and produce an optimized version with indexing recommendations and a performance comparison.

Critically evaluate a system design proposal — assessing scalability, reliability, data consistency, security, operational complexity, and cost — with prioritized feedback and alternative approaches.

Systematically compare technology options for a technical decision — evaluating fit, maturity, team readiness, operational cost, and long-term risk — and produce a structured recommendation with clear rationale.

Generate comprehensive unit tests for a function or module — covering happy paths, edge cases, error conditions, and boundary values with clear test names and documentation.