Best Prompts for Coding: 25+ Production Engineering Templates (2026)

System Directive:
You are a Principal Distributed Systems Architect and Staff Software Engineer. I need to design an end-to-end technical architecture and engineering RFC for a new software system from complete scratch.

Execution Protocol:
1. Do not generate code or architectural blueprints immediately.
2. Conduct an interactive discovery consultation with me by asking exactly ONE question at a time. Wait for my answer before proceeding to the subsequent question.
3. Architectural Diagnostic Sequence:
   - Question 1: What is the core business capability of this system, what are the expected throughput requirements (requests per second, daily active users), and what are the P99 latency SLA targets?
   - Question 2: What is your preferred core technology stack (runtime language, web framework, primary database, caching layer, messaging broker)?
   - Question 3: What data persistence characteristics are required (ACID transaction guarantees, eventual consistency, high-read vs. high-write, relational vs. document)?
   - Question 4: What are the primary failure domains, network boundaries, and third-party API dependencies that could fail?
   - Question 5: What deployment environment and infrastructure constraints apply (AWS serverless, Kubernetes, Docker containers, bare metal)?
4. After I answer Question 5, synthesize my inputs into a comprehensive Senior Staff Technical Design Document (TDD) complete with component diagrams, relational data schemas, error budgets, and failure recovery protocols.

Act as a Principal Staff Software Engineer. Write a comprehensive Technical Design Document (TDD) for the following engineering initiative:

Initiative Parameters:
- System / Feature Name: [e.g., Real-Time Collaborative Document Workspace / Distributed Event Ingestion Engine]
- Primary Tech Stack: [e.g., TypeScript, Next.js 15, Node.js v22, PostgreSQL, Redis Pub/Sub, WebSockets]
- Scale & SLA Targets: [e.g., 25,000 concurrent active connections, <80ms P99 message delivery latency]

Deliverables:
1. System Architecture Overview: High-level component interaction described in clear ASCII diagrams showing data ingestion, caching, and persistence pathways.
2. Data Model & Schema: Complete SQL DDL tables with typed fields, primary/foreign keys, UUID identifiers, and specific indexing strategies (B-Tree, GIN, partial indexes).
3. Failure Modes & Edge Cases: Detailed breakdown of 4 specific failure scenarios (network partitions, race conditions in concurrent writes, Redis cache invalidation, connection pool exhaustion) with explicit recovery protocols.
4. Security & Access Control: Authentication flow, session token validation, RBAC permission models, and input sanitization boundaries.
5. Phased Rollout Plan: Feature flagging strategy, database migration steps, canary deployment gates, and automated rollback triggers.

Act as a Principal Database Reliability Engineer (DBRE) and PostgreSQL/MySQL Performance Specialist.

Application Context:
- Domain: [e.g., Multi-Tenant B2B SaaS Invoicing Platform]
- Read/Write Ratio: [e.g., 85% Read / 15% Write]
- High-Traffic Query Pattern: [DESCRIBE THE MOST FREQUENT 2-3 QUERIES, e.g., Fetching all unpaid invoices for a specific workspace filtered by date]

Design a Production Database Schema:
1. SQL DDL Table Definitions: Fully typed SQL table definitions with constraints (NOT NULL, CHECK, UNIQUE, FOREIGN KEY with ON DELETE behaviors).
2. Targeted Indexing Strategy: Exact index creation commands (B-Tree, Composite indexes, Partial indexes) optimized specifically for the high-traffic query patterns, explaining why each index column order matters.
3. Concurrency & Locking Strategy: Explain how to handle concurrent row updates without deadlock (e.g., SELECT ... FOR UPDATE, optimistic locking with version columns).
4. Zero-Downtime Migration Script: A safe, backward-compatible migration script to apply schema changes without locking active production tables.

You are a Staff Systems Reliability Engineer and Core Runtime Specialist. Analyze the following production defect:

Runtime Environment:
- Stack / Version: [e.g., Node.js v22 on AWS Lambda with PostgreSQL / Python 3.12 with FastAPI]
- Deployment Context: [e.g., Fails intermittently under concurrent load]

Error Log & Stack Trace:
```
[PASTE EXACT ERROR LOGS / STACK TRACES HERE]
```

Failing Code Snippet:
```
[PASTE FAILING SOURCE CODE HERE]
```

Execution Protocol:
1. Root Cause Analysis: Explain the exact runtime condition triggering the failure (e.g., unhandled promise rejection, event loop starvation, off-by-one pointer arithmetic, or race condition).
2. Minimal Reproduction Case: Write a minimal, self-contained test script that reliably triggers this error in under 5 lines of code.
3. Surgical Patch: Provide the minimal code diff required to fix the bug without altering public API signatures or breaking downstream dependencies.
4. Automated Regression Test: Write a unit test (Pytest / Vitest / Jest) that fails on the unpatched code and passes with your patch.

Act as a Systems Performance & Concurrency Engineer.

Performance Issue Observed:
- Symptoms: [e.g., Node.js memory steadily climbing until OOM crash / Python asyncio tasks hanging / Go goroutines leaking]
- Telemetry: [e.g., P99 latency spikes to 15s after 6 hours of continuous runtime; CPU at 98%]

Suspicious Code Excerpt:
```
[PASTE RELEVANT ASYNC OR CONCURRENT CODE HERE]
```

Investigative Protocol:
1. Failure Hypothesis: Identify the exact resource retention mechanism (e.g., unclosed database connection pools, global event listener accumulation, circular object references, or unbuffered channels).
2. Concurrency Trace: Map the sequence of asynchronous events leading to deadlock, starvation, or memory accumulation.
3. Hardened Refactor: Provide the refactored code incorporating proper cleanup handlers, context timeout propagation (`context.WithTimeout`), and bounded worker pool concurrency.

Act as a Senior Software Refactoring Specialist and Static Analysis Expert.

Migration Parameters:
- Source Language / Framework: [e.g., Legacy React Class Components with Redux / Python 2.7 monolithic script]
- Target Modern Stack: [e.g., React 19 Function Components with TypeScript & Zustand / Python 3.12 with Pydantic & Asyncio]

Legacy Code to Modernize:
```
[PASTE LEGACY CODE HERE]
```

Modernization Directives:
1. 100% Behavioral Equivalence: Every input, output, side effect, and error behavior must remain identical.
2. Idiomatic Refactoring: Apply modern syntax conventions (strict TypeScript types, async/await, immutability, proper hooks lifecycle).
3. Technical Debt Elimination: Remove deprecated lifecycle methods and antipatterns.
4. Migration Unit Test: Provide an automated test verifying that the modern refactor produces identical outputs across 5 edge-case test vectors.

Act as a Principal Software Development Engineer in Test (SDET).

Target Code Under Test:
```
[PASTE CODE / FUNCTION / SERVICE CLASS HERE]
```

Testing Framework: [e.g., Pytest (Python) / Vitest with TypeScript / Jest / Go testing]

Generate an Exhaustive Test Suite:
1. Happy-Path Verification: Tests confirming expected behavior with standard valid inputs.
2. Boundary Value Analysis: Explicit tests for boundary values (0, 1, -1, max integer, empty strings, empty arrays, null/undefined).
3. Malformed & Error Handling: Tests verifying that malformed payloads trigger expected typed exceptions with correct HTTP/error status codes.
4. Dependency Isolation & Mocking: Clean mocks for external database calls, third-party APIs, and filesystem interactions.
5. Code Structure: Group tests into logical `describe()` blocks with self-documenting test names.

You are a Formal Methods and Property-Based Testing Engineer.

Target Function / Algorithm:
```
[PASTE ALGORITHM OR DATA PARSING FUNCTION HERE]
```
Testing Tool: [e.g., Hypothesis (Python) / fast-check (TypeScript/JS)]

Your Mission:
1. Invariant Identification: Define 3 fundamental mathematical or logical invariants that must hold true for this function regardless of the input (e.g., idempotent operations, round-trip serialization `decode(encode(x)) == x`, order independence).
2. Fuzzing Strategy: Define data generators that produce randomized, adversarial input data (including unicode null bytes, extreme floating-point values, and recursive payloads).
3. Complete Test Code: Write the executable property-based test suite that will run 1,000 automated iterations to verify invariant stability.

Act as an Enterprise Integration Test Architect.

API Endpoint Under Test:
- Route & Method: [e.g., POST /api/v1/workspaces/{id}/billing/subscribe]
- Authentication: [e.g., Bearer JWT Token with Workspace Admin Role]
- Request Payload Schema: [DESCRIBE OR PASTE JSON SCHEMA]
- Expected Response Schema: [DESCRIBE OR PASTE JSON SCHEMA]

Build a Complete Integration Test Suite (using Playwright, Supertest, or Pytest-httpx):
1. Happy Path Test: Authenticated admin sends valid payload -> Asserts 201 Created and verifies response schema matches contract.
2. Authorization & RBAC Test: Non-admin or unauthenticated request -> Asserts 401 Unauthorized / 403 Forbidden.
3. Payload Validation Test: Missing required field or invalid enum -> Asserts 422 Unprocessable Entity with structured field errors.
4. Idempotency Test: Sending identical request twice with same `Idempotency-Key` header -> Asserts 200 OK with identical payload and no duplicate charge.

Act as a Clean Architecture Consultant and Software Craftsman.

Bloated Monolithic Code:
```
[PASTE MONOLITHIC 100+ LINE FUNCTION HERE]
```

Refactoring Mandate:
1. Single Responsibility Decomposition: Break down the monolithic logic into distinct single-responsibility service classes or pure functions (e.g., Separation of Validation, Business Domain Rules, Database Persistence, and External Notification).
2. Dependency Injection: Inject external services and repositories via interfaces/types rather than hardcoding instantiations inside the function.
3. Error Handling Architecture: Implement structured domain error classes instead of generic try/catch blocks that swallow stack traces.
4. Provide the fully refactored, modular code with clean type annotations and zero functional regressions.

Act as an AI Developer Tooling Specialist and Lead Architect.

Project Parameters:
- Tech Stack: [e.g., Next.js 15 App Router, React 19, TypeScript, Tailwind CSS, Prisma, Supabase]
- Architectural Philosophy: [e.g., Server Components by default, zero `any` types, absolute path imports `@/*`]
- Coding Conventions: [e.g., Functional programming, Zod validation schemas on all server actions]

Generate a Production `.cursorrules` / AI Assistant Configuration:
1. System Role & Architecture Context: Define how the AI should reason about the project structure.
2. Strict Code Generation Rules:
   - File placement and naming conventions.
   - Component guidelines (Server vs. Client components).
   - Error handling and logging standards.
3. Banned Antipatterns: Explicit list of outdated patterns to never emit (e.g., no Pages Router, no `useEffect` for data fetching).
4. Few-Shot Exemplar: Provide 1 model component demonstrating the exact desired file structure.

You are a Senior Application Security (AppSec) Penetration Tester and Code Auditor.

Source Code to Audit:
```
[PASTE APPLICATION CODE, CONTROLLER, OR DATABASE QUERY HERE]
```

Audit Protocol (Evaluating Against OWASP Top 10):
1. Vulnerability Sweep: Scan for:
   - SQL / NoSQL Injection risks.
   - Broken Object Level Authorization (BOLA / IDOR).
   - Server-Side Request Forgery (SSRF) and unsanitized redirects.
   - Hardcoded secrets, API tokens, or insecure default configurations.
2. Exploit Proof-of-Concept: For each vulnerability identified, explain the exact malicious payload an attacker could submit to exploit it.
3. Remediated Code: Provide the hardened, patched code utilizing parameterized queries, strict authorization checks, and safe sanitization libraries.

Act as a Principal DevOps & Container Security Engineer.

Application Profile:
- Runtime / Language: [e.g., Node.js v22 Next.js Standalone / Python 3.12 FastAPI with Poetry / Go 1.23 binary]
- Production Requirements: [e.g., Minimal image size under 100MB, non-root user execution, security hardened]

Generate a Production Multi-Stage `Dockerfile` and `.dockerignore`:
1. Multi-Stage Pipeline:
   - Stage 1 (`builder`): Dependency installation and compilation.
   - Stage 2 (`runner`): Minimal base image (Alpine or Distroless) copying only required production artifacts.
2. Container Hardening:
   - Create and switch to a non-root user (`USER appuser`).
   - Eliminate dev dependencies, package manager caches, and build tools.
3. Health Check Directive: Add a native `HEALTHCHECK` command verifying container readiness.
4. Companion `.dockerignore`: Exhaustive file excluding `.git`, `node_modules`, `.env`, and test artifacts.

Act as a Staff Site Reliability Engineer (SRE) and CI/CD Pipeline Specialist.

Project Requirements:
- Repository Type: [e.g., TypeScript Monorepo / Python Backend API]
- Pipeline Triggers: Pull requests to `main` and releases tagged `v*`.
- Automated Tasks: Linting (ESLint/Ruff), Type-checking, Automated Unit Tests with Postgres service container, Docker image build, and AWS/Cloudflare deployment.

Build a Complete `.github/workflows/deploy.yml` Workflow:
1. Dependency Caching: Cache package manager dependencies (npm/pnpm/pip) to achieve sub-2-minute build times.
2. Parallel Matrix Execution: Run unit tests across multiple runtime versions or environments simultaneously.
3. Service Containers: Spin up ephemeral PostgreSQL and Redis service containers for integration testing.
4. Secure Secret Injection: Properly inject production API keys and credentials using GitHub Repository Secrets.

Act as a Principal Backend API Architect.

Endpoint Specification:
- Resource / Entity: [e.g., Organization Team Membership Management]
- Methods: [e.g., POST (Invite Member), GET (List Members with Pagination), DELETE (Revoke Membership)]
- Framework: [e.g., FastAPI (Python) / Express with Zod (TypeScript) / Go Chi]

Generate Production API Implementation:
1. Typed Request / Response Schemas: Pydantic / Zod models with field validation, regex constraints, and documentation descriptions.
2. Controller Route Implementation: Clean route handlers incorporating:
   - JWT authentication and role-based authorization middleware.
   - Pagination query parameters (`page`, `page_size`, `sort_by`).
   - Structured JSON error responses (`400`, `401`, `404`, `409 Conflict`).
3. OpenAPI Documentation: Docstrings formatted to automatically generate interactive Swagger / Redoc API specifications.