50 Best AI Prompts for Coding & Tech 2026: Debugging, Code Review, Architecture & Documentation

Act as a senior software engineer specialising in debugging. I have a bug I need you to diagnose systematically — do not jump to a fix until you have identified the most likely root cause.

Language / Framework: [e.g. Python 3.11 / FastAPI]
What I expected to happen: [describe the intended behaviour]
What actually happens: [describe the observed behaviour, including any error output]
Error message (paste in full, including stack trace): [paste here]
Relevant code snippet: [paste the function or block where the issue occurs]
When the bug first appeared: [e.g. after a dependency update / always / intermittently / after a specific code change]
What I've already tried: [list your attempts]

Please:
1. Identify the 3 most likely root causes, ranked by probability — explain the reasoning for each
2. For the most probable cause: describe exactly what is happening in the code at the point of failure
3. List the minimum code change needed to fix the most probable cause — no refactors, just the fix
4. Suggest a way to verify the fix is correct before committing it
5. Flag any secondary issues in the code that could cause related bugs in future — separate from the immediate fix

Act as a debugging expert. Decode this error message completely — explain what every part of it means, not just the final line.

Language / Runtime: [e.g. Node.js 20, Python 3.12, Java 21, Rust 1.78]
Full error output (paste entirely — do not truncate):
[paste here]

Context where the error occurs:
[paste the relevant code block]

Please:
1. Decode every line of the error message in plain English — what each part tells us
2. Identify the exact file, line, and operation where the error originates
3. Explain the underlying cause in one sentence a junior developer could understand
4. Provide the most likely fix — with the specific change needed, not just the concept
5. Explain any technical terms in the error that are worth understanding for future debugging
6. If this is a library or framework error: link the error to the concept in the library documentation that governs this behaviour (describe the concept, not a URL)

Act as a performance engineering expert. Help me diagnose a runtime performance problem in my code.

Language / Framework: [e.g. Python / Django, Go, Java / Spring Boot]
Symptom: [e.g. API endpoint takes 4s instead of expected 200ms / memory grows 100MB per hour / CPU spikes to 95% under moderate load]
When it happens: [e.g. only under load / always / with large datasets / after X hours of uptime]
Profiling data (if available — paste any profiler output, flame graph text, or timing logs):
[paste here or describe what you've measured]
Relevant code (paste the slow function or endpoint handler):
[paste here]
Database queries involved (if applicable — paste the ORM call or raw SQL):
[paste here]

Please:
1. Identify the most likely performance bottleneck from what I've provided — explain the mechanism
2. Classify the bottleneck: CPU-bound / IO-bound / memory / network / database / algorithmic complexity
3. Estimate the theoretical improvement available if the bottleneck is fixed
4. Provide a specific fix or optimisation — not general advice
5. Suggest the minimum profiling instrumentation I should add to confirm the bottleneck and measure the fix
6. Flag any secondary performance risks in the code I've shared

Act as a senior engineer doing correctness analysis. My code runs without errors but produces wrong output. I need you to trace through the logic and find where it diverges from my intention.

Language: [e.g. JavaScript, Python, Go]
What the function is supposed to do: [describe the intended behaviour in plain English]
Input I'm testing with: [paste the specific input value(s)]
Output I expected: [exact expected value or structure]
Output I actually got: [exact actual value or structure]
The code: [paste the complete function or block]

Please:
1. Trace through the code step-by-step with my specific input — show the value of key variables at each step
2. Identify exactly where the output diverges from the expected result
3. Explain why the code produces the wrong output — the logical flaw, not just the symptom
4. Provide the corrected code with the minimal change needed to fix the logic
5. Suggest 2–3 test cases that would catch this type of logic error in future (including one edge case I may not have thought of)

Act as a DevOps and environment debugging specialist. I have a bug that appears in one environment but not another. Help me isolate the environmental cause.

Language / Runtime: [e.g. Node.js 18, Python 3.10]
Works in: [e.g. my local Mac / dev environment / Docker container]
Fails in: [e.g. CI/CD pipeline / staging server / another developer's machine / production]
Error in the failing environment (full output): [paste here]
My dependency file (paste package.json / requirements.txt / go.mod / Gemfile etc.): [paste here]
Environment variables that differ between environments (redact sensitive values with placeholder text): [list them]
OS / runtime version differences if known: [describe]

Please:
1. Identify the most likely environmental cause — version mismatch / missing env var / OS difference / path issue / network policy / permission
2. Produce a checklist of things to verify in the failing environment to confirm the cause
3. Suggest the minimum change needed to make the environment consistent — don't redesign the whole setup
4. Recommend one tool or technique to lock this environment difference from recurring (e.g. .nvmrc, Docker pinning, pyproject.toml constraints)
5. Flag any dependency in my lockfile that is pinned loosely and could cause silent version drift in future

Act as a concurrency and async programming expert. Help me diagnose a bug that involves asynchronous code, parallel execution, or shared state.

Language / Concurrency model: [e.g. JavaScript async/await, Python asyncio, Go goroutines, Java CompletableFuture, Rust async]
Bug description: [e.g. intermittent failure / deadlock / race condition / incorrect data / requests sometimes never complete]
Frequency: [always / intermittent — roughly what % of the time]
The code (paste the async function, goroutine, thread, or concurrent section): [paste here]
Any locks, mutexes, or synchronisation primitives in use: [describe or paste]
What shared state is being accessed: [describe the shared variables or resources]

Please:
1. Identify the concurrency hazard: race condition / deadlock / livelock / starvation / async misuse (missing await / unhandled promise rejection)
2. Explain the exact execution sequence that produces the bug — draw out the interleaving if it's a race condition
3. Provide the corrected code — with the synchronisation or async fix applied
4. Explain why the fix works in terms of the memory model or event loop
5. Suggest how to test for this type of concurrency bug — since unit tests often can't catch it reliably

Act as a patient senior engineer doing rubber duck debugging with me. Do not give me a solution yet. Instead, ask me probing questions that help me think through the problem systematically.

My problem (describe it as clearly as you can — include what you've tried):
[describe your problem]

Start by asking me questions in this order:
1. Clarifying questions about what the code is supposed to do
2. Questions about what I've already ruled out and how
3. Questions about the conditions under which the bug does and doesn't appear
4. Questions about recent changes to the codebase, dependencies, or environment
5. Questions about any assumptions I'm making that I haven't verified

After I answer each round, either ask a follow-up question that narrows further, or — if you think we've found the root cause — explain what you believe the issue is and why, then ask me to confirm before suggesting a fix.

Act as a senior software engineer conducting a thorough code review. Review the code below and provide structured, prioritised feedback.

Language / Framework: [e.g. TypeScript / Express, Python / FastAPI]
Context — what this code does: [describe the function or module's purpose]
Context — where it runs: [e.g. server-side API endpoint / browser client / background job / CLI tool]
Existing test coverage (if any): [describe or say "none"]
Code to review:
[paste code here]

Please structure your review with severity labels:

🔴 CRITICAL — Must fix before shipping (correctness bugs, security holes, data loss risks)
🟠 HIGH — Should fix before shipping (significant design problems, error handling gaps)
🟡 MEDIUM — Should fix soon (readability, maintainability, missing tests)
🟢 LOW — Nice to have (style, minor optimisations, documentation)

For each issue:
- Line reference (if applicable)
- What the problem is
- Why it matters
- Specific suggested fix or alternative

Finish with: a one-paragraph overall assessment — is this code ready to ship, needs minor work, or needs significant revision?

Act as an application security engineer performing a security-focused code audit. Review the code below for vulnerabilities — think like an attacker trying to exploit this code.

Language / Framework: [e.g. Python / Django, Node.js / Express, PHP / Laravel]
What this code handles: [e.g. user authentication / payment processing / file uploads / external API calls / database queries]
Data sensitivity: [e.g. processes PII / financial data / public data only]
Authentication context: [e.g. endpoint is public / requires JWT / internal service only]
Code to audit:
[paste code here]

Please check for and report on:
1. Injection vulnerabilities (SQL injection, command injection, XSS, SSTI)
2. Authentication and session management flaws
3. Insecure direct object references (IDOR) or broken access control
4. Sensitive data exposure (secrets in code, unencrypted data, over-exposed API responses)
5. Security misconfiguration
6. Insecure deserialisation
7. Missing input validation or insufficient output encoding
8. Dependency or third-party risks

For each finding: severity (Critical / High / Medium / Low), the vulnerable code snippet, the attack vector an adversary would use, and the specific remediation.

Act as a performance engineering expert. Review the code below for performance problems — focus on algorithmic complexity, resource usage, and scalability concerns.

Language / Framework: [e.g. Python / Django, Java / Spring]
Scale context: [e.g. this runs on every HTTP request / processes 1M records per night / called 50 times/second under load]
Expected data size: [e.g. input list could be 10–100k items / table has 50M rows]
Code to review:
[paste code here]
Database queries (if relevant, paste ORM or SQL):
[paste here]

Please analyse:
1. Time complexity of the core algorithm — Big-O notation and explanation
2. Space complexity — memory allocation patterns and any obvious leaks
3. Database query issues — N+1 queries, missing indexes, unnecessary full table scans, over-fetching
4. Loop inefficiencies — unnecessary iterations, redundant computations, misuse of data structures
5. Caching opportunities — what could be memoised, cached, or pre-computed
6. I/O blocking — synchronous calls that could be async, unnecessary serialisation/deserialisation

For each issue: estimate the performance impact (negligible / noticeable / severe at scale) and provide a specific optimised alternative.

Act as a senior engineer focused on code quality and long-term maintainability. Review the code below — assume this code will be read by a developer who has never seen it before, six months from now.

Language: [e.g. TypeScript, Python, Go]
Team context: [e.g. solo project / small startup team / large engineering org with many contributors]
Existing style guide or conventions: [describe or say "none enforced"]
Code to review:
[paste code here]

Please evaluate and flag issues in:
1. Naming — variables, functions, and classes that don't clearly communicate intent
2. Function and class size — functions that do too much, violate single responsibility
3. Cognitive complexity — deeply nested conditionals, complex boolean logic, magic numbers
4. Coupling and cohesion — things that are unnecessarily tangled or separated that should be together
5. Comments — missing where needed, misleading where they exist, or redundant (comments that just repeat the code)
6. Error handling — silent failures, swallowed exceptions, missing validation
7. Duplication — copy-pasted logic that should be extracted

For each: quote the problematic code, explain the maintainability risk, and show the improved version.

Act as a senior engineer reviewing a pull request. Produce your review in the format of a GitHub PR review — with inline comments referencing specific lines, a summary, and a clear verdict.

PR title / description: [paste PR description or describe the change]
Type of change: [e.g. new feature / bug fix / refactor / performance improvement / breaking change]
Language / Framework: [e.g. TypeScript / React, Go / gRPC]
Diff or changed code (paste the changed files or functions):
[paste here]
Tests added (if any): [paste or describe]

Please produce:

PR SUMMARY REVIEW
- Overall assessment: [Approve / Approve with suggestions / Request changes]
- What this PR does well:
- Primary concerns:

INLINE COMMENTS (format each as):
[File: filename.ext, Line ~N]: [Comment text — issue or suggestion]

BLOCKERS (must fix before merge):
[list]

SUGGESTIONS (non-blocking improvements):
[list]

QUESTIONS for the author:
[list anything that needs clarification before you can fully approve]

Act as a code quality expert. Review the code below specifically for anti-patterns, code smells, and misuse of language or framework features.

Language / Framework: [e.g. Python, JavaScript / React, Java / Spring, Go]
Code to review:
[paste code here]

Please identify:

GENERAL CODE SMELLS:
- God objects / classes that know too much
- Long methods doing too many things
- Feature envy (a function that's more interested in another class's data)
- Primitive obsession (using raw strings/ints where domain types should exist)
- Shotgun surgery (one change requires many small changes across many places)
- Dead code — unreachable branches, unused variables, stale imports

LANGUAGE-SPECIFIC ANTI-PATTERNS for [language]:
[AI should identify the relevant anti-patterns for the specified language, e.g. for Python: mutable default args, bare except, overusing *args/**kwargs; for JS: callback hell, prototype pollution risk, implicit globals]

FRAMEWORK MISUSE for [framework]:
[AI should identify misuse patterns specific to the named framework]

For each finding: name the anti-pattern, show the problematic code, explain the consequence, and provide the idiomatic alternative.

Act as a principal software engineer and solutions architect. Design a high-level system architecture for the following requirement.

What I'm building: [describe the product, feature, or service in plain English]
Expected scale: [e.g. 100 users at launch / 10k daily active users / 1M requests per day]
Team size and capability: [e.g. 2 full-stack engineers / 5 backend engineers with strong Python / solo developer]
Existing infrastructure or constraints: [e.g. already on AWS / must use existing PostgreSQL / no budget for managed services / must be on-premise]
Key non-functional requirements: [e.g. must be GDPR-compliant / 99.9% uptime SLA / response time under 100ms / offline capability]
Timeline to first production deployment: [e.g. 6 weeks, 3 months]

Please produce:
1. High-level component diagram (described in text — list components and how they connect)
2. Data flow — how data moves through the system from user action to storage to response
3. Key technology recommendations for each component — with brief justification
4. The 3 highest-risk architectural decisions I need to make before starting, and a recommended choice for each
5. What this architecture will struggle with at 10× the expected scale — and the trigger point to rearchitect
6. What I should NOT build yet — components to defer until the system proves itself

Act as a solutions architect who has migrated several monoliths to microservices — and seen several go badly. Advise me on service decomposition for my situation.

Current system: [describe the monolith or existing architecture]
Current pain points driving the decomposition discussion: [e.g. deployment bottlenecks / scaling a specific component / team coordination / technology heterogeneity]
Domain areas or bounded contexts I've identified: [list the business domains or capabilities — e.g. user management, payments, notifications, inventory]
Team structure: [e.g. 1 backend team of 8 / 3 independent squads / 2 developers total]
Current operational maturity: [e.g. no k8s experience / running on managed k8s / strong DevOps team / no dedicated ops]
Scale of the specific component I think needs to scale independently: [describe]

Please:
1. Give me an honest assessment — is microservices decomposition the right solution for my actual problem? What alternatives should I consider first?
2. If decomposition is justified: recommend the first service to extract and the boundary to draw — based on domain independence and team ownership
3. Identify the strangler fig pattern steps for extracting the first service without a big-bang rewrite
4. List the operational prerequisites I need in place before running microservices in production
5. Flag the 3 most common mistakes teams make at my stage of decomposition

Act as a database architect. Design or review a database schema based on the requirements below.

Database engine: [e.g. PostgreSQL 16, MySQL 8, SQLite, MongoDB, DynamoDB]
What I'm modelling: [describe the domain — e.g. e-commerce orders, SaaS user accounts and billing, social media posts and reactions]
My current schema or draft (paste DDL, describe tables, or describe entities):
[paste or describe]
Expected data volume: [e.g. 10k users / 100M events per month / billions of time-series records]
Primary query patterns — the 3–5 most frequent queries this schema must serve efficiently:
[describe each: e.g. "look up all orders for a user in the last 30 days sorted by date"]
Write-heavy or read-heavy: [describe the ratio]

Please:
1. Identify any normalisation violations — and whether to fix or intentionally denormalise for performance
2. Review relationships — are foreign keys correct? Are there any missing constraints?
3. Recommend an indexing strategy for my primary query patterns — which columns to index and why
4. Flag any schema decisions that will cause pain at 10× current scale
5. Identify any columns or tables that suggest a modelling misunderstanding of the domain
6. Suggest any schema changes that would make the 3 most frequent queries more efficient

Act as an API design expert. Review my API design for correctness, usability, and long-term maintainability.

API type: [REST / GraphQL / gRPC / WebSocket]
API consumers: [e.g. internal frontend only / third-party developers / mobile apps / other backend services]
My API design (paste OpenAPI spec, route definitions, or describe endpoints):
[paste here]
Authentication method: [e.g. JWT Bearer / API key / OAuth 2.0 / session cookie]

Please review for:
1. HTTP method semantics — are GET/POST/PUT/PATCH/DELETE used correctly?
2. URL structure — are resources named correctly (nouns, not verbs), are hierarchies logical?
3. Status codes — are the right HTTP status codes returned for each case?
4. Request/response shapes — are payloads consistent, well-named, and free of internal domain leakage?
5. Error response format — is the error schema consistent and developer-friendly?
6. Versioning strategy — is there one, and is it appropriate?
7. Pagination — are list endpoints paginated, and is the pagination pattern standard?
8. Security — are endpoints appropriately protected and returning only what consumers need?

For each issue: the problem, the consequence for API consumers, and the recommended fix.

Act as a systems architect with deep experience in scaling web applications. Help me plan for scalability before my system hits load limits.

Current architecture: [describe your stack — web server, database, caching layer, message queue, etc.]
Current load: [e.g. 500 requests/day / 200 concurrent users / 50k records in DB]
Expected load in 6 months: [best estimate]
Expected load in 2 years: [best estimate — be honest if uncertain]
The component most likely to be the first bottleneck under load: [your hypothesis]
Current infrastructure: [e.g. single VPS, 3 EC2 instances, managed Kubernetes, serverless]
Budget constraints for scaling: [e.g. must stay under $500/month / no constraint / enterprise budget]

Please:
1. Identify the actual first bottleneck — confirm or challenge my hypothesis with reasoning
2. Estimate the approximate load at which each major component (web tier, database, cache, storage) will fail under current architecture
3. Design a scale path: what to do first, second, and third — as load grows — without over-engineering prematurely
4. Identify the lowest-cost, highest-impact change I can make today to increase capacity headroom
5. Describe the load test I should run this week to validate these estimates with real data

Act as a technology advisor with no vendor affiliation. Help me make a structured technology decision — not based on trends, but on my actual constraints and requirements.

Decision I'm making: [e.g. which backend framework / which database / which message queue / which frontend framework / which cloud provider]
Options I'm considering: [list 2–4 options you want compared]
My requirements (rate each 1–5 for importance):
- Performance: [1–5]
- Developer experience: [1–5]
- Operational simplicity: [1–5]
- Ecosystem maturity: [1–5]
- Hire-ability (can I find engineers who know this): [1–5]
- Total cost of ownership: [1–5]
Team's current skills: [describe what the team knows well vs is learning]
Scale I need to support: [describe]
Any hard constraints: [e.g. must be open source / must run on-premise / must have SOC2 compliance / must integrate with X]

Please:
1. Score each option against my requirements — justify each score in one sentence
2. Name the winner for my specific constraints — give a clear recommendation, not "it depends"
3. Describe the top risk of choosing the recommended option
4. Describe the scenario in which I should choose the second option instead
5. Flag any option that looks good on paper but has a known hidden cost for teams at my scale

Act as a principal architect. Analyse the trade-offs of a specific architectural decision I'm making — give me the full picture before I commit.

The decision: [describe the architectural choice, e.g. "use eventual consistency with an event-driven architecture vs strong consistency with synchronous calls" or "store files in S3 vs in the database vs on local disk"]
My context: [describe the system, team, and constraints this decision fits into]
Why I'm leaning toward option A: [describe your current thinking]
What concerns me about option A: [describe your doubts]
Option B (the alternative): [describe]

Please analyse:
1. What option A optimises for — what becomes easier, faster, or cheaper
2. What option A makes harder — the costs, constraints, or failure modes it introduces
3. The same analysis for option B
4. The conditions under which option A is clearly the better choice
5. The conditions under which I should pick option B instead
6. The decision criteria most likely to change in the next 12–18 months that would make me regret picking option A today
7. Your recommendation — and the one question I should answer before committing to it

Act as a technical writer. Generate a professional, complete README.md for my project.

Project name: [name]
What it does (one sentence): [describe]
Who it's for: [e.g. developers building X / data scientists / end users of Y type]
Tech stack: [e.g. Python 3.11, FastAPI, PostgreSQL, Docker]
Key features: [list 3–5 main features]
Installation prerequisites: [e.g. Python 3.10+, Docker, a PostgreSQL instance]
How to install and run locally (describe the steps or paste them): [describe]
How to run tests: [command or description]
Configuration — key environment variables: [list them, with descriptions]
Any API or CLI interface to document: [describe or paste]
License: [e.g. MIT, Apache 2.0, proprietary]
Project status: [e.g. early alpha / production-stable / actively maintained / archived]

Please generate a README.md with these sections:
1. Project name + one-line description + badges (build status, license, version)
2. Overview — what problem this solves and why it exists
3. Quick start — get it running in under 5 commands
4. Features
5. Installation — full step-by-step
6. Configuration — environment variables with examples
7. Usage — code example or CLI example
8. Running tests
9. Contributing (brief)
10. License

Act as a technical writer who understands code deeply. Add inline comments and docstrings to the code below — following the principle that comments should explain WHY, not WHAT.

Language: [e.g. Python, TypeScript, Go, Java]
Docstring format: [e.g. Google style / NumPy / JSDoc / GoDoc / JavaDoc / just clear prose]
Audience for the comments: [e.g. junior developers / senior engineers unfamiliar with this domain / public API users]
Code to document:
[paste code here]

Rules for your comments:
1. Docstring / JSDoc for every public function, class, and method — including params, return types, raises/throws
2. Inline comments only where the logic is non-obvious — not for self-explanatory code
3. Comments that explain the WHY behind non-obvious decisions (e.g. "using insertion sort here because n is always < 10")
4. Warning comments for known gotchas or footguns in the function
5. TODO comments for anything that should be improved but isn't being changed now
6. Do NOT add comments like "# increment i by 1" above "i += 1" — only add value

Return the fully commented code.

Act as a technical writer specialising in API documentation. Generate complete API reference documentation for the endpoints below.

API type: [REST / GraphQL / gRPC]
Output format: [Markdown / OpenAPI 3.0 YAML / JSON / plain structured docs]
Authentication: [describe how consumers authenticate — e.g. Bearer token in Authorization header]
Base URL: [e.g. https://api.example.com/v1]
Endpoints to document (paste route definitions, controller code, or describe each endpoint):
[paste here]

For each endpoint, generate:
1. Summary — one-sentence description of what the endpoint does
2. HTTP method and full path
3. Authentication required: yes/no and type
4. Path parameters — name, type, required, description
5. Query parameters — name, type, required, default, description
6. Request body schema — with field names, types, required/optional, constraints, and example
7. Success response — status code, schema, and concrete JSON example
8. Error responses — all possible error codes with description and example error body
9. Rate limiting notes (if applicable)
10. Code example in [language the caller is likely using — e.g. curl / Python / JavaScript]

Act as a technical writer. Create a formal Architecture Decision Record (ADR) for the following technical decision.

Decision title: [short, descriptive title — e.g. "Use PostgreSQL over MongoDB for user data storage"]
Date: [today's date]
Status: [Proposed / Accepted / Deprecated / Superseded]
Decision made by: [team name or individual role — no personal names needed]

Context (describe the problem or situation that required a decision):
[describe why a decision was needed]

Decision (what was decided):
[describe what was chosen]

Options considered:
Option A: [name] — [brief description]
Option B: [name] — [brief description]
Option C (if applicable): [name] — [brief description]

Reasons for the chosen option:
[describe the key factors that drove the decision]

Reasons the other options were rejected:
[describe why each alternative was not chosen]

Consequences — positive:
[what this decision enables]

Consequences — negative or risks:
[what this decision makes harder or the risks it introduces]

Please format this as a standard ADR document in Markdown, including all sections above in a consistent structure that can be stored in a /docs/decisions/ folder in the repository.

Act as a technical writer creating a developer onboarding guide. Generate a structured onboarding document that gets a new engineer productive within their first day.

Project or codebase: [name and brief description]
Tech stack: [languages, frameworks, databases, cloud services]
Local development setup (describe the steps or paste your setup script): [describe]
Key repositories and their purpose: [list them]
Coding conventions and style guide: [describe or link]
Branching and PR workflow: [e.g. feature branches, squash merge to main, PR template required]
How to run tests locally: [describe]
How to deploy to staging: [describe]
Key people to know for specific areas: [describe by role, not name — e.g. "database questions → the backend lead"]
Most common mistakes new engineers make: [describe 3–5 gotchas]
Glossary of internal terms, acronyms, or domain-specific concepts: [list them]

Generate an onboarding guide covering:
1. Welcome & system overview — what this system does and why it exists
2. Local environment setup — numbered, command-by-command
3. Codebase tour — key directories and what each contains
4. Workflow guide — how to pick up a ticket, branch, commit, PR, and deploy
5. How to run and write tests
6. Common gotchas and how to avoid them
7. Glossary
8. First-week checklist — specific tasks to complete in order

Act as a senior engineer specialising in test-driven development. Generate a complete unit test suite for the code below.

Language: [e.g. Python, TypeScript, Java, Go]
Testing framework: [e.g. pytest, Jest, JUnit 5, Go testing, Vitest, RSpec]
Mocking library (if applicable): [e.g. unittest.mock, jest.mock, Mockito]
Code to test:
[paste the function or class here]
Any existing tests (to avoid duplication): [paste or describe]

Generate test cases covering:
1. Happy path — all expected inputs produce correct outputs
2. Edge cases — empty input, null/None, zero, empty string, empty array, maximum values
3. Error paths — invalid input types, out-of-range values, missing required fields
4. Boundary conditions — values at the exact limit of valid ranges
5. State — if the function modifies state, test before/after
6. Side effects — external calls that should or should not be made (use mocks)

For each test:
- Use a descriptive name following [describe/it / test_ / TestXxx] convention for [framework]
- Add a one-line comment explaining what the test verifies
- Structure tests with Arrange / Act / Assert pattern
- Mock all external dependencies (database, API calls, file system)

Return runnable test code — not pseudo-code.

Act as a test engineer specialising in boundary analysis and adversarial testing. Generate edge case and boundary test scenarios for the code below — focus on the inputs that would fail in production that developers typically miss.

Language / Framework: [e.g. Python / pytest]
Code to test:
[paste function or class]
Existing tests I already have: [paste or describe — so you don't repeat them]

Generate edge case scenarios across these categories:
1. Numeric boundaries — zero, negative, max int, min int, float precision issues, NaN, infinity
2. String inputs — empty string, whitespace-only, very long strings, special characters, unicode, null bytes, newlines
3. Collection inputs — empty list/array, single element, very large collections, duplicate values, None/null elements
4. Date and time — epoch, far-future dates, leap year February 29, timezone edge cases, DST transitions
5. Concurrency — what if this function is called simultaneously from two threads?
6. Adversarial inputs — SQL injection strings, script tags, path traversal sequences (../), excessively nested JSON
7. State — what if required state hasn't been initialised? What if it's been partially initialised?
8. Combinations — the interaction of two individually valid inputs that together cause unexpected behaviour

Return as runnable test cases in [framework], with a one-line comment on what each edge case is probing for.

Act as a QA engineer and testing architect. Design an integration test strategy for the system described below.

System description: [describe your application — its components, external dependencies, and data flow]
Key integrations (list each pair of components that talk to each other): [e.g. API → database / API → third-party payment service / worker → message queue / frontend → backend API]
External services involved: [e.g. Stripe, SendGrid, AWS S3, a third-party REST API]
Testing environment available: [e.g. can spin up Docker Compose / have a staging environment / limited to CI/CD pipeline / local only]
Current test coverage level: [e.g. good unit tests, no integration tests / some integration tests / full coverage]

Please design:
1. Which integrations are highest priority to test and why — ranked by risk of failure and business impact
2. For each high-priority integration: the specific test scenarios to cover (not just happy path)
3. What to use real implementations for vs what to stub/mock — with justification
4. Test data strategy — how to set up and tear down state for each integration test
5. How to handle external services that can't be called in tests (payment providers, email services)
6. A recommended test structure — where integration tests live in the codebase and how they're run in CI

Act as a senior QA engineer. Analyse the gap between my existing tests and my code — identify what's missing, not just what's untested by line count.

Language / Testing framework: [e.g. Python / pytest, TypeScript / Jest]
Code under test:
[paste the code]
Existing tests:
[paste the test file]
Coverage report (if available — paste the output): [paste or describe]

Please analyse:
1. Untested code paths — branches (if/else), exception handlers, early returns that no test exercises
2. Untested business rules — logic that exists in the code but no test verifies it works correctly
3. Missing error path tests — exceptions that could be raised but no test verifies the handling
4. Weak assertions — tests that call the code but don't assert enough to catch a regression
5. Tests that test the wrong thing — tests so tightly coupled to implementation they'd break on refactor without any real behaviour change
6. Missing integration points — places where the code calls external dependencies that no test covers, even with mocking

Produce a prioritised list of test gaps to fill, with a one-sentence description of what each missing test should verify. Rank by: likelihood of a real bug hiding there.

Act as a TDD coach. Guide me through the red-green-refactor cycle for a specific feature I'm building.

Language / Framework: [e.g. Python / pytest, TypeScript / Jest]
Feature I'm building: [describe what the code should do — in terms of behaviour, not implementation]
Interface I've decided on (function signature, class API, or REST endpoint): [describe or paste]
Any constraints on the implementation: [e.g. must use existing UserRepository class / must not call the database directly]

Please:

STEP 1 — RED (failing test):
Write the first, most important failing test for this feature. It should:
- Test one specific behaviour
- Fail for the right reason (not a syntax error — a genuine assertion failure)
- Be named to describe the behaviour it verifies

STEP 2 — GREEN (minimal implementation):
Write the minimum code that makes the test pass — not a complete implementation, just enough to go green. It can be ugly.

STEP 3 — NEXT TEST:
Write the next failing test that forces me to improve the implementation — adding the next important behaviour.

STEP 4 — REFACTOR prompt:
After the second test is green: suggest one refactor that improves the implementation without changing behaviour, and explain what makes it worth doing.

Act as a senior engineer specialising in refactoring and code quality. Help me plan a safe, incremental refactoring of the code below — no big-bang rewrites.

Language: [e.g. Python, TypeScript, Java]
Code to refactor:
[paste code here]
What's wrong with it (in your own words): [describe the problems you see]
Existing test coverage: [describe — no tests / some unit tests / full coverage]
Risk level: [e.g. critical production path / used in many places / low-traffic feature / internal tool]

Please:
1. Identify the specific code quality problems — name them with recognised terms (long method, feature envy, primitive obsession, etc.)
2. Design a refactoring sequence — ordered steps from safest to most structural, each step leaving the code in a working state
3. For each step: describe what change is made, why it's an improvement, and what test I should run to confirm no behaviour changed
4. Identify which refactoring steps require new tests to be written first (before refactoring)
5. Flag any step that carries meaningful risk and explain how to mitigate it
6. Estimate the total effort — is this a 30-minute tidy or a 3-day project?

Act as a code quality engineer. Audit the code below for dead code, unnecessary complexity, and things that can be safely removed or simplified.

Language: [e.g. Python, JavaScript, Go]
Code to audit:
[paste code here]

Please identify:
1. Dead code — functions, methods, or branches that are never called or never reached
2. Unused imports / dependencies — imported but never used
3. Commented-out code — old code blocks that should be deleted (not kept "just in case")
4. Redundant conditions — if/else branches that always evaluate the same way given how the function is called
5. Unnecessary abstraction — over-engineered patterns applied to problems that don't require them
6. Feature flags or config switches that are always on or always off — making one branch unreachable
7. Complexity that wraps simple operations — functions that could be one-liners

For each: confirm whether it's safe to remove (and how to verify), or whether it might be called from somewhere not shown. Provide the simplified version where appropriate.

Act as a software design expert. Diagnose the structural problem in my code and recommend the most appropriate design pattern to address it.

Language: [e.g. Python, TypeScript, Java, Go]
The problem I'm experiencing (describe in plain English — not in pattern terminology):
[e.g. "I have a series of if/elif blocks that check the type of an object and call different processing functions — adding a new type requires touching 5 different places" / "I need to add behaviour to existing objects without modifying their classes" / "I have a complex object creation process that's scattered across many files"]
The current code (paste the problematic section):
[paste here]

Please:
1. Name the structural problem my code has — in design terms
2. Recommend the most appropriate design pattern to solve it — with a one-sentence justification
3. Show how the pattern applies to my specific code — not a generic textbook example, but my actual code rewritten with the pattern applied
4. Name any alternative patterns I considered and why they're less appropriate here
5. Flag the risk of over-engineering: is this pattern justified by the complexity I have, or would a simpler refactor achieve 80% of the benefit without the pattern overhead?

Act as a software engineer with deep experience in legacy code modernisation. Help me plan a safe upgrade path for old or brittle code.

Language and current version: [e.g. Python 2.7 → 3.12, Node.js 12 → 20, Java 8 → 21]
Framework and current version: [e.g. Django 2.1, React 16, Spring Boot 2.3]
Code description (paste a sample or describe the major patterns used): [paste or describe]
Test coverage: [none / partial / good]
Business criticality: [e.g. core revenue path / internal tool / deprecated but still used]
Team capacity for this work: [e.g. 1 developer 20% time / full sprint allocation]
Hard deadline (if any): [describe or say "none"]

Please plan:
1. A characterisation strategy — how to understand what the code does before changing it (including adding tests without changing behaviour)
2. A dependency audit — which dependencies are blocking the upgrade, and are there maintained alternatives?
3. A phased modernisation plan — ordered steps from least risky to most structural
4. Breaking changes to plan for — what in the new version will require code changes
5. Quick wins — modernisations that deliver value immediately with low risk
6. The "never touch this" assessment — is any part of this code so risky it should be kept as-is and isolated rather than modernised?

Act as a software design coach. Audit the code below against the SOLID principles and identify violations with specific, actionable fixes.

Language: [e.g. Python, TypeScript, Java, C#]
Code to audit:
[paste class(es) or module here]

For each SOLID principle, please:
1. Assess whether the code satisfies or violates it
2. If violated: quote the specific code that violates it and explain why
3. Provide the corrected design — show the restructured code that satisfies the principle
4. Rate the severity of the violation: Minor (style issue) / Moderate (makes extension hard) / Severe (causes active pain when adding features)

SOLID Principles to assess:
S — Single Responsibility Principle: does each class have one reason to change?
O — Open/Closed Principle: is the code open to extension without modification?
L — Liskov Substitution Principle: are subtypes interchangeable with their base types?
I — Interface Segregation Principle: are interfaces focused and minimal?
D — Dependency Inversion Principle: do high-level modules depend on abstractions, not concretions?

End with: a prioritised list of which violations to fix first based on their actual impact on the codebase.

Act as a database performance engineer. Help me optimise a slow SQL query.

Database engine and version: [e.g. PostgreSQL 16, MySQL 8.0, SQLite 3.43]
The slow query (paste in full): [paste here]
Relevant table schema (paste CREATE TABLE statements): [paste here]
Current indexes on relevant tables: [list or paste]
Execution plan (paste EXPLAIN ANALYZE or EXPLAIN output if available): [paste here]
Row counts for relevant tables: [e.g. users: 500k rows, orders: 8M rows]
Current query execution time: [e.g. 4.2 seconds]
How often this query runs: [e.g. on every page load / once per minute / nightly batch]

Please:
1. Identify the primary performance bottleneck from the execution plan or schema (sequential scan, hash join on large table, missing index, etc.)
2. Propose an optimised query — with explanation of what changed and why
3. Recommend specific indexes to create — with the exact CREATE INDEX statement
4. Estimate the expected performance improvement after the optimisation
5. Flag any query rewrites that might change the result set in edge cases — so I can test carefully
6. Identify any schema changes (partitioning, denormalisation) that would help if query rewrites aren't sufficient

Act as a frontend performance engineer. Audit my frontend for performance issues and recommend specific, implementable improvements.

Framework / Tech stack: [e.g. React 18 / Next.js 14 / Vite, Vue 3 / Nuxt, vanilla JS]
Deployment: [e.g. Vercel, Cloudflare Pages, self-hosted Nginx, CDN details]
Current Core Web Vitals (if known):
- LCP (Largest Contentful Paint): [value or "unknown"]
- INP (Interaction to Next Paint): [value or "unknown"]
- CLS (Cumulative Layout Shift): [value or "unknown"]
Current bundle size (if known): [e.g. 1.2MB JS / 450KB gzipped]
Performance symptoms: [describe what users experience — slow initial load / sluggish interactions / layout shifts / slow time to interactive]
Relevant code (paste component, page, or build config if relevant): [paste here]

Please audit:
1. Bundle size — large dependencies, missing tree-shaking, duplicate packages
2. Code splitting — are routes and heavy components loaded lazily?
3. Image optimisation — format (WebP/AVIF), sizing, lazy loading, priority hints
4. Critical rendering path — render-blocking resources, font loading strategy
5. JavaScript execution — long tasks blocking the main thread, expensive re-renders
6. Caching strategy — cache-control headers, service worker, CDN caching
7. Network — unnecessary API calls, missing HTTP/2 or HTTP/3, lack of compression

For each issue: severity impact on Core Web Vitals, specific fix, and estimated improvement.

Act as a computer science and algorithms expert. Analyse the time and space complexity of my code and recommend improvements if a better algorithm exists.

Language: [e.g. Python, JavaScript, Java, Go]
Code to analyse:
[paste the function or algorithm]
Input characteristics: [e.g. sorted list / unsorted / large n (millions) / small n (always under 100) / graph with sparse edges / dense matrix]
Performance requirement: [e.g. must run in under 100ms / runs nightly as a batch / real-time with 50ms budget]

Please:
1. State the time complexity — Big-O for best case, average case, and worst case
2. State the space complexity — including any hidden allocations (recursion stack, intermediate collections)
3. Identify the bottleneck operation — the specific line or loop that dominates the complexity
4. If a more efficient algorithm exists: name it, explain it, and provide an implementation in my language
5. State the improved time and space complexity
6. Flag any trade-offs of the more efficient algorithm (e.g. harder to understand, requires sorted input, uses more memory)
7. If the current algorithm is already optimal for this problem: confirm it and explain why

Act as a systems engineer specialising in memory management. Identify memory leaks and resource management issues in my code.

Language / Runtime: [e.g. Python 3 / CPython, JavaScript / Node.js, Java / JVM, Go, C++]
Symptom: [e.g. memory grows continuously until OOM / process gets slower over 6+ hours / database connections exhausted / event loop overloaded]
How long the process runs before symptoms appear: [e.g. 2 hours / after 10k requests / after 3 days]
Code to analyse:
[paste the relevant section — e.g. request handler, background worker, event listener setup]

Please identify:
1. Unclosed resources — file handles, database connections, HTTP clients, sockets that may not be closed on all code paths
2. Growing collections — lists, maps, caches, queues that grow unboundedly without eviction
3. Event listener accumulation — listeners added but never removed, especially in loops
4. Circular references — objects that reference each other and prevent garbage collection
5. Long-lived references — objects captured in closures, class variables, or global state that should be short-lived
6. Language-specific memory issues for [language] — e.g. Python reference cycles, Node.js EventEmitter memory leaks, Java heap generation issues

For each finding: the specific code, why it leaks, and the fix including the correct resource cleanup pattern for my language.

Act as a systems architect. Design a caching strategy for the bottleneck described below.

What's slow: [describe the operation — e.g. database query / external API call / computation / file read]
Current latency: [e.g. 800ms average]
How frequently this is called: [e.g. 200 times/second / once per user session / nightly batch]
Data freshness requirements: [e.g. must be real-time / eventual consistency OK / can be stale for up to 5 minutes / cache forever and bust on write]
Data size per cache entry: [rough estimate — e.g. 2KB JSON / 500 bytes / 50KB HTML fragment]
Infrastructure available: [e.g. Redis / Memcached / in-process memory / CDN / browser cache / none yet]
Cache invalidation trigger: [e.g. on write / TTL only / manual / no writes — read-only data]

Please design:
1. Recommended cache type and layer — where in the stack to cache (database query cache / application-level / HTTP cache / CDN / browser)
2. Cache key design — how to construct keys that are specific enough to avoid collisions and general enough for good hit rate
3. TTL strategy — how long to cache, and whether to use sliding expiration or fixed
4. Invalidation strategy — how to evict stale data when the source changes
5. Cache warming — should the cache be pre-populated, and how?
6. Cache stampede prevention — what happens when the cache expires and 1000 requests hit the backend simultaneously?
7. Monitoring — what metrics to track to know if the cache is working

Act as a web application security expert using the OWASP Top 10 (2021) as your audit framework. Check the code below for each category systematically.

Language / Framework: [e.g. Python / Django, PHP / Laravel, Node.js / Express, Ruby / Rails]
Code type: [e.g. API endpoint handler / authentication module / file upload handler / admin panel / user-facing form handler]
Authentication context: [e.g. public endpoint / authenticated users only / admin only]
Code to audit:
[paste code here]

Check each OWASP Top 10 category:
A01 – Broken Access Control: is authorisation enforced on every operation?
A02 – Cryptographic Failures: is sensitive data encrypted? Are weak algorithms used?
A03 – Injection: SQL, command, LDAP, XSS, SSTI injection vulnerabilities
A04 – Insecure Design: are there design-level flaws that can't be patched with code?
A05 – Security Misconfiguration: debug mode, default credentials, overly permissive CORS
A06 – Vulnerable Components: known-vulnerable libraries or frameworks in use
A07 – Identification and Authentication Failures: weak passwords, session management, MFA gaps
A08 – Software and Data Integrity Failures: unsigned updates, insecure deserialisation
A09 – Security Logging and Monitoring Failures: are security events logged?
A10 – Server-Side Request Forgery (SSRF): are user-supplied URLs fetched server-side?

For each finding: severity, the vulnerable code, the attack scenario, and the specific remediation.

Act as a security engineer specialising in secrets management. Audit the code and configuration below for hardcoded credentials, exposed secrets, and insecure secrets handling.

Language / Stack: [describe]
Code / config to audit (replace any real values with [REDACTED] before pasting — I only need the structure):
[paste here]

Please identify:
1. Hardcoded secrets — API keys, passwords, tokens, private keys embedded directly in source code
2. Secrets in version-controlled config files — .env files committed to the repo, config.yaml with real values
3. Secrets in logs — code that logs request parameters, headers, or response bodies that may contain credentials
4. Secrets in error messages — exceptions that expose credentials in their message
5. Insecure secret handling — secrets stored in plain text in a database, passed as URL query parameters, stored in browser localStorage
6. Overly permissive access — credentials with broader permissions than the code requires

For each finding:
- Risk level (Critical / High / Medium)
- The pattern or code that exposes the secret
- The correct alternative (environment variable, secrets manager, vault, etc.)
- The immediate remediation if a real secret is currently exposed

Finish with: a recommended secrets management architecture for my stack.

Act as a supply chain security engineer. Help me audit my third-party dependencies for known vulnerabilities and supply chain risk.

Package manager / ecosystem: [e.g. npm, pip, Maven, Cargo, Go modules, RubyGems]
Dependency file (paste package.json, requirements.txt, go.mod, Gemfile, pom.xml, or equivalent):
[paste here]
Vulnerability scan output (if available — paste npm audit, pip-audit, bundler-audit, or snyk output):
[paste or say "not run yet"]
Production vs development dependencies: [note which are dev-only if your file doesn't distinguish]

Please:
1. Review the dependency list for packages with known major security issues (based on your training knowledge — note these should be verified against current CVE databases)
2. Identify any packages that appear to be unmaintained, deprecated, or have had known supply chain incidents
3. Flag any packages pinned to very old versions where major security patches have likely been released
4. Identify transitive dependency risks — the packages most likely to pull in vulnerable sub-dependencies
5. Recommend a dependency audit process — which tools to run, how frequently, and how to integrate into CI
6. Suggest 3 dependency hygiene rules for my project going forward

Note: for accurate CVE data, always run npm audit, pip-audit, bundler-audit, or snyk test — I can interpret the output with you.

Act as an application security engineer. Review my authentication and authorisation implementation for security vulnerabilities.

Framework / Language: [e.g. Node.js / Express / Passport.js, Python / FastAPI / JWT, Java / Spring Security]
Auth mechanism: [e.g. JWT with RS256 / session cookies / OAuth 2.0 / API keys / SAML]
User roles / permission model: [describe — e.g. admin/user/guest / RBAC with custom roles / no roles]
Code to review (paste auth middleware, login handler, and one example of an authorised endpoint):
[paste here]

Please review for:
AUTHENTICATION:
1. Password storage — hashing algorithm (bcrypt/argon2 required; MD5/SHA1 = critical vulnerability)
2. Session management — token expiry, rotation, revocation, secure/httpOnly flags
3. JWT vulnerabilities — algorithm confusion (none algorithm), weak secrets, missing claims validation
4. Brute force protection — rate limiting, account lockout
5. Credential stuffing resistance — breach detection, MFA support

AUTHORISATION:
6. Missing authorisation checks — endpoints that check authentication but not authorisation
7. IDOR vulnerabilities — can a user access another user's resources by changing an ID?
8. Privilege escalation — can a lower-privilege user gain higher-privilege access?
9. Horizontal privilege escalation — can a user of equal privilege access another user's data?
10. Authorisation bypass — edge cases where authorisation is skipped (e.g. OPTIONS requests, error paths)

For each finding: severity, the vulnerable code, the attack, and the fix.

Act as a security architect. Run a STRIDE threat model on the feature or system I'm designing.

What I'm building: [describe the feature or system in detail — include data flows, user types, external integrations, and sensitive operations]
Who uses it: [describe user types and trust levels]
Data it handles: [describe the data — PII / financial / health / public data]
External systems it touches: [APIs, databases, message queues, cloud services]
Deployment environment: [cloud / on-premise / SaaS / mobile app]

Apply STRIDE — for each threat category, identify specific threats to my system:

S — Spoofing: how could an attacker impersonate a legitimate user or system component?
T — Tampering: how could data be modified in transit or at rest without detection?
R — Repudiation: how could a user deny performing an action they actually took?
I — Information Disclosure: how could sensitive data be exposed to unauthorised parties?
D — Denial of Service: how could availability be disrupted?
E — Elevation of Privilege: how could a user gain access they shouldn't have?

For each identified threat:
- Likelihood (High / Medium / Low) given my deployment context
- Impact (High / Medium / Low)
- Specific mitigation to implement before launch
- Monitoring or detection mechanism to add

Finish with: a prioritised list of the 5 most critical threats to address before shipping.

Act as a DevOps engineer. Design a CI/CD pipeline for my project — optimised for speed, reliability, and developer experience.

Stack: [language, framework, test runner]
CI/CD platform: [e.g. GitHub Actions / GitLab CI / CircleCI / Jenkins / Bitbucket Pipelines]
Deployment target: [e.g. AWS ECS / Heroku / Vercel / Kubernetes / self-hosted VPS / serverless]
Current deployment process: [describe how you currently deploy — manual / existing pipeline]
Environments: [e.g. dev / staging / production / just prod]
Test suite: [describe — unit tests only / unit + integration / e2e with Playwright or Cypress]
Current pipeline time (if any): [e.g. 12 minutes / no pipeline yet]
Team size: [number of developers pushing code]

Please design:
1. Full pipeline configuration for [CI platform] — with actual YAML structure or equivalent
2. Stage breakdown — test / lint / build / security scan / deploy — with what runs in each
3. Parallelisation strategy — which stages can run concurrently to reduce total pipeline time
4. Caching strategy — dependencies, build artifacts, Docker layers
5. Environment promotion strategy — how code moves from commit to production safely
6. Failure handling — which failures should block deployment vs notify and continue
7. Estimated pipeline time for the designed pipeline
8. One quick win to implement first if the full pipeline is too much to build at once

Act as a senior engineering manager and Git workflow expert. Design a branching strategy and Git workflow for my team and release cadence.

Team size: [number of engineers committing code]
Release cadence: [e.g. continuous deployment (multiple times per day) / weekly releases / monthly releases / on-demand / mobile app with app store releases]
Current Git pain points: [e.g. merge conflicts / unclear release branches / hotfix process is chaotic / long-lived feature branches / unclear what's in production]
Monorepo or polyrepo: [describe]
Environments: [e.g. dev / staging / production / feature environments]
Currently using: [e.g. Gitflow / trunk-based / no formal strategy / feature branches only]

Please design:
1. Recommended branching strategy — name it, describe it, and justify it for my specific team and cadence
2. Branch naming conventions — with examples for features, fixes, releases, hotfixes
3. Merge vs rebase policy — and where each applies
4. PR / merge request rules — required reviewers, CI gates, squash vs merge commit
5. Release process — how a feature goes from branch to production, step by step
6. Hotfix process — how to fix a production bug without disrupting in-progress development
7. The one current pain point this strategy specifically solves — and how

If my current approach is already appropriate: confirm it and suggest the one improvement that would have the most impact.

Act as a technical communicator. Translate the technical concept, decision, or code below into clear language for a non-technical audience.

Audience: [e.g. the CEO / product managers / a sales team / a client / a board member / a non-technical co-founder]
What they care about: [e.g. cost / risk / timeline / customer impact / competitive advantage]
Technical thing to explain (choose one):
  A) A piece of code: [paste it]
  B) A technical decision we made: [describe it]
  C) A technical problem we're experiencing: [describe it]
  D) Why something took longer than expected: [describe what happened]

Please produce:
1. A plain English explanation (2–3 paragraphs) — no jargon, no acronyms without explanation
2. An analogy that connects this technical concept to something from everyday business life
3. What this means for the audience specifically — in terms of cost, risk, timeline, or customer impact
4. What they need to decide or know as a result of understanding this
5. One question they're likely to ask — and the answer

Optional: a one-sentence executive summary suitable for a Slack message or email subject line.

Act as a senior engineering interviewer and interview coach. Prepare me for a technical interview loop.

Role I'm interviewing for: [e.g. Senior Backend Engineer / Staff Engineer / Frontend Engineer]
Company tier: [e.g. FAANG / Series B startup / mid-size tech company / financial services firm]
Interview rounds expected: [e.g. 1x coding / 1x system design / 1x code review / 2x behavioural]
My strongest areas: [describe — e.g. strong in Python and data structures / strong in system design / strong in backend APIs]
My weakest areas: [describe honestly]
Language I prefer for coding rounds: [e.g. Python, Java, TypeScript]
Days until interview: [number]

Please provide a targeted prep plan:

1. CODING ROUND: Give me 3 algorithm problems at the right difficulty level for this role, with hints if I get stuck. After I attempt one, critique my solution for correctness, time/space complexity, and interview communication style.

2. SYSTEM DESIGN: Give me one system design prompt appropriate for this role. Ask me clarifying questions as a real interviewer would. After I describe my design, provide structured feedback covering: requirements gathering, component design, scalability, trade-offs, and failure modes.

3. BEHAVIOURAL: Give me 5 behavioural questions likely for this role and tier. After I answer one, score it on the STAR framework and identify what I should strengthen.

4. STUDY PLAN: Given my timeline, what to study in what order to maximise readiness.

Act as a developer productivity coach. Design a personal workflow system for a software engineer — optimised for deep work and minimum context-switching.

My role: [e.g. full-stack developer / backend engineer / tech lead / solo founder-engineer]
Team communication tools: [e.g. Slack / Teams / email / async Notion updates]
Expected responsiveness from my team: [e.g. real-time during business hours / async within 4 hours / I set my own schedule]
My biggest productivity killers right now: [e.g. Slack interruptions / unclear priorities / too many meetings / context-switching between projects / unclear requirements causing rework]
My current setup: [OS, editor, terminal, task management — describe your current tools]
My energy pattern: [morning person / afternoon person / slow start]
Meeting load: [how many meetings per week and when they're concentrated]

Design a developer workflow covering:
1. Daily structure — deep work blocks, communication windows, and a daily planning ritual
2. Task management system — how to capture, prioritise, and track engineering work without overhead
3. Interruption protocol — a specific policy for handling Slack/Teams during focus time
4. Context-switching recovery — what to do when you're forced off a task and need to return quickly
5. Development environment setup — 3 tooling or workflow improvements that would save the most time
6. Weekly engineering review — a 15-minute Friday practice that surfaces blockers before they become crises
7. One change to make today that will have the largest impact on deep work quality