Prompts for Software Development

20 ready-to-use ChatGPT prompts for software development. Fill in the bracketed fields, paste into ChatGPT, and go.

Engineering · 20 prompts

01

Write Python Registration Validation with Structured Errors and Password Policy Checks

Generate Python registration validation logic that enforces email and password policy rules, returns structured errors, and is easy to plug into an API or form handler.

You’ll needvalidation rulesframework contexterror formatpassword policynormalization needsconstraints
Prompt
You are a senior software engineer.

Produce code or a code scaffold for Python user registration validation with structured errors.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: a password policy checked only for length with no check against a common-password or breach list, error messages that reveal which specific field failed in a way that helps an attacker enumerate valid usernames or emails, validation logic duplicated between client and server with no single source of truth, and input sanitized for display but not normalized before uniqueness checks, letting near-duplicate accounts slip through.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including enumeration-safe error handling)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
02

Design and Implement a Flask REST API with Resource Boundaries, Validation, and Production-Ready Basics

Generate a Flask REST API with resource boundaries, request validation, error handling, persistence assumptions, and production-ready basics so the result can grow beyond tutorial-grade CRUD.

You’ll needdata modelauth needsstorage approachresponse formattesting expectationsoperational constraints
Prompt
You are a senior software engineer.

Produce code or a code scaffold for a Flask REST API with resource boundaries and validation.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: resource ownership not checked, so one user's ID in a URL can access or modify another user's data, error responses inconsistent between endpoints with some returning stack traces and others generic messages, no pagination on list endpoints so the API degrades as data grows, and input validation applied inconsistently across routes instead of through a shared layer.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including ownership-check tests)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
03

Design a Unit Test Strategy for a JavaScript Pricing Function with Edge-Case and Change-Risk Coverage

Design a unit test strategy for a JavaScript pricing function with edge-case coverage, failure-path checks, and the kinds of regressions most likely to break revenue logic.

You’ll needfunction behavioredge casestest frameworkchange riskintegration assumptionsconstraints
Prompt
You are a senior software engineer advising on a real implementation rather than teaching a generic tutorial.

Help with the engineering task below.

Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]

Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: tests written only for the happy path of the pricing function, missing boundary conditions like zero, negative, or extremely large inputs that actually break pricing logic, floating-point comparison done with exact equality instead of a tolerance, causing false test failures, no test for a change in one pricing rule silently breaking an unrelated one, and mocks used so heavily that the test verifies the mock's behavior instead of the actual function's.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.

Output format:
- Test cases covering boundary and edge conditions
- Floating-point comparison strategy
- Change-risk coverage across pricing rules
- Mock usage that verifies real behavior
- Main assumptions and risks

Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.

Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
04

Automate ESLint and Prettier with Project Scripts and Pre-Commit Hooks

Develop a linting and formatting setup for a JavaScript project that covers project scripts, file targeting, optional pre-commit hooks, and conflict-free tool configuration.

You’ll needproject structuretoolingscripts setuppackage managerhook preferencesconstraints
Prompt
You are a senior software engineer.

Produce code or a code scaffold for an ESLint and Prettier automation setup with pre-commit hooks.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: ESLint and Prettier rules that conflict with each other, causing the pre-commit hook to fight itself on every commit, the hook configured to auto-fix silently instead of failing loudly on rules that shouldn't be auto-corrected, no fallback for a developer whose editor doesn't run the hook, letting broken formatting reach CI anyway, and rule changes applied retroactively to the whole codebase in one commit, creating an unreviewable diff.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including CI-side fallback enforcement)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
05

Set Up Docker for a Node Backend and MongoDB with Dev and Local Environment Boundaries

Create a guide for containerizing a Node backend with MongoDB that covers local development ergonomics, environment variables, network setup, and persistent data decisions.

You’ll neednode app structuredatabase needsdocker goalslocal development needsenvironment configconstraints
Prompt
You are a senior software engineer advising on a real implementation rather than teaching a generic tutorial.

Help with the engineering task below.

Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]

Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: the MongoDB data volume not actually persisted correctly, so a container restart silently wipes local data, environment variables for credentials hardcoded into the compose file instead of a gitignored env file, no health check or startup ordering so the Node service starts and fails before Mongo is ready, and the local Docker setup diverging enough from production configuration to give false confidence in local testing.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.

Output format:
- Volume persistence verification
- Credential handling via env file
- Startup ordering and health checks
- Local-vs-production configuration parity
- Main assumptions and risks

Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.

Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
06

Plan Version Control Standards for a Large Project with Review and Release Discipline

Write a plan for Git and GitHub standards in a large project covering branch policy, review flow, release discipline, and the failure patterns the team needs to prevent.

You’ll needteam sizebranching modelrelease flowpain pointscompliance or audit needs
Prompt
You are a senior software development architect creating a plan for a real engineering initiative.

Create a plan for the task below.

Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]

Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: branch protection rules defined but never actually tested against a real failing PR, commit message or branching conventions documented but with no enforcement mechanism so they decay over time, no plan for how a large, long-running feature branch avoids painful merge conflicts, and release tagging done manually and inconsistently, making it unclear what's actually in a given release.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.

Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions

Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.

Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
07

Build a Python API-to-CSV Export Script with Pagination and Retry Handling

Create a Python export script that pulls paginated API data, normalizes records, handles retries, and writes a stable CSV output.

You’ll needapi shapecsv schemapagination behaviorauth needsretry expectationsconstraints
Prompt
You are a senior software engineer.

Produce code or a code scaffold for a Python API-to-CSV export script with pagination and retry handling.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: pagination logic that assumes every page returns a full page size, breaking on the last partial page or an API that changes its page-size behavior, no retry or backoff for transient API failures mid-export, causing a multi-hour export to fail and restart from scratch, memory usage that loads the entire dataset before writing instead of streaming to the CSV incrementally, and no handling for a field containing a comma or newline that breaks CSV structure if not properly escaped.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including partial-page and retry scenarios)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
08

Implement JWT Authentication in an Express API with Refresh and Route Protection

Generate Express API authentication code covering login, token issuance, protected routes, refresh behavior, and safe middleware boundaries.

You’ll needuser modelauth flowtoken lifespan strategymiddleware needspersistence approachconstraints
Prompt
You are a senior software engineer.

Produce code or a code scaffold for JWT authentication in an Express API with refresh and route protection.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: refresh tokens stored and validated with no rotation, so a leaked refresh token stays valid indefinitely, route-protection middleware applied inconsistently, leaving some routes unintentionally unprotected, token expiry checked only at issuance and not re-verified on each protected request, and no distinction in error responses between an expired token and an invalid one, leaking information useful to an attacker.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including route-protection coverage)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
09

Refactor Legacy Python Code Safely

Refactor legacy Python code for readability and performance without breaking current behavior.

You’ll needcode snippetcurrent behaviorperformance concernstests
Prompt
You are a senior software engineer working on a real legacy refactoring effort.

Diagnose and improve the technical issue below.

Context:
- Problem description: [problem]
- Stack or environment: [stack]
- Current system role or production impact: [system role]
- Expected behavior: [expected]
- Actual behavior: [actual]
- Relevant code, logs, traces, metrics, or signals: [evidence]

Instructions:
1. Check first for the risks that actually make legacy refactors go wrong: refactoring started with no test coverage in place first, so there's no way to confirm behavior didn't change, large-scale renames or restructuring done in the same change as actual logic changes, making the diff impossible to review safely, implicit behavior relied on elsewhere in the codebase such as a side effect or a specific exception type silently changed during cleanup, and no incremental rollout, so the entire refactor ships as one high-risk deploy instead of being validated in stages.
2. Explain the safe-refactor path in priority order based on risk, blast radius, and how easily each step can be verified.
3. Recommend fixes, mitigations, or containment steps and when each is appropriate.
4. Include how to validate the refactor and what to monitor after rollout.
5. Keep the answer concise, operational, and biased toward not changing behavior unintentionally.

Output format:
- Likely risk areas (checked against the failure modes above)
- Highest-priority safe-refactor steps
- Fix or containment options with incremental rollout
- Validation and post-refactor monitoring
- Main assumptions or risks

Missing information policy:
Ask up to 2 concise questions only if the code, production impact, or refactor scope is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prioritize behavior preservation over cosmetic cleanup.
- Name the specific failure modes above rather than generic refactoring advice.
- Explain how to verify the refactor didn't change behavior.
- Include the operational reality of shipping the change safely.
10

Set Up GitHub Actions CI/CD for a Python Project with Test, Build, and Deploy Gates

Set up a GitHub Actions workflow for a Python project with linting, tests, artifact or image build steps, deployment gates, and secret-handling guidance.

You’ll needproject typedeployment targettest setuprelease flowsecret handling constraintsconstraints
Prompt
You are a senior software engineer advising on a real implementation rather than teaching a generic tutorial.

Help with the engineering task below.

Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]

Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: secrets referenced in workflow files with no scoping, giving every job broader access than it needs, a deploy stage that runs even when the test stage fails because the job dependency isn't actually configured, no caching strategy for dependencies, making every run slower than necessary, and workflow triggers configured broadly enough that unrelated pushes trigger a full deploy pipeline.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.

Output format:
- Secret scoping per job
- Job dependency gating (deploy blocked on test failure)
- Dependency caching strategy
- Trigger scoping to relevant changes
- Main assumptions and risks

Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.

Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
11

Optimize a Search Function for Large Data with Indexing and Query Tradeoffs

Create an algorithmic plan for improving large-data search performance with indexing, query-shaping, caching, and memory-versus-latency tradeoff decisions.

You’ll needdataset characteristicsquery patternslatency goalsupdate frequencyconstraints
Prompt
You are a senior software development architect creating a plan for a real engineering initiative.

Create a plan for the task below.

Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]

Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: an index chosen based on query patterns tested in development that don't reflect the actual production query mix, index maintenance cost such as write amplification not weighed against read-speed gains, no plan for how the index handles data actually growing past the scale it was designed for, and a change in ranking or scoring logic pushed without a way to compare old versus new relevance before fully cutting over.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.

Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions

Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.

Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
12

Plan Multi-Tenancy in a SaaS Application with Isolation and Operability Tradeoffs

Draft a multi-tenancy strategy that weighs isolation level, data model, provisioning, and operational complexity instead of assuming one default architecture.

You’ll needsaas modeltenant isolation needsstackcompliance requirementsoperational maturityconstraints
Prompt
You are a senior software development architect creating a plan for a real engineering initiative.

Create a plan for the task below.

Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]

Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: tenant isolation assumed at the application layer with no database-level enforcement, so a bug in query-building logic can leak one tenant's data to another, noisy-neighbor performance impact from one tenant's heavy usage not isolated from the rest, no plan for a tenant-specific data export or deletion request, which becomes a compliance problem later, and schema or migration changes rolled out to all tenants simultaneously with no staged approach.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.

Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions

Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.

Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
13

Plan a Real-Time Notification System with WebSockets and Delivery Guarantees

Develop a plan for a WebSocket-based notification system that covers event flow, connection lifecycle, delivery expectations, and fallback behavior under scale.

You’ll needapp contextnotification typesscaledelivery guaranteesconstraints
Prompt
You are a senior software development architect creating a plan for a real engineering initiative.

Create a plan for the task below.

Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]

Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: no reconnect and message-replay strategy, so a client that briefly disconnects misses notifications with no way to catch up, delivery treated as guaranteed when the underlying transport is actually best-effort, no de-duplication for a notification that gets delivered twice due to a reconnect, and horizontal scaling across multiple server instances not accounted for, breaking delivery to a client connected to a different instance than the one that generated the event.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.

Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions

Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.

Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
14

Integrate a Third-Party Payment Gateway with Checkout, Webhooks, and Reconciliation Flow

Write a payment integration guide that covers checkout initiation, server trust boundaries, webhook reconciliation, and payment failure or retry handling.

You’ll needgateway choicecheckout flowstackorder lifecyclerefund or retry needsconstraints
Prompt
You are a senior software engineer advising on a real implementation rather than teaching a generic tutorial.

Help with the engineering task below.

Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]

Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: webhook signature verification skipped or misconfigured, opening a replay or spoofing risk, webhook events handled non-idempotently, causing duplicate order fulfillment on a retried webhook, no reconciliation process to catch payments that succeeded at the gateway but never got recorded due to a dropped webhook, and test-mode credentials or logic accidentally left active in production.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.

Output format:
- Checkout and webhook handling design
- Idempotent webhook processing
- Reconciliation process for dropped webhooks
- Test-to-production safeguards
- Main assumptions and risks

Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.

Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
15

Automate MySQL Backups to Cloud Storage with Rotation and Restore Checks

Generate a MySQL backup automation script that handles secure export, cloud upload, retention rotation, and basic restore verification.

You’ll needdatabase sizecloud targetschedulesecurity constraintsretention policyrestore expectations
Prompt
You are a senior software engineer.

Produce code or a code scaffold for an automated MySQL backup workflow to cloud storage.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: backups taken with mysqldump on a live database with no consistency guarantee, producing a backup that's technically complete but internally inconsistent, no verification that a restore actually works until the day it's needed, a retention policy that deletes backups before the actual recovery-point requirement is met, and backup files uploaded to cloud storage with no encryption in transit or at rest.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including restore verification)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
16

Build a Robust Python API Client for JSON Fetching and Validation

Create a Python API client that handles authentication, timeouts, response validation, and structured parsing for JSON APIs.

You’ll needapi endpoint shapeauth needsoutput contracterror handling expectationsruntime environmentconstraints
Prompt
You are a senior software engineer.

Produce code or a code scaffold for a robust Python API client for JSON fetching and validation.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: JSON parsing errors treated the same as network errors, making it impossible to tell whether the request failed or the response was malformed, no timeout set on the request, so a hung connection blocks the whole script indefinitely, a response schema assumed stable with no validation so an API change silently produces wrong data instead of a clear error, and no handling for pagination or rate-limiting if the API actually has either.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including schema-validation and timeout scenarios)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
17

Use Mock Objects in Java Unit Tests Without Hiding Behavioral Bugs

Use mock objects in Java unit tests without overspecifying implementation details or hiding behavioral bugs behind brittle mocks.

You’ll needjava stacktesting frameworkdatabase interactionlegacy or modern codebase contextrisk areasconstraints
Prompt
You are a senior software engineer advising on a real implementation rather than teaching a generic tutorial.

Help with the engineering task below.

Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]

Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: mocks configured to always return success, hiding how the code under test actually behaves when a dependency fails, over-mocking so heavily that the test verifies the mock setup instead of real behavior, mock verification that checks a method was called without checking it was called with the right arguments, and mocks used for a class that should have just been tested directly, adding complexity with no real benefit.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.

Output format:
- Mocking scope and failure-path coverage
- Argument-level verification not just call verification
- When to mock vs test directly
- Avoiding tests that verify the mock instead of the code
- Main assumptions and risks

Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.

Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
18

Create a Web Application Security Review Checklist by Layer and Severity

Provide a web application security review checklist organized by application layer and risk severity so it can drive real engineering review instead of checkbox theater.

You’ll needapp typerisk profilestackcompliance contextreview stage
Prompt
You are a senior software engineer creating a reusable engineering asset for a real team workflow.

Build the asset using the context below.

Context:
- Goal of the asset: [goal]
- System or project context: [context]
- Audience using it: [audience]
- Constraints, standards, or compliance needs: [constraints]
- Quality risks, failure modes, or review focus: [risk focus]
- Stage of use such as design, implementation, release, or incident response: [stage]

Instructions:
1. Create an asset that is immediately usable in a real workflow.
2. Keep the structure concise and scannable, but include the checks that materially affect quality, safety, or operability.
3. Prioritize the checks that catch real security gaps over generic completeness: checklist items that treat authentication and authorization as the same concern, missing authorization checks that matter even when authentication is solid, no distinction between checks that apply at the network layer, application layer, and data layer, burying critical application-layer gaps among generic network advice, a flat list with no severity ranking that lets a cosmetic item get equal attention to a critical one, and no guidance on how findings get triaged or who owns remediation.
4. Organize the checklist by layer (network, application, data) and severity rather than a flat list.
5. Add short usage guidance when it improves consistency or judgment.
6. Make sure the asset helps a team catch real failure modes before they ship or escalate.

Output format:
- Checklist organized by layer and severity
- How to use it well
- Triage and ownership guidance for findings

Missing information policy:
Ask up to 2 concise questions only if the goal, audience, or context is unclear. Otherwise proceed with assumptions.

Quality bar:
- Keep it practical.
- Make the structure reusable.
- Name the specific failure modes above rather than generic checklist bloat.
- Emphasize the checks that prevent real mistakes.
19

Design a Container and Kubernetes Operating Model for a Microservices Platform

Design a container and Kubernetes operating model for a microservices platform with service boundaries, deployment flow, observability, and failure-isolation concerns.

You’ll needservice countdeployment targetteam maturityservice couplingobservability expectationsconstraints
Prompt
You are a senior platform engineer advising on a real Kubernetes operating model rather than teaching a generic tutorial.

Help with the engineering task below.

Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]

Instructions:
1. Explain the approach in the order the team should actually execute it (service boundaries first, then deployment and scaling, then resilience and observability).
2. Tailor the guidance to the stated service count, team maturity, and coupling.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break microservices-on-Kubernetes rollouts: service boundaries drifting into a distributed monolith with synchronous call chains, cascading failures with no circuit breaker or timeout budget, secrets and config sprawl across namespaces with no rotation story, and missing distributed tracing that makes cross-service incidents unresolvable.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.

Output format:
- Service boundary and coupling decisions
- Deployment, scaling, and rollout model
- Resilience plan (timeouts, circuit breakers, failure isolation)
- Observability plan (tracing, logging, alerting across services)
- Main assumptions and risks

Missing information policy:
Ask up to 2 concise questions only if the service topology, team maturity, or operational context is unclear. Otherwise proceed with assumptions.

Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific distributed-systems failure modes above rather than generic "container best practices" language.
- Make the advice usable by a platform team shipping real work.
20

Implement Event-Driven Architecture with Kafka

Plan an event-driven architecture that uses Kafka for messaging, retries, and service decoupling.

You’ll needsystem contextevent typesthroughput needsconstraints
Prompt
You are a senior software development architect creating a plan for a real engineering initiative.

Create a plan for the task below.

Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]

Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: no schema versioning strategy for events, so a producer change silently breaks consumers expecting the old shape, consumer offset management that isn't idempotent, causing duplicate processing on any rebalance or restart, no dead-letter handling for a malformed event that can stall an entire consumer group, and event ordering assumed guaranteed across partitions when it's actually only guaranteed within a single partition.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.

Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions

Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.

Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.